app.py

import gradio as gr
import tensorflow as tf
import numpy as np
from scipy.spatial.distance import cosine
import cv2
import os

# K-mean Clustering
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt

# Threshold 
RECOGNITION_THRESHOLD = 0.1  # Adjust as needed
n_clusters = 5  # You can adjust this based on your data
kmeans = KMeans(n_clusters=n_clusters)

# Load the embedding model
embedding_model = tf.keras.models.load_model('base.h5')

# Database to store embeddings and user IDs
user_embeddings = []
user_ids = []

# Preprocess the image
def preprocess_image(image):
    image = cv2.resize(image, (200, 200))  # Resize image to 200x200
    image = tf.keras.applications.resnet50.preprocess_input(image)
    return np.expand_dims(image, axis=0)

# Generate embedding
def generate_embedding(image):
    preprocessed_image = preprocess_image(image)
    return embedding_model.predict(preprocessed_image)[0]

# Register new user
def register_user(image, user_id):
    try:
        embedding = generate_embedding(image)
        user_embeddings.append(embedding)
        user_ids.append(user_id)
        return f"User {user_id} registered successfully."
    except Exception as e:
        return f"Error during registration: {str(e)}"

# Recognize user
def recognize_user(image):
    try:
        new_embedding = generate_embedding(image)
        # Update the KMeans model
        kmeans.fit(user_embeddings)
        cluster_label = kmeans.predict([new_embedding])[0]
        distances = kmeans.transform([new_embedding])[0]
        min_distance = np.min(distances)

        if min_distance > RECOGNITION_THRESHOLD:
            return "User not recognized."

        # Find the user ID(s) in the closest cluster
        recognized_user_ids = [user_ids[i] for i, label in enumerate(kmeans.labels_) if label == cluster_label]
        return f"Recognized User(s): {', '.join(recognized_user_ids)}"
    except Exception as e:
        return f"Error during recognition: {str(e)}"

def plot_clusters():
    # Assuming embeddings are 2-dimensional
    plt.figure(figsize=(8, 6))
    plt.scatter(*zip(*user_embeddings), c=kmeans.labels_)
    plt.title('User Embeddings Clustered by K-Means')
    plt.xlabel('Embedding Dimension 1')
    plt.ylabel('Embedding Dimension 2')
    plt.show()
        
def main():
    with gr.Blocks() as demo:
        gr.Markdown("Facial Recognition System")
        with gr.Tab("Register"):
            with gr.Row():
                img_register = gr.Image()
                user_id = gr.Textbox(label="User ID")
                register_button = gr.Button("Register")
            register_output = gr.Textbox()
            register_button.click(register_user, inputs=[img_register, user_id], outputs=register_output)

        with gr.Tab("Recognize"):
            with gr.Row():
                img_recognize = gr.Image()
                recognize_button = gr.Button("Recognize")
            recognize_output = gr.Textbox()
            recognize_button.click(recognize_user, inputs=[img_recognize], outputs=recognize_output)

    demo.launch(share=True)

if __name__ == "__main__":
    main()