Update app.py

app.py

@@ -1,190 +1,102 @@
-# Transformers and its models
-#import transformers
-
-# For Image Processing
-#from transformers import ViTImageProcessor
-
-# For Model
-#from transformers import ViTModel, ViTConfig, pipeline
-import insightface
-from insightface.app import FaceAnalysis
-
-# For data augmentation
-from torchvision import transforms, datasets
-from flask import request
-# For GPU
-#from transformers import set_seed
-#from torch.optim import AdamW
-#from accelerate import Accelerator, notebook_launcher
-
-# For Data Loaders
-import datasets
-from torch.utils.data import Dataset, DataLoader
-
-# For Display
-#from tqdm.notebook import tqdm
-
-# Other Generic Libraries
-import torch
-from PIL import Image
-import cv2
 import os
+import cv2
+import torch
+import numpy as np
 import streamlit as st
-import gc
+import requests
+
+from PIL import Image
 from glob import glob
-import shutil
-import pandas as pd
-import numpy as np
-#import matplotlib.pyplot as plt
-from io import BytesIO
+from insightface.app import FaceAnalysis
 import torch.nn.functional as F
 
-# Set the device (GPU or CPU)
+# Set the device
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
-# Initialse Globle Variables
-MODEL_TRANSFORMER = 'google/vit-base-patch16-224'
-BATCH_SIZE = 8
-
-# Set Paths
+# Global Variables
+IMAGE_SHAPE = 640
 data_path = 'employees'
-model_path = 'vit_pytorch_GPU_1.pt'
 webcam_path = 'captured_image.jpg'
 
-IMAGE_SHAPE = 640
-
-# Set Title
+# Set Streamlit title
 st.title("AIML-Student Attendance System")
-   
-# Read images from directory
-image_paths = []
-image_file = glob(os.path.join(data_path, '*.jpg'))
-#st.write(image_file)
-image_paths.extend(image_file)
-#st.write('input path size:', len(image_paths))
-#st.write(image_paths)
-
-# Initialize the app
-app = FaceAnalysis(name="buffalo_l")  # buffalo_l includes ArcFace model
-app.prepare(ctx_id=-1, det_size=(IMAGE_SHAPE, IMAGE_SHAPE))  # Use ctx_id=-1 if you want CPU, and ctx_id=0 for GPU
-
-# Define the ML model - Evaluation function
-def prod_function(app, prod_path, webcam_path):
-    webcam_img = Image.open(webcam_path)
-    np_webcam = np.array(webcam_img) # Convert to NumPy array
-    cv2_webcam = cv2.cvtColor(np_webcam, cv2.COLOR_RGB2BGR) # Convert RGB (PIL) to BGR (OpenCV)
+
+# Load employee image paths
+image_paths = glob(os.path.join(data_path, '*.jpg'))
+
+# Initialize Face Analysis
+app = FaceAnalysis(name="buffalo_l")  # ArcFace model
+app.prepare(ctx_id=0 if torch.cuda.is_available() else -1, det_size=(IMAGE_SHAPE, IMAGE_SHAPE))
+
+# Define function to match face embeddings
+def prod_function(app, prod_path, webcam_img_pil):
+    np_webcam = np.array(webcam_img_pil)
+    cv2_webcam = cv2.cvtColor(np_webcam, cv2.COLOR_RGB2BGR)
     
-    webcam_emb = app.get(cv2_webcam, max_num=1)
-    webcam_emb = webcam_emb[0].embedding
-    webcam_emb = torch.from_numpy(np.array(webcam_emb))
+    webcam_faces = app.get(cv2_webcam, max_num=1)
+    if not webcam_faces:
+        return None, None
     
-    similarity_score = []
+    webcam_emb = torch.tensor(webcam_faces[0].embedding, dtype=torch.float32)
+
+    similarity_scores = []
     for path in prod_path:
         img = cv2.imread(path)
-        face_embedding = app.get(img, max_num=1)
-        face_embedding = face_embedding[0].embedding
-        face_embedding = torch.from_numpy(np.array(face_embedding))
-        
-        similarity_score.append(F.cosine_similarity(face_embedding,webcam_emb, dim=0))
-        #distance = F.pairwise_distance(emb, emb_prod)
-        #prod_preds.append(distance)
-    similarity_score = torch.from_numpy(np.array(similarity_score))
-    return similarity_score #prod_preds
+        faces = app.get(img, max_num=1)
+        if not faces:
+            similarity_scores.append(torch.tensor(-1.0))
+            continue
+
+        face_emb = torch.tensor(faces[0].embedding, dtype=torch.float32)
+        score = F.cosine_similarity(face_emb, webcam_emb, dim=0)
+        similarity_scores.append(score)
 
+    similarity_scores = torch.stack(similarity_scores)
+    return similarity_scores, torch.argmax(similarity_scores)
+
+# Streamlit tabs
 about_tab, app_tab = st.tabs(["About the app", "Face Recognition"])
-# About the app Tab
+
 with about_tab:
-    st.markdown(
-        """
-        # 👁️‍🗨️ AI-Powered Face Recognition Attendance System
-        Effortless, Secure, and Accurate Attendance with Vision Transformer Technology
-        
-        An intelligent, facial recognition-based attendance solution that redefines how organizations manage employee presence. By leveraging cutting-edge computer vision and AI, the app automates attendance tracking with speed, precision, and reliability—no timecards, no fingerprint scans, just a glance.
-        
-        ## 🎯 Project Objective
-        To eliminate outdated, manual attendance methods with a seamless, contactless facial recognition system. Our solution not only improves the accuracy of attendance logs but also boosts workplace security and streamlines HR operations—all in real time.
-        Employees are simply scanned as they enter or leave the premises. Their attendance is automatically logged, reducing the risk of buddy punching, manual entry errors, and delays in record-keeping.
-        
-        ## 🧠 How It Works: The AI in Action
-        At the core of this app is Google’s Vision Transformer (ViT) architecture, trained on the Labeled Faces in the Wild (LFW) dataset for robust, real-world face recognition.
-        
-        - **Face Detection & Feature Extraction**
-        The model scans an employee’s face and extracts a high-dimensional representation of their unique features.
-        
-        - **Identity Matching with Confidence Scoring**
-        The scanned features are compared to stored profiles. If the confidence score crosses a threshold, the model confirms the match and automatically marks attendance.
-        
-        - **Real-Time Logging**
-        The app logs entry and exit times in real-time, providing live dashboards and attendance reports for HR and management.
-        
-        ## 🏗️ About the Architecture: Vision Transformer (ViT)
-        The Vision Transformer (ViT) brings the power of transformer models—originally created for language—to the world of images. Here's how it works:
-        
-        - An input image is split into fixed-size non-overlapping patches.
-        - Each patch is flattened and embedded into a higher-dimensional space.
-        - These embeddings are fed into a transformer encoder, which learns complex spatial and contextual relationships across the entire image using multi-head self-attention.
-        - ViT’s ability to capture global dependencies enables it to outperform traditional CNNs when trained on sufficient data.
-        
-        This makes it ideal for high-accuracy face recognition in dynamic, real-world environments.
-        
-        ## 📚 About the Dataset: Labeled Faces in the Wild (LFW)
-        To train the model, we used the renowned Labeled Faces in the Wild (LFW) dataset, consisting of 13,000+ facial images, 5,749 individuals, each shown in diverse lighting, angles, and backgrounds. Sourced from real-world photographs of public figures. Benchmark dataset for tasks like face verification and recognition. The diversity in LFW ensures our model is resilient to variations in appearance, making it highly reliable in real-world workplace scenarios.
-        
-        ## ✅ Key Features
-        - Fast, contactless attendance logging
-        - High-security identity verification
-        - Real-time data and analytics
-        - Powered by state-of-the-art Vision Transformer architecture
-        - Eliminates manual records, reduces fraud, enhances efficiency
-        
-        ## 👥 Use Cases
-        - Corporate Offices: Accurate time tracking and security for large workforces
-        - Factories & Warehouses: Contactless attendance in high-throughput environments
-        - Educational Institutions: Seamless student and staff attendance
-        - Healthcare & Public Services: Ensures hygienic, automated check-ins
-        
-        ## 🚀 Future Scope
-        Looking ahead, we aim to integrate multi-face detection for group scanning, mask-aware recognition, and cross-location synchronization for distributed teams—all while preserving data privacy and security.
-        """)
-
-# Gesture recognition Tab
+    st.markdown("""
+    # 👁️‍🗨️ AI-Powered Face Recognition Attendance System
+    Secure and Accurate Attendance using Vision Transformer + ArcFace Embeddings.
+    
+    - **Automated, contactless attendance logging**
+    - **Uses InsightFace ArcFace embeddings for recognition**
+    - **Real-time logging with confidence scoring**
+    - **Future Scope: Mask-aware recognition, Group detection, and more**
+    """)
+
 with app_tab:
-    # Read image from Camera
     enable = st.checkbox("Enable camera")
     picture = st.camera_input("Take a picture", disabled=not enable)
+
     if picture is not None:
-         
-        with st.spinner("Wait for it...", show_time=True):
-            # Run the predictions
-            prediction = prod_function(app, image_paths, picture)
-            #prediction = torch.cat(prediction, 0).to(device)
-            match_idx = torch.argmax(prediction)
-            st.write(prediction)
-            st.write(image_paths)
-        
-            # Display the results
-            if prediction[match_idx] >= 0.6:
-                pname = image_paths[match_idx].split('/')[-1].split('.')[0]
-                st.write('Welcome: ',pname)
-
-                ###### upload the data to Glitch https://aimljan25f.glitch.me/adds
-                # # using post method
-                url = "https://aimljan25f.glitch.me/adds"
-                 
-                data = {'rno': '15','sname': pname, 'sclass': '7'  }
-                # response = requests.post(url +url1 , data=data)
-    
-                # Post Method is invoked if data != None
-                req =  request.Request(url , method="POST", data=data)
-                
-                # Response
-                resp = request.urlopen(req)
-                if response.status_code == 200:
-                    st.success("Data updated on: " + "https://aimljan25f.glitch.me/")
-                else:
-                    st.warning("Data not updated")
-                ########## end update website 
+        with st.spinner("Analyzing face..."):
+            image_pil = Image.open(picture)
+            prediction_scores, match_idx = prod_function(app, image_paths, image_pil)
 
-                #######################
+            if prediction_scores is None:
+                st.warning("No face detected in the captured image.")
             else:
-              st.write("Match not found")
+                st.write("Similarity Scores:", prediction_scores)
+                matched_score = prediction_scores[match_idx].item()
+
+                if matched_score >= 0.6:
+                    matched_name = os.path.basename(image_paths[match_idx]).split('.')[0]
+                    st.success(f"✅ Welcome: {matched_name}")
+                    
+                    # Send attendance via POST
+                    url = "https://aimljan25f.glitch.me/adds"
+                    data = {'rno': '15', 'sname': matched_name, 'sclass': '7'}
+                    try:
+                        response = requests.post(url, data=data)
+                        if response.status_code == 200:
+                            st.success("Attendance marked successfully.")
+                        else:
+                            st.warning("Failed to update attendance.")
+                    except Exception as e:
+                        st.error(f"Request failed: {e}")
+                else:
+                    st.error("❌ Match not found. Try again.")