Upload 8 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+gender_model.keras filter=lfs diff=lfs merge=lfs -text

__init__.py

@@ -0,0 +1,18 @@
+"""
+Utilities package for fingerprint analysis
+"""
+
+from .model_loader import load_blood_group_model, load_gender_model, set_model_paths
+from .predictor import predict_blood_group, predict_gender
+from .preprocessing import preprocess_fingerprint, enhance_fingerprint, normalize_fingerprint
+
+__all__ = [
+    'load_blood_group_model',
+    'load_gender_model',
+    'set_model_paths',
+    'predict_blood_group',
+    'predict_gender',
+    'preprocess_fingerprint',
+    'enhance_fingerprint',
+    'normalize_fingerprint'
+]

app.py

@@ -0,0 +1,106 @@
+import gradio as gr
+import cv2
+import numpy as np
+from PIL import Image
+import os
+from utils.model_loader import load_blood_group_model, load_gender_model
+from utils.predictor import predict_blood_group, predict_gender
+from utils.preprocessing import preprocess_fingerprint
+
+blood_model = None
+gender_model = None
+
+
+def load_models():
+    global blood_model, gender_model
+    if blood_model is None:
+        try:
+            blood_model = load_blood_group_model()
+        except Exception as e:
+            print(f"Warning: Blood group model not loaded: {e}")
+            blood_model = None
+
+    if gender_model is None:
+        try:
+            gender_model = load_gender_model()
+        except Exception as e:
+            print(f"Warning: Gender model not loaded: {e}")
+            gender_model = None
+
+    return blood_model, gender_model
+
+
+def analyze_fingerprint(image):
+    """Analyze uploaded fingerprint image"""
+    if image is None:
+        return "Please upload a fingerprint image.", "", "", ""
+    
+    try:
+        # Load models lazily
+        blood_model, gender_model = load_models()
+        if blood_model is None or gender_model is None:
+            missing = []
+            if blood_model is None:
+                missing.append("blood group")
+            if gender_model is None:
+                missing.append("gender")
+            missing_text = ", ".join(missing)
+            msg = f"Model files not deployed on Vercel. Missing: {missing_text}."
+            return msg, "", msg, ""
+
+        # Preprocess for both models
+        preprocessed_blood = preprocess_fingerprint(image, model_type="blood_group")
+        preprocessed_gender = preprocess_fingerprint(image, model_type="gender")
+        
+        # Get predictions
+        blood_result = predict_blood_group(blood_model, preprocessed_blood)
+        gender_result = predict_gender(gender_model, preprocessed_gender)
+        
+        # Format results
+        if blood_result["success"]:
+            blood_text = f"**Predicted Blood Group:** {blood_result['blood_group']}\n**Confidence:** {blood_result['confidence']:.2%}"
+            blood_details = "\n".join([f"{k}: {v:.2%}" for k, v in blood_result['all_scores'].items()])
+        else:
+            blood_text = "Error predicting blood group"
+            blood_details = str(blood_result.get('error', 'Unknown error'))
+        
+        if gender_result["success"]:
+            gender_text = f"**Predicted Gender:** {gender_result['gender']}\n**Confidence:** {gender_result['confidence']:.2%}"
+        else:
+            gender_text = "Error predicting gender"
+        
+        return blood_text, blood_details, gender_text, ""
+    
+    except Exception as e:
+        return f"Error processing image: {str(e)}", "", "", ""
+
+# Create Gradio interface
+with gr.Blocks(title="Forensic Fingerprint Analysis", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🔍 Forensic Fingerprint Analysis System")
+    gr.Markdown("Upload a fingerprint image to predict blood group and gender using machine learning models.")
+    
+    with gr.Row():
+        with gr.Column():
+            image_input = gr.Image(label="Upload Fingerprint Image", type="pil")
+            analyze_btn = gr.Button("Analyze Fingerprint", variant="primary")
+        
+        with gr.Column():
+            gr.Markdown("### Results")
+            blood_output = gr.Textbox(label="Blood Group Prediction", lines=2)
+            blood_scores = gr.Textbox(label="All Blood Group Scores", lines=8)
+            gender_output = gr.Textbox(label="Gender Prediction", lines=2)
+    
+    # Connect the function
+    analyze_btn.click(
+        analyze_fingerprint,
+        inputs=image_input,
+        outputs=[blood_output, blood_scores, gender_output, gr.Textbox(visible=False)]
+    )
+    
+    gr.Markdown("---")
+    gr.Markdown("**About:** 4th Year Forensic Research Project - Analyzing fingerprint patterns for biometric identification.")
+
+# Launch the app
+if __name__ == "__main__":
+    port = int(os.environ.get("PORT", 7860))
+    demo.launch(server_name="0.0.0.0", server_port=port)

blood_group.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3ea178e44a802816aed922387593bb75fc087bd3096ca49aad3684fbf5b8be6d
+size 228500768

gender_model.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b66ad937568293257a76d3a80f561a8f72e092103d8c98f687398779365fef06
+size 53635603

model_loader.py

@@ -0,0 +1,108 @@
+"""
+Model loading utilities for fingerprint analysis models
+"""
+
+import os
+import pickle
+import joblib
+from pathlib import Path
+import warnings
+warnings.filterwarnings('ignore')
+
+# Import TensorFlow
+import tensorflow as tf
+
+# Configure paths
+BASE_DIR = Path(__file__).parent.parent
+MODELS_DIR = BASE_DIR / "models"
+
+# Model paths
+BLOOD_GROUP_MODEL_PATH = os.environ.get(
+    "BLOOD_GROUP_MODEL_PATH",
+    str(MODELS_DIR / "blood_group.h5")
+)
+GENDER_MODEL_PATH = os.environ.get(
+    "GENDER_MODEL_PATH", 
+    str(MODELS_DIR / "gender_model.keras")
+)
+
+# Global variables to cache loaded models
+_blood_group_model = None
+_gender_model = None
+
+
+def load_blood_group_model():
+    """Load the blood group prediction model"""
+    global _blood_group_model
+    
+    if _blood_group_model is not None:
+        return _blood_group_model
+    
+    try:
+        if BLOOD_GROUP_MODEL_PATH.endswith(('.h5', '.keras')):
+            try:
+                _blood_group_model = tf.keras.models.load_model(BLOOD_GROUP_MODEL_PATH)
+            except Exception as e:
+                # Fallback: load without compile
+                print(f"⚠️ Trying compile=False...")
+                _blood_group_model = tf.keras.models.load_model(BLOOD_GROUP_MODEL_PATH, compile=False)
+                _blood_group_model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
+        elif BLOOD_GROUP_MODEL_PATH.endswith('.pkl'):
+            with open(BLOOD_GROUP_MODEL_PATH, 'rb') as f:
+                _blood_group_model = pickle.load(f)
+        elif BLOOD_GROUP_MODEL_PATH.endswith('.joblib'):
+            _blood_group_model = joblib.load(BLOOD_GROUP_MODEL_PATH)
+        else:
+            raise ValueError(f"Unsupported format: {BLOOD_GROUP_MODEL_PATH}")
+        
+        print(f"✓ Blood group model loaded")
+        return _blood_group_model
+    
+    except Exception as e:
+        raise Exception(f"Error loading blood group model: {str(e)}")
+
+
+def load_gender_model():
+    """Load the gender classification model"""
+    global _gender_model
+    
+    if _gender_model is not None:
+        return _gender_model
+    
+    try:
+        if GENDER_MODEL_PATH.endswith(('.h5', '.keras')):
+            try:
+                _gender_model = tf.keras.models.load_model(GENDER_MODEL_PATH)
+            except Exception as e:
+                # Fallback: load without compile
+                print(f"⚠️ Trying compile=False...")
+                _gender_model = tf.keras.models.load_model(GENDER_MODEL_PATH, compile=False)
+                _gender_model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
+        elif GENDER_MODEL_PATH.endswith('.pkl'):
+            with open(GENDER_MODEL_PATH, 'rb') as f:
+                _gender_model = pickle.load(f)
+        elif GENDER_MODEL_PATH.endswith('.joblib'):
+            _gender_model = joblib.load(GENDER_MODEL_PATH)
+        else:
+            raise ValueError(f"Unsupported format: {GENDER_MODEL_PATH}")
+        
+        print(f"✓ Gender model loaded")
+        return _gender_model
+    
+    except Exception as e:
+        raise Exception(f"Error loading gender model: {str(e)}")
+
+
+def set_model_paths(blood_group_path, gender_path):
+    """Update model paths at runtime"""
+    global BLOOD_GROUP_MODEL_PATH, GENDER_MODEL_PATH
+    global _blood_group_model, _gender_model
+    
+    BLOOD_GROUP_MODEL_PATH = blood_group_path
+    GENDER_MODEL_PATH = gender_path
+    
+    # Clear cached models
+    _blood_group_model = None
+    _gender_model = None
+    
+    print(f"Model paths updated successfully")

predictor.py

@@ -0,0 +1,146 @@
+"""
+Prediction functions for fingerprint analysis models
+"""
+
+import numpy as np
+from typing import Dict, Any
+
+
+# Blood group classes
+BLOOD_GROUPS = ['A+', 'A-', 'B+', 'B-', 'AB+', 'AB-', 'O+', 'O-']
+
+
+def predict_blood_group(model, image_array: np.ndarray) -> Dict[str, Any]:
+    """
+    Predict blood group from fingerprint image
+    
+    Args:
+        model: Loaded blood group model
+        image_array: Preprocessed image array (150x150x3)
+    
+    Returns:
+        Dictionary with prediction results
+    """
+    try:
+        # Ensure image has batch dimension
+        if len(image_array.shape) == 3:
+            image_array = np.expand_dims(image_array, axis=0)
+        
+        print(f"DEBUG: Blood group input shape: {image_array.shape}")
+        print(f"DEBUG: Blood group input min/max: {image_array.min()}/{image_array.max()}")
+        
+        # Get predictions
+        predictions = model.predict(image_array, verbose=0)
+        
+        print(f"DEBUG: Raw predictions shape: {predictions.shape}")
+        print(f"DEBUG: Raw predictions: {predictions[0]}")
+        print(f"DEBUG: Raw predictions min/max: {predictions.min()}/{predictions.max()}")
+        
+        # Apply softmax if values look like logits (large range)
+        if np.max(np.abs(predictions)) > 50:
+            print("DEBUG: Applying softmax...")
+            predictions = np.exp(predictions) / np.sum(np.exp(predictions), axis=1, keepdims=True)
+        
+        # Handle different output shapes
+        if predictions.shape[1] == len(BLOOD_GROUPS):
+            # Multiple classes (classification)
+            confidence = np.max(predictions[0])
+            predicted_class = np.argmax(predictions[0])
+            predicted_blood_group = BLOOD_GROUPS[predicted_class]
+            
+            # Get all scores
+            all_scores = {BLOOD_GROUPS[i]: float(predictions[0][i]) 
+                         for i in range(len(BLOOD_GROUPS))}
+        else:
+            # Different output size, map to blood groups
+            confidence = np.max(predictions[0])
+            predicted_class = np.argmax(predictions[0])
+            predicted_blood_group = BLOOD_GROUPS[min(predicted_class, len(BLOOD_GROUPS)-1)]
+            
+            all_scores = {BLOOD_GROUPS[i]: float(predictions[0][i]) 
+                         for i in range(min(len(predictions[0]), len(BLOOD_GROUPS)))}
+        
+        print(f"DEBUG: Final confidence: {confidence}")
+        
+        return {
+            "blood_group": predicted_blood_group,
+            "confidence": float(confidence),
+            "all_scores": all_scores,
+            "success": True
+        }
+    
+    except Exception as e:
+        print(f"ERROR in predict_blood_group: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return {
+            "blood_group": None,
+            "confidence": 0.0,
+            "all_scores": {},
+            "success": False,
+            "error": str(e)
+        }
+
+
+def predict_gender(model, image_array: np.ndarray) -> Dict[str, Any]:
+    """
+    Predict gender from fingerprint image
+    
+    Args:
+        model: Loaded gender classification model
+        image_array: Preprocessed image array (224x224x1)
+    
+    Returns:
+        Dictionary with prediction results
+    """
+    try:
+        # Ensure image has batch dimension
+        if len(image_array.shape) == 3:
+            image_array = np.expand_dims(image_array, axis=0)
+        
+        print(f"DEBUG (gender): Input shape: {image_array.shape}")
+        print(f"DEBUG (gender): Input min/max: {image_array.min()}/{image_array.max()}")
+        
+        # Get prediction
+        prediction = model.predict(image_array, verbose=0)
+        
+        print(f"DEBUG (gender): Raw predictions shape: {prediction.shape}")
+        print(f"DEBUG (gender): Raw predictions: {prediction[0]}")
+        print(f"DEBUG (gender): Raw predictions min/max: {prediction.min()}/{prediction.max()}")
+        
+        # Apply softmax if values look like logits
+        if np.max(np.abs(prediction)) > 50:
+            print("DEBUG (gender): Applying softmax...")
+            prediction = np.exp(prediction) / np.sum(np.exp(prediction), axis=1, keepdims=True)
+        
+        # Handle different output shapes
+        if prediction.shape[1] == 1:
+            # Binary classification: single output (sigmoid)
+            confidence = float(prediction[0][0])
+            predicted_gender = "Female" if confidence < 0.5 else "Male"
+            # Adjust confidence to be distance from 0.5
+            confidence = abs(confidence - 0.5) * 2
+        else:
+            # Binary classification: two outputs (softmax)
+            confidence = float(np.max(prediction[0]))
+            predicted_class = np.argmax(prediction[0])
+            predicted_gender = "Female" if predicted_class == 0 else "Male"
+        
+        print(f"DEBUG (gender): Final confidence: {confidence}")
+        
+        return {
+            "gender": predicted_gender,
+            "confidence": confidence,
+            "success": True
+        }
+    
+    except Exception as e:
+        print(f"ERROR in predict_gender: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return {
+            "gender": None,
+            "confidence": 0.0,
+            "success": False,
+            "error": str(e)
+        }

preprocessing.py

@@ -0,0 +1,103 @@
+"""
+Image preprocessing utilities for fingerprint images
+"""
+
+import cv2
+import numpy as np
+from PIL import Image
+
+
+def preprocess_fingerprint(image: Image.Image, model_type: str = "gender", target_size: tuple = None) -> np.ndarray:
+    """
+    Preprocess fingerprint image for model prediction
+    
+    Args:
+        image: PIL Image object
+        model_type: "blood_group" or "gender" - determines preprocessing
+        target_size: Override target size
+    
+    Returns:
+        Preprocessed numpy array with correct shape for the model
+    """
+    # Set target size and channels based on model type
+    if model_type == "blood_group":
+        target_size = target_size or (150, 150)
+        output_channels = 3  # RGB
+    else:  # gender
+        target_size = target_size or (224, 224)
+        output_channels = 1  # Grayscale
+    
+    # Convert PIL Image to numpy array
+    img_array = np.array(image)
+    
+    # Convert to grayscale first
+    if len(img_array.shape) == 3:
+        img_array = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
+    
+    # Resize to target size
+    img_resized = cv2.resize(img_array, target_size, interpolation=cv2.INTER_AREA)
+    
+    # Normalize pixel values to 0-1 range
+    img_normalized = img_resized.astype('float32') / 255.0
+    
+    # Apply histogram equalization for better contrast
+    img_normalized = cv2.equalizeHist((img_normalized * 255).astype(np.uint8)).astype(np.float32) / 255.0
+    
+    # Format output based on model type
+    if output_channels == 3:
+        # Blood group: Convert grayscale to RGB by repeating channels
+        img_output = np.stack([img_normalized, img_normalized, img_normalized], axis=-1)
+    else:
+        # Gender: Keep as grayscale with single channel
+        img_output = np.expand_dims(img_normalized, axis=-1)
+    
+    print(f"DEBUG preprocessing ({model_type}): Output shape = {img_output.shape}, min/max = {img_output.min()}/{img_output.max()}")
+    
+    return img_output
+
+
+def enhance_fingerprint(image: np.ndarray) -> np.ndarray:
+    """
+    Enhance fingerprint features using image processing techniques
+    
+    Args:
+        image: Fingerprint image as numpy array
+    
+    Returns:
+        Enhanced image array
+    """
+    # Convert to grayscale if needed
+    if len(image.shape) == 3:
+        image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+    
+    # Apply morphological operations
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
+    enhanced = cv2.morphologyEx(image, cv2.MORPH_CLOSE, kernel)
+    enhanced = cv2.morphologyEx(enhanced, cv2.MORPH_OPEN, kernel)
+    
+    # Apply median filter to remove noise
+    enhanced = cv2.medianBlur(enhanced, 5)
+    
+    return enhanced
+
+
+def normalize_fingerprint(image: np.ndarray) -> np.ndarray:
+    """
+    Normalize fingerprint image using standard normalization
+    
+    Args:
+        image: Fingerprint image as numpy array
+    
+    Returns:
+        Normalized image array
+    """
+    if len(image.shape) == 3 and image.shape[-1] == 3:
+        # RGB normalization
+        mean = np.array([0.485, 0.456, 0.406])
+        std = np.array([0.229, 0.224, 0.225])
+        return (image - mean) / std
+    else:
+        # Grayscale normalization
+        mean = 0.5
+        std = 0.5
+        return (image - mean) / std

requirements.txt

@@ -0,0 +1,9 @@
+gradio==6.13.0
+opencv-python==4.8.1.78
+numpy==1.26.4
+Pillow==12.2.0
+tensorflow-cpu==2.21.0
+scikit-learn==1.8.0
+pandas==2.2.3
+fastapi>=0.115.2
+uvicorn==0.24.0