added app file

gradio_app.py

@@ -0,0 +1,222 @@
+from email.headerregistry import Group
+import numpy as np
+from psutil import getloadavg
+import tensorflow as tf
+import logging
+from rich.logging import RichHandler
+from PIL import Image
+import numpy as np
+from config import get_config
+from deepface import DeepFace
+import matplotlib.pyplot as plt
+from imutils import url_to_image
+import cv2
+import gradio as gr
+
+# # --------------------------------------------------------------------------
+# #                              global variables
+# # --------------------------------------------------------------------------
+
+REFERENCE = None
+QUERY = None
+interpreter = tf.lite.Interpreter(model_path="IR/model_float16_quant.tflite")
+interpreter.allocate_tensors()
+input_details = interpreter.get_input_details()
+output_details = interpreter.get_output_details()
+ref = None
+query = None
+face_query_ = None
+face_ref_ = None
+
+# demo = gr.Interface(
+#     fn=image_classifier,
+#     inputs=[
+#         gr.Image(shape=(224, 224),
+#                  image_mode='RGB',
+#                  source='webcam',
+#                  type="numpy",
+#                  label="Reference Image",
+#                  streaming=True,
+#                  mirror_webcam=True),
+
+#         gr.Image(shape=(224, 224),
+#                  image_mode='RGB',
+#                  source='webcam',
+#                  type="numpy",
+#                  label="Query Image",
+#                  streaming=True,
+#                  mirror_webcam=True)
+#         ],
+#     outputs=[
+#         gr.Number(label="Cosine Similarity",
+#                   precision=5),
+#         gr.Plot(label="Reference Embedding Histogram",
+#                 ),
+#         gr.Plot(label="Query Embedding Histogram",
+#                 )
+#         ],
+#     live=False,
+#     title="Face Recognition",
+#     # description='''
+#     # | feature | description |
+#     # | :-----:| :------------: |
+#     # | model | mobile-facenet |
+#     # | precision | fp16 |
+#     # |type | tflite|
+#     # ''',
+#     # article="""
+
+#     # - detects face in input image
+#     # - resizes face to 112x112
+#     # - aligns the face using **deepface MTCNN**
+#     # - runs inference on the aligned face
+
+#     # """,
+#     allow_flagging="auto",
+#     analytics_enabled=True,
+# )
+
+
+# demo.launch(inbrowser=True, auth=("talha", "123"))
+
+def plot_images():
+    global face_query_, face_ref_
+    return face_ref_, face_query_
+
+
+def predict(interpreter, input_details, input_data, output_details):
+    interpreter.set_tensor(input_details[0]['index'], input_data)
+
+    interpreter.invoke()
+
+    output_data = interpreter.get_tensor(output_details[0]['index'])
+
+    return output_data
+
+
+def get_ref_vector(image):
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+    cv2.imwrite("ref.jpg", image)
+    global face_ref_
+    face_ref_ = DeepFace.detectFace("ref.jpg", detector_backend="opencv",
+                                    align=True, target_size=(112, 112))
+
+    face_ref = face_ref_.copy()
+    # face_ is [0, 1] fp32 , needs to be changed to [0, 255] uint8
+    face_ref = cv2.normalize(face_ref, None, 0, 255,
+                             cv2.NORM_MINMAX, cv2.CV_32FC3)
+    print(
+        f"dtype {face_ref.dtype} || max {np.max(face_ref)} || min {np.min(face_ref)}")
+
+    # calculate embeddings
+    face_ref = face_ref[np.newaxis, ...]  # [1, 112, 112, 3]
+    output_data_ref = predict(interpreter, input_details,
+                              face_ref, output_details)
+
+    global ref
+    ref = output_data_ref
+
+    return str(f"shape  --->  {face_ref_.shape}  dtype ---> {face_ref_.dtype}  max  {face_ref_.max()}   min  {face_ref_.min()}"), ref
+
+
+def get_query_vector(image1):
+    image1 = cv2.cvtColor(image1, cv2.COLOR_BGR2RGB)
+    cv2.imwrite("query.jpg", image1)
+    global face_query_
+
+    face_query_ = DeepFace.detectFace("query.jpg", detector_backend="opencv",
+                                      align=True, target_size=(112, 112))
+
+    face_query = face_query_.copy()
+    # face_ is [0, 1] fp32 , needs to be changed to [0, 255] uint8
+    face_query = cv2.normalize(
+        face_query, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_32FC3)
+    print(
+        f"dtype {face_query.dtype} || max {np.max(face_query)} || min {np.min(face_query)}")
+
+    # calculate embeddings
+    face_query = face_query[np.newaxis, ...]  # [1, 112, 112, 3]
+    output_data_query = predict(interpreter, input_details,
+                                face_query, output_details)
+    global query
+    query = output_data_query
+    return str(f"shape  --->  {face_query_.shape}  dtype ---> {face_query_.dtype}  max  {face_query_.max()}   min  {face_query_.min()}"), query
+
+
+def get_metrics():
+    global ref, query
+    return float(np.dot(np.squeeze(ref), np.squeeze(query))), float(np.linalg.norm(np.squeeze(ref) - np.squeeze(query)))
+
+
+with gr.Blocks(analytics_enabled=True, title="Face Recognition") as demo:
+
+    # draw a box around children
+    with gr.Box():
+        gr.Markdown(
+            "# First provide the *reference* image and then the *query* image. The **cosine similarity** will be displayed as output.")
+        # put both cameras under separate groups
+        with gr.Group():
+            # components under this scope will have no padding or margin between them
+            with gr.Row():
+                # reference image
+                with gr.Column():
+                    inp_ref = gr.Image(shape=(224, 224),
+                                       image_mode='RGB',
+                                       source='webcam',
+                                       type="numpy",
+                                       label="Reference Image",
+                                       streaming=True,
+                                       mirror_webcam=True),
+
+                    out_ref = [gr.Textbox(label="Face capture details"),
+                               gr.Dataframe(label="Embedding",
+                                            type="pandas", max_cols=512,
+                                            headers=None),
+                               ]
+                    # make button on left column
+                    btn_ref = gr.Button("reference_image")
+                    btn_ref.click(fn=get_ref_vector,
+                                  inputs=inp_ref, outputs=out_ref)
+                with gr.Column():
+                    inp_query = gr.Image(shape=(224, 224),
+                                         image_mode='RGB',
+                                         source='webcam',
+                                         type="numpy",
+                                         label="Query Image",
+                                         streaming=True,
+                                         mirror_webcam=True),
+
+                    out_query = [gr.Textbox(label="Face capture details"),
+                                 gr.Dataframe(label="Embedding",
+                                              type="pandas", max_cols=512,
+                                              headers=None),
+                                 ]
+                    # make button on right column
+                    btn_query = gr.Button("query_image")
+                    btn_query.click(fn=get_query_vector,
+                                    inputs=inp_query, outputs=out_query)
+    with gr.Box():
+        gr.Markdown("# Metrics")
+        with gr.Group():
+            gr.Markdown(
+                "The **cosine similarity** and **l2 norm of diff.** will be displayed as output here")
+            with gr.Row():
+                out_sim = gr.Number(label="Cosine Similarity", precision=5)
+                out_d = gr.Number(label="L2 norm distance", precision=5)
+            # make button in center, outside row
+            btn_sim = gr.Button("Calculate Metrics")
+            btn_sim.click(fn=get_metrics, inputs=[], outputs=[out_sim, out_d])
+    with gr.Box():
+        with gr.Group():
+            gr.Markdown("# detected face results are shown below")
+            with gr.Row():
+                out_faces = [
+                    gr.Image(shape=(60, 60), label="Detected Face Reference"),
+                    gr.Image(shape=(112, 112), label="Detected Face Query")
+                ]
+                # make button inside row
+            # make button outside (below) row
+            button_show = gr.Button("Show detected faces")
+            button_show.click(fn=plot_images, inputs=[], outputs=out_faces)
+
+demo.launch(share=True)

requirements.txt

@@ -0,0 +1,12 @@
+config==0.5.1
+deepface==0.0.75
+gradio==3.1.1
+imutils==0.5.4
+matplotlib==3.5.2
+numpy==1.22.4
+opencv_contrib_python==4.6.0.66
+opencv-python==4.6.0.66
+Pillow==9.2.0
+psutil==5.9.1
+rich==12.5.1
+tensorflow==2.8.0