minor fixes

README.md

@@ -1,8 +1,8 @@
 ---
 title: Cifar10 Classification
-emoji: 👀
-colorFrom: yellow
-colorTo: yellow
+emoji: 🤗
+colorFrom: red
+colorTo: pink
 sdk: streamlit
 sdk_version: 1.33.0
 app_file: app.py
@@ -11,3 +11,31 @@ license: apache-2.0
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+
+### To access the app, follow these steps:
+
+
+Step 1: Access the app directly on the link (This does not use the FastAPI endpoints):
+[https://huggingface.co/spaces/TrishanuDas/cifar10_classification](https://huggingface.co/spaces/TrishanuDas/cifar10_classification)
+
+Step 2: Use the Streamlit app via the FastAPI endpoint. 
+- Run the FastAPI server on any instance using the following command:
+    ```
+    uvicorn api_endpoint:app --reload --host <host_name>
+    ```
+- Change the HOST variable on the `app_with_fastapi.py` file.
+- Execute the app_with_fastapi.py file using the following command:
+    ```
+    streamlit run app_with_fastapi.py
+    ```
+
+### Files
+
+The following files are present in this repository:
+
+- `app.py`: The main Streamlit app file to run directly.
+- `requirements.txt`: The list of Python dependencies required by the app.
+- `model.py`: Contains the code for loading and using the pre-trained model.
+- `app_endpoint.py`: Contains api_endpoint for the prediction.
+- `app_with_fastapi.py`: Contains the code for the Streamlit app with FastAPI endpoint.

api_endpoint.py

@@ -0,0 +1,36 @@
+import os
+from fastapi import FastAPI, HTTPException, Depends
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi import File, UploadFile
+from PIL import Image
+import model
+
+app = FastAPI()
+# Add the CORSMiddleware to enable Cross-Origin Resource Sharing
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Allow all origins
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.post("/upload_image_for_inference") # This is the endpoint for updating the bot's Knowledge Base
+async def upload_image(file: UploadFile = File(...)):
+    # Save the uploaded image to a file
+    with open('image.jpg', 'wb') as image:
+        contents = await file.read()  # Read the content of the uploaded file
+        image.write(contents)  # Write the content to the image file
+
+    # Process the image
+    image_pil = Image.open('image.jpg')  # Open the image using PIL
+
+    # Predict the image class
+    predicted_class = model.predict(image_pil)
+    # print(f"Predicted label: {predicted_class}")
+
+    image_pil.close()
+    # Delete the image file after processing
+    os.remove("image.jpg")
+
+    return {'predicted_class': predicted_class}

app.py

@@ -0,0 +1,25 @@
+from PIL import Image
+import streamlit as st
+import requests
+import model
+
+# Streamlit layout
+st.title("CIFAR10 Prediction")
+
+uploaded_file = st.file_uploader("Choose an image...", type=["jpg", "jpeg", "png"])
+
+if uploaded_file is not None:
+    # Convert uploaded file to PIL image
+    image = Image.open(uploaded_file)
+    
+    # Display the uploaded image
+    with st.container(height=300):
+        st.image(image, caption='Uploaded Image', use_column_width=True)
+
+    if st.button('Predict'):
+        predicted_class = model.predict(image)
+
+        if predicted_class is not None:
+            st.header(f"Predicted Label: {predicted_class}")
+        else:
+            st.error("Error processing image. Please try again!")

app_with_fastapi.py

@@ -0,0 +1,25 @@
+import requests
+import streamlit as st
+
+# Streamlit layout
+st.title("CIFAR10 Prediction")
+
+HOST = "http://localhost:8000"
+
+uploaded_file = st.file_uploader("Choose an image...", type=["jpg", "jpeg", "png"])
+
+if uploaded_file is not None:
+    with st.container(height=300):
+        st.image(uploaded_file, caption='Uploaded Image', use_column_width=True)
+
+    if st.button('Predict'):
+        # Send image to FastAPI endpoint
+        files = {'file': uploaded_file}
+        response = requests.post(f"{HOST}/upload_image_for_inference", files=files)
+
+        if response.status_code == 200:
+            result = response.json()
+            st.header(f"Predicted Label: {result['predicted_class']}")
+        else:
+            st.error("Error processing image. Please try again.")
+

check.ipynb

@@ -0,0 +1,205 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 73,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch    \n",
+    "import pickle\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import time"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 75,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "IMAGE_SIZE = 224 # We need to resize the images given resnet takes input of image size >= 224\n",
+    "\n",
+    "mean, std = [0.4914, 0.4822, 0.4465], [0.247, 0.243, 0.261]\n",
+    "classes = ('airplane', \n",
+    "           'automobile', \n",
+    "           'bird',\n",
+    "           'cat',\n",
+    "           'deer',\n",
+    "           'dog', \n",
+    "           'frog', \n",
+    "           'horse', \n",
+    "           'ship',\n",
+    "           'truck')\n",
+    "\n",
+    "if torch.cuda.is_available():\n",
+    "    torch.set_default_device('cuda')\n",
+    "\n",
+    "def show_data(img):\n",
+    "    try:\n",
+    "        plt.imshow(img[0])\n",
+    "    except Exception as e:\n",
+    "        print(e)\n",
+    "    print(img[0].shape, img[0].permute(1,2,0).shape)\n",
+    "    plt.imshow(img[0].permute(1,2,0))\n",
+    "    plt.title('y = '+ str(img[1]))\n",
+    "    plt.show()\n",
+    "    \n",
+    "# We need to convert the images to numpy arrays as tensors are not compatible with matplotlib.\n",
+    "def im_convert(tensor):\n",
+    "    #Lets\n",
+    "    img = tensor.cpu().clone().detach().numpy() #\n",
+    "    img = img.transpose(1, 2, 0)\n",
+    "    img = img * np.array(tuple(mean)) + np.array(tuple(std))\n",
+    "    img = img.clip(0, 1) # Clipping the size to print the images later\n",
+    "    return img"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def unpickle(file):\n",
+    "    with open(file, 'rb') as fo:\n",
+    "        data_dict = pickle.load(fo, encoding='bytes')\n",
+    "        \n",
+    "        # Decode keys from bytes to strings\n",
+    "        decoded_dict = {}\n",
+    "        for key, value in data_dict.items():\n",
+    "            decoded_key = key.decode('utf-8')  # Assuming UTF-8 encoding\n",
+    "            decoded_dict[decoded_key] = value\n",
+    "        \n",
+    "    return decoded_dict\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 76,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "decoded_dict = unpickle('./test_batch')\n",
+    "decoded_dict\n",
+    "data = torch.tensor(decoded_dict['data']).reshape([10000,3,32,32])\n",
+    "dataset = {\"image\":data, \"target\": torch.tensor(decoded_dict[\"labels\"])}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 77,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['batch_label', 'labels', 'data', 'filenames'])"
+      ]
+     },
+     "execution_count": 77,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "decoded_dict.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 78,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "idx = 0\n",
+    "image = dataset['image'][idx]\n",
+    "label = dataset[\"target\"][idx].item()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 79,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'cat'"
+      ]
+     },
+     "execution_count": 79,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "classes[label]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 82,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "cat\n",
+      "Time taken: 0.013 s\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Load model directly\n",
+    "from transformers import AutoImageProcessor, AutoModelForImageClassification\n",
+    "\n",
+    "processor = AutoImageProcessor.from_pretrained(\"heyitskim1912/AML_A2_Q4\")\n",
+    "model = AutoModelForImageClassification.from_pretrained(\"heyitskim1912/AML_A2_Q4\")\n",
+    "\n",
+    "inputs = processor(image, return_tensors=\"pt\")\n",
+    "\n",
+    "start_time = time.time()\n",
+    "with torch.no_grad():\n",
+    "    logits = model(**inputs).logits\n",
+    "\n",
+    "# model predicts one of the 1000 ImageNet classes\n",
+    "predicted_label = logits.argmax(-1).item()\n",
+    "print(model.config.id2label[predicted_label])\n",
+    "end_time = time.time()\n",
+    "time_taken = round(end_time - start_time, 3)\n",
+    "print(f\"Time taken: {time_taken} s\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "PyTorchenv",
+   "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.10.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

model.py

@@ -0,0 +1,16 @@
+from transformers import AutoImageProcessor, AutoModelForImageClassification
+import torch
+
+processor = AutoImageProcessor.from_pretrained("heyitskim1912/AML_A2_Q4")
+model = AutoModelForImageClassification.from_pretrained("heyitskim1912/AML_A2_Q4")
+
+def predict(image_pil):
+    inputs = processor(image_pil, return_tensors="pt")
+
+    with torch.no_grad():
+        logits = model(**inputs).logits
+
+    # Get predicted label
+    predicted_label = logits.argmax(-1).item()
+    predicted_class = model.config.id2label[predicted_label]
+    return predicted_class

requirements.txt

@@ -0,0 +1,8 @@
+transformers
+pillow
+streamlit
+requests
+fastapi
+torch
+uvicorn
+gunicorn