Add face recognition with Siamese embeddings and classifier

app/Hackathon_setup/face_recognition.py

@@ -2,25 +2,23 @@ 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.
-# Keep '.' before face_recognition_model while uploading to the server
-from .face_recognition_model import *
+from .face_recognition_model import Siamese, trnscm, device
 from PIL import Image
-import base64
-import io
 import os
 import joblib
-import pickle
-# Add more imports if required
-
-###########################################################################################################################################
-#         Caution: Don't change any of the filenames, function names and definitions                                                      #
-#        Always use the current_path + file_name for refering any files, without it we cannot access files on the server                  # 
-###########################################################################################################################################
+import torch.nn.functional as F
 
 # Current_path stores absolute path of the file from where it runs. 
 current_path = os.path.dirname(os.path.abspath(__file__))
 
+# -------------------------
+# Load trained classifier and label encoder
+# -------------------------
+clf_path = os.path.join(current_path, "team_classifier.joblib")
+le_path = os.path.join(current_path, "label_encoder.joblib")
+clf = joblib.load(clf_path)
+le = joblib.load(le_path)
+
 # -------------------------
 # Face Detection
 # -------------------------
@@ -46,8 +44,6 @@ def detected_face(image):
 # Compute Similarity
 # -------------------------
 def get_similarity(img1, img2):
-    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-    
     # Detect faces
     det_img1 = detected_face(img1)
     det_img2 = detected_face(img2)
@@ -59,22 +55,17 @@ def get_similarity(img1, img2):
     face1 = trnscm(det_img1).unsqueeze(0).to(device)
     face2 = trnscm(det_img2).unsqueeze(0).to(device)
     
-    # -------------------------
-    # Load Siamese Model
-    # -------------------------
+    # Load Siamese model
     model_path = current_path + '/siamese_model.t7'
     checkpoint = torch.load(model_path, map_location=device)
     feature_net = Siamese().to(device)
     feature_net.load_state_dict(checkpoint['net_dict'])
     feature_net.eval()
     
-    # -------------------------
-    # Compute similarity (Euclidean distance)
-    # -------------------------
+    # Compute similarity
     with torch.no_grad():
         output1, output2 = feature_net(face1, face2)
         euclidean_distance = F.pairwise_distance(output1, output2)
-        # Convert distance to similarity score (0–1)
         similarity_score = 1 / (1 + euclidean_distance.item())
     
     return round(similarity_score, 3)
@@ -83,8 +74,7 @@ def get_similarity(img1, img2):
 # Get Face Class
 # -------------------------
 def get_face_class(img1):
-    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-    
+    # Detect face
     det_img1 = detected_face(img1)
     if det_img1 == 0:
         det_img1 = Image.fromarray(cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY))
@@ -99,17 +89,14 @@ def get_face_class(img1):
     feature_net.load_state_dict(checkpoint['net_dict'])
     feature_net.eval()
     
-    # -------------------------
-    # Use Siamese + classifier to predict class (if classifier exists)
-    # -------------------------
-    # If you have a trained classifier that takes embeddings from Siamese as input:
-    # classifier = <your classifier>
-    # with torch.no_grad():
-    #     embedding = feature_net.forward_once(face)
-    #     pred = classifier(embedding)
-    #     predicted_class = classes[pred.argmax(dim=1).item()]
+    # Get embedding
+    with torch.no_grad():
+        embedding = feature_net.forward_once(face)
+        embedding_np = embedding.cpu().numpy()
     
-    # Since classifier is not trained here, return placeholder
-    predicted_class = "YET TO BE CODED"
+    # Predict class using trained classifier
+    pred_idx = clf.predict(embedding_np)[0]
+    pred_proba = clf.predict_proba(embedding_np).max()
+    predicted_class = le.inverse_transform([pred_idx])[0]
     
-    return predicted_class
+    return {"name": predicted_class, "probability": float(pred_proba)}

app/Hackathon_setup/face_recognition_bkp.py

@@ -0,0 +1,115 @@
+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.
+# Keep '.' before face_recognition_model while uploading to the server
+from .face_recognition_model import *
+from PIL import Image
+import base64
+import io
+import os
+import joblib
+import pickle
+# Add more imports if required
+
+###########################################################################################################################################
+#         Caution: Don't change any of the filenames, function names and definitions                                                      #
+#        Always use the current_path + file_name for refering any files, without it we cannot access files on the server                  # 
+###########################################################################################################################################
+
+# Current_path stores absolute path of the file from where it runs. 
+current_path = os.path.dirname(os.path.abspath(__file__))
+
+# -------------------------
+# Face Detection
+# -------------------------
+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 = []
+    images = []
+    required_image = 0
+    for i, (x, y, w, h) in enumerate(faces):
+        face_cropped = gray[y:y+h, x:x+w]
+        face_areas.append(w*h)
+        images.append(face_cropped)
+        required_image = images[np.argmax(face_areas)]
+        required_image = Image.fromarray(required_image)
+    return required_image
+
+# -------------------------
+# Compute Similarity
+# -------------------------
+def get_similarity(img1, img2):
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    
+    # Detect faces
+    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))
+    
+    # Transform images
+    face1 = trnscm(det_img1).unsqueeze(0).to(device)
+    face2 = trnscm(det_img2).unsqueeze(0).to(device)
+    
+    # -------------------------
+    # Load Siamese Model
+    # -------------------------
+    model_path = current_path + '/siamese_model.t7'
+    checkpoint = torch.load(model_path, map_location=device)
+    feature_net = Siamese().to(device)
+    feature_net.load_state_dict(checkpoint['net_dict'])
+    feature_net.eval()
+    
+    # -------------------------
+    # Compute similarity (Euclidean distance)
+    # -------------------------
+    with torch.no_grad():
+        output1, output2 = feature_net(face1, face2)
+        euclidean_distance = F.pairwise_distance(output1, output2)
+        # Convert distance to similarity score (0–1)
+        similarity_score = 1 / (1 + euclidean_distance.item())
+    
+    return round(similarity_score, 3)
+
+# -------------------------
+# Get Face Class
+# -------------------------
+def get_face_class(img1):
+    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))
+    
+    # Transform image
+    face = trnscm(det_img1).unsqueeze(0).to(device)
+    
+    # Load Siamese model
+    model_path = current_path + '/siamese_model.t7'
+    checkpoint = torch.load(model_path, map_location=device)
+    feature_net = Siamese().to(device)
+    feature_net.load_state_dict(checkpoint['net_dict'])
+    feature_net.eval()
+    
+    # -------------------------
+    # Use Siamese + classifier to predict class (if classifier exists)
+    # -------------------------
+    # If you have a trained classifier that takes embeddings from Siamese as input:
+    # classifier = <your classifier>
+    # with torch.no_grad():
+    #     embedding = feature_net.forward_once(face)
+    #     pred = classifier(embedding)
+    #     predicted_class = classes[pred.argmax(dim=1).item()]
+    
+    # Since classifier is not trained here, return placeholder
+    predicted_class = "YET TO BE CODED"
+    
+    return predicted_class

app/Hackathon_setup/face_recognition_model.py

@@ -4,8 +4,11 @@ import torchvision
 import torch.nn as nn
 import torch.nn.functional as F
 from torchvision import transforms
-# Add more imports if required
 
+# ---------------------------
+# Device configuration
+# ---------------------------
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
 # ---------------------------
 # Transformation Function
@@ -16,11 +19,10 @@ trnscm = transforms.Compose([
     transforms.ToTensor()
 ])
 
-
 # ---------------------------
 # Siamese Network Definition
 # ---------------------------
-class Siamese(torch.nn.Module):
+class Siamese(nn.Module):
     def __init__(self):
         super(Siamese, self).__init__()
         
@@ -54,7 +56,7 @@ class Siamese(torch.nn.Module):
     def forward_once(self, x):
         # Forward pass for one image
         output = self.cnn1(x)
-        output = output.view(output.size()[0], -1)
+        output = output.view(output.size(0), -1)
         output = self.fc1(output)
         return output
         
@@ -64,17 +66,13 @@ class Siamese(torch.nn.Module):
         output2 = self.forward_once(x2)
         return output1, output2
 
-
 ##########################################################################################################
-## 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 for face recognition
+## Not used for face similarity; now we use a Sklearn classifier separately
 ##########################################################################################################
-
-# Not used for face similarity — so keep it as None
-classifier = None
-
+classifier = None  # Keep as None; we use joblib-loaded Sklearn model in facerecognition.py
 
 # ---------------------------
-# Class labels (optional)
+# Class labels (optional, for reference)
 # ---------------------------
 classes = ['person1', 'person2', 'person3', 'person4', 'person5', 'person6', 'person7']

app/Hackathon_setup/face_recognition_model_bkp.py

@@ -0,0 +1,80 @@
+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
+
+
+# ---------------------------
+# Transformation Function
+# ---------------------------
+# Same transforms as used during training in Colab
+trnscm = transforms.Compose([
+    transforms.Resize((100, 100)),
+    transforms.ToTensor()
+])
+
+
+# ---------------------------
+# Siamese Network Definition
+# ---------------------------
+class Siamese(torch.nn.Module):
+    def __init__(self):
+        super(Siamese, self).__init__()
+        
+        # CNN layers (same as your Colab model)
+        self.cnn1 = nn.Sequential(
+            nn.ReflectionPad2d(1),
+            nn.Conv2d(1, 4, kernel_size=3),
+            nn.ReLU(inplace=True),
+            nn.BatchNorm2d(4),
+
+            nn.ReflectionPad2d(1),
+            nn.Conv2d(4, 8, kernel_size=3),
+            nn.ReLU(inplace=True),
+            nn.BatchNorm2d(8),
+
+            nn.ReflectionPad2d(1),
+            nn.Conv2d(8, 8, kernel_size=3),
+            nn.ReLU(inplace=True),
+            nn.BatchNorm2d(8)
+        )
+
+        # Fully connected layers
+        self.fc1 = nn.Sequential(
+            nn.Linear(8 * 100 * 100, 500),
+            nn.ReLU(inplace=True),
+            nn.Linear(500, 500),
+            nn.ReLU(inplace=True),
+            nn.Linear(500, 5)
+        )
+        
+    def forward_once(self, x):
+        # Forward pass for one image
+        output = self.cnn1(x)
+        output = output.view(output.size()[0], -1)
+        output = self.fc1(output)
+        return output
+        
+    def forward(self, x1, x2):
+        # Forward pass for both images
+        output1 = self.forward_once(x1)
+        output2 = self.forward_once(x2)
+        return output1, output2
+
+
+##########################################################################################################
+## 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...)           ##
+##########################################################################################################
+
+# Not used for face similarity — so keep it as None
+classifier = None
+
+
+# ---------------------------
+# Class labels (optional)
+# ---------------------------
+classes = ['person1', 'person2', 'person3', 'person4', 'person5', 'person6', 'person7']

app/Hackathon_setup/label_encoder.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6613233d2442a0938635221fec29c91fcf4024f791c79465777286a70349ec97
+size 351

app/Hackathon_setup/team_classifier.joblib

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