Upload 20 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
+sh.png filter=lfs diff=lfs merge=lfs -text

data_preprocessing.py

@@ -0,0 +1,68 @@
+import os
+import pickle
+import numpy as np
+import imgaug.augmenters as iaa
+from PIL import Image
+import face_recognition
+
+def augment_image(image, num_augmented=5):
+    """
+    Apply data augmentation to an image.
+    
+    Parameters:
+    image (PIL.Image): The image to augment.
+    num_augmented (int): Number of augmented images to generate.
+    
+    Returns:
+    List[PIL.Image]: List of augmented images.
+    """
+    image = np.array(image)
+
+    # Define a sequence of augmentation techniques
+    aug = iaa.Sequential([
+        iaa.Fliplr(0.5),  # horizontal flips
+        iaa.Affine(rotate=(-25, 25)),  # rotation
+        iaa.AdditiveGaussianNoise(scale=(0, 0.05*255)),  # noise
+        iaa.Multiply((0.8, 1.2)),  # brightness
+        iaa.GaussianBlur(sigma=(0.0, 1.0))  # blur
+    ])
+
+    # Generate augmented images
+    augmented_images = [Image.fromarray(aug(image=image)) for _ in range(num_augmented)]
+    return augmented_images
+
+def preprocess_and_save_augmented_encodings(image_dir, output_file, num_augmented=5):
+    known_encodings = []
+    known_labels = []
+
+    # List all files in the image directory
+    image_paths = [os.path.join(image_dir, f) for f in os.listdir(image_dir) if f.endswith(('.png', '.jpg', '.jpeg'))]
+
+    for image_path in image_paths:
+        # Load the original image
+        original_image = Image.open(image_path).convert("RGB")  # Ensure the image is in RGB format
+
+        # Augment the image
+        augmented_images = augment_image(original_image, num_augmented=num_augmented)
+
+        # Include the original image in the list of images to encode
+        images_to_encode = [original_image] + augmented_images
+
+        for img in images_to_encode:
+            img_array = np.array(img)
+            # Encode the face
+            encoding = face_recognition.face_encodings(img_array)[0]
+            
+            # Store the encoding and the corresponding label
+            known_encodings.append(encoding)
+            known_labels.append(image_path)  # You can use a more descriptive label here
+
+    # Save encodings and labels to a file
+    data = {"encodings": known_encodings, "labels": known_labels}
+    with open(output_file, "wb") as file:
+        pickle.dump(data, file)
+
+# Example usage:
+image_dir = "train"  # Directory containing all the training images
+output_file = "face_encoding.pkl"
+preprocess_and_save_augmented_encodings(image_dir, output_file, num_augmented=5)

face_encoding.pkl

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

main.py

@@ -0,0 +1,119 @@
+import face_recognition
+import numpy as np
+import pickle
+from mtcnn import MTCNN
+from PIL import Image
+import cv2
+import faiss
+import imgaug.augmenters as iaa
+import os
+import gradio as gr
+
+def detect_and_align_face(image_path):
+    detector = MTCNN()
+    image = cv2.imread(image_path)
+    image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+    detections = detector.detect_faces(image_rgb)
+    
+    if len(detections) == 0:
+        raise ValueError("No face detected in the image.")
+    
+    detection = detections[0]
+    x, y, width, height = detection['box']
+    keypoints = detection['keypoints']
+    face = image_rgb[y:y+height, x:x+width]
+    
+    left_eye = keypoints['left_eye']
+    right_eye = keypoints['right_eye']
+    delta_x = right_eye[0] - left_eye[0]
+    delta_y = right_eye[1] - left_eye[1]
+    angle = np.arctan2(delta_y, delta_x) * (180.0 / np.pi)
+    
+    center = ((x + x + width) // 2, (y + y + height) // 2)
+    rot_matrix = cv2.getRotationMatrix2D(center, angle, scale=1.0)
+    aligned_image = cv2.warpAffine(image_rgb, rot_matrix, (image_rgb.shape[1], image_rgb.shape[0]))
+    aligned_face = aligned_image[y:y+height, x:x+width]
+    
+    return Image.fromarray(aligned_face)
+
+def load_encodings(file_path):
+    with open(file_path, "rb") as file:
+        data = pickle.load(file)
+    return np.array(data["encodings"]), data["labels"]
+
+def save_encodings(encodings, labels, file_path):
+    data = {"encodings": encodings, "labels": labels}
+    with open(file_path, "wb") as file:
+        pickle.dump(data, file)
+
+def create_faiss_index(known_encodings):
+    dimension = known_encodings.shape[1]
+    index = faiss.IndexFlatL2(dimension)
+    index.add(known_encodings)
+    return index
+
+def encode_face(image):
+    img_array = np.array(image)
+    encodings = face_recognition.face_encodings(img_array)
+    return encodings[0] if encodings else None
+
+def augment_image(image, num_augmented=5):
+    image = np.array(image)
+    aug = iaa.Sequential([
+        iaa.Fliplr(0.5),  # horizontal flips
+        iaa.Affine(rotate=(-25, 25)),  # rotation
+        iaa.AdditiveGaussianNoise(scale=(0, 0.05*255)),  # noise
+        iaa.Multiply((0.8, 1.2)),  # brightness
+        iaa.GaussianBlur(sigma=(0.0, 1.0))  # blur
+    ])
+    augmented_images = [Image.fromarray(aug(image=image)) for _ in range(num_augmented)]
+    return augmented_images
+
+def update_dataset_with_verified_image(image, encodings_file, label, num_augmented=5):
+    known_encodings, known_labels = load_encodings(encodings_file)
+    augmented_images = augment_image(image, num_augmented=num_augmented)
+    images_to_encode = [image] + augmented_images
+    for img in images_to_encode:
+        img_array = np.array(img)
+        encoding = face_recognition.face_encodings(img_array)[0]
+        known_encodings = np.append(known_encodings, [encoding], axis=0)
+        known_labels.append(label)
+    save_encodings(known_encodings, known_labels, encodings_file)
+
+def verify_face_with_faiss(image, encodings_file, similarity_threshold=70, num_augmented=5):
+    aligned_face = image.convert("RGB")
+    target_encoding = face_recognition.face_encodings(np.array(aligned_face))[0].reshape(1, -1)
+    
+    known_encodings, known_labels = load_encodings(encodings_file)
+    known_encodings = np.array(known_encodings)
+    
+    index = create_faiss_index(known_encodings)
+    
+    distances, indices = index.search(target_encoding, 1)
+    
+    best_match_index = indices[0][0]
+    best_similarity_percentage = (1 - distances[0][0]) * 100
+    
+    is_match = best_similarity_percentage >= similarity_threshold
+    
+    if is_match:
+        matched_label = known_labels[best_match_index]
+        update_dataset_with_verified_image(image, encodings_file, matched_label, num_augmented=num_augmented)
+        return True, f"Match found: {matched_label}, Similarity: {best_similarity_percentage:.2f}%"
+    else:
+        return False, "No match found."
+
+# Define the Gradio interface
+def gradio_interface(image, similarity_threshold=70):
+    encodings_file = "face_encoding.pkl"
+    result, message = verify_face_with_faiss(image, encodings_file, similarity_threshold=similarity_threshold)
+    return message
+
+# Launch the Gradio interface
+iface = gr.Interface(fn=gradio_interface, 
+                     inputs=[gr.Image(type="pil"), gr.Slider(0, 100, value=70, label="Similarity Threshold")], 
+                     outputs="text", 
+                     title="Face Recognition with MTCNN and FAISS",
+                     description="Upload an image to see if it matches any face in the database.")
+
+iface.launch()

requirements.txt

@@ -0,0 +1,7 @@
+face_recognition
+opencv-python
+pillow 
+imgaug
+faiss-cpu
+mtcnn
+gradio