Deployed backend

Dockerfile

@@ -0,0 +1,14 @@
+# Get the image of python
+FROM python:3.9
+
+# Copy all the files from local-dir to machine dir
+COPY . .
+
+# Set the current directory as working dir
+WORKDIR /
+
+# Install the requirements
+RUN pip install --no-cache-dir -r ./requirements.txt
+
+# Launch the server
+CMD ["uvicorn", "backend:app", "--host", "0.0.0.0", "--port", "7860"]

backend.py

@@ -0,0 +1,91 @@
+import os
+
+from model import get_model
+
+import torch as T
+import torch.nn.functional as F
+from torchvision.transforms import v2
+from fastapi import FastAPI, UploadFile, File
+
+
+import json
+import numpy as np
+from PIL import Image
+from io import BytesIO
+
+MODEL_IMAGE_WIDTH = 224
+MODEL_IMAGE_HEIGHT = 224
+
+transform = v2.Compose([
+    v2.Resize((MODEL_IMAGE_HEIGHT, MODEL_IMAGE_WIDTH)),
+    v2.ToTensor()
+])
+
+######### Utilities #########
+def load_image(image_data):
+    image = Image.open(BytesIO(image_data))
+    return image
+
+def preprocess(image):
+    image = image.resize((MODEL_IMAGE_WIDTH, MODEL_IMAGE_HEIGHT))
+    image = transform(image)
+    
+    return image
+
+def get_prediction(image, model):
+    image = T.from_numpy(np.array(image))
+    print("image shape: ", image.shape)
+    
+    image = image.unsqueeze(0)
+    # image = image.permute(0, 3, 1, 2)
+    print("batch size shape: ", image.shape)
+
+    pred_probs = model(image)
+    pred_probs = F.softmax(pred_probs, dim=-1)
+    pred_probs = pred_probs.detach().numpy()[0]
+    label = np.argmax(pred_probs, axis=-1)
+
+    return {
+        'pred_probs': pred_probs.tolist(),
+        'label': int(label)
+    }
+
+####################################
+
+############## Backend #############
+app = FastAPI()
+model = get_model(6, [-1], 0.1)
+
+@app.get("/")
+def foo():
+    return {
+        "status": "Face Expression Classifier"
+    }
+
+@app.post("/")
+def bar():
+    return {
+        "status": "Response"
+    }
+
+@app.post("/get_prediction")
+async def predict(face_img: UploadFile = File(...)):
+    image = load_image(await face_img.read())
+
+    image = preprocess(image)
+
+    result = get_prediction(image, model)
+    print("Model Predicted: \n", result)
+
+    return {
+        'result': json.dumps(result)
+    }
+
+@app.post("/test")
+def test():
+    return {
+        'result': {
+            'pred_probs': [0.5, 0.2, 0.1],
+            'label': 0
+        }
+    }

model.py

@@ -0,0 +1,55 @@
+import torch as T
+from torch import nn, optim
+import torch.nn.functional as F
+import torchvision.models as models
+
+from typing import Union, List
+
+def get_model(num_classes:int, unfreeze_layers:Union[None, List[int]] = None, drop_rate: Union[None, float] = None):
+
+    model = models.efficientnet_b7(weights=models.EfficientNet_B7_Weights.DEFAULT)
+
+ 
+
+    for param in model.parameters():
+
+        param.requires_grad = False
+
+ 
+
+    if unfreeze_layers is not None and len(unfreeze_layers) > 0:
+
+        # Now unfreeze the layers in the unfreeze layer/ list
+
+        for layer_num in unfreeze_layers:
+
+            for name, child in model.features[layer_num].named_modules():
+
+                if not isinstance(child, nn.BatchNorm2d) and \
+                    not isinstance(child, nn.Sequential) and \
+                    not hasattr(child, 'block'):
+
+                    for param in child.parameters():
+
+                        param.requires_grad = True
+
+ 
+
+    if drop_rate is not None:
+
+        model.classifier[0] = nn.Dropout(drop_rate)
+
+ 
+
+    # Chagne the classifier head as per our need
+
+    model.classifier[1] = nn.Linear(2560, num_classes)
+
+    return model
+
+if __name__ == "__main__":
+    model = get_model(
+        6,
+        [-1],
+        0.1
+    )

requirements.txt

@@ -0,0 +1,6 @@
+streamlit
+fastapi
+uvicorn[standard]
+tensorflow==2.15.0
+pillow
+numpy