init commit

README.md

@@ -1,13 +1,11 @@
 ---
 title: Face Detection
-emoji: 🌍
+emoji: App 👤
 colorFrom: purple
-colorTo: red
+colorTo: blue
 sdk: gradio
 sdk_version: 3.15.0
 app_file: app.py
 pinned: false
 license: mit
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,60 @@
+from model_utils import detect_face
+import gradio as gr
+import numpy as np
+
+# Function to run the app
+
+
+def run_model(image: np.ndarray):
+    return gr.Image.update(value=detect_face(image))
+
+
+def interface() -> None:
+    """
+    Create and launch the graphical user interface face detection app.
+    """
+
+    # Create the blocks for the interface
+    with gr.Blocks() as app:
+        # Add a title and opening HTML element
+        gr.HTML(
+            """
+            <div style="text-align: center; max-width: 650px; margin: 0 auto; padding-top: 7px;">
+              <div
+                style="
+                  display: inline-flex;
+                  align-items: center;
+                  gap: 0.8rem;
+                  font-size: 1.85rem;
+                "
+              >
+                <h1 style="font-weight: 900; margin-bottom: 7px;">
+                  Face Detection App 👤
+                </h1>
+              </div>
+            </div>
+        """
+        )
+        with gr.Group():
+            with gr.Row():
+                with gr.Column():
+                    with gr.Row():
+                        webcam_image_in = gr.Webcam(label="Webcam input")
+                    with gr.Row():
+                        gr.Text(
+                            label="⚠️ Reminder ", value="Do not forget to click the camera button to freeze and get the webcam image 📷!", interactive=False)
+                with gr.Column():
+                    with gr.Row():
+                        face_detected_image_out = gr.Image(
+							label="Face detected", interactive=False)
+                    with gr.Row():
+                        detect_button = gr.Button(value="Detect face 👤")
+
+                    detect_button.click(fn=run_model, inputs=[
+						webcam_image_in], outputs=face_detected_image_out)
+
+        app.launch()
+
+
+if __name__ == '__main__':
+    interface()  # Run the interface

faceNet/faceDetection.py

@@ -0,0 +1,82 @@
+import cv2
+import typing
+import numpy as np
+import mediapipe as mp
+
+class MPFaceDetection:
+    """Object to create and do mediapipe face detection, more about it:
+    https://google.github.io/mediapipe/solutions/face_detection.html
+    """
+    def __init__(
+        self,
+        model_selection: bool = 1,
+        confidence: float = 0.5,
+        mp_drawing_utils: bool = True,
+        color: typing.Tuple[int, int, int] = (255, 255, 255),
+        thickness: int = 2,
+        ) -> None:
+        """
+        Args:
+            model_selection: (bool) - 1 - for low distance, 0 - for far distance face detectors.
+            confidence: (float) - confidence for face detector, when detection are confirmed, range (0.0-1.0).
+            mp_drawing_utils: (bool) - bool option whether to use mp_drawing utils or or own, Default to True.
+            color: (typing.Tuple[int, int, int]) - Color for drawing the annotation. Default to the white color.
+            thickness: (int) - Thickness for drawing the annotation. Default to 2 pixels.
+        """
+        self.mp_drawing_utils = mp_drawing_utils
+        self.color = color
+        self.thickness = thickness
+        self.mp_drawing = mp.solutions.drawing_utils
+        self.mp_face_detection = mp.solutions.face_detection
+        self.face_detection = self.mp_face_detection.FaceDetection(model_selection=model_selection, min_detection_confidence=confidence)
+
+    def tlbr(self, frame: np.ndarray, mp_detections: typing.List) -> np.ndarray:
+        """Return coorinates in typing.Iterable([[Top, Left, Bottom, Right]])
+        Args:
+            frame: (np.ndarray) - frame on which we want to apply detections
+            mp_detections: (typing.List) - list of media pipe detections
+        Returns:
+            detections: (np.ndarray) - list of detection in [Top, Left, Bottom, Right] coordinates
+        """
+        detections = []
+        frame_height, frame_width, _ = frame.shape
+        for detection in mp_detections:
+            height = int(detection.location_data.relative_bounding_box.height * frame_height)
+            width = int(detection.location_data.relative_bounding_box.width * frame_width)
+            left = max(0 ,int(detection.location_data.relative_bounding_box.xmin * frame_width))
+            top = max(0 ,int(detection.location_data.relative_bounding_box.ymin * frame_height))
+
+            detections.append([top, left, top + height, left + width])
+
+        return np.array(detections)
+
+    def __call__(self, frame: np.ndarray, return_tlbr: bool = False) -> np.ndarray:
+        """Main function to do face detection
+        Args:
+            frame: (np.ndarray) - frame to excecute face detection on
+            return_tlbr: (bool) - bool option to return coordinates instead of frame with drawn detections
+        Returns:
+            typing.Union[
+                frame: (np.ndarray) - processed frame with detected faces,
+                detections: (typing.List) - detections in [Top, Left, Bottom, Right]
+                ]
+        """
+        results = self.face_detection.process(frame)
+
+        if return_tlbr:
+            if results.detections:
+                return self.tlbr(frame, results.detections)
+            return []
+
+        if results.detections:
+            if self.mp_drawing_utils:
+                # Draw face detections of each face using media pipe drawing utils.
+                for detection in results.detections:
+                    self.mp_drawing.draw_detection(frame, detection)
+            
+            else:
+                # Draw face detections of each face using our own tlbr and cv2.rectangle
+                for tlbr in self.tlbr(frame, results.detections):
+                    cv2.rectangle(frame, tlbr[:2][::-1], tlbr[2:][::-1], self.color, self.thickness)
+
+        return frame

faceNet/faceNet.py

@@ -0,0 +1,189 @@
+import cv2
+import stow
+import typing
+import numpy as np
+import onnxruntime as ort
+
+class FaceNet:
+    """FaceNet class object, which can be used for simplified face recognition
+    """
+    def __init__(
+        self, 
+        detector: object,
+        onnx_model_path: str = "models/faceNet.onnx", 
+        anchors: typing.Union[str, dict] = 'faces',
+        force_cpu: bool = False,
+        threshold: float = 0.5,
+        color: tuple = (255, 255, 255),
+        thickness: int = 2,
+        ) -> None:
+        """Object for face recognition
+        Params:
+            detector: (object) - detector object to detect faces in image
+            onnx_model_path: (str) - path to onnx model
+            force_cpu: (bool) - if True, onnx model will be run on CPU
+            anchors: (str or dict) - path to directory with faces or dictionary with anchor names as keys and anchor encodings as values
+            threshold: (float) - threshold for face recognition
+            color: (tuple) - color of bounding box and text
+            thickness: (int) - thickness of bounding box and text
+        """
+        if not stow.exists(onnx_model_path):
+            raise Exception(f"Model doesn't exists in {onnx_model_path}")
+
+        self.detector = detector
+        self.threshold = threshold
+        self.color = color
+        self.thickness = thickness
+
+        providers = ['CUDAExecutionProvider', 'CPUExecutionProvider']
+
+        providers = providers if ort.get_device() == "GPU" and not force_cpu else providers[::-1]
+
+        self.ort_sess = ort.InferenceSession(onnx_model_path, providers=providers)
+
+        self.input_shape = self.ort_sess._inputs_meta[0].shape[1:3]
+        
+        self.anchors = self.load_anchors(anchors) if isinstance(anchors, str) else anchors
+
+    def normalize(self, img: np.ndarray) -> np.ndarray:
+        """Normalize image
+
+        Args:
+            img: (np.ndarray) - image to be normalized
+
+        Returns:
+            img: (np.ndarray) - normalized image
+        """
+        mean, std = img.mean(), img.std()
+        return (img - mean) / std
+
+    def l2_normalize(self, x: np.ndarray, axis: int = -1, epsilon: float = 1e-10) -> np.ndarray:
+        """l2 normalization function
+
+        Args:
+            x: (np.ndarray) - input array
+            axis: (int) - axis to normalize
+            epsilon: (float) - epsilon to avoid division by zero
+
+        Returns:
+            x: (np.ndarray) - normalized array
+        """
+        output = x / np.sqrt(np.maximum(np.sum(np.square(x), axis=axis, keepdims=True), epsilon))
+        return output
+
+    def detect_save_faces(self, image: np.ndarray, output_dir: str = "faces"):
+        """Detect faces in given image and save them to output_dir
+
+        Args:
+            image: (np.ndarray) - image to be processed
+            output_dir: (str) - directory where faces will be saved
+
+        Returns:
+            bool: (bool) - True if faces were detected and saved
+        """
+        face_crops = [image[t:b, l:r] for t, l, b, r in self.detector(image, return_tlbr=True)]
+
+        if face_crops == []: 
+            return False
+
+        #stow.mkdir(output_dir)
+
+        for index, crop in enumerate(face_crops):
+            #output_path = stow.join(output_dir, f"face_{str(index)}.png")
+            #cv2.imwrite(output_path, crop)
+            #print("Crop saved to:", output_path)
+
+        #self.anchors = self.load_anchors(output_dir)
+        
+            return crop
+
+    def load_anchors(self, faces_path: str):
+        """Generate anchors for given faces path
+
+        Args:
+            faces_path: (str) - path to directory with faces
+
+        Returns:
+            anchors: (dict) - dictionary with anchor names as keys and anchor encodings as values
+        """
+        anchors = {}
+        if not stow.exists(faces_path):
+            return {}
+
+        for face_path in stow.ls(faces_path):
+            anchors[stow.basename(face_path)] = self.encode(cv2.imread(face_path.path))
+
+        return anchors
+
+    def encode(self, face_image: np.ndarray) -> np.ndarray:
+        """Encode face image with FaceNet model
+
+        Args 
+            face_image: (np.ndarray) - face image to be encoded
+            
+        Returns:
+            face_encoding: (np.ndarray) - face encoding
+        """
+        face = self.normalize(face_image)
+        face = cv2.resize(face, self.input_shape).astype(np.float32)
+
+        encode = self.ort_sess.run(None, {self.ort_sess._inputs_meta[0].name: np.expand_dims(face, axis=0)})[0][0]
+        normalized_encode = self.l2_normalize(encode)
+
+        return normalized_encode
+
+    def cosine_distance(self, a: np.ndarray, b: typing.Union[np.ndarray, list]) -> np.ndarray:
+        """Cosine distance between wectors a and b
+
+        Args:
+            a: (np.ndarray) - first vector
+            b: (np.ndarray) - second list of vectors
+
+        Returns:
+            distance: (float) - cosine distance
+        """
+        if isinstance(a, list):
+            a = np.array(a)
+
+        if isinstance(b, list):
+            b = np.array(b)
+
+        return np.dot(a, b.T) / (np.linalg.norm(a) * np.linalg.norm(b))
+
+    def draw(self, image: np.ndarray, face_crops: dict):
+        """Draw face crops on image
+
+        Args:
+            image: (np.ndarray) - image to be drawn on
+            face_crops: (dict) - dictionary with face crops as values and face names as keys
+
+        Returns:
+            image: (np.ndarray) - image with drawn face crops
+        """
+        for value in face_crops.values():
+            t, l, b, r = value["tlbr"]
+            cv2.rectangle(image, (l, t), (r, b), self.color, self.thickness)
+            cv2.putText(image, stow.name(value['name']), (l, t - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, self.color, self.thickness)
+
+        return image
+
+    def __call__(self, frame: np.ndarray) -> np.ndarray:
+        """Face recognition pipeline
+
+        Args:
+            frame: (np.ndarray) - image to be processed
+
+        Returns:
+            frame: (np.ndarray) - image with drawn face recognition results
+        """
+        face_crops = {index: {"name": "Unknown", "tlbr": tlbr} for index, tlbr in enumerate(self.detector(frame, return_tlbr=True))}
+        for key, value in face_crops.items():
+            t, l, b, r = value["tlbr"]
+            face_encoding = self.encode(frame[t:b, l:r])
+            distances = self.cosine_distance(face_encoding, list(self.anchors.values()))
+            if np.max(distances) > self.threshold:
+                face_crops[key]["name"] = list(self.anchors.keys())[np.argmax(distances)]
+
+        frame = self.draw(frame, face_crops)
+
+        return frame

model_utils.py

@@ -0,0 +1,11 @@
+from faceNet.faceDetection import MPFaceDetection
+from faceNet.faceNet import FaceNet
+import numpy as np
+
+def detect_face(image: np.array) -> np.array:
+    facenet = FaceNet(
+        detector = MPFaceDetection(),
+        onnx_model_path = "models/faceNet.onnx", 
+        force_cpu = True,
+    )
+    return facenet.detect_save_faces(image)

models/faceNet.onnx

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

requirements.txt

@@ -0,0 +1,6 @@
+gradio==3.1.4
+numpy==1.23.1
+mediapipe==0.9.0
+onnxruntime==1.13.1
+opencv-python==4.6.0.66
+stow==1.1.6