Working API Added

.gitattributes

@@ -33,3 +33,6 @@ 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
+weights/face_detection_onnx_32.onnx filter=lfs diff=lfs merge=lfs -text
+weights/siamese_onnx_32.onnx filter=lfs diff=lfs merge=lfs -text
+weights/keypoint_68_weights.dat filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,3 @@
+__pycache__
+*/__pycache__
+*/*/__pycache__

api/main.py

@@ -0,0 +1,31 @@
+import sys
+import os
+from PIL import Image
+import numpy as np
+from fastapi import FastAPI, UploadFile
+
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "../src")))
+from image_tagger.main import tagger
+
+app = FastAPI(title="Face Recognition")
+
+
+@app.get("/")
+def display():
+    return "Welcome to Image Tagger Api"
+
+
+@app.post("/predict")
+def predict(file: UploadFile):
+    img = Image.open(file.file)
+    img = np.array(img)
+    img = np.transpose(img, (2, 0, 1)).astype(dtype=np.float32)
+    img /= 255.0
+    boxes, matrixs, keypoints, results = tagger(img)
+
+    return {
+        "predictions": results,
+        "boxes": boxes.tolist(),
+        "matrixs": [matrix.tolist() for matrix in matrixs],
+        "keypoints": [keypoint.tolist() for keypoint in keypoints],
+    }

src/image_tagger/components.py

@@ -0,0 +1,61 @@
+import json
+import dlib
+import numpy as np
+import onnxruntime as ort
+from image_tagger import config
+from image_tagger.utility import FaceAligner
+from image_tagger.utility import face_similarity
+
+
+def face_recognition(aligned):
+    print(config.FACE_EMBEDDING)
+    with open(config.FACE_EMBEDDING, "r") as file:
+        actor_embeddings = json.load(file)
+
+    face_identified = []
+    for face in aligned:
+        embedding = face_embedding(face)
+        identity = []
+        for actor in sorted(actor_embeddings.keys()):
+            similarity = face_similarity(embedding, actor_embeddings[actor])
+            identity.append((actor, similarity))
+        identity = [
+            n
+            for i, (n, similar) in enumerate(sorted(identity, key=lambda x: x[1]))
+            if i < 3
+        ]
+        face_identified.append(identity)
+    return face_identified
+
+
+def face_detection(img):
+    session = ort.InferenceSession(
+        config.FACE_DETECTION_ONNX_WEIGHTS, providers=["CPUExecutionProvider"]
+    )
+    output = session.run([], {"input": img[np.newaxis, ...]})
+    return output
+
+
+def face_alignment(img, boxes):
+    predictor = dlib.shape_predictor(config.FACE_KEYPOINT_DLIB_WEIGHTS)
+    aligner = FaceAligner(predictor)
+    matrix = []
+    aligned = []
+    facial_keypoints = []
+
+    for box in boxes:
+        align_image, align_matrix, face_keypoint = aligner.align(img, box)
+        matrix.append(align_matrix)
+        aligned.append(align_image)
+        facial_keypoints.append(face_keypoint)
+
+    return (aligned, matrix, facial_keypoints)
+
+
+def face_embedding(img):
+    img = (img / 255.0 - config.MEAN) / config.STD
+    img = np.transpose(img, (2, 0, 1)).astype(np.float32)
+    img = img[np.newaxis, ...]
+    session = ort.InferenceSession(config.FACE_EMBEDDING_ONNX_WEIGHTS)
+    output = session.run([], {"input": img})[0][0].tolist()
+    return output

src/image_tagger/config.py

@@ -0,0 +1,15 @@
+import numpy as np
+import os
+
+PROJECT_DIR=os.getcwd()
+WEIGHT_DIR=os.path.join(PROJECT_DIR,"weights")
+DATA_DIR=os.path.join(PROJECT_DIR,"data")
+FACE_DETECTION_ONNX_WEIGHTS=os.path.join(WEIGHT_DIR,"face_detection_onnx_32.onnx")
+FACE_KEYPOINT_DLIB_WEIGHTS=os.path.join(WEIGHT_DIR,"keypoint_68_weights.dat")
+FACE_EMBEDDING_ONNX_WEIGHTS=os.path.join(WEIGHT_DIR,"siamese_onnx_32.onnx")
+FACE_EMBEDDING=os.path.join(DATA_DIR,"actor_embedding.json")
+MEAN=np.array([0.485,0.456,0.406])
+STD=np.array([0.229,0.224,0.225])
+THRESHOLD=10.50
+PADDING=15
+SIZE=224

src/image_tagger/main.py

@@ -0,0 +1,21 @@
+import argparse
+from image_tagger.utility import preprocess_img
+from image_tagger.components import face_detection
+from image_tagger.components import face_alignment
+from image_tagger.components import face_recognition
+
+def tagger(img):
+	boxes,labels,scores=face_detection(img)
+	aligned,matrixs,keypoints=face_alignment(img, boxes)
+	results=face_recognition(aligned)
+
+	return (boxes, matrixs, keypoints, results)
+
+if  __name__ == '__main__':
+	parser=argparse.ArgumentParser()
+	parser.add_argument("-p","--path",required=True)
+	args=vars(parser.parse_args())
+
+	img=preprocess_img(args["path"])
+	boxes, matrixs, results = tagger(img)
+

src/image_tagger/utility.py

@@ -0,0 +1,74 @@
+import cv2
+import numpy as np
+import dlib
+from image_tagger import config
+
+def preprocess_img(img_pth):
+    img=cv2.imread(img_pth)
+    img=cv2.cvtColor(img,cv2.COLOR_BGR2RGB) 
+    img=(np.transpose(img,(2,0,1)).astype(dtype=np.float32))
+    img/=255.0
+    
+    return img
+
+def face_similarity(embed_1,embed_2):
+    return np.sqrt(np.sum(np.square(np.array(embed_1)-np.array(embed_2))))
+
+class FaceAligner():
+    def __init__(self,predictor,desired_left_eye=(0.35,0.35),desired_face_width=config.SIZE, desired_face_height=None):
+        self.predictor=predictor
+        self.desired_left_eye=desired_left_eye
+        self.desired_right_eye=tuple([1-val for val in desired_left_eye])
+        self.desired_face_width=desired_face_width
+        self.desired_face_height=desired_face_height
+        
+        if self.desired_face_height is None:
+            self.desired_face_height=self.desired_face_width
+            
+    def shape_to_np(self,shape, dtype="int"):
+        coords = np.zeros((68, 2), dtype=dtype)
+        for i in range(0, 68):
+            coords[i] = (shape.part(i).x, shape.part(i).y)
+        return coords
+
+    def align(self,img,box):
+        image=np.transpose(img,(1,2,0)).copy()
+        image=(image*255).astype("uint8")
+
+        x1=max(int(box[0])-config.PADDING,0)
+        x2=min(int(box[2])+config.PADDING,image.shape[1])
+        y1=max(int(box[1])-config.PADDING,0)
+        y2=min(int(box[3])+config.PADDING,image.shape[0])
+        
+        dlib_box=dlib.rectangle(left=x1, top=y1, right=x2, bottom=y2)
+    
+        face_keypoint=self.predictor(image,dlib_box)
+        face_keypoint=self.shape_to_np(face_keypoint)
+        
+        left_eye_center=(np.mean(face_keypoint[36:42,0]),np.mean(face_keypoint[36:42,1]))
+        right_eye_center=(np.mean(face_keypoint[42:48,0]),np.mean(face_keypoint[42:48,1]))
+
+        dy=right_eye_center[1]-left_eye_center[1]
+        dx=right_eye_center[0]-left_eye_center[0]
+        
+        angle=np.degrees(np.arctan2(dy, dx))
+
+        dist=np.sqrt((dx ** 2) + (dy ** 2))
+        desired_dist=self.desired_right_eye[0]-self.desired_left_eye[0]
+        desired_dist*=self.desired_face_width
+        scale=desired_dist/dist
+
+        eye_center=((left_eye_center[0] + right_eye_center[0]) // 2,
+                    (left_eye_center[1] + right_eye_center[1]) // 2)
+      
+        Matrix = cv2.getRotationMatrix2D(eye_center, angle, scale)
+        
+        tX = self.desired_face_width * 0.5
+        tY = tY = self.desired_face_height * self.desired_left_eye[1]
+        Matrix[0, 2] += (tX - eye_center[0])
+        Matrix[1, 2] += (tY - eye_center[1])
+        
+        (w, h) = (self.desired_face_width, self.desired_face_height)
+        aligned_img = cv2.warpAffine(image, Matrix, (w,h),flags=cv2.INTER_CUBIC)
+        
+        return (aligned_img, Matrix, face_keypoint)

weights/face_detection_onnx_32.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:81ce635a5105481dfd45084b0d4715f9873f8e3e3326e3c768568d75fa2fbf67
+size 76044313

weights/keypoint_68_weights.dat

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

weights/siamese_onnx_32.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:02353e6dffae29fe97756ccf09153ed79feafb1edad158c81684919020733f26
+size 45221862