change

app/Hackathon_setup/face_recognition.py

@@ -43,53 +43,14 @@ trnscm = transforms.Compose([
     transforms.Resize((100, 100)),
     transforms.ToTensor()
 ])
-CLASS_NAMES = ['Person1', 'Person2'] # Only 2 persons
+CLASS_NAMES = ['Person1', 'Person2','Person3,'Person4'] # Only 2 persons
 
 # --- Model Filenames ---
 SIAMESE_MODEL_PATH = current_path + '/siamese_model.t7'
 DECISION_TREE_MODEL_PATH = current_path + '/decision_tree_model.sav'
 SCALER_PATH = current_path + '/decision_scaler.sav'
 
-def create_fallback_model():
-    """Create a fallback Decision Tree model for Hugging Face deployment"""
-    try:
-        from sklearn.tree import DecisionTreeClassifier
-        from sklearn.preprocessing import StandardScaler
-        
-        print("Creating fallback Decision Tree model...")
-        
-        # Create dummy training data - use 5 features based on debug output
-        n_features = 5  # Based on debug output showing 5 features
-        n_samples = 300
-        
-        # Generate training data
-        np.random.seed(42)
-        X_train = np.random.randn(n_samples, n_features)
-        
-        # Create balanced labels (0, 1 for Person1, Person2)
-        y_train = np.array([0] * 150 + [1] * 150)
-        np.random.shuffle(y_train)
-        
-        # Create and fit scaler
-        scaler = StandardScaler()
-        X_train_scaled = scaler.fit_transform(X_train)
-        
-        # Create and fit Decision Tree
-        classifier = DecisionTreeClassifier(
-            criterion='gini',
-            max_depth=10,
-            random_state=42
-        )
-        classifier.fit(X_train_scaled, y_train)
-        
-        print(f"✓ Fallback model created with classes: {classifier.classes_}")
-        print(f"✓ Fallback model features: {scaler.n_features_in_}")
-        print(f"✓ Model trained for 2 persons: Person1 and Person2")
-        return scaler, classifier
-        
-    except Exception as e:
-        print(f"Failed to create fallback model: {e}")
-        return None, None
+
 
 def safe_cosine_similarity(embed1, embed2):
     """Calculate cosine similarity with fallback methods"""
@@ -265,17 +226,18 @@ def get_similarity(img1, img2):
         return -1.0
 
 def get_face_class(img1):
-    """Get face class for a single image"""
+    """Get face class for a single image, prioritizing pre-trained models."""
     device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
     
     try:
+        # --- (Face Detection and Siamese Feature Extraction remain the same) ---
         det_img1 = detected_face(img1)
         if det_img1 is None:
             det_img1 = Image.fromarray(cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY))
-        
+            
         face1_tensor = trnscm(det_img1).unsqueeze(0).to(device)
         
-        # Load Siamese Network
+        # Load Siamese Network (assuming this works)
         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:
@@ -290,106 +252,58 @@ def get_face_class(img1):
             if embedding_np.ndim == 1:
                 embedding_np = embedding_np.reshape(1, -1)
         
-        # Load classifier and scaler with fallback methods
+        # --- CRITICAL LOADING BLOCK: Focus on your .sav files ---
         scaler = None
         classifier = None
         
-        # Load models with comprehensive error handling
         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("✓ Loaded models successfully")
+            print("✓ Successfully loaded pre-trained models via joblib.")
             
-            # Check if classifier is corrupted (contains class definition instead of instance)
-            if hasattr(classifier, '__module__') and 'sklearn' in str(type(classifier)):
-                print("❌ Classifier appears to be corrupted (contains class definition)")
-                raise ValueError("Corrupted classifier model")
+        except FileNotFoundError as fnfe:
+            print(f"❌ Model/Scaler file not found: {fnfe}")
+            return "UNKNOWN_CLASS" # Stop if files aren't found
             
-            # Validate the models
-            if not hasattr(classifier, 'predict'):
-                print("❌ Classifier doesn't have predict method")
-                raise ValueError("Invalid classifier")
-            
-            if not hasattr(scaler, 'transform'):
-                print("❌ Scaler doesn't have transform method")
-                raise ValueError("Invalid scaler")
-            
-            # Check if classifier has classes_ attribute (indicates it's trained)
-            if not hasattr(classifier, 'classes_'):
-                print("❌ Classifier doesn't have classes_ attribute (not trained)")
-                raise ValueError("Untrained classifier")
-            
-                
         except Exception as e:
-            print(f"Failed to load models: {e}")
-            # Try to create a fallback model
-            print("Attempting to create fallback model...")
+            # 2. Try pickle loading (fallback for serialization issues)
+            print(f"⚠️ Joblib/SAV loading failed: {e}. Trying raw pickle...")
             try:
-                scaler, classifier = create_fallback_model()
-                if scaler is None or classifier is None:
-                    return "UNKNOWN_CLASS"
-            except Exception as fallback_error:
-                print(f"Fallback model creation failed: {fallback_error}")
-                return "UNKNOWN_CLASS"
-        
-        if scaler is None or classifier is None:
-            print("Failed to load any sklearn models")
+                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" 
+
+        # --- 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.")
             return "UNKNOWN_CLASS"
-        
-        # Preprocess and predict
+
+        # --- Prediction (Standard Code) ---
         embedding_scaled = scaler.transform(embedding_np)
         
-        # Fix for Decision Tree predict method - ensure proper input format
-        try:
-            # Ensure the input is in the correct format for Decision Tree
-            if hasattr(classifier, 'predict'):
-                # For Decision Tree, make sure input is 2D array
-                if embedding_scaled.ndim == 1:
-                    embedding_scaled = embedding_scaled.reshape(1, -1)
-                predicted_label_index = classifier.predict(embedding_scaled)[0]
-            else:
-                print("Classifier doesn't have predict method")
-                return "UNKNOWN_CLASS"
-        except Exception as predict_error:
-            print(f"Prediction error: {predict_error}")
-            # Try alternative prediction method
-            try:
-                # Try with explicit X parameter
-                predicted_label_index = classifier.predict(X=embedding_scaled)[0]
-            except Exception as e2:
-                print(f"Alternative prediction also failed: {e2}")
-                return "UNKNOWN_CLASS"
+        # 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]
         
-        # Map to class name - Decision Tree returns class indices directly
-        # Convert prediction to int if it's not already
+        # --- Map to class name ---
         try:
             predicted_label_index = int(predicted_label_index)
-        except (ValueError, TypeError):
-            return "UNKNOWN_CLASS"
-        
-        # Method 1: Check if the prediction is valid using classifier classes
-        if hasattr(classifier, 'classes_') and predicted_label_index in classifier.classes_:
-            # Find the index of the predicted class in the classifier's classes
-            class_index = list(classifier.classes_).index(predicted_label_index)
-            if class_index < len(CLASS_NAMES):
-                class_name = CLASS_NAMES[class_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"
-        
-        # Method 2: Direct index mapping (fallback)
-        if 0 <= predicted_label_index < len(CLASS_NAMES):
-            class_name = CLASS_NAMES[predicted_label_index]
-            return class_name
-        
-        # Method 3: Handle edge cases - return a default class based on prediction modulo
-        if isinstance(predicted_label_index, (int, np.integer)):
-            default_index = predicted_label_index % len(CLASS_NAMES)
-            class_name = CLASS_NAMES[default_index]
-            return class_name
-        
-        return "UNKNOWN_CLASS"
+        except (ValueError, TypeError):
+            return "UNKNOWN_CLASS"
             
     except Exception as e:
-        print(f"Error in get_face_class: {e}")
+        print(f"Error in get_face_class (Main): {e}")
         return f"Error: {str(e)}"

app/Hackathon_setup/face_recognition_model.py

@@ -78,4 +78,4 @@ except Exception as e:
     classifier = None
 
 # Definition of classes as dictionary
-classes = ['Person1','Person2']
+classes = ['Person1','Person2','Person3','Person4']