1

app/Hackathon_setup/face_recognition.py

@@ -226,86 +226,92 @@ def get_similarity(img1, img2):
         return -1.0
 
 def get_face_class(img1):
-    """Get face class for a single image, prioritizing pre-trained models."""
+    """Get face class for a single image with detailed debugging."""
     device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
     
     try:
-        # --- (Face Detection and Siamese Feature Extraction remain the same) ---
+        # --- Face Detection ---
         det_img1 = detected_face(img1)
         if det_img1 is None:
+            print("⚠️ No face detected, using grayscale fallback.")
             det_img1 = Image.fromarray(cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY))
             
         face1_tensor = trnscm(det_img1).unsqueeze(0).to(device)
-        
-        # Load Siamese Network (assuming this works)
+        print(f"🧩 Face tensor shape: {face1_tensor.shape}")
+
+        # --- Load Siamese Model ---
         siamese_net = Siamese().to(device)
         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'])
+            print("✓ Siamese model loaded (from net_dict key).")
         else:
             siamese_net.load_state_dict(model_data)
+            print("✓ Siamese model loaded (direct state_dict).")
+
         siamese_net.eval()
-        
-        # Extract embedding
+
+        # --- Extract Embedding ---
         with torch.no_grad():
             embedding_np = siamese_net.forward_once(face1_tensor).cpu().numpy()
-            if embedding_np.ndim == 1:
-                embedding_np = embedding_np.reshape(1, -1)
-        
-        # --- CRITICAL LOADING BLOCK: Focus on your .sav files ---
-        scaler = None
-        classifier = None
-        
+
+        print(f"🧠 Raw embedding shape: {embedding_np.shape}")
+        print(f"🧮 Embedding mean={np.mean(embedding_np):.5f}, std={np.std(embedding_np):.5f}")
+
+        if embedding_np.ndim == 1:
+            embedding_np = embedding_np.reshape(1, -1)
+
+        # --- Load Scaler and Classifier ---
         try:
-            # 1. Try joblib/sav loading (most likely format)
             scaler = safe_load_model(SCALER_PATH, "joblib")
             classifier = safe_load_model(DECISION_TREE_MODEL_PATH, "joblib")
-            print("✓ Successfully loaded pre-trained models via joblib.")
-            
-        except FileNotFoundError as fnfe:
-            print(f"❌ Model/Scaler file not found: {fnfe}")
-            return "UNKNOWN_CLASS" # Stop if files aren't found
-            
+            print("✓ Loaded scaler and classifier via joblib.")
         except Exception as e:
-            # 2. Try pickle loading (fallback for serialization issues)
-            print(f"⚠️ Joblib/SAV loading failed: {e}. Trying raw pickle...")
-            try:
-                scaler = safe_load_model(SCALER_PATH, "pickle")
-                classifier = safe_load_model(DECISION_TREE_MODEL_PATH, "pickle")
-                print("✓ Successfully loaded pre-trained models via raw pickle.")
-            except Exception as e_pickle:
-                print(f"❌ Raw pickle loading failed: {e_pickle}")
-                # Use UNKNOWN_CLASS instead of generating a new model
-                return "UNKNOWN_CLASS" 
+            print(f"⚠️ Joblib load failed: {e}, trying pickle...")
+            scaler = safe_load_model(SCALER_PATH, "pickle")
+            classifier = safe_load_model(DECISION_TREE_MODEL_PATH, "pickle")
+
+        # --- Validate Objects ---
+        if not hasattr(scaler, 'transform'):
+            print("❌ Scaler missing transform() — corrupted file?")
+            return "UNKNOWN_CLASS"
+        if not hasattr(classifier, 'predict'):
+            print("❌ Classifier missing predict() — corrupted file?")
+            return "UNKNOWN_CLASS"
 
-        # --- Validation (Ensure loaded object has required methods) ---
-        if not hasattr(classifier, 'predict') or not hasattr(scaler, 'transform'):
-            print("❌ Loaded model/scaler object is corrupted or invalid.")
+        # --- Transform Embedding ---
+        try:
+            embedding_scaled = scaler.transform(embedding_np)
+        except Exception as e:
+            print(f"❌ Scaler transform failed: {e}")
             return "UNKNOWN_CLASS"
 
-        # --- Prediction (Standard Code) ---
-        embedding_scaled = scaler.transform(embedding_np)
-        print("embedding_scaled", embedding_scaled)
-        
-        # Ensure 2D input for prediction
-        if embedding_scaled.ndim == 1:
-            embedding_scaled = embedding_scaled.reshape(1, -1)
-            
-        predicted_label_index = classifier.predict(embedding_scaled)[0]
-        print("Before converting to int", {predicted_label_index} )
-        
-        # --- Map to class name ---
+        print(f"⚙️ Scaled embedding (first 5 vals): {embedding_scaled[0, :5]}")
+        print(f"⚙️ Scaled embedding mean={np.mean(embedding_scaled):.5f}, std={np.std(embedding_scaled):.5f}")
+
+        # --- Predict Class ---
         try:
-            predicted_label_index = int(predicted_label_index)
-            if 0 <= predicted_label_index < len(CLASS_NAMES):
-                class_name = CLASS_NAMES[predicted_label_index]
-                print(f"Prediction: Index {predicted_label_index} -> {class_name}")
-                return class_name
-            else:
-                return "UNKNOWN_CLASS"
-        except (ValueError, TypeError):
+            prediction = classifier.predict(embedding_scaled)
+            print(f"🧾 Raw classifier prediction: {prediction}")
+            if hasattr(classifier, 'predict_proba'):
+                proba = classifier.predict_proba(embedding_scaled)
+                print(f"📊 Prediction probabilities: {np.round(proba, 3)}")
+        except Exception as e:
+            print(f"❌ Prediction failed: {e}")
             return "UNKNOWN_CLASS"
-            
+
+        predicted_label_index = int(prediction[0])
+
+        # --- Map Index to Class Name ---
+        if 0 <= predicted_label_index < len(CLASS_NAMES):
+            class_name = CLASS_NAMES[predicted_label_index]
+            print(f"✅ Final Prediction: Index {predicted_label_index} -> {class_name}")
+            return class_name
+        else:
+            print(f"⚠️ Invalid class index: {predicted_label_index}")
+            return "UNKNOWN_CLASS"
+
     except Exception as e:
-        print(f"Error in get_face_class (Main): {e}")
+        print(f"💥 Error in get_face_class(): {e}")
         return f"Error: {str(e)}"