deploy code

app/Hackathon_setup/diagnose_errors.py

@@ -0,0 +1,167 @@
+"""
+Diagnostic script to identify common issues with face recognition setup
+"""
+
+import sys
+import os
+import traceback
+
+def check_python_version():
+    """Check Python version"""
+    print("Python Version Check")
+    print("=" * 20)
+    print(f"Python version: {sys.version}")
+    if sys.version_info < (3, 6):
+        print("WARNING: Python 3.6+ recommended")
+    else:
+        print("OK: Python version is compatible")
+
+def check_packages():
+    """Check if required packages are installed"""
+    print("\nPackage Installation Check")
+    print("=" * 30)
+    
+    packages = [
+        ('numpy', 'numpy'),
+        ('cv2', 'cv2'),
+        ('torch', 'torch'),
+        ('sklearn', 'sklearn'),
+        ('PIL', 'PIL'),
+        ('matplotlib', 'matplotlib'),
+        ('joblib', 'joblib')
+    ]
+    
+    missing_packages = []
+    
+    for package_name, import_name in packages:
+        try:
+            __import__(import_name)
+            print(f"OK: {package_name}")
+        except ImportError:
+            print(f"ERROR: {package_name} - MISSING")
+            missing_packages.append(package_name)
+    
+    if missing_packages:
+        print(f"\nWARNING: Missing packages: {', '.join(missing_packages)}")
+        print("Install with: pip install " + " ".join(missing_packages))
+        return False
+    else:
+        print("\nOK: All required packages are installed")
+        return True
+
+def check_files():
+    """Check if required files exist"""
+    print("\nFile Structure Check")
+    print("=" * 25)
+    
+    required_files = [
+        'face_recognition.py',
+        'face_recognition_model.py',
+        'test_cosine_similarity.py'
+    ]
+    
+    model_files = [
+        'siamese_model.t7',
+        'decision_tree_model.sav',
+        'face_recognition_scaler.sav'
+    ]
+    
+    missing_files = []
+    
+    print("Required Python files:")
+    for file in required_files:
+        if os.path.exists(file):
+            print(f"OK: {file}")
+        else:
+            print(f"ERROR: {file} - MISSING")
+            missing_files.append(file)
+    
+    print("\nModel files (need to be trained):")
+    for file in model_files:
+        if os.path.exists(file):
+            print(f"OK: {file}")
+        else:
+            print(f"ERROR: {file} - MISSING (needs training)")
+            missing_files.append(file)
+    
+    return len(missing_files) == 0
+
+def test_imports():
+    """Test importing the face recognition module"""
+    print("\nImport Test")
+    print("=" * 15)
+    
+    try:
+        # Add current directory to path
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        sys.path.insert(0, current_dir)
+        
+        from face_recognition import get_similarity, get_face_class
+        print("OK: Successfully imported face_recognition functions")
+        return True
+    except Exception as e:
+        print(f"ERROR: Failed to import face_recognition: {e}")
+        print("Full error:")
+        traceback.print_exc()
+        return False
+
+def test_basic_functionality():
+    """Test basic functionality without model files"""
+    print("\nBasic Functionality Test")
+    print("=" * 30)
+    
+    try:
+        import numpy as np
+        from face_recognition import detected_face
+        
+        # Create a test image
+        test_img = np.random.randint(0, 255, (100, 100, 3), dtype=np.uint8)
+        
+        # Test face detection
+        result = detected_face(test_img)
+        print("OK: detected_face function works")
+        
+        return True
+    except Exception as e:
+        print(f"ERROR: Basic functionality test failed: {e}")
+        traceback.print_exc()
+        return False
+
+def main():
+    """Run all diagnostic checks"""
+    print("Face Recognition System Diagnostic")
+    print("=" * 40)
+    
+    checks = [
+        check_python_version,
+        check_packages,
+        check_files,
+        test_imports,
+        test_basic_functionality
+    ]
+    
+    results = []
+    for check in checks:
+        try:
+            result = check()
+            results.append(result)
+        except Exception as e:
+            print(f"ERROR: Check failed with error: {e}")
+            results.append(False)
+    
+    print("\n" + "=" * 40)
+    print("DIAGNOSTIC SUMMARY")
+    print("=" * 40)
+    
+    if all(results):
+        print("SUCCESS: All checks passed! Your setup looks good.")
+        print("You can now run the test script.")
+    else:
+        print("ERROR: Some checks failed. Please fix the issues above.")
+        print("\nCommon solutions:")
+        print("1. Install missing packages: pip install numpy opencv-python torch scikit-learn matplotlib joblib")
+        print("2. Make sure all Python files are in the same directory")
+        print("3. Train your models first before testing similarity")
+
+if __name__ == "__main__":
+    main()

app/Hackathon_setup/face_recognition.py

@@ -3,13 +3,19 @@ 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 *
+try:
+    from .face_recognition_model import *
+except ImportError:
+    # Fallback for when running as standalone script
+    from face_recognition_model import *
 from PIL import Image
 import base64
 import io
 import os
 import joblib
 import pickle
+from sklearn.metrics.pairwise import cosine_similarity
+from sklearn.preprocessing import StandardScaler
 # Add more imports if required
 
 
@@ -90,9 +96,16 @@ def get_similarity(img1, img2):
     # 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))
+        # Using the Siamese class from your model file
+        siamese_net = Siamese().to(device)
+        
+        # Load the model - check if it has 'net_dict' key
+        model_data = torch.load(SIAMESE_MODEL_PATH, map_location=device)
+        if isinstance(model_data, dict) and 'net_dict' in model_data:
+            siamese_net.load_state_dict(model_data['net_dict'])
+        else:
+            siamese_net.load_state_dict(model_data)
+        
         siamese_net.eval()
     except Exception as e:
         print(f"Error loading Siamese Model get_similarity: {e}")
@@ -102,8 +115,8 @@ def get_similarity(img1, img2):
     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()
+        embed1 = siamese_net.forward_once(face1.to(device)).cpu().numpy()
+        embed2 = siamese_net.forward_once(face2.to(device)).cpu().numpy()
         
     # 3. Calculate Similarity Measure
     # The Euclidean distance is the fundamental metric used by the Triplet/Contrastive loss.
@@ -114,7 +127,21 @@ def get_similarity(img1, img2):
     # similarity = -distance 
     
     # Option B: Cosine Similarity (Higher is better) -> Recommended
-    similarity = cosine_similarity(embed1, embed2)[0][0]
+    try:
+        # Ensure embeddings are 2D arrays for sklearn cosine_similarity
+        if embed1.ndim == 1:
+            embed1 = embed1.reshape(1, -1)
+        if embed2.ndim == 1:
+            embed2 = embed2.reshape(1, -1)
+            
+        similarity = cosine_similarity(embed1, embed2)[0][0]
+        
+        # Clamp similarity to valid range [-1, 1] to handle numerical precision issues
+        similarity = np.clip(similarity, -1.0, 1.0)
+        
+    except Exception as e:
+        print(f"Error calculating cosine similarity: {e}")
+        return -1.0  # Return error value
     
     return float(similarity)
     
@@ -137,8 +164,15 @@ def get_face_class(img1):
 
     # 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 = Siamese().to(device)
+        
+        # Load the model - check if it has 'net_dict' key
+        model_data = torch.load(SIAMESE_MODEL_PATH, map_location=device)
+        if isinstance(model_data, dict) and 'net_dict' in model_data:
+            siamese_net.load_state_dict(model_data['net_dict'])
+        else:
+            siamese_net.load_state_dict(model_data)
+        
         siamese_net.eval()
     except Exception as e:
         return f"Error loading Siamese Model get_face_class: {e}"
@@ -146,6 +180,10 @@ def get_face_class(img1):
     # 2. Extract Embedding
     with torch.no_grad():
         embedding_np = siamese_net.forward_once(face1_tensor).cpu().numpy()
+        
+        # Ensure embedding is 2D for sklearn
+        if embedding_np.ndim == 1:
+            embedding_np = embedding_np.reshape(1, -1)
     
     # 3. Load Sklearn Scaler and Classifier (Joblib)
     try:

app/Hackathon_setup/face_recognition_model.py

@@ -14,11 +14,43 @@ trnscm = transforms.Compose([transforms.Resize((100,100)), transforms.ToTensor()
 class Siamese(torch.nn.Module):
     def __init__(self):
         super(Siamese, self).__init__()
-        #YOUR CODE HERE
-        
-    def forward(self, x):
-        pass   # remove 'pass' once you have written your code
-        #YOUR CODE HERE
+        self.cnn1 = nn.Sequential(
+            nn.ReflectionPad2d(1),       #Pads the input tensor using the reflection of the input boundary, it similar to the padding.
+            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),
+        )
+
+        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))
+
+    # forward_once is for one image. This can be used while classifying the face images
+    def forward_once(self, x):
+        output = self.cnn1(x)
+        output = output.view(output.size()[0], -1)
+        output = self.fc1(output)
+        return output
+
+    def forward(self, input1, input2):
+        output1 = self.forward_once(input1)
+        output2 = self.forward_once(input2)
+        return output1, output2
         
 ##########################################################################################################
 ## Sample classification network (Specify if you are using a pytorch classifier during the training)    ##
@@ -28,102 +60,4 @@ class Siamese(torch.nn.Module):
 # YOUR CODE HERE for pytorch classifier
 
 # Definition of classes as dictionary
-classes = ['person1','person2','person3','person4','person5','person6','person7']
-def get_similarity(img1, img2):
-    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
-    # 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 float(similarity)
-    
-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))
-    ##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
-    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 get_face_class: {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
+classes = ['person1','person2','person3','person4','person5','person6','person7']

app/Hackathon_setup/inspect_model.py

@@ -0,0 +1,41 @@
+"""
+Script to inspect the saved model structure
+"""
+
+import torch
+import os
+
+def inspect_model():
+    """Inspect the structure of the saved model"""
+    model_path = 'siamese_model.t7'
+    
+    if not os.path.exists(model_path):
+        print(f"Model file {model_path} not found!")
+        return
+    
+    try:
+        # Load the model
+        model_data = torch.load(model_path, map_location='cpu')
+        
+        print("Model file loaded successfully!")
+        print(f"Type: {type(model_data)}")
+        
+        if isinstance(model_data, dict):
+            print("\nDictionary keys:")
+            for key in model_data.keys():
+                print(f"  - {key}")
+                
+            if 'net_dict' in model_data:
+                print(f"\n'net_dict' contains {len(model_data['net_dict'])} items:")
+                for key in list(model_data['net_dict'].keys())[:10]:  # Show first 10 keys
+                    print(f"  - {key}")
+                if len(model_data['net_dict']) > 10:
+                    print(f"  ... and {len(model_data['net_dict']) - 10} more keys")
+        else:
+            print("Model data is not a dictionary")
+            
+    except Exception as e:
+        print(f"Error loading model: {e}")
+
+if __name__ == "__main__":
+    inspect_model()

app/Hackathon_setup/test_cosine_similarity.py

@@ -0,0 +1,159 @@
+"""
+Test script to demonstrate cosine similarity for face recognition
+This script shows how to use the implemented cosine similarity functionality
+"""
+
+import sys
+import os
+import traceback
+
+# Add current directory to path to ensure imports work
+current_dir = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, current_dir)
+
+try:
+    import numpy as np
+    import cv2
+    import torch
+    from sklearn.metrics.pairwise import cosine_similarity
+    print("OK: All required packages imported successfully")
+except ImportError as e:
+    print(f"✗ Import Error: {e}")
+    print("Please install missing packages:")
+    print("pip install numpy opencv-python torch scikit-learn matplotlib")
+    sys.exit(1)
+
+try:
+    from face_recognition import get_similarity, get_face_class
+    print("OK: Face recognition module imported successfully")
+except ImportError as e:
+    print(f"✗ Error importing face_recognition module: {e}")
+    print("Make sure face_recognition.py is in the same directory")
+    sys.exit(1)
+
+def check_model_files():
+    """
+    Check if required model files exist
+    """
+    print("Checking for required model files...")
+    model_files = [
+        'siamese_model.t7',
+        'decision_tree_model.sav', 
+        'face_recognition_scaler.sav'
+    ]
+    
+    missing_files = []
+    for file in model_files:
+        if os.path.exists(file):
+            print(f"OK: Found {file}")
+        else:
+            print(f"ERROR: Missing {file}")
+            missing_files.append(file)
+    
+    if missing_files:
+        print(f"\nWARNING: Missing {len(missing_files)} model files!")
+        print("You need to train and save these models first.")
+        return False
+    else:
+        print("OK: All model files found!")
+        return True
+
+def test_cosine_similarity():
+    """
+    Test function to demonstrate cosine similarity between faces
+    """
+    print("\nTesting Cosine Similarity for Face Recognition")
+    print("=" * 50)
+    
+    # Check if model files exist first
+    if not check_model_files():
+        print("Skipping similarity test due to missing model files.")
+        return
+    
+    # Create sample test images (you can replace these with actual face images)
+    # For demonstration, we'll create random images
+    img1 = np.random.randint(0, 255, (100, 100, 3), dtype=np.uint8)
+    img2 = np.random.randint(0, 255, (100, 100, 3), dtype=np.uint8)
+    
+    print("Sample images created for testing...")
+    
+    try:
+        print("Calling get_similarity function...")
+        # Test cosine similarity
+        similarity_score = get_similarity(img1, img2)
+        print(f"Cosine Similarity Score: {similarity_score:.4f}")
+        
+        # Interpret the similarity score
+        if similarity_score > 0.8:
+            print("Result: Very High Similarity (likely same person)")
+        elif similarity_score > 0.6:
+            print("Result: High Similarity (possibly same person)")
+        elif similarity_score > 0.4:
+            print("Result: Moderate Similarity (uncertain)")
+        elif similarity_score > 0.2:
+            print("Result: Low Similarity (likely different persons)")
+        else:
+            print("Result: Very Low Similarity (definitely different persons)")
+            
+    except Exception as e:
+        print(f"ERROR: Error during similarity calculation: {e}")
+        print("Full error details:")
+        traceback.print_exc()
+        print("\nTroubleshooting tips:")
+        print("1. Make sure your model files are properly trained and saved")
+        print("2. Check that PyTorch is installed correctly")
+        print("3. Verify the model architecture matches your saved model")
+    
+    print("\n" + "=" * 50)
+    print("Cosine Similarity Test Complete!")
+    print("\nKey Points about Cosine Similarity:")
+    print("- Range: -1 to +1")
+    print("- +1: Identical faces (same person)")
+    print("- 0: No similarity (orthogonal vectors)")
+    print("- -1: Completely opposite (different persons)")
+    print("- Values closer to +1 indicate higher similarity")
+
+def test_face_classification():
+    """
+    Test function to demonstrate face classification
+    """
+    print("\nTesting Face Classification")
+    print("=" * 30)
+    
+    # Check if model files exist first
+    if not check_model_files():
+        print("Skipping classification test due to missing model files.")
+        return
+    
+    # Create sample test image
+    img = np.random.randint(0, 255, (100, 100, 3), dtype=np.uint8)
+    
+    try:
+        print("Calling get_face_class function...")
+        # Test face classification
+        predicted_class = get_face_class(img)
+        print(f"Predicted Face Class: {predicted_class}")
+        
+    except Exception as e:
+        print(f"ERROR: Error during face classification: {e}")
+        print("Full error details:")
+        traceback.print_exc()
+        print("\nTroubleshooting tips:")
+        print("1. Make sure your classifier and scaler files are properly trained")
+        print("2. Check that joblib is installed correctly")
+        print("3. Verify the scaler was trained on the same embedding format")
+
+if __name__ == "__main__":
+    # Run the tests
+    test_cosine_similarity()
+    test_face_classification()
+    
+    print("\n" + "=" * 60)
+    print("IMPORTANT NOTES:")
+    print("1. This is a demonstration with random images")
+    print("2. For real testing, use actual face images")
+    print("3. Make sure your model files are trained and saved:")
+    print("   - siamese_model.t7")
+    print("   - decision_tree_model.sav") 
+    print("   - face_recognition_scaler.sav")
+    print("4. The cosine similarity will work best with properly trained models")