work 0.1

.gitignore

@@ -0,0 +1,2 @@
+# Will later remove that commit 
+known_faces/

Dockerfile

@@ -0,0 +1,16 @@
+FROM python:3.10-slim
+
+# Install g++
+RUN apt-get update && apt-get install -y g++
+
+WORKDIR /app
+
+COPY ./ /app
+
+# For GPU support:
+RUN pip3 install --extra-index-url https://download.pytorch.org/whl/cu118 torch torchvision 
+
+RUN pip install -r requirements.txt
+
+
+CMD fastapi run --reload --host=0.0.0.0 --port=7860

Dockerfile.update

@@ -0,0 +1,3 @@
+FROM attend_b-hf
+
+RUN pip install python-multipart opencv-python-headless pillow

activate_env.bat

@@ -0,0 +1,2 @@
+@echo off
+conda activate E:\INTERNSHIP\ongc\USING_DEEPLEARNING\table-transformer\env

app.py

@@ -0,0 +1,330 @@
+#4:
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+import numpy as np
+import cv2
+import base64
+import logging
+import os
+from pathlib import Path
+from face_recognition_system import FaceRecognitionSystem
+
+# Set up logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="Face Recognition API",
+    description="API for face detection and recognition using InsightFace",
+    version="1.0.0"
+)
+
+# Add CORS middleware for Hugging Face Spaces
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Create necessary directories
+MODELS_DIR = Path("models")
+KNOWN_FACES_DIR = Path("known_faces")
+for directory in [MODELS_DIR, KNOWN_FACES_DIR]:
+    directory.mkdir(parents=True, exist_ok=True)
+
+# Initialize face recognition system
+try:
+    face_recog_system = FaceRecognitionSystem(
+        model_name="buffalo_l",
+        model_root=str(MODELS_DIR)
+    )
+    face_recog_system.process_known_faces(str(KNOWN_FACES_DIR))
+    logger.info("Face recognition system initialized successfully")
+except Exception as e:
+    logger.error(f"Failed to initialize face recognition system: {e}")
+    raise
+
+@app.get("/")
+async def root():
+    """Health check endpoint"""
+    model_files = list(MODELS_DIR.glob("*"))
+    known_faces = list(KNOWN_FACES_DIR.glob("*"))
+    return {
+        "status": "ok",
+        "message": "Face Recognition API is running",
+        "model_directory": str(MODELS_DIR),
+        "known_faces_directory": str(KNOWN_FACES_DIR),
+        "model_files": [str(f.name) for f in model_files],
+        "known_faces": [str(f.name) for f in known_faces]
+    }
+
+@app.post("/detect_faces")
+async def detect_faces(file: UploadFile = File(...)):
+    """
+    Endpoint to detect and identify faces in an uploaded image
+    """
+    try:
+        # Validate file type
+        if not file.content_type.startswith('image/'):
+            raise HTTPException(status_code=400, detail="File must be an image")
+
+        # Read and decode image
+        image_data = await file.read()
+        nparr = np.frombuffer(image_data, np.uint8)
+        img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+
+        if img is None:
+            raise HTTPException(status_code=400, detail="Failed to decode image")
+
+        # Process image
+        detected_img = face_recog_system.detect_and_identify(img)
+
+        # Encode processed image to base64
+        success, buffer = cv2.imencode('.jpg', detected_img)
+        if not success:
+            raise HTTPException(status_code=500, detail="Failed to encode processed image")
+
+        processed_image_base64 = base64.b64encode(buffer).decode("utf-8")
+
+        # Prepare response
+        serializable_embeddings = {
+            name: embedding.tolist() if isinstance(embedding, np.ndarray) else embedding 
+            for name, embedding in face_recog_system.known_face_embeddings.items()
+        }
+
+        return JSONResponse(content={
+            "status": "success",
+            "processed_image": processed_image_base64,
+            "faces": serializable_embeddings
+        })
+
+    except HTTPException as he:
+        raise he
+    except Exception as e:
+        logger.error(f"Error processing image: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+# Configuration for Hugging Face Spaces
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#3:
+
+# from fastapi import FastAPI, File, UploadFile, HTTPException
+# from fastapi.responses import JSONResponse
+# from fastapi.middleware.cors import CORSMiddleware
+# import numpy as np
+# import cv2
+# import base64
+# import logging
+# from face_recognition_system import FaceRecognitionSystem
+
+# # Set up logging
+# logging.basicConfig(
+#     level=logging.INFO,
+#     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+# )
+# logger = logging.getLogger(__name__)
+
+# # Initialize FastAPI app
+# app = FastAPI(
+#     title="Face Recognition API",
+#     description="API for face detection and recognition using InsightFace",
+#     version="1.0.0"
+# )
+
+# # Add CORS middleware for Hugging Face Spaces
+# app.add_middleware(
+#     CORSMiddleware,
+#     allow_origins=["*"],
+#     allow_credentials=True,
+#     allow_methods=["*"],
+#     allow_headers=["*"],
+# )
+
+# # Initialize face recognition system
+# try:
+#     face_recog_system = FaceRecognitionSystem()
+#     # Update the path to match your Hugging Face Spaces directory structure
+#     face_recog_system.process_known_faces("known_faces")
+#     logger.info("Face recognition system initialized successfully")
+# except Exception as e:
+#     logger.error(f"Failed to initialize face recognition system: {e}")
+#     raise
+
+# @app.get("/")
+# async def root():
+#     """Health check endpoint"""
+#     return {"status": "ok", "message": "Face Recognition API is running"}
+
+# @app.post("/detect_faces")
+# async def detect_faces(file: UploadFile = File(...)):
+#     """
+#     Endpoint to detect and identify faces in an uploaded image
+#     """
+#     try:
+#         # Validate file type
+#         if not file.content_type.startswith('image/'):
+#             raise HTTPException(status_code=400, detail="File must be an image")
+
+#         # Read and decode image
+#         image_data = await file.read()
+#         nparr = np.frombuffer(image_data, np.uint8)
+#         img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+
+#         if img is None:
+#             raise HTTPException(status_code=400, detail="Failed to decode image")
+
+#         # Process image
+#         detected_img = face_recog_system.detect_and_identify(img)
+
+#         # Encode processed image to base64
+#         success, buffer = cv2.imencode('.jpg', detected_img)
+#         if not success:
+#             raise HTTPException(status_code=500, detail="Failed to encode processed image")
+
+#         processed_image_base64 = base64.b64encode(buffer).decode("utf-8")
+
+#         # Prepare response
+#         serializable_embeddings = {
+#             name: embedding.tolist() if isinstance(embedding, np.ndarray) else embedding 
+#             for name, embedding in face_recog_system.known_face_embeddings.items()
+#         }
+
+#         return JSONResponse(content={
+#             "status": "success",
+#             "processed_image": processed_image_base64,
+#             "faces": serializable_embeddings
+#         })
+
+#     except HTTPException as he:
+#         raise he
+#     except Exception as e:
+#         logger.error(f"Error processing image: {e}")
+#         raise HTTPException(status_code=500, detail=str(e))
+
+# # Configuration for Hugging Face Spaces
+# if __name__ == "__main__":
+#     import uvicorn
+#     uvicorn.run(app, host="0.0.0.0", port=7860)
+
+
+
+
+
+# initial:
+# from fastapi import FastAPI
+
+# app = FastAPI()
+
+# @app.get("/")
+# def home():
+#     '''Fuck Everyday Bitch'''
+#     return {"Everything's": "OK bTICH✅"}
+
+
+# final:
+# #2
+# from fastapi import FastAPI, File, UploadFile
+# from fastapi.responses import JSONResponse
+# import numpy as np
+# import cv2
+# import base64
+# import logging
+# from face_recognition_system import FaceRecognitionSystem  # import your class
+
+# # Set up logging
+# logging.basicConfig(level=logging.INFO)
+
+# app = FastAPI()
+# face_recog_system = FaceRecognitionSystem()
+
+# # Load known faces
+# try:
+#     face_recog_system.process_known_faces("./data/known/custom/")
+#     logging.info("Loaded known faces successfully.")
+# except Exception as e:
+#     logging.error(f"Error loading known faces: {e}")
+
+# @app.post("/detect_faces")
+# async def detect_faces(file: UploadFile = File(...)):
+#     try:
+#         # Read and decode image from the uploaded file
+#         image_data = await file.read()
+#         nparr = np.frombuffer(image_data, np.uint8)
+#         img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+
+#         # Check if image is loaded
+#         if img is None:
+#             logging.error("Failed to decode image. Ensure the uploaded file is a valid image.")
+#             return JSONResponse(content={"error": "Invalid image file"}, status_code=400)
+
+#         # Run detection and identification
+#         detected_img = face_recog_system.detect_and_identify(img)
+
+#         # Encode imNONOFage to base64
+#         success, buffer = cv2.imencode('.jpg', detected_img)
+#         if not success:
+#             logging.error("Image encoding failed.")
+#             return JSONResponse(content={"error": "Image encoding failed"}, status_code=500)
+
+#         processed_image_base64 = base64.b64encode(buffer).decode("utf-8")
+
+#         # Optional: Check if face embeddings were created
+#         if not face_recog_system.known_face_embeddings:
+#             logging.warning("No faces detected.")
+
+#         # NOTE:
+#         # Convert numpy arrays to lists for JSON serialization
+#         serializable_embeddings = {
+#             name: embedding.tolist() if isinstance(embedding, np.ndarray) else embedding 
+#             for name, embedding in face_recog_system.known_face_embeddings.items()
+#         }
+#         return JSONResponse(content={
+#             "processed_image": processed_image_base64, 
+#             "faces": serializable_embeddings
+#         })
+        
+#         # return JSONResponse(content={"processed_image": processed_image_base64, "faces": face_recog_system.known_face_embeddings})
+
+#     except Exception as e:
+#         logging.error(f"Error processing image: {e}")
+#         return JSONResponse(content={"error": "An error occurred while processing the image"}, status_code=500)
+
+
+# # main:
+# # NOTE: ALWAYS FIRST CHECK IPv4-Address via: <ipconfig>
+# # import uvicorn
+# # if __name__ == "__main__":
+# #     uvicorn.run(app='app:app',
+# #                 host='192.168.1.17', port=7860, reload=True)
+
+
+

face_recognition_system.py

@@ -0,0 +1,424 @@
+# 2:
+import cv2
+import numpy as np
+import insightface
+from insightface.app import FaceAnalysis
+from insightface.utils import download_onnx
+from pathlib import Path
+from typing import Dict, List, Tuple
+import pickle
+import logging
+import os
+
+class FaceRecognitionSystem:
+    def __init__(self, model_name: str = "buffalo_l", model_root: str = "./models"):
+        # Set up logging
+        logging.basicConfig(level=logging.INFO)
+        self.logger = logging.getLogger(__name__)
+        
+        # Create model directory if it doesn't exist
+        self.model_root = Path(model_root)
+        self.model_root.mkdir(parents=True, exist_ok=True)
+        
+        # Set InsightFace model root
+        # insightface.utils.set_download_root(str(self.model_root))
+        # insightface.utils.download(root='./models_x', sub_dir='downloads', name='file')
+        
+        # Initialize the face analysis model
+        try:
+            self.face_analyzer = FaceAnalysis(
+                name=model_name,
+                root=str(self.model_root),
+                download=True  # Allow downloading if model doesn't exist
+            )
+            self.face_analyzer.prepare(ctx_id=-1, det_size=(640, 640))  # Using CPU
+            self.logger.info(f"Face analyzer initialized successfully in {self.model_root}")
+        except Exception as e:
+            self.logger.error(f"Error initializing face analyzer: {e}")
+            raise
+        
+        # Dictionary to store known face embeddings
+        self.known_face_embeddings: Dict[str, np.ndarray] = {}
+        
+    def process_known_faces(self, people_folder_path: str) -> None:
+        """Process and store embeddings of known faces from a folder."""
+        embeddings_file = self.model_root / "known_faces_embeddings.pkl"
+        
+        try:
+            # Load existing embeddings if available
+            if embeddings_file.exists():
+                with open(embeddings_file, 'rb') as f:
+                    self.known_face_embeddings = pickle.load(f)
+                self.logger.info("Loaded existing face embeddings")
+                return
+                
+            self.logger.info("Processing known faces...")
+            people_path = Path(people_folder_path)
+            if not people_path.exists():
+                self.logger.warning(f"Directory not found: {people_folder_path}")
+                return
+                
+            for person_path in people_path.glob("*"):
+                if person_path.is_dir():
+                    person_name = person_path.name
+                    embeddings_list = []
+                    
+                    for img_path in person_path.glob("*"):
+                        if img_path.suffix.lower() in ['.jpg', '.jpeg', '.png']:
+                            img = cv2.imread(str(img_path))
+                            if img is None:
+                                self.logger.warning(f"Could not read image: {img_path}")
+                                continue
+                                
+                            faces = self.face_analyzer.get(img)
+                            if faces:
+                                embeddings_list.append(faces[0].embedding)
+                            else:
+                                self.logger.warning(f"No face detected in {img_path}")
+                    
+                    if embeddings_list:
+                        self.known_face_embeddings[person_name] = np.mean(embeddings_list, axis=0)
+                        self.logger.info(f"Processed {person_name}'s faces")
+                    else:
+                        self.logger.warning(f"No valid faces found for {person_name}")
+            
+            # Save embeddings in model directory
+            with open(embeddings_file, 'wb') as f:
+                pickle.dump(self.known_face_embeddings, f)
+            self.logger.info(f"Face embeddings saved to {embeddings_file}")
+            
+        except Exception as e:
+            self.logger.error(f"Error processing known faces: {e}")
+            raise
+    
+    def identify_face(self, face_embedding: np.ndarray, threshold: float = 0.6) -> Tuple[str, float]:
+        """Identify a face by comparing its embedding with known faces."""
+        try:
+            best_match = "Unknown"
+            best_score = float('inf')
+            
+            for person_name, known_embedding in self.known_face_embeddings.items():
+                similarity = np.dot(face_embedding, known_embedding) / (
+                    np.linalg.norm(face_embedding) * np.linalg.norm(known_embedding)
+                )
+                distance = 1 - similarity
+                
+                if distance < best_score:
+                    best_score = distance
+                    best_match = person_name
+            
+            return (best_match, best_score) if best_score < threshold else ("Unknown", best_score)
+            
+        except Exception as e:
+            self.logger.error(f"Error in face identification: {e}")
+            return ("Error", 1.0)
+    
+    def detect_and_identify(self, image_input) -> np.ndarray:
+        """Detect and identify faces in an input image."""
+        try:
+            # Handle both string paths and numpy arrays
+            if isinstance(image_input, str):
+                img = cv2.imread(image_input)
+            else:
+                img = image_input
+
+            if img is None:
+                raise ValueError("Could not read input image")
+            
+            faces = self.face_analyzer.get(img)
+            
+            for face in faces:
+                bbox = face.bbox.astype(int)
+                embedding = face.embedding
+                name, score = self.identify_face(embedding)
+                
+                cv2.rectangle(img, (bbox[0], bbox[1]), (bbox[2], bbox[3]), (0, 255, 0), 2)
+                label = f"{name} ({1-score:.2f})"
+                
+                cv2.putText(img, label.upper(), (bbox[0], bbox[1]-10),
+                        cv2.FONT_HERSHEY_PLAIN, 2.0, (0, 255, 0), 2)
+            
+            return img
+            
+        except Exception as e:
+            self.logger.error(f"Error in detection and identification: {e}")
+            raise
+
+
+# 1:
+# import cv2
+# import numpy as np
+# import insightface
+# from insightface.app import FaceAnalysis
+# from pathlib import Path
+# from typing import Dict, List, Tuple
+# import pickle
+# import logging
+
+# class FaceRecognitionSystem:
+#     def __init__(self, model_name: str = "buffalo_l"):
+#         # Set up logging
+#         logging.basicConfig(level=logging.INFO)
+#         self.logger = logging.getLogger(__name__)
+        
+#         # Initialize the face analysis model
+#         try:
+#             self.face_analyzer = FaceAnalysis(name=model_name)
+#             self.face_analyzer.prepare(ctx_id=-1, det_size=(640, 640))  # Using CPU
+#             self.logger.info("Face analyzer initialized successfully")
+#         except Exception as e:
+#             self.logger.error(f"Error initializing face analyzer: {e}")
+#             raise
+        
+#         # Dictionary to store known face embeddings
+#         self.known_face_embeddings: Dict[str, np.ndarray] = {}
+        
+#     def process_known_faces(self, people_folder_path: str) -> None:
+#         """Process and store embeddings of known faces from a folder."""
+#         embeddings_file = Path("known_faces_embeddings.pkl")
+        
+#         try:
+#             # Load existing embeddings if available
+#             if embeddings_file.exists():
+#                 with open(embeddings_file, 'rb') as f:
+#                     self.known_face_embeddings = pickle.load(f)
+#                 self.logger.info("Loaded existing face embeddings")
+#                 return
+                
+#             self.logger.info("Processing known faces...")
+#             people_path = Path(people_folder_path)
+#             if not people_path.exists():
+#                 self.logger.warning(f"Directory not found: {people_folder_path}")
+#                 return
+                
+#             for person_path in people_path.glob("*"):
+#                 if person_path.is_dir():
+#                     person_name = person_path.name
+#                     embeddings_list = []
+                    
+#                     for img_path in person_path.glob("*"):
+#                         if img_path.suffix.lower() in ['.jpg', '.jpeg', '.png']:
+#                             img = cv2.imread(str(img_path))
+#                             if img is None:
+#                                 self.logger.warning(f"Could not read image: {img_path}")
+#                                 continue
+                                
+#                             faces = self.face_analyzer.get(img)
+#                             if faces:
+#                                 embeddings_list.append(faces[0].embedding)
+#                             else:
+#                                 self.logger.warning(f"No face detected in {img_path}")
+                    
+#                     if embeddings_list:
+#                         self.known_face_embeddings[person_name] = np.mean(embeddings_list, axis=0)
+#                         self.logger.info(f"Processed {person_name}'s faces")
+#                     else:
+#                         self.logger.warning(f"No valid faces found for {person_name}")
+            
+#             # Save embeddings
+#             with open(embeddings_file, 'wb') as f:
+#                 pickle.dump(self.known_face_embeddings, f)
+#             self.logger.info("Face processing complete")
+            
+#         except Exception as e:
+#             self.logger.error(f"Error processing known faces: {e}")
+#             raise
+    
+#     def identify_face(self, face_embedding: np.ndarray, threshold: float = 0.6) -> Tuple[str, float]:
+#         """Identify a face by comparing its embedding with known faces."""
+#         try:
+#             best_match = "Unknown"
+#             best_score = float('inf')
+            
+#             for person_name, known_embedding in self.known_face_embeddings.items():
+#                 similarity = np.dot(face_embedding, known_embedding) / (
+#                     np.linalg.norm(face_embedding) * np.linalg.norm(known_embedding)
+#                 )
+#                 distance = 1 - similarity
+                
+#                 if distance < best_score:
+#                     best_score = distance
+#                     best_match = person_name
+            
+#             return (best_match, best_score) if best_score < threshold else ("Unknown", best_score)
+            
+#         except Exception as e:
+#             self.logger.error(f"Error in face identification: {e}")
+#             return ("Error", 1.0)
+    
+#     def detect_and_identify(self, image_input) -> np.ndarray:
+#         """Detect and identify faces in an input image."""
+#         try:
+#             # Handle both string paths and numpy arrays
+#             if isinstance(image_input, str):
+#                 img = cv2.imread(image_input)
+#             else:
+#                 img = image_input
+
+#             if img is None:
+#                 raise ValueError("Could not read input image")
+            
+#             faces = self.face_analyzer.get(img)
+            
+#             for face in faces:
+#                 bbox = face.bbox.astype(int)
+#                 embedding = face.embedding
+#                 name, score = self.identify_face(embedding)
+                
+#                 cv2.rectangle(img, (bbox[0], bbox[1]), (bbox[2], bbox[3]), (0, 255, 0), 2)
+#                 label = f"{name} ({1-score:.2f})"
+                
+#                 cv2.putText(img, label.upper(), (bbox[0], bbox[1]-10),
+#                         cv2.FONT_HERSHEY_PLAIN, 2.0, (0, 255, 0), 2)
+            
+#             return img
+            
+#         except Exception as e:
+#             self.logger.error(f"Error in detection and identification: {e}")
+#             raise
+
+
+
+# OLD:
+# import cv2
+# import numpy as np
+# import insightface
+# from insightface.app import FaceAnalysis
+# from insightface.data import get_image as ins_get_image
+# import os
+# from pathlib import Path
+# from typing import Dict, List, Tuple
+# import pickle
+
+# class FaceRecognitionSystem:
+#     def __init__(self, model_name: str = "buffalo_l"):
+#         # Initialize the face analysis model
+#         self.face_analyzer = FaceAnalysis(name=model_name)
+#         self.face_analyzer.prepare(ctx_id=0, det_size=(640, 640))
+        
+#         # Dictionary to store known face embeddings
+#         self.known_face_embeddings: Dict[str, np.ndarray] = {}
+        
+#     def process_known_faces(self, people_folder_path: str) -> None:
+#         """Process and store embeddings of known faces from a folder."""
+#         # Create embeddings file path
+#         # embeddings_file = Path("known_face_embeddings copy2.pkl")
+#         embeddings_file = Path("data/model/known_faces_embeddings.pkl")
+        
+#         # Load existing embeddings if available
+#         if embeddings_file.exists():
+#             with open(embeddings_file, 'rb') as f:
+#                 self.known_face_embeddings = pickle.load(f)
+#             print("Loaded existing face embeddings.")
+#             return
+            
+#         print("Processing known faces...")
+#         for person_path in Path(people_folder_path).glob("*"):
+#             if person_path.is_dir():
+#                 person_name = person_path.name
+#                 embeddings_list = []
+                
+#                 # Process each image in person's folder
+#                 for img_path in person_path.glob("*"):
+#                     if img_path.suffix.lower() in ['.jpg', '.jpeg', '.png']:
+#                         img = cv2.imread(str(img_path))
+#                         if img is None:
+#                             continue
+                            
+#                         # Get face embedding
+#                         faces = self.face_analyzer.get(img)
+#                         if faces:
+#                             embeddings_list.append(faces[0].embedding)
+                
+#                 if embeddings_list:
+#                     # Average all embeddings for this person
+#                     self.known_face_embeddings[person_name] = np.mean(embeddings_list, axis=0)
+#                     print(f"Processed {person_name}'s faces")
+        
+#         # Save embeddings for future use
+#         with open(embeddings_file, 'wb') as f:
+#             pickle.dump(self.known_face_embeddings, f)
+#         print("Face processing complete.")
+    
+#     # OLD:
+#     def identify_face(self, face_embedding: np.ndarray, threshold: float = 0.6) -> Tuple[str, float]:
+#         """Identify a face by comparing its embedding with known faces."""
+#         best_match = "Unknown"
+#         best_score = float('inf')
+        
+#         for person_name, known_embedding in self.known_face_embeddings.items():
+#             # Calculate cosine similarity
+#             similarity = np.dot(face_embedding, known_embedding) / (
+#                 np.linalg.norm(face_embedding) * np.linalg.norm(known_embedding)
+#             )
+#             distance = 1 - similarity
+            
+#             if distance < best_score:
+#                 best_score = distance
+#                 best_match = person_name
+        
+#         return (best_match, best_score) if best_score < threshold else ("Unknown", best_score)
+    
+  
+    
+#     def detect_and_identify(self, image_input, output_path: str = None) -> np.ndarray:
+#         """Detect and identify faces in an input image."""
+#         # Handle both string paths and numpy arrays
+#         if isinstance(image_input, str):
+#             img = cv2.imread(image_input)
+#         else:
+#             img = image_input
+
+#         if img is None:
+#             raise ValueError("Could not read input image")
+        
+#         # Rest of the code remains the same
+#         faces = self.face_analyzer.get(img)
+        
+#         for face in faces:
+#             bbox = face.bbox.astype(int)
+#             embedding = face.embedding
+#             name, score = self.identify_face(embedding)
+            
+#             cv2.rectangle(img, (bbox[0], bbox[1]), (bbox[2], bbox[3]), (0, 255, 0), 2)
+#             label = f"{name} ({1-score:.2f})"
+            
+#             cv2.putText(img, label.upper(), (bbox[0], bbox[1]-10),
+#                     cv2.FONT_HERSHEY_PLAIN, 4.2, (0, 255, 0), 2)
+#                     # cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
+        
+#         if output_path:
+#             cv2.imwrite(output_path, img)
+        
+#         return img
+    
+    
+#     # def detect_and_identify(self, image_path: str, output_path: str = None) -> np.ndarray:
+#         #     """Detect and identify faces in an input image."""
+#         #     # Read input image
+#         #     img = cv2.imread(image_path)
+#         #     if img is None:
+#         #         raise ValueError("Could not read input image")
+            
+#         #     # Detect faces
+#         #     faces = self.face_analyzer.get(img)
+            
+#         #     # Draw results on image
+#         #     for face in faces:
+#         #         bbox = face.bbox.astype(int)
+#         #         embedding = face.embedding
+#         #         name, score = self.identify_face(embedding)
+                
+#         #         # Draw rectangle around face
+#         #         cv2.rectangle(img, (bbox[0], bbox[1]), (bbox[2], bbox[3]), (0, 255, 0), 2)
+                
+#         #         # Add name and confidence score
+#         #         label = f"{name} ({1-score:.2f})"
+#         #         cv2.putText(img, label, (bbox[0], bbox[1]-10),
+#         #                    cv2.FONT_HERSHEY_PLAIN, 1.5, (0, 255, 0), 2)
+            
+#             # # Save output image if path provided
+#             # if output_path:
+#             #     cv2.imwrite(output_path, img)
+            
+#             # return img

known_faces_embeddings.pkl

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

models/known_faces_embeddings.pkl

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

models/models/buffalo_l.zip

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

models/models/buffalo_l/1k3d68.onnx

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

models/models/buffalo_l/2d106det.onnx

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

models/models/buffalo_l/det_10g.onnx

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

models/models/buffalo_l/genderage.onnx

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

models/models/buffalo_l/w600k_r50.onnx

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

notes.ipynb

@@ -0,0 +1,48 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# **Docker NOTES 📝🖌️**\n",
+    "\n",
+    "1. **Create `Dockerfile`**\n",
+    "2. **`docker buildx build -t attendify_fastapi_backend-hf .`**\n",
+    "3. **`docker run -v E:\\MULTIFACE_RECOGNITION_CLASSROOM\\Backend\\ATTENDIFY_BACKEND:/app --name attendify_fastapi_backend_container -p 7860:7860 attendify_fastapi_backend-hf`**"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* **Updating Docker Image without rebuilding again and only including the necessary packages:**\n",
+    "    \n",
+    "    **`Dockerfile.update`**: \n",
+    "\n",
+    "    `FROM attend_b-hf`\n",
+    "    \n",
+    "    `RUN pip install <new_package_1> <new_package_2>`\n",
+    "\n",
+    "    Then run:\n",
+    "\n",
+    "    `docker build -t attend_b-hf-update -f Dockerfile.update .`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# **FastAPI NOTES**\n",
+    "\n",
+    "1. **Learning about: Middlewares & CORS(`Cross Origin Resource Sharing`)**"
+   ]
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

requirements.txt

@@ -0,0 +1,10 @@
+fastapi[all]
+# Installed Torch & Torchvision: Via Dockerfile
+# torch
+# torchvision
+onnxruntime
+insightface
+
+python-multipart
+opencv-python-headless
+pillow