FaceREcognition changes stage3

app/Hackathon_setup/face_recognition.py

@@ -21,6 +21,19 @@ import pickle
 
 # Current_path stores absolute path of the file from where it runs. 
 current_path = os.path.dirname(os.path.abspath(__file__))
+# --- GLOBAL SETUP: Must match your training transforms ---
+# Define the transformation pipeline for inference
+trnscm = transforms.Compose([
+    transforms.Grayscale(num_output_channels=1),
+    transforms.Resize((100, 100)),
+    transforms.ToTensor()
+])
+CLASS_NAMES = ['Person0', 'Person1', 'Person2', 'Person3', 'Person4'] # ADJUST THIS!
+
+# --- Model Filenames ---
+SIAMESE_MODEL_PATH = current_path + '/siamese_model.t7'
+KNN_CLASSIFIER_PATH = current_path + '/decision_tree_model.sav'
+SCALER_PATH = current_path + '/face_recognition_scaler.sav'
 
 #1) The below function is used to detect faces in the given image.
 #2) It returns only one image which has maximum area out of all the detected faces in the photo.
@@ -75,8 +88,35 @@ def get_similarity(img1, img2):
     # YOUR CODE HERE, load the model
     
     # YOUR CODE HERE, return similarity measure using your model
+    # 1. Initialize and Load Siamese Network
+    try:
+        # Assuming your Siamese Network class is named 'SiameseNetwork'
+        siamese_net = SiameseNetwork().to(device)
+        siamese_net.load_state_dict(torch.load(SIAMESE_MODEL_PATH, map_location=device))
+        siamese_net.eval()
+    except Exception as e:
+        print(f"Error loading Siamese Model: {e}")
+        return -1 # Return error code
+
+    # 2. Get Features (Embeddings)
+    with torch.no_grad():
+        # Get the feature vector from one tower/forward_once method
+        # Ensure your SiameseNetwork class has a forward_once or get_embedding method
+        embed1 = siamese_net.forward_once(face1).cpu().numpy()
+        embed2 = siamese_net.forward_once(face2).cpu().numpy()
+        
+    # 3. Calculate Similarity Measure
+    # The Euclidean distance is the fundamental metric used by the Triplet/Contrastive loss.
+    # We return the NEGATIVE Euclidean distance or COSINE similarity, as *higher* value usually means *more* similar.
+    
+    # Option A: Euclidean Distance (Lower is better) -> return NEGATIVE distance for API expectation
+    # distance = euclidean_distances(embed1, embed2)[0][0]
+    # similarity = -distance 
     
-    return 0
+    # Option B: Cosine Similarity (Higher is better) -> Recommended
+    similarity = cosine_similarity(embed1, embed2)[0][0]
+    
+    return float(similarity)
     
 #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
@@ -93,4 +133,38 @@ def get_face_class(img1):
     ##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"
+    face1_tensor = trnscm(det_img1).unsqueeze(0).to(device)
+
+    # 1. Load Siamese Network (Feature Extractor)
+    try:
+        siamese_net = SiameseNetwork().to(device)
+        siamese_net.load_state_dict(torch.load(SIAMESE_MODEL_PATH, map_location=device))
+        siamese_net.eval()
+    except Exception as e:
+        return f"Error loading Siamese Model: {e}"
+
+    # 2. Extract Embedding
+    with torch.no_grad():
+        embedding_np = siamese_net.forward_once(face1_tensor).cpu().numpy()
+    
+    # 3. Load Sklearn Scaler and Classifier (Joblib)
+    try:
+        knn_classifier = joblib.load(KNN_CLASSIFIER_PATH)
+        scaler = joblib.load(SCALER_PATH)
+    except Exception as e:
+        return f"Error loading Sklearn models: {e}"
+    
+    # 4. Preprocess Embedding and Predict
+    # The embedding must be reshaped to (1, N_features) for the scaler
+    embedding_scaled = scaler.transform(embedding_np.reshape(1, -1))
+    
+    # Perform prediction (returns a NumPy array with the predicted label index)
+    predicted_label_index = knn_classifier.predict(embedding_scaled)[0]
+    
+    # 5. Map index to Class Name
+    if predicted_label_index < len(CLASS_NAMES):
+        predicted_class_name = CLASS_NAMES[predicted_label_index]
+    else:
+        predicted_class_name = "UNKNOWN_CLASS"
+
+    return predicted_class_name

app/Hackathon_setup/face_recognition_model.py

@@ -53,5 +53,32 @@ def get_similarity(img1, img2):
     # YOUR CODE HERE, load the model
     
     # YOUR CODE HERE, return similarity measure using your model
+    # 1. Initialize and Load Siamese Network
+    try:
+        # Assuming your Siamese Network class is named 'SiameseNetwork'
+        siamese_net = SiameseNetwork().to(device)
+        siamese_net.load_state_dict(torch.load(SIAMESE_MODEL_PATH, map_location=device))
+        siamese_net.eval()
+    except Exception as e:
+        print(f"Error loading Siamese Model: {e}")
+        return -1 # Return error code
+
+    # 2. Get Features (Embeddings)
+    with torch.no_grad():
+        # Get the feature vector from one tower/forward_once method
+        # Ensure your SiameseNetwork class has a forward_once or get_embedding method
+        embed1 = siamese_net.forward_once(face1).cpu().numpy()
+        embed2 = siamese_net.forward_once(face2).cpu().numpy()
+        
+    # 3. Calculate Similarity Measure
+    # The Euclidean distance is the fundamental metric used by the Triplet/Contrastive loss.
+    # We return the NEGATIVE Euclidean distance or COSINE similarity, as *higher* value usually means *more* similar.
+    
+    # Option A: Euclidean Distance (Lower is better) -> return NEGATIVE distance for API expectation
+    # distance = euclidean_distances(embed1, embed2)[0][0]
+    # similarity = -distance 
+    
+    # Option B: Cosine Similarity (Higher is better) -> Recommended
+    similarity = cosine_similarity(embed1, embed2)[0][0]
     
-    return 0
+    return float(similarity)