Add deepface app

README.md

@@ -0,0 +1,6 @@
+---
+emoji: 🤗
+sdk: gradio
+sdk_version: 4.13.0
+title: Deepface
+---

app.py

@@ -0,0 +1,208 @@
+from gradio import AnnotatedImage, Blocks, Button, Column, Dropdown, Examples, Gallery, HTML, Image, Row, SelectData, Tab, Textbox
+
+import db
+import deeperface
+import os.path
+
+################################################################################
+
+
+def delete(id):
+    db.delete_by_id(id)
+
+
+def emotions():
+    return deeperface.Emotion.labels
+
+
+def process(path):
+    img = deeperface.Image.read(path)
+
+    ############################################################################
+
+    if img.nsfw():
+        img.pixelate().write(path)
+
+    ############################################################################
+
+    if db.exists(path):
+        id, metadata = db.get(path)
+    else:
+        metadata = deeperface.Metadata(img)
+
+        id = db.update(path, metadata)
+
+    ############################################################################
+
+    annotations = []
+    for face in metadata:
+        annotations.extend(img.annotate(face, metadata[face]['emotion']))
+
+    ############################################################################
+
+    verified_paths = []
+    for test_id, test_path, test_metadata in db.tuples():
+        if test_path != path:
+            if deeperface.verify(metadata.representations(),
+                                 test_metadata.representations()):
+                verified_paths.append((test_path, os.path.basename(test_id)))
+
+    ############################################################################
+
+    return id, (path, annotations), verified_paths
+
+
+def search(filter='All'):
+    filtered_paths = []
+    for id, path, metadata in db.tuples():
+        if filter == 'All' or filter in metadata.emotions():
+            filtered_paths.append((path, os.path.basename(id)))
+
+    return filtered_paths
+
+
+################################################################################
+
+with Blocks(title='Face recognition and facial attribute analysis') as blocks:
+    HTML(
+        '<h1><p align="center">Face recognition and facial attribute analysis</p></h1>'
+    )
+    with Row():
+        with Column(scale=3):
+            with Row():
+                with Column():
+                    textbox = Textbox(visible=False)
+                    annotated_image = AnnotatedImage(color_map={
+                        'face': '#f97316',
+                        'emotion': '#f3f4f6'
+                    },
+                                                     show_legend=False,
+                                                     visible=False)
+                    button = Button('Delete', visible=False)
+                with Column():
+                    gallery_1 = Gallery(columns=3,
+                                        container=False,
+                                        show_download_button=False,
+                                        show_share_button=False,
+                                        visible=False)
+                    html = HTML(visible=False)
+        with Column(scale=2):
+            with Tab(label='Upload / Camera'):
+                image = Image(container=False,
+                              sources=['upload', 'webcam'],
+                              type='filepath')
+                Examples('examples', image)
+            with Tab(label='Gallery') as tab:
+                dropdown = Dropdown(['All'] + emotions(),
+                                    container=False,
+                                    filterable=False,
+                                    value=0)
+                gallery_2 = Gallery(allow_preview=False,
+                                    columns=3,
+                                    container=False,
+                                    show_share_button=False)
+
+    ############################################################################
+
+    def on_button_click(textbox, dropdown):
+        if not textbox or not dropdown:
+            return AnnotatedImage(), Button(), Gallery(), HTML(), Gallery()
+
+        delete(textbox)
+        gallery_2 = search(dropdown)
+
+        return AnnotatedImage(visible=False), Button(visible=False), Gallery(
+            visible=False), HTML(visible=False), Gallery(gallery_2,
+                                                         selected_index=None)
+
+    button.click(on_button_click, [textbox, dropdown],
+                 [annotated_image, button, gallery_1, html, gallery_2],
+                 show_progress='hidden')
+
+    ############################################################################
+
+
+    def on_image_change_or_select(image, dropdown):
+        if not image or not dropdown:
+            return Textbox(), AnnotatedImage(), Button(), Gallery(), HTML(
+            ), Gallery()
+
+        textbox, annotated_image, gallery_1 = process(image)
+        gallery_2 = search(dropdown)
+
+        if len(gallery_1) > 1:
+            return textbox, AnnotatedImage(
+                annotated_image, label=textbox, visible=True
+            ), Button(visible=True), Gallery(gallery_1, visible=True), HTML(
+                f'<i><p align="center">{len(gallery_1)} Similar Images in Gallery</p></i>',
+                visible=True), Gallery(gallery_2, selected_index=None)
+        elif len(gallery_1) > 0:
+            return textbox, AnnotatedImage(
+                annotated_image, label=textbox, visible=True
+            ), Button(visible=True), Gallery(gallery_1, visible=True), HTML(
+                '<i><p align="center">1 Similar Image in Gallery</p></i>',
+                visible=True), Gallery(gallery_2, selected_index=None)
+        else:
+            return textbox, AnnotatedImage(
+                annotated_image, label=textbox,
+                visible=True), Button(visible=True), Gallery(
+                    visible=False), HTML(visible=False), Gallery(
+                        gallery_2, selected_index=None)
+
+    image.change(
+        on_image_change_or_select, [image, dropdown],
+        [textbox, annotated_image, button, gallery_1, html, gallery_2],
+        show_progress='hidden')
+
+    image.select(
+        on_image_change_or_select, [image, dropdown],
+        [textbox, annotated_image, button, gallery_1, html, gallery_2],
+        show_progress='hidden')
+
+    ############################################################################
+
+
+    def on_tab_select(dropdown):
+        if not dropdown:
+            return Gallery()
+
+        gallery_2 = search(dropdown)
+
+        return Gallery(gallery_2, selected_index=None)
+
+    tab.select(on_tab_select, dropdown, gallery_2, show_progress='hidden')
+
+    ############################################################################
+
+
+    def on_dropdown_select_event(event: SelectData):
+        dropdown = event.value
+
+        gallery_2 = on_tab_select(dropdown)
+
+        return gallery_2
+
+    dropdown.select(on_dropdown_select_event,
+                    outputs=gallery_2,
+                    show_progress='hidden')
+
+    ############################################################################
+
+
+    def on_gallery_2_select_event(event: SelectData, dropdown):
+        image = event.value['image']['path']
+
+        textbox, annotated_image, button, gallery_1, html, gallery_2 = on_image_change_or_select(
+            image, dropdown)
+
+        return textbox, annotated_image, button, gallery_1, html, gallery_2
+
+    gallery_2.select(
+        on_gallery_2_select_event,
+        dropdown,
+        [textbox, annotated_image, button, gallery_1, html, gallery_2],
+        show_progress='hidden')
+
+    ############################################################################
+
+blocks.launch(show_api=False)

db.py

@@ -0,0 +1,78 @@
+from peewee import BlobField, CharField, IntegrityError, Model, SqliteDatabase
+
+import datetime
+import os.path
+import pickle
+import tempfile
+
+################################################################################
+
+
+class Gallery(Model):
+
+    id = CharField(primary_key=True)
+
+    path = CharField(unique=True)
+
+    metadata = BlobField()
+
+    class Meta:
+
+        database = SqliteDatabase(f'{tempfile.gettempdir()}/.db')
+
+
+Gallery.create_table()
+
+################################################################################
+
+
+def delete(path):
+    Gallery.delete().where(Gallery.path == path).execute()
+
+
+def delete_by_id(id):
+    Gallery.delete().where(Gallery.id == id).execute()
+
+
+def exists(path):
+    return Gallery.select().where(Gallery.path == path).exists()
+
+
+def exists_by_id(id):
+    return Gallery.select().where(Gallery.id == id).exists()
+
+
+def get(path):
+    image = Gallery.get(Gallery.path == path)
+    return image.id, pickle.loads(image.metadata)
+
+
+def get_by_id(id):
+    image = Gallery.get(Gallery.id == id)
+    return image.path, pickle.loads(image.metadata)
+
+
+def tuples():
+    images = []
+    for id, path, metadata in Gallery.select().order_by(Gallery.id).tuples():
+        images.append((id, path, pickle.loads(metadata)))
+    return images
+
+
+def update(path, metadata):
+    metadata = pickle.dumps(metadata)
+
+    if os.path.basename(path) == 'webcam.png':
+        timestamp = datetime.datetime.fromtimestamp(
+            os.path.getctime(path)).strftime('%Y%m%d_%H%M%S')
+
+        id = f'DCIM/Camera/{timestamp}.png'
+    else:
+        id = f'DCIM/Upload/{os.path.basename(path)}'
+
+    try:
+        Gallery.create(id=id, path=path, metadata=metadata)
+    except IntegrityError:
+        Gallery.set_by_id(id, dict(path=path, metadata=metadata))
+
+    return id

deeperface.py

@@ -0,0 +1,158 @@
+from deepface import DeepFace
+from deepface.detectors import FaceDetector, OpenCvWrapper
+from deepface.extendedmodels import Emotion
+
+import cv2
+import deepface.commons.functions
+import numpy
+import opennsfw2
+
+
+class Emotion:
+
+    labels = [emotion.capitalize() for emotion in Emotion.labels]
+    model = DeepFace.build_model('Emotion')
+
+
+class NSFW:
+
+    labels = [False, True]
+    model = opennsfw2.make_open_nsfw_model()
+
+
+################################################################################
+
+
+class Pixels(numpy.ndarray):
+
+    @classmethod
+    def read(cls, path):
+        return cv2.imread(path).view(type=cls)
+
+    def write(self, path):
+        cv2.imwrite(path, self)
+
+
+class FaceImage(Pixels):
+
+    def analyze(face_img):
+        face_img = cv2.cvtColor(face_img, cv2.COLOR_BGR2GRAY)
+        face_img = cv2.resize(face_img, (48, 48))
+        face_img = numpy.expand_dims(face_img, axis=0)
+
+        predictions = Emotion.model.predict(face_img).ravel()
+
+        return Emotion.labels[numpy.argmax(predictions)]
+
+    def represent(face_img):
+        face_img = numpy.expand_dims(face_img, axis=0)
+        return DeepFace.represent(face_img,
+                                  'VGG-Face',
+                                  detector_backend='skip')[0]['embedding']
+
+
+class Image(Pixels):
+
+    def annotate(img, face, emotion):
+        face_annotation = numpy.zeros_like(img)
+        face_annotation = cv2.cvtColor(face_annotation,
+                                       cv2.COLOR_BGR2GRAY).view(type=Pixels)
+        x, y, w, h = face
+        axes = (int(0.1 * w), int(0.1 * h))
+        cv2.ellipse(face_annotation, (x + axes[0], y + axes[1]), axes, 180, 0,
+                    90, (1, 0, 0), 2)
+        cv2.ellipse(face_annotation, (x + w - axes[0], y + axes[1]), axes, 270,
+                    0, 90, (1, 0, 0), 2)
+        cv2.ellipse(face_annotation, (x + axes[0], y + h - axes[1]), axes, 90,
+                    0, 90, (1, 0, 0), 2)
+        cv2.ellipse(face_annotation, (x + w - axes[0], y + h - axes[1]), axes,
+                    0, 0, 90, (1, 0, 0), 2)
+
+        emotion_annotation = numpy.zeros_like(img)
+        emotion_annotation = cv2.cvtColor(emotion_annotation,
+                                          cv2.COLOR_BGR2GRAY).view(type=Pixels)
+        for fontScale in numpy.arange(10, 0, -0.1):
+            textSize, _ = cv2.getTextSize(emotion, cv2.FONT_HERSHEY_SIMPLEX,
+                                          fontScale, 2)
+            if textSize[0] <= int(0.6 * w):
+                break
+        cv2.putText(emotion_annotation, emotion,
+                    (int(x + (w - textSize[0]) / 2), int(y + textSize[1] / 2)),
+                    cv2.FONT_HERSHEY_SIMPLEX, fontScale, (1, 0, 0), 2)
+
+        return [(face_annotation, 'face'), (emotion_annotation, 'emotion')]
+
+    def detect_faces(img):
+        face_detector = FaceDetector.build_model('opencv')
+        faces = []
+        for _, face, _ in FaceDetector.detect_faces(face_detector, 'opencv',
+                                                    img, False):
+            face = (int(face[0]), int(face[1]), int(face[2]), int(face[3]))
+            faces.append(face)
+        return faces
+
+    def extract_face(img, face):
+        face_detector = FaceDetector.build_model('opencv')
+        x, y, w, h = face
+        img = img[y:y + h, x:x + w]
+        img = OpenCvWrapper.align_face(face_detector['eye_detector'], img)
+        target_size = deepface.commons.functions.find_target_size('VGG-Face')
+        face_img, _, _ = deepface.commons.functions.extract_faces(
+            img, target_size, 'skip')[0]
+        face_img = numpy.squeeze(face_img, axis=0)
+        return face_img.view(type=FaceImage)
+
+    def nsfw(img):
+        img = cv2.resize(img, (224, 224))
+        img = img - numpy.array([104, 117, 123], numpy.float32)
+        img = numpy.expand_dims(img, axis=0)
+
+        predictions = NSFW.model.predict(img).ravel()
+
+        return NSFW.labels[numpy.argmax(predictions)]
+
+    def pixelate(img):
+        h, w, _ = img.shape
+        img = cv2.resize(img, (16, 16))
+        return cv2.resize(img, (w, h),
+                          interpolation=cv2.INTER_NEAREST).view(type=Pixels)
+
+
+################################################################################
+
+
+class Metadata(dict):
+
+    def __init__(self, img):
+        metadata = {}
+        for face in img.detect_faces():
+            face_img = img.extract_face(face)
+
+            emotion = face_img.analyze()
+            representation = face_img.represent()
+
+            metadata[face] = {
+                'emotion': emotion,
+                'representation': representation
+            }
+
+        super(Metadata, self).__init__(metadata)
+
+    def emotions(self):
+        return [value['emotion'] for value in self.values()]
+
+    def representations(self):
+        return [value['representation'] for value in self.values()]
+
+
+################################################################################
+
+
+def verify(source_representations, test_representations):
+    for source_representation in source_representations:
+        for test_representation in test_representations:
+            if deepface.commons.distance.findCosineDistance(
+                    source_representation, test_representation
+            ) < deepface.commons.distance.findThreshold('VGG-Face', 'cosine'):
+                return True
+    return False

examples/log.csv

@@ -0,0 +1,6 @@
+image
+ospan-ali-5zigAp0ng4s-unsplash.jpg
+ospan-ali-GUmRXc-vOxw-unsplash.jpg
+ospan-ali-t1JfI6SyEhM-unsplash.jpg
+ospan-ali-ufgR_EHJOUw-unsplash.jpg
+ospan-ali-_ZXdnKTHPGs-unsplash.jpg

requirements.txt

@@ -0,0 +1,3 @@
+deepface==0.0.81
+opennsfw2==0.13.7
+peewee==3.17.0