gradio classifier

.gitignore

@@ -0,0 +1,2 @@
+.venv
+__pycache__

app.py

@@ -0,0 +1,67 @@
+import os
+
+import torch
+from PIL import Image
+import torchvision.transforms as T
+
+import gradio as gr
+
+
+# Current path
+current_path = os.getcwd()
+
+# Define the model path
+model_path = os.path.join(current_path, "ml", "models", "model.pt")
+
+# Determine the device to use (GPU if available, otherwise CPU)
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# Load model
+model = torch.jit.load(model_path)
+model.eval()  # Set to evaluation mode
+
+# Depending on the device, load the model
+model = model.to(device)
+
+
+# Define the transformation
+transform = T.Compose(
+    [
+        T.Resize(224),
+        T.CenterCrop(224),
+        T.ToTensor(),  # Converts to [C, H, W] with values in [0, 1]
+        T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),  # ImageNet mean  # ImageNet std
+    ]
+)
+
+
+def cls_helper(label):
+    if label == 0:
+        return "Clear sky"
+    elif label == 1:
+        return "Cloudy"
+    elif label == 2:
+        return "Haze"
+    else:
+        return "Unknown"
+
+
+def predict(image: Image.Image):
+    img = image.convert("RGB")
+    tensor = transform(img).unsqueeze(0)  # [1, 3, 224, 224]
+
+    with torch.no_grad():
+        output = model(tensor)
+        pred_idx = torch.argmax(output, dim=1).item()
+        pred_class = cls_helper(pred_idx)
+
+    return pred_class
+
+
+interface = gr.Interface(
+    fn=predict,
+    inputs=gr.Image(type="pil"),
+    outputs=["text"],
+)
+
+interface.launch()

notebooks/classification_inference.ipynb

@@ -0,0 +1,173 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "875564f0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "import torch\n",
+    "from PIL import Image\n",
+    "import torchvision.transforms as T"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "33891e0b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Current path\n",
+    "current_path = os.getcwd()\n",
+    "\n",
+    "# Define the model path\n",
+    "model_path = os.path.join(current_path, '..', 'ml', 'models', 'model.pt')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "0085c439",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Determine the device to use (GPU if available, otherwise CPU)\n",
+    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "\n",
+    "# Load model\n",
+    "model = torch.jit.load(model_path)\n",
+    "model.eval()  # Set to evaluation mode\n",
+    "\n",
+    "# Depending on the device, load the model\n",
+    "model = model.to(device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "e3620e37",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define data path\n",
+    "data_path = os.path.join(current_path, '..', 'ml', 'data')\n",
+    "\n",
+    "# Define the image path\n",
+    "img_path = os.path.join(data_path, \"train_11716.jpg\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "e8375f5d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load and preprocess the image\n",
+    "image = Image.open(img_path).convert(\"RGB\")\n",
+    "\n",
+    "# Define the transformation\n",
+    "transform = T.Compose(\n",
+    "    [\n",
+    "        T.Resize(224),\n",
+    "        T.CenterCrop(224),\n",
+    "        T.ToTensor(),  # Converts to [C, H, W] with values in [0, 1]\n",
+    "        T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),  # ImageNet mean  # ImageNet std\n",
+    "    ]\n",
+    ")\n",
+    "\n",
+    "# Prepare the input tensor\n",
+    "input_tensor = transform(image).unsqueeze(0)  # Add batch dim → [1, 3, 224, 224]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "0b3a589f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Predicted class index: 1\n"
+     ]
+    }
+   ],
+   "source": [
+    "with torch.no_grad():\n",
+    "    output = model(input_tensor)\n",
+    "    pred = torch.argmax(output, dim=1)\n",
+    "\n",
+    "pred_class = pred.item()\n",
+    "\n",
+    "print(f\"Predicted class index: {pred.item()}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "9d676ebf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def show_image(image: Image.Image, pred_cls: int) -> None:\n",
+    "    \"\"\"Display an image.\"\"\"\n",
+    "    if pred_cls == 0:\n",
+    "        title = \"Clear sky\"\n",
+    "    elif pred_cls == 1:\n",
+    "        title = \"Cloudy\"\n",
+    "    elif pred_cls == 2:\n",
+    "        title = \"Haze\"\n",
+    "    else:\n",
+    "        title = \"Unknown\"\n",
+    "\n",
+    "    image.show(title=title)\n",
+    "    print(title)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "d0935f27",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Cloudy\n"
+     ]
+    }
+   ],
+   "source": [
+    "show_image(image, pred_class)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

requirements.txt

@@ -0,0 +1,2 @@
+fastai
+gradio