First commit

.gitattributes

@@ -0,0 +1,2 @@
+*.png filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text

.github/workflows/main.yml

@@ -0,0 +1,20 @@
+name: Sync to Hugging Face hub
+on:
+  push:
+    branches: [master]
+
+  # to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+jobs:
+  sync-to-hub:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          lfs: true
+      - name: Push to hub
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: git push --force https://sssingh:[email protected]/spaces/sssingh/famous-landmarks-classifier-cnn master

.gitignore

@@ -0,0 +1,141 @@
+# MY CHNAGES
+*.p
+*.pt
+secrets.toml
+scratch*.ipynb
+venv*/
+.vscode*
+.vscode*/
+.examples/
+.swp
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+
+# Environments
+.env
+.venv
+env/
+venv*/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/

README.md

@@ -0,0 +1,221 @@
+---
+title: Famous Landmarks Classifier Cnn
+emoji: 🌉
+colorFrom: blue
+colorTo: red
+sdk: gradio
+sdk_version: 3.45.2
+app_file: app.py
+pinned: false
+license: mit
+---
+
+<a href="https://tv-script-generation-rnn-sssingh.streamlit.app/"  target="_blank"><img src="https://img.shields.io/badge/click_here_to_open_demo_app-orange?style=for-the-badge&logo=dependabot"/></a>
+
+
+# Landmarks Classification and Tagging using CNN
+In this project we solve a `multi-label-classification` problem by classifying/tagging a given image of a famous landmark using CNN (Convolutional Neural Network).
+
+<img src="https://github.com/sssingh/landmark-classification-tagging/blob/master/assets/title_image_sydney_opera_house.jpg?raw=true" width="800" height="300" />
+
+## Features
+⚡Multi Label Image Classification  
+⚡Custom CNN  
+⚡Transfer Learning CNN  
+⚡PyTorch
+
+## Table of Contents
+
+- [Introduction](#introduction) 
+- [Objective](#objective)
+- [Dataset](#dataset)
+- [Evaluation Criteria](#evaluation-criteria)
+- [Solution Approach](#solution-approach)
+- [How To Use](#how-to-use)
+- [License](#license)
+- [Get in touch](#get-in-touch)
+- [Credits](#credits)
+
+## Introduction
+
+<img src="https://github.com/sssingh/landmark-classification-tagging/blob/master/assets/app-screenshot.png?raw=true">
+
+Photo sharing and photo storage services like to have location data for each uploaded photo. In addition, these services can build advanced features with the location data, such as the automatic suggestion of relevant tags or automatic photo organization, which help provide a compelling user experience. However, although a photo's location can often be obtained by looking at the photo's metadata, many images uploaded to these services will not have location metadata available. This can happen when, for example, the camera capturing the picture does not have GPS or if a photo's metadata is scrubbed due to privacy concerns.
+
+If no location metadata for an image is available, one way to infer the location is to detect and classify a discernible landmark in the picture. However, given the large number of landmarks worldwide and the immense volume of images uploaded to photo-sharing services, using human judgment to classify these landmarks would not be feasible. In this project, we'll try to address this problem by building `Neural Network` (NN) based models to automatically predict the location of the image based on any landmarks depicted in the picture.
+
+## Objective
+To build NN based model that'd accept any user-supplied image as input and suggest the `top k` most relevant landmarks from '50 possible` landmarks from across the world. 
+
+1. Download the dataset 
+2. Build a CNN based neural network from scratch to classify the landmark image
+   - Here, we aim to attain a test accuracy of at least 30%. At first glance, an accuracy of 30% may appear to be very low, but it's way better than random guessing, which would provide an accuracy of just 2% since we have 50 different landmarks classes in the dataset.
+3. Build a CNN based neural network, using transfer-learning, to classify the landmark image
+    - Here, we aim to attain a test accuracy of at least 60%, which is pretty good given the complex nature of this task.
+4. Implement an inference function that will accept a file path to an image and an integer k and then predict the top k most likely landmarks this image belongs to. The print below displays the expected sample output from the predict function, indicating the top 3 (k = 3) possibilities for the image in question.
+
+<img src="https://github.com/sssingh/landmark-classification-tagging/blob/master/assets/sample_output.png?raw=true">
+
+## Dataset
+- Dataset to be downloaded from [here](https://udacity-dlnfd.s3-us-west-1.amazonaws.com/datasets/landmark_images.zip). Note that this is a mini dataset containing around 6,000 images); this dataset is a small subset of the [Original Landmark Dataset](https://github.com/cvdfoundation/google-landmark) that has over 700,000 images.
+- Unzipped dataset would have the parent folder `landmark_images` containing training data in the `train` sub-folder and testing data in the `test` sub-folder
+- There are 1250 images in the `test` sub-folder to be kept hidden and only used for model evaluation
+- There are 4996 images in the `train` sub-folder to be used for training and validation
+- Images in `test` and `train` sets are further categorized and kept in one of the 50 sub-folders representing 50 different landmarks classes (from 0 to 49)
+- Images in the dataset are of different sizes and resolution
+- Here are a few samples from the training dataset with their respective labels descriptions...
+
+<img src="https://github.com/sssingh/landmark-classification-tagging/blob/master/assets/landmark_samples.png?raw=true">
+
+## Evaluation Criteria
+
+### Loss Function  
+We will use `LogSoftmax` in the output layer of the network...
+
+<img src="https://github.com/sssingh/landmark-classification-tagging/blob/master/assets/LogSoftmax.png?raw=true">
+
+We need a suitable loss function that consumes these `log-probabilities` outputs and produces a total loss. The function that we are looking for is `NLLLoss` (Negative Log-Likelihood Loss). In practice, `NLLLoss` is nothing but a generalization of `BCELoss` (Binary Cross EntropyLoss or Log Loss) extended from binary-class to multi-class problem.
+
+<img src="https://github.com/sssingh/landmark-classification-tagging/blob/master/assets/NLLLoss.png?raw=true">
+
+<br>Note the `negative` sign in front `NLLLoss` formula hence negative in the name. The negative sign is put in front to make the average loss positive. Suppose we don't do this then since the `log` of a number less than 1 is negative. In that case, we will have a negative overall average loss. To reduce the loss, we need to `maximize` the loss function instead of `minimizing,` which is a much easier task mathematically than `maximizing.`
+
+
+### Performance Metric
+
+`accuracy` is used as the model's performance metric on the test-set 
+
+<img src="https://github.com/sssingh/landmark-classification-tagging/blob/master/assets/accuracy.png?raw=true">
+
+
+## Solution Approach
+- Once the dataset is downloaded and unzipped, we split the training set into training and validation sets in 80%:20% (3996:1000) ratio and keep images in respective `train` and `val` sub-folders.
+- `train` data is then used to build Pytorch `Dataset` object; after applying data augmentations, images are resized to 128x128.
+`mean` and `standard deviation` is computed for the train dataset, and then the dataset is `normalized` using the calculated statistics. 
+- The RGB channel histogram of the train set is shown below...
+
+<img src="https://github.com/sssingh/landmark-classification-tagging/blob/master/assets/train_hist1.png?raw=true">
+
+- The RGB channel histogram of the train set after normalization is shown below...
+
+<img src="https://github.com/sssingh/landmark-classification-tagging/blob/master/assets/train_hist2.png?raw=true">
+
+- Now, `test` and `val` Dataset objects are prepared in the same fashion where images are resized to 128x128 and then normalized.
+- The training, validation, and testing datasets are then wrapped in Pytorch `DataLoader` object so that we can iterate through them with ease. A typical `batch_size` 32 is used.
+
+### CNN from scratch
+- The neural network is implemented as a subclass of the `nn.Module` PyTorch class. The final network presented here is built incrementally with many experiments...
+    - Started with a very small CNN of just two convolutions and a linear layer with LogSoftmax output. 
+    - Tried to overfit the network on a single batch of 32 training images, but the network found it hard to overfit, which means it's not powerful enough. 
+    - Gradually increased the Conv and Linear layers to overfit the batch easily. 
+    - Then trained on complete training data, adjusted layers, and output sizes to ensure that training loss goes down. 
+    - Then, trained again with validation data to select the best network with the lowest validation loss.
+    - `ReLU` is used as an activation function, and `BatchNorm` is used after every layer except the last.
+    - Final model architecture (from scratch) is shown below...
+    
+<img src="https://github.com/sssingh/landmark-classification-tagging/blob/master/assets/scratch_network.png?raw=true">    
+
+- Network initial weights are initialized by numbers drawn from a `normal-distribution in the range... 
+
+<img src="https://github.com/sssingh/landmark-classification-tagging/blob/master/assets/sqrt_n_inputs.png?raw=true">
+
+- Network is then trained and validated for 15 epochs using the `NLLLoss` function and `Adam` optimizer with a learning rate of 0.001. We save the trained model here as `ignore.pt` (ignore because we are not using it for evaluation)
+- We keep track of training and validation losses. When plotted, we observe that the model starts to `overfit` very quickly.
+
+<img src="https://github.com/sssingh/landmark-classification-tagging/blob/master/assets/loss1.png?raw=true">
+
+- Now, we reset the Network initial weights to Pytorch default weight to check if there are any improvements 
+- Network is then again trained and validated for 15 epochs using the `NLLLoss` function and `Adam` optimizer with a learning rate of 0.001. We save the trained model here as `model_scratch.pt` (we will use this saved model for evaluation)
+- We keep track of training and validation losses. When plotted, we observe that result is almost the same as that of custom weight initialization
+
+<img src="https://github.com/sssingh/landmark-classification-tagging/blob/master/assets/loss2.png?raw=true">
+
+- The trained network (`model_scratch.pt`) is then loaded and evaluated on unseen 1,250 testing images.
+The network can achieve around `38%` accuracy, which is more than we aimed for (i.e., 30%). Furthermore, the network can classify `475` images out of the total `1250` test images.
+
+### CNN using transfer-learning
+- Here, we use transfer-learning to implement the CNN network to classify images of landmarks.  
+    - We have selected the `VGG19` pre-trained model on `ImageNet` as our base model.
+    Models pre-trained and tested on ImgaeNet can extract general features from even the datasets that may not be very similar to ImageNet. This is due to the sheer size of the ImageNet dataset (1.2 million images) and the number of classes (1000). Instead of `VGG19`, we could have chosen `ResNet` `DenseNet`  as our base network; they would have worked just fine. `VGG19` was selected here because of its simplicity of the architecture and still producing an impressive result.
+    - VGG19 models weights are frozen so that they do not change during the training. 
+    - A `custom-classifier` with `ReLU` activation, `Dropouts` in hidden layers and `LogSoftmax` in last layer is created.
+    The original classifier layer in VGG19 is replaced by a `custom-classifier` with learnable weights.
+    - Final model architecture (transfer learning) is shown below...
+    
+<img src="https://github.com/sssingh/landmark-classification-tagging/blob/master/assets/transfer_network.png?raw=true">    
+
+- Network is then trained and validated for ten epochs using the `NLLLoss` function and `Adam` optimizer with a learning rate of 0.001. Note that the optimizer has been supplied with the learnable parameters of `custom-classifier` only and not the whole model. This is because we want to optimize our custom-classifier weights only and use ImageNet learned weights for the rest of the layers.
+- We keep track of training and validation losses and plot them. 
+
+<img src="https://github.com/sssingh/landmark-classification-tagging/blob/master/assets/loss3.png?raw=true">
+
+- The trained network is saved as `model_transfer.pt` 
+
+- The trained network `model_transfer.pt` is then loaded and evaluated on unseen 1,250 testing images.
+- This time network can achieve around `63%` accuracy, which is more than what we aimed for (i.e., 60%). In addition, the network can classify `788` images out of the total `1250` test images.
+As we can see, the model built using transfer learning has outperformed the model built from scratch; hence, the second model will be used to predict unseen images.
+
+### Interface for inference 
+- For our model to be used easily, we'll implement a function `predict_landmarks` which will... 
+    - Accepts a `file-path` to an image and an integer `k`
+    The function expects the trained model `model_transfer.pt` to be present in the same folder/directory from where the function is invoked. The trained model can be downloaded from [here](https://drive.google.com/file/d/1c3aj2l3f3mkuH2a9orFDRNPdg0Vqa-wg/view?usp=sharing)
+    - It predicts and returns the **top k most likely landmarks**. 
+    - `predict_landmarks` function can be invoked from the `python` script or shell; an example is shown below...
+    
+    
+    ```python
+         >>> predicted_landmarks = predict_landmarks('images/test/09.Golden_Gate_Bridge/190f3bae17c32c37.jpg', 5)
+         >>> print(predicted_landmarks)
+         ['Golden Gate Bridge',
+          'Forth Bridge',
+          'Sydney Harbour Bridge',
+          'Brooklyn Bridge',
+          'Niagara Falls']
+    ```
+    
+- We create another higher-level function, `suggest_locations` that accepts the same parameters as that of `predict_landmarks` and internally uses the `predict_landmarks` function
+- A sample of function usage and its output is shown below
+
+``` python
+    >>> suggest_locations('assets/Eiffel-tower_night.jpg')
+```
+
+<img src="https://github.com/sssingh/landmark-classification-tagging/blob/master/assets/eiffel_tower_prediction.png?raw=true">
+    
+
+## How To Use 
+
+### Open the LIVE app
+
+App has been deployed on `Hugging Face Spaces`.  <br>   
+<a href="https://gradio.app/"  target="_blank"><img src="https://img.shields.io/badge/click_here_to_open_demo_app-orange?style=for-the-badge&logo=dependabot"/></a>   
+
+### Training and Testing using jupyter notebook
+1. Ensure the below-listed packages are installed
+    - `NumPy`
+    - `matplotlib`
+    - `torch`
+    - `torchvision`
+    - `cv2`
+    - `PIL`
+2. Download `landmark-classification-cnn-pytorch.ipynb` jupyter notebook from this repo
+3. To train the models, it's recommended to execute the notebook one cell at a time. If a GPU is available (recommended), it'll use it automatically; otherwise, it'll fall back to the CPU. 
+4. On a machine with `NVIDIA Quadro P5000` GPU with 16GB memory, it approximately takes 15-18 minutes to train and validate the `from scratch` model for 15 epochs
+5. On a machine with `NVIDIA Quadro P5000` GPU with 16GB memory, it approximately takes 15-18 minutes to train and validate the `transfer-learning` model for ten epochs
+6. A fully trained model `model_transfer.pt` can be downloaded from [here](https://drive.google.com/file/d/1c3aj2l3f3mkuH2a9orFDRNPdg0Vqa-wg/view?usp=sharing). This model then can be used directly for tagging new landmark images as described in [Interface for inference](#interface-for-inference) section. 
+
+## License
+[![MIT License](https://img.shields.io/badge/License-MIT-green.svg)](https://choosealicense.com/licenses/mit/)
+
+## Get in touch
+[![email](https://img.shields.io/badge/Gmail-D14836?style=for-the-badge&logo=gmail&logoColor=white)](mailto:[email protected])
+[![twitter](https://img.shields.io/badge/twitter-1DA1F2?style=for-the-badge&logo=twitter&logoColor=white)](https://twitter.com/@thesssingh)
+[![linkedin](https://img.shields.io/badge/linkedin-0A66C2?style=for-the-badge&logo=linkedin&logoColor=white)](https://www.linkedin.com/in/sssingh/)
+[![website](https://img.shields.io/badge/web_site-8B5BE8?style=for-the-badge&logo=ko-fi&logoColor=white)](https://sunilssingh.me)
+
+## Credits
+- Dataset used in this project is provided by [Udacity](https://www.udacity.com/)
+- Above dataset is a subset taken from the original landmarks dataset by Google [Original Landmark Dataset](https://github.com/cvdfoundation/google-landmark)
+- Title photo by [Patty Jansen On Pixabay](https://pixabay.com/users/pattyjansen-154933/)
+
+[Back To The Top](#Landmarks-Classification-and-Tagging-using-CNN)

app.py

@@ -0,0 +1,88 @@
+import gradio as gr
+import model
+from config import app_config
+
+
+def init():
+    if model != None:
+        print("Initializing App...")
+    app_config.model = model.load_model()
+
+
+def clear():
+    return None, 2, None, None, None
+
+
+def create_interface():
+    md = """
+       # Famous Landmark Classifier using CNN
+       **Choose an image containing any of the `50 possible classes` of world famous landmarks,** 
+       **choose the number of prediction required (k) and hit `Predict`, model will try to identify**
+       **the landmark in the image.** 
+       **Please note that the model is trained on a small set of only 4,000 images hence it may not** 
+       **be right all the time, but its fun to try out.**  
+       Visit the [project's repo](https://github.com/sssingh/landmark-classification-tagging)
+       """
+    with gr.Blocks(
+        title=app_config.title, theme=app_config.theme, css=app_config.css
+    ) as app:
+        with gr.Row():
+            gr.Markdown(md)
+            with gr.Accordion(
+                "Expand to see 50 classes:", open=False, elem_classes="accordion"
+            ):
+                gr.JSON(app_config.classes, elem_classes="json-box")
+        with gr.Row():
+            with gr.Column():
+                img = gr.Image(type="pil", elem_classes="image-picker")
+                k = gr.Slider(
+                    label="Number of predictions (k):",
+                    minimum=2,
+                    maximum=5,
+                    value=2,
+                    step=1,
+                    elem_classes="slider",
+                )
+                with gr.Row():
+                    submit_btn = gr.Button(
+                        "Predict",
+                        icon="assets/button-icon.png",
+                        elem_classes="submit-button",
+                    )
+                    clear_btn = gr.ClearButton(elem_classes="clear-button")
+            with gr.Column():
+                landmarks = gr.JSON(
+                    label="Predicted Landmarks:", elem_classes="json-box"
+                )
+                proba = gr.JSON(
+                    label="Predicted Probabilities:", elem_classes="json-box"
+                )
+                plot = gr.Plot(container=True, elem_classes="plot")
+        with gr.Row():
+            with gr.Accordion(
+                "Expand for examples:", open=False, elem_classes="accordion"
+            ):
+                gr.Examples(
+                    examples=[
+                        ["assets/examples/gateway-of-india.jpg", 3],
+                        ["assets/examples/grand-canyon.jpg", 2],
+                        ["assets/examples/opera-house.jpg", 3],
+                        ["assets/examples/stone-henge.jpg", 4],
+                        ["assets/examples/temple-of-zeus.jpg", 5],
+                    ],
+                    inputs=[img, k],
+                    outputs=[landmarks, proba],
+                    elem_id="examples",
+                )
+        submit_btn.click(
+            fn=model.predict, inputs=[img, k], outputs=[landmarks, proba, plot]
+        )
+        clear_btn.click(fn=clear, inputs=[], outputs=[img, k, landmarks, proba, plot])
+        img.clear(fn=clear, inputs=[], outputs=[img, k, landmarks, proba, plot])
+    return app
+
+
+if __name__ == "__main__":
+    init()
+    app = create_interface()
+    app.launch()

config.py

@@ -0,0 +1,73 @@
+import os
+from dataclasses import dataclass
+
+
+### define all app-wide configuration here,
+### should not be accessed and changed directly hence leading "__"
+@dataclass
+class __AppConfig:
+    """app-wide configurations"""
+
+    title = "Computer Vision - Landmark Classifier"
+    theme = "freddyaboulton/dracula_revamped"
+    hf_repo_id = "sssingh/landmark-classifier-pt"
+    hf_weights_file = "model_transfer.pt"
+    css = "style.css"
+    model = None
+    classes = [
+        "Haleakala_National_Park",
+        "Mount_Rainier_National_Park",
+        "Ljubljana_Castle",
+        "Dead_Sea",
+        "Wroclaws_Dwarves",
+        "London_Olympic_Stadium",
+        "Niagara_Falls",
+        "Stonehenge",
+        "Grand_Canyon",
+        "Golden_Gate_Bridge",
+        "Edinburgh_Castle",
+        "Mount_Rushmore_National_Memorial",
+        "Kantanagar_Temple",
+        "Yellowstone_National_Park",
+        "Terminal_Tower",
+        "Central_Park",
+        "Eiffel_Tower",
+        "Changdeokgung",
+        "Delicate_Arch",
+        "Vienna_City_Hall",
+        "Matterhorn",
+        "Taj_Mahal",
+        "Moscow_Raceway",
+        "Externsteine",
+        "Soreq_Cave",
+        "Banff_National_Park",
+        "Pont_du_Gard",
+        "Seattle_Japanese_Garden",
+        "Sydney_Harbour_Bridge",
+        "Petronas_Towers",
+        "Brooklyn_Bridge",
+        "Washington_Monument",
+        "Hanging_Temple",
+        "Sydney_Opera_House",
+        "Great_Barrier_Reef",
+        "Monumento_a_la_Revolucion",
+        "Badlands_National_Park",
+        "Atomium",
+        "Forth_Bridge",
+        "Gateway_of_India",
+        "Stockholm_City_Hall",
+        "Machu_Picchu",
+        "Death_Valley_National_Park",
+        "Gullfoss_Falls",
+        "Trevi_Fountain",
+        "Temple_of_Heaven",
+        "Great_Wall_of_China",
+        "Prague_Astronomical_Clock",
+        "Whitby_Abbey",
+        "Temple_of_Olympian_Zeus",
+    ]
+    mean = [0.4624, 0.4711, 0.4668]
+    std = [0.2592, 0.2600, 0.2925]
+
+
+app_config = __AppConfig()

model.py

@@ -0,0 +1,89 @@
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn as nn
+import torchvision.models as models
+import torchvision.transforms as transforms
+import plotly.express as px
+from huggingface_hub import hf_hub_download
+from config import app_config
+
+### Reproducibility
+np.random.seed(42)
+torch.manual_seed(42)
+torch.cuda.manual_seed_all(42)
+torch.backends.cudnn.deterministic = True
+torch.backends.cudnn.benchmark = False
+
+
+def load_model():
+    ### useful variable that tells us whether we should use the GPU
+    use_cuda = torch.cuda.is_available()
+
+    ### Our model is based on VGG19 with classifier head replaced with custom layers
+    ### Load the pretrained VGG19 model
+    model_transfer = models.vgg19(weights="DEFAULT")
+
+    ### Instantiate a custom classifier for our 50 classes and use it with pretrained model
+    clf = nn.Sequential(
+        nn.Linear(in_features=25088, out_features=4096),
+        nn.ReLU(inplace=True),
+        nn.Dropout(p=0.5),
+        nn.Linear(in_features=4096, out_features=1024),
+        nn.ReLU(inplace=True),
+        nn.Dropout(p=0.5),
+        nn.Linear(in_features=1024, out_features=50),
+        nn.LogSoftmax(dim=1),
+    )
+    model_transfer.classifier = clf
+    if use_cuda:
+        model_transfer = model_transfer.cuda()
+
+    ### Download the saved fine-tuned model weights and load it
+    model_weights = hf_hub_download(
+        repo_id=app_config.hf_repo_id, filename=app_config.hf_weights_file
+    )
+    if not use_cuda:
+        state_dict = torch.load(model_weights, map_location=torch.device("cpu"))
+    else:
+        state_dict = torch.load(model_weights)
+    model_transfer.load_state_dict(state_dict)
+
+    return model_transfer
+
+
+def predict(img, k):
+    model = app_config.model
+    classes = app_config.classes
+    mean = torch.tensor(app_config.mean)
+    std = torch.tensor(app_config.std)
+
+    # Prepare image for model prediction
+    transform = transforms.Compose(
+        [
+            transforms.Resize((128, 128)),
+            transforms.ToTensor(),
+            transforms.Normalize(mean, std),
+        ]
+    )
+    img = transform(img).unsqueeze(dim=0)
+
+    # Predict
+    model.eval()
+    use_cuda = torch.cuda.is_available()
+    if use_cuda:
+        img = img.cuda()
+    pred = model(img)  # LogSoftmax output
+    pred_proba = torch.exp(pred)  # Prediction probabilities
+    proba, labels = torch.topk(pred_proba, k)
+    labels = labels.cpu().numpy().squeeze()
+    landmarks = [classes[i] for i in labels]
+    # Cleanup the labels
+    landmarks = [" ".join(label.split("_")) for label in landmarks]
+    proba = proba.squeeze().tolist()
+    fig = px.bar(
+        pd.DataFrame(data={"Landmarks": landmarks, "Probabilities": proba}),
+        y="Probabilities",
+        x="Landmarks",
+    )
+    return landmarks, proba, fig