Recognition

app/Hackathon_setup/simple_test.py

@@ -0,0 +1,65 @@
+"""
+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_classifier_comprehensive.py

@@ -0,0 +1,210 @@
+"""
+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_local.py

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

test_local_server.py

@@ -0,0 +1,152 @@
+"""
+Simple local FastAPI server for testing face recognition
+Run this to test the web interface locally
+"""
+
+import sys
+import os
+from pathlib import Path
+
+# Add the parent directory to Python path
+sys.path.append(str(Path(__file__).resolve().parent.parent))
+
+from fastapi import FastAPI, Request, File, UploadFile
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+from fastapi.responses import HTMLResponse
+import numpy as np
+from PIL import Image
+import uvicorn
+
+# Import face recognition
+from app.Hackathon_setup import face_recognition
+
+app = FastAPI(title="Local Face Recognition Test")
+
+# Mount static files
+app.mount("/static", StaticFiles(directory="app/static"), name="static")
+
+# Templates
+templates = Jinja2Templates(directory="app/templates")
+
+@app.get("/", response_class=HTMLResponse)
+async def root():
+    """Simple HTML interface for testing"""
+    html_content = """
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>Face Recognition Test</title>
+        <style>
+            body { font-family: Arial, sans-serif; margin: 40px; }
+            .container { max-width: 600px; margin: 0 auto; }
+            .form-group { margin: 20px 0; }
+            input[type="file"] { margin: 10px 0; }
+            button { background: #007bff; color: white; padding: 10px 20px; border: none; border-radius: 5px; cursor: pointer; }
+            button:hover { background: #0056b3; }
+            .result { margin: 20px 0; padding: 15px; background: #f8f9fa; border-radius: 5px; }
+            .error { background: #f8d7da; color: #721c24; }
+            .success { background: #d4edda; color: #155724; }
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <h1>🧠 Face Recognition Test</h1>
+            <p>Upload a face image to test the classification locally.</p>
+            
+            <form action="/predict" method="post" enctype="multipart/form-data">
+                <div class="form-group">
+                    <label for="file">Select Face Image:</label><br>
+                    <input type="file" id="file" name="file" accept="image/*" required>
+                </div>
+                <button type="submit">🔍 Classify Face</button>
+            </form>
+            
+            <div id="result"></div>
+        </div>
+        
+        <script>
+            document.querySelector('form').addEventListener('submit', async function(e) {
+                e.preventDefault();
+                
+                const formData = new FormData();
+                const fileInput = document.getElementById('file');
+                formData.append('file', fileInput.files[0]);
+                
+                const resultDiv = document.getElementById('result');
+                resultDiv.innerHTML = '<div class="result">Processing...</div>';
+                
+                try {
+                    const response = await fetch('/predict', {
+                        method: 'POST',
+                        body: formData
+                    });
+                    
+                    const result = await response.text();
+                    
+                    if (result.includes('UNKNOWN_CLASS')) {
+                        resultDiv.innerHTML = `<div class="result error">❌ Result: ${result}</div>`;
+                    } else if (result.includes('Person')) {
+                        resultDiv.innerHTML = `<div class="result success">✅ Result: ${result}</div>`;
+                    } else {
+                        resultDiv.innerHTML = `<div class="result">📋 Result: ${result}</div>`;
+                    }
+                } catch (error) {
+                    resultDiv.innerHTML = `<div class="result error">❌ Error: ${error.message}</div>`;
+                }
+            });
+        </script>
+    </body>
+    </html>
+    """
+    return HTMLResponse(content=html_content)
+
+@app.post("/predict")
+async def predict_face(file: UploadFile = File(...)):
+    """Predict face class from uploaded image"""
+    try:
+        # Save uploaded file
+        contents = await file.read()
+        filename = f"app/static/{file.filename}"
+        
+        with open(filename, 'wb') as f:
+            f.write(contents)
+        
+        # Load and process image
+        img = Image.open(filename)
+        img_array = np.array(img).reshape(img.size[1], img.size[0], 3).astype(np.uint8)
+        
+        # Get face class
+        result = face_recognition.get_face_class(img_array)
+        
+        return f"Predicted Face Class: {result}"
+        
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+@app.get("/test")
+async def test_endpoint():
+    """Simple test endpoint"""
+    try:
+        from app.Hackathon_setup.face_recognition import CLASS_NAMES
+        import joblib
+        
+        # Test model loading
+        classifier = joblib.load('app/Hackathon_setup/decision_tree_model.sav')
+        scaler = joblib.load('app/Hackathon_setup/face_recognition_scaler.sav')
+        
+        return {
+            "status": "success",
+            "class_names": CLASS_NAMES,
+            "classifier_classes": classifier.classes_.tolist(),
+            "scaler_features": scaler.n_features_in_
+        }
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+
+if __name__ == "__main__":
+    print("Starting local Face Recognition test server...")
+    print("Open your browser and go to: http://localhost:8000")
+    print("Press Ctrl+C to stop the server")
+    
+    uvicorn.run(app, host="0.0.0.0", port=8000)