Transferred from from PyTorch -> Tensorflow

Dockerfile

@@ -1,5 +1,5 @@
 # Get the image of python
-FROM python:3.9
+FROM python:3.7.9
 
 # Copy all the files from local-dir to machine dir
 COPY . .

backend.py

@@ -1,90 +1,63 @@
+import os
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
 
-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
+from model import get_model
+
+app = FastAPI()
+
+IMAGE_WIDTH = 224
+IMAGE_HEIGHT = 224
 
-transform = v2.Compose([
-    v2.Resize((MODEL_IMAGE_HEIGHT, MODEL_IMAGE_WIDTH)),
-    v2.ToTensor()
-])
+MODEL_WEIGHT_PATH = 'vgg_face_weights2.h5'
+model = get_model(
+		image_shape = (IMAGE_WIDTH, IMAGE_HEIGHT, 3),
+		num_classes = 6,
+		model_weights = MODEL_WEIGHT_PATH
+	)
+print(model.summary())
+print("Model Loaded Successfully")
 
 ######### Utilities #########
 def load_image(image_data):
-    image = Image.open(BytesIO(image_data))
-    return image
+	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 = T.jit.load('model_script.pt')
+	image = image.resize((IMAGE_WIDTH, IMAGE_HEIGHT))
+
+	image = np.array(image)
+	image = np.expand_dims(image, axis=0)
+
+	return image
+
+def get_prediction(image):
+	probs = model.predict(image)[0]
+	label = np.argmax(probs)
+
+	return {
+		'pred_probs': pred_probs.tolist(),
+		'label': int(label)
+	}
 
 @app.get("/")
 def foo():
-    return {
-        "status": "Face Expression Classifier"
-    }
+	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
-        }
-    }
+async def predict(face_image: UploadFile = File(...)):
+	image = load_image(await face_image.read())
+
+	image = preprocess(image)
+	result = get_prediction(image)
+
+	return {
+		"result": json.dumps(result)
+	}

model.py

@@ -1,55 +1,39 @@
-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)
-
+import os
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
+
+import keras
+from keras.layers import Input, Dropout, Dense
+from keras.models import Model
+from keras_vggface.vggface import VGGFace
+
+def get_model(image_shape, num_classes, model_weights, unfreeze_layers=-3, drop_rate=0.5):
+    
+    input_layer = Input(shape=image_shape)
+    vgg_base_model = VGGFace(include_top = False, input_shape = image_shape, pooling='avg')
+    
+    # Freeze all the layers till unfreeze layers
+    for layer in vgg_base_model.layers[:unfreeze_layers]:
+        layer.trainable = False
+    
+    for layer in vgg_base_model.layers[unfreeze_layers:]:
+        layer.trainable = True
+    
+    x = vgg_base_model(input_layer)
+    
+    x = Dropout(drop_rate)(x)
+    output = Dense(num_classes, activation='softmax')(x)
+    
+    model = Model(inputs=[input_layer], outputs=[output], name="Expression_Classifier")
+    model.load_weights(model_weights)
     return model
 
+
 if __name__ == "__main__":
-    model = get_model(
-        6,
-        [-1],
-        0.1
-    )
+	model_path = "vgg_face_weights2.h5"
+	model = get_model(
+			image_shape = (224, 224, 3),
+			num_classes = 6,
+			model_weights = model_path
+		)
+
+	print(model.summary())

requirements.txt

@@ -1,8 +1,7 @@
-streamlit
-fastapi
-uvicorn[standard]
-torch==2.3.1
-torchaudio==2.3.1
-torchvision==0.18.1
-pillow
-numpy
+keras==2.2.4
+keras_vggface==0.6
+tensorflow==1.14.0
+protobuf==3.20.1
+h5py==2.10.0
+fastapi==0.103.2
+uvicorn[standard]