updated files

.gitignore

@@ -1 +0,0 @@
-**/__pycache__/**

Dockerfile

@@ -24,6 +24,6 @@ USER myuser
 
 COPY --chown=myuser app app
 
-EXPOSE 7860
+EXPOSE 8001
 
 CMD ["python", "app/main.py"]

README.md

@@ -1,10 +0,0 @@
----
-title: Hackathon 4
-emoji: 🐢
-colorFrom: indigo
-colorTo: indigo
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app/Hackathon_setup/classes.txt

@@ -1,17 +0,0 @@
-Angelina Jolie
-Brad Pitt
-Denzel Washington
-Hugh Jackman
-Jennifer Lawrence
-Johnny Depp
-Kate Winslet
-Leonardo DiCaprio
-Megan Fox
-Natalie Portman
-Nicole Kidman
-Robert Downey Jr
-Sandra Bullock
-Scarlett Johansson
-Tom Cruise
-Tom Hanks
-Will Smith

app/Hackathon_setup/exp_recognition.py

@@ -1,10 +1,14 @@
 import numpy as np
 import cv2
+from matplotlib import pyplot as plt
 import torch
+# In the below line,remove '.' while working on your local system.However Make sure that '.' is present before face_recognition_model while uploading to the server, Do not remove it.
 from .exp_recognition_model import *
 from PIL import Image
+import base64
+import io
 import os
-from functools import lru_cache
+## Add more imports if required
 
 #############################################################################################################################
 #   Caution: Don't change any of the filenames, function names and definitions                                              #
@@ -20,8 +24,10 @@ current_path = os.path.dirname(os.path.abspath(__file__))
 #3) If no face is detected,then it returns zero(0).
 
 def detected_face(image):
+    eye_haar = current_path + '/haarcascade_eye.xml'
     face_haar = current_path + '/haarcascade_frontalface_default.xml'
     face_cascade = cv2.CascadeClassifier(face_haar)
+    eye_cascade = cv2.CascadeClassifier(eye_haar)
     gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
     faces = face_cascade.detectMultiScale(gray, 1.3, 5)
     face_areas=[]
@@ -34,68 +40,6 @@ def detected_face(image):
         required_image = images[np.argmax(face_areas)]
         required_image = Image.fromarray(required_image)
     return required_image
-
-
-def _load_state_dict(model, path, device):
-    checkpoint = torch.load(path, map_location=device)
-    if isinstance(checkpoint, dict):
-        state_dict = checkpoint.get("net_dict") or checkpoint.get("state_dict") or checkpoint
-    else:
-        state_dict = checkpoint
-    model.load_state_dict(state_dict, strict=False)
-    return model
-
-
-@lru_cache(maxsize=1)
-def _load_expression_model():
-    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-    model_paths = [
-        "expression_model.t7",
-        "expression_model.pth",
-        "exp_recognition_net.t7",
-        "exp_recognition_model.t7",
-    ]
-    for filename in model_paths:
-        path = os.path.join(current_path, filename)
-        if os.path.exists(path):
-            model = facExpRec().to(device)
-            _load_state_dict(model, path, device)
-            model.eval()
-            return model, device
-    return None, device
-
-
-def _prepare_face(img):
-    face = detected_face(img)
-    if face == 0:
-        face = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2GRAY))
-    return face
-
-
-def _heuristic_expression(face):
-    gray = np.asarray(face.resize((48, 48)).convert("L"), dtype=np.float32) / 255.0
-    upper = gray[:24, :]
-    lower = gray[24:, :]
-    mouth = gray[30:43, 12:36]
-    eye_band = gray[10:22, 8:40]
-    brightness = float(gray.mean())
-    contrast = float(gray.std())
-    mouth_darkness = float(1.0 - mouth.mean())
-    eye_contrast = float(eye_band.std())
-    lower_edges = float(cv2.Laplacian(lower, cv2.CV_32F).var())
-    upper_edges = float(cv2.Laplacian(upper, cv2.CV_32F).var())
-
-    if mouth_darkness > 0.52 and lower_edges > upper_edges * 1.15:
-        return "HAPPINESS"
-    if eye_contrast > 0.22 and mouth_darkness > 0.42:
-        return "SURPRISE"
-    if brightness < 0.34 and contrast > 0.24:
-        return "ANGER"
-    if contrast < 0.13:
-        return "NEUTRAL"
-    if lower_edges < upper_edges * 0.72:
-        return "SADNESS"
-    return "NEUTRAL"
     
 
 #1) Images captured from mobile is passed as parameter to the below function in the API call, It returns the Expression detected by your network.
@@ -105,13 +49,23 @@ def _heuristic_expression(face):
 #5) For loading your model use the current_path+'your model file name', anyhow detailed example is given in comments to the function 
 ##Caution: Don't change the definition or function name; for loading the model use the current_path for path example is given in comments to the function
 def get_expression(img):
-    face = _prepare_face(img)
-    model, device = _load_expression_model()
-    if model is None:
-        return _heuristic_expression(face)
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    
+    ##########################################################################################
+    ##Example for loading a model using weight state dictionary:                            ##
+    ## face_det_net = facExpRec() #Example Network                                          ##
+    ## model = torch.load(current_path + '/exp_recognition_net.t7', map_location=device)    ##
+    ## face_det_net.load_state_dict(model['net_dict'])                                      ##
+    ##                                                                                      ##
+    ##current_path + '/<network_definition>' is path of the saved model if present in       ##
+    ##the same path as this file, we recommend to put in the same directory                 ##
+    ##########################################################################################
+    ##########################################################################################
+
+    face = detected_face(img)
+    if face==0:
+        face = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2GRAY))
+    
+    # YOUR CODE HERE, return expression using your model
 
-    with torch.no_grad():
-        tensor = trnscm(face).unsqueeze(0).to(device)
-        logits = model(tensor)
-        class_index = int(torch.argmax(logits, dim=1).item())
-    return classes.get(class_index, "UNKNOWN")
+    return "YET TO BE CODED"

app/Hackathon_setup/exp_recognition_model.py

@@ -1,7 +1,8 @@
 import torch
+import torchvision
 import torch.nn as nn
-import torch.nn.functional as F
 from torchvision import transforms
+## Add more imports if required
 
 ####################################################################################################################
 # Define your model and transform and all necessary helper functions here                                          #
@@ -11,37 +12,20 @@ from torchvision import transforms
 # Definition of classes as dictionary
 classes = {0: 'ANGER', 1: 'DISGUST', 2: 'FEAR', 3: 'HAPPINESS', 4: 'NEUTRAL', 5: 'SADNESS', 6: 'SURPRISE'}
 
-class facExpRec(nn.Module):
+# Example Network
+class facExpRec(torch.nn.Module):
     def __init__(self):
-        super().__init__()
-        self.features = nn.Sequential(
-            nn.Conv2d(1, 32, kernel_size=3, padding=1),
-            nn.BatchNorm2d(32),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(2),
-            nn.Conv2d(32, 64, kernel_size=3, padding=1),
-            nn.BatchNorm2d(64),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(2),
-            nn.Conv2d(64, 128, kernel_size=3, padding=1),
-            nn.BatchNorm2d(128),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(2),
-        )
-        self.classifier = nn.Sequential(
-            nn.Flatten(),
-            nn.Linear(128 * 6 * 6, 256),
-            nn.ReLU(inplace=True),
-            nn.Dropout(0.35),
-            nn.Linear(256, len(classes)),
-        )
+        pass   # remove 'pass' once you have written your code
+        #YOUR CODE HERE
         
     def forward(self, x):
-        x = self.features(x)
-        return self.classifier(x)
+        pass   # remove 'pass' once you have written your code
+        #YOUR CODE HERE
         
 # Sample Helper function
 def rgb2gray(image):
     return image.convert('L')
     
-trnscm = transforms.Compose([rgb2gray, transforms.Resize((48, 48)), transforms.ToTensor()])
+# Sample Transformation function
+#YOUR CODE HERE for changing the Transformation values.
+trnscm = transforms.Compose([rgb2gray, transforms.Resize((48,48)), transforms.ToTensor()])

app/Hackathon_setup/face_classifier.joblib

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:63543e655da6a76c150f1faa489c631a2aef9dd1865670c2c337378570ea44a7
-size 2278873

app/Hackathon_setup/face_recognition.py

@@ -1,11 +1,18 @@
 import numpy as np
 import cv2
+from matplotlib import pyplot as plt
 import torch
+# In the below line,remove '.' while working on your local system. However Make sure that '.' is present before face_recognition_model while uploading to the server, Do not remove it.
 from .face_recognition_model import *
 from PIL import Image
+import base64
+import io
 import os
 import joblib
-from functools import lru_cache
+import pickle
+# Add more imports if required
+
+
 
 ###########################################################################################################################################
 #         Caution: Don't change any of the filenames, function names and definitions                                                      #
@@ -20,8 +27,10 @@ current_path = os.path.dirname(os.path.abspath(__file__))
 #3) If no face is detected,then it returns zero(0).
 
 def detected_face(image):
+    eye_haar = current_path + '/haarcascade_eye.xml'
     face_haar = current_path + '/haarcascade_frontalface_default.xml'
     face_cascade = cv2.CascadeClassifier(face_haar)
+    eye_cascade = cv2.CascadeClassifier(eye_haar)
     gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
     faces = face_cascade.detectMultiScale(gray, 1.3, 5)
     face_areas=[]
@@ -36,85 +45,6 @@ def detected_face(image):
     return required_image
 
 
-def _load_state_dict(model, path, device):
-    checkpoint = torch.load(path, map_location=device)
-    if isinstance(checkpoint, dict):
-        state_dict = checkpoint.get("net_dict") or checkpoint.get("state_dict") or checkpoint
-    else:
-        state_dict = checkpoint
-    model.load_state_dict(state_dict, strict=False)
-    return model
-
-
-@lru_cache(maxsize=1)
-def _load_siamese():
-    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-    model_paths = [
-        "siamese_model.t7",
-        "siamese_model.pth",
-        "face_similarity_model.t7",
-        "face_recognition_model.t7",
-    ]
-    for filename in model_paths:
-        path = os.path.join(current_path, filename)
-        if os.path.exists(path):
-            model = Siamese().to(device)
-            _load_state_dict(model, path, device)
-            model.eval()
-            return model, device
-    return None, device
-
-
-@lru_cache(maxsize=1)
-def _load_classifier():
-    classifier_paths = [
-        "face_classifier.joblib",
-        "face_classifier.pkl",
-        "decision_tree_model.sav",
-        "classifier.sav",
-    ]
-    for filename in classifier_paths:
-        path = os.path.join(current_path, filename)
-        print("path :", path)
-        if os.path.exists(path):
-            return joblib.load(path)
-    return None
-
-
-def _prepare_face(image):
-    face = detected_face(image)
-    if face == 0:
-        face = Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2GRAY))
-    return face
-
-
-def _handcrafted_embedding(face):
-    gray = np.asarray(face.resize((100, 100)).convert("L"), dtype=np.float32) / 255.0
-    resized = cv2.resize(gray, (32, 32)).flatten()
-    hist = cv2.calcHist([(gray * 255).astype(np.uint8)], [0], None, [32], [0, 256]).flatten()
-    hist = hist / max(float(hist.sum()), 1.0)
-    gx = cv2.Sobel(gray, cv2.CV_32F, 1, 0, ksize=3)
-    gy = cv2.Sobel(gray, cv2.CV_32F, 0, 1, ksize=3)
-    mag, ang = cv2.cartToPolar(gx, gy, angleInDegrees=True)
-    grad_hist = np.histogram(ang, bins=16, range=(0, 360), weights=mag)[0].astype(np.float32)
-    grad_hist = grad_hist / max(float(grad_hist.sum()), 1.0)
-    embedding = np.concatenate([resized, hist, grad_hist]).astype(np.float32)
-    norm = np.linalg.norm(embedding)
-    return embedding / norm if norm else embedding
-
-
-def _embedding(face):
-    model, device = _load_siamese()
-    if model is None:
-        return _handcrafted_embedding(face)
-
-    with torch.no_grad():
-        tensor = trnscm(face).unsqueeze(0).to(device)
-        output = model(tensor).detach().cpu().numpy().reshape(-1)
-    norm = np.linalg.norm(output)
-    return output / norm if norm else output
-
-
 #1) Images captured from mobile is passed as parameter to the below function in the API call. It returns the similarity measure between given images.
 #2) The image is passed to the function in base64 encoding, Code for decoding the image is provided within the function.
 #3) Define an object to your siamese network here in the function and load the weight from the trained network, set it in evaluation mode.
@@ -122,13 +52,31 @@ def _embedding(face):
 #5) For loading your model use the current_path+'your model file name', anyhow detailed example is given in comments to the function 
 #Caution: Don't change the definition or function name; for loading the model use the current_path for path example is given in comments to the function
 def get_similarity(img1, img2):
-    face1 = _prepare_face(img1)
-    face2 = _prepare_face(img2)
-    emb1 = _embedding(face1)
-    emb2 = _embedding(face2)
-    cosine_similarity = float(np.dot(emb1, emb2))
-    cosine_similarity = max(min(cosine_similarity, 1.0), -1.0)
-    return float(1.0 - cosine_similarity)
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    
+    det_img1 = detected_face(img1)
+    det_img2 = detected_face(img2)
+    if(det_img1 == 0 or det_img2 == 0):
+        det_img1 = Image.fromarray(cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY))
+        det_img2 = Image.fromarray(cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY))
+    face1 = trnscm(det_img1).unsqueeze(0)
+    face2 = trnscm(det_img2).unsqueeze(0)
+    ##########################################################################################
+    ##Example for loading a model using weight state dictionary:                            ##
+    ## feature_net = light_cnn() #Example Network                                           ##
+    ## model = torch.load(current_path + '/siamese_model.t7', map_location=device)          ##
+    ## feature_net.load_state_dict(model['net_dict'])                                       ##
+    ##                                                                                      ##
+    ##current_path + '/<network_definition>' is path of the saved model if present in       ##
+    ##the same path as this file, we recommend to put in the same directory                 ##
+    ##########################################################################################
+    ##########################################################################################
+    
+    # YOUR CODE HERE, load the model
+    
+    # YOUR CODE HERE, return similarity measure using your model
+    
+    return 0
     
 #1) Image captured from mobile is passed as parameter to this function in the API call, It returns the face class in the string form ex: "Person1"
 #2) The image is passed to the function in base64 encoding, Code to decode the image provided within the function
@@ -137,49 +85,12 @@ def get_similarity(img1, img2):
 #5) Along with the siamese, you need the classifier as well, which is to be finetuned with the faces that you are training
 ##Caution: Don't change the definition or function name; for loading the model use the current_path for path example is given in comments to the function
 def get_face_class(img1):
-    face = _prepare_face(img1)
-    emb = _embedding(face).reshape(1, -1)
-    classifier_model = _load_classifier()
-    if classifier_model is not None:
-        model = classifier_model["model"]
-        prediction = model.predict(emb)[0]
-        if isinstance(prediction, (int, np.integer)) and 0 <= int(prediction) < len(classes):
-            return classes[int(prediction)]
-        return str(prediction)
-
-    gallery_result = _nearest_gallery_match(emb.reshape(-1))
-    if gallery_result is not None:
-        name, distance = gallery_result
-        return f"{name} (distance: {distance:.3f})"
-
-    return "Unknown - add face_classifier.joblib or known_faces/<person> images"
-
-
-@lru_cache(maxsize=1)
-def _gallery_embeddings():
-    gallery_dir = os.path.join(current_path, "known_faces")
-    if not os.path.isdir(gallery_dir):
-        return []
-
-    gallery = []
-    for person_name in sorted(os.listdir(gallery_dir)):
-        person_dir = os.path.join(gallery_dir, person_name)
-        if not os.path.isdir(person_dir):
-            continue
-        for filename in sorted(os.listdir(person_dir)):
-            if not filename.lower().endswith((".jpg", ".jpeg", ".png", ".bmp", ".webp")):
-                continue
-            image = cv2.imread(os.path.join(person_dir, filename))
-            if image is None:
-                continue
-            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
-            gallery.append((person_name, _embedding(_prepare_face(image))))
-    return gallery
-
-
-def _nearest_gallery_match(query_embedding):
-    gallery = _gallery_embeddings()
-    if not gallery:
-        return None
-    distances = [(name, float(1.0 - np.dot(query_embedding, emb))) for name, emb in gallery]
-    return min(distances, key=lambda item: item[1])
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    
+    det_img1 = detected_face(img1)
+    if(det_img1 == 0):
+        det_img1 = Image.fromarray(cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY))
+    ##YOUR CODE HERE, return face class here
+    ##Hint: you need a classifier finetuned for your classes, it takes o/p of siamese as i/p to it
+    ##Better Hint: Siamese experiment is covered in one of the labs
+    return "YET TO BE CODED"

app/Hackathon_setup/face_recognition_model.py

@@ -1,55 +1,31 @@
+import math
 import torch
+import torchvision
 import torch.nn as nn
 import torch.nn.functional as F
 from torchvision import transforms
+# Add more imports if required
 
-def rgb2gray(image):
-    return image.convert("L")
+# Sample Transformation function
+# YOUR CODE HERE for changing the Transformation values.
+trnscm = transforms.Compose([transforms.Resize((100,100)), transforms.ToTensor()])
 
-
-trnscm = transforms.Compose([rgb2gray, transforms.Resize((100, 100)), transforms.ToTensor()])
-
-class Siamese(nn.Module):
+##Example Network
+class Siamese(torch.nn.Module):
     def __init__(self):
-        super().__init__()
-        self.features = nn.Sequential(
-            nn.Conv2d(1, 16, kernel_size=5, padding=2),
-            nn.BatchNorm2d(16),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(2),
-            nn.Conv2d(16, 32, kernel_size=3, padding=1),
-            nn.BatchNorm2d(32),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(2),
-            nn.Conv2d(32, 64, kernel_size=3, padding=1),
-            nn.BatchNorm2d(64),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(2),
-        )
-        self.embedding = nn.Sequential(
-            nn.Flatten(),
-            nn.Linear(64 * 12 * 12, 256),
-            nn.ReLU(inplace=True),
-            nn.Dropout(0.25),
-            nn.Linear(256, 128),
-        )
+        super(Siamese, self).__init__()
+        #YOUR CODE HERE
         
     def forward(self, x):
-        x = self.features(x)
-        x = self.embedding(x)
-        return F.normalize(x, p=2, dim=1)
+        pass   # remove 'pass' once you have written your code
+        #YOUR CODE HERE
         
 ##########################################################################################################
 ## Sample classification network (Specify if you are using a pytorch classifier during the training)    ##
 ## classifier = nn.Sequential(nn.Linear(64, 64), nn.BatchNorm1d(64), nn.ReLU(), nn.Linear...)           ##
 ##########################################################################################################
 
-classifier = nn.Sequential(
-    nn.Linear(128, 64),
-    nn.BatchNorm1d(64),
-    nn.ReLU(inplace=True),
-    nn.Linear(64, 7),
-)
+# YOUR CODE HERE for pytorch classifier
 
 # Definition of classes as dictionary
-classes = ['Person1', 'Person2', 'Person3', 'Person4', 'Person5', 'Person6', 'Person7']
+classes = ['person1','person2','person3','person4','person5','person6','person7']

app/Hackathon_setup/siamese_model.pth

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:540cd55c4c19e93208315ef83ed6eba15a929da696db72dc9e36623dc861d19f
-size 9674169

app/config.py

@@ -1,17 +1,25 @@
-class Settings:
-    API_V1_STR = "/api/v1"
+import sys
+from typing import List
 
+from pydantic import AnyHttpUrl, BaseSettings
+
+class Settings(BaseSettings):
+    API_V1_STR: str = "/api/v1"
+
+    # Meta
+ 
     # BACKEND_CORS_ORIGINS is a comma-separated list of origins
     # e.g: http://localhost,http://localhost:4200,http://localhost:3000
-    BACKEND_CORS_ORIGINS = [
-        "http://localhost:3000",
-        "http://localhost:8000",
-        "http://localhost:7860",
-        "https://localhost:3000",
-        "https://localhost:8000",
-        "https://localhost:7860",
+    BACKEND_CORS_ORIGINS: List[AnyHttpUrl] = [
+        "http://localhost:3000",  # type: ignore
+        "http://localhost:8000",  # type: ignore
+        "https://localhost:3000",  # type: ignore
+        "https://localhost:8000",  # type: ignore
     ]
 
-    PROJECT_NAME = "Recognition API"
+    PROJECT_NAME: str = "Recognition API"
+
+    class Config:
+        case_sensitive = True
 
 settings = Settings()

app/main.py

@@ -1,122 +1,133 @@
 import sys
 from pathlib import Path
-from uuid import uuid4
-
 sys.path.append(str(Path(__file__).resolve().parent.parent))
+#print(sys.path)
+from typing import Any
 
-from fastapi import FastAPI, HTTPException, Request, File, UploadFile
+from fastapi import FastAPI, Request, APIRouter, File, UploadFile
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
 from fastapi.middleware.cors import CORSMiddleware
 from app.config import settings
+from app import __version__
 from app.Hackathon_setup import face_recognition, exp_recognition
 
 import numpy as np
 from PIL import Image
 
-BASE_DIR = Path(__file__).resolve().parent
-STATIC_DIR = BASE_DIR / "static"
-TEMPLATES_DIR = BASE_DIR / "templates"
-STATIC_DIR.mkdir(parents=True, exist_ok=True)
 
 app = FastAPI(
     title=settings.PROJECT_NAME, openapi_url=f"{settings.API_V1_STR}/openapi.json"
 )
 
 # To store files uploaded by users
-app.mount("/static", StaticFiles(directory=str(STATIC_DIR)), name="static")
+app.mount("/static", StaticFiles(directory="app/static"), name="static")
 
 # To access Templates directory
-templates = Jinja2Templates(directory=str(TEMPLATES_DIR))
-
-def render_template(request: Request, template_name: str, context: dict | None = None):
-    return templates.TemplateResponse(
-        name=template_name,
-        request=request,
-        context=context or {}
-    )
-
-
-def _file_extension(filename: str) -> str:
-    suffix = Path(filename or "").suffix.lower()
-    return suffix if suffix in {".jpg", ".jpeg", ".png", ".bmp", ".webp"} else ".jpg"
-
-
-async def save_upload_image(upload: UploadFile) -> tuple[np.ndarray, str]:
-    if not upload.content_type or "image" not in upload.content_type:
-        raise HTTPException(status_code=400, detail="Please upload a valid image file.")
-
-    contents = await upload.read()
-    filename = f"{uuid4().hex}{_file_extension(upload.filename)}"
-    filepath = STATIC_DIR / filename
-    filepath.write_bytes(contents)
-
-    try:
-        image = Image.open(filepath).convert("RGB")
-    except Exception as exc:
-        filepath.unlink(missing_ok=True)
-        raise HTTPException(status_code=400, detail="The uploaded file could not be read as an image.") from exc
+templates = Jinja2Templates(directory="app/templates")
 
-    return np.asarray(image).astype(np.uint8), f"../static/{filename}"
+simi_filename1 = None
+simi_filename2 = None
+face_rec_filename = None
+expr_rec_filename = None
 
 
 ####################################  Home Page endpoints  #################################################
 @app.get("/")
 async def root(request: Request):
-    return render_template(request, "index.html")
+    return templates.TemplateResponse("index.html", {'request': request,})
 
 
 ####################################  Face Similarity endpoints  #################################################
 @app.get("/similarity/")
 async def similarity_root(request: Request):
-    return render_template(request, "similarity.html")
+    return templates.TemplateResponse("similarity.html", {'request': request,})
 
 
 @app.post("/predict_similarity/")
 async def create_upload_files(request: Request, file1: UploadFile = File(...), file2: UploadFile = File(...)):
-    img1, simi_filename1 = await save_upload_image(file1)
-    img2, simi_filename2 = await save_upload_image(file2)
+    global simi_filename1
+    global simi_filename2
+    
+    if 'image' in file1.content_type:
+        contents = await file1.read()
+        simi_filename1 = 'app/static/' + file1.filename
+        with open(simi_filename1, 'wb') as f:
+            f.write(contents)
+    
+    if 'image' in file2.content_type:
+        contents = await file2.read()
+        simi_filename2 = 'app/static/' + file2.filename
+        with open(simi_filename2, 'wb') as f:
+            f.write(contents)
+    
+    img1 = Image.open(simi_filename1)
+    img1 =  np.array(img1).reshape(img1.size[1], img1.size[0], 3).astype(np.uint8)
+    
+    img2 = Image.open(simi_filename2)
+    img2 =  np.array(img2).reshape(img2.size[1], img2.size[0], 3).astype(np.uint8)
+    
     result = face_recognition.get_similarity(img1, img2)
+    #print(result)
     
-    return render_template(request, "predict_similarity.html", {
-        "result": np.round(result, 3),
-        "simi_filename1": simi_filename1,
-        "simi_filename2": simi_filename2,
-    })
+    return templates.TemplateResponse("predict_similarity.html", {"request": request,
+                                                       "result": np.round(result, 3),
+                                                       "simi_filename1": '../static/'+file1.filename,
+                                                       "simi_filename2": '../static/'+file2.filename,})
     
 
 ####################################  Face Recognition endpoints  #################################################
 @app.get("/face_recognition/")
 async def face_recognition_root(request: Request):
-    return render_template(request, "face_recognition.html")
+    return templates.TemplateResponse("face_recognition.html", {'request': request,})
 
 
 @app.post("/predict_face_recognition/")
 async def create_upload_files(request: Request, file3: UploadFile = File(...)):
-    img1, face_rec_filename = await save_upload_image(file3)
+    global face_rec_filename
+    
+    if 'image' in file3.content_type:
+        contents = await file3.read()
+        face_rec_filename = 'app/static/' + file3.filename
+        with open(face_rec_filename, 'wb') as f:
+            f.write(contents)
+    
+    img1 = Image.open(face_rec_filename)
+    img1 =  np.array(img1).reshape(img1.size[1], img1.size[0], 3).astype(np.uint8)
+        
     result = face_recognition.get_face_class(img1)
+    print(result)
     
-    return render_template(request, "predict_face_recognition.html", {
-        "result": result,
-        "face_rec_filename": face_rec_filename,
-    })
+    return templates.TemplateResponse("predict_face_recognition.html", {"request": request,
+                                                       "result": result,
+                                                       "face_rec_filename": '../static/'+file3.filename,})
 
 
 ####################################  Expresion Recognition endpoints  #################################################
 @app.get("/expr_recognition/")
 async def expr_recognition_root(request: Request):
-    return render_template(request, "expr_recognition.html")
+    return templates.TemplateResponse("expr_recognition.html", {'request': request,})
 
 
 @app.post("/predict_expr_recognition/")
 async def create_upload_files(request: Request, file4: UploadFile = File(...)):
-    img1, expr_rec_filename = await save_upload_image(file4)
+    global expr_rec_filename
+    
+    if 'image' in file4.content_type:
+        contents = await file4.read()
+        expr_rec_filename = 'app/static/' + file4.filename
+        with open(expr_rec_filename, 'wb') as f:
+            f.write(contents)
+    
+    img1 = Image.open(expr_rec_filename)
+    img1 =  np.array(img1).reshape(img1.size[1], img1.size[0], 3).astype(np.uint8)
+        
     result = exp_recognition.get_expression(img1)
+    print(result)
     
-    return render_template(request, "predict_expr_recognition.html", {
-        "result": result,
-        "expr_rec_filename": expr_rec_filename,
-    })
+    return templates.TemplateResponse("predict_expr_recognition.html", {"request": request,
+                                                       "result": result,
+                                                       "expr_rec_filename": '../static/'+file4.filename,})
 
 
 
@@ -134,4 +145,4 @@ if settings.BACKEND_CORS_ORIGINS:
 # Start app
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    uvicorn.run(app, host="0.0.0.0", port=8001)