Deploy changes

app/Hackathon_setup/deep_debug_classification.py

@@ -0,0 +1,174 @@
+"""
+Deep debugging script to find why UNKNOWN_CLASS still occurs
+"""
+
+import os
+import sys
+import numpy as np
+import cv2
+from PIL import Image
+import traceback
+
+# Add current directory to path
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+def deep_debug_classification():
+    """Deep debug the classification process step by step"""
+    print("Deep Debug: Face Classification Process")
+    print("=" * 50)
+    
+    try:
+        # Step 1: Check model files
+        print("1. Checking model files...")
+        model_files = {
+            'siamese_model.t7': 'Siamese network',
+            'decision_tree_model.sav': 'DecisionTree classifier', 
+            'face_recognition_scaler.sav': 'Feature scaler'
+        }
+        
+        for file, desc in model_files.items():
+            if os.path.exists(file):
+                size = os.path.getsize(file)
+                print(f"   ✓ {file} exists ({size} bytes) - {desc}")
+            else:
+                print(f"   ✗ {file} missing - {desc}")
+        
+        # Step 2: Check classifier classes
+        print("\n2. Checking classifier classes...")
+        try:
+            import joblib
+            classifier = joblib.load('decision_tree_model.sav')
+            scaler = joblib.load('face_recognition_scaler.sav')
+            
+            print(f"   Classifier classes: {classifier.classes_}")
+            print(f"   Number of classes: {len(classifier.classes_)}")
+            print(f"   Class range: {min(classifier.classes_)} to {max(classifier.classes_)}")
+            print(f"   Scaler features: {scaler.n_features_in_}")
+            
+        except Exception as e:
+            print(f"   ✗ Error loading models: {e}")
+            return
+        
+        # Step 3: Check CLASS_NAMES
+        print("\n3. Checking CLASS_NAMES...")
+        try:
+            from face_recognition import CLASS_NAMES
+            print(f"   CLASS_NAMES: {CLASS_NAMES}")
+            print(f"   Number of CLASS_NAMES: {len(CLASS_NAMES)}")
+            
+            # Check if CLASS_NAMES length matches classifier classes
+            if len(CLASS_NAMES) == len(classifier.classes_):
+                print("   ✓ CLASS_NAMES length matches classifier classes")
+            else:
+                print(f"   ✗ Length mismatch: CLASS_NAMES={len(CLASS_NAMES)}, classifier={len(classifier.classes_)}")
+                
+        except Exception as e:
+            print(f"   ✗ Error checking CLASS_NAMES: {e}")
+        
+        # Step 4: Test with actual image
+        print("\n4. Testing with actual Person1 image...")
+        actual_image_path = "../static/Person1_1697805233.jpg"
+        if os.path.exists(actual_image_path):
+            print(f"   ✓ Found actual image: {actual_image_path}")
+            
+            try:
+                # Load image
+                img = cv2.imread(actual_image_path)
+                print(f"   Image shape: {img.shape}")
+                
+                # Test face detection
+                from face_recognition import detected_face
+                detected = detected_face(img)
+                print(f"   Face detected: {type(detected)}")
+                
+                # Test full classification
+                from face_recognition import get_face_class
+                result = get_face_class(img)
+                print(f"   Classification result: {result}")
+                
+                # Debug the classification process step by step
+                print("\n5. Step-by-step classification debug...")
+                debug_classification_step_by_step(img)
+                
+            except Exception as e:
+                print(f"   ✗ Error with actual image: {e}")
+                traceback.print_exc()
+        else:
+            print(f"   ✗ No actual image found at {actual_image_path}")
+            
+    except Exception as e:
+        print(f"✗ Error in deep debug: {e}")
+        traceback.print_exc()
+
+def debug_classification_step_by_step(img):
+    """Debug the classification process step by step"""
+    try:
+        import torch
+        from face_recognition import detected_face, trnscm, CLASS_NAMES
+        from face_recognition_model import Siamese
+        
+        print("   Step 1: Face detection...")
+        det_img = detected_face(img)
+        if det_img == 0:
+            det_img = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2GRAY))
+        print(f"     Detected face type: {type(det_img)}")
+        
+        print("   Step 2: Image transformation...")
+        face_tensor = trnscm(det_img).unsqueeze(0)
+        print(f"     Tensor shape: {face_tensor.shape}")
+        
+        print("   Step 3: Siamese network...")
+        device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+        siamese_net = Siamese().to(device)
+        
+        # Load model
+        model_data = torch.load('siamese_model.t7', 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()
+        
+        print("   Step 4: Feature extraction...")
+        with torch.no_grad():
+            embedding = siamese_net.forward_once(face_tensor.to(device)).cpu().numpy()
+            print(f"     Embedding shape: {embedding.shape}")
+            print(f"     Embedding values: {embedding}")
+        
+        print("   Step 5: Classification...")
+        import joblib
+        scaler = joblib.load('face_recognition_scaler.sav')
+        classifier = joblib.load('decision_tree_model.sav')
+        
+        # Reshape embedding if needed
+        if embedding.ndim == 1:
+            embedding = embedding.reshape(1, -1)
+        
+        print(f"     Embedding after reshape: {embedding.shape}")
+        
+        # Scale features
+        embedding_scaled = scaler.transform(embedding)
+        print(f"     Scaled embedding: {embedding_scaled}")
+        
+        # Predict
+        predicted_label_index = classifier.predict(embedding_scaled)[0]
+        print(f"     Predicted index: {predicted_label_index}")
+        print(f"     Classifier classes: {classifier.classes_}")
+        
+        # Map to class name
+        print(f"     CLASS_NAMES: {CLASS_NAMES}")
+        print(f"     CLASS_NAMES length: {len(CLASS_NAMES)}")
+        
+        if predicted_label_index < len(CLASS_NAMES):
+            class_name = CLASS_NAMES[predicted_label_index]
+            print(f"     ✓ Mapped to: {class_name}")
+        else:
+            print(f"     ✗ Index {predicted_label_index} is out of range!")
+            print(f"     ✗ This causes UNKNOWN_CLASS!")
+            
+    except Exception as e:
+        print(f"   ✗ Error in step-by-step debug: {e}")
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    deep_debug_classification()

app/Hackathon_setup/face_recognition.py

@@ -121,16 +121,23 @@ def detected_face(image):
     
     gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
     faces = face_cascade.detectMultiScale(gray, 1.3, 5)
+    
+    # If no faces detected, return None
+    if len(faces) == 0:
+        print("No faces detected, using fallback")
+        return None
+    
     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)
+    
+    # Get the largest face
+    largest_face_idx = np.argmax(face_areas)
+    required_image = Image.fromarray(images[largest_face_idx])
     
     return required_image
 
@@ -141,7 +148,7 @@ def get_similarity(img1, img2):
     try:
         det_img1 = detected_face(img1)
         det_img2 = detected_face(img2)
-        if det_img1 == 0 or det_img2 == 0:
+        if det_img1 is None or det_img2 is None:
             det_img1 = Image.fromarray(cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY))
             det_img2 = Image.fromarray(cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY))
         
@@ -176,7 +183,7 @@ def get_face_class(img1):
     
     try:
         det_img1 = detected_face(img1)
-        if det_img1 == 0:
+        if det_img1 is None:
             det_img1 = Image.fromarray(cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY))
         
         face1_tensor = trnscm(det_img1).unsqueeze(0).to(device)

app/Hackathon_setup/test_complete_fix.py

@@ -0,0 +1,208 @@
+"""
+Comprehensive test to verify all fixes for UNKNOWN_CLASS issue
+"""
+
+import os
+import sys
+import numpy as np
+import cv2
+from PIL import Image
+
+# Add current directory to path
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+def test_complete_fix():
+    """Test all fixes comprehensively"""
+    print("Comprehensive Test: All UNKNOWN_CLASS Fixes")
+    print("=" * 60)
+    
+    # Test 1: Check all components
+    print("1. Checking all components...")
+    
+    try:
+        from face_recognition import get_face_class, CLASS_NAMES, detected_face
+        from face_recognition_model import classes
+        import joblib
+        
+        print(f"   ✓ face_recognition imported successfully")
+        print(f"   ✓ CLASS_NAMES: {CLASS_NAMES}")
+        print(f"   ✓ classes: {classes}")
+        
+        # Check consistency
+        if CLASS_NAMES == classes:
+            print("   ✓ Class names are consistent")
+        else:
+            print("   ✗ Class names are inconsistent")
+        
+        # Check classifier
+        classifier = joblib.load('decision_tree_model.sav')
+        scaler = joblib.load('face_recognition_scaler.sav')
+        print(f"   ✓ Classifier loaded: {len(classifier.classes_)} classes")
+        print(f"   ✓ Scaler loaded: {scaler.n_features_in_} features")
+        
+    except Exception as e:
+        print(f"   ✗ Error importing components: {e}")
+        return
+    
+    # Test 2: Test face detection
+    print("\n2. Testing face detection...")
+    
+    # Create test image with face
+    test_img = create_test_face_image()
+    print(f"   Test image shape: {test_img.shape}")
+    
+    try:
+        detected = detected_face(test_img)
+        if detected is not None:
+            print(f"   ✓ Face detected successfully: {type(detected)}")
+        else:
+            print("   ⚠ No face detected, will use fallback")
+    except Exception as e:
+        print(f"   ✗ Error in face detection: {e}")
+    
+    # Test 3: Test classification with synthetic images
+    print("\n3. Testing classification with synthetic images...")
+    
+    for i in range(1, 8):  # Person1-Person7
+        print(f"\n   Testing Person{i}:")
+        
+        # Create synthetic face
+        face_img = create_test_face_image(i)
+        
+        try:
+            result = get_face_class(face_img)
+            print(f"     Input: Person{i} synthetic image")
+            print(f"     Output: {result}")
+            
+            if result in CLASS_NAMES:
+                print(f"     ✓ Valid classification: {result}")
+            elif result == "UNKNOWN_CLASS":
+                print(f"     ✗ Still getting UNKNOWN_CLASS!")
+            elif result.startswith("Error:"):
+                print(f"     ✗ Error: {result}")
+            else:
+                print(f"     ? Unexpected result: {result}")
+                
+        except Exception as e:
+            print(f"     ✗ Exception: {e}")
+    
+    # Test 4: Test with actual image
+    print("\n4. Testing with actual Person1 image...")
+    actual_image_path = "../static/Person1_1697805233.jpg"
+    
+    if os.path.exists(actual_image_path):
+        try:
+            img = cv2.imread(actual_image_path)
+            print(f"   ✓ Loaded actual image: {img.shape}")
+            
+            result = get_face_class(img)
+            print(f"   Result: {result}")
+            
+            if result == "Person1":
+                print("   🎉 PERFECT! Person1 correctly classified!")
+            elif result in CLASS_NAMES:
+                print(f"   ✓ Valid classification: {result}")
+            elif result == "UNKNOWN_CLASS":
+                print("   ✗ Still getting UNKNOWN_CLASS")
+            else:
+                print(f"   ? Unexpected: {result}")
+                
+        except Exception as e:
+            print(f"   ✗ Error with actual image: {e}")
+            import traceback
+            traceback.print_exc()
+    else:
+        print(f"   ⚠ No actual image found at {actual_image_path}")
+    
+    # Test 5: Debug step by step
+    print("\n5. Step-by-step debug...")
+    debug_step_by_step(test_img)
+    
+    print("\n" + "=" * 60)
+    print("Test completed!")
+
+def create_test_face_image(person_id=1):
+    """Create a test face image"""
+    img = np.zeros((100, 100, 3), dtype=np.uint8)
+    
+    # Face outline
+    cv2.ellipse(img, (50, 50), (40, 50), 0, 0, 360, (120, 120, 120), -1)
+    
+    # Vary features based on person_id
+    eye_offset = (person_id - 1) * 3
+    mouth_width = 10 + (person_id - 1) * 2
+    
+    # Eyes
+    cv2.circle(img, (35 + eye_offset, 40), 4, (200, 200, 200), -1)
+    cv2.circle(img, (65 - eye_offset, 40), 4, (200, 200, 200), -1)
+    
+    # Nose
+    cv2.line(img, (50, 45), (50, 60), (150, 150, 150), 2)
+    
+    # Mouth
+    cv2.ellipse(img, (50, 70), (mouth_width, 6), 0, 0, 180, (150, 150, 150), 2)
+    
+    return img
+
+def debug_step_by_step(img):
+    """Debug the classification process step by step"""
+    try:
+        import torch
+        from face_recognition import detected_face, trnscm, CLASS_NAMES
+        from face_recognition_model import Siamese
+        import joblib
+        
+        print("   Step 1: Face detection...")
+        det_img = detected_face(img)
+        if det_img is None:
+            print("     No face detected, using fallback")
+            det_img = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2GRAY))
+        print(f"     Face type: {type(det_img)}")
+        
+        print("   Step 2: Image transformation...")
+        face_tensor = trnscm(det_img).unsqueeze(0)
+        print(f"     Tensor shape: {face_tensor.shape}")
+        
+        print("   Step 3: Siamese network...")
+        device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+        siamese_net = Siamese().to(device)
+        
+        model_data = torch.load('siamese_model.t7', 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()
+        
+        print("   Step 4: Feature extraction...")
+        with torch.no_grad():
+            embedding = siamese_net.forward_once(face_tensor.to(device)).cpu().numpy()
+            print(f"     Embedding shape: {embedding.shape}")
+        
+        print("   Step 5: Classification...")
+        scaler = joblib.load('face_recognition_scaler.sav')
+        classifier = joblib.load('decision_tree_model.sav')
+        
+        if embedding.ndim == 1:
+            embedding = embedding.reshape(1, -1)
+        
+        embedding_scaled = scaler.transform(embedding)
+        predicted_label_index = classifier.predict(embedding_scaled)[0]
+        
+        print(f"     Predicted index: {predicted_label_index}")
+        print(f"     Classifier classes: {classifier.classes_}")
+        print(f"     CLASS_NAMES: {CLASS_NAMES}")
+        
+        if predicted_label_index < len(CLASS_NAMES):
+            class_name = CLASS_NAMES[predicted_label_index]
+            print(f"     ✓ Final result: {class_name}")
+        else:
+            print(f"     ✗ Index {predicted_label_index} out of range!")
+            
+    except Exception as e:
+        print(f"   ✗ Error in debug: {e}")
+        import traceback
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    test_complete_fix()