init

app.py

@@ -0,0 +1,213 @@
+import gradio as gr
+from gradio_webrtc import WebRTC
+import os
+import pickle
+import numpy as np
+import cv2
+import tensorflow as tf
+from sklearn.preprocessing import OneHotEncoder
+from tensorflow.keras.callbacks import EarlyStopping
+from tensorflow.keras import Model
+from tensorflow.image import resize
+from tensorflow.keras.preprocessing.image import load_img, img_to_array
+from keras_vggface.vggface import VGGFace
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import RandomFlip, RandomRotation, RandomBrightness, RandomContrast, RandomTranslation, Input, Dense, Flatten
+from sklearn.model_selection import train_test_split
+
+class ResNetModel():
+    def __init__(self):
+        self.data_augmentation = Sequential([
+            RandomBrightness(factor=0.2),
+            RandomContrast(factor=0.2),
+            RandomFlip("horizontal"),
+            RandomTranslation(height_factor=0.1, width_factor=0.1),
+            RandomRotation(factor=0.1)
+        ])
+        
+    def load_data(self, data_path: str, input_size:tuple = (224, 224)):
+        image_list = []
+        class_list = []
+        self.input_size = input_size
+        faceCascade = cv2.CascadeClassifier('Cascades/haarcascade_frontalface_default.xml')
+        for label in os.listdir(data_path):
+            if len(os.listdir(os.path.join(data_path, label))) < 5:
+                continue
+            for j, filename in enumerate(os.listdir(os.path.join(data_path, label))):
+                if j >= 10:
+                    break
+                filename = os.path.join(data_path, label, filename)
+                print(f"Index {j}. {filename}")
+                image = load_img(filename)
+                # image = load_img(filename, color_mode = color_mode)
+                # if color_mode != "grayscale":
+                #     gray = np.array(rgb_to_grayscale(image))
+                # else:
+                #     gray = np.array(image.copy())
+                image = np.array(image)
+                faces = faceCascade.detectMultiScale(
+                    image,     
+                    scaleFactor=1.2,
+                    minNeighbors=5,     
+                    minSize=(20, 20)
+                )
+                for (x,y,w,h) in faces:
+                    if w == 0 or h == 0:
+                        continue
+                    image_roi = image[y:y+h, x:x+w]
+                    image_roi = img_to_array(image_roi)
+                    image_roi = resize(image_roi, input_size)
+                    
+                    image_list.append(image_roi)
+                    class_list.append(label)
+                    
+        os.system("cls")
+        encoder = OneHotEncoder(sparse_output=False)
+        class_list = encoder.fit_transform(np.array(class_list).reshape(-1, 1))
+        
+        image_list = np.asarray(image_list)
+        self.label_names = encoder.categories_[0]
+        
+        X_train, X_temp, y_train, y_temp = train_test_split(image_list, class_list, test_size=0.3)
+        X_val, X_test, y_val, y_test = train_test_split(X_temp, y_temp, test_size=0.5)
+        
+        self.X_train = X_train
+        self.y_train = y_train
+        self.X_val = X_val
+        self.y_val = y_val
+        self.X_test = X_test
+        self.y_test = y_test
+        print(f"Train dataset len: {X_train.shape[0]}")
+        print(f"Val dataset len: {X_val.shape[0]}")
+        print(f"Test dataset len: {X_test.shape[0]}")
+        print(f"Sample image shape: {X_train[0].shape}")
+                    
+    def save(self, save_path):
+        self.X_train = []
+        self.y_train = []
+        self.X_val = []
+        self.y_val = []
+        self.X_test = []
+        self.y_test = []
+        
+        model_save_path = save_path + "_model.h5"
+        self.model.save(model_save_path)
+
+        # Save the rest of the class attributes
+        with open(save_path + "_attributes.pickle", "wb") as file:
+            pickle.dump({
+                "data_augmentation": self.data_augmentation,
+                "label_names": self.label_names,
+                "input_size": self.input_size,
+            }, file)
+            
+    @classmethod
+    def load(cls, save_path):
+        with open(save_path + "_attributes.pickle", "rb") as file:
+            attributes = pickle.load(file)
+
+        instance = cls()
+        instance.data_augmentation = attributes["data_augmentation"]
+        instance.label_names = attributes["label_names"]
+        instance.input_size = attributes["input_size"]
+
+        # Load the Keras model
+        model_save_path = save_path + "_model.h5"
+        instance.model = tf.keras.models.load_model(model_save_path)
+
+        print(f"Model and attributes loaded from {save_path}")
+        return instance
+
+        
+    def fit(self, model_name: str, augmentation=True, save_path=None, batch_size=64, epochs=10):
+        inputs = Input(shape=self.X_train[0].shape)
+        layer = self.data_augmentation(inputs) if augmentation else inputs
+        
+        base_model = VGGFace(model=model_name, include_top=False, input_shape=self.X_train[0].shape, pooling="avg")
+        base_model.trainable = False
+        
+        layer = base_model(layer)
+        
+        layer = Flatten(name="Flatten")(layer)
+        out = Dense(len(self.label_names), activation="softmax")(layer)
+        
+        model = Model(inputs, out)
+        model.compile(optimizer="adam", metrics=["accuracy"], loss="categorical_crossentropy")
+        
+        print(model.summary())
+        
+        self.history = model.fit(
+            self.X_train, self.y_train, 
+            batch_size=batch_size, 
+            epochs=epochs, 
+            validation_data=(self.X_val, self.y_val),
+            callbacks=[EarlyStopping(monitor="val_loss", patience=3)]
+        )
+        
+        self.model = model
+        if save_path is not None:
+            self.save(save_path)
+        
+        loss, accuracy = model.evaluate(self.X_test, self.y_test)
+        print(f"Test accuracy:{(accuracy * 100):2f}")
+        print(f"Test loss:{loss:2f}")
+        return model
+
+            
+    def predict(self, predict_image):
+        predict_image = img_to_array(predict_image)
+        predict_image = resize(predict_image, self.input_size)
+        predict_image = np.expand_dims(predict_image, axis=0)
+        predict_label = self.model.predict(predict_image)
+        return self.label_names[np.argmax(predict_label)], np.max(predict_label)
+
+faceRecognition = ResNetModel.load("resnet_v2")
+def predict(image):
+
+    faceCascade = cv2.CascadeClassifier('Cascades/haarcascade_frontalface_default.xml')
+    frame = cv2.flip(image, 1)
+    faces = faceCascade.detectMultiScale(
+        frame,     
+        scaleFactor=1.2,
+        minNeighbors=5,     
+        minSize=(20, 20)
+    )
+    for (x,y,w,h) in faces:
+        cv2.rectangle(frame,(x,y),(x+w,y+h),(0,0,255),2)
+        roi_color = frame[y:y+h, x:x+w]
+        roi_color = cv2.flip(roi_color, 1)
+        label, conf = faceRecognition.predict(roi_color)
+        label = label[:12] + "..." if len(label) > 10 else label
+        text = "{label} : {conf:.3f}".format(label = label, conf = conf)
+        
+        cv2.putText(frame, text, (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0,0,255), 2)
+    return frame
+
+css = """.my-group {max-width: 600px !important; max-height: 600px !important;}
+         .my-column {display: flex !important; justify-content: center !important; align-items: center !important;}"""
+rtc_configuration = {
+    "frameRate": {"ideal": 10}
+}
+with gr.Blocks(css=css) as demo:
+    gr.HTML(
+        """
+        <h1 style='text-align: center'>
+            Face Recognition Using FaceNet LB01 - Kelompok 8
+        </h1>
+        <ul style='text-align: center'>
+            <h4> <li>2602082452 - Rendy Susanto </li> </h4>
+            <h4> <li>2602090031 - Rafael Juviano Joesoef </li> </h4> 
+            <h4> <li>2602091122 - Owen Tamashi Buntoro </li> </h4>
+        </ul>
+        """
+    )
+    with gr.Column(elem_classes=["my-column"]):
+        with gr.Group(elem_classes=["my-group"]):
+            image = WebRTC(label="Stream", rtc_configuration=rtc_configuration)
+
+        image.stream(
+            fn=predict, inputs=[image], outputs=[image]
+        )
+
+if __name__ == "__main__":
+    demo.launch(share=True)

requirements.txt

@@ -0,0 +1,5 @@
+tensorflow==2.13.0
+keras==2.12
+keras-vggface==0.6
+keras-applications==1.0.8
+scikit-learn==1.6.0

resnet_v2_attributes.pickle

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

resnet_v2_model.h5

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