fafdasdf

FacePass.py

@@ -0,0 +1,23 @@
+from yolo.yoloFace import YOLO_FACE
+from vgg.vgg_face import MODEL_FACE
+from database.retriever import BruteForceStore
+import cv2
+
+
+DB = BruteForceStore()
+
+def pipeline(img):
+
+    images = YOLO_FACE(img)
+    for patch in images:
+        embeddings = MODEL_FACE(patch)
+        if DB(embeddings): return "Welcome!"
+    
+    return "Buzz off!!! petrichor me chor"
+
+if __name__ == "__main__":
+    
+    import cv2
+    
+    img = cv2.imread('temp.jpg', cv2.IMREAD_UNCHANGED) 
+    print(pipeline(img))

ReadMe.md

@@ -0,0 +1,14 @@
+## How to run:
+Be in root directory: FacePass/
+1. pip install -r requirements.txt to install all requirements. Python 3.12 recommended
+2. Create a folder named models and add your images into it
+3. Download the models from the links given in refs.txt and add them in models
+4. To run the program: python3 FacePass.py
+
+## Additional Instruction:
+When taking images to store in database please remove your glasses. Similarly when unlocking the facelock remove your glasses
+
+## Future work:
+1. Make a better database or use existing ones like FAISS
+2. Make a user interface so that the adminstrator can registor new users into the database
+3. For now the threshold value seems to be working fine but further tweaking and fine tuning is required

app.py

@@ -0,0 +1,49 @@
+import gradio as gr
+from yolo.yoloFace import YOLO_FACE
+from vgg.vgg_face import MODEL_FACE
+from database.retriever import BruteForceStore
+import cv2
+
+# Initialize the database
+DB = BruteForceStore()
+
+def pipeline(img):
+    images = YOLO_FACE(img)
+    for patch in images:
+        embeddings = MODEL_FACE(patch)
+        if DB(embeddings):
+            return "Welcome!"
+    return "Unauthorised"
+
+# Define a Gradio interface
+def process_image(image):
+    if image is None:
+        return "Please upload an image."
+    result = pipeline(image)
+    return result
+
+# Gradio App
+with gr.Blocks() as demo:
+    gr.Markdown("""
+    <div style="background: url('/home/asad/temp/app/FacePass/logo.png') no-repeat center center fixed; background-size: cover; height: 100%; padding: 20px; display: flex; flex-direction: column; justify-content: center; align-items: center;">
+        <h1 style="text-align: center; color: white;">
+            Face Verification App
+        </h1>
+        <h3 style="text-align: center; color: lightgrey;">
+            Upload your photo and let the app verify your identity!
+        </h3>
+    </div>
+    """)
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            image_input = gr.Image(type="numpy", label="Upload Your Image")
+        with gr.Column(scale=1):
+            output_text = gr.Textbox(label="Verification Result", interactive=False)
+
+    with gr.Row():
+        submit_button = gr.Button("Verify")
+        submit_button.click(process_image, inputs=[image_input], outputs=[output_text])
+
+if __name__ == "__main__":
+    demo.launch()

coco.names

@@ -0,0 +1,80 @@
+person
+bicycle
+car
+motorbike
+aeroplane
+bus
+train
+truck
+boat
+traffic light
+fire hydrant
+stop sign
+parking meter
+bench
+bird
+cat
+dog
+horse
+sheep
+cow
+elephant
+bear
+zebra
+giraffe
+backpack
+umbrella
+handbag
+tie
+suitcase
+frisbee
+skis
+snowboard
+sports ball
+kite
+baseball bat
+baseball glove
+skateboard
+surfboard
+tennis racket
+bottle
+wine glass
+cup
+fork
+knife
+spoon
+bowl
+banana
+apple
+sandwich
+orange
+broccoli
+carrot
+hot dog
+pizza
+donut
+cake
+chair
+sofa
+pottedplant
+bed
+diningtable
+toilet
+tvmonitor
+laptop
+mouse
+remote
+keyboard
+cell phone
+microwave
+oven
+toaster
+sink
+refrigerator
+book
+clock
+vase
+scissors
+teddy bear
+hair drier
+toothbrush

configs/yolov3-tiny.cfg

@@ -0,0 +1,182 @@
+[net]
+# Testing
+batch=1
+subdivisions=1
+# Training
+# batch=64
+# subdivisions=2
+width=416
+height=416
+channels=3
+momentum=0.9
+decay=0.0005
+angle=0
+saturation = 1.5
+exposure = 1.5
+hue=.1
+
+learning_rate=0.001
+burn_in=1000
+max_batches = 500200
+policy=steps
+steps=400000,450000
+scales=.1,.1
+
+[convolutional]
+batch_normalize=1
+filters=16
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[maxpool]
+size=2
+stride=2
+
+[convolutional]
+batch_normalize=1
+filters=32
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[maxpool]
+size=2
+stride=2
+
+[convolutional]
+batch_normalize=1
+filters=64
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[maxpool]
+size=2
+stride=2
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[maxpool]
+size=2
+stride=2
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[maxpool]
+size=2
+stride=2
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[maxpool]
+size=2
+stride=1
+
+[convolutional]
+batch_normalize=1
+filters=1024
+size=3
+stride=1
+pad=1
+activation=leaky
+
+###########
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+size=1
+stride=1
+pad=1
+filters=255
+activation=linear
+
+
+
+[yolo]
+mask = 3,4,5
+anchors = 10,14,  23,27,  37,58,  81,82,  135,169,  344,319
+classes=80
+num=6
+jitter=.3
+ignore_thresh = .7
+truth_thresh = 1
+random=1
+
+[route]
+layers = -4
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[upsample]
+stride=2
+
+[route]
+layers = -1, 8
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=3
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+size=1
+stride=1
+pad=1
+filters=255
+activation=linear
+
+[yolo]
+mask = 0,1,2
+anchors = 10,14,  23,27,  37,58,  81,82,  135,169,  344,319
+classes=80
+num=6
+jitter=.3
+ignore_thresh = .7
+truth_thresh = 1
+random=1

database/retriever.py

@@ -0,0 +1,51 @@
+import os
+from database.utils import similarity
+import cv2
+from vgg.vgg_face import MODEL_FACE
+from yolo.yoloFace import YOLO_FACE
+
+class Retriever:
+    """Base Retriever class"""
+    def __init__(self, thres=0.7, folder_loc="database/images", *args, **kwargs):
+        self.thres = thres
+        self.folder_loc = folder_loc
+    def unlock_lock(self, *args, **kwargs): ...
+    def __call__(self, *args, **kwargs):
+        return self.unlock_lock(*args, **kwargs)
+
+class Naive(Retriever):
+    def unlock_lock(self, emb):
+        "Kind of Dynamic but very slow"
+        for root, dirs, files in os.walk(self.folder_loc):
+            for file in files:
+                file_path = os.path.join(root, file)
+                image = cv2.imread(file_path)
+                for patch in YOLO_FACE(image):
+                    embedding = MODEL_FACE(patch)
+                    if similarity(emb, embedding) > self.thres:
+                        return True
+        return False
+    
+class BruteForceStore(Retriever):
+    def __init__(self, *args, **kwargs):
+        """
+            Watch dog integration required later
+            Only Use when the number of images are less
+        """
+        super().__init__(*args, **kwargs)
+        self.embeddings = []
+        for root, dirs, files in os.walk(self.folder_loc):
+            for file in files:
+                file_path = os.path.join(root, file)
+                image = cv2.imread(file_path)
+                for patch in YOLO_FACE(image):
+                    embedding = MODEL_FACE(patch)
+                    self.embeddings.append(embedding)
+
+    def unlock_lock(self, emb):
+        """Only Use when the number of images are less"""
+        for embedding in self.embeddings:
+            print(f"similarity : {similarity(emb, embedding)}")
+            if similarity(emb, embedding) > self.thres:
+                return True
+        return False

database/utils.py

@@ -0,0 +1,7 @@
+import numpy as np
+
+def similarity(v1:np.ndarray, v2:np.ndarray):
+    num = (v1 @ v2.T).item()
+    denom = np.linalg.norm(v1) * np.linalg.norm(v2)
+    print(num/denom)
+    return num/denom

models/best.pt

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

models/vgg_face_dag.pth

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

refs.txt

@@ -0,0 +1,8 @@
+references:
+https://github.com/noorkhokhar99/face-detection-yolov8/blob/main/test_web.py
+https://www.robots.ox.ac.uk/~albanie/pytorch-models.html
+
+
+download links:
+vgg_face: http://www.robots.ox.ac.uk/~albanie/models/pytorch-mcn/vgg_face_dag.pth
+yolo_face: https://github.com/noorkhokhar99/face-detection-yolov8/blob/main/best.pt

requirements.txt

@@ -0,0 +1,53 @@
+certifi==2024.12.14
+charset-normalizer==3.4.0
+contourpy==1.3.1
+cycler==0.12.1
+filelock==3.16.1
+fonttools==4.55.3
+fsspec==2024.10.0
+idna==3.10
+Jinja2==3.1.4
+kiwisolver==1.4.7
+MarkupSafe==3.0.2
+matplotlib==3.10.0
+mpmath==1.3.0
+networkx==3.4.2
+numpy==2.2.0
+nvidia-cublas-cu12==12.4.5.8
+nvidia-cuda-cupti-cu12==12.4.127
+nvidia-cuda-nvrtc-cu12==12.4.127
+nvidia-cuda-runtime-cu12==12.4.127
+nvidia-cudnn-cu12==9.1.0.70
+nvidia-cufft-cu12==11.2.1.3
+nvidia-curand-cu12==10.3.5.147
+nvidia-cusolver-cu12==11.6.1.9
+nvidia-cusparse-cu12==12.3.1.170
+nvidia-nccl-cu12==2.21.5
+nvidia-nvjitlink-cu12==12.4.127
+nvidia-nvtx-cu12==12.4.127
+opencv-python==4.10.0.84
+packaging==24.2
+pandas==2.2.3
+pillow==11.0.0
+psutil==6.1.0
+py-cpuinfo==9.0.0
+pyparsing==3.2.0
+python-dateutil==2.9.0.post0
+pytz==2024.2
+PyYAML==6.0.2
+requests==2.32.3
+scipy==1.14.1
+seaborn==0.13.2
+setuptools==75.6.0
+six==1.17.0
+sympy==1.13.1
+torch==2.5.1
+torchvision==0.20.1
+tqdm==4.67.1
+triton==3.1.0
+typing_extensions==4.12.2
+tzdata==2024.2
+ultralytics==8.3.51
+ultralytics-thop==2.0.13
+urllib3==2.2.3
+gradio

vgg/vgg19.py

@@ -0,0 +1,76 @@
+import torch
+from torch import nn
+
+KERNEL_SIZE = (3,3)
+
+class VGG19(nn.Module):
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.features = nn.Sequential(
+            nn.Conv2d(3, 64, KERNEL_SIZE, 1, 1),
+            nn.ReLU(),
+            nn.Conv2d(64, 64, KERNEL_SIZE, 1, 1),
+            nn.ReLU(),
+
+            nn.MaxPool2d(2),
+
+            nn.Conv2d(64, 128, KERNEL_SIZE, 1, 1),
+            nn.ReLU(),
+            nn.Conv2d(128, 128, KERNEL_SIZE, 1, 1),
+            nn.ReLU(),
+
+            nn.MaxPool2d(2),
+
+            nn.Conv2d(128, 256, KERNEL_SIZE, 1, 1),
+            nn.ReLU(),
+            nn.Conv2d(256, 256, KERNEL_SIZE, 1, 1),
+            nn.ReLU(),
+            nn.Conv2d(256, 256, KERNEL_SIZE, 1, 1),
+            nn.ReLU(),
+            nn.Conv2d(256, 256, KERNEL_SIZE, 1, 1),
+            nn.ReLU(),
+
+            nn.MaxPool2d(2),
+
+            nn.Conv2d(256, 512, KERNEL_SIZE, 1, 1),
+            nn.ReLU(),
+            nn.Conv2d(512, 512, KERNEL_SIZE, 1, 1),
+            nn.ReLU(),
+            nn.Conv2d(512, 512, KERNEL_SIZE, 1, 1),
+            nn.ReLU(),
+            nn.Conv2d(512, 512, KERNEL_SIZE, 1, 1),
+            nn.ReLU(),
+
+            nn.MaxPool2d(2),
+
+            nn.Conv2d(512, 512, KERNEL_SIZE, 1, 1),
+            nn.ReLU(),
+            nn.Conv2d(512, 512, KERNEL_SIZE, 1, 1),
+            nn.ReLU(),
+            nn.Conv2d(512, 512, KERNEL_SIZE, 1, 1),
+            nn.ReLU(),
+            nn.Conv2d(512, 512, KERNEL_SIZE, 1, 1),
+            nn.ReLU(),
+
+            nn.MaxPool2d(2)
+        )
+        self.classifier = nn.Sequential(
+            nn.Linear(49*512, 4096),
+            nn.ReLU(),
+            nn.Dropout(),
+            nn.Linear(4096, 4096),
+            nn.ReLU(),
+            nn.Dropout(),
+            nn.Linear(4096, 1000),
+        )
+    def forward(self, x:torch.Tensor):
+        x = self.features(x)
+        return self.classifier(x)
+    def embeddings(self, x:torch.Tensor):
+        return self.features(x).flatten().detach().numpy()
+    __call__ = embeddings
+
+MODEL_19 = VGG19()
+MODEL_19.load_state_dict(torch.load("models/vgg19-dcbb9e9d.pth"), strict=True)
+if __name__ == "__main__":
+    print(MODEL_19.state_dict().keys())

vgg/vgg_face.py

@@ -0,0 +1,117 @@
+import torch
+from torch import nn
+from warnings import filterwarnings
+from torchvision.transforms import ToTensor, Resize, Normalize, Compose
+
+filterwarnings("ignore")
+
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+KERNEL_SIZE = (3,3)
+
+class VGGFACE(nn.Module):
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.conv1_1 = nn.Conv2d(3, 64, KERNEL_SIZE, 1, 1)
+        self.conv1_2 = nn.Conv2d(64, 64, KERNEL_SIZE, 1, 1)
+
+        self.conv2_1 = nn.Conv2d(64, 128, KERNEL_SIZE, 1, 1)
+        self.conv2_2 = nn.Conv2d(128, 128, KERNEL_SIZE, 1, 1)
+
+        self.conv3_1 = nn.Conv2d(128, 256, KERNEL_SIZE, 1, 1)
+        self.conv3_2 = nn.Conv2d(256, 256, KERNEL_SIZE, 1, 1)
+        self.conv3_3 = nn.Conv2d(256, 256, KERNEL_SIZE, 1, 1)
+
+        self.conv4_1 = nn.Conv2d(256, 512, KERNEL_SIZE, 1, 1)
+        self.conv4_2 = nn.Conv2d(512, 512, KERNEL_SIZE, 1, 1)
+        self.conv4_3 = nn.Conv2d(512, 512, KERNEL_SIZE, 1, 1)
+
+        self.conv5_1 = nn.Conv2d(512, 512, KERNEL_SIZE, 1, 1)
+        self.conv5_2 = nn.Conv2d(512, 512, KERNEL_SIZE, 1, 1)
+        self.conv5_3 = nn.Conv2d(512, 512, KERNEL_SIZE, 1, 1)
+
+        self.fc6 = nn.Linear(49*512, 4096)
+        self.fc7 = nn.Linear(4096, 4096)
+        self.fc8 = nn.Linear(4096, 2622)
+        self.relu = nn.ReLU()
+        self.maxpool = nn.MaxPool2d(2)
+
+        self._features = [
+            self.conv1_1, self.relu,
+            self.conv1_2, self.relu,
+            self.maxpool,
+            self.conv2_1, self.relu,
+            self.conv2_2, self.relu,
+            self.maxpool,
+            self.conv3_1, self.relu,
+            self.conv3_2, self.relu,
+            self.conv3_3, self.relu,
+            self.maxpool,
+            self.conv4_1, self.relu,
+            self.conv4_2, self.relu,
+            self.conv4_3, self.relu,
+            self.maxpool,
+            self.conv5_1, self.relu,
+            self.conv5_2, self.relu,
+            self.conv5_3, self.relu,
+            self.maxpool,
+            nn.Flatten(start_dim=0)
+        ]
+
+        self._classifier = [
+            self.fc6, self.relu,
+            self.fc7, self.relu,
+            self.fc8
+        ]
+
+        self._embedder = [
+            self.conv1_1, self.relu,
+            self.conv1_2, self.relu,
+            self.maxpool,
+            self.conv2_1, self.relu,
+            self.conv2_2, self.relu,
+            self.maxpool,
+            self.conv3_1, self.relu,
+            self.conv3_2, self.relu,
+            self.conv3_3, self.relu,
+            self.maxpool,
+            self.conv4_1, self.relu,
+            self.conv4_2, self.relu,
+            self.conv4_3, self.relu,
+            self.maxpool,
+            self.conv5_1, self.relu,
+            self.conv5_2, self.relu,
+            self.conv5_3, self.relu,
+            self.maxpool,
+            nn.Flatten(start_dim=0),
+            self.fc6,
+        ]
+        self.transform = Compose([ToTensor() ,Resize((224, 224)), Normalize(mean=(93.59396362304688/255, 104.76238250732422/255, 129.186279296875/255), std=(1, 1, 1))])
+    def features(self, x):
+        x = self.transform(x)
+        x = x.to(DEVICE)
+        for layer in self._features:
+            x = layer(x)
+        return x
+    def classifier(self, x):
+        for layer in self._classifier:
+            x = layer(x)
+        return x
+    def embedder(self, x):
+        x = self.transform(x)
+        x = x.to(DEVICE)
+        for layer in self._embedder:
+            x = layer(x)
+        return x
+    def forward(self, x:torch.Tensor):
+        x = self.features(x)
+        return self.classifier(x)
+    def embeddings(self, x:torch.Tensor):
+        return self.embedder(x).cpu().flatten().detach().numpy()
+    __call__ = embeddings
+    
+MODEL_FACE = VGGFACE()
+MODEL_FACE.load_state_dict(torch.load("models/vgg_face_dag.pth"), strict=True)
+MODEL_FACE.to(DEVICE)
+
+if __name__ == "__main__":
+    print(MODEL_FACE.state_dict().keys())

yolo/yolo.py

@@ -0,0 +1,92 @@
+import cv2
+import numpy as np
+
+# need to change these offsets later
+X1_OFFSET, X2_OFFSET = 0,0
+Y1_OFFSET, Y2_OFFSET = 0,0
+
+class YOLO:
+    def __init__(self):
+        self.net = cv2.dnn.readNet("models/yolov3-tiny.weights", "configs/yolov3-tiny.cfg")
+        self.layer_names = self.net.getLayerNames()
+        self.output_layers = [self.layer_names[i - 1] for i in self.net.getUnconnectedOutLayers()]
+        self.classes = []
+        with open("coco.names", "r") as f:
+            self.classes = [line.strip() for line in f.readlines()]
+    def get_patches(self, img):
+        patches = []
+        for (x1, y1), (x2, y2), color, confidence, label in self.forward(img):
+            if (x1 == x2 or y1 == y2):
+                continue
+            print((x1, y1), (x2, y2))
+            patches.append(img[y1:y2, x1:x2])
+        return patches
+    def forward(self, img):
+        height, width, channels = img.shape
+
+        # Prepare the image for YOLO
+        blob = cv2.dnn.blobFromImage(img, 0.00392, (416, 416), (0, 0, 0), True, crop=False)
+        self.net.setInput(blob)
+
+        # Run the forward pass
+        outs = self.net.forward(self.output_layers)
+
+        # Processing the output
+        class_ids = []
+        confidences = []
+        boxes = []
+        for out in outs:
+            for detection in out:
+                scores = detection[5:] # center x, center y, width,  height, object confidence score, class confidence scores...
+                class_id = np.argmax(scores)
+                class_confidence = scores[class_id]
+                object_confidence = detection[4]
+                if object_confidence > 0.5:
+                    # Get the coordinates for the bounding box
+                    center_x = int(detection[0] * width)
+                    center_y = int(detection[1] * height)
+                    w = int(detection[2] * width)
+                    h = int(detection[3] * height)
+
+                    # Rectangle coordinates
+                    x = int(center_x - w / 2)
+                    y = int(center_y - h / 2)
+                    if x < 0 or y < 0:
+                        continue
+                    boxes.append([x, y, w, h])
+                    confidences.append(float(class_confidence))
+                    class_ids.append(class_id)
+
+        # Apply non-max suppression to remove overlapping boxes
+        indexes = cv2.dnn.NMSBoxes(boxes, confidences, 0.5, 0.4)
+        for i in range(len(boxes)):
+            if i in indexes:
+                x, y, w, h = boxes[i]
+                label = str(self.classes[class_ids[i]])
+                confidence = confidences[i]
+                color = (0, 255, 0)  # Green box
+                if label == "person":
+                    yield (x + X1_OFFSET, y + Y1_OFFSET), (x + w + X2_OFFSET, y + h + Y2_OFFSET), color, confidence, label
+    __call__ = get_patches
+    
+def display(yolo_model:YOLO):
+    cam = cv2.VideoCapture(0)
+    while True:
+        ret, img = cam.read()
+        if not ret:
+            print("unable to record")
+            continue
+        for (x1, y1), (x2, y2), color, confidence, label in yolo_model.forward(img):
+            print(x1, y1, x2, y2)
+            cv2.rectangle(img, (x1, y1), (x2, y2), color, 2)
+            cv2.putText(img, f"{label} {confidence:.2f}", (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
+        cv2.imshow("Camera Feed", img)
+        if cv2.waitKey(1) & 0xFF == ord('q'):
+            break
+        # Show the image
+    cam.release()
+    cv2.destroyAllWindows()
+
+if __name__ == "__main__":
+    yolo_model = YOLO()
+    display(yolo_model=yolo_model)

yolo/yoloFace.py

@@ -0,0 +1,25 @@
+import cv2
+from ultralytics import YOLO
+
+X1_OFFSET, Y1_OFFSET, X2_OFFSET, Y2_OFFSET = 0, 0, 0, 0 # need to tinker with later
+COLOR = (0, 255, 0)
+
+class YOLOFace:
+    
+    def __init__(self):
+        self.net = YOLO("models/best.pt")
+    def get_patches(self, img):
+        patches = []
+        for (x1, y1), (x2, y2) in self.forward(img):
+            cv2.rectangle(img, (x1, y1), (x2, y2), COLOR, 2)
+            if (x1 == x2 or y1 == y2):
+                continue
+            patches.append(img[y1:y2, x1:x2])
+        return patches
+    def forward(self, img):
+        boxes = self.net.predict(img, verbose=False)[0].boxes.xyxy.cpu().detach().numpy()
+        for x1, y1, x2, y2 in boxes:
+            yield (int(x1.item()+X1_OFFSET), int(y1.item()+Y1_OFFSET)), (int(x2.item()+X2_OFFSET), int(y2.item()+Y2_OFFSET))
+    __call__ = get_patches
+    
+YOLO_FACE = YOLOFace()