change

app/Hackathon_setup/analyze_face_detection.py

@@ -1,248 +0,0 @@
-"""
-Analyze face detection issues and improve face recognition pipeline
-"""
-
-import os
-import sys
-import numpy as np
-import cv2
-from PIL import Image
-
-print("🔍 Face Detection Analysis & Improvement")
-print("=" * 50)
-
-def analyze_face_detection_issue():
-    """Analyze why face detection is failing"""
-    
-    print("📊 Current Issue Analysis:")
-    print("   - Logs show: 'No faces detected, using fallback'")
-    print("   - This means OpenCV face detection is failing")
-    print("   - System falls back to using entire image")
-    print("   - Classification still works but may be less accurate")
-    print()
-    
-    print("🔍 Possible Causes:")
-    print("   1. Face cascade file issues")
-    print("   2. Image quality/resolution problems")
-    print("   3. Face detection parameters too strict")
-    print("   4. Images don't contain clear frontal faces")
-    print("   5. Cascade classifier not loading properly")
-    print()
-
-def check_cascade_files():
-    """Check if cascade files are working properly"""
-    
-    print("🔧 Checking Cascade Files...")
-    
-    cascade_files = [
-        'haarcascade_frontalface_default.xml',
-        'haarcascade_eye.xml'
-    ]
-    
-    for file in cascade_files:
-        if os.path.exists(file):
-            size = os.path.getsize(file)
-            print(f"   ✓ {file} exists ({size:,} bytes)")
-            
-            # Test loading
-            try:
-                cascade = cv2.CascadeClassifier(file)
-                if cascade.empty():
-                    print(f"   ❌ {file} failed to load properly")
-                else:
-                    print(f"   ✅ {file} loaded successfully")
-            except Exception as e:
-                print(f"   ❌ Error loading {file}: {e}")
-        else:
-            print(f"   ❌ {file} missing")
-
-def improve_face_detection():
-    """Improve the face detection function"""
-    
-    print("\n🔧 Improving Face Detection...")
-    
-    # Create improved face detection function
-    improved_code = '''
-def improved_detected_face(image):
-    """Improved face detection with better parameters"""
-    eye_haar = current_path + '/haarcascade_eye.xml'
-    face_haar = current_path + '/haarcascade_frontalface_default.xml'
-    
-    # Check if cascade files exist
-    if not os.path.exists(face_haar):
-        print(f"Warning: {face_haar} not found, using fallback")
-        return Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2GRAY))
-    
-    face_cascade = cv2.CascadeClassifier(face_haar)
-    eye_cascade = cv2.CascadeClassifier(eye_haar) if os.path.exists(eye_haar) else None
-    
-    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-    
-    # Try multiple detection parameters for better results
-    detection_params = [
-        (1.1, 3),   # Default
-        (1.05, 4),  # More sensitive
-        (1.2, 2),   # Less sensitive but faster
-        (1.3, 5)    # Very sensitive
-    ]
-    
-    faces = []
-    for scale_factor, min_neighbors in detection_params:
-        faces = face_cascade.detectMultiScale(
-            gray, 
-            scaleFactor=scale_factor, 
-            minNeighbors=min_neighbors,
-            minSize=(30, 30),  # Minimum face size
-            maxSize=(300, 300) # Maximum face size
-        )
-        if len(faces) > 0:
-            print(f"✓ Faces detected with scaleFactor={scale_factor}, minNeighbors={min_neighbors}")
-            break
-    
-    # If still no faces, try with different image preprocessing
-    if len(faces) == 0:
-        print("No faces detected with standard parameters, trying preprocessing...")
-        
-        # Try histogram equalization
-        gray_eq = cv2.equalizeHist(gray)
-        faces = face_cascade.detectMultiScale(gray_eq, 1.1, 3)
-        
-        if len(faces) == 0:
-            # Try Gaussian blur
-            gray_blur = cv2.GaussianBlur(gray, (3, 3), 0)
-            faces = face_cascade.detectMultiScale(gray_blur, 1.1, 3)
-    
-    if len(faces) == 0:
-        print("No faces detected after all attempts, using fallback")
-        return None
-    
-    # Find the largest face
-    face_areas = []
-    images = []
-    
-    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)
-    
-    # Get the largest face
-    largest_face_idx = np.argmax(face_areas)
-    required_image = Image.fromarray(images[largest_face_idx])
-    
-    print(f"✓ Selected face {largest_face_idx + 1} of {len(faces)} detected faces")
-    
-    return required_image
-'''
-    
-    print("✅ Improved face detection function created")
-    print("   - Multiple detection parameters")
-    print("   - Image preprocessing options")
-    print("   - Better error handling")
-    print("   - More detailed logging")
-
-def create_face_detection_test():
-    """Create a test to verify face detection"""
-    
-    print("\n🧪 Creating Face Detection Test...")
-    
-    test_code = '''
-def test_face_detection():
-    """Test face detection with sample images"""
-    
-    # Test with actual image if available
-    test_paths = [
-        "../static/Person1_1697805233.jpg",
-        "Person1_1697805233.jpg",
-        "static/Person1_1697805233.jpg"
-    ]
-    
-    for path in test_paths:
-        if os.path.exists(path):
-            print(f"Testing face detection with: {path}")
-            
-            # Load image
-            img = cv2.imread(path)
-            print(f"Image shape: {img.shape}")
-            
-            # Test face detection
-            detected = improved_detected_face(img)
-            
-            if detected is not None:
-                print(f"✅ Face detected successfully: {type(detected)}")
-                print(f"Face size: {detected.size}")
-            else:
-                print("❌ No face detected")
-            
-            break
-    else:
-        print("No test images found")
-        
-        # Create synthetic face for testing
-        print("Creating synthetic face for testing...")
-        synthetic_img = np.zeros((200, 200, 3), dtype=np.uint8)
-        
-        # Draw a simple face
-        cv2.ellipse(synthetic_img, (100, 100), (80, 100), 0, 0, 360, (120, 120, 120), -1)
-        cv2.circle(synthetic_img, (70, 80), 8, (200, 200, 200), -1)
-        cv2.circle(synthetic_img, (130, 80), 8, (200, 200, 200), -1)
-        cv2.line(synthetic_img, (100, 90), (100, 120), (150, 150, 150), 3)
-        cv2.ellipse(synthetic_img, (100, 140), (20, 10), 0, 0, 180, (150, 150, 150), 2)
-        
-        print("Testing with synthetic face...")
-        detected = improved_detected_face(synthetic_img)
-        
-        if detected is not None:
-            print("✅ Synthetic face detected successfully")
-        else:
-            print("❌ Even synthetic face not detected - cascade issue")
-'''
-    
-    print("✅ Face detection test created")
-
-def provide_recommendations():
-    """Provide recommendations for better face detection"""
-    
-    print("\n💡 Recommendations for Better Face Detection:")
-    print()
-    print("1. 📸 Image Quality:")
-    print("   - Ensure images have clear, frontal faces")
-    print("   - Good lighting and contrast")
-    print("   - Face should be clearly visible")
-    print("   - Avoid side profiles or partially hidden faces")
-    print()
-    
-    print("2. 🔧 Detection Parameters:")
-    print("   - Try different scaleFactor values (1.05-1.3)")
-    print("   - Adjust minNeighbors (2-5)")
-    print("   - Set appropriate minSize and maxSize")
-    print()
-    
-    print("3. 🖼️ Image Preprocessing:")
-    print("   - Histogram equalization for better contrast")
-    print("   - Gaussian blur to reduce noise")
-    print("   - Resize images to standard size")
-    print()
-    
-    print("4. 📊 Training Data Considerations:")
-    print("   - Your training used face detection during training")
-    print("   - If training images had faces detected, inference should too")
-    print("   - Check if training images were preprocessed differently")
-    print()
-    
-    print("5. 🎯 Current Status:")
-    print("   - ✅ Classification working (Person2 detected)")
-    print("   - ⚠️ Face detection failing (using fallback)")
-    print("   - ✅ System still functional but may be less accurate")
-
-if __name__ == "__main__":
-    analyze_face_detection_issue()
-    check_cascade_files()
-    improve_face_detection()
-    create_face_detection_test()
-    provide_recommendations()
-    
-    print("\n🎯 Summary:")
-    print("Your classification is working correctly (Person2 detected)")
-    print("Face detection is failing but system uses fallback")
-    print("This may reduce accuracy but doesn't break the system")
-    print("Consider improving image quality or detection parameters")

app/Hackathon_setup/analyze_model_bias.py

@@ -1,235 +0,0 @@
-"""
-Analyze and fix model bias issue - always predicting Person2
-"""
-
-import os
-import sys
-import numpy as np
-import joblib
-import torch
-from PIL import Image
-import cv2
-
-print("🔍 Model Bias Analysis - Always Predicting Person2")
-print("=" * 60)
-
-def analyze_model_bias():
-    """Analyze why the model always predicts Person2"""
-    
-    print("📊 Current Issue:")
-    print("   - Face detection now working ✅")
-    print("   - But model always predicts Person2 ❌")
-    print("   - This suggests model bias or training data imbalance")
-    print()
-    
-    try:
-        # Load classifier and scaler
-        classifier = joblib.load('decision_tree_model.sav')
-        scaler = joblib.load('face_recognition_scaler.sav')
-        
-        print("🔍 Model Analysis:")
-        print(f"   Classifier type: {type(classifier)}")
-        print(f"   Classifier classes: {classifier.classes_}")
-        print(f"   Scaler features: {scaler.n_features_in_}")
-        
-        # Check if it's a KNN classifier
-        if hasattr(classifier, 'n_neighbors'):
-            print(f"   KNN neighbors: {classifier.n_neighbors}")
-        
-        # Test with random features
-        print("\n🧪 Testing with random features:")
-        for i in range(5):
-            random_features = np.random.randn(1, scaler.n_features_in_)
-            scaled_features = scaler.transform(random_features)
-            prediction = classifier.predict(scaled_features)[0]
-            print(f"   Random test {i+1}: {prediction}")
-        
-        # Check training data distribution
-        if hasattr(classifier, '_y'):
-            unique, counts = np.unique(classifier._y, return_counts=True)
-            print(f"\n📊 Training data distribution:")
-            for class_id, count in zip(unique, counts):
-                print(f"   Class {class_id}: {count} samples")
-        
-        return True
-        
-    except Exception as e:
-        print(f"❌ Error analyzing model: {e}")
-        return False
-
-def test_feature_extraction():
-    """Test if feature extraction is working properly"""
-    
-    print("\n🔬 Testing Feature Extraction:")
-    
-    try:
-        from face_recognition import detected_face, trnscm, CLASS_NAMES
-        from face_recognition_model import Siamese
-        
-        # Create test images with different characteristics
-        test_images = []
-        
-        # Image 1: Simple face
-        img1 = np.zeros((100, 100, 3), dtype=np.uint8)
-        cv2.ellipse(img1, (50, 50), (40, 50), 0, 0, 360, (120, 120, 120), -1)
-        cv2.circle(img1, (35, 40), 5, (200, 200, 200), -1)
-        cv2.circle(img1, (65, 40), 5, (200, 200, 200), -1)
-        test_images.append(("Simple face", img1))
-        
-        # Image 2: Different face
-        img2 = np.zeros((100, 100, 3), dtype=np.uint8)
-        cv2.ellipse(img2, (50, 50), (40, 50), 0, 0, 360, (100, 100, 100), -1)
-        cv2.circle(img2, (30, 40), 6, (180, 180, 180), -1)
-        cv2.circle(img2, (70, 40), 6, (180, 180, 180), -1)
-        test_images.append(("Different face", img2))
-        
-        # Image 3: Very different face
-        img3 = np.zeros((100, 100, 3), dtype=np.uint8)
-        cv2.ellipse(img3, (50, 50), (35, 45), 0, 0, 360, (140, 140, 140), -1)
-        cv2.circle(img3, (40, 45), 4, (220, 220, 220), -1)
-        cv2.circle(img3, (60, 45), 4, (220, 220, 220), -1)
-        test_images.append(("Very different face", img3))
-        
-        # Test each image
-        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("   Testing feature extraction with different images:")
-        
-        for name, img in test_images:
-            # Face detection
-            detected = detected_face(img)
-            if detected is None:
-                detected = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2GRAY))
-            
-            # Transform
-            face_tensor = trnscm(detected).unsqueeze(0).to(device)
-            
-            # Extract features
-            with torch.no_grad():
-                embedding = siamese_net.forward_once(face_tensor).cpu().numpy()
-                if embedding.ndim == 1:
-                    embedding = embedding.reshape(1, -1)
-            
-            print(f"     {name}: embedding shape {embedding.shape}, values {embedding.flatten()[:3]}")
-        
-        return True
-        
-    except Exception as e:
-        print(f"❌ Error testing feature extraction: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-def diagnose_classification_pipeline():
-    """Diagnose the entire classification pipeline"""
-    
-    print("\n🔧 Diagnosing Classification Pipeline:")
-    
-    try:
-        from face_recognition import get_face_class
-        
-        # Test with different synthetic images
-        test_cases = [
-            ("Person1-like", create_person1_like_image()),
-            ("Person2-like", create_person2_like_image()),
-            ("Person3-like", create_person3_like_image())
-        ]
-        
-        for name, img in test_cases:
-            result = get_face_class(img)
-            print(f"   {name}: {result}")
-        
-        return True
-        
-    except Exception as e:
-        print(f"❌ Error in classification pipeline: {e}")
-        return False
-
-def create_person1_like_image():
-    """Create an image that should look like Person1"""
-    img = np.zeros((100, 100, 3), dtype=np.uint8)
-    cv2.ellipse(img, (50, 50), (40, 50), 0, 0, 360, (120, 120, 120), -1)
-    cv2.circle(img, (35, 40), 5, (200, 200, 200), -1)
-    cv2.circle(img, (65, 40), 5, (200, 200, 200), -1)
-    cv2.line(img, (50, 45), (50, 60), (150, 150, 150), 2)
-    cv2.ellipse(img, (50, 70), (15, 8), 0, 0, 180, (150, 150, 150), 2)
-    return img
-
-def create_person2_like_image():
-    """Create an image that should look like Person2"""
-    img = np.zeros((100, 100, 3), dtype=np.uint8)
-    cv2.ellipse(img, (50, 50), (40, 50), 0, 0, 360, (100, 100, 100), -1)
-    cv2.circle(img, (30, 40), 6, (180, 180, 180), -1)
-    cv2.circle(img, (70, 40), 6, (180, 180, 180), -1)
-    cv2.line(img, (50, 45), (50, 60), (140, 140, 140), 2)
-    cv2.ellipse(img, (50, 70), (18, 10), 0, 0, 180, (140, 140, 140), 2)
-    return img
-
-def create_person3_like_image():
-    """Create an image that should look like Person3"""
-    img = np.zeros((100, 100, 3), dtype=np.uint8)
-    cv2.ellipse(img, (50, 50), (35, 45), 0, 0, 360, (140, 140, 140), -1)
-    cv2.circle(img, (40, 45), 4, (220, 220, 220), -1)
-    cv2.circle(img, (60, 45), 4, (220, 220, 220), -1)
-    cv2.line(img, (50, 45), (50, 60), (160, 160, 160), 2)
-    cv2.ellipse(img, (50, 70), (12, 6), 0, 0, 180, (160, 160, 160), 2)
-    return img
-
-def provide_solutions():
-    """Provide solutions for the Person2 bias issue"""
-    
-    print("\n💡 Solutions for Person2 Bias Issue:")
-    print()
-    print("1. 🎯 Model Bias Causes:")
-    print("   - Training data heavily skewed toward Person2")
-    print("   - Person2 had 100% precision/recall in training")
-    print("   - Model learned to favor Person2")
-    print("   - Insufficient diversity in Person1 and Person3")
-    print()
-    
-    print("2. 🔧 Immediate Solutions:")
-    print("   - Retrain with balanced data (equal samples per person)")
-    print("   - Add more Person1 and Person3 training images")
-    print("   - Use data augmentation for minority classes")
-    print("   - Try different k values (k=3 instead of k=5)")
-    print()
-    
-    print("3. 📊 Data Collection:")
-    print("   - Collect 20-30 images per person")
-    print("   - Ensure diverse lighting and angles")
-    print("   - Include different expressions")
-    print("   - Balance the dataset")
-    print()
-    
-    print("4. 🎛️ Model Adjustments:")
-    print("   - Try DecisionTree instead of KNN")
-    print("   - Use class weights to balance")
-    print("   - Experiment with different metrics")
-    print()
-    
-    print("5. 🧪 Quick Test:")
-    print("   - Upload images of different people")
-    print("   - Check if they all get Person2")
-    print("   - If yes, it's definitely model bias")
-
-if __name__ == "__main__":
-    print("Starting Model Bias Analysis...")
-    
-    success1 = analyze_model_bias()
-    success2 = test_feature_extraction()
-    success3 = diagnose_classification_pipeline()
-    provide_solutions()
-    
-    print("\n🎯 Summary:")
-    print("The model is biased toward Person2 due to training data imbalance")
-    print("Person2 had perfect performance in training (100% precision/recall)")
-    print("Need to retrain with balanced data for better performance")

app/Hackathon_setup/app_old.py

@@ -1,135 +0,0 @@
-"""
-Hugging Face Space App for Face Recognition
-"""
-
-import gradio as gr
-import numpy as np
-import cv2
-from PIL import Image
-import torch
-import joblib
-import warnings
-import os
-
-# Suppress sklearn version warnings
-warnings.filterwarnings('ignore', category=UserWarning, module='sklearn')
-warnings.filterwarnings('ignore', message='.*InconsistentVersionWarning.*')
-
-# Import your face recognition functions
-from face_recognition import get_similarity, get_face_class
-
-def predict_similarity(file1, file2):
-    """Predict similarity between two face images"""
-    try:
-        # Convert Gradio file objects to images
-        if file1 is None or file2 is None:
-            return "Please upload both images"
-        
-        # Load images
-        img1 = cv2.imread(file1)
-        img2 = cv2.imread(file2)
-        
-        if img1 is None or img2 is None:
-            return "Error loading images. Please ensure they are valid image files."
-        
-        # Get similarity score
-        similarity_score = get_similarity(img1, img2)
-        
-        # Interpret the result
-        if similarity_score > 0.8:
-            result = f"Very High Similarity ({similarity_score:.4f}) - Likely same person"
-        elif similarity_score > 0.6:
-            result = f"High Similarity ({similarity_score:.4f}) - Possibly same person"
-        elif similarity_score > 0.4:
-            result = f"Moderate Similarity ({similarity_score:.4f}) - Uncertain"
-        elif similarity_score > 0.2:
-            result = f"Low Similarity ({similarity_score:.4f}) - Likely different persons"
-        else:
-            result = f"Very Low Similarity ({similarity_score:.4f}) - Definitely different persons"
-        
-        return result
-        
-    except Exception as e:
-        return f"Error: {str(e)}"
-
-def predict_class(file):
-    """Predict the class of a face image"""
-    try:
-        if file is None:
-            return "Please upload an image"
-        
-        # Load image
-        img = cv2.imread(file)
-        
-        if img is None:
-            return "Error loading image. Please ensure it's a valid image file."
-        
-        # Get face class
-        face_class = get_face_class(img)
-        
-        return f"Predicted Face Class: {face_class}"
-        
-    except Exception as e:
-        return f"Error: {str(e)}"
-
-# Create Gradio interface
-with gr.Blocks(title="Face Recognition System") as demo:
-    gr.Markdown("# Face Recognition System")
-    gr.Markdown("Upload face images to compare similarity or classify faces.")
-    
-    with gr.Tab("Face Similarity"):
-        gr.Markdown("## Compare Two Faces")
-        gr.Markdown("Upload two face images to compare their similarity.")
-        
-        with gr.Row():
-            with gr.Column():
-                img1 = gr.Image(type="filepath", label="First Face Image")
-            with gr.Column():
-                img2 = gr.Image(type="filepath", label="Second Face Image")
-        
-        similarity_btn = gr.Button("Compare Faces", variant="primary")
-        similarity_output = gr.Textbox(label="Similarity Result", interactive=False)
-        
-        similarity_btn.click(
-            fn=predict_similarity,
-            inputs=[img1, img2],
-            outputs=similarity_output
-        )
-    
-    with gr.Tab("Face Classification"):
-        gr.Markdown("## Classify a Face")
-        gr.Markdown("Upload a face image to classify it.")
-        
-        img_class = gr.Image(type="filepath", label="Face Image")
-        class_btn = gr.Button("Classify Face", variant="primary")
-        class_output = gr.Textbox(label="Classification Result", interactive=False)
-        
-        class_btn.click(
-            fn=predict_class,
-            inputs=[img_class],
-            outputs=class_output
-        )
-    
-    with gr.Tab("About"):
-        gr.Markdown("""
-        ## About This Face Recognition System
-        
-        This system uses:
-        - **Siamese Neural Network** for face feature extraction
-        - **Cosine Similarity** for face comparison
-        - **K-Nearest Neighbors** for face classification
-        
-        ### How to Use:
-        1. **Face Similarity**: Upload two face images to compare their similarity
-        2. **Face Classification**: Upload a single face image to classify it
-        
-        ### Similarity Scores:
-        - **0.8-1.0**: Very High Similarity (likely same person)
-        - **0.6-0.8**: High Similarity (possibly same person)
-        - **0.4-0.6**: Moderate Similarity (uncertain)
-        - **0.2-0.4**: Low Similarity (likely different persons)
-        - **0.0-0.2**: Very Low Similarity (definitely different persons)
-        """)
-
-if __name__ == "__main__":
-    demo.launch()

app/Hackathon_setup/apply_final_fix.py

@@ -1,132 +0,0 @@
-"""
-Final fix for UNKNOWN_CLASS issue in face recognition
-This script addresses the most common causes of UNKNOWN_CLASS predictions
-"""
-
-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 apply_final_fix():
-    """Apply the final fix for UNKNOWN_CLASS issue"""
-    print("Applying Final Fix for UNKNOWN_CLASS Issue")
-    print("=" * 50)
-    
-    # 1. Verify CLASS_NAMES consistency
-    print("1. Checking CLASS_NAMES consistency...")
-    try:
-        from face_recognition import CLASS_NAMES
-        from face_recognition_model import classes
-        
-        print(f"   CLASS_NAMES: {CLASS_NAMES}")
-        print(f"   classes: {classes}")
-        
-        if CLASS_NAMES == classes:
-            print("   ✓ Class names are consistent")
-        else:
-            print("   ✗ Class names are inconsistent - fixing...")
-            # Update face_recognition_model.py to match CLASS_NAMES
-            with open('face_recognition_model.py', 'r') as f:
-                content = f.read()
-            
-            # Replace the classes definition
-            old_classes = "classes = ['person1','person2','person3','person4','person5','person6','person7']"
-            new_classes = "classes = ['Person0','Person1','Person2','Person3','Person4','Person5','Person6']"
-            
-            if old_classes in content:
-                content = content.replace(old_classes, new_classes)
-                with open('face_recognition_model.py', 'w') as f:
-                    f.write(content)
-                print("   ✓ Fixed class names in face_recognition_model.py")
-            
-    except Exception as e:
-        print(f"   ✗ Error checking class names: {e}")
-    
-    # 2. Test model loading and prediction
-    print("\n2. Testing model loading and prediction...")
-    try:
-        import joblib
-        
-        # Load models
-        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")
-        
-        # Test prediction with dummy data
-        dummy_features = np.random.randn(1, scaler.n_features_in_)
-        scaled_features = scaler.transform(dummy_features)
-        prediction = classifier.predict(scaled_features)[0]
-        
-        print(f"   ✓ Test prediction: {prediction}")
-        
-        # Check if prediction maps to valid class name
-        if prediction < len(CLASS_NAMES):
-            class_name = CLASS_NAMES[prediction]
-            print(f"   ✓ Maps to: {class_name}")
-        else:
-            print(f"   ✗ Prediction {prediction} is out of range!")
-            
-    except Exception as e:
-        print(f"   ✗ Error testing models: {e}")
-    
-    # 3. Test face recognition with synthetic image
-    print("\n3. Testing face recognition with synthetic image...")
-    try:
-        from face_recognition import get_face_class
-        
-        # Create a synthetic face image
-        synthetic_img = create_test_face_image()
-        
-        # Test classification
-        result = get_face_class(synthetic_img)
-        print(f"   ✓ Classification result: {result}")
-        
-        if result in CLASS_NAMES:
-            print("   ✓ Result is a valid class name - FIX SUCCESSFUL!")
-        elif result == "UNKNOWN_CLASS":
-            print("   ✗ Still getting UNKNOWN_CLASS - need further investigation")
-        else:
-            print(f"   ? Unexpected result: {result}")
-            
-    except Exception as e:
-        print(f"   ✗ Error testing face recognition: {e}")
-        import traceback
-        traceback.print_exc()
-    
-    # 4. Provide recommendations
-    print("\n4. Recommendations:")
-    print("   - Ensure all model files are present and not corrupted")
-    print("   - Check that the training data had 7 classes (0-6)")
-    print("   - Verify that the Siamese network outputs 5 features")
-    print("   - Make sure the scaler was trained on the same feature space")
-    print("   - Test with actual face images, not just synthetic ones")
-
-def create_test_face_image():
-    """Create a test face image for validation"""
-    # Create a simple face-like 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)
-    
-    # Eyes
-    cv2.circle(img, (35, 40), 4, (200, 200, 200), -1)
-    cv2.circle(img, (65, 40), 4, (200, 200, 200), -1)
-    
-    # Nose
-    cv2.line(img, (50, 45), (50, 60), (150, 150, 150), 2)
-    
-    # Mouth
-    cv2.ellipse(img, (50, 70), (15, 6), 0, 0, 180, (150, 150, 150), 2)
-    
-    return img
-
-if __name__ == "__main__":
-    apply_final_fix()

app/Hackathon_setup/classifier_analysis.py

@@ -1,276 +0,0 @@
-"""
-Analyze KNN vs other classifiers for face recognition
-"""
-
-import numpy as np
-import joblib
-from sklearn.neighbors import KNeighborsClassifier
-from sklearn.tree import DecisionTreeClassifier
-from sklearn.svm import SVC
-from sklearn.ensemble import RandomForestClassifier
-from sklearn.linear_model import LogisticRegression
-from sklearn.metrics import accuracy_score, classification_report
-
-print("🔍 Classifier Analysis for Face Recognition")
-print("=" * 60)
-
-def analyze_current_knn():
-    """Analyze the current KNN classifier performance"""
-    
-    print("📊 Current KNN Performance Analysis:")
-    print("   Based on your training report:")
-    print("   - Accuracy: 71.43%")
-    print("   - Person1 (Class 0): 60% precision, 100% recall")
-    print("   - Person2 (Class 1): 100% precision, 100% recall")
-    print("   - Person3 (Class 2): 0% precision, 0% recall")
-    print()
-    
-    print("🔍 KNN Issues Identified:")
-    print("   1. Poor Person3 performance (0% precision/recall)")
-    print("   2. Imbalanced training data (15, 11, 7 samples)")
-    print("   3. Small dataset (33 total samples)")
-    print("   4. Sensitive to outliers and noise")
-    print()
-
-def compare_classifiers():
-    """Compare different classifiers for face recognition"""
-    
-    print("🏆 Classifier Comparison for Face Recognition:")
-    print()
-    
-    classifiers = {
-        "K-Nearest Neighbors (Current)": {
-            "pros": [
-                "Simple and intuitive",
-                "No training time (lazy learning)",
-                "Works well with small datasets",
-                "Non-parametric (no assumptions about data distribution)",
-                "Good for non-linear decision boundaries"
-            ],
-            "cons": [
-                "Sensitive to irrelevant features",
-                "Computationally expensive during prediction",
-                "Sensitive to outliers",
-                "Poor performance with high-dimensional data",
-                "Memory intensive (stores all training data)"
-            ],
-            "best_for": "Small datasets, non-linear patterns, simple implementation"
-        },
-        
-        "Decision Tree": {
-            "pros": [
-                "Easy to interpret and visualize",
-                "Handles both numerical and categorical data",
-                "Requires little data preparation",
-                "Can handle missing values",
-                "Fast prediction",
-                "Good for feature importance"
-            ],
-            "cons": [
-                "Prone to overfitting",
-                "Unstable (small changes in data can cause big changes)",
-                "Biased towards features with more levels",
-                "Can create biased trees if some classes dominate"
-            ],
-            "best_for": "Interpretable models, feature selection, fast inference"
-        },
-        
-        "Random Forest": {
-            "pros": [
-                "Reduces overfitting compared to single decision tree",
-                "Handles missing values well",
-                "Provides feature importance",
-                "Works well with imbalanced data",
-                "Robust to outliers",
-                "Good performance on many problems"
-            ],
-            "cons": [
-                "Less interpretable than single decision tree",
-                "Can be slow for large datasets",
-                "Memory intensive",
-                "May overfit with very noisy data"
-            ],
-            "best_for": "General purpose, robust performance, feature importance"
-        },
-        
-        "Support Vector Machine (SVM)": {
-            "pros": [
-                "Effective in high-dimensional spaces",
-                "Memory efficient",
-                "Works well with small datasets",
-                "Robust to outliers",
-                "Good generalization performance"
-            ],
-            "cons": [
-                "Slow training on large datasets",
-                "Sensitive to feature scaling",
-                "Black box model (hard to interpret)",
-                "Memory intensive for large datasets",
-                "Sensitive to kernel choice"
-            ],
-            "best_for": "High-dimensional data, small datasets, good generalization"
-        },
-        
-        "Logistic Regression": {
-            "pros": [
-                "Fast training and prediction",
-                "Interpretable (coefficients have meaning)",
-                "Probabilistic output",
-                "Memory efficient",
-                "Works well with small datasets"
-            ],
-            "cons": [
-                "Assumes linear relationship",
-                "Sensitive to outliers",
-                "Requires feature scaling",
-                "May not work well with non-linear patterns"
-            ],
-            "best_for": "Linear relationships, interpretability, fast inference"
-        }
-    }
-    
-    for name, info in classifiers.items():
-        print(f"🤖 {name}:")
-        print(f"   ✅ Pros: {', '.join(info['pros'][:3])}...")
-        print(f"   ❌ Cons: {', '.join(info['cons'][:3])}...")
-        print(f"   🎯 Best for: {info['best_for']}")
-        print()
-
-def recommend_classifier():
-    """Recommend the best classifier for your specific case"""
-    
-    print("💡 Recommendations for Your Face Recognition Task:")
-    print()
-    
-    print("🎯 Your Specific Situation:")
-    print("   - Small dataset (33 samples)")
-    print("   - Imbalanced classes (15, 11, 7)")
-    print("   - High-dimensional features (5 from Siamese network)")
-    print("   - Need fast inference for web deployment")
-    print("   - Person3 has poor performance (0% precision/recall)")
-    print()
-    
-    print("🏆 Top Recommendations:")
-    print()
-    
-    print("1. 🥇 Random Forest (RECOMMENDED):")
-    print("   ✅ Handles imbalanced data well")
-    print("   ✅ Robust to outliers")
-    print("   ✅ Good performance on small datasets")
-    print("   ✅ Fast prediction")
-    print("   ✅ Provides feature importance")
-    print("   ✅ Less prone to overfitting than single decision tree")
-    print()
-    
-    print("2. 🥈 Decision Tree:")
-    print("   ✅ Fast training and prediction")
-    print("   ✅ Easy to interpret")
-    print("   ✅ Good for small datasets")
-    print("   ⚠️ May overfit with small data")
-    print("   ⚠️ Less robust than Random Forest")
-    print()
-    
-    print("3. 🥉 SVM:")
-    print("   ✅ Good for high-dimensional data")
-    print("   ✅ Works well with small datasets")
-    print("   ✅ Robust to outliers")
-    print("   ⚠️ Slower training")
-    print("   ⚠️ Requires careful parameter tuning")
-    print()
-    
-    print("❌ Not Recommended:")
-    print("   - Logistic Regression: Assumes linear relationships")
-    print("   - KNN: Current issues with Person3 performance")
-    print()
-
-def provide_implementation_guide():
-    """Provide implementation guide for recommended classifier"""
-    
-    print("🔧 Implementation Guide for Random Forest:")
-    print()
-    
-    code_example = '''
-# Random Forest Implementation
-from sklearn.ensemble import RandomForestClassifier
-from sklearn.model_selection import train_test_split
-from sklearn.metrics import classification_report
-
-# Create Random Forest classifier
-rf_classifier = RandomForestClassifier(
-    n_estimators=100,        # Number of trees
-    max_depth=10,            # Maximum depth of trees
-    min_samples_split=2,     # Minimum samples to split
-    min_samples_leaf=1,     # Minimum samples in leaf
-    class_weight='balanced', # Handle imbalanced data
-    random_state=42
-)
-
-# Train the classifier
-rf_classifier.fit(X_scaled, y)
-
-# Make predictions
-y_pred_rf = rf_classifier.predict(X_test_scaled)
-
-# Evaluate performance
-rf_accuracy = accuracy_score(y_test, y_pred_rf)
-print(f"Random Forest Accuracy: {rf_accuracy*100:.2f}%")
-print(classification_report(y_test, y_pred_rf))
-
-# Save the model
-joblib.dump(rf_classifier, 'random_forest_model.sav')
-'''
-    
-    print("📝 Code Example:")
-    print(code_example)
-    
-    print("🎯 Key Parameters:")
-    print("   - n_estimators: Number of trees (100-200)")
-    print("   - max_depth: Prevent overfitting (5-15)")
-    print("   - class_weight='balanced': Handle imbalanced data")
-    print("   - min_samples_split: Minimum samples to split (2-5)")
-    print()
-
-def data_improvement_suggestions():
-    """Suggestions for improving training data"""
-    
-    print("📊 Data Improvement Suggestions:")
-    print()
-    
-    print("1. 🎯 Balance Your Dataset:")
-    print("   - Current: Person1(15), Person2(11), Person3(7)")
-    print("   - Target: 15-20 samples per person")
-    print("   - Add more Person3 images (currently only 7)")
-    print()
-    
-    print("2. 📸 Improve Image Quality:")
-    print("   - Clear frontal faces")
-    print("   - Good lighting and contrast")
-    print("   - Consistent image size")
-    print("   - Remove blurry or low-quality images")
-    print()
-    
-    print("3. 🔄 Data Augmentation:")
-    print("   - Rotate images slightly (±5 degrees)")
-    print("   - Adjust brightness/contrast")
-    print("   - Add slight noise")
-    print("   - Crop different regions")
-    print()
-    
-    print("4. 🎨 Diversity:")
-    print("   - Different expressions")
-    print("   - Various lighting conditions")
-    print("   - Different angles (slight variations)")
-    print("   - Different backgrounds")
-    print()
-
-if __name__ == "__main__":
-    analyze_current_knn()
-    compare_classifiers()
-    recommend_classifier()
-    provide_implementation_guide()
-    data_improvement_suggestions()
-    
-    print("🎯 Final Recommendation:")
-    print("Switch to Random Forest for better performance with imbalanced data")
-    print("Focus on improving Person3 training data")
-    print("Consider data augmentation to increase dataset size")

app/Hackathon_setup/create_workaround_models.py

@@ -1,66 +0,0 @@
-"""
-Create a simple workaround for Hugging Face sklearn compatibility
-"""
-
-import os
-import numpy as np
-import joblib
-import pickle
-
-def create_workaround_models():
-    """Create workaround models that should work on Hugging Face"""
-    print("Creating workaround models for Hugging Face...")
-    
-    try:
-        # Load original models
-        original_classifier = joblib.load('decision_tree_model.sav')
-        original_scaler = joblib.load('face_recognition_scaler.sav')
-        
-        print(f"Original classifier: {type(original_classifier)}")
-        print(f"Original scaler: {type(original_scaler)}")
-        
-        # Create a simple pickle version that should work
-        with open('decision_tree_model.pkl', 'wb') as f:
-            pickle.dump(original_classifier, f)
-        
-        with open('face_recognition_scaler.pkl', 'wb') as f:
-            pickle.dump(original_scaler, f)
-        
-        print("✅ Created pickle versions:")
-        print("   - decision_tree_model.pkl")
-        print("   - face_recognition_scaler.pkl")
-        
-        # Test loading
-        with open('decision_tree_model.pkl', 'rb') as f:
-            test_classifier = pickle.load(f)
-        
-        with open('face_recognition_scaler.pkl', 'rb') as f:
-            test_scaler = pickle.load(f)
-        
-        print(f"✅ Test classifier: {type(test_classifier)}")
-        print(f"✅ Test scaler: {type(test_scaler)}")
-        
-        # Test prediction
-        dummy_features = np.random.randn(1, test_scaler.n_features_in_)
-        scaled_features = test_scaler.transform(dummy_features)
-        prediction = test_classifier.predict(scaled_features)[0]
-        
-        print(f"✅ Test prediction: {prediction}")
-        
-        return True
-        
-    except Exception as e:
-        print(f"❌ Error: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-if __name__ == "__main__":
-    success = create_workaround_models()
-    if success:
-        print("\n🎉 Workaround models created successfully!")
-        print("Use these files for Hugging Face:")
-        print("- decision_tree_model.pkl")
-        print("- face_recognition_scaler.pkl")
-    else:
-        print("\n❌ Failed to create workaround models")

app/Hackathon_setup/debug_classification.py

@@ -1,130 +0,0 @@
-"""
-Debug script to understand why classification returns UNKNOWN_CLASS
-"""
-
-import numpy as np
-import cv2
-from face_recognition import get_face_class
-import torch
-import joblib
-
-def debug_classification():
-    """Debug the classification process step by step"""
-    print("Debugging Face Classification")
-    print("=" * 40)
-    
-    # Create a test image
-    test_img = np.random.randint(0, 255, (100, 100, 3), dtype=np.uint8)
-    
-    try:
-        # Test the classification
-        result = get_face_class(test_img)
-        print(f"Classification result: {result}")
-        
-        # Let's also check what the model files contain
-        print("\nChecking model files...")
-        
-        # Check scaler
-        try:
-            scaler = joblib.load('face_recognition_scaler.sav')
-            print(f"Scaler loaded successfully: {type(scaler)}")
-            print(f"Scaler mean shape: {scaler.mean_.shape if hasattr(scaler, 'mean_') else 'No mean'}")
-        except Exception as e:
-            print(f"Scaler error: {e}")
-        
-        # Check classifier
-        try:
-            classifier = joblib.load('decision_tree_model.sav')
-            print(f"Classifier loaded successfully: {type(classifier)}")
-            print(f"Classifier classes: {classifier.classes_ if hasattr(classifier, 'classes_') else 'No classes'}")
-            print(f"Number of classes: {len(classifier.classes_) if hasattr(classifier, 'classes_') else 'Unknown'}")
-        except Exception as e:
-            print(f"Classifier error: {e}")
-        
-        # Check CLASS_NAMES
-        from face_recognition import CLASS_NAMES
-        print(f"CLASS_NAMES: {CLASS_NAMES}")
-        print(f"Number of class names: {len(CLASS_NAMES)}")
-        
-        # Test with a more realistic face-like image
-        print("\nTesting with face-like image...")
-        face_img = create_face_like_image()
-        face_result = get_face_class(face_img)
-        print(f"Face-like image result: {face_result}")
-        
-    except Exception as e:
-        print(f"Error in debug: {e}")
-        import traceback
-        traceback.print_exc()
-
-def create_face_like_image():
-    """Create a more realistic face-like image"""
-    img = np.zeros((100, 100, 3), dtype=np.uint8)
-    
-    # Face outline (oval)
-    cv2.ellipse(img, (50, 50), (40, 50), 0, 0, 360, (100, 100, 100), -1)
-    
-    # Eyes
-    cv2.circle(img, (35, 40), 5, (200, 200, 200), -1)
-    cv2.circle(img, (65, 40), 5, (200, 200, 200), -1)
-    
-    # Nose
-    cv2.line(img, (50, 45), (50, 60), (150, 150, 150), 2)
-    
-    # Mouth
-    cv2.ellipse(img, (50, 70), (15, 8), 0, 0, 180, (150, 150, 150), 2)
-    
-    return img
-
-def test_embedding_extraction():
-    """Test the embedding extraction process"""
-    print("\nTesting embedding extraction...")
-    print("=" * 40)
-    
-    try:
-        from face_recognition import detected_face
-        from face_recognition_model import Siamese, trnscm
-        import torch
-        
-        # Create test image
-        test_img = np.random.randint(0, 255, (100, 100, 3), dtype=np.uint8)
-        
-        # Test face detection
-        detected = detected_face(test_img)
-        print(f"Face detection result: {type(detected)}")
-        
-        if detected != 0:
-            # Test transformation
-            face_tensor = trnscm(detected).unsqueeze(0)
-            print(f"Face tensor shape: {face_tensor.shape}")
-            
-            # Test model loading and embedding
-            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()
-            
-            # Extract embedding
-            with torch.no_grad():
-                embedding = siamese_net.forward_once(face_tensor.to(device)).cpu().numpy()
-                print(f"Embedding shape: {embedding.shape}")
-                print(f"Embedding sample: {embedding[0][:5]}")  # First 5 values
-                
-        else:
-            print("No face detected in test image")
-            
-    except Exception as e:
-        print(f"Error in embedding extraction: {e}")
-        import traceback
-        traceback.print_exc()
-
-if __name__ == "__main__":
-    debug_classification()
-    test_embedding_extraction()

app/Hackathon_setup/deep_debug_classification.py

@@ -1,174 +0,0 @@
-"""
-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/deploy_fix.py

@@ -1,117 +0,0 @@
-"""
-Deployment fix for Hugging Face Space sklearn compatibility issue
-"""
-
-import os
-import shutil
-
-def create_deployment_package():
-    """Create a complete deployment package"""
-    print("Creating Hugging Face Space Deployment Package")
-    print("=" * 60)
-    
-    # Files to deploy
-    files_to_deploy = [
-        'face_recognition_robust.py',  # Robust implementation
-        'face_recognition_model.py',   # Model definition
-        'app_robust.py',              # Robust Gradio app
-        'requirements.txt',           # Dependencies
-        'README.md',                  # Documentation
-        'siamese_model.t7',           # Trained model
-        'decision_tree_model.sav',    # Classifier
-        'face_recognition_scaler.sav' # Scaler
-    ]
-    
-    # Optional files
-    optional_files = [
-        'haarcascade_frontalface_default.xml',
-        'haarcascade_eye.xml'
-    ]
-    
-    print("Files to deploy:")
-    for file in files_to_deploy:
-        if os.path.exists(file):
-            size = os.path.getsize(file) / (1024 * 1024)
-            print(f"✓ {file} ({size:.2f} MB)")
-        else:
-            print(f"✗ {file} - MISSING!")
-    
-    print("\nOptional files:")
-    for file in optional_files:
-        if os.path.exists(file):
-            print(f"✓ {file}")
-        else:
-            print(f"- {file} - Not found")
-    
-    print("\n" + "=" * 60)
-    print("DEPLOYMENT STEPS:")
-    print("=" * 60)
-    print("1. Go to: https://huggingface.co/spaces/pavaniyerra/hackthon4")
-    print("2. Click 'Files and versions' tab")
-    print("3. Upload these files (replace existing):")
-    print("   - app_robust.py → rename to app.py")
-    print("   - face_recognition_robust.py → rename to face_recognition.py")
-    print("   - requirements.txt")
-    print("   - README.md")
-    print("   - All model files (.t7, .sav)")
-    print("4. Wait for rebuild (2-5 minutes)")
-    
-    print("\n" + "=" * 60)
-    print("KEY FIXES IN THIS DEPLOYMENT:")
-    print("=" * 60)
-    print("✓ Robust sklearn compatibility handling")
-    print("✓ Fallback cosine similarity calculation")
-    print("✓ Safe model loading with multiple methods")
-    print("✓ Better error handling and user feedback")
-    print("✓ Improved Gradio interface")
-    print("✓ Comprehensive documentation")
-    
-    print("\n" + "=" * 60)
-    print("TROUBLESHOOTING:")
-    print("=" * 60)
-    print("If you still get errors:")
-    print("1. Check build logs in Hugging Face Space")
-    print("2. Ensure all model files are uploaded")
-    print("3. Verify requirements.txt is correct")
-    print("4. Try rebuilding the space")
-    print("5. Check file permissions and paths")
-
-def create_requirements_robust():
-    """Create a robust requirements.txt"""
-    requirements = """torch>=1.9.0
-torchvision>=0.10.0
-opencv-python>=4.5.0
-numpy>=1.21.0
-scikit-learn>=1.0.0,<2.0.0
-matplotlib>=3.3.0
-Pillow>=8.0.0
-joblib>=1.0.0
-requests>=2.25.0
-gradio>=4.0.0
-"""
-    
-    with open('requirements_robust.txt', 'w') as f:
-        f.write(requirements)
-    
-    print("Created requirements_robust.txt with flexible sklearn version")
-
-def main():
-    print("Hugging Face Space Fix Deployment")
-    print("=" * 50)
-    
-    # Check if we're in the right directory
-    if not os.path.exists('face_recognition.py'):
-        print("ERROR: Please run this from the Hackathon_setup directory")
-        return
-    
-    create_deployment_package()
-    create_requirements_robust()
-    
-    print("\n" + "=" * 60)
-    print("READY TO DEPLOY!")
-    print("=" * 60)
-    print("This deployment should fix the sklearn compatibility issue.")
-    print("The robust implementation will work even if sklearn versions don't match.")
-
-if __name__ == "__main__":
-    main()

app/Hackathon_setup/deploy_to_huggingface.py

@@ -1,117 +0,0 @@
-"""
-Script to help deploy the face recognition system to Hugging Face Spaces
-"""
-
-import os
-import shutil
-
-def create_deployment_files():
-    """Create all necessary files for Hugging Face deployment"""
-    print("Creating deployment files for Hugging Face Space...")
-    print("=" * 60)
-    
-    # Files needed for deployment
-    files_to_copy = [
-        'face_recognition.py',
-        'face_recognition_model.py',
-        'siamese_model.t7',
-        'decision_tree_model.sav',
-        'face_recognition_scaler.sav',
-        'requirements.txt',
-        'app.py',
-        'README.md'
-    ]
-    
-    # Optional files (if they exist)
-    optional_files = [
-        'haarcascade_frontalface_default.xml',
-        'haarcascade_eye.xml'
-    ]
-    
-    print("Required files:")
-    for file in files_to_copy:
-        if os.path.exists(file):
-            print(f"OK: {file}")
-        else:
-            print(f"ERROR: {file} - MISSING!")
-    
-    print("\nOptional files:")
-    for file in optional_files:
-        if os.path.exists(file):
-            print(f"OK: {file}")
-        else:
-            print(f"- {file} - Not found (optional)")
-    
-    print("\n" + "=" * 60)
-    print("DEPLOYMENT INSTRUCTIONS:")
-    print("=" * 60)
-    print("1. Go to your Hugging Face Space: https://huggingface.co/spaces/pavaniyerra/hackthon4")
-    print("2. Click on 'Files and versions' tab")
-    print("3. Upload the following files:")
-    
-    for file in files_to_copy:
-        if os.path.exists(file):
-            print(f"   - {file}")
-    
-    print("\n4. Make sure to replace any existing files with the same names")
-    print("5. The space will automatically rebuild with the new files")
-    print("6. Wait for the build to complete (usually 2-5 minutes)")
-    
-    print("\n" + "=" * 60)
-    print("KEY CHANGES FOR DEPLOYMENT:")
-    print("=" * 60)
-    print("OK: Fixed sklearn version compatibility (1.6.1)")
-    print("OK: Added warning suppression")
-    print("OK: Created proper Gradio interface")
-    print("OK: Added requirements.txt with correct versions")
-    print("OK: Updated README.md with documentation")
-    
-    print("\n" + "=" * 60)
-    print("TROUBLESHOOTING:")
-    print("=" * 60)
-    print("If you still get sklearn errors:")
-    print("1. Check that requirements.txt specifies scikit-learn==1.6.1")
-    print("2. Ensure all model files are uploaded")
-    print("3. Check the build logs for any missing dependencies")
-    print("4. Try rebuilding the space")
-
-def check_file_sizes():
-    """Check file sizes to ensure they're within limits"""
-    print("\nChecking file sizes...")
-    print("=" * 30)
-    
-    large_files = []
-    for file in os.listdir('.'):
-        if os.path.isfile(file) and file.endswith(('.t7', '.sav', '.pkl')):
-            size_mb = os.path.getsize(file) / (1024 * 1024)
-            print(f"{file}: {size_mb:.2f} MB")
-            if size_mb > 100:  # Hugging Face has limits
-                large_files.append(file)
-    
-    if large_files:
-        print(f"\nWARNING: Large files detected: {large_files}")
-        print("Hugging Face Spaces have file size limits. Consider:")
-        print("1. Using Git LFS for large files")
-        print("2. Compressing model files")
-        print("3. Using external storage for very large models")
-
-def main():
-    print("Hugging Face Space Deployment Helper")
-    print("=" * 50)
-    
-    # Check current directory
-    if not os.path.exists('face_recognition.py'):
-        print("ERROR: Please run this script from the Hackathon_setup directory")
-        return
-    
-    create_deployment_files()
-    check_file_sizes()
-    
-    print("\n" + "=" * 60)
-    print("READY FOR DEPLOYMENT!")
-    print("=" * 60)
-    print("Your files are ready to be uploaded to Hugging Face Space.")
-    print("Follow the instructions above to complete the deployment.")
-
-if __name__ == "__main__":
-    main()

app/Hackathon_setup/diagnose_errors.py

@@ -1,167 +0,0 @@
-"""
-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/diagnose_models.py

@@ -1,132 +0,0 @@
-"""
-Diagnostic script to check model loading and compatibility
-"""
-
-import os
-import sys
-import numpy as np
-
-# Add current directory to path
-sys.path.append(os.path.dirname(os.path.abspath(__file__)))
-
-def diagnose_models():
-    """Diagnose model loading and compatibility issues"""
-    print("Model Loading Diagnosis")
-    print("=" * 40)
-    
-    # Check if model files exist
-    model_files = [
-        'siamese_model.t7',
-        'decision_tree_model.sav', 
-        'face_recognition_scaler.sav'
-    ]
-    
-    print("Checking model files:")
-    for file in model_files:
-        if os.path.exists(file):
-            size = os.path.getsize(file)
-            print(f"  ✓ {file} exists ({size} bytes)")
-        else:
-            print(f"  ✗ {file} missing!")
-    
-    # Test model loading
-    print("\nTesting model loading:")
-    
-    try:
-        import joblib
-        print("  ✓ joblib imported successfully")
-        
-        # Load classifier
-        classifier = joblib.load('decision_tree_model.sav')
-        print(f"  ✓ Classifier loaded: {type(classifier)}")
-        print(f"    Classes: {classifier.classes_}")
-        print(f"    Number of classes: {len(classifier.classes_)}")
-        
-        # Load scaler
-        scaler = joblib.load('face_recognition_scaler.sav')
-        print(f"  ✓ Scaler loaded: {type(scaler)}")
-        print(f"    Feature count: {scaler.n_features_in_}")
-        
-        # Test compatibility
-        dummy_features = np.random.randn(1, scaler.n_features_in_)
-        scaled_features = scaler.transform(dummy_features)
-        prediction = classifier.predict(scaled_features)[0]
-        
-        print(f"  ✓ Test prediction: {prediction}")
-        print(f"    Prediction valid: {prediction in classifier.classes_}")
-        
-    except Exception as e:
-        print(f"  ✗ Error loading models: {e}")
-        import traceback
-        traceback.print_exc()
-    
-    # Test Siamese network
-    print("\nTesting Siamese network:")
-    try:
-        import torch
-        print("  ✓ torch imported successfully")
-        
-        from face_recognition_model import Siamese
-        
-        # Create model instance
-        model = Siamese()
-        print(f"  ✓ Siamese model created: {type(model)}")
-        
-        # Test forward pass
-        dummy_input = torch.randn(1, 1, 100, 100)
-        with torch.no_grad():
-            output = model.forward_once(dummy_input)
-            print(f"  ✓ Forward pass successful")
-            print(f"    Output shape: {output.shape}")
-            print(f"    Expected features: 5, Got: {output.shape[1]}")
-            
-            if output.shape[1] == 5:
-                print("  ✓ Feature count matches scaler expectations")
-            else:
-                print("  ✗ Feature count mismatch!")
-        
-        # Test model loading
-        if os.path.exists('siamese_model.t7'):
-            model_data = torch.load('siamese_model.t7', map_location='cpu')
-            print(f"  ✓ Model file loaded: {type(model_data)}")
-            
-            if isinstance(model_data, dict):
-                print(f"    Keys: {list(model_data.keys())}")
-            else:
-                print("    Model data is state dict")
-                
-    except Exception as e:
-        print(f"  ✗ Error with Siamese network: {e}")
-        import traceback
-        traceback.print_exc()
-    
-    # Test face recognition function
-    print("\nTesting face recognition function:")
-    try:
-        from face_recognition import get_face_class, CLASS_NAMES
-        
-        print(f"  ✓ Face recognition imported")
-        print(f"    CLASS_NAMES: {CLASS_NAMES}")
-        print(f"    Number of classes: {len(CLASS_NAMES)}")
-        
-        # Create test image
-        test_img = np.random.randint(0, 255, (100, 100, 3), dtype=np.uint8)
-        
-        # Test classification
-        result = get_face_class(test_img)
-        print(f"  ✓ Test classification: {result}")
-        
-        if result in CLASS_NAMES:
-            print("  ✓ Result is a valid class name")
-        elif result == "UNKNOWN_CLASS":
-            print("  ✗ UNKNOWN_CLASS detected - this is the problem!")
-        else:
-            print(f"  ? Unexpected result: {result}")
-            
-    except Exception as e:
-        print(f"  ✗ Error with face recognition: {e}")
-        import traceback
-        traceback.print_exc()
-
-if __name__ == "__main__":
-    diagnose_models()

app/Hackathon_setup/face_recognition.py

@@ -47,17 +47,9 @@ CLASS_NAMES = ['Person1', 'Person2', 'Person3'] # Updated to match training data
 
 # --- Model Filenames ---
 SIAMESE_MODEL_PATH = current_path + '/siamese_model.t7'
-KNN_CLASSIFIER_PATH = current_path + '/decision_tree_model.sav'
+DECISION_TREE_MODEL_PATH = current_path + '/decision_tree_model.sav'
 SCALER_PATH = current_path + '/decision_scaler.sav'
 
-# Compatible model paths for Hugging Face
-KNN_CLASSIFIER_COMPATIBLE_PATH = current_path + '/decision_tree_model.sav'
-SCALER_COMPATIBLE_PATH = current_path + '/decision_scaler.sav'
-
-# Pickle model paths (most compatible)
-KNN_CLASSIFIER_PKL_PATH = current_path + '/decision_tree_model.pkl'
-SCALER_PKL_PATH = current_path + '/face_recognition_scaler.pkl'
-
 def safe_cosine_similarity(embed1, embed2):
     """Calculate cosine similarity with fallback methods"""
     if SKLEARN_AVAILABLE:
@@ -96,7 +88,18 @@ def safe_load_model(file_path, model_type="joblib"):
     
     try:
         if model_type == "joblib":
-            return joblib.load(file_path)
+            model = joblib.load(file_path)
+            # Additional validation for Decision Tree models
+            if hasattr(model, 'predict'):
+                # Test if the model can make predictions
+                import numpy as np
+                dummy_data = np.random.randn(1, 5)  # Test with dummy data
+                try:
+                    _ = model.predict(dummy_data)
+                    print(f"✓ Model {file_path} loaded and validated successfully")
+                except Exception as test_error:
+                    print(f"⚠️ Model loaded but prediction test failed: {test_error}")
+            return model
         elif model_type == "pickle":
             with open(file_path, 'rb') as f:
                 return pickle.load(f)
@@ -250,62 +253,42 @@ def get_face_class(img1):
         scaler = None
         classifier = None
         
-        # Try to load original models first
+        # Load models
         try:
             scaler = safe_load_model(SCALER_PATH, "joblib")
-            classifier = safe_load_model(KNN_CLASSIFIER_PATH, "joblib")
-            print("✓ Loaded original models successfully")
+            classifier = safe_load_model(DECISION_TREE_MODEL_PATH, "joblib")
+            print("✓ Loaded models successfully")
         except Exception as e:
-            print(f"Failed to load original models: {e}")
-            
-            # Try pickle models (most compatible)
-            try:
-                if os.path.exists(SCALER_PKL_PATH) and os.path.exists(KNN_CLASSIFIER_PKL_PATH):
-                    import pickle
-                    with open(SCALER_PKL_PATH, 'rb') as f:
-                        scaler = pickle.load(f)
-                    with open(KNN_CLASSIFIER_PKL_PATH, 'rb') as f:
-                        classifier = pickle.load(f)
-                    print("✓ Loaded pickle models successfully")
-                else:
-                    print("Pickle models not found, trying compatible models")
-                    
-                    # Try compatible models
-                    if os.path.exists(SCALER_COMPATIBLE_PATH) and os.path.exists(KNN_CLASSIFIER_COMPATIBLE_PATH):
-                        scaler = safe_load_model(SCALER_COMPATIBLE_PATH, "joblib")
-                        classifier = safe_load_model(KNN_CLASSIFIER_COMPATIBLE_PATH, "joblib")
-                        print("✓ Loaded compatible models successfully")
-                    else:
-                        print("Compatible models not found, trying original with pickle")
-                        
-                        # Try loading original models with pickle
-                        try:
-                            import pickle
-                            with open(SCALER_PATH, 'rb') as f:
-                                scaler = pickle.load(f)
-                            with open(KNN_CLASSIFIER_PATH, 'rb') as f:
-                                classifier = pickle.load(f)
-                            print("✓ Loaded original models with pickle")
-                        except Exception as e2:
-                            print(f"All loading methods failed: {e2}")
-                            return "UNKNOWN_CLASS"
-                        
-            except Exception as e2:
-                print(f"Failed to load compatible models: {e2}")
-                return "UNKNOWN_CLASS"
-        
+            print(f"Failed to load models: {e}")
+            return "UNKNOWN_CLASS"
         
-        # --- CRITICAL VERIFICATION STEP ---
-        if not hasattr(classifier, 'predict'):
-            raise TypeError(f"Loaded object is not a valid classifier. Type is: {type(classifier)}")
-            
         if scaler is None or classifier is None:
             print("Failed to load any sklearn models")
             return "UNKNOWN_CLASS"
         
         # Preprocess and predict
         embedding_scaled = scaler.transform(embedding_np)
-        predicted_label_index = classifier.predict(embedding_scaled)[0]
+        
+        # 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"
         
         # Map to class name
         if predicted_label_index < len(CLASS_NAMES):

app/Hackathon_setup/face_recognition_old.py

@@ -1,213 +0,0 @@
-import numpy as np
-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.
-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 warnings
-# Suppress sklearn version warnings
-warnings.filterwarnings('ignore', category=UserWarning, module='sklearn')
-warnings.filterwarnings('ignore', message='.*InconsistentVersionWarning.*')
-
-import pickle
-from sklearn.metrics.pairwise import cosine_similarity
-from sklearn.preprocessing import StandardScaler
-# Add more imports if required
-
-
-
-###########################################################################################################################################
-#         Caution: Don't change any of the filenames, function names and definitions                                                      #
-#        Always use the current_path + file_name for refering any files, without it we cannot access files on the server                  # 
-###########################################################################################################################################
-
-# 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.
-#3) If no face is detected,then it returns zero(0).
-
-def detected_face(image):
-    eye_haar = current_path + '/haarcascade_eye.xml'
-    face_haar = current_path + '/haarcascade_frontalface_default.xml'
-    face_cascade = cv2.CascadeClassifier(face_haar)
-    eye_cascade = cv2.CascadeClassifier(eye_haar)
-    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-    faces = face_cascade.detectMultiScale(gray, 1.3, 5)
-    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)
-    return required_image
-
-
-#1) Images captured from mobile is passed as parameter to the below function in the API call. It returns the similarity measure between given images.
-#2) The image is passed to the function in base64 encoding, Code for decoding the image is provided within the function.
-#3) Define an object to your siamese network here in the function and load the weight from the trained network, set it in evaluation mode.
-#4) Get the features for both the faces from the network and return the similarity measure, Euclidean,cosine etc can be it. But choose the Relevant measure.
-#5) For loading your model use the current_path+'your model file name', anyhow detailed example is given in comments to the function 
-#Caution: Don't change the definition or function name; for loading the model use the current_path for path example is given in comments to the function
-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:
-        # 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}")
-        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.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.
-    # 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
-    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)
-    
-#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
-#3) Define an object to your network here in the function and load the weight from the trained network, set it in evaluation mode
-#4) Perform necessary transformations to the input(detected face using the above function).
-#5) Along with the siamese, you need the classifier as well, which is to be finetuned with the faces that you are training
-##Caution: Don't change the definition or function name; for loading the model use the current_path for path example is given in comments to the function
-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 = 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}"
-
-    # 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:
-        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/fix_class_labels.py

@@ -1,138 +0,0 @@
-"""
-Diagnostic script to check classifier classes and fix label mismatch
-"""
-
-import os
-import sys
-import numpy as np
-
-# Add current directory to path
-sys.path.append(os.path.dirname(os.path.abspath(__file__)))
-
-def diagnose_classifier_classes():
-    """Check what classes the classifier actually expects"""
-    print("Classifier Classes Diagnosis")
-    print("=" * 40)
-    
-    try:
-        import joblib
-        
-        # Load classifier
-        classifier_path = 'decision_tree_model.sav'
-        if os.path.exists(classifier_path):
-            classifier = joblib.load(classifier_path)
-            
-            print(f"✓ Classifier loaded successfully")
-            print(f"  Classes: {classifier.classes_}")
-            print(f"  Number of classes: {len(classifier.classes_)}")
-            print(f"  Class range: {min(classifier.classes_)} to {max(classifier.classes_)}")
-            
-            # Check if classes start from 0 or 1
-            if min(classifier.classes_) == 0:
-                print("  ✓ Classes start from 0 (Person0, Person1, ...)")
-                expected_names = ['Person0', 'Person1', 'Person2', 'Person3', 'Person4', 'Person5', 'Person6']
-            elif min(classifier.classes_) == 1:
-                print("  ✓ Classes start from 1 (Person1, Person2, ...)")
-                expected_names = ['Person1', 'Person2', 'Person3', 'Person4', 'Person5', 'Person6', 'Person7']
-            else:
-                print(f"  ? Classes start from {min(classifier.classes_)}")
-                expected_names = [f'Person{i}' for i in classifier.classes_]
-            
-            print(f"  Expected class names: {expected_names}")
-            
-            # Check current CLASS_NAMES
-            try:
-                from face_recognition import CLASS_NAMES
-                print(f"  Current CLASS_NAMES: {CLASS_NAMES}")
-                
-                if CLASS_NAMES == expected_names:
-                    print("  ✓ CLASS_NAMES match expected names")
-                else:
-                    print("  ✗ CLASS_NAMES don't match expected names")
-                    print("  This is likely the cause of UNKNOWN_CLASS!")
-                    
-                    # Suggest fix
-                    print(f"\n  SUGGESTED FIX:")
-                    print(f"  Update CLASS_NAMES to: {expected_names}")
-                    
-            except Exception as e:
-                print(f"  Error checking CLASS_NAMES: {e}")
-                
-        else:
-            print(f"✗ Classifier file not found: {classifier_path}")
-            
-    except Exception as e:
-        print(f"✗ Error: {e}")
-        import traceback
-        traceback.print_exc()
-
-def fix_class_names():
-    """Fix CLASS_NAMES to match the actual classifier classes"""
-    print("\nFixing CLASS_NAMES...")
-    
-    try:
-        import joblib
-        classifier = joblib.load('decision_tree_model.sav')
-        
-        # Determine correct class names based on classifier classes
-        if min(classifier.classes_) == 0:
-            # Classes 0-6 -> Person0-Person6
-            correct_names = ['Person0', 'Person1', 'Person2', 'Person3', 'Person4', 'Person5', 'Person6']
-        elif min(classifier.classes_) == 1:
-            # Classes 1-7 -> Person1-Person7
-            correct_names = ['Person1', 'Person2', 'Person3', 'Person4', 'Person5', 'Person6', 'Person7']
-        else:
-            # Custom mapping
-            correct_names = [f'Person{i}' for i in classifier.classes_]
-        
-        print(f"Correct CLASS_NAMES should be: {correct_names}")
-        
-        # Update face_recognition.py
-        face_recognition_path = 'face_recognition.py'
-        if os.path.exists(face_recognition_path):
-            with open(face_recognition_path, 'r') as f:
-                content = f.read()
-            
-            # Find and replace CLASS_NAMES line
-            import re
-            pattern = r"CLASS_NAMES = \[.*?\]"
-            new_line = f"CLASS_NAMES = {correct_names}"
-            
-            if re.search(pattern, content):
-                content = re.sub(pattern, new_line, content)
-                
-                with open(face_recognition_path, 'w') as f:
-                    f.write(content)
-                
-                print(f"✓ Updated CLASS_NAMES in face_recognition.py")
-            else:
-                print("✗ Could not find CLASS_NAMES line to update")
-        
-        # Update face_recognition_model.py
-        model_path = 'face_recognition_model.py'
-        if os.path.exists(model_path):
-            with open(model_path, 'r') as f:
-                content = f.read()
-            
-            # Find and replace classes line
-            pattern = r"classes = \[.*?\]"
-            new_line = f"classes = {correct_names}"
-            
-            if re.search(pattern, content):
-                content = re.sub(pattern, new_line, content)
-                
-                with open(model_path, 'w') as f:
-                    f.write(content)
-                
-                print(f"✓ Updated classes in face_recognition_model.py")
-            else:
-                print("✗ Could not find classes line to update")
-                
-    except Exception as e:
-        print(f"✗ Error fixing class names: {e}")
-        import traceback
-        traceback.print_exc()
-
-if __name__ == "__main__":
-    diagnose_classifier_classes()
-    fix_class_names()

app/Hackathon_setup/fix_class_mapping.py

@@ -1,180 +0,0 @@
-"""
-Analyze training data and fix class mapping based on actual training report
-"""
-
-import os
-import sys
-import numpy as np
-
-print("🔍 Training Data Analysis & Class Mapping Fix")
-print("=" * 60)
-
-def analyze_training_data():
-    """Analyze the training data based on the report"""
-    
-    print("Based on your training report:")
-    print("📊 Training Data Summary:")
-    print("   - Train samples: 26")
-    print("   - Test samples: 7") 
-    print("   - Classes: 3 (0, 1, 2)")
-    print("   - Accuracy: 71.43%")
-    print()
-    
-    print("📈 Classification Performance:")
-    print("   - Class 0: precision=0.60, recall=1.00, f1=0.75 (3 samples)")
-    print("   - Class 1: precision=1.00, recall=1.00, f1=1.00 (2 samples)")
-    print("   - Class 2: precision=0.00, recall=0.00, f1=0.00 (2 samples)")
-    print()
-    
-    print("🔍 Issues Identified:")
-    print("   1. Class 2 has poor performance (0% precision/recall)")
-    print("   2. Only 3 classes trained, but CLASS_NAMES has 7 classes")
-    print("   3. Small test set (7 samples) may not be representative")
-    print()
-    
-    return True
-
-def fix_class_mapping():
-    """Fix the class mapping to match actual training data"""
-    
-    print("🔧 Fixing Class Mapping...")
-    
-    # Current incorrect mapping
-    current_names = ['Person1', 'Person2', 'Person3', 'Person4', 'Person5', 'Person6', 'Person7']
-    
-    # Correct mapping based on training (3 classes)
-    correct_names = ['Person1', 'Person2', 'Person3']
-    
-    print(f"Current CLASS_NAMES: {current_names}")
-    print(f"Correct CLASS_NAMES: {correct_names}")
-    print()
-    
-    # Update face_recognition.py
-    try:
-        with open('face_recognition.py', 'r') as f:
-            content = f.read()
-        
-        # Replace the CLASS_NAMES line
-        old_line = "CLASS_NAMES = ['Person1', 'Person2', 'Person3', 'Person4', 'Person5', 'Person6', 'Person7']"
-        new_line = "CLASS_NAMES = ['Person1', 'Person2', 'Person3']"
-        
-        if old_line in content:
-            content = content.replace(old_line, new_line)
-            
-            with open('face_recognition.py', 'w') as f:
-                f.write(content)
-            
-            print("✅ Updated face_recognition.py CLASS_NAMES")
-        else:
-            print("⚠️ Could not find CLASS_NAMES line to update")
-    
-    except Exception as e:
-        print(f"❌ Error updating face_recognition.py: {e}")
-    
-    # Update face_recognition_model.py
-    try:
-        with open('face_recognition_model.py', 'r') as f:
-            content = f.read()
-        
-        # Replace the classes line
-        old_line = "classes = ['Person1','Person2','Person3','Person4','Person5','Person6','Person7']"
-        new_line = "classes = ['Person1','Person2','Person3']"
-        
-        if old_line in content:
-            content = content.replace(old_line, new_line)
-            
-            with open('face_recognition_model.py', 'w') as f:
-                f.write(content)
-            
-            print("✅ Updated face_recognition_model.py classes")
-        else:
-            print("⚠️ Could not find classes line to update")
-    
-    except Exception as e:
-        print(f"❌ Error updating face_recognition_model.py: {e}")
-
-def test_corrected_mapping():
-    """Test the corrected class mapping"""
-    
-    print("\n🧪 Testing Corrected Mapping...")
-    
-    try:
-        from face_recognition import get_face_class, CLASS_NAMES
-        import joblib
-        
-        print(f"Updated CLASS_NAMES: {CLASS_NAMES}")
-        print(f"Number of classes: {len(CLASS_NAMES)}")
-        
-        # Load classifier to verify
-        classifier = joblib.load('decision_tree_model.sav')
-        print(f"Classifier classes: {classifier.classes_}")
-        
-        if len(CLASS_NAMES) == len(classifier.classes_):
-            print("✅ Class mapping now matches classifier!")
-        else:
-            print("❌ Class mapping still doesn't match")
-        
-        # Test with synthetic image
-        import cv2
-        test_img = np.zeros((100, 100, 3), dtype=np.uint8)
-        cv2.ellipse(test_img, (50, 50), (40, 50), 0, 0, 360, (100, 100, 100), -1)
-        cv2.circle(test_img, (35, 40), 5, (200, 200, 200), -1)
-        cv2.circle(test_img, (65, 40), 5, (200, 200, 200), -1)
-        
-        result = get_face_class(test_img)
-        print(f"Test classification result: {result}")
-        
-        if result in CLASS_NAMES:
-            print("✅ Classification working correctly!")
-        else:
-            print("❌ Classification still has issues")
-            
-    except Exception as e:
-        print(f"❌ Error testing: {e}")
-
-def provide_recommendations():
-    """Provide recommendations for improving the model"""
-    
-    print("\n💡 Recommendations for Better Performance:")
-    print()
-    print("1. 📊 Improve Class 2 Performance:")
-    print("   - Class 2 has 0% precision/recall")
-    print("   - Add more training samples for Person3")
-    print("   - Check if Person3 images are clear and diverse")
-    print()
-    
-    print("2. 📈 Increase Training Data:")
-    print("   - Current: 26 train samples (very small)")
-    print("   - Recommended: 50-100+ samples per person")
-    print("   - Add more diverse images per person")
-    print()
-    
-    print("3. 🎯 Improve Test Set:")
-    print("   - Current: 7 test samples (too small)")
-    print("   - Recommended: 20-30% of total data for testing")
-    print("   - Ensure balanced representation of all classes")
-    print()
-    
-    print("4. 🔧 Model Improvements:")
-    print("   - Try different k values (k=3, k=7)")
-    print("   - Consider using DecisionTree instead of k-NN")
-    print("   - Add data augmentation for more training variety")
-    print()
-    
-    print("5. 📝 Current Status:")
-    print("   - ✅ System working (no more UNKNOWN_CLASS)")
-    print("   - ✅ Class mapping fixed")
-    print("   - ⚠️ Model performance needs improvement")
-    print("   - ⚠️ Need more training data")
-
-if __name__ == "__main__":
-    analyze_training_data()
-    fix_class_mapping()
-    test_corrected_mapping()
-    provide_recommendations()
-    
-    print("\n🎉 Class mapping fix completed!")
-    print("Your face recognition will now work with the correct 3 classes:")
-    print("- Person1 (Class 0)")
-    print("- Person2 (Class 1)") 
-    print("- Person3 (Class 2)")

app/Hackathon_setup/fix_sklearn_advanced.py

@@ -1,149 +0,0 @@
-"""
-Better fix for sklearn compatibility - properly copy all model attributes
-"""
-
-import os
-import numpy as np
-import joblib
-import pickle
-from sklearn.neighbors import KNeighborsClassifier
-from sklearn.preprocessing import StandardScaler
-
-def create_properly_compatible_model():
-    """Create a properly compatible model by copying all necessary attributes"""
-    print("Creating properly compatible sklearn models...")
-    
-    try:
-        # Load original models
-        original_classifier = joblib.load('decision_tree_model.sav')
-        original_scaler = joblib.load('face_recognition_scaler.sav')
-        
-        print(f"Original classifier: {type(original_classifier)}")
-        print(f"Original scaler: {type(original_scaler)}")
-        
-        # Create new scaler and copy all attributes
-        new_scaler = StandardScaler()
-        
-        # Copy all scaler attributes
-        for attr in ['n_features_in_', 'mean_', 'scale_', 'var_', 'feature_names_in_']:
-            if hasattr(original_scaler, attr):
-                setattr(new_scaler, attr, getattr(original_scaler, attr))
-        
-        # Create new classifier and copy all attributes
-        new_classifier = KNeighborsClassifier()
-        
-        # Copy all classifier attributes
-        for attr in ['n_neighbors', 'weights', 'algorithm', 'leaf_size', 'p', 'metric', 'metric_params', 'n_jobs']:
-            if hasattr(original_classifier, attr):
-                setattr(new_classifier, attr, getattr(original_classifier, attr))
-        
-        # Copy fitted attributes
-        for attr in ['classes_', '_fit_X', '_y', '_tree', 'n_features_in_', 'effective_metric_', 'effective_metric_params_']:
-            if hasattr(original_classifier, attr):
-                setattr(new_classifier, attr, getattr(original_classifier, attr))
-        
-        # Mark as fitted
-        new_classifier._sklearn_version = getattr(original_classifier, '_sklearn_version', '1.0')
-        
-        # Save the models
-        joblib.dump(new_classifier, 'decision_tree_model_compatible.sav')
-        joblib.dump(new_scaler, 'face_recognition_scaler_compatible.sav')
-        
-        print("✅ Created properly compatible models")
-        
-        # Test the models
-        print("\nTesting compatible models...")
-        
-        # Load and test
-        test_classifier = joblib.load('decision_tree_model_compatible.sav')
-        test_scaler = joblib.load('face_recognition_scaler_compatible.sav')
-        
-        print(f"Test classifier type: {type(test_classifier)}")
-        print(f"Test classifier classes: {test_classifier.classes_}")
-        print(f"Test scaler features: {test_scaler.n_features_in_}")
-        
-        # Test prediction
-        dummy_features = np.random.randn(1, test_scaler.n_features_in_)
-        scaled_features = test_scaler.transform(dummy_features)
-        prediction = test_classifier.predict(scaled_features)[0]
-        
-        print(f"✅ Test prediction successful: {prediction}")
-        
-        return True
-        
-    except Exception as e:
-        print(f"❌ Error: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-def create_simple_fallback():
-    """Create a simple fallback model that should work on any sklearn version"""
-    print("\nCreating simple fallback model...")
-    
-    try:
-        # Load original models
-        original_classifier = joblib.load('decision_tree_model.sav')
-        original_scaler = joblib.load('face_recognition_scaler.sav')
-        
-        # Create simple models with same parameters
-        new_scaler = StandardScaler()
-        new_scaler.n_features_in_ = original_scaler.n_features_in_
-        new_scaler.mean_ = original_scaler.mean_.copy()
-        new_scaler.scale_ = original_scaler.scale_.copy()
-        
-        # Create simple classifier
-        new_classifier = KNeighborsClassifier(n_neighbors=3)
-        
-        # Use the original training data to refit
-        if hasattr(original_classifier, '_fit_X') and hasattr(original_classifier, '_y'):
-            X = original_classifier._fit_X
-            y = original_classifier._y
-            new_classifier.fit(X, y)
-            print("✅ Refitted classifier with original data")
-        else:
-            # Create dummy data
-            X = np.random.randn(100, original_scaler.n_features_in_)
-            y = np.random.choice([0, 1, 2], 100)
-            new_classifier.fit(X, y)
-            print("✅ Created classifier with dummy data")
-        
-        # Save fallback models
-        joblib.dump(new_classifier, 'decision_tree_model_fallback.sav')
-        joblib.dump(new_scaler, 'face_recognition_scaler_fallback.sav')
-        
-        print("✅ Created fallback models")
-        
-        # Test fallback
-        test_features = np.random.randn(1, new_scaler.n_features_in_)
-        scaled = new_scaler.transform(test_features)
-        pred = new_classifier.predict(scaled)[0]
-        
-        print(f"✅ Fallback test prediction: {pred}")
-        
-        return True
-        
-    except Exception as e:
-        print(f"❌ Fallback creation failed: {e}")
-        return False
-
-if __name__ == "__main__":
-    print("🔧 Advanced Sklearn Compatibility Fix")
-    print("=" * 50)
-    
-    # Try the proper method first
-    success1 = create_properly_compatible_model()
-    
-    # If that fails, try fallback
-    if not success1:
-        success2 = create_simple_fallback()
-    
-    if success1 or success2:
-        print("\n🎉 Compatible models created!")
-        print("Files ready for Hugging Face:")
-        print("- decision_tree_model_compatible.sav")
-        print("- face_recognition_scaler_compatible.sav")
-        print("- decision_tree_model_fallback.sav (if needed)")
-        print("- face_recognition_scaler_fallback.sav (if needed)")
-    else:
-        print("\n❌ All methods failed")

app/Hackathon_setup/fix_sklearn_compatibility.py

@@ -1,113 +0,0 @@
-"""
-Fix for sklearn version compatibility issue on Hugging Face
-"""
-
-import os
-import sys
-import numpy as np
-import pickle
-import warnings
-
-# Suppress sklearn warnings
-warnings.filterwarnings('ignore', category=UserWarning, module='sklearn')
-
-def create_compatible_model():
-    """Create a sklearn-compatible version of the model"""
-    print("Creating sklearn-compatible model...")
-    
-    try:
-        # Try to load the original model
-        import joblib
-        original_classifier = joblib.load('decision_tree_model.sav')
-        original_scaler = joblib.load('face_recognition_scaler.sav')
-        
-        print(f"Original classifier type: {type(original_classifier)}")
-        print(f"Original classifier classes: {original_classifier.classes_}")
-        print(f"Original scaler features: {original_scaler.n_features_in_}")
-        
-        # Create a new compatible classifier
-        from sklearn.neighbors import KNeighborsClassifier
-        from sklearn.preprocessing import StandardScaler
-        
-        # Create new scaler with same parameters
-        new_scaler = StandardScaler()
-        new_scaler.n_features_in_ = original_scaler.n_features_in_
-        new_scaler.mean_ = original_scaler.mean_.copy()
-        new_scaler.scale_ = original_scaler.scale_.copy()
-        new_scaler.var_ = original_scaler.var_.copy()
-        
-        # Create new classifier with same parameters
-        new_classifier = KNeighborsClassifier(
-            n_neighbors=original_classifier.n_neighbors,
-            weights=original_classifier.weights,
-            algorithm=original_classifier.algorithm,
-            leaf_size=original_classifier.leaf_size,
-            p=original_classifier.p,
-            metric=original_classifier.metric,
-            metric_params=original_classifier.metric_params,
-            n_jobs=original_classifier.n_jobs
-        )
-        
-        # Copy the training data and classes
-        new_classifier.classes_ = original_classifier.classes_.copy()
-        new_classifier._fit_X = original_classifier._fit_X.copy()
-        new_classifier._y = original_classifier._y.copy()
-        new_classifier._tree = original_classifier._tree
-        
-        # Save the compatible models
-        joblib.dump(new_classifier, 'decision_tree_model_compatible.sav')
-        joblib.dump(new_scaler, 'face_recognition_scaler_compatible.sav')
-        
-        print("✅ Created compatible models:")
-        print("   - decision_tree_model_compatible.sav")
-        print("   - face_recognition_scaler_compatible.sav")
-        
-        return True
-        
-    except Exception as e:
-        print(f"❌ Error creating compatible model: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-def test_compatible_model():
-    """Test the compatible model"""
-    print("\nTesting compatible model...")
-    
-    try:
-        import joblib
-        
-        # Load compatible models
-        classifier = joblib.load('decision_tree_model_compatible.sav')
-        scaler = joblib.load('face_recognition_scaler_compatible.sav')
-        
-        print(f"✅ Compatible classifier loaded: {type(classifier)}")
-        print(f"✅ Compatible scaler loaded: {scaler.n_features_in_} features")
-        
-        # Test with dummy data
-        dummy_features = np.random.randn(1, scaler.n_features_in_)
-        scaled_features = scaler.transform(dummy_features)
-        prediction = classifier.predict(scaled_features)[0]
-        
-        print(f"✅ Test prediction: {prediction}")
-        print(f"✅ Classifier classes: {classifier.classes_}")
-        
-        return True
-        
-    except Exception as e:
-        print(f"❌ Error testing compatible model: {e}")
-        return False
-
-if __name__ == "__main__":
-    print("🔧 Sklearn Compatibility Fix")
-    print("=" * 40)
-    
-    success = create_compatible_model()
-    if success:
-        test_compatible_model()
-        print("\n🎉 Compatible models created successfully!")
-        print("Use these files for Hugging Face deployment:")
-        print("- decision_tree_model_compatible.sav")
-        print("- face_recognition_scaler_compatible.sav")
-    else:
-        print("\n❌ Failed to create compatible models")

app/Hackathon_setup/fix_sklearn_warnings.py

@@ -1,98 +0,0 @@
-"""
-Fix sklearn version warnings by suppressing them
-"""
-
-import warnings
-import joblib
-import os
-
-def suppress_sklearn_warnings():
-    """Suppress sklearn version warnings"""
-    warnings.filterwarnings('ignore', category=UserWarning, module='sklearn')
-    warnings.filterwarnings('ignore', message='.*InconsistentVersionWarning.*')
-
-def test_models_without_warnings():
-    """Test model loading without warnings"""
-    print("Testing models with suppressed warnings...")
-    print("=" * 50)
-    
-    # Suppress warnings
-    suppress_sklearn_warnings()
-    
-    try:
-        # Test scaler
-        print("Loading StandardScaler...")
-        scaler = joblib.load('face_recognition_scaler.sav')
-        print("OK: Scaler loaded")
-        
-        # Test classifier
-        print("Loading KNeighborsClassifier...")
-        classifier = joblib.load('decision_tree_model.sav')
-        print("OK: Classifier loaded")
-        
-        # Test with dummy data
-        import numpy as np
-        dummy_data = np.random.randn(1, 5)
-        scaled_data = scaler.transform(dummy_data)
-        prediction = classifier.predict(scaled_data)
-        
-        print(f"OK: Test prediction: {prediction[0]}")
-        print("SUCCESS: Models work without warnings!")
-        
-        return True
-        
-    except Exception as e:
-        print(f"ERROR: {e}")
-        return False
-
-def update_face_recognition_file():
-    """Update face_recognition.py to suppress warnings"""
-    print("\nUpdating face_recognition.py to suppress warnings...")
-    
-    # Read the current file
-    with open('face_recognition.py', 'r') as f:
-        content = f.read()
-    
-    # Add warning suppression at the top
-    if 'warnings.filterwarnings' not in content:
-        # Find the import section and add warning suppression
-        import_section = content.find('import joblib')
-        if import_section != -1:
-            # Add warning suppression after joblib import
-            insert_pos = content.find('\n', import_section) + 1
-            warning_code = """import warnings
-# Suppress sklearn version warnings
-warnings.filterwarnings('ignore', category=UserWarning, module='sklearn')
-warnings.filterwarnings('ignore', message='.*InconsistentVersionWarning.*')
-
-"""
-            content = content[:insert_pos] + warning_code + content[insert_pos:]
-            
-            # Write back to file
-            with open('face_recognition.py', 'w') as f:
-                f.write(content)
-            
-            print("OK: Added warning suppression to face_recognition.py")
-        else:
-            print("WARNING: Could not find import section to add warning suppression")
-    else:
-        print("OK: Warning suppression already present")
-
-def main():
-    print("Sklearn Warning Suppression Fix")
-    print("=" * 40)
-    
-    # Test models
-    if test_models_without_warnings():
-        print("\nModels are working! Now updating face_recognition.py...")
-        update_face_recognition_file()
-        
-        print("\n" + "=" * 50)
-        print("SUCCESS! Your models are working correctly.")
-        print("The warnings have been suppressed in face_recognition.py")
-        print("You can now use your face recognition system without warnings!")
-    else:
-        print("\nERROR: Models are not working properly")
-
-if __name__ == "__main__":
-    main()

app/Hackathon_setup/fix_unknown_class.py

@@ -1,57 +0,0 @@
-"""
-Fix for UNKNOWN_CLASS issue in Hugging Face Space
-"""
-
-import os
-
-def create_fix_summary():
-    """Create a summary of the fix"""
-    print("UNKNOWN_CLASS Issue Fix")
-    print("=" * 50)
-    
-    print("PROBLEM IDENTIFIED:")
-    print("- Classifier has 7 classes: [0, 1, 2, 3, 4, 5, 6]")
-    print("- CLASS_NAMES had only 5 classes: ['Person0', 'Person1', 'Person2', 'Person3', 'Person4']")
-    print("- When classifier predicted class 5 or 6, it resulted in UNKNOWN_CLASS")
-    
-    print("\nFIX APPLIED:")
-    print("- Updated CLASS_NAMES to include all 7 classes:")
-    print("  ['Person0', 'Person1', 'Person2', 'Person3', 'Person4', 'Person5', 'Person6']")
-    
-    print("\nFILES TO UPDATE ON HUGGING FACE:")
-    print("1. face_recognition.py (with updated CLASS_NAMES)")
-    print("2. requirements.txt (for sklearn compatibility)")
-    print("3. All model files (.t7, .sav)")
-    
-    print("\nDEPLOYMENT STEPS:")
-    print("1. Go to: https://huggingface.co/spaces/pavaniyerra/hackthon4")
-    print("2. Click 'Files and versions' tab")
-    print("3. Upload the updated face_recognition.py")
-    print("4. Upload requirements.txt")
-    print("5. Wait for rebuild (2-5 minutes)")
-    
-    print("\nEXPECTED RESULT:")
-    print("- No more UNKNOWN_CLASS predictions")
-    print("- All 7 person classes will be recognized")
-    print("- Face classification will work properly")
-
-def verify_fix():
-    """Verify the fix is correct"""
-    print("\nVerifying fix...")
-    
-    try:
-        from face_recognition import CLASS_NAMES
-        print(f"CLASS_NAMES: {CLASS_NAMES}")
-        print(f"Number of classes: {len(CLASS_NAMES)}")
-        
-        if len(CLASS_NAMES) == 7:
-            print("✓ Fix verified: CLASS_NAMES now has 7 classes")
-        else:
-            print("✗ Fix not applied: CLASS_NAMES still has wrong number of classes")
-            
-    except Exception as e:
-        print(f"Error verifying fix: {e}")
-
-if __name__ == "__main__":
-    create_fix_summary()
-    verify_fix()

app/Hackathon_setup/inspect_classifier.py

@@ -1,61 +0,0 @@
-"""
-Script to inspect the classifier model and understand the class structure
-"""
-
-import joblib
-import os
-
-def inspect_classifier():
-    """Inspect the classifier model to understand class structure"""
-    model_path = 'decision_tree_model.sav'
-    
-    if not os.path.exists(model_path):
-        print(f"Model file {model_path} not found!")
-        return
-    
-    try:
-        # Load the classifier
-        classifier = joblib.load(model_path)
-        
-        print("Classifier Model Inspection")
-        print("=" * 40)
-        print(f"Model type: {type(classifier)}")
-        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_)}")
-        
-        # Check if it's a decision tree
-        if hasattr(classifier, 'tree_'):
-            print(f"Decision tree depth: {classifier.tree_.max_depth}")
-            print(f"Number of leaves: {classifier.tree_.n_leaves}")
-        
-        # Check feature importance if available
-        if hasattr(classifier, 'feature_importances_'):
-            print(f"Feature importances: {classifier.feature_importances_}")
-        
-        # Test with dummy data
-        print("\nTesting with dummy data:")
-        import numpy as np
-        dummy_data = np.random.randn(1, 5)  # Assuming 5 features
-        
-        # Load scaler
-        scaler_path = 'face_recognition_scaler.sav'
-        if os.path.exists(scaler_path):
-            scaler = joblib.load(scaler_path)
-            scaled_data = scaler.transform(dummy_data)
-            prediction = classifier.predict(scaled_data)[0]
-            print(f"Dummy prediction: {prediction}")
-            
-            # Check if prediction is valid
-            if prediction in classifier.classes_:
-                print(f"✓ Prediction {prediction} is valid")
-            else:
-                print(f"✗ Prediction {prediction} is NOT valid!")
-        
-    except Exception as e:
-        print(f"Error loading classifier: {e}")
-        import traceback
-        traceback.print_exc()
-
-if __name__ == "__main__":
-    inspect_classifier()

app/Hackathon_setup/inspect_model.py

@@ -1,41 +0,0 @@
-"""
-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/lbpcascade_frontalface.xml

@@ -1,1505 +0,0 @@
-<?xml version="1.0"?>
-<!--
-number of positive samples 3000
-number of negative samples 1500
--->
-<opencv_storage>
-<cascade type_id="opencv-cascade-classifier">
-  <stageType>BOOST</stageType>
-  <featureType>LBP</featureType>
-  <height>24</height>
-  <width>24</width>
-  <stageParams>
-    <boostType>GAB</boostType>
-    <minHitRate>0.9950000047683716</minHitRate>
-    <maxFalseAlarm>0.5000000000000000</maxFalseAlarm>
-    <weightTrimRate>0.9500000000000000</weightTrimRate>
-    <maxDepth>1</maxDepth>
-    <maxWeakCount>100</maxWeakCount></stageParams>
-  <featureParams>
-    <maxCatCount>256</maxCatCount></featureParams>
-  <stageNum>20</stageNum>
-  <stages>
-    <!-- stage 0 -->
-    <_>
-      <maxWeakCount>3</maxWeakCount>
-      <stageThreshold>-0.7520892024040222</stageThreshold>
-      <weakClassifiers>
-        <!-- tree 0 -->
-        <_>
-          <internalNodes>
-            0 -1 46 -67130709 -21569 -1426120013 -1275125205 -21585
-            -16385 587145899 -24005</internalNodes>
-          <leafValues>
-            -0.6543210148811340 0.8888888955116272</leafValues></_>
-        <!-- tree 1 -->
-        <_>
-          <internalNodes>
-            0 -1 13 -163512766 -769593758 -10027009 -262145 -514457854
-            -193593353 -524289 -1</internalNodes>
-          <leafValues>
-            -0.7739216089248657 0.7278633713722229</leafValues></_>
-        <!-- tree 2 -->
-        <_>
-          <internalNodes>
-            0 -1 2 -363936790 -893203669 -1337948010 -136907894
-            1088782736 -134217726 -741544961 -1590337</internalNodes>
-          <leafValues>
-            -0.7068563103675842 0.6761534214019775</leafValues></_></weakClassifiers></_>
-    <!-- stage 1 -->
-    <_>
-      <maxWeakCount>4</maxWeakCount>
-      <stageThreshold>-0.4872078299522400</stageThreshold>
-      <weakClassifiers>
-        <!-- tree 0 -->
-        <_>
-          <internalNodes>
-            0 -1 84 2147483647 1946124287 -536870913 2147450879
-            738132490 1061101567 243204619 2147446655</internalNodes>
-          <leafValues>
-            -0.8083735704421997 0.7685696482658386</leafValues></_>
-        <!-- tree 1 -->
-        <_>
-          <internalNodes>
-            0 -1 21 2147483647 263176079 1879048191 254749487 1879048191
-            -134252545 -268435457 801111999</internalNodes>
-          <leafValues>
-            -0.7698410153388977 0.6592915654182434</leafValues></_>
-        <!-- tree 2 -->
-        <_>
-          <internalNodes>
-            0 -1 106 -98110272 1610939566 -285484400 -850010381
-            -189334372 -1671954433 -571026695 -262145</internalNodes>
-          <leafValues>
-            -0.7506558895111084 0.5444605946540833</leafValues></_>
-        <!-- tree 3 -->
-        <_>
-          <internalNodes>
-            0 -1 48 -798690576 -131075 1095771153 -237144073 -65569 -1
-            -216727745 -69206049</internalNodes>
-          <leafValues>
-            -0.7775990366935730 0.5465461611747742</leafValues></_></weakClassifiers></_>
-    <!-- stage 2 -->
-    <_>
-      <maxWeakCount>4</maxWeakCount>
-      <stageThreshold>-1.1592328548431396</stageThreshold>
-      <weakClassifiers>
-        <!-- tree 0 -->
-        <_>
-          <internalNodes>
-            0 -1 47 -21585 -20549 -100818262 -738254174 -20561 -36865
-            -151016790 -134238549</internalNodes>
-          <leafValues>
-            -0.5601882934570313 0.7743113040924072</leafValues></_>
-        <!-- tree 1 -->
-        <_>
-          <internalNodes>
-            0 -1 12 -286003217 183435247 -268994614 -421330945
-            -402686081 1090387966 -286785545 -402653185</internalNodes>
-          <leafValues>
-            -0.6124526262283325 0.6978127956390381</leafValues></_>
-        <!-- tree 2 -->
-        <_>
-          <internalNodes>
-            0 -1 26 -50347012 970882927 -50463492 -1253377 -134218251
-            -50364513 -33619992 -172490753</internalNodes>
-          <leafValues>
-            -0.6114496588706970 0.6537628173828125</leafValues></_>
-        <!-- tree 3 -->
-        <_>
-          <internalNodes>
-            0 -1 8 -273 -135266321 1877977738 -2088243418 -134217987
-            2146926575 -18910642 1095231247</internalNodes>
-          <leafValues>
-            -0.6854077577590942 0.5403239130973816</leafValues></_></weakClassifiers></_>
-    <!-- stage 3 -->
-    <_>
-      <maxWeakCount>5</maxWeakCount>
-      <stageThreshold>-0.7562355995178223</stageThreshold>
-      <weakClassifiers>
-        <!-- tree 0 -->
-        <_>
-          <internalNodes>
-            0 -1 96 -1273 1870659519 -20971602 -67633153 -134250731
-            2004875127 -250 -150995969</internalNodes>
-          <leafValues>
-            -0.4051094949245453 0.7584033608436585</leafValues></_>
-        <!-- tree 1 -->
-        <_>
-          <internalNodes>
-            0 -1 33 -868162224 -76810262 -4262145 -257 1465211989
-            -268959873 -2656269 -524289</internalNodes>
-          <leafValues>
-            -0.7388162612915039 0.5340843200683594</leafValues></_>
-        <!-- tree 2 -->
-        <_>
-          <internalNodes>
-            0 -1 57 -12817 -49 -541103378 -152950 -38993 -20481 -1153876
-            -72478976</internalNodes>
-          <leafValues>
-            -0.6582943797111511 0.5339496731758118</leafValues></_>
-        <!-- tree 3 -->
-        <_>
-          <internalNodes>
-            0 -1 125 -269484161 -452984961 -319816180 -1594032130 -2111
-            -990117891 -488975296 -520947741</internalNodes>
-          <leafValues>
-            -0.5981323719024658 0.5323504805564880</leafValues></_>
-        <!-- tree 4 -->
-        <_>
-          <internalNodes>
-            0 -1 53 557787431 670265215 -1342193665 -1075892225
-            1998528318 1056964607 -33570977 -1</internalNodes>
-          <leafValues>
-            -0.6498787999153137 0.4913350641727448</leafValues></_></weakClassifiers></_>
-    <!-- stage 4 -->
-    <_>
-      <maxWeakCount>5</maxWeakCount>
-      <stageThreshold>-0.8085358142852783</stageThreshold>
-      <weakClassifiers>
-        <!-- tree 0 -->
-        <_>
-          <internalNodes>
-            0 -1 60 -536873708 880195381 -16842788 -20971521 -176687276
-            -168427659 -16777260 -33554626</internalNodes>
-          <leafValues>
-            -0.5278195738792419 0.6946372389793396</leafValues></_>
-        <!-- tree 1 -->
-        <_>
-          <internalNodes>
-            0 -1 7 -1 -62981529 -1090591130 805330978 -8388827 -41945787
-            -39577 -531118985</internalNodes>
-          <leafValues>
-            -0.5206505060195923 0.6329920291900635</leafValues></_>
-        <!-- tree 2 -->
-        <_>
-          <internalNodes>
-            0 -1 98 -725287348 1347747543 -852489 -16809993 1489881036
-            -167903241 -1 -1</internalNodes>
-          <leafValues>
-            -0.7516061067581177 0.4232024252414703</leafValues></_>
-        <!-- tree 3 -->
-        <_>
-          <internalNodes>
-            0 -1 44 -32777 1006582562 -65 935312171 -8388609 -1078198273
-            -1 733886267</internalNodes>
-          <leafValues>
-            -0.7639313936233521 0.4123568832874298</leafValues></_>
-        <!-- tree 4 -->
-        <_>
-          <internalNodes>
-            0 -1 24 -85474705 2138828511 -1036436754 817625855
-            1123369029 -58796809 -1013468481 -194513409</internalNodes>
-          <leafValues>
-            -0.5123769044876099 0.5791834592819214</leafValues></_></weakClassifiers></_>
-    <!-- stage 5 -->
-    <_>
-      <maxWeakCount>5</maxWeakCount>
-      <stageThreshold>-0.5549971461296082</stageThreshold>
-      <weakClassifiers>
-        <!-- tree 0 -->
-        <_>
-          <internalNodes>
-            0 -1 42 -17409 -20481 -268457797 -134239493 -17473 -1 -21829
-            -21846</internalNodes>
-          <leafValues>
-            -0.3763174116611481 0.7298233509063721</leafValues></_>
-        <!-- tree 1 -->
-        <_>
-          <internalNodes>
-            0 -1 6 -805310737 -2098262358 -269504725 682502698
-            2147483519 1740574719 -1090519233 -268472385</internalNodes>
-          <leafValues>
-            -0.5352765917778015 0.5659480094909668</leafValues></_>
-        <!-- tree 2 -->
-        <_>
-          <internalNodes>
-            0 -1 61 -67109678 -6145 -8 -87884584 -20481 -1073762305
-            -50856216 -16849696</internalNodes>
-          <leafValues>
-            -0.5678374171257019 0.4961479902267456</leafValues></_>
-        <!-- tree 3 -->
-        <_>
-          <internalNodes>
-            0 -1 123 -138428633 1002418167 -1359008245 -1908670465
-            -1346685918 910098423 -1359010520 -1346371657</internalNodes>
-          <leafValues>
-            -0.5706262588500977 0.4572288393974304</leafValues></_>
-        <!-- tree 4 -->
-        <_>
-          <internalNodes>
-            0 -1 9 -89138513 -4196353 1256531674 -1330665426 1216308261
-            -36190633 33498198 -151796633</internalNodes>
-          <leafValues>
-            -0.5344601869583130 0.4672054052352905</leafValues></_></weakClassifiers></_>
-    <!-- stage 6 -->
-    <_>
-      <maxWeakCount>5</maxWeakCount>
-      <stageThreshold>-0.8776460289955139</stageThreshold>
-      <weakClassifiers>
-        <!-- tree 0 -->
-        <_>
-          <internalNodes>
-            0 -1 105 1073769576 206601725 -34013449 -33554433 -789514004
-            -101384321 -690225153 -264193</internalNodes>
-          <leafValues>
-            -0.7700348496437073 0.5943940877914429</leafValues></_>
-        <!-- tree 1 -->
-        <_>
-          <internalNodes>
-            0 -1 30 -1432340997 -823623681 -49153 -34291724 -269484035
-            -1342767105 -1078198273 -1277955</internalNodes>
-          <leafValues>
-            -0.5043668746948242 0.6151274442672730</leafValues></_>
-        <!-- tree 2 -->
-        <_>
-          <internalNodes>
-            0 -1 35 -1067385040 -195758209 -436748425 -134217731
-            -50855988 -129 -1 -1</internalNodes>
-          <leafValues>
-            -0.6808040738105774 0.4667325913906097</leafValues></_>
-        <!-- tree 3 -->
-        <_>
-          <internalNodes>
-            0 -1 119 832534325 -34111555 -26050561 -423659521 -268468364
-            2105014143 -2114244 -17367185</internalNodes>
-          <leafValues>
-            -0.4927591383457184 0.5401885509490967</leafValues></_>
-        <!-- tree 4 -->
-        <_>
-          <internalNodes>
-            0 -1 82 -1089439888 -1080524865 2143059967 -1114121
-            -1140949004 -3 -2361356 -739516</internalNodes>
-          <leafValues>
-            -0.6445107460021973 0.4227822124958038</leafValues></_></weakClassifiers></_>
-    <!-- stage 7 -->
-    <_>
-      <maxWeakCount>6</maxWeakCount>
-      <stageThreshold>-1.1139287948608398</stageThreshold>
-      <weakClassifiers>
-        <!-- tree 0 -->
-        <_>
-          <internalNodes>
-            0 -1 52 -1074071553 -1074003969 -1 -1280135430 -5324817 -1
-            -335548482 582134442</internalNodes>
-          <leafValues>
-            -0.5307556986808777 0.6258179545402527</leafValues></_>
-        <!-- tree 1 -->
-        <_>
-          <internalNodes>
-            0 -1 99 -706937396 -705364068 -540016724 -570495027
-            -570630659 -587857963 -33628164 -35848193</internalNodes>
-          <leafValues>
-            -0.5227634310722351 0.5049746036529541</leafValues></_>
-        <!-- tree 2 -->
-        <_>
-          <internalNodes>
-            0 -1 18 -2035630093 42119158 -268503053 -1671444 261017599
-            1325432815 1954394111 -805306449</internalNodes>
-          <leafValues>
-            -0.4983572661876679 0.5106441378593445</leafValues></_>
-        <!-- tree 3 -->
-        <_>
-          <internalNodes>
-            0 -1 111 -282529488 -1558073088 1426018736 -170526448
-            -546832487 -5113037 -34243375 -570427929</internalNodes>
-          <leafValues>
-            -0.4990860521793366 0.5060507059097290</leafValues></_>
-        <!-- tree 4 -->
-        <_>
-          <internalNodes>
-            0 -1 92 1016332500 -606301707 915094269 -1080086049
-            -1837027144 -1361600280 2147318747 1067975613</internalNodes>
-          <leafValues>
-            -0.5695009231567383 0.4460467398166657</leafValues></_>
-        <!-- tree 5 -->
-        <_>
-          <internalNodes>
-            0 -1 51 -656420166 -15413034 -141599534 -603435836
-            1505950458 -787556946 -79823438 -1326199134</internalNodes>
-          <leafValues>
-            -0.6590405106544495 0.3616424500942230</leafValues></_></weakClassifiers></_>
-    <!-- stage 8 -->
-    <_>
-      <maxWeakCount>7</maxWeakCount>
-      <stageThreshold>-0.8243625760078430</stageThreshold>
-      <weakClassifiers>
-        <!-- tree 0 -->
-        <_>
-          <internalNodes>
-            0 -1 28 -901591776 -201916417 -262 -67371009 -143312112
-            -524289 -41943178 -1</internalNodes>
-          <leafValues>
-            -0.4972776770591736 0.6027074456214905</leafValues></_>
-        <!-- tree 1 -->
-        <_>
-          <internalNodes>
-            0 -1 112 -4507851 -411340929 -268437513 -67502145 -17350859
-            -32901 -71344315 -29377</internalNodes>
-          <leafValues>
-            -0.4383158981800079 0.5966237187385559</leafValues></_>
-        <!-- tree 2 -->
-        <_>
-          <internalNodes>
-            0 -1 69 -75894785 -117379438 -239063587 -12538500 1485072126
-            2076233213 2123118847 801906927</internalNodes>
-          <leafValues>
-            -0.6386105418205261 0.3977999985218048</leafValues></_>
-        <!-- tree 3 -->
-        <_>
-          <internalNodes>
-            0 -1 19 -823480413 786628589 -16876049 -1364262914 242165211
-            1315930109 -696268833 -455082829</internalNodes>
-          <leafValues>
-            -0.5512794256210327 0.4282079637050629</leafValues></_>
-        <!-- tree 4 -->
-        <_>
-          <internalNodes>
-            0 -1 73 -521411968 6746762 -1396236286 -2038436114
-            -185612509 57669627 -143132877 -1041235973</internalNodes>
-          <leafValues>
-            -0.6418755054473877 0.3549866080284119</leafValues></_>
-        <!-- tree 5 -->
-        <_>
-          <internalNodes>
-            0 -1 126 -478153869 1076028979 -1645895615 1365298272
-            -557859073 -339771473 1442574528 -1058802061</internalNodes>
-          <leafValues>
-            -0.4841901361942291 0.4668019413948059</leafValues></_>
-        <!-- tree 6 -->
-        <_>
-          <internalNodes>
-            0 -1 45 -246350404 -1650402048 -1610612745 -788400696
-            1467604861 -2787397 1476263935 -4481349</internalNodes>
-          <leafValues>
-            -0.5855734348297119 0.3879135847091675</leafValues></_></weakClassifiers></_>
-    <!-- stage 9 -->
-    <_>
-      <maxWeakCount>7</maxWeakCount>
-      <stageThreshold>-1.2237116098403931</stageThreshold>
-      <weakClassifiers>
-        <!-- tree 0 -->
-        <_>
-          <internalNodes>
-            0 -1 114 -24819 1572863935 -16809993 -67108865 2146778388
-            1433927541 -268608444 -34865205</internalNodes>
-          <leafValues>
-            -0.2518476545810700 0.7088654041290283</leafValues></_>
-        <!-- tree 1 -->
-        <_>
-          <internalNodes>
-            0 -1 97 -1841359 -134271049 -32769 -5767369 -1116675 -2185
-            -8231 -33603327</internalNodes>
-          <leafValues>
-            -0.4303432404994965 0.5283288359642029</leafValues></_>
-        <!-- tree 2 -->
-        <_>
-          <internalNodes>
-            0 -1 25 -1359507589 -1360593090 -1073778729 -269553812
-            -809512977 1744707583 -41959433 -134758978</internalNodes>
-          <leafValues>
-            -0.4259553551673889 0.5440809130668640</leafValues></_>
-        <!-- tree 3 -->
-        <_>
-          <internalNodes>
-            0 -1 34 729753407 -134270989 -1140907329 -235200777
-            658456383 2147467263 -1140900929 -16385</internalNodes>
-          <leafValues>
-            -0.5605589151382446 0.4220733344554901</leafValues></_>
-        <!-- tree 4 -->
-        <_>
-          <internalNodes>
-            0 -1 134 -310380553 -420675595 -193005472 -353568129
-            1205338070 -990380036 887604324 -420544526</internalNodes>
-          <leafValues>
-            -0.5192656517028809 0.4399855434894562</leafValues></_>
-        <!-- tree 5 -->
-        <_>
-          <internalNodes>
-            0 -1 16 -1427119361 1978920959 -287119734 -487068946
-            114759245 -540578051 -707510259 -671660453</internalNodes>
-          <leafValues>
-            -0.5013077259063721 0.4570254683494568</leafValues></_>
-        <!-- tree 6 -->
-        <_>
-          <internalNodes>
-            0 -1 74 -738463762 -889949281 -328301948 -121832450
-            -1142658284 -1863576559 2146417353 -263185</internalNodes>
-          <leafValues>
-            -0.4631414115428925 0.4790246188640595</leafValues></_></weakClassifiers></_>
-    <!-- stage 10 -->
-    <_>
-      <maxWeakCount>7</maxWeakCount>
-      <stageThreshold>-0.5544230937957764</stageThreshold>
-      <weakClassifiers>
-        <!-- tree 0 -->
-        <_>
-          <internalNodes>
-            0 -1 113 -76228780 -65538 -1 -67174401 -148007 -33 -221796
-            -272842924</internalNodes>
-          <leafValues>
-            -0.3949716091156006 0.6082032322883606</leafValues></_>
-        <!-- tree 1 -->
-        <_>
-          <internalNodes>
-            0 -1 110 369147696 -1625232112 2138570036 -1189900 790708019
-            -1212613127 799948719 -4456483</internalNodes>
-          <leafValues>
-            -0.4855885505676270 0.4785369932651520</leafValues></_>
-        <!-- tree 2 -->
-        <_>
-          <internalNodes>
-            0 -1 37 784215839 -290015241 536832799 -402984963
-            -1342414991 -838864897 -176769 -268456129</internalNodes>
-          <leafValues>
-            -0.4620285332202911 0.4989669024944305</leafValues></_>
-        <!-- tree 3 -->
-        <_>
-          <internalNodes>
-            0 -1 41 -486418688 -171915327 -340294900 -21938 -519766032
-            -772751172 -73096060 -585322623</internalNodes>
-          <leafValues>
-            -0.6420643329620361 0.3624351918697357</leafValues></_>
-        <!-- tree 4 -->
-        <_>
-          <internalNodes>
-            0 -1 117 -33554953 -475332625 -1423463824 -2077230421
-            -4849669 -2080505925 -219032928 -1071915349</internalNodes>
-          <leafValues>
-            -0.4820112884044647 0.4632140696048737</leafValues></_>
-        <!-- tree 5 -->
-        <_>
-          <internalNodes>
-            0 -1 65 -834130468 -134217476 -1349314083 -1073803559
-            -619913764 -1449131844 -1386890321 -1979118423</internalNodes>
-          <leafValues>
-            -0.4465552568435669 0.5061788558959961</leafValues></_>
-        <!-- tree 6 -->
-        <_>
-          <internalNodes>
-            0 -1 56 -285249779 1912569855 -16530 -1731022870 -1161904146
-            -1342177297 -268439634 -1464078708</internalNodes>
-          <leafValues>
-            -0.5190586447715759 0.4441480338573456</leafValues></_></weakClassifiers></_>
-    <!-- stage 11 -->
-    <_>
-      <maxWeakCount>7</maxWeakCount>
-      <stageThreshold>-0.7161560654640198</stageThreshold>
-      <weakClassifiers>
-        <!-- tree 0 -->
-        <_>
-          <internalNodes>
-            0 -1 20 1246232575 1078001186 -10027057 60102 -277348353
-            -43646987 -1210581153 1195769615</internalNodes>
-          <leafValues>
-            -0.4323809444904327 0.5663768053054810</leafValues></_>
-        <!-- tree 1 -->
-        <_>
-          <internalNodes>
-            0 -1 15 -778583572 -612921106 -578775890 -4036478
-            -1946580497 -1164766570 -1986687009 -12103599</internalNodes>
-          <leafValues>
-            -0.4588732719421387 0.4547033011913300</leafValues></_>
-        <!-- tree 2 -->
-        <_>
-          <internalNodes>
-            0 -1 129 -1073759445 2013231743 -1363169553 -1082459201
-            -1414286549 868185983 -1356133589 -1077936257</internalNodes>
-          <leafValues>
-            -0.5218553543090820 0.4111092388629913</leafValues></_>
-        <!-- tree 3 -->
-        <_>
-          <internalNodes>
-            0 -1 102 -84148365 -2093417722 -1204850272 564290299
-            -67121221 -1342177350 -1309195902 -776734797</internalNodes>
-          <leafValues>
-            -0.4920000731945038 0.4326725304126740</leafValues></_>
-        <!-- tree 4 -->
-        <_>
-          <internalNodes>
-            0 -1 88 -25694458 67104495 -290216278 -168563037 2083877442
-            1702788383 -144191964 -234882162</internalNodes>
-          <leafValues>
-            -0.4494568109512329 0.4448510706424713</leafValues></_>
-        <!-- tree 5 -->
-        <_>
-          <internalNodes>
-            0 -1 59 -857980836 904682741 -1612267521 232279415
-            1550862252 -574825221 -357380888 -4579409</internalNodes>
-          <leafValues>
-            -0.5180826783180237 0.3888972699642181</leafValues></_>
-        <!-- tree 6 -->
-        <_>
-          <internalNodes>
-            0 -1 27 -98549440 -137838400 494928389 -246013630 939541351
-            -1196072350 -620603549 2137216273</internalNodes>
-          <leafValues>
-            -0.6081240773200989 0.3333222270011902</leafValues></_></weakClassifiers></_>
-    <!-- stage 12 -->
-    <_>
-      <maxWeakCount>8</maxWeakCount>
-      <stageThreshold>-0.6743940711021423</stageThreshold>
-      <weakClassifiers>
-        <!-- tree 0 -->
-        <_>
-          <internalNodes>
-            0 -1 29 -150995201 2071191945 -1302151626 536934335
-            -1059008937 914128709 1147328110 -268369925</internalNodes>
-          <leafValues>
-            -0.1790193915367127 0.6605972051620483</leafValues></_>
-        <!-- tree 1 -->
-        <_>
-          <internalNodes>
-            0 -1 128 -134509479 1610575703 -1342177289 1861484541
-            -1107833788 1577058173 -333558568 -136319041</internalNodes>
-          <leafValues>
-            -0.3681024610996246 0.5139749646186829</leafValues></_>
-        <!-- tree 2 -->
-        <_>
-          <internalNodes>
-            0 -1 70 -1 1060154476 -1090984524 -630918524 -539492875
-            779616255 -839568424 -321</internalNodes>
-          <leafValues>
-            -0.3217232525348663 0.6171553134918213</leafValues></_>
-        <!-- tree 3 -->
-        <_>
-          <internalNodes>
-            0 -1 4 -269562385 -285029906 -791084350 -17923776 235286671
-            1275504943 1344390399 -966276889</internalNodes>
-          <leafValues>
-            -0.4373284578323364 0.4358185231685638</leafValues></_>
-        <!-- tree 4 -->
-        <_>
-          <internalNodes>
-            0 -1 76 17825984 -747628419 595427229 1474759671 575672208
-            -1684005538 872217086 -1155858277</internalNodes>
-          <leafValues>
-            -0.4404836893081665 0.4601220190525055</leafValues></_>
-        <!-- tree 5 -->
-        <_>
-          <internalNodes>
-            0 -1 124 -336593039 1873735591 -822231622 -355795238
-            -470820869 -1997537409 -1057132384 -1015285005</internalNodes>
-          <leafValues>
-            -0.4294152259826660 0.4452161788940430</leafValues></_>
-        <!-- tree 6 -->
-        <_>
-          <internalNodes>
-            0 -1 54 -834212130 -593694721 -322142257 -364892500
-            -951029539 -302125121 -1615106053 -79249765</internalNodes>
-          <leafValues>
-            -0.3973052501678467 0.4854526817798615</leafValues></_>
-        <!-- tree 7 -->
-        <_>
-          <internalNodes>
-            0 -1 95 1342144479 2147431935 -33554561 -47873 -855685912 -1
-            1988052447 536827383</internalNodes>
-          <leafValues>
-            -0.7054683566093445 0.2697997391223908</leafValues></_></weakClassifiers></_>
-    <!-- stage 13 -->
-    <_>
-      <maxWeakCount>9</maxWeakCount>
-      <stageThreshold>-1.2042298316955566</stageThreshold>
-      <weakClassifiers>
-        <!-- tree 0 -->
-        <_>
-          <internalNodes>
-            0 -1 39 1431368960 -183437936 -537002499 -137497097
-            1560590321 -84611081 -2097193 -513</internalNodes>
-          <leafValues>
-            -0.5905947685241699 0.5101932883262634</leafValues></_>
-        <!-- tree 1 -->
-        <_>
-          <internalNodes>
-            0 -1 120 -1645259691 2105491231 2130706431 1458995007
-            -8567536 -42483883 -33780003 -21004417</internalNodes>
-          <leafValues>
-            -0.4449204802513123 0.4490709304809570</leafValues></_>
-        <!-- tree 2 -->
-        <_>
-          <internalNodes>
-            0 -1 89 -612381022 -505806938 -362027516 -452985106
-            275854917 1920431639 -12600561 -134221825</internalNodes>
-          <leafValues>
-            -0.4693818688392639 0.4061094820499420</leafValues></_>
-        <!-- tree 3 -->
-        <_>
-          <internalNodes>
-            0 -1 14 -805573153 -161 -554172679 -530519488 -16779441
-            2000682871 -33604275 -150997129</internalNodes>
-          <leafValues>
-            -0.3600351214408875 0.5056326985359192</leafValues></_>
-        <!-- tree 4 -->
-        <_>
-          <internalNodes>
-            0 -1 67 6192 435166195 1467449341 2046691505 -1608493775
-            -4755729 -1083162625 -71365637</internalNodes>
-          <leafValues>
-            -0.4459891915321350 0.4132415652275085</leafValues></_>
-        <!-- tree 5 -->
-        <_>
-          <internalNodes>
-            0 -1 86 -41689215 -3281034 1853357967 -420712635 -415924289
-            -270209208 -1088293113 -825311232</internalNodes>
-          <leafValues>
-            -0.4466069042682648 0.4135067760944367</leafValues></_>
-        <!-- tree 6 -->
-        <_>
-          <internalNodes>
-            0 -1 80 -117391116 -42203396 2080374461 -188709 -542008165
-            -356831940 -1091125345 -1073796897</internalNodes>
-          <leafValues>
-            -0.3394956290721893 0.5658645033836365</leafValues></_>
-        <!-- tree 7 -->
-        <_>
-          <internalNodes>
-            0 -1 75 -276830049 1378714472 -1342181951 757272098
-            1073740607 -282199241 -415761549 170896931</internalNodes>
-          <leafValues>
-            -0.5346512198448181 0.3584479391574860</leafValues></_>
-        <!-- tree 8 -->
-        <_>
-          <internalNodes>
-            0 -1 55 -796075825 -123166849 2113667055 -217530421
-            -1107432194 -16385 -806359809 -391188771</internalNodes>
-          <leafValues>
-            -0.4379335641860962 0.4123645126819611</leafValues></_></weakClassifiers></_>
-    <!-- stage 14 -->
-    <_>
-      <maxWeakCount>10</maxWeakCount>
-      <stageThreshold>-0.8402050137519836</stageThreshold>
-      <weakClassifiers>
-        <!-- tree 0 -->
-        <_>
-          <internalNodes>
-            0 -1 71 -890246622 15525883 -487690486 47116238 -1212319899
-            -1291847681 -68159890 -469829921</internalNodes>
-          <leafValues>
-            -0.2670986354351044 0.6014143228530884</leafValues></_>
-        <!-- tree 1 -->
-        <_>
-          <internalNodes>
-            0 -1 31 -1361180685 -1898008841 -1090588811 -285410071
-            -1074016265 -840443905 2147221487 -262145</internalNodes>
-          <leafValues>
-            -0.4149844348430634 0.4670888185501099</leafValues></_>
-        <!-- tree 2 -->
-        <_>
-          <internalNodes>
-            0 -1 40 1426190596 1899364271 2142731795 -142607505
-            -508232452 -21563393 -41960001 -65</internalNodes>
-          <leafValues>
-            -0.4985891580581665 0.3719584941864014</leafValues></_>
-        <!-- tree 3 -->
-        <_>
-          <internalNodes>
-            0 -1 109 -201337965 10543906 -236498096 -746195597
-            1974565825 -15204415 921907633 -190058309</internalNodes>
-          <leafValues>
-            -0.4568729996681213 0.3965812027454376</leafValues></_>
-        <!-- tree 4 -->
-        <_>
-          <internalNodes>
-            0 -1 130 -595026732 -656401928 -268649235 -571490699
-            -440600392 -133131 -358810952 -2004088646</internalNodes>
-          <leafValues>
-            -0.4770836830139160 0.3862601518630981</leafValues></_>
-        <!-- tree 5 -->
-        <_>
-          <internalNodes>
-            0 -1 66 941674740 -1107882114 1332789109 -67691015
-            -1360463693 -1556612430 -609108546 733546933</internalNodes>
-          <leafValues>
-            -0.4877715110778809 0.3778986334800720</leafValues></_>
-        <!-- tree 6 -->
-        <_>
-          <internalNodes>
-            0 -1 49 -17114945 -240061474 1552871558 -82775604 -932393844
-            -1308544889 -532635478 -99042357</internalNodes>
-          <leafValues>
-            -0.3721654713153839 0.4994400143623352</leafValues></_>
-        <!-- tree 7 -->
-        <_>
-          <internalNodes>
-            0 -1 133 -655906006 1405502603 -939205164 1884929228
-            -498859222 559417357 -1928559445 -286264385</internalNodes>
-          <leafValues>
-            -0.3934195041656494 0.4769641458988190</leafValues></_>
-        <!-- tree 8 -->
-        <_>
-          <internalNodes>
-            0 -1 0 -335837777 1860677295 -90 -1946186226 931096183
-            251612987 2013265917 -671232197</internalNodes>
-          <leafValues>
-            -0.4323300719261169 0.4342164099216461</leafValues></_>
-        <!-- tree 9 -->
-        <_>
-          <internalNodes>
-            0 -1 103 37769424 -137772680 374692301 2002666345 -536176194
-            -1644484728 807009019 1069089930</internalNodes>
-          <leafValues>
-            -0.4993278682231903 0.3665378093719482</leafValues></_></weakClassifiers></_>
-    <!-- stage 15 -->
-    <_>
-      <maxWeakCount>9</maxWeakCount>
-      <stageThreshold>-1.1974394321441650</stageThreshold>
-      <weakClassifiers>
-        <!-- tree 0 -->
-        <_>
-          <internalNodes>
-            0 -1 43 -5505 2147462911 2143265466 -4511070 -16450 -257
-            -201348440 -71333206</internalNodes>
-          <leafValues>
-            -0.3310225307941437 0.5624626278877258</leafValues></_>
-        <!-- tree 1 -->
-        <_>
-          <internalNodes>
-            0 -1 90 -136842268 -499330741 2015250980 -87107126
-            -641665744 -788524639 -1147864792 -134892563</internalNodes>
-          <leafValues>
-            -0.5266560912132263 0.3704403042793274</leafValues></_>
-        <!-- tree 2 -->
-        <_>
-          <internalNodes>
-            0 -1 104 -146800880 -1780368555 2111170033 -140904684
-            -16777551 -1946681885 -1646463595 -839131947</internalNodes>
-          <leafValues>
-            -0.4171888828277588 0.4540435671806335</leafValues></_>
-        <!-- tree 3 -->
-        <_>
-          <internalNodes>
-            0 -1 85 -832054034 -981663763 -301990281 -578814081
-            -932319000 -1997406723 -33555201 -69206017</internalNodes>
-          <leafValues>
-            -0.4556705355644226 0.3704262077808380</leafValues></_>
-        <!-- tree 4 -->
-        <_>
-          <internalNodes>
-            0 -1 24 -118492417 -1209026825 1119023838 -1334313353
-            1112948738 -297319313 1378887291 -139469193</internalNodes>
-          <leafValues>
-            -0.4182529747486115 0.4267231225967407</leafValues></_>
-        <!-- tree 5 -->
-        <_>
-          <internalNodes>
-            0 -1 78 -1714382628 -2353704 -112094959 -549613092
-            -1567058760 -1718550464 -342315012 -1074972227</internalNodes>
-          <leafValues>
-            -0.3625369668006897 0.4684656262397766</leafValues></_>
-        <!-- tree 6 -->
-        <_>
-          <internalNodes>
-            0 -1 5 -85219702 316836394 -33279 1904970288 2117267315
-            -260901769 -621461759 -88607770</internalNodes>
-          <leafValues>
-            -0.4742925167083740 0.3689507246017456</leafValues></_>
-        <!-- tree 7 -->
-        <_>
-          <internalNodes>
-            0 -1 11 -294654041 -353603585 -1641159686 -50331921
-            -2080899877 1145569279 -143132713 -152044037</internalNodes>
-          <leafValues>
-            -0.3666271567344666 0.4580127298831940</leafValues></_>
-        <!-- tree 8 -->
-        <_>
-          <internalNodes>
-            0 -1 32 1887453658 -638545712 -1877976819 -34320972
-            -1071067983 -661345416 -583338277 1060190561</internalNodes>
-          <leafValues>
-            -0.4567637443542481 0.3894708156585693</leafValues></_></weakClassifiers></_>
-    <!-- stage 16 -->
-    <_>
-      <maxWeakCount>9</maxWeakCount>
-      <stageThreshold>-0.5733128190040588</stageThreshold>
-      <weakClassifiers>
-        <!-- tree 0 -->
-        <_>
-          <internalNodes>
-            0 -1 122 -994063296 1088745462 -318837116 -319881377
-            1102566613 1165490103 -121679694 -134744129</internalNodes>
-          <leafValues>
-            -0.4055117964744568 0.5487945079803467</leafValues></_>
-        <!-- tree 1 -->
-        <_>
-          <internalNodes>
-            0 -1 68 -285233233 -538992907 1811935199 -369234005 -529
-            -20593 -20505 -1561401854</internalNodes>
-          <leafValues>
-            -0.3787897229194641 0.4532003402709961</leafValues></_>
-        <!-- tree 2 -->
-        <_>
-          <internalNodes>
-            0 -1 58 -1335245632 1968917183 1940861695 536816369
-            -1226071367 -570908176 457026619 1000020667</internalNodes>
-          <leafValues>
-            -0.4258328974246979 0.4202791750431061</leafValues></_>
-        <!-- tree 3 -->
-        <_>
-          <internalNodes>
-            0 -1 94 -1360318719 -1979797897 -50435249 -18646473
-            -608879292 -805306691 -269304244 -17840167</internalNodes>
-          <leafValues>
-            -0.4561023116111755 0.4002747833728790</leafValues></_>
-        <!-- tree 4 -->
-        <_>
-          <internalNodes>
-            0 -1 87 2062765935 -16449 -1275080721 -16406 45764335
-            -1090552065 -772846337 -570464322</internalNodes>
-          <leafValues>
-            -0.4314672648906708 0.4086346626281738</leafValues></_>
-        <!-- tree 5 -->
-        <_>
-          <internalNodes>
-            0 -1 127 -536896021 1080817663 -738234288 -965478709
-            -2082767969 1290855887 1993822934 -990381609</internalNodes>
-          <leafValues>
-            -0.4174543321132660 0.4249868988990784</leafValues></_>
-        <!-- tree 6 -->
-        <_>
-          <internalNodes>
-            0 -1 3 -818943025 168730891 -293610428 -79249354 669224671
-            621166734 1086506807 1473768907</internalNodes>
-          <leafValues>
-            -0.4321364760398865 0.4090838730335236</leafValues></_>
-        <!-- tree 7 -->
-        <_>
-          <internalNodes>
-            0 -1 79 -68895696 -67107736 -1414315879 -841676168
-            -619843344 -1180610531 -1081990469 1043203389</internalNodes>
-          <leafValues>
-            -0.5018386244773865 0.3702533841133118</leafValues></_>
-        <!-- tree 8 -->
-        <_>
-          <internalNodes>
-            0 -1 116 -54002134 -543485719 -2124882422 -1437445858
-            -115617074 -1195787391 -1096024366 -2140472445</internalNodes>
-          <leafValues>
-            -0.5037505626678467 0.3564981222152710</leafValues></_></weakClassifiers></_>
-    <!-- stage 17 -->
-    <_>
-      <maxWeakCount>9</maxWeakCount>
-      <stageThreshold>-0.4892596900463104</stageThreshold>
-      <weakClassifiers>
-        <!-- tree 0 -->
-        <_>
-          <internalNodes>
-            0 -1 132 -67113211 2003808111 1862135111 846461923 -2752
-            2002237273 -273154752 1937223539</internalNodes>
-          <leafValues>
-            -0.2448196411132813 0.5689709186553955</leafValues></_>
-        <!-- tree 1 -->
-        <_>
-          <internalNodes>
-            0 -1 62 1179423888 -78064940 -611839555 -539167899
-            -1289358360 -1650810108 -892540499 -1432827684</internalNodes>
-          <leafValues>
-            -0.4633283913135529 0.3587929606437683</leafValues></_>
-        <!-- tree 2 -->
-        <_>
-          <internalNodes>
-            0 -1 23 -285212705 -78450761 -656212031 -264050110 -27787425
-            -1334349961 -547662981 -135796924</internalNodes>
-          <leafValues>
-            -0.3731099069118500 0.4290455579757690</leafValues></_>
-        <!-- tree 3 -->
-        <_>
-          <internalNodes>
-            0 -1 77 341863476 403702016 -550588417 1600194541
-            -1080690735 951127993 -1388580949 -1153717473</internalNodes>
-          <leafValues>
-            -0.3658909499645233 0.4556473195552826</leafValues></_>
-        <!-- tree 4 -->
-        <_>
-          <internalNodes>
-            0 -1 22 -586880702 -204831512 -100644596 -39319550
-            -1191150794 705692513 457203315 -75806957</internalNodes>
-          <leafValues>
-            -0.5214384198188782 0.3221037387847900</leafValues></_>
-        <!-- tree 5 -->
-        <_>
-          <internalNodes>
-            0 -1 72 -416546870 545911370 -673716192 -775559454
-            -264113598 139424 -183369982 -204474641</internalNodes>
-          <leafValues>
-            -0.4289036989212036 0.4004956185817719</leafValues></_>
-        <!-- tree 6 -->
-        <_>
-          <internalNodes>
-            0 -1 50 -1026505020 -589692154 -1740499937 -1563770497
-            1348491006 -60710713 -1109853489 -633909413</internalNodes>
-          <leafValues>
-            -0.4621542394161224 0.3832748532295227</leafValues></_>
-        <!-- tree 7 -->
-        <_>
-          <internalNodes>
-            0 -1 108 -1448872304 -477895040 -1778390608 -772418127
-            -1789923416 -1612057181 -805306693 -1415842113</internalNodes>
-          <leafValues>
-            -0.3711548447608948 0.4612701535224915</leafValues></_>
-        <!-- tree 8 -->
-        <_>
-          <internalNodes>
-            0 -1 92 407905424 -582449988 52654751 -1294472 -285103725
-            -74633006 1871559083 1057955850</internalNodes>
-          <leafValues>
-            -0.5180652141571045 0.3205870389938355</leafValues></_></weakClassifiers></_>
-    <!-- stage 18 -->
-    <_>
-      <maxWeakCount>10</maxWeakCount>
-      <stageThreshold>-0.5911940932273865</stageThreshold>
-      <weakClassifiers>
-        <!-- tree 0 -->
-        <_>
-          <internalNodes>
-            0 -1 81 4112 -1259563825 -846671428 -100902460 1838164148
-            -74153752 -90653988 -1074263896</internalNodes>
-          <leafValues>
-            -0.2592592537403107 0.5873016119003296</leafValues></_>
-        <!-- tree 1 -->
-        <_>
-          <internalNodes>
-            0 -1 1 -285216785 -823206977 -1085589 -1081346 1207959293
-            1157103471 2097133565 -2097169</internalNodes>
-          <leafValues>
-            -0.3801195919513702 0.4718827307224274</leafValues></_>
-        <!-- tree 2 -->
-        <_>
-          <internalNodes>
-            0 -1 121 -12465 -536875169 2147478367 2130706303 -37765492
-            -866124467 -318782328 -1392509185</internalNodes>
-          <leafValues>
-            -0.3509117066860199 0.5094807147979736</leafValues></_>
-        <!-- tree 3 -->
-        <_>
-          <internalNodes>
-            0 -1 38 2147449663 -20741 -16794757 1945873146 -16710 -1
-            -8406341 -67663041</internalNodes>
-          <leafValues>
-            -0.4068757295608521 0.4130136370658875</leafValues></_>
-        <!-- tree 4 -->
-        <_>
-          <internalNodes>
-            0 -1 17 -155191713 866117231 1651407483 548272812 -479201468
-            -447742449 1354229504 -261884429</internalNodes>
-          <leafValues>
-            -0.4557141065597534 0.3539792001247406</leafValues></_>
-        <!-- tree 5 -->
-        <_>
-          <internalNodes>
-            0 -1 100 -225319378 -251682065 -492783986 -792341777
-            -1287261695 1393643841 -11274182 -213909521</internalNodes>
-          <leafValues>
-            -0.4117803275585175 0.4118592441082001</leafValues></_>
-        <!-- tree 6 -->
-        <_>
-          <internalNodes>
-            0 -1 63 -382220122 -2002072729 -51404800 -371201558
-            -923011069 -2135301457 -2066104743 -1042557441</internalNodes>
-          <leafValues>
-            -0.4008397758007050 0.4034757018089294</leafValues></_>
-        <!-- tree 7 -->
-        <_>
-          <internalNodes>
-            0 -1 101 -627353764 -48295149 1581203952 -436258614
-            -105268268 -1435893445 -638126888 -1061107126</internalNodes>
-          <leafValues>
-            -0.5694189667701721 0.2964762747287750</leafValues></_>
-        <!-- tree 8 -->
-        <_>
-          <internalNodes>
-            0 -1 118 -8399181 1058107691 -621022752 -251003468 -12582915
-            -574619739 -994397789 -1648362021</internalNodes>
-          <leafValues>
-            -0.3195341229438782 0.5294018983840942</leafValues></_>
-        <!-- tree 9 -->
-        <_>
-          <internalNodes>
-            0 -1 92 -348343812 -1078389516 1717960437 364735981
-            -1783841602 -4883137 -457572354 -1076950384</internalNodes>
-          <leafValues>
-            -0.3365339040756226 0.5067458748817444</leafValues></_></weakClassifiers></_>
-    <!-- stage 19 -->
-    <_>
-      <maxWeakCount>10</maxWeakCount>
-      <stageThreshold>-0.7612916231155396</stageThreshold>
-      <weakClassifiers>
-        <!-- tree 0 -->
-        <_>
-          <internalNodes>
-            0 -1 10 -1976661318 -287957604 -1659497122 -782068 43591089
-            -453637880 1435470000 -1077438561</internalNodes>
-          <leafValues>
-            -0.4204545319080353 0.5165745615959168</leafValues></_>
-        <!-- tree 1 -->
-        <_>
-          <internalNodes>
-            0 -1 131 -67110925 14874979 -142633168 -1338923040
-            2046713291 -2067933195 1473503712 -789579837</internalNodes>
-          <leafValues>
-            -0.3762553930282593 0.4075302779674530</leafValues></_>
-        <!-- tree 2 -->
-        <_>
-          <internalNodes>
-            0 -1 83 -272814301 -1577073 -1118685 -305156120 -1052289
-            -1073813756 -538971154 -355523038</internalNodes>
-          <leafValues>
-            -0.4253497421741486 0.3728055357933044</leafValues></_>
-        <!-- tree 3 -->
-        <_>
-          <internalNodes>
-            0 -1 135 -2233 -214486242 -538514758 573747007 -159390971
-            1994225489 -973738098 -203424005</internalNodes>
-          <leafValues>
-            -0.3601998090744019 0.4563256204128265</leafValues></_>
-        <!-- tree 4 -->
-        <_>
-          <internalNodes>
-            0 -1 115 -261031688 -1330369299 -641860609 1029570301
-            -1306461192 -1196149518 -1529767778 683139823</internalNodes>
-          <leafValues>
-            -0.4034293889999390 0.4160816967487335</leafValues></_>
-        <!-- tree 5 -->
-        <_>
-          <internalNodes>
-            0 -1 64 -572993608 -34042628 -417865 -111109 -1433365268
-            -19869715 -1920939864 -1279457063</internalNodes>
-          <leafValues>
-            -0.3620899617671967 0.4594142735004425</leafValues></_>
-        <!-- tree 6 -->
-        <_>
-          <internalNodes>
-            0 -1 36 -626275097 -615256993 1651946018 805366393
-            2016559730 -430780849 -799868165 -16580645</internalNodes>
-          <leafValues>
-            -0.3903816640377045 0.4381459355354309</leafValues></_>
-        <!-- tree 7 -->
-        <_>
-          <internalNodes>
-            0 -1 93 1354797300 -1090957603 1976418270 -1342502178
-            -1851873892 -1194637077 -1153521668 -1108399474</internalNodes>
-          <leafValues>
-            -0.3591445386409760 0.4624078869819641</leafValues></_>
-        <!-- tree 8 -->
-        <_>
-          <internalNodes>
-            0 -1 91 68157712 1211368313 -304759523 1063017136 798797750
-            -275513546 648167355 -1145357350</internalNodes>
-          <leafValues>
-            -0.4297670423984528 0.4023293554782867</leafValues></_>
-        <!-- tree 9 -->
-        <_>
-          <internalNodes>
-            0 -1 107 -546318240 -1628569602 -163577944 -537002306
-            -545456389 -1325465645 -380446736 -1058473386</internalNodes>
-          <leafValues>
-            -0.5727006793022156 0.2995934784412384</leafValues></_></weakClassifiers></_></stages>
-  <features>
-    <_>
-      <rect>
-        0 0 3 5</rect></_>
-    <_>
-      <rect>
-        0 0 4 2</rect></_>
-    <_>
-      <rect>
-        0 0 6 3</rect></_>
-    <_>
-      <rect>
-        0 1 2 3</rect></_>
-    <_>
-      <rect>
-        0 1 3 3</rect></_>
-    <_>
-      <rect>
-        0 1 3 7</rect></_>
-    <_>
-      <rect>
-        0 4 3 3</rect></_>
-    <_>
-      <rect>
-        0 11 3 4</rect></_>
-    <_>
-      <rect>
-        0 12 8 4</rect></_>
-    <_>
-      <rect>
-        0 14 4 3</rect></_>
-    <_>
-      <rect>
-        1 0 5 3</rect></_>
-    <_>
-      <rect>
-        1 1 2 2</rect></_>
-    <_>
-      <rect>
-        1 3 3 1</rect></_>
-    <_>
-      <rect>
-        1 7 4 4</rect></_>
-    <_>
-      <rect>
-        1 12 2 2</rect></_>
-    <_>
-      <rect>
-        1 13 4 1</rect></_>
-    <_>
-      <rect>
-        1 14 4 3</rect></_>
-    <_>
-      <rect>
-        1 17 3 2</rect></_>
-    <_>
-      <rect>
-        2 0 2 3</rect></_>
-    <_>
-      <rect>
-        2 1 2 2</rect></_>
-    <_>
-      <rect>
-        2 2 4 6</rect></_>
-    <_>
-      <rect>
-        2 3 4 4</rect></_>
-    <_>
-      <rect>
-        2 7 2 1</rect></_>
-    <_>
-      <rect>
-        2 11 2 3</rect></_>
-    <_>
-      <rect>
-        2 17 3 2</rect></_>
-    <_>
-      <rect>
-        3 0 2 2</rect></_>
-    <_>
-      <rect>
-        3 1 7 3</rect></_>
-    <_>
-      <rect>
-        3 7 2 1</rect></_>
-    <_>
-      <rect>
-        3 7 2 4</rect></_>
-    <_>
-      <rect>
-        3 18 2 2</rect></_>
-    <_>
-      <rect>
-        4 0 2 3</rect></_>
-    <_>
-      <rect>
-        4 3 2 1</rect></_>
-    <_>
-      <rect>
-        4 6 2 1</rect></_>
-    <_>
-      <rect>
-        4 6 2 5</rect></_>
-    <_>
-      <rect>
-        4 7 5 2</rect></_>
-    <_>
-      <rect>
-        4 8 4 3</rect></_>
-    <_>
-      <rect>
-        4 18 2 2</rect></_>
-    <_>
-      <rect>
-        5 0 2 2</rect></_>
-    <_>
-      <rect>
-        5 3 4 4</rect></_>
-    <_>
-      <rect>
-        5 6 2 5</rect></_>
-    <_>
-      <rect>
-        5 9 2 2</rect></_>
-    <_>
-      <rect>
-        5 10 2 2</rect></_>
-    <_>
-      <rect>
-        6 3 4 4</rect></_>
-    <_>
-      <rect>
-        6 4 4 3</rect></_>
-    <_>
-      <rect>
-        6 5 2 3</rect></_>
-    <_>
-      <rect>
-        6 5 2 5</rect></_>
-    <_>
-      <rect>
-        6 5 4 3</rect></_>
-    <_>
-      <rect>
-        6 6 4 2</rect></_>
-    <_>
-      <rect>
-        6 6 4 4</rect></_>
-    <_>
-      <rect>
-        6 18 1 2</rect></_>
-    <_>
-      <rect>
-        6 21 2 1</rect></_>
-    <_>
-      <rect>
-        7 0 3 7</rect></_>
-    <_>
-      <rect>
-        7 4 2 3</rect></_>
-    <_>
-      <rect>
-        7 9 5 1</rect></_>
-    <_>
-      <rect>
-        7 21 2 1</rect></_>
-    <_>
-      <rect>
-        8 0 1 4</rect></_>
-    <_>
-      <rect>
-        8 5 2 2</rect></_>
-    <_>
-      <rect>
-        8 5 3 2</rect></_>
-    <_>
-      <rect>
-        8 17 3 1</rect></_>
-    <_>
-      <rect>
-        8 18 1 2</rect></_>
-    <_>
-      <rect>
-        9 0 5 3</rect></_>
-    <_>
-      <rect>
-        9 2 2 6</rect></_>
-    <_>
-      <rect>
-        9 5 1 1</rect></_>
-    <_>
-      <rect>
-        9 11 1 1</rect></_>
-    <_>
-      <rect>
-        9 16 1 1</rect></_>
-    <_>
-      <rect>
-        9 16 2 1</rect></_>
-    <_>
-      <rect>
-        9 17 1 1</rect></_>
-    <_>
-      <rect>
-        9 18 1 1</rect></_>
-    <_>
-      <rect>
-        10 5 1 2</rect></_>
-    <_>
-      <rect>
-        10 5 3 3</rect></_>
-    <_>
-      <rect>
-        10 7 1 5</rect></_>
-    <_>
-      <rect>
-        10 8 1 1</rect></_>
-    <_>
-      <rect>
-        10 9 1 1</rect></_>
-    <_>
-      <rect>
-        10 10 1 1</rect></_>
-    <_>
-      <rect>
-        10 10 1 2</rect></_>
-    <_>
-      <rect>
-        10 14 3 3</rect></_>
-    <_>
-      <rect>
-        10 15 1 1</rect></_>
-    <_>
-      <rect>
-        10 15 2 1</rect></_>
-    <_>
-      <rect>
-        10 16 1 1</rect></_>
-    <_>
-      <rect>
-        10 16 2 1</rect></_>
-    <_>
-      <rect>
-        10 17 1 1</rect></_>
-    <_>
-      <rect>
-        10 21 1 1</rect></_>
-    <_>
-      <rect>
-        11 3 2 2</rect></_>
-    <_>
-      <rect>
-        11 5 1 2</rect></_>
-    <_>
-      <rect>
-        11 5 3 3</rect></_>
-    <_>
-      <rect>
-        11 5 4 6</rect></_>
-    <_>
-      <rect>
-        11 6 1 1</rect></_>
-    <_>
-      <rect>
-        11 7 2 2</rect></_>
-    <_>
-      <rect>
-        11 8 1 2</rect></_>
-    <_>
-      <rect>
-        11 10 1 1</rect></_>
-    <_>
-      <rect>
-        11 10 1 2</rect></_>
-    <_>
-      <rect>
-        11 15 1 1</rect></_>
-    <_>
-      <rect>
-        11 17 1 1</rect></_>
-    <_>
-      <rect>
-        11 18 1 1</rect></_>
-    <_>
-      <rect>
-        12 0 2 2</rect></_>
-    <_>
-      <rect>
-        12 1 2 5</rect></_>
-    <_>
-      <rect>
-        12 2 4 1</rect></_>
-    <_>
-      <rect>
-        12 3 1 3</rect></_>
-    <_>
-      <rect>
-        12 7 3 4</rect></_>
-    <_>
-      <rect>
-        12 10 3 2</rect></_>
-    <_>
-      <rect>
-        12 11 1 1</rect></_>
-    <_>
-      <rect>
-        12 12 3 2</rect></_>
-    <_>
-      <rect>
-        12 14 4 3</rect></_>
-    <_>
-      <rect>
-        12 17 1 1</rect></_>
-    <_>
-      <rect>
-        12 21 2 1</rect></_>
-    <_>
-      <rect>
-        13 6 2 5</rect></_>
-    <_>
-      <rect>
-        13 7 3 5</rect></_>
-    <_>
-      <rect>
-        13 11 3 2</rect></_>
-    <_>
-      <rect>
-        13 17 2 2</rect></_>
-    <_>
-      <rect>
-        13 17 3 2</rect></_>
-    <_>
-      <rect>
-        13 18 1 2</rect></_>
-    <_>
-      <rect>
-        13 18 2 2</rect></_>
-    <_>
-      <rect>
-        14 0 2 2</rect></_>
-    <_>
-      <rect>
-        14 1 1 3</rect></_>
-    <_>
-      <rect>
-        14 2 3 2</rect></_>
-    <_>
-      <rect>
-        14 7 2 1</rect></_>
-    <_>
-      <rect>
-        14 13 2 1</rect></_>
-    <_>
-      <rect>
-        14 13 3 3</rect></_>
-    <_>
-      <rect>
-        14 17 2 2</rect></_>
-    <_>
-      <rect>
-        15 0 2 2</rect></_>
-    <_>
-      <rect>
-        15 0 2 3</rect></_>
-    <_>
-      <rect>
-        15 4 3 2</rect></_>
-    <_>
-      <rect>
-        15 4 3 6</rect></_>
-    <_>
-      <rect>
-        15 6 3 2</rect></_>
-    <_>
-      <rect>
-        15 11 3 4</rect></_>
-    <_>
-      <rect>
-        15 13 3 2</rect></_>
-    <_>
-      <rect>
-        15 17 2 2</rect></_>
-    <_>
-      <rect>
-        15 17 3 2</rect></_>
-    <_>
-      <rect>
-        16 1 2 3</rect></_>
-    <_>
-      <rect>
-        16 3 2 4</rect></_>
-    <_>
-      <rect>
-        16 6 1 1</rect></_>
-    <_>
-      <rect>
-        16 16 2 2</rect></_>
-    <_>
-      <rect>
-        17 1 2 2</rect></_>
-    <_>
-      <rect>
-        17 1 2 5</rect></_>
-    <_>
-      <rect>
-        17 12 2 2</rect></_>
-    <_>
-      <rect>
-        18 0 2 2</rect></_></features></cascade>
-</opencv_storage>

app/Hackathon_setup/simple_test.py

@@ -1,65 +0,0 @@
-"""
-Ultra-simple test to check face recognition
-"""
-
-print("Starting Face Recognition Test...")
-
-try:
-    import os
-    print(f"Current directory: {os.getcwd()}")
-    
-    # Check model files
-    model_files = ['siamese_model.t7', 'decision_tree_model.sav', 'face_recognition_scaler.sav']
-    for file in model_files:
-        if os.path.exists(file):
-            print(f"✓ {file} exists")
-        else:
-            print(f"✗ {file} missing")
-    
-    # Try to import
-    print("\nTrying to import face_recognition...")
-    from face_recognition import get_face_class, CLASS_NAMES
-    print(f"✓ Imported successfully")
-    print(f"CLASS_NAMES: {CLASS_NAMES}")
-    
-    # Test with simple image
-    print("\nTesting with simple image...")
-    import numpy as np
-    import cv2
-    
-    # Create simple test image
-    test_img = np.zeros((100, 100, 3), dtype=np.uint8)
-    cv2.ellipse(test_img, (50, 50), (40, 50), 0, 0, 360, (100, 100, 100), -1)
-    cv2.circle(test_img, (35, 40), 5, (200, 200, 200), -1)
-    cv2.circle(test_img, (65, 40), 5, (200, 200, 200), -1)
-    
-    print(f"Created test image: {test_img.shape}")
-    
-    # Test classification
-    result = get_face_class(test_img)
-    print(f"Classification result: {result}")
-    
-    if result == "UNKNOWN_CLASS":
-        print("❌ Still getting UNKNOWN_CLASS!")
-        
-        # Debug further
-        print("\nDebugging...")
-        import joblib
-        classifier = joblib.load('decision_tree_model.sav')
-        scaler = joblib.load('face_recognition_scaler.sav')
-        
-        print(f"Classifier classes: {classifier.classes_}")
-        print(f"Scaler features: {scaler.n_features_in_}")
-        print(f"CLASS_NAMES length: {len(CLASS_NAMES)}")
-        
-    elif result in CLASS_NAMES:
-        print(f"✅ Success! Classified as: {result}")
-    else:
-        print(f"? Unexpected result: {result}")
-        
-except Exception as e:
-    print(f"❌ Error: {e}")
-    import traceback
-    traceback.print_exc()
-
-print("\nTest completed!")

app/Hackathon_setup/test_all_classes.py

@@ -1,85 +0,0 @@
-"""
-Test all possible class predictions to ensure no UNKNOWN_CLASS
-"""
-
-import numpy as np
-import cv2
-from face_recognition import get_face_class
-import joblib
-
-def test_all_class_predictions():
-    """Test that all classifier predictions map to valid class names"""
-    print("Testing All Class Predictions")
-    print("=" * 40)
-    
-    try:
-        # Load the classifier directly
-        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_)}")
-        
-        # Test each possible class prediction
-        for class_idx in classifier.classes_:
-            print(f"\nTesting class {class_idx}:")
-            
-            # Create a dummy embedding that would predict this class
-            # We'll create embeddings and see what the classifier predicts
-            dummy_embedding = np.random.randn(1, 5)  # 5 features based on scaler
-            
-            # Scale the embedding
-            scaled_embedding = scaler.transform(dummy_embedding)
-            
-            # Get prediction
-            prediction = classifier.predict(scaled_embedding)[0]
-            
-            # Map to class name
-            from face_recognition import CLASS_NAMES
-            if prediction < len(CLASS_NAMES):
-                class_name = CLASS_NAMES[prediction]
-                print(f"  Prediction: {prediction} -> {class_name}")
-            else:
-                print(f"  Prediction: {prediction} -> UNKNOWN_CLASS (ERROR!)")
-        
-        print(f"\nCLASS_NAMES: {CLASS_NAMES}")
-        print(f"Number of CLASS_NAMES: {len(CLASS_NAMES)}")
-        
-        # Test with actual face images
-        print("\nTesting with face images...")
-        for i in range(5):
-            # Create different face-like images
-            face_img = create_varied_face_image(i)
-            result = get_face_class(face_img)
-            print(f"Face image {i+1}: {result}")
-            
-    except Exception as e:
-        print(f"Error: {e}")
-        import traceback
-        traceback.print_exc()
-
-def create_varied_face_image(variation):
-    """Create different face-like images for testing"""
-    img = np.zeros((100, 100, 3), dtype=np.uint8)
-    
-    # Vary the face features based on variation
-    eye_offset = variation * 5
-    mouth_offset = variation * 3
-    
-    # Face outline (oval)
-    cv2.ellipse(img, (50, 50), (40, 50), 0, 0, 360, (100, 100, 100), -1)
-    
-    # Eyes (varied position)
-    cv2.circle(img, (35 + eye_offset, 40), 5, (200, 200, 200), -1)
-    cv2.circle(img, (65 - eye_offset, 40), 5, (200, 200, 200), -1)
-    
-    # Nose
-    cv2.line(img, (50, 45), (50, 60), (150, 150, 150), 2)
-    
-    # Mouth (varied position)
-    cv2.ellipse(img, (50, 70 + mouth_offset), (15, 8), 0, 0, 180, (150, 150, 150), 2)
-    
-    return img
-
-if __name__ == "__main__":
-    test_all_class_predictions()

app/Hackathon_setup/test_api.py

@@ -1,132 +0,0 @@
-"""
-Test script for the deployed Hugging Face API
-"""
-
-import requests
-import base64
-import numpy as np
-import cv2
-from PIL import Image
-import io
-
-def create_test_image():
-    """Create a test image for API testing"""
-    # Create a simple test image
-    img = np.random.randint(0, 255, (100, 100, 3), dtype=np.uint8)
-    
-    # Convert to PIL Image
-    pil_img = Image.fromarray(img)
-    
-    # Convert to base64
-    buffer = io.BytesIO()
-    pil_img.save(buffer, format='JPEG')
-    img_str = base64.b64encode(buffer.getvalue()).decode()
-    
-    return img_str
-
-def test_api_similarity():
-    """Test the similarity API endpoint"""
-    url = "https://pavaniyerra-hackthon4.hf.space/predict_similarity/"
-    
-    print("Testing Hugging Face API...")
-    print("=" * 40)
-    
-    try:
-        # Create two test images
-        img1_b64 = create_test_image()
-        img2_b64 = create_test_image()
-        
-        # Prepare the request data - API expects file1 and file2
-        data = {
-            "file1": img1_b64,
-            "file2": img2_b64
-        }
-        
-        print("Sending request to API...")
-        response = requests.post(url, json=data, timeout=30)
-        
-        if response.status_code == 200:
-            result = response.json()
-            print("SUCCESS: API Response received successfully!")
-            print(f"Similarity Score: {result}")
-            
-            # Interpret the similarity score
-            if isinstance(result, (int, float)):
-                if result > 0.8:
-                    print("Result: Very High Similarity (likely same person)")
-                elif result > 0.6:
-                    print("Result: High Similarity (possibly same person)")
-                elif result > 0.4:
-                    print("Result: Moderate Similarity (uncertain)")
-                elif result > 0.2:
-                    print("Result: Low Similarity (likely different persons)")
-                else:
-                    print("Result: Very Low Similarity (definitely different persons)")
-            else:
-                print(f"Unexpected response format: {result}")
-                
-        else:
-            print(f"ERROR: API Error: {response.status_code}")
-            print(f"Response: {response.text}")
-            
-    except requests.exceptions.RequestException as e:
-        print(f"ERROR: Network Error: {e}")
-    except Exception as e:
-        print(f"ERROR: Error: {e}")
-
-def test_api_classification():
-    """Test the classification API endpoint (if available)"""
-    # Try different possible endpoints
-    possible_urls = [
-        "https://pavaniyerra-hackthon4.hf.space/predict_class/",
-        "https://pavaniyerra-hackthon4.hf.space/classify/",
-        "https://pavaniyerra-hackthon4.hf.space/predict/"
-    ]
-    
-    print("\nTesting Classification API...")
-    print("=" * 40)
-    
-    for url in possible_urls:
-        try:
-            # Create a test image
-            img_b64 = create_test_image()
-            
-            # Prepare the request data - try different parameter names
-            data = {
-                "file": img_b64
-            }
-            
-            print(f"Trying endpoint: {url}")
-            response = requests.post(url, json=data, timeout=30)
-            
-            if response.status_code == 200:
-                result = response.json()
-                print("SUCCESS: Classification API Response received successfully!")
-                print(f"Predicted Class: {result}")
-                return
-            else:
-                print(f"ERROR: {response.status_code} - {response.text[:100]}...")
-                
-        except requests.exceptions.RequestException as e:
-            print(f"ERROR: Network Error for {url}: {e}")
-        except Exception as e:
-            print(f"ERROR: Error for {url}: {e}")
-    
-    print("No working classification endpoint found.")
-
-if __name__ == "__main__":
-    print("Hugging Face API Test")
-    print("=" * 50)
-    print(f"API URL: https://pavaniyerra-hackthon4.hf.space/predict_similarity/")
-    print()
-    
-    # Test similarity API
-    test_api_similarity()
-    
-    # Test classification API (if available)
-    test_api_classification()
-    
-    print("\n" + "=" * 50)
-    print("API Testing Complete!")
-    print("\nNote: This test uses random images.")
-    print("For real testing, use actual face images.")

app/Hackathon_setup/test_api_fixed.py

@@ -1,142 +0,0 @@
-"""
-Fixed test script for the deployed Hugging Face API
-"""
-
-import requests
-import base64
-import numpy as np
-from PIL import Image
-import io
-
-def create_test_image():
-    """Create a test image for API testing"""
-    # Create a simple test image
-    img = np.random.randint(0, 255, (100, 100, 3), dtype=np.uint8)
-    
-    # Convert to PIL Image
-    pil_img = Image.fromarray(img)
-    
-    # Convert to base64
-    buffer = io.BytesIO()
-    pil_img.save(buffer, format='JPEG')
-    img_str = base64.b64encode(buffer.getvalue()).decode()
-    
-    return img_str
-
-def test_api_with_form_data():
-    """Test the API using form data (multipart/form-data)"""
-    url = "https://pavaniyerra-hackthon4.hf.space/predict_similarity/"
-    
-    print("Testing API with form data...")
-    print("=" * 40)
-    
-    try:
-        # Create test images
-        img1_b64 = create_test_image()
-        img2_b64 = create_test_image()
-        
-        # Convert base64 to bytes
-        img1_bytes = base64.b64decode(img1_b64)
-        img2_bytes = base64.b64decode(img2_b64)
-        
-        # Prepare files for form data
-        files = {
-            'file1': ('image1.jpg', img1_bytes, 'image/jpeg'),
-            'file2': ('image2.jpg', img2_bytes, 'image/jpeg')
-        }
-        
-        print("Sending request with form data...")
-        response = requests.post(url, files=files, timeout=30)
-        
-        print(f"Status Code: {response.status_code}")
-        print(f"Response Headers: {dict(response.headers)}")
-        print(f"Response Text: {response.text}")
-        
-        if response.status_code == 200:
-            try:
-                result = response.json()
-                print("SUCCESS: API Response received successfully!")
-                print(f"Similarity Score: {result}")
-            except:
-                print(f"Response (not JSON): {response.text}")
-        else:
-            print(f"ERROR: API Error: {response.status_code}")
-            
-    except Exception as e:
-        print(f"ERROR: {e}")
-
-def test_api_with_json():
-    """Test the API using JSON data"""
-    url = "https://pavaniyerra-hackthon4.hf.space/predict_similarity/"
-    
-    print("\nTesting API with JSON data...")
-    print("=" * 40)
-    
-    try:
-        # Create test images
-        img1_b64 = create_test_image()
-        img2_b64 = create_test_image()
-        
-        # Try different JSON formats
-        json_formats = [
-            {"file1": img1_b64, "file2": img2_b64},
-            {"img1": img1_b64, "img2": img2_b64},
-            {"image1": img1_b64, "image2": img2_b64},
-            {"files": [img1_b64, img2_b64]},
-            {"data": {"file1": img1_b64, "file2": img2_b64}}
-        ]
-        
-        for i, data in enumerate(json_formats):
-            print(f"\nTrying JSON format {i+1}: {list(data.keys())}")
-            response = requests.post(url, json=data, timeout=30)
-            print(f"Status: {response.status_code}")
-            if response.status_code == 200:
-                print("SUCCESS!")
-                print(f"Response: {response.text}")
-                break
-            else:
-                print(f"Error: {response.text[:200]}...")
-                
-    except Exception as e:
-        print(f"ERROR: {e}")
-
-def test_api_info():
-    """Get information about the API"""
-    base_url = "https://pavaniyerra-hackthon4.hf.space"
-    
-    print("\nGetting API information...")
-    print("=" * 40)
-    
-    try:
-        # Try to get API info
-        response = requests.get(base_url, timeout=30)
-        print(f"Base URL Status: {response.status_code}")
-        
-        # Try common endpoints
-        endpoints = ["/", "/docs", "/openapi.json", "/info", "/health"]
-        for endpoint in endpoints:
-            try:
-                url = base_url + endpoint
-                response = requests.get(url, timeout=10)
-                print(f"{endpoint}: {response.status_code}")
-                if response.status_code == 200 and len(response.text) < 500:
-                    print(f"  Content: {response.text[:100]}...")
-            except:
-                print(f"{endpoint}: Error")
-                
-    except Exception as e:
-        print(f"ERROR: {e}")
-
-if __name__ == "__main__":
-    print("Hugging Face API Test - Fixed Version")
-    print("=" * 50)
-    print(f"API URL: https://pavaniyerra-hackthon4.hf.space/predict_similarity/")
-    print()
-    
-    # Test different approaches
-    test_api_with_form_data()
-    test_api_with_json()
-    test_api_info()
-    
-    print("\n" + "=" * 50)
-    print("API Testing Complete!")

app/Hackathon_setup/test_api_simple.py

@@ -1,172 +0,0 @@
-"""
-Simple API test script that extracts the numerical score
-"""
-
-import requests
-import base64
-import numpy as np
-import cv2
-from PIL import Image
-import io
-import re
-
-def create_face_image():
-    """Create a simple face-like image"""
-    img = np.zeros((100, 100), dtype=np.uint8)
-    
-    # Face outline
-    cv2.ellipse(img, (50, 50), (40, 50), 0, 0, 360, 100, -1)
-    
-    # Eyes
-    cv2.circle(img, (35, 40), 5, 200, -1)
-    cv2.circle(img, (65, 40), 5, 200, -1)
-    
-    # Nose
-    cv2.line(img, (50, 45), (50, 60), 150, 2)
-    
-    # Mouth
-    cv2.ellipse(img, (50, 70), (15, 8), 0, 0, 180, 150, 2)
-    
-    # Convert to RGB
-    img_rgb = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB)
-    return img_rgb
-
-def test_api():
-    """Test the API and extract the score"""
-    url = "https://pavaniyerra-hackthon4.hf.space/predict_similarity/"
-    
-    print("Testing Face Similarity API")
-    print("=" * 40)
-    
-    try:
-        # Create two test face images
-        face1 = create_face_image()
-        face2 = create_face_image()
-        
-        # Convert to bytes
-        def img_to_bytes(img):
-            pil_img = Image.fromarray(img)
-            buffer = io.BytesIO()
-            pil_img.save(buffer, format='JPEG')
-            return buffer.getvalue()
-        
-        face1_bytes = img_to_bytes(face1)
-        face2_bytes = img_to_bytes(face2)
-        
-        # Prepare files for upload
-        files = {
-            'file1': ('face1.jpg', face1_bytes, 'image/jpeg'),
-            'file2': ('face2.jpg', face2_bytes, 'image/jpeg')
-        }
-        
-        print("Sending request to API...")
-        response = requests.post(url, files=files, timeout=30)
-        
-        print(f"Status Code: {response.status_code}")
-        
-        if response.status_code == 200:
-            print("SUCCESS! API is working")
-            
-            # Extract the dissimilarity score from HTML
-            html_content = response.text
-            
-            # Look for the dissimilarity score in the HTML
-            # Pattern: "Dissimilarity: X.X"
-            pattern = r'Dissimilarity:</span>\s*<span[^>]*>\s*([0-9.]+)'
-            match = re.search(pattern, html_content)
-            
-            if match:
-                score = float(match.group(1))
-                print(f"Dissimilarity Score: {score}")
-                
-                # Convert dissimilarity to similarity (assuming 1.0 = completely different, 0.0 = identical)
-                similarity = 1.0 - score
-                print(f"Similarity Score: {similarity:.4f}")
-                
-                # Interpret the result
-                if similarity > 0.8:
-                    print("Result: Very High Similarity (likely same person)")
-                elif similarity > 0.6:
-                    print("Result: High Similarity (possibly same person)")
-                elif similarity > 0.4:
-                    print("Result: Moderate Similarity (uncertain)")
-                elif similarity > 0.2:
-                    print("Result: Low Similarity (likely different persons)")
-                else:
-                    print("Result: Very Low Similarity (definitely different persons)")
-            else:
-                print("WARNING: Could not extract score from HTML response")
-                print("HTML content preview:")
-                print(html_content[:500] + "..." if len(html_content) > 500 else html_content)
-        else:
-            print(f"ERROR: {response.status_code}")
-            print(f"Response: {response.text}")
-            
-    except Exception as e:
-        print(f"ERROR: {e}")
-
-def test_multiple_times():
-    """Test the API multiple times to check consistency"""
-    print("\n" + "=" * 40)
-    print("Testing API Multiple Times")
-    print("=" * 40)
-    
-    scores = []
-    for i in range(3):
-        print(f"\nTest {i+1}/3:")
-        try:
-            face1 = create_face_image()
-            face2 = create_face_image()
-            
-            def img_to_bytes(img):
-                pil_img = Image.fromarray(img)
-                buffer = io.BytesIO()
-                pil_img.save(buffer, format='JPEG')
-                return buffer.getvalue()
-            
-            files = {
-                'file1': ('face1.jpg', img_to_bytes(face1), 'image/jpeg'),
-                'file2': ('face2.jpg', img_to_bytes(face2), 'image/jpeg')
-            }
-            
-            response = requests.post("https://pavaniyerra-hackthon4.hf.space/predict_similarity/", 
-                                   files=files, timeout=30)
-            
-            if response.status_code == 200:
-                # Extract score
-                pattern = r'Dissimilarity:</span>\s*<span[^>]*>\s*([0-9.]+)'
-                match = re.search(pattern, response.text)
-                if match:
-                    score = float(match.group(1))
-                    scores.append(score)
-                    print(f"  Score: {score}")
-                else:
-                    print("  Could not extract score")
-            else:
-                print(f"  Error: {response.status_code}")
-                
-        except Exception as e:
-            print(f"  Error: {e}")
-    
-    if scores:
-        print(f"\nScore Statistics:")
-        print(f"  Average: {sum(scores)/len(scores):.4f}")
-        print(f"  Min: {min(scores):.4f}")
-        print(f"  Max: {max(scores):.4f}")
-        print(f"  Range: {max(scores) - min(scores):.4f}")
-
-if __name__ == "__main__":
-    # Test the API
-    test_api()
-    
-    # Test multiple times for consistency
-    test_multiple_times()
-    
-    print("\n" + "=" * 50)
-    print("API Testing Complete!")
-    print("\nYour API is working correctly!")
-    print("The API expects:")
-    print("- Method: POST")
-    print("- Format: multipart/form-data")
-    print("- Parameters: file1, file2 (image files)")
-    print("- Response: HTML with dissimilarity score")

app/Hackathon_setup/test_api_with_faces.py

@@ -1,228 +0,0 @@
-"""
-Test script for the Hugging Face API using face images
-"""
-
-import requests
-import base64
-import numpy as np
-import cv2
-from PIL import Image
-import io
-import os
-
-def create_face_like_image():
-    """Create a more realistic face-like image for testing"""
-    # Create a grayscale image that looks more like a face
-    img = np.zeros((100, 100), dtype=np.uint8)
-    
-    # Add some face-like features
-    # Face outline (oval)
-    cv2.ellipse(img, (50, 50), (40, 50), 0, 0, 360, 100, -1)
-    
-    # Eyes
-    cv2.circle(img, (35, 40), 5, 200, -1)
-    cv2.circle(img, (65, 40), 5, 200, -1)
-    
-    # Nose
-    cv2.line(img, (50, 45), (50, 60), 150, 2)
-    
-    # Mouth
-    cv2.ellipse(img, (50, 70), (15, 8), 0, 0, 180, 150, 2)
-    
-    # Convert to 3-channel for consistency
-    img_rgb = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB)
-    
-    return img_rgb
-
-def load_real_face_image(image_path):
-    """Load a real face image if available"""
-    if os.path.exists(image_path):
-        try:
-            img = cv2.imread(image_path)
-            if img is not None:
-                # Resize to 100x100
-                img = cv2.resize(img, (100, 100))
-                return img
-        except Exception as e:
-            print(f"Error loading image {image_path}: {e}")
-    
-    return None
-
-def image_to_base64(img):
-    """Convert image to base64 string"""
-    if len(img.shape) == 2:  # Grayscale
-        pil_img = Image.fromarray(img, mode='L')
-    else:  # RGB
-        pil_img = Image.fromarray(img)
-    
-    buffer = io.BytesIO()
-    pil_img.save(buffer, format='JPEG')
-    img_str = base64.b64encode(buffer.getvalue()).decode()
-    return img_str
-
-def test_api_with_face_images():
-    """Test the API with face-like images"""
-    url = "https://pavaniyerra-hackthon4.hf.space/predict_similarity/"
-    
-    print("Testing API with face-like images...")
-    print("=" * 50)
-    
-    try:
-        # Create two face-like images
-        face1 = create_face_like_image()
-        face2 = create_face_like_image()
-        
-        # Convert to base64
-        face1_b64 = image_to_base64(face1)
-        face2_b64 = image_to_base64(face2)
-        
-        print("Created face-like test images")
-        print(f"Image 1 shape: {face1.shape}")
-        print(f"Image 2 shape: {face2.shape}")
-        
-        # Try different request formats
-        test_formats = [
-            # Format 1: JSON with file1, file2
-            {"file1": face1_b64, "file2": face2_b64},
-            # Format 2: JSON with img1, img2  
-            {"img1": face1_b64, "img2": face2_b64},
-            # Format 3: JSON with image1, image2
-            {"image1": face1_b64, "image2": face2_b64},
-            # Format 4: JSON with faces array
-            {"faces": [face1_b64, face2_b64]},
-            # Format 5: JSON with data wrapper
-            {"data": {"file1": face1_b64, "file2": face2_b64}}
-        ]
-        
-        for i, data in enumerate(test_formats, 1):
-            print(f"\n--- Testing Format {i}: {list(data.keys())} ---")
-            
-            try:
-                response = requests.post(url, json=data, timeout=30)
-                print(f"Status Code: {response.status_code}")
-                
-                if response.status_code == 200:
-                    try:
-                        result = response.json()
-                        print("SUCCESS! API Response:")
-                        print(f"Similarity Score: {result}")
-                        
-                        # Interpret the result
-                        if isinstance(result, (int, float)):
-                            if result > 0.8:
-                                print("Result: Very High Similarity (likely same person)")
-                            elif result > 0.6:
-                                print("Result: High Similarity (possibly same person)")
-                            elif result > 0.4:
-                                print("Result: Moderate Similarity (uncertain)")
-                            elif result > 0.2:
-                                print("Result: Low Similarity (likely different persons)")
-                            else:
-                                print("Result: Very Low Similarity (definitely different persons)")
-                        else:
-                            print(f"Response format: {type(result)} - {result}")
-                        
-                        return True  # Success, no need to try other formats
-                        
-                    except Exception as e:
-                        print(f"Error parsing JSON response: {e}")
-                        print(f"Raw response: {response.text}")
-                else:
-                    print(f"Error: {response.text[:200]}...")
-                    
-            except requests.exceptions.RequestException as e:
-                print(f"Network error: {e}")
-            except Exception as e:
-                print(f"Error: {e}")
-        
-        print("\nAll JSON formats failed. Trying form data...")
-        
-        # Try form data approach
-        try:
-            face1_bytes = base64.b64decode(face1_b64)
-            face2_bytes = base64.b64decode(face2_b64)
-            
-            files = {
-                'file1': ('face1.jpg', face1_bytes, 'image/jpeg'),
-                'file2': ('face2.jpg', face2_bytes, 'image/jpeg')
-            }
-            
-            response = requests.post(url, files=files, timeout=30)
-            print(f"Form data Status: {response.status_code}")
-            print(f"Form data Response: {response.text}")
-            
-        except Exception as e:
-            print(f"Form data error: {e}")
-            
-    except Exception as e:
-        print(f"General error: {e}")
-    
-    return False
-
-def test_with_real_images():
-    """Test with real face images if available"""
-    print("\nTesting with real face images...")
-    print("=" * 40)
-    
-    # Look for common face image files
-    possible_files = [
-        "face1.jpg", "face2.jpg", "person1.jpg", "person2.jpg",
-        "test_face1.jpg", "test_face2.jpg", "sample1.jpg", "sample2.jpg"
-    ]
-    
-    found_images = []
-    for filename in possible_files:
-        if os.path.exists(filename):
-            found_images.append(filename)
-            print(f"Found: {filename}")
-    
-    if len(found_images) >= 2:
-        try:
-            # Load the first two images
-            img1 = load_real_face_image(found_images[0])
-            img2 = load_real_face_image(found_images[1])
-            
-            if img1 is not None and img2 is not None:
-                print(f"Loaded real images: {found_images[0]}, {found_images[1]}")
-                
-                # Convert to base64
-                img1_b64 = image_to_base64(img1)
-                img2_b64 = image_to_base64(img2)
-                
-                # Test with real images
-                url = "https://pavaniyerra-hackthon4.hf.space/predict_similarity/"
-                data = {"file1": img1_b64, "file2": img2_b64}
-                
-                response = requests.post(url, json=data, timeout=30)
-                print(f"Real images test - Status: {response.status_code}")
-                if response.status_code == 200:
-                    result = response.json()
-                    print(f"SUCCESS with real images! Similarity: {result}")
-                else:
-                    print(f"Error with real images: {response.text}")
-            else:
-                print("Could not load real images properly")
-        except Exception as e:
-            print(f"Error testing with real images: {e}")
-    else:
-        print("No real face images found for testing")
-        print("Place some face images in the current directory to test with real data")
-
-if __name__ == "__main__":
-    print("Hugging Face API Test - Face Images")
-    print("=" * 60)
-    print(f"API URL: https://pavaniyerra-hackthon4.hf.space/predict_similarity/")
-    print()
-    
-    # Test with face-like images
-    success = test_api_with_face_images()
-    
-    # Test with real images if available
-    test_with_real_images()
-    
-    print("\n" + "=" * 60)
-    print("Face API Testing Complete!")
-    print("\nTo test with real face images:")
-    print("1. Place face images in the current directory")
-    print("2. Name them face1.jpg, face2.jpg, etc.")
-    print("3. Run this script again")

app/Hackathon_setup/test_classifier_comprehensive.py

@@ -1,210 +0,0 @@
-"""
-Comprehensive local test for face recognition classifier
-Test with real images to verify classifier is working correctly
-"""
-
-import os
-import sys
-import numpy as np
-import cv2
-from PIL import Image
-
-print("🧪 Comprehensive Face Recognition Classifier Test")
-print("=" * 60)
-
-def test_classifier_comprehensively():
-    """Test the classifier with various scenarios"""
-    
-    # Step 1: Check environment
-    print("1. Environment Check...")
-    print(f"   Current directory: {os.getcwd()}")
-    
-    # Check model files
-    model_files = {
-        'siamese_model.t7': 'Siamese Network',
-        'decision_tree_model.sav': 'DecisionTree Classifier',
-        'face_recognition_scaler.sav': 'Feature Scaler',
-        'haarcascade_frontalface_default.xml': 'Face Detection Cascade'
-    }
-    
-    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: Import and check components
-    print("\n2. Component Check...")
-    try:
-        from face_recognition import get_face_class, CLASS_NAMES, detected_face
-        from face_recognition_model import Siamese
-        import joblib
-        import torch
-        
-        print("   ✓ All imports successful")
-        print(f"   ✓ CLASS_NAMES: {CLASS_NAMES}")
-        print(f"   ✓ Number of classes: {len(CLASS_NAMES)}")
-        
-        # Load models
-        classifier = joblib.load('decision_tree_model.sav')
-        scaler = joblib.load('face_recognition_scaler.sav')
-        
-        print(f"   ✓ Classifier classes: {classifier.classes_}")
-        print(f"   ✓ Classifier type: {type(classifier)}")
-        print(f"   ✓ Scaler features: {scaler.n_features_in_}")
-        
-    except Exception as e:
-        print(f"   ✗ Import error: {e}")
-        return False
-    
-    # Step 3: Test with synthetic images
-    print("\n3. Testing with Synthetic Images...")
-    
-    for i in range(1, 8):  # Person1 to Person7
-        print(f"\n   Testing Person{i}:")
-        
-        # Create synthetic face
-        test_img = create_synthetic_face(i)
-        
-        try:
-            result = get_face_class(test_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"     ❌ UNKNOWN_CLASS detected!")
-            else:
-                print(f"     ? Unexpected result: {result}")
-                
-        except Exception as e:
-            print(f"     ❌ Error: {e}")
-    
-    # Step 4: Test with actual images
-    print("\n4. Testing with Actual Images...")
-    
-    # Look for actual images in various locations
-    image_paths = [
-        "../static/Person1_1697805233.jpg",
-        "Person1_1697805233.jpg", 
-        "static/Person1_1697805233.jpg",
-        "../Person1_1697805233.jpg"
-    ]
-    
-    actual_image_found = False
-    for path in image_paths:
-        if os.path.exists(path):
-            print(f"   Found actual image: {path}")
-            actual_image_found = True
-            
-            try:
-                # Load image
-                img = cv2.imread(path)
-                print(f"   Image shape: {img.shape}")
-                
-                # Test face detection
-                detected = detected_face(img)
-                if detected is not None:
-                    print("   ✓ Face detected successfully")
-                else:
-                    print("   ⚠ No face detected, using fallback")
-                
-                # Test classification
-                result = get_face_class(img)
-                print(f"   Classification 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: {result}")
-                    
-            except Exception as e:
-                print(f"   ❌ Error with actual image: {e}")
-                import traceback
-                traceback.print_exc()
-            
-            break
-    
-    if not actual_image_found:
-        print("   ⚠ No actual images found for testing")
-        print("   You can add a Person1 image to test with real data")
-    
-    # Step 5: Test classifier directly
-    print("\n5. Testing Classifier Directly...")
-    
-    try:
-        # Create dummy features that should predict different classes
-        for class_idx in classifier.classes_:
-            # Create random features
-            dummy_features = np.random.randn(1, scaler.n_features_in_)
-            scaled_features = scaler.transform(dummy_features)
-            
-            # Get prediction
-            prediction = classifier.predict(scaled_features)[0]
-            
-            # Map to class name
-            if prediction < len(CLASS_NAMES):
-                class_name = CLASS_NAMES[prediction]
-                print(f"   Classifier prediction {prediction} → {class_name}")
-            else:
-                print(f"   ❌ Prediction {prediction} out of range!")
-                
-    except Exception as e:
-        print(f"   ❌ Error testing classifier: {e}")
-    
-    # Step 6: Summary
-    print("\n6. Test Summary...")
-    print("   ✅ All model files present")
-    print("   ✅ All imports successful") 
-    print("   ✅ Classifier loaded correctly")
-    print("   ✅ Face detection working")
-    print("   ✅ Classification pipeline working")
-    print("   🎉 Face recognition system is ready!")
-    
-    return True
-
-def create_synthetic_face(person_id):
-    """Create a synthetic face image for testing"""
-    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
-    nose_length = 10 + (person_id - 1)
-    
-    # Eyes (varied position)
-    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 (varied length)
-    cv2.line(img, (50, 45), (50, 45 + nose_length), (150, 150, 150), 2)
-    
-    # Mouth (varied width)
-    cv2.ellipse(img, (50, 70), (mouth_width, 6), 0, 0, 180, (150, 150, 150), 2)
-    
-    # Add some texture variation
-    noise = np.random.randint(-20, 20, img.shape, dtype=np.int16)
-    img = np.clip(img.astype(np.int16) + noise, 0, 255).astype(np.uint8)
-    
-    return img
-
-if __name__ == "__main__":
-    success = test_classifier_comprehensively()
-    
-    if success:
-        print("\n🎉 All tests passed! Your face recognition system is working correctly.")
-        print("You can now:")
-        print("1. Test with real images through the web interface")
-        print("2. Deploy to Hugging Face with confidence")
-        print("3. Use the system for actual face recognition tasks")
-    else:
-        print("\n❌ Some tests failed. Please check the errors above.")

app/Hackathon_setup/test_complete_fix.py

@@ -1,208 +0,0 @@
-"""
-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()

app/Hackathon_setup/test_cosine_similarity.py

@@ -1,159 +0,0 @@
-"""
-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")

app/Hackathon_setup/test_face_recognition_comprehensive.py

@@ -1,114 +0,0 @@
-"""
-Comprehensive test script to verify face recognition is working properly
-"""
-
-import numpy as np
-import cv2
-from PIL import Image
-import os
-import sys
-
-# Add current directory to path for imports
-sys.path.append(os.path.dirname(os.path.abspath(__file__)))
-
-def test_face_recognition():
-    """Test the face recognition system comprehensively"""
-    print("Face Recognition System Test")
-    print("=" * 50)
-    
-    try:
-        # Import the face recognition functions
-        from face_recognition import get_face_class, CLASS_NAMES
-        from face_recognition_model import classes
-        
-        print(f"CLASS_NAMES from face_recognition.py: {CLASS_NAMES}")
-        print(f"classes from face_recognition_model.py: {classes}")
-        print(f"Number of CLASS_NAMES: {len(CLASS_NAMES)}")
-        print(f"Number of classes: {len(classes)}")
-        
-        # Check consistency
-        if CLASS_NAMES == classes:
-            print("✓ Class names are consistent between files")
-        else:
-            print("✗ Class names are inconsistent between files")
-            print(f"  Difference: {set(CLASS_NAMES) - set(classes)}")
-        
-        # Test with different face images
-        print("\nTesting face classification with synthetic images:")
-        
-        for i in range(7):  # Test all 7 possible classes
-            print(f"\nTest {i+1}: Creating face image for Person{i}")
-            
-            # Create a synthetic face image
-            face_img = create_synthetic_face(i)
-            
-            # Test classification
-            try:
-                result = get_face_class(face_img)
-                print(f"  Input: Person{i} synthetic image")
-                print(f"  Output: {result}")
-                
-                # Check if result is valid
-                if result in CLASS_NAMES:
-                    print(f"  ✓ Valid classification: {result}")
-                elif result == "UNKNOWN_CLASS":
-                    print(f"  ✗ UNKNOWN_CLASS detected!")
-                elif result.startswith("Error:"):
-                    print(f"  ✗ Error in classification: {result}")
-                else:
-                    print(f"  ? Unexpected result: {result}")
-                    
-            except Exception as e:
-                print(f"  ✗ Exception during classification: {e}")
-        
-        # Test with actual image if available
-        print("\nTesting with actual image:")
-        actual_image_path = "../static/Person1_1697805233.jpg"
-        if os.path.exists(actual_image_path):
-            try:
-                img = cv2.imread(actual_image_path)
-                result = get_face_class(img)
-                print(f"  Actual image result: {result}")
-            except Exception as e:
-                print(f"  Error with actual image: {e}")
-        else:
-            print(f"  No actual image found at {actual_image_path}")
-        
-        print("\nTest completed!")
-        
-    except Exception as e:
-        print(f"Error during testing: {e}")
-        import traceback
-        traceback.print_exc()
-
-def create_synthetic_face(person_id):
-    """Create a synthetic face image for testing"""
-    # Create a base face image
-    img = np.zeros((100, 100, 3), dtype=np.uint8)
-    
-    # Face outline (oval)
-    cv2.ellipse(img, (50, 50), (40, 50), 0, 0, 360, (120, 120, 120), -1)
-    
-    # Vary features based on person_id
-    eye_offset = person_id * 3
-    mouth_width = 10 + person_id * 2
-    nose_length = 10 + person_id
-    
-    # Eyes (varied position)
-    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 (varied length)
-    cv2.line(img, (50, 45), (50, 45 + nose_length), (150, 150, 150), 2)
-    
-    # Mouth (varied width)
-    cv2.ellipse(img, (50, 70), (mouth_width, 6), 0, 0, 180, (150, 150, 150), 2)
-    
-    # Add some texture variation
-    noise = np.random.randint(-20, 20, img.shape, dtype=np.int16)
-    img = np.clip(img.astype(np.int16) + noise, 0, 255).astype(np.uint8)
-    
-    return img
-
-if __name__ == "__main__":
-    test_face_recognition()

app/Hackathon_setup/test_local.py

@@ -1,181 +0,0 @@
-"""
-Simple local test script to debug UNKNOWN_CLASS issue
-Run this to test face recognition locally without deploying
-"""
-
-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_locally():
-    """Test face recognition locally with detailed debugging"""
-    print("Local Face Recognition Test")
-    print("=" * 40)
-    
-    # Check if we're in the right directory
-    print(f"Current directory: {os.getcwd()}")
-    print(f"Python path: {sys.path[0]}")
-    
-    # Check if model files exist
-    print("\n1. Checking model files...")
-    model_files = [
-        'siamese_model.t7',
-        'decision_tree_model.sav', 
-        'face_recognition_scaler.sav',
-        'haarcascade_frontalface_default.xml'
-    ]
-    
-    for file in model_files:
-        if os.path.exists(file):
-            size = os.path.getsize(file)
-            print(f"   ✓ {file} exists ({size} bytes)")
-        else:
-            print(f"   ✗ {file} missing!")
-    
-    # Test with a simple synthetic image first
-    print("\n2. Testing with synthetic image...")
-    
-    # Create a simple face-like image
-    test_img = create_simple_face()
-    print(f"   Created test image: {test_img.shape}")
-    
-    try:
-        # Import and test
-        from face_recognition import get_face_class, CLASS_NAMES
-        print(f"   ✓ Imported face_recognition")
-        print(f"   CLASS_NAMES: {CLASS_NAMES}")
-        
-        # Test classification
-        result = get_face_class(test_img)
-        print(f"   Classification result: {result}")
-        
-        if result == "UNKNOWN_CLASS":
-            print("   ✗ Still getting UNKNOWN_CLASS!")
-            debug_detailed(test_img)
-        elif result in CLASS_NAMES:
-            print(f"   ✓ Success! Classified as: {result}")
-        else:
-            print(f"   ? Unexpected result: {result}")
-            
-    except Exception as e:
-        print(f"   ✗ Error: {e}")
-        import traceback
-        traceback.print_exc()
-    
-    # Test with actual image if available
-    print("\n3. Testing with actual image...")
-    actual_paths = [
-        "../static/Person1_1697805233.jpg",
-        "Person1_1697805233.jpg",
-        "static/Person1_1697805233.jpg"
-    ]
-    
-    for path in actual_paths:
-        if os.path.exists(path):
-            print(f"   Found image at: {path}")
-            try:
-                img = cv2.imread(path)
-                result = get_face_class(img)
-                print(f"   Result: {result}")
-                break
-            except Exception as e:
-                print(f"   Error with {path}: {e}")
-    else:
-        print("   No actual image found")
-
-def create_simple_face():
-    """Create a very simple face image for testing"""
-    img = np.zeros((100, 100, 3), dtype=np.uint8)
-    
-    # Simple face
-    cv2.ellipse(img, (50, 50), (40, 50), 0, 0, 360, (100, 100, 100), -1)
-    cv2.circle(img, (35, 40), 5, (200, 200, 200), -1)
-    cv2.circle(img, (65, 40), 5, (200, 200, 200), -1)
-    cv2.line(img, (50, 45), (50, 60), (150, 150, 150), 2)
-    cv2.ellipse(img, (50, 70), (15, 8), 0, 0, 180, (150, 150, 150), 2)
-    
-    return img
-
-def debug_detailed(img):
-    """Detailed debugging of the classification process"""
-    print("\n4. Detailed debugging...")
-    
-    try:
-        import torch
-        import joblib
-        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)
-        print(f"     Detected face type: {type(det_img)}")
-        if det_img is None:
-            print("     No face detected, using fallback")
-            det_img = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2GRAY))
-        
-        print("   Step 2: Image transformation...")
-        face_tensor = trnscm(det_img).unsqueeze(0)
-        print(f"     Tensor shape: {face_tensor.shape}")
-        print(f"     Tensor values range: {face_tensor.min():.3f} to {face_tensor.max():.3f}")
-        
-        print("   Step 3: Siamese network...")
-        device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-        print(f"     Using device: {device}")
-        
-        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'])
-            print("     Loaded model from net_dict")
-        else:
-            siamese_net.load_state_dict(model_data)
-            print("     Loaded model from state_dict")
-        
-        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...")
-        scaler = joblib.load('face_recognition_scaler.sav')
-        classifier = joblib.load('decision_tree_model.sav')
-        
-        print(f"     Scaler features: {scaler.n_features_in_}")
-        print(f"     Classifier classes: {classifier.classes_}")
-        
-        if embedding.ndim == 1:
-            embedding = embedding.reshape(1, -1)
-            print(f"     Reshaped embedding: {embedding.shape}")
-        
-        embedding_scaled = scaler.transform(embedding)
-        print(f"     Scaled embedding: {embedding_scaled}")
-        
-        predicted_label_index = classifier.predict(embedding_scaled)[0]
-        print(f"     Predicted index: {predicted_label_index}")
-        
-        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"     ✓ Should return: {class_name}")
-        else:
-            print(f"     ✗ Index {predicted_label_index} >= {len(CLASS_NAMES)}")
-            print(f"     ✗ This causes UNKNOWN_CLASS!")
-            
-    except Exception as e:
-        print(f"   ✗ Error in detailed debug: {e}")
-        import traceback
-        traceback.print_exc()
-
-if __name__ == "__main__":
-    test_locally()

app/Hackathon_setup/test_model_loading.py

@@ -1,162 +0,0 @@
-"""
-Test script to diagnose and fix sklearn model loading issues
-"""
-
-import joblib
-import pickle
-import os
-import sys
-
-def test_model_loading():
-    """Test loading the sklearn models"""
-    print("Testing sklearn model loading...")
-    print("=" * 40)
-    
-    # Test scaler
-    print("Testing StandardScaler...")
-    try:
-        scaler = joblib.load('face_recognition_scaler.sav')
-        print("OK: Scaler loaded successfully")
-        
-        # Test with dummy data
-        import numpy as np
-        dummy_data = np.random.randn(1, 5)  # Assuming 5 features
-        scaled_data = scaler.transform(dummy_data)
-        print(f"OK: Scaler transform works: {scaled_data.shape}")
-        
-    except Exception as e:
-        print(f"ERROR: Scaler error: {e}")
-        return False
-    
-    # Test classifier
-    print("\nTesting KNeighborsClassifier...")
-    try:
-        classifier = joblib.load('decision_tree_model.sav')
-        print("OK: Classifier loaded successfully")
-        
-        # Test prediction
-        prediction = classifier.predict(scaled_data)
-        print(f"OK: Classifier prediction works: {prediction[0]}")
-        
-    except Exception as e:
-        print(f"ERROR: Classifier error: {e}")
-        return False
-    
-    return True
-
-def try_compatibility_fixes():
-    """Try different compatibility approaches"""
-    print("\nTrying compatibility fixes...")
-    print("=" * 40)
-    
-    # Method 1: Try with different joblib versions
-    print("Method 1: Trying with different joblib parameters...")
-    try:
-        scaler = joblib.load('face_recognition_scaler.sav', mmap_mode=None)
-        classifier = joblib.load('decision_tree_model.sav', mmap_mode=None)
-        print("OK: Loaded with mmap_mode=None")
-        return True
-    except Exception as e:
-        print(f"ERROR: Method 1 failed: {e}")
-    
-    # Method 2: Try with pickle directly
-    print("\nMethod 2: Trying with pickle...")
-    try:
-        with open('face_recognition_scaler.sav', 'rb') as f:
-            scaler = pickle.load(f)
-        with open('decision_tree_model.sav', 'rb') as f:
-            classifier = pickle.load(f)
-        print("OK: Loaded with pickle")
-        return True
-    except Exception as e:
-        print(f"ERROR: Method 2 failed: {e}")
-    
-    # Method 3: Try with different sklearn version
-    print("\nMethod 3: Checking sklearn version compatibility...")
-    import sklearn
-    print(f"Current sklearn version: {sklearn.__version__}")
-    
-    # Try to downgrade sklearn temporarily
-    print("You may need to downgrade sklearn to match the training version")
-    print("Try: pip install scikit-learn==1.6.1")
-    
-    return False
-
-def create_dummy_models():
-    """Create dummy models for testing"""
-    print("\nCreating dummy models for testing...")
-    print("=" * 40)
-    
-    try:
-        from sklearn.neighbors import KNeighborsClassifier
-        from sklearn.preprocessing import StandardScaler
-        import numpy as np
-        
-        # Create dummy data
-        n_samples = 50
-        n_features = 5
-        X = np.random.randn(n_samples, n_features)
-        y = np.random.randint(0, 5, n_samples)
-        
-        # Create and fit scaler
-        scaler = StandardScaler()
-        scaler.fit(X)
-        joblib.dump(scaler, 'face_recognition_scaler_dummy.sav')
-        print("OK: Created dummy scaler")
-        
-        # Create and fit classifier
-        classifier = KNeighborsClassifier(n_neighbors=3)
-        classifier.fit(scaler.transform(X), y)
-        joblib.dump(classifier, 'decision_tree_model_dummy.sav')
-        print("OK: Created dummy classifier")
-        
-        # Test the dummy models
-        test_data = np.random.randn(1, n_features)
-        scaled_data = scaler.transform(test_data)
-        prediction = classifier.predict(scaled_data)
-        print(f"OK: Dummy model test: {prediction[0]}")
-        
-        return True
-        
-    except Exception as e:
-        print(f"ERROR: Error creating dummy models: {e}")
-        return False
-
-def main():
-    print("Sklearn Model Loading Diagnostic")
-    print("=" * 50)
-    
-    # Check if model files exist
-    model_files = ['decision_tree_model.sav', 'face_recognition_scaler.sav']
-    for file in model_files:
-        if os.path.exists(file):
-            print(f"OK: Found {file}")
-        else:
-            print(f"ERROR: Missing {file}")
-            return
-    
-    # Test current models
-    if test_model_loading():
-        print("\nSUCCESS! Your models are working fine!")
-        return
-    
-    # Try compatibility fixes
-    if try_compatibility_fixes():
-        print("\nSUCCESS! Fixed with compatibility approach!")
-        return
-    
-    # Create dummy models as fallback
-    if create_dummy_models():
-        print("\nWARNING: Created dummy models. You should retrain with current sklearn version.")
-        print("To use dummy models, rename them:")
-        print("  mv face_recognition_scaler_dummy.sav face_recognition_scaler.sav")
-        print("  mv decision_tree_model_dummy.sav decision_tree_model.sav")
-    
-    print("\n" + "=" * 50)
-    print("RECOMMENDATIONS:")
-    print("1. Downgrade sklearn: pip install scikit-learn==1.6.1")
-    print("2. Retrain your models with current sklearn version")
-    print("3. Use the dummy models for testing")
-
-if __name__ == "__main__":
-    main()

app/Hackathon_setup/test_person1_person7_labels.py

@@ -1,121 +0,0 @@
-"""
-Test script to verify the Person1-Person7 class labels fix
-"""
-
-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_classification_with_correct_labels():
-    """Test face classification with corrected Person1-Person7 labels"""
-    print("Testing Face Classification with Corrected Labels")
-    print("=" * 50)
-    
-    try:
-        # Import the face recognition functions
-        from face_recognition import get_face_class, CLASS_NAMES
-        from face_recognition_model import classes
-        
-        print(f"CLASS_NAMES: {CLASS_NAMES}")
-        print(f"classes: {classes}")
-        
-        # Check consistency
-        if CLASS_NAMES == classes:
-            print("✓ Class names are consistent between files")
-        else:
-            print("✗ Class names are still inconsistent")
-        
-        # Test with synthetic images
-        print("\nTesting with synthetic face images:")
-        
-        for i in range(1, 8):  # Test Person1-Person7
-            print(f"\nTest Person{i}:")
-            
-            # Create a synthetic face image
-            face_img = create_test_face_image(i)
-            
-            # Test classification
-            try:
-                result = get_face_class(face_img)
-                print(f"  Input: Person{i} synthetic image")
-                print(f"  Output: {result}")
-                
-                # Check if result is valid
-                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 in classification: {result}")
-                else:
-                    print(f"  ? Unexpected result: {result}")
-                    
-            except Exception as e:
-                print(f"  ✗ Exception during classification: {e}")
-        
-        # Test with actual image if available
-        print("\nTesting 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)
-                result = get_face_class(img)
-                print(f"  Actual Person1 image result: {result}")
-                
-                if result == "Person1":
-                    print("  ✓ Perfect! Person1 image correctly classified as Person1")
-                elif result in CLASS_NAMES:
-                    print(f"  ✓ Classified as {result} (valid class)")
-                elif result == "UNKNOWN_CLASS":
-                    print("  ✗ Still getting UNKNOWN_CLASS with actual image")
-                else:
-                    print(f"  ? Unexpected result: {result}")
-                    
-            except Exception as e:
-                print(f"  Error with actual image: {e}")
-        else:
-            print(f"  No actual image found at {actual_image_path}")
-        
-        print("\nTest completed!")
-        
-    except Exception as e:
-        print(f"Error during testing: {e}")
-        import traceback
-        traceback.print_exc()
-
-def create_test_face_image(person_id):
-    """Create a test face image for a specific person ID"""
-    # Create a base face image
-    img = np.zeros((100, 100, 3), dtype=np.uint8)
-    
-    # Face outline (oval)
-    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  # Person1=0, Person2=3, etc.
-    mouth_width = 10 + (person_id - 1) * 2
-    nose_length = 10 + (person_id - 1)
-    
-    # Eyes (varied position)
-    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 (varied length)
-    cv2.line(img, (50, 45), (50, 45 + nose_length), (150, 150, 150), 2)
-    
-    # Mouth (varied width)
-    cv2.ellipse(img, (50, 70), (mouth_width, 6), 0, 0, 180, (150, 150, 150), 2)
-    
-    # Add some texture variation
-    noise = np.random.randint(-20, 20, img.shape, dtype=np.int16)
-    img = np.clip(img.astype(np.int16) + noise, 0, 255).astype(np.uint8)
-    
-    return img
-
-if __name__ == "__main__":
-    test_classification_with_correct_labels()

app/Hackathon_setup/test_person2_bias.py

@@ -1,93 +0,0 @@
-"""
-Simple test to diagnose Person2 bias issue
-"""
-
-import numpy as np
-import joblib
-import cv2
-
-print("🔍 Diagnosing Person2 Bias Issue")
-print("=" * 40)
-
-# Test 1: Check model predictions with random data
-print("1. Testing model with random features...")
-try:
-    classifier = joblib.load('decision_tree_model.sav')
-    scaler = joblib.load('face_recognition_scaler.sav')
-    
-    print(f"   Classifier classes: {classifier.classes_}")
-    print(f"   Scaler features: {scaler.n_features_in_}")
-    
-    # Test with 10 random feature sets
-    predictions = []
-    for i in range(10):
-        random_features = np.random.randn(1, scaler.n_features_in_)
-        scaled_features = scaler.transform(random_features)
-        prediction = classifier.predict(scaled_features)[0]
-        predictions.append(prediction)
-        print(f"   Random test {i+1}: {prediction}")
-    
-    # Count predictions
-    unique, counts = np.unique(predictions, return_counts=True)
-    print(f"\n   Prediction distribution:")
-    for pred, count in zip(unique, counts):
-        print(f"     Class {pred}: {count}/10 times")
-    
-except Exception as e:
-    print(f"   Error: {e}")
-
-# Test 2: Check training data distribution
-print("\n2. Checking training data distribution...")
-try:
-    if hasattr(classifier, '_y'):
-        unique, counts = np.unique(classifier._y, return_counts=True)
-        print(f"   Training data distribution:")
-        for class_id, count in zip(unique, counts):
-            print(f"     Class {class_id}: {count} samples")
-    else:
-        print("   No training data info available")
-except Exception as e:
-    print(f"   Error: {e}")
-
-# Test 3: Test with different synthetic images
-print("\n3. Testing with different synthetic images...")
-try:
-    from face_recognition import get_face_class
-    
-    # Create 3 different synthetic faces
-    images = []
-    
-    # Face 1
-    img1 = np.zeros((100, 100, 3), dtype=np.uint8)
-    cv2.ellipse(img1, (50, 50), (40, 50), 0, 0, 360, (120, 120, 120), -1)
-    cv2.circle(img1, (35, 40), 5, (200, 200, 200), -1)
-    cv2.circle(img1, (65, 40), 5, (200, 200, 200), -1)
-    images.append(("Face 1", img1))
-    
-    # Face 2 (different)
-    img2 = np.zeros((100, 100, 3), dtype=np.uint8)
-    cv2.ellipse(img2, (50, 50), (40, 50), 0, 0, 360, (100, 100, 100), -1)
-    cv2.circle(img2, (30, 40), 6, (180, 180, 180), -1)
-    cv2.circle(img2, (70, 40), 6, (180, 180, 180), -1)
-    images.append(("Face 2", img2))
-    
-    # Face 3 (very different)
-    img3 = np.zeros((100, 100, 3), dtype=np.uint8)
-    cv2.ellipse(img3, (50, 50), (35, 45), 0, 0, 360, (140, 140, 140), -1)
-    cv2.circle(img3, (40, 45), 4, (220, 220, 220), -1)
-    cv2.circle(img3, (60, 45), 4, (220, 220, 220), -1)
-    images.append(("Face 3", img3))
-    
-    # Test each image
-    for name, img in images:
-        result = get_face_class(img)
-        print(f"   {name}: {result}")
-    
-except Exception as e:
-    print(f"   Error: {e}")
-
-print("\n🎯 Analysis:")
-print("If all predictions are Person2, the model is biased")
-print("This is likely due to training data imbalance")
-print("Person2 had 100% precision/recall in your training report")
-print("Need to retrain with balanced data")

app/Hackathon_setup/test_robust.py

@@ -1,35 +0,0 @@
-"""
-Test the robust face recognition implementation
-"""
-
-import numpy as np
-import cv2
-from face_recognition_robust import get_similarity, get_face_class
-
-def test_robust_implementation():
-    """Test the robust face recognition implementation"""
-    print("Testing Robust Face Recognition Implementation")
-    print("=" * 50)
-    
-    try:
-        # Create test 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("Testing similarity...")
-        similarity = get_similarity(img1, img2)
-        print(f"Similarity Score: {similarity:.4f}")
-        
-        print("\nTesting classification...")
-        face_class = get_face_class(img1)
-        print(f"Face Class: {face_class}")
-        
-        print("\nSUCCESS: Robust implementation works!")
-        return True
-        
-    except Exception as e:
-        print(f"ERROR: {e}")
-        return False
-
-if __name__ == "__main__":
-    test_robust_implementation()