diff --git a/DeepFace.py b/DeepFace.py
new file mode 100644
index 0000000000000000000000000000000000000000..cb29852c35f70cd6c2f909ec2972c41a29dd1d5b
--- /dev/null
+++ b/DeepFace.py
@@ -0,0 +1,585 @@
+# common dependencies
+import os
+import warnings
+import logging
+from typing import Any, Dict, List, Union, Optional
+from deepface.commons.os_path import os_path
+
+# this has to be set before importing tensorflow
+os.environ["TF_USE_LEGACY_KERAS"] = "1"
+
+# pylint: disable=wrong-import-position
+
+# 3rd party dependencies
+import numpy as np
+import pandas as pd
+import tensorflow as tf
+
+# package dependencies
+from deepface.commons import package_utils, folder_utils
+from deepface.commons import logger as log
+from deepface.modules import (
+    modeling,
+    representation,
+    verification,
+    recognition,
+    demography,
+    detection,
+    streaming,
+    preprocessing,
+    cloudservice,
+)
+from deepface import __version__
+
+logger = log.get_singletonish_logger()
+
+# -----------------------------------
+# configurations for dependencies
+
+# users should install tf_keras package if they are using tf 2.16 or later versions
+package_utils.validate_for_keras3()
+
+warnings.filterwarnings("ignore")
+os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
+tf_version = package_utils.get_tf_major_version()
+if tf_version == 2:
+    tf.get_logger().setLevel(logging.ERROR)
+# -----------------------------------
+
+# create required folders if necessary to store model weights
+folder_utils.initialize_folder()
+
+
+def build_model(model_name: str) -> Any:
+    """
+    This function builds a deepface model
+    Args:
+        model_name (string): face recognition or facial attribute model
+            VGG-Face, Facenet, OpenFace, DeepFace, DeepID for face recognition
+            Age, Gender, Emotion, Race for facial attributes
+    Returns:
+        built_model
+    """
+    return modeling.build_model(model_name=model_name)
+
+
+def verify(
+    img1_path: Union[str, np.ndarray, List[float]],
+    img2_path: Union[str, np.ndarray, List[float]],
+    model_name: str = "VGG-Face",
+    detector_backend: str = "opencv",
+    distance_metric: str = "cosine",
+    enforce_detection: bool = True,
+    align: bool = True,
+    expand_percentage: int = 0,
+    normalization: str = "base",
+    silent: bool = False,
+) -> Dict[str, Any]:
+    """
+    Verify if an image pair represents the same person or different persons.
+    Args:
+        img1_path (str or np.ndarray or List[float]): Path to the first image.
+            Accepts exact image path as a string, numpy array (BGR), base64 encoded images
+            or pre-calculated embeddings.
+
+        img2_path (str or np.ndarray or List[float]): Path to the second image.
+            Accepts exact image path as a string, numpy array (BGR), base64 encoded images
+            or pre-calculated embeddings.
+
+        model_name (str): Model for face recognition. Options: VGG-Face, Facenet, Facenet512,
+            OpenFace, DeepFace, DeepID, Dlib, ArcFace, SFace and GhostFaceNet (default is VGG-Face).
+
+        detector_backend (string): face detector backend. Options: 'opencv', 'retinaface',
+            'mtcnn', 'ssd', 'dlib', 'mediapipe', 'yolov8', 'centerface' or 'skip'
+            (default is opencv).
+
+        distance_metric (string): Metric for measuring similarity. Options: 'cosine',
+            'euclidean', 'euclidean_l2' (default is cosine).
+
+        enforce_detection (boolean): If no face is detected in an image, raise an exception.
+            Set to False to avoid the exception for low-resolution images (default is True).
+
+        align (bool): Flag to enable face alignment (default is True).
+
+        expand_percentage (int): expand detected facial area with a percentage (default is 0).
+
+        normalization (string): Normalize the input image before feeding it to the model.
+            Options: base, raw, Facenet, Facenet2018, VGGFace, VGGFace2, ArcFace (default is base)
+
+        silent (boolean): Suppress or allow some log messages for a quieter analysis process
+            (default is False).
+
+    Returns:
+        result (dict): A dictionary containing verification results with following keys.
+
+        - 'verified' (bool): Indicates whether the images represent the same person (True)
+            or different persons (False).
+
+        - 'distance' (float): The distance measure between the face vectors.
+            A lower distance indicates higher similarity.
+
+        - 'max_threshold_to_verify' (float): The maximum threshold used for verification.
+            If the distance is below this threshold, the images are considered a match.
+
+        - 'model' (str): The chosen face recognition model.
+
+        - 'distance_metric' (str): The chosen similarity metric for measuring distances.
+
+        - 'facial_areas' (dict): Rectangular regions of interest for faces in both images.
+            - 'img1': {'x': int, 'y': int, 'w': int, 'h': int}
+                    Region of interest for the first image.
+            - 'img2': {'x': int, 'y': int, 'w': int, 'h': int}
+                    Region of interest for the second image.
+
+        - 'time' (float): Time taken for the verification process in seconds.
+    """
+
+    return verification.verify(
+        img1_path=img1_path,
+        img2_path=img2_path,
+        model_name=model_name,
+        detector_backend=detector_backend,
+        distance_metric=distance_metric,
+        enforce_detection=enforce_detection,
+        align=align,
+        expand_percentage=expand_percentage,
+        normalization=normalization,
+        silent=silent,
+    )
+
+
+def analyze(
+    img_path: Union[str, np.ndarray],
+    actions: Union[tuple, list] = ("emotion", "age", "gender", "race"),
+    enforce_detection: bool = True,
+    detector_backend: str = "opencv",
+    align: bool = True,
+    expand_percentage: int = 0,
+    silent: bool = False,
+) -> List[Dict[str, Any]]:
+    """
+    Analyze facial attributes such as age, gender, emotion, and race in the provided image.
+    Args:
+        img_path (str or np.ndarray): The exact path to the image, a numpy array in BGR format,
+            or a base64 encoded image. If the source image contains multiple faces, the result will
+            include information for each detected face.
+
+        actions (tuple): Attributes to analyze. The default is ('age', 'gender', 'emotion', 'race').
+            You can exclude some of these attributes from the analysis if needed.
+
+        enforce_detection (boolean): If no face is detected in an image, raise an exception.
+            Set to False to avoid the exception for low-resolution images (default is True).
+
+        detector_backend (string): face detector backend. Options: 'opencv', 'retinaface',
+            'mtcnn', 'ssd', 'dlib', 'mediapipe', 'yolov8', 'centerface' or 'skip'
+            (default is opencv).
+
+        distance_metric (string): Metric for measuring similarity. Options: 'cosine',
+            'euclidean', 'euclidean_l2' (default is cosine).
+
+        align (boolean): Perform alignment based on the eye positions (default is True).
+
+        expand_percentage (int): expand detected facial area with a percentage (default is 0).
+
+        silent (boolean): Suppress or allow some log messages for a quieter analysis process
+            (default is False).
+
+    Returns:
+        results (List[Dict[str, Any]]): A list of dictionaries, where each dictionary represents
+           the analysis results for a detected face. Each dictionary in the list contains the
+           following keys:
+
+        - 'region' (dict): Represents the rectangular region of the detected face in the image.
+            - 'x': x-coordinate of the top-left corner of the face.
+            - 'y': y-coordinate of the top-left corner of the face.
+            - 'w': Width of the detected face region.
+            - 'h': Height of the detected face region.
+
+        - 'age' (float): Estimated age of the detected face.
+
+        - 'face_confidence' (float): Confidence score for the detected face.
+            Indicates the reliability of the face detection.
+
+        - 'dominant_gender' (str): The dominant gender in the detected face.
+            Either "Man" or "Woman".
+
+        - 'gender' (dict): Confidence scores for each gender category.
+            - 'Man': Confidence score for the male gender.
+            - 'Woman': Confidence score for the female gender.
+
+        - 'dominant_emotion' (str): The dominant emotion in the detected face.
+            Possible values include "sad," "angry," "surprise," "fear," "happy,"
+            "disgust," and "neutral"
+
+        - 'emotion' (dict): Confidence scores for each emotion category.
+            - 'sad': Confidence score for sadness.
+            - 'angry': Confidence score for anger.
+            - 'surprise': Confidence score for surprise.
+            - 'fear': Confidence score for fear.
+            - 'happy': Confidence score for happiness.
+            - 'disgust': Confidence score for disgust.
+            - 'neutral': Confidence score for neutrality.
+
+        - 'dominant_race' (str): The dominant race in the detected face.
+            Possible values include "indian," "asian," "latino hispanic,"
+            "black," "middle eastern," and "white."
+
+        - 'race' (dict): Confidence scores for each race category.
+            - 'indian': Confidence score for Indian ethnicity.
+            - 'asian': Confidence score for Asian ethnicity.
+            - 'latino hispanic': Confidence score for Latino/Hispanic ethnicity.
+            - 'black': Confidence score for Black ethnicity.
+            - 'middle eastern': Confidence score for Middle Eastern ethnicity.
+            - 'white': Confidence score for White ethnicity.
+    """
+    return demography.analyze(
+        img_path=img_path,
+        actions=actions,
+        enforce_detection=enforce_detection,
+        detector_backend=detector_backend,
+        align=align,
+        expand_percentage=expand_percentage,
+        silent=silent,
+    )
+
+
+def find(
+    img_path: Union[str, np.ndarray],
+    db_path: str,
+    model_name: str = "VGG-Face",
+    distance_metric: str = "cosine",
+    enforce_detection: bool = True,
+    detector_backend: str = "opencv",
+    align: bool = True,
+    expand_percentage: int = 0,
+    threshold: Optional[float] = None,
+    normalization: str = "base",
+    silent: bool = False,
+) -> List[pd.DataFrame]:
+    """
+    Identify individuals in a database
+    Args:
+        img_path (str or np.ndarray): The exact path to the image, a numpy array in BGR format,
+            or a base64 encoded image. If the source image contains multiple faces, the result will
+            include information for each detected face.
+
+        db_path (string): Path to the folder containing image files. All detected faces
+            in the database will be considered in the decision-making process.
+
+        model_name (str): Model for face recognition. Options: VGG-Face, Facenet, Facenet512,
+            OpenFace, DeepFace, DeepID, Dlib, ArcFace, SFace and GhostFaceNet (default is VGG-Face).
+
+        distance_metric (string): Metric for measuring similarity. Options: 'cosine',
+            'euclidean', 'euclidean_l2' (default is cosine).
+
+        enforce_detection (boolean): If no face is detected in an image, raise an exception.
+            Set to False to avoid the exception for low-resolution images (default is True).
+
+        detector_backend (string): face detector backend. Options: 'opencv', 'retinaface',
+            'mtcnn', 'ssd', 'dlib', 'mediapipe', 'yolov8', 'centerface' or 'skip'
+            (default is opencv).
+
+        align (boolean): Perform alignment based on the eye positions (default is True).
+
+        expand_percentage (int): expand detected facial area with a percentage (default is 0).
+
+        threshold (float): Specify a threshold to determine whether a pair represents the same
+            person or different individuals. This threshold is used for comparing distances.
+            If left unset, default pre-tuned threshold values will be applied based on the specified
+            model name and distance metric (default is None).
+
+        normalization (string): Normalize the input image before feeding it to the model.
+            Options: base, raw, Facenet, Facenet2018, VGGFace, VGGFace2, ArcFace (default is base).
+
+        silent (boolean): Suppress or allow some log messages for a quieter analysis process
+            (default is False).
+
+    Returns:
+        results (List[pd.DataFrame]): A list of pandas dataframes. Each dataframe corresponds
+            to the identity information for an individual detected in the source image.
+            The DataFrame columns include:
+
+        - 'identity': Identity label of the detected individual.
+
+        - 'target_x', 'target_y', 'target_w', 'target_h': Bounding box coordinates of the
+                target face in the database.
+
+        - 'source_x', 'source_y', 'source_w', 'source_h': Bounding box coordinates of the
+                detected face in the source image.
+
+        - 'threshold': threshold to determine a pair whether same person or different persons
+
+        - 'distance': Similarity score between the faces based on the
+                specified model and distance metric
+    """
+    return recognition.find(
+        img_path=img_path,
+        db_path=db_path,
+        model_name=model_name,
+        distance_metric=distance_metric,
+        enforce_detection=enforce_detection,
+        detector_backend=detector_backend,
+        align=align,
+        expand_percentage=expand_percentage,
+        threshold=threshold,
+        normalization=normalization,
+        silent=silent,
+    )
+
+
+def represent(
+    img_path: Union[str, np.ndarray],
+    model_name: str = "VGG-Face",
+    enforce_detection: bool = True,
+    detector_backend: str = "opencv",
+    align: bool = True,
+    expand_percentage: int = 0,
+    normalization: str = "base",
+) -> List[Dict[str, Any]]:
+    """
+    Represent facial images as multi-dimensional vector embeddings.
+
+    Args:
+        img_path (str or np.ndarray): The exact path to the image, a numpy array in BGR format,
+            or a base64 encoded image. If the source image contains multiple faces, the result will
+            include information for each detected face.
+
+        model_name (str): Model for face recognition. Options: VGG-Face, Facenet, Facenet512,
+            OpenFace, DeepFace, DeepID, Dlib, ArcFace, SFace and GhostFaceNet
+            (default is VGG-Face.).
+
+        enforce_detection (boolean): If no face is detected in an image, raise an exception.
+            Default is True. Set to False to avoid the exception for low-resolution images
+            (default is True).
+
+        detector_backend (string): face detector backend. Options: 'opencv', 'retinaface',
+            'mtcnn', 'ssd', 'dlib', 'mediapipe', 'yolov8', 'centerface' or 'skip'
+            (default is opencv).
+
+        align (boolean): Perform alignment based on the eye positions (default is True).
+
+        expand_percentage (int): expand detected facial area with a percentage (default is 0).
+
+        normalization (string): Normalize the input image before feeding it to the model.
+            Default is base. Options: base, raw, Facenet, Facenet2018, VGGFace, VGGFace2, ArcFace
+            (default is base).
+
+    Returns:
+        results (List[Dict[str, Any]]): A list of dictionaries, each containing the
+            following fields:
+
+        - embedding (List[float]): Multidimensional vector representing facial features.
+            The number of dimensions varies based on the reference model
+            (e.g., FaceNet returns 128 dimensions, VGG-Face returns 4096 dimensions).
+
+        - facial_area (dict): Detected facial area by face detection in dictionary format.
+            Contains 'x' and 'y' as the left-corner point, and 'w' and 'h'
+            as the width and height. If `detector_backend` is set to 'skip', it represents
+            the full image area and is nonsensical.
+
+        - face_confidence (float): Confidence score of face detection. If `detector_backend` is set
+            to 'skip', the confidence will be 0 and is nonsensical.
+    """
+    return representation.represent(
+        img_path=img_path,
+        model_name=model_name,
+        enforce_detection=enforce_detection,
+        detector_backend=detector_backend,
+        align=align,
+        expand_percentage=expand_percentage,
+        normalization=normalization,
+    )
+
+
+def stream(
+    db_path: str = "",
+    model_name: str = "VGG-Face",
+    detector_backend: str = "opencv",
+    distance_metric: str = "cosine",
+    enable_face_analysis: bool = True,
+    source: Any = 0,
+    time_threshold: int = 5,
+    frame_threshold: int = 5,
+) -> None:
+    """
+    Run real time face recognition and facial attribute analysis
+
+    Args:
+        db_path (string): Path to the folder containing image files. All detected faces
+            in the database will be considered in the decision-making process.
+
+        model_name (str): Model for face recognition. Options: VGG-Face, Facenet, Facenet512,
+            OpenFace, DeepFace, DeepID, Dlib, ArcFace, SFace and GhostFaceNet (default is VGG-Face).
+
+        detector_backend (string): face detector backend. Options: 'opencv', 'retinaface',
+            'mtcnn', 'ssd', 'dlib', 'mediapipe', 'yolov8', 'centerface' or 'skip'
+            (default is opencv).
+
+        distance_metric (string): Metric for measuring similarity. Options: 'cosine',
+            'euclidean', 'euclidean_l2' (default is cosine).
+
+        enable_face_analysis (bool): Flag to enable face analysis (default is True).
+
+        source (Any): The source for the video stream (default is 0, which represents the
+            default camera).
+
+        time_threshold (int): The time threshold (in seconds) for face recognition (default is 5).
+
+        frame_threshold (int): The frame threshold for face recognition (default is 5).
+    Returns:
+        None
+    """
+
+    time_threshold = max(time_threshold, 1)
+    frame_threshold = max(frame_threshold, 1)
+
+    streaming.analysis(
+        db_path=db_path,
+        model_name=model_name,
+        detector_backend=detector_backend,
+        distance_metric=distance_metric,
+        enable_face_analysis=enable_face_analysis,
+        source=source,
+        time_threshold=time_threshold,
+        frame_threshold=frame_threshold,
+    )
+
+
+def extract_faces(
+    img_path: Union[str, np.ndarray],
+    detector_backend: str = "opencv",
+    enforce_detection: bool = True,
+    align: bool = True,
+    expand_percentage: int = 0,
+    grayscale: bool = False,
+) -> List[Dict[str, Any]]:
+    """
+    Extract faces from a given image
+
+    Args:
+        img_path (str or np.ndarray): Path to the first image. Accepts exact image path
+            as a string, numpy array (BGR), or base64 encoded images.
+
+        detector_backend (string): face detector backend. Options: 'opencv', 'retinaface',
+            'mtcnn', 'ssd', 'dlib', 'mediapipe', 'yolov8', 'centerface' or 'skip'
+            (default is opencv).
+
+        enforce_detection (boolean): If no face is detected in an image, raise an exception.
+            Set to False to avoid the exception for low-resolution images (default is True).
+
+        align (bool): Flag to enable face alignment (default is True).
+
+        expand_percentage (int): expand detected facial area with a percentage (default is 0).
+
+        grayscale (boolean): Flag to convert the image to grayscale before
+            processing (default is False).
+
+    Returns:
+        results (List[Dict[str, Any]]): A list of dictionaries, where each dictionary contains:
+
+        - "face" (np.ndarray): The detected face as a NumPy array.
+
+        - "facial_area" (Dict[str, Any]): The detected face's regions as a dictionary containing:
+            - keys 'x', 'y', 'w', 'h' with int values
+            - keys 'left_eye', 'right_eye' with a tuple of 2 ints as values. left and right eyes
+                are eyes on the left and right respectively with respect to the person itself
+                instead of observer.
+
+        - "confidence" (float): The confidence score associated with the detected face.
+    """
+
+    return detection.extract_faces(
+        img_path=img_path,
+        detector_backend=detector_backend,
+        enforce_detection=enforce_detection,
+        align=align,
+        expand_percentage=expand_percentage,
+        grayscale=grayscale,
+    )
+
+
+def cli() -> None:
+    """
+    command line interface function will be offered in this block
+    """
+    import fire
+
+    fire.Fire()
+
+
+# deprecated function(s)
+
+
+def detectFace(
+    img_path: Union[str, np.ndarray],
+    target_size: tuple = (224, 224),
+    detector_backend: str = "opencv",
+    enforce_detection: bool = True,
+    align: bool = True,
+) -> Union[np.ndarray, None]:
+    """
+    Deprecated face detection function. Use extract_faces for same functionality.
+
+    Args:
+        img_path (str or np.ndarray): Path to the first image. Accepts exact image path
+            as a string, numpy array (BGR), or base64 encoded images.
+
+        target_size (tuple): final shape of facial image. black pixels will be
+            added to resize the image (default is (224, 224)).
+
+        detector_backend (string): face detector backend. Options: 'opencv', 'retinaface',
+            'mtcnn', 'ssd', 'dlib', 'mediapipe', 'yolov8', 'centerface' or 'skip'
+            (default is opencv).
+
+        enforce_detection (boolean): If no face is detected in an image, raise an exception.
+            Set to False to avoid the exception for low-resolution images (default is True).
+
+        align (bool): Flag to enable face alignment (default is True).
+
+    Returns:
+        img (np.ndarray): detected (and aligned) facial area image as numpy array
+    """
+    logger.warn("Function detectFace is deprecated. Use extract_faces instead.")
+    face_objs = extract_faces(
+        img_path=img_path,
+        detector_backend=detector_backend,
+        enforce_detection=enforce_detection,
+        align=align,
+        grayscale=False,
+    )
+    extracted_face = None
+    if len(face_objs) > 0:
+        extracted_face = face_objs[0]["face"]
+        extracted_face = preprocessing.resize_image(img=extracted_face, target_size=target_size)
+    return extracted_face
+
+
+def sync_datasets():
+    # Set the local directories
+    base_dir = os_path.get_main_directory()
+
+    missing_dir = os.path.join(base_dir, 'mafqoud', 'images', 'missing_people')
+    founded_dir = os.path.join(base_dir, 'mafqoud', 'images', 'founded_people')
+
+    # Ensure the directories exist
+    os.makedirs(missing_dir, exist_ok=True)
+    os.makedirs(founded_dir, exist_ok=True)
+
+    missing_people = cloudservice.sync_folder('missing_people', missing_dir)
+
+    founded_people = cloudservice.sync_folder('founded_people', founded_dir)
+
+def delete_pkls():
+    # Set the local directories
+    base_dir = os_path.get_main_directory()
+
+    missing_dir = os.path.join(base_dir, 'mafqoud', 'images', 'missing_people')
+    founded_dir = os.path.join(base_dir, 'mafqoud', 'images', 'founded_people')
+
+    # Ensure the directories exist
+    os.makedirs(missing_dir, exist_ok=True)
+    os.makedirs(founded_dir, exist_ok=True)
+
+    cloudservice.delete_pkl_files(missing_dir)
+    cloudservice.delete_pkl_files(founded_dir)
+
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..2b0f9fbb7d024c081d12ea0418b02a0969c5d35a
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Sefik Ilkin Serengil
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..cb8e9aeb40d45d5c58a014b95cc19eb7237a7908
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,8 @@
+test:
+	cd tests && python -m pytest . -s --disable-warnings
+
+lint:
+	python -m pylint deepface/ --fail-under=10
+
+coverage:
+	pip install pytest-cov && cd tests && python -m pytest --cov=deepface
\ No newline at end of file
diff --git a/Train.py b/Train.py
new file mode 100644
index 0000000000000000000000000000000000000000..4ad7bc8847148bf242801204469afbf50647c446
--- /dev/null
+++ b/Train.py
@@ -0,0 +1,55 @@
+
+# from deepface import DeepFace
+# import os
+# models = [
+#     "VGG-Face",
+#     "Facenet",
+#     "Facenet512",
+#     "OpenFace",
+#     "DeepFace",
+#     "DeepID",
+#     "ArcFace",
+#     "Dlib",
+#     "SFace",
+# ]
+
+# metrics = ["cosine", "euclidean", "euclidean_l2"]
+
+# backends = [
+#     'opencv',
+#     'ssd',
+#     'dlib',
+#     'mtcnn',
+#     'retinaface',
+#     'mediapipe',
+#     'yolov8',
+#     'yunet',
+#     'fastmtcnn',
+# ]
+
+# # df = DeepFace.find(img_path='F:/projects/python/mafqoud/dataset/missing_people/m0.jpg'
+# #                     , db_path='F:/projects/python/mafqoud/dataset/founded_people'
+# #                     , enforce_detection = True
+# #                     , model_name = models[2]
+# #                     , distance_metric = metrics[2]
+# #                     , detector_backend = backends[3])
+
+# DeepFace.stream(db_path = "F:/deepface")
+
+# base_dir = os.path.abspath(os.path.dirname(__file__))
+# # base_dir = "f:\\"
+# founded_dir = os.path.join(base_dir, 'mafqoud', 'images', 'founded_people')
+# def get_main_directory():
+#     path = os.path.abspath(__file__)
+#     drive, _ = os.path.splitdrive(path)
+#     if not drive.endswith(os.path.sep):
+#         drive += os.path.sep
+#     return drive
+
+# base_dir = get_main_directory()
+# missing_dir = os.path.join(base_dir, 'mafqoud', 'images', 'missing_people')
+# print(missing_dir)
+
+# print(base_dir)
+# print(missing_dir)
+# print(founded_dir)
\ No newline at end of file
diff --git a/__init__.py b/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..69d27b416452135a4da763cc8c98a8872648ee34
--- /dev/null
+++ b/__init__.py
@@ -0,0 +1 @@
+__version__ = "0.0.90"
diff --git a/__pycache__/DeepFace.cpython-312.pyc b/__pycache__/DeepFace.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..07660320af17f02337ef35b18d4b21dfb4fd26d2
Binary files /dev/null and b/__pycache__/DeepFace.cpython-312.pyc differ
diff --git a/__pycache__/__init__.cpython-312.pyc b/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e596fa2bbf8d79722878d5466394b7a5b54c72c1
Binary files /dev/null and b/__pycache__/__init__.cpython-312.pyc differ
diff --git a/api/__init__.py b/api/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/api/__pycache__/__init__.cpython-312.pyc b/api/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f73d5c0638c5bc62fa9cba5fba5e9688e58c6086
Binary files /dev/null and b/api/__pycache__/__init__.cpython-312.pyc differ
diff --git a/api/postman/deepface-api.postman_collection.json b/api/postman/deepface-api.postman_collection.json
new file mode 100644
index 0000000000000000000000000000000000000000..0cbb0a3886499a37bc54b4a61b780eccbdd22f96
--- /dev/null
+++ b/api/postman/deepface-api.postman_collection.json
@@ -0,0 +1,102 @@
+{
+	"info": {
+		"_postman_id": "4c0b144e-4294-4bdd-8072-bcb326b1fed2",
+		"name": "deepface-api",
+		"schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
+	},
+	"item": [
+		{
+			"name": "Represent",
+			"request": {
+				"method": "POST",
+				"header": [],
+				"body": {
+					"mode": "raw",
+					"raw": "{\n  \"model_name\": \"Facenet\",\n  \"img\": \"/Users/sefik/Desktop/deepface/tests/dataset/img1.jpg\"\n}",
+					"options": {
+						"raw": {
+							"language": "json"
+						}
+					}
+				},
+				"url": {
+					"raw": "http://127.0.0.1:5000/represent",
+					"protocol": "http",
+					"host": [
+						"127",
+						"0",
+						"0",
+						"1"
+					],
+					"port": "5000",
+					"path": [
+						"represent"
+					]
+				}
+			},
+			"response": []
+		},
+		{
+			"name": "Face verification",
+			"request": {
+				"method": "POST",
+				"header": [],
+				"body": {
+					"mode": "raw",
+					"raw": "  {\n  \t\"img1_path\": \"/Users/sefik/Desktop/deepface/tests/dataset/img1.jpg\",\n    \"img2_path\": \"/Users/sefik/Desktop/deepface/tests/dataset/img2.jpg\",\n    \"model_name\": \"Facenet\",\n    \"detector_backend\": \"mtcnn\",\n    \"distance_metric\": \"euclidean\"\n  }",
+					"options": {
+						"raw": {
+							"language": "json"
+						}
+					}
+				},
+				"url": {
+					"raw": "http://127.0.0.1:5000/verify",
+					"protocol": "http",
+					"host": [
+						"127",
+						"0",
+						"0",
+						"1"
+					],
+					"port": "5000",
+					"path": [
+						"verify"
+					]
+				}
+			},
+			"response": []
+		},
+		{
+			"name": "Face analysis",
+			"request": {
+				"method": "POST",
+				"header": [],
+				"body": {
+					"mode": "raw",
+					"raw": "{\n    \"img_path\": \"/Users/sefik/Desktop/deepface/tests/dataset/couple.jpg\",\n    \"actions\": [\"age\", \"gender\", \"emotion\", \"race\"]\n}",
+					"options": {
+						"raw": {
+							"language": "json"
+						}
+					}
+				},
+				"url": {
+					"raw": "http://127.0.0.1:5000/analyze",
+					"protocol": "http",
+					"host": [
+						"127",
+						"0",
+						"0",
+						"1"
+					],
+					"port": "5000",
+					"path": [
+						"analyze"
+					]
+				}
+			},
+			"response": []
+		}
+	]
+}
\ No newline at end of file
diff --git a/api/src/__init__.py b/api/src/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/api/src/__pycache__/__init__.cpython-312.pyc b/api/src/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..76f1d160b308ecc7c721b448b7950fe5f747d6b2
Binary files /dev/null and b/api/src/__pycache__/__init__.cpython-312.pyc differ
diff --git a/api/src/__pycache__/app.cpython-312.pyc b/api/src/__pycache__/app.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2009180827db802f40567e1dcaced5caf6aa8a6f
Binary files /dev/null and b/api/src/__pycache__/app.cpython-312.pyc differ
diff --git a/api/src/api.py b/api/src/api.py
new file mode 100644
index 0000000000000000000000000000000000000000..70ccb512210c5b9882c84c073b6359674591d08a
--- /dev/null
+++ b/api/src/api.py
@@ -0,0 +1,10 @@
+import argparse
+import app
+import os
+
+if __name__ == "__main__":
+    deepface_app = app.create_app()
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-p", "--port", type=int, default=int(os.getenv('DEFAULT_PORT')), help="Port of serving api")
+    args = parser.parse_args()
+    deepface_app.run(host="0.0.0.0", port=args.port)
diff --git a/api/src/app.py b/api/src/app.py
new file mode 100644
index 0000000000000000000000000000000000000000..69ec52f5cea3175717e4d68924e52d34d23a1d68
--- /dev/null
+++ b/api/src/app.py
@@ -0,0 +1,11 @@
+# 3rd parth dependencies
+from flask import Flask
+from deepface.api.src.modules.core.routes import blueprint
+
+
+def create_app():
+    app = Flask(__name__)
+    app.register_blueprint(blueprint)
+    print(app.url_map)
+    return app
+
diff --git a/api/src/modules/__init__.py b/api/src/modules/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/api/src/modules/__pycache__/__init__.cpython-312.pyc b/api/src/modules/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1509f1b4935cda2f331772616f8e03fd776397a9
Binary files /dev/null and b/api/src/modules/__pycache__/__init__.cpython-312.pyc differ
diff --git a/api/src/modules/core/__init__.py b/api/src/modules/core/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/api/src/modules/core/__pycache__/__init__.cpython-312.pyc b/api/src/modules/core/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..caa62da742fbd294b70178009710595bbcfdcab6
Binary files /dev/null and b/api/src/modules/core/__pycache__/__init__.cpython-312.pyc differ
diff --git a/api/src/modules/core/__pycache__/routes.cpython-312.pyc b/api/src/modules/core/__pycache__/routes.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0edb67d059d24106d0b25c1aa459cdede9017dd6
Binary files /dev/null and b/api/src/modules/core/__pycache__/routes.cpython-312.pyc differ
diff --git a/api/src/modules/core/__pycache__/service.cpython-312.pyc b/api/src/modules/core/__pycache__/service.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f9879c164a8bb201e3806b035acf05ce69fa4c92
Binary files /dev/null and b/api/src/modules/core/__pycache__/service.cpython-312.pyc differ
diff --git a/api/src/modules/core/routes.py b/api/src/modules/core/routes.py
new file mode 100644
index 0000000000000000000000000000000000000000..eb5d942d7e72321dc9f8f0dde055ef8d318fc4fb
--- /dev/null
+++ b/api/src/modules/core/routes.py
@@ -0,0 +1,207 @@
+from flask import Blueprint, request , jsonify
+from deepface.api.src.modules.core import service
+from deepface.commons.logger import Logger
+from deepface.commons.os_path import os_path
+import json
+import os
+
+logger = Logger(module="api/src/routes.py")
+
+blueprint = Blueprint("routes", __name__)
+
+
+@blueprint.route("/")
+def home():
+    return "<h1>Welcome to DeepFace API!</h1>"
+
+
+@blueprint.route("/represent", methods=["POST"])
+def represent():
+    input_args = request.get_json()
+
+    if input_args is None:
+        return {"message": "empty input set passed"}
+
+    img_path = input_args.get("img") or input_args.get("img_path")
+    if img_path is None:
+        return {"message": "you must pass img_path input"}
+
+    model_name = input_args.get("model_name", "VGG-Face")
+    detector_backend = input_args.get("detector_backend", "opencv")
+    enforce_detection = input_args.get("enforce_detection", True)
+    align = input_args.get("align", True)
+
+    obj = service.represent(
+        img_path=img_path,
+        model_name=model_name,
+        detector_backend=detector_backend,
+        enforce_detection=enforce_detection,
+        align=align,
+    )
+
+    logger.debug(obj)
+
+    return obj
+
+
+@blueprint.route("/verify", methods=["POST"])
+def verify():
+    input_args = request.get_json()
+
+    if input_args is None:
+        return {"message": "empty input set passed"}
+
+    img1_path = input_args.get("img1") or input_args.get("img1_path")
+    img2_path = input_args.get("img2") or input_args.get("img2_path")
+
+    if img1_path is None:
+        return {"message": "you must pass img1_path input"}
+
+    if img2_path is None:
+        return {"message": "you must pass img2_path input"}
+
+    model_name = input_args.get("model_name", "VGG-Face")
+    detector_backend = input_args.get("detector_backend", "opencv")
+    enforce_detection = input_args.get("enforce_detection", True)
+    distance_metric = input_args.get("distance_metric", "cosine")
+    align = input_args.get("align", True)
+
+    verification = service.verify(
+        img1_path=img1_path,
+        img2_path=img2_path,
+        model_name=model_name,
+        detector_backend=detector_backend,
+        distance_metric=distance_metric,
+        align=align,
+        enforce_detection=enforce_detection,
+    )
+
+    logger.debug(verification)
+
+    return verification
+
+
+@blueprint.route("/analyze", methods=["POST"])
+def analyze():
+    input_args = request.get_json()
+
+    if input_args is None:
+        return {"message": "empty input set passed"}
+
+    img_path = input_args.get("img") or input_args.get("img_path")
+    if img_path is None:
+        return {"message": "you must pass img_path input"}
+
+    detector_backend = input_args.get("detector_backend", "opencv")
+    enforce_detection = input_args.get("enforce_detection", True)
+    align = input_args.get("align", True)
+    actions = input_args.get("actions", ["age", "gender", "emotion", "race"])
+
+    demographies = service.analyze(
+        img_path=img_path,
+        actions=actions,
+        detector_backend=detector_backend,
+        enforce_detection=enforce_detection,
+        align=align,
+    )
+
+    logger.debug(demographies)
+
+    return demographies
+
+@blueprint.route("/find", methods=["POST"])
+def find():
+    input_args = request.get_json()
+
+    if input_args is None:
+        response = jsonify({'error': 'empty input set passed'})
+        response.status_code = 500
+        return response
+
+    img_name = input_args.get("img") or input_args.get("img_name")
+    img_type = input_args.get("img_type")
+
+    if img_name is None:
+        response = jsonify({'error': 'you must pass img_name input'})
+        response.status_code = 404
+        return response
+
+    if img_type == "missing" or img_type == "missing_person" or img_type == "missing_people" or img_type == "missing person" or img_type == "missing people" :
+        
+        img_path = os.path.join( os_path.get_main_directory() , 'mafqoud' , 'images' , "missing_people" , img_name)
+        db_path = os.path.join( os_path.get_main_directory() , 'mafqoud' , 'images' , "founded_people")
+        
+    elif img_type == "founded" or img_type == "founded_person" or img_type == "founded_people" or img_type == "founded person" or img_type == "founded people" :
+    
+        img_path = os.path.join( os_path.get_main_directory() , 'mafqoud' , 'images' , "founded_people" , img_name)
+        db_path = os.path.join( os_path.get_main_directory() , 'mafqoud' , 'images' , "missing_people")
+
+    else :
+
+        response = jsonify({'error': 'the type of the image is not correct and it should be one of those : ( missing , missing_people , missing_people , missing person , missing people ) or ( founded , founded_people , founded_people , founded person , founded people )'})
+        response.status_code = 400
+        return response
+    
+    print(img_path)
+    if not os.path.exists(img_path) or not os.path.isfile(img_path):
+        # If the image does not exist, return a JSON response with status code 404
+        response = jsonify({'error': 'Image not found'})
+        response.status_code = 404
+        return response
+    
+        
+    model_name = input_args.get("model_name", "Facenet512")
+    detector_backend = input_args.get("detector_backend", "mtcnn")
+    enforce_detection = input_args.get("enforce_detection", True)
+    distance_metric = input_args.get("distance_metric", "euclidean_l2")
+    align = input_args.get("align", True)
+
+    if img_name is None:
+        return {"message": "you must pass img1_path input"}
+
+    if db_path is None:
+        dataset_path = os.path.join(path.get_parent_path(), 'dataset')
+        if img_type == "missing_person":
+            img_path = os.path.join(dataset_path, 'missing_people', img_name)
+            db_path = os.path.join(dataset_path, 'founded_people')
+        elif img_type == "founded_people":
+            img_path = os.path.join(dataset_path, 'founded_people', img_name)
+            db_path = os.path.join(dataset_path, 'missing_people')
+
+    results = service.find(
+        img_path=img_path,
+        db_path=db_path,
+        model_name=model_name,
+        detector_backend=detector_backend,
+        distance_metric=distance_metric,
+        align=align,
+        enforce_detection=enforce_detection,
+    )
+
+    # Calculate similarity_percentage for each row
+    results[0]['similarity_percentage'] =100 - ((results[0]['distance'] / results[0]['threshold']) * 100)
+
+    data = []
+    for _, row in results[0].iterrows():
+        data.append({
+            "identity": row['identity'],
+            "similarity_percentage": row['similarity_percentage']
+        })
+
+    json_data = json.dumps(data, indent=4)
+
+
+    logger.debug(json_data)
+    return json_data
+
+
+@blueprint.route("/dataset/sync", methods=["GET"])
+def sync_datasets():
+    result = service.sync_datasets()
+    return jsonify(result)
+
+
+@blueprint.route("/delete/pkls", methods=["GET"])
+def delete_pkls():
+    result = service.delete_pkls()
+    return jsonify(result)
\ No newline at end of file
diff --git a/api/src/modules/core/service.py b/api/src/modules/core/service.py
new file mode 100644
index 0000000000000000000000000000000000000000..121a8b842292a305332094b3e333cf21a5ddc94e
--- /dev/null
+++ b/api/src/modules/core/service.py
@@ -0,0 +1,84 @@
+from deepface import DeepFace
+
+# pylint: disable=broad-except
+
+
+def represent(img_path, model_name, detector_backend, enforce_detection, align):
+    try:
+        result = {}
+        embedding_objs = DeepFace.represent(
+            img_path=img_path,
+            model_name=model_name,
+            detector_backend=detector_backend,
+            enforce_detection=enforce_detection,
+            align=align,
+        )
+        result["results"] = embedding_objs
+        return result
+    except Exception as err:
+        return {"error": f"Exception while representing: {str(err)}"}, 400
+
+
+def verify(
+    img1_path, img2_path, model_name, detector_backend, distance_metric, enforce_detection, align
+):
+    try:
+        obj = DeepFace.verify(
+            img1_path=img1_path,
+            img2_path=img2_path,
+            model_name=model_name,
+            detector_backend=detector_backend,
+            distance_metric=distance_metric,
+            align=align,
+            enforce_detection=enforce_detection,
+        )
+        return obj
+    except Exception as err:
+        return {"error": f"Exception while verifying: {str(err)}"}, 400
+
+
+def analyze(img_path, actions, detector_backend, enforce_detection, align):
+    try:
+        result = {}
+        demographies = DeepFace.analyze(
+            img_path=img_path,
+            actions=actions,
+            detector_backend=detector_backend,
+            enforce_detection=enforce_detection,
+            align=align,
+            silent=True,
+        )
+        result["results"] = demographies
+        return result
+    except Exception as err:
+        return {"error": f"Exception while analyzing: {str(err)}"}, 400
+
+def find(img_path, db_path, model_name, detector_backend, distance_metric, enforce_detection, align):
+    try:
+        obj = DeepFace.find(
+            img_path=img_path,
+            db_path=db_path,
+            model_name=model_name,
+            detector_backend=detector_backend,
+            distance_metric=distance_metric,
+            align=align,
+            enforce_detection=enforce_detection,
+        )
+        return obj
+    except Exception as err:
+        return {"error": f"Exception while Findind: {str(err)}"}, 400
+
+
+def sync_datasets():
+    try:
+        DeepFace.sync_datasets()
+        return {'data': 'synced successfully'}, 200
+    except Exception as e:
+        return {'error': str(e)}, 400
+
+def delete_pkls():
+    try:
+        DeepFace.delete_pkls()
+        return {'data': 'pkl files deleted successfully'}, 200
+    except Exception as e:
+        return {'error': str(e)}, 400
\ No newline at end of file
diff --git a/basemodels/ArcFace.py b/basemodels/ArcFace.py
new file mode 100644
index 0000000000000000000000000000000000000000..43dd4247ccdbc8f52b4e9803425f16a700120ba4
--- /dev/null
+++ b/basemodels/ArcFace.py
@@ -0,0 +1,179 @@
+import os
+import gdown
+from deepface.commons import package_utils, folder_utils
+from deepface.models.FacialRecognition import FacialRecognition
+
+from deepface.commons import logger as log
+
+logger = log.get_singletonish_logger()
+
+# pylint: disable=unsubscriptable-object
+
+# --------------------------------
+# dependency configuration
+
+tf_version = package_utils.get_tf_major_version()
+
+if tf_version == 1:
+    from keras.models import Model
+    from keras.engine import training
+    from keras.layers import (
+        ZeroPadding2D,
+        Input,
+        Conv2D,
+        BatchNormalization,
+        PReLU,
+        Add,
+        Dropout,
+        Flatten,
+        Dense,
+    )
+else:
+    from tensorflow.keras.models import Model
+    from tensorflow.python.keras.engine import training
+    from tensorflow.keras.layers import (
+        ZeroPadding2D,
+        Input,
+        Conv2D,
+        BatchNormalization,
+        PReLU,
+        Add,
+        Dropout,
+        Flatten,
+        Dense,
+    )
+
+# pylint: disable=too-few-public-methods
+class ArcFaceClient(FacialRecognition):
+    """
+    ArcFace model class
+    """
+
+    def __init__(self):
+        self.model = load_model()
+        self.model_name = "ArcFace"
+        self.input_shape = (112, 112)
+        self.output_shape = 512
+
+
+def load_model(
+    url="https://github.com/serengil/deepface_models/releases/download/v1.0/arcface_weights.h5",
+) -> Model:
+    """
+    Construct ArcFace model, download its weights and load
+    Returns:
+        model (Model)
+    """
+    base_model = ResNet34()
+    inputs = base_model.inputs[0]
+    arcface_model = base_model.outputs[0]
+    arcface_model = BatchNormalization(momentum=0.9, epsilon=2e-5)(arcface_model)
+    arcface_model = Dropout(0.4)(arcface_model)
+    arcface_model = Flatten()(arcface_model)
+    arcface_model = Dense(512, activation=None, use_bias=True, kernel_initializer="glorot_normal")(
+        arcface_model
+    )
+    embedding = BatchNormalization(momentum=0.9, epsilon=2e-5, name="embedding", scale=True)(
+        arcface_model
+    )
+    model = Model(inputs, embedding, name=base_model.name)
+
+    # ---------------------------------------
+    # check the availability of pre-trained weights
+
+    home = folder_utils.get_deepface_home()
+
+    file_name = "arcface_weights.h5"
+    output = home + "/.deepface/weights/" + file_name
+
+    if os.path.isfile(output) != True:
+
+        logger.info(f"{file_name} will be downloaded to {output}")
+        gdown.download(url, output, quiet=False)
+
+    # ---------------------------------------
+
+    model.load_weights(output)
+
+    return model
+
+
+def ResNet34() -> Model:
+    """
+    ResNet34 model
+    Returns:
+        model (Model)
+    """
+    img_input = Input(shape=(112, 112, 3))
+
+    x = ZeroPadding2D(padding=1, name="conv1_pad")(img_input)
+    x = Conv2D(
+        64, 3, strides=1, use_bias=False, kernel_initializer="glorot_normal", name="conv1_conv"
+    )(x)
+    x = BatchNormalization(axis=3, epsilon=2e-5, momentum=0.9, name="conv1_bn")(x)
+    x = PReLU(shared_axes=[1, 2], name="conv1_prelu")(x)
+    x = stack_fn(x)
+
+    model = training.Model(img_input, x, name="ResNet34")
+
+    return model
+
+
+def block1(x, filters, kernel_size=3, stride=1, conv_shortcut=True, name=None):
+    bn_axis = 3
+
+    if conv_shortcut:
+        shortcut = Conv2D(
+            filters,
+            1,
+            strides=stride,
+            use_bias=False,
+            kernel_initializer="glorot_normal",
+            name=name + "_0_conv",
+        )(x)
+        shortcut = BatchNormalization(
+            axis=bn_axis, epsilon=2e-5, momentum=0.9, name=name + "_0_bn"
+        )(shortcut)
+    else:
+        shortcut = x
+
+    x = BatchNormalization(axis=bn_axis, epsilon=2e-5, momentum=0.9, name=name + "_1_bn")(x)
+    x = ZeroPadding2D(padding=1, name=name + "_1_pad")(x)
+    x = Conv2D(
+        filters,
+        3,
+        strides=1,
+        kernel_initializer="glorot_normal",
+        use_bias=False,
+        name=name + "_1_conv",
+    )(x)
+    x = BatchNormalization(axis=bn_axis, epsilon=2e-5, momentum=0.9, name=name + "_2_bn")(x)
+    x = PReLU(shared_axes=[1, 2], name=name + "_1_prelu")(x)
+
+    x = ZeroPadding2D(padding=1, name=name + "_2_pad")(x)
+    x = Conv2D(
+        filters,
+        kernel_size,
+        strides=stride,
+        kernel_initializer="glorot_normal",
+        use_bias=False,
+        name=name + "_2_conv",
+    )(x)
+    x = BatchNormalization(axis=bn_axis, epsilon=2e-5, momentum=0.9, name=name + "_3_bn")(x)
+
+    x = Add(name=name + "_add")([shortcut, x])
+    return x
+
+
+def stack1(x, filters, blocks, stride1=2, name=None):
+    x = block1(x, filters, stride=stride1, name=name + "_block1")
+    for i in range(2, blocks + 1):
+        x = block1(x, filters, conv_shortcut=False, name=name + "_block" + str(i))
+    return x
+
+
+def stack_fn(x):
+    x = stack1(x, 64, 3, name="conv2")
+    x = stack1(x, 128, 4, name="conv3")
+    x = stack1(x, 256, 6, name="conv4")
+    return stack1(x, 512, 3, name="conv5")
diff --git a/basemodels/DeepID.py b/basemodels/DeepID.py
new file mode 100644
index 0000000000000000000000000000000000000000..b68b37915e7d34ac4d18e7e833e68e886d38b932
--- /dev/null
+++ b/basemodels/DeepID.py
@@ -0,0 +1,99 @@
+import os
+import gdown
+from deepface.commons import package_utils, folder_utils
+from deepface.models.FacialRecognition import FacialRecognition
+from deepface.commons import logger as log
+
+logger = log.get_singletonish_logger()
+
+tf_version = package_utils.get_tf_major_version()
+
+if tf_version == 1:
+    from keras.models import Model
+    from keras.layers import (
+        Conv2D,
+        Activation,
+        Input,
+        Add,
+        MaxPooling2D,
+        Flatten,
+        Dense,
+        Dropout,
+    )
+else:
+    from tensorflow.keras.models import Model
+    from tensorflow.keras.layers import (
+        Conv2D,
+        Activation,
+        Input,
+        Add,
+        MaxPooling2D,
+        Flatten,
+        Dense,
+        Dropout,
+    )
+
+# pylint: disable=line-too-long
+
+
+# -------------------------------------
+
+# pylint: disable=too-few-public-methods
+class DeepIdClient(FacialRecognition):
+    """
+    DeepId model class
+    """
+
+    def __init__(self):
+        self.model = load_model()
+        self.model_name = "DeepId"
+        self.input_shape = (47, 55)
+        self.output_shape = 160
+
+
+def load_model(
+    url="https://github.com/serengil/deepface_models/releases/download/v1.0/deepid_keras_weights.h5",
+) -> Model:
+    """
+    Construct DeepId model, download its weights and load
+    """
+
+    myInput = Input(shape=(55, 47, 3))
+
+    x = Conv2D(20, (4, 4), name="Conv1", activation="relu", input_shape=(55, 47, 3))(myInput)
+    x = MaxPooling2D(pool_size=2, strides=2, name="Pool1")(x)
+    x = Dropout(rate=0.99, name="D1")(x)
+
+    x = Conv2D(40, (3, 3), name="Conv2", activation="relu")(x)
+    x = MaxPooling2D(pool_size=2, strides=2, name="Pool2")(x)
+    x = Dropout(rate=0.99, name="D2")(x)
+
+    x = Conv2D(60, (3, 3), name="Conv3", activation="relu")(x)
+    x = MaxPooling2D(pool_size=2, strides=2, name="Pool3")(x)
+    x = Dropout(rate=0.99, name="D3")(x)
+
+    x1 = Flatten()(x)
+    fc11 = Dense(160, name="fc11")(x1)
+
+    x2 = Conv2D(80, (2, 2), name="Conv4", activation="relu")(x)
+    x2 = Flatten()(x2)
+    fc12 = Dense(160, name="fc12")(x2)
+
+    y = Add()([fc11, fc12])
+    y = Activation("relu", name="deepid")(y)
+
+    model = Model(inputs=[myInput], outputs=y)
+
+    # ---------------------------------
+
+    home = folder_utils.get_deepface_home()
+
+    if os.path.isfile(home + "/.deepface/weights/deepid_keras_weights.h5") != True:
+        logger.info("deepid_keras_weights.h5 will be downloaded...")
+
+        output = home + "/.deepface/weights/deepid_keras_weights.h5"
+        gdown.download(url, output, quiet=False)
+
+    model.load_weights(home + "/.deepface/weights/deepid_keras_weights.h5")
+
+    return model
diff --git a/basemodels/Dlib.py b/basemodels/Dlib.py
new file mode 100644
index 0000000000000000000000000000000000000000..f13b7cad1f4c79c5f805b0da4d5fc3a03ee82f7f
--- /dev/null
+++ b/basemodels/Dlib.py
@@ -0,0 +1,89 @@
+from typing import List
+import os
+import bz2
+import gdown
+import numpy as np
+from deepface.commons import folder_utils
+from deepface.models.FacialRecognition import FacialRecognition
+from deepface.commons import logger as log
+
+logger = log.get_singletonish_logger()
+
+# pylint: disable=too-few-public-methods
+
+
+class DlibClient(FacialRecognition):
+    """
+    Dlib model class
+    """
+
+    def __init__(self):
+        self.model = DlibResNet()
+        self.model_name = "Dlib"
+        self.input_shape = (150, 150)
+        self.output_shape = 128
+
+    def forward(self, img: np.ndarray) -> List[float]:
+        """
+        Find embeddings with Dlib model.
+            This model necessitates the override of the forward method
+            because it is not a keras model.
+        Args:
+            img (np.ndarray): pre-loaded image in BGR
+        Returns
+            embeddings (list): multi-dimensional vector
+        """
+        # return self.model.predict(img)[0].tolist()
+
+        # extract_faces returns 4 dimensional images
+        if len(img.shape) == 4:
+            img = img[0]
+
+        # bgr to rgb
+        img = img[:, :, ::-1]  # bgr to rgb
+
+        # img is in scale of [0, 1] but expected [0, 255]
+        if img.max() <= 1:
+            img = img * 255
+
+        img = img.astype(np.uint8)
+
+        img_representation = self.model.model.compute_face_descriptor(img)
+        img_representation = np.array(img_representation)
+        img_representation = np.expand_dims(img_representation, axis=0)
+        return img_representation[0].tolist()
+
+
+class DlibResNet:
+    def __init__(self):
+
+        ## this is not a must dependency. do not import it in the global level.
+        try:
+            import dlib
+        except ModuleNotFoundError as e:
+            raise ImportError(
+                "Dlib is an optional dependency, ensure the library is installed."
+                "Please install using 'pip install dlib' "
+            ) from e
+
+        home = folder_utils.get_deepface_home()
+        weight_file = home + "/.deepface/weights/dlib_face_recognition_resnet_model_v1.dat"
+
+        # download pre-trained model if it does not exist
+        if os.path.isfile(weight_file) != True:
+            logger.info("dlib_face_recognition_resnet_model_v1.dat is going to be downloaded")
+
+            file_name = "dlib_face_recognition_resnet_model_v1.dat.bz2"
+            url = f"http://dlib.net/files/{file_name}"
+            output = f"{home}/.deepface/weights/{file_name}"
+            gdown.download(url, output, quiet=False)
+
+            zipfile = bz2.BZ2File(output)
+            data = zipfile.read()
+            newfilepath = output[:-4]  # discard .bz2 extension
+            with open(newfilepath, "wb") as f:
+                f.write(data)
+
+        self.model = dlib.face_recognition_model_v1(weight_file)
+
+        # return None  # classes must return None
diff --git a/basemodels/Facenet.py b/basemodels/Facenet.py
new file mode 100644
index 0000000000000000000000000000000000000000..bcbb7b718fcb995663876ad7c22c614e4f77e5c8
--- /dev/null
+++ b/basemodels/Facenet.py
@@ -0,0 +1,1715 @@
+import os
+import gdown
+from deepface.commons import package_utils, folder_utils
+from deepface.models.FacialRecognition import FacialRecognition
+from deepface.commons import logger as log
+
+logger = log.get_singletonish_logger()
+
+# --------------------------------
+# dependency configuration
+
+tf_version = package_utils.get_tf_major_version()
+
+if tf_version == 1:
+    from keras.models import Model
+    from keras.layers import Activation
+    from keras.layers import BatchNormalization
+    from keras.layers import Concatenate
+    from keras.layers import Conv2D
+    from keras.layers import Dense
+    from keras.layers import Dropout
+    from keras.layers import GlobalAveragePooling2D
+    from keras.layers import Input
+    from keras.layers import Lambda
+    from keras.layers import MaxPooling2D
+    from keras.layers import add
+    from keras import backend as K
+else:
+    from tensorflow.keras.models import Model
+    from tensorflow.keras.layers import Activation
+    from tensorflow.keras.layers import BatchNormalization
+    from tensorflow.keras.layers import Concatenate
+    from tensorflow.keras.layers import Conv2D
+    from tensorflow.keras.layers import Dense
+    from tensorflow.keras.layers import Dropout
+    from tensorflow.keras.layers import GlobalAveragePooling2D
+    from tensorflow.keras.layers import Input
+    from tensorflow.keras.layers import Lambda
+    from tensorflow.keras.layers import MaxPooling2D
+    from tensorflow.keras.layers import add
+    from tensorflow.keras import backend as K
+
+# --------------------------------
+
+# pylint: disable=too-few-public-methods
+class FaceNet128dClient(FacialRecognition):
+    """
+    FaceNet-128d model class
+    """
+
+    def __init__(self):
+        self.model = load_facenet128d_model()
+        self.model_name = "FaceNet-128d"
+        self.input_shape = (160, 160)
+        self.output_shape = 128
+
+
+class FaceNet512dClient(FacialRecognition):
+    """
+    FaceNet-1512d model class
+    """
+
+    def __init__(self):
+        self.model = load_facenet512d_model()
+        self.model_name = "FaceNet-512d"
+        self.input_shape = (160, 160)
+        self.output_shape = 512
+
+
+def scaling(x, scale):
+    return x * scale
+
+
+def InceptionResNetV1(dimension: int = 128) -> Model:
+    """
+    InceptionResNetV1 model heavily inspired from
+    github.com/davidsandberg/facenet/blob/master/src/models/inception_resnet_v1.py
+    As mentioned in Sandberg's repo's readme, pre-trained models are using Inception ResNet v1
+    Besides training process is documented at
+    sefiks.com/2018/09/03/face-recognition-with-facenet-in-keras/
+
+    Args:
+        dimension (int): number of dimensions in the embedding layer
+    Returns:
+        model (Model)
+    """
+
+    inputs = Input(shape=(160, 160, 3))
+    x = Conv2D(32, 3, strides=2, padding="valid", use_bias=False, name="Conv2d_1a_3x3")(inputs)
+    x = BatchNormalization(
+        axis=3, momentum=0.995, epsilon=0.001, scale=False, name="Conv2d_1a_3x3_BatchNorm"
+    )(x)
+    x = Activation("relu", name="Conv2d_1a_3x3_Activation")(x)
+    x = Conv2D(32, 3, strides=1, padding="valid", use_bias=False, name="Conv2d_2a_3x3")(x)
+    x = BatchNormalization(
+        axis=3, momentum=0.995, epsilon=0.001, scale=False, name="Conv2d_2a_3x3_BatchNorm"
+    )(x)
+    x = Activation("relu", name="Conv2d_2a_3x3_Activation")(x)
+    x = Conv2D(64, 3, strides=1, padding="same", use_bias=False, name="Conv2d_2b_3x3")(x)
+    x = BatchNormalization(
+        axis=3, momentum=0.995, epsilon=0.001, scale=False, name="Conv2d_2b_3x3_BatchNorm"
+    )(x)
+    x = Activation("relu", name="Conv2d_2b_3x3_Activation")(x)
+    x = MaxPooling2D(3, strides=2, name="MaxPool_3a_3x3")(x)
+    x = Conv2D(80, 1, strides=1, padding="valid", use_bias=False, name="Conv2d_3b_1x1")(x)
+    x = BatchNormalization(
+        axis=3, momentum=0.995, epsilon=0.001, scale=False, name="Conv2d_3b_1x1_BatchNorm"
+    )(x)
+    x = Activation("relu", name="Conv2d_3b_1x1_Activation")(x)
+    x = Conv2D(192, 3, strides=1, padding="valid", use_bias=False, name="Conv2d_4a_3x3")(x)
+    x = BatchNormalization(
+        axis=3, momentum=0.995, epsilon=0.001, scale=False, name="Conv2d_4a_3x3_BatchNorm"
+    )(x)
+    x = Activation("relu", name="Conv2d_4a_3x3_Activation")(x)
+    x = Conv2D(256, 3, strides=2, padding="valid", use_bias=False, name="Conv2d_4b_3x3")(x)
+    x = BatchNormalization(
+        axis=3, momentum=0.995, epsilon=0.001, scale=False, name="Conv2d_4b_3x3_BatchNorm"
+    )(x)
+    x = Activation("relu", name="Conv2d_4b_3x3_Activation")(x)
+
+    # 5x Block35 (Inception-ResNet-A block):
+    branch_0 = Conv2D(
+        32, 1, strides=1, padding="same", use_bias=False, name="Block35_1_Branch_0_Conv2d_1x1"
+    )(x)
+    branch_0 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block35_1_Branch_0_Conv2d_1x1_BatchNorm",
+    )(branch_0)
+    branch_0 = Activation("relu", name="Block35_1_Branch_0_Conv2d_1x1_Activation")(branch_0)
+    branch_1 = Conv2D(
+        32, 1, strides=1, padding="same", use_bias=False, name="Block35_1_Branch_1_Conv2d_0a_1x1"
+    )(x)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block35_1_Branch_1_Conv2d_0a_1x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block35_1_Branch_1_Conv2d_0a_1x1_Activation")(branch_1)
+    branch_1 = Conv2D(
+        32, 3, strides=1, padding="same", use_bias=False, name="Block35_1_Branch_1_Conv2d_0b_3x3"
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block35_1_Branch_1_Conv2d_0b_3x3_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block35_1_Branch_1_Conv2d_0b_3x3_Activation")(branch_1)
+    branch_2 = Conv2D(
+        32, 1, strides=1, padding="same", use_bias=False, name="Block35_1_Branch_2_Conv2d_0a_1x1"
+    )(x)
+    branch_2 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block35_1_Branch_2_Conv2d_0a_1x1_BatchNorm",
+    )(branch_2)
+    branch_2 = Activation("relu", name="Block35_1_Branch_2_Conv2d_0a_1x1_Activation")(branch_2)
+    branch_2 = Conv2D(
+        32, 3, strides=1, padding="same", use_bias=False, name="Block35_1_Branch_2_Conv2d_0b_3x3"
+    )(branch_2)
+    branch_2 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block35_1_Branch_2_Conv2d_0b_3x3_BatchNorm",
+    )(branch_2)
+    branch_2 = Activation("relu", name="Block35_1_Branch_2_Conv2d_0b_3x3_Activation")(branch_2)
+    branch_2 = Conv2D(
+        32, 3, strides=1, padding="same", use_bias=False, name="Block35_1_Branch_2_Conv2d_0c_3x3"
+    )(branch_2)
+    branch_2 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block35_1_Branch_2_Conv2d_0c_3x3_BatchNorm",
+    )(branch_2)
+    branch_2 = Activation("relu", name="Block35_1_Branch_2_Conv2d_0c_3x3_Activation")(branch_2)
+    branches = [branch_0, branch_1, branch_2]
+    mixed = Concatenate(axis=3, name="Block35_1_Concatenate")(branches)
+    up = Conv2D(256, 1, strides=1, padding="same", use_bias=True, name="Block35_1_Conv2d_1x1")(
+        mixed
+    )
+    up = Lambda(scaling, output_shape=K.int_shape(up)[1:], arguments={"scale": 0.17})(up)
+    x = add([x, up])
+    x = Activation("relu", name="Block35_1_Activation")(x)
+
+    branch_0 = Conv2D(
+        32, 1, strides=1, padding="same", use_bias=False, name="Block35_2_Branch_0_Conv2d_1x1"
+    )(x)
+    branch_0 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block35_2_Branch_0_Conv2d_1x1_BatchNorm",
+    )(branch_0)
+    branch_0 = Activation("relu", name="Block35_2_Branch_0_Conv2d_1x1_Activation")(branch_0)
+    branch_1 = Conv2D(
+        32, 1, strides=1, padding="same", use_bias=False, name="Block35_2_Branch_1_Conv2d_0a_1x1"
+    )(x)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block35_2_Branch_1_Conv2d_0a_1x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block35_2_Branch_1_Conv2d_0a_1x1_Activation")(branch_1)
+    branch_1 = Conv2D(
+        32, 3, strides=1, padding="same", use_bias=False, name="Block35_2_Branch_1_Conv2d_0b_3x3"
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block35_2_Branch_1_Conv2d_0b_3x3_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block35_2_Branch_1_Conv2d_0b_3x3_Activation")(branch_1)
+    branch_2 = Conv2D(
+        32, 1, strides=1, padding="same", use_bias=False, name="Block35_2_Branch_2_Conv2d_0a_1x1"
+    )(x)
+    branch_2 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block35_2_Branch_2_Conv2d_0a_1x1_BatchNorm",
+    )(branch_2)
+    branch_2 = Activation("relu", name="Block35_2_Branch_2_Conv2d_0a_1x1_Activation")(branch_2)
+    branch_2 = Conv2D(
+        32, 3, strides=1, padding="same", use_bias=False, name="Block35_2_Branch_2_Conv2d_0b_3x3"
+    )(branch_2)
+    branch_2 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block35_2_Branch_2_Conv2d_0b_3x3_BatchNorm",
+    )(branch_2)
+    branch_2 = Activation("relu", name="Block35_2_Branch_2_Conv2d_0b_3x3_Activation")(branch_2)
+    branch_2 = Conv2D(
+        32, 3, strides=1, padding="same", use_bias=False, name="Block35_2_Branch_2_Conv2d_0c_3x3"
+    )(branch_2)
+    branch_2 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block35_2_Branch_2_Conv2d_0c_3x3_BatchNorm",
+    )(branch_2)
+    branch_2 = Activation("relu", name="Block35_2_Branch_2_Conv2d_0c_3x3_Activation")(branch_2)
+    branches = [branch_0, branch_1, branch_2]
+    mixed = Concatenate(axis=3, name="Block35_2_Concatenate")(branches)
+    up = Conv2D(256, 1, strides=1, padding="same", use_bias=True, name="Block35_2_Conv2d_1x1")(
+        mixed
+    )
+    up = Lambda(scaling, output_shape=K.int_shape(up)[1:], arguments={"scale": 0.17})(up)
+    x = add([x, up])
+    x = Activation("relu", name="Block35_2_Activation")(x)
+
+    branch_0 = Conv2D(
+        32, 1, strides=1, padding="same", use_bias=False, name="Block35_3_Branch_0_Conv2d_1x1"
+    )(x)
+    branch_0 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block35_3_Branch_0_Conv2d_1x1_BatchNorm",
+    )(branch_0)
+    branch_0 = Activation("relu", name="Block35_3_Branch_0_Conv2d_1x1_Activation")(branch_0)
+    branch_1 = Conv2D(
+        32, 1, strides=1, padding="same", use_bias=False, name="Block35_3_Branch_1_Conv2d_0a_1x1"
+    )(x)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block35_3_Branch_1_Conv2d_0a_1x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block35_3_Branch_1_Conv2d_0a_1x1_Activation")(branch_1)
+    branch_1 = Conv2D(
+        32, 3, strides=1, padding="same", use_bias=False, name="Block35_3_Branch_1_Conv2d_0b_3x3"
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block35_3_Branch_1_Conv2d_0b_3x3_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block35_3_Branch_1_Conv2d_0b_3x3_Activation")(branch_1)
+    branch_2 = Conv2D(
+        32, 1, strides=1, padding="same", use_bias=False, name="Block35_3_Branch_2_Conv2d_0a_1x1"
+    )(x)
+    branch_2 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block35_3_Branch_2_Conv2d_0a_1x1_BatchNorm",
+    )(branch_2)
+    branch_2 = Activation("relu", name="Block35_3_Branch_2_Conv2d_0a_1x1_Activation")(branch_2)
+    branch_2 = Conv2D(
+        32, 3, strides=1, padding="same", use_bias=False, name="Block35_3_Branch_2_Conv2d_0b_3x3"
+    )(branch_2)
+    branch_2 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block35_3_Branch_2_Conv2d_0b_3x3_BatchNorm",
+    )(branch_2)
+    branch_2 = Activation("relu", name="Block35_3_Branch_2_Conv2d_0b_3x3_Activation")(branch_2)
+    branch_2 = Conv2D(
+        32, 3, strides=1, padding="same", use_bias=False, name="Block35_3_Branch_2_Conv2d_0c_3x3"
+    )(branch_2)
+    branch_2 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block35_3_Branch_2_Conv2d_0c_3x3_BatchNorm",
+    )(branch_2)
+    branch_2 = Activation("relu", name="Block35_3_Branch_2_Conv2d_0c_3x3_Activation")(branch_2)
+    branches = [branch_0, branch_1, branch_2]
+    mixed = Concatenate(axis=3, name="Block35_3_Concatenate")(branches)
+    up = Conv2D(256, 1, strides=1, padding="same", use_bias=True, name="Block35_3_Conv2d_1x1")(
+        mixed
+    )
+    up = Lambda(scaling, output_shape=K.int_shape(up)[1:], arguments={"scale": 0.17})(up)
+    x = add([x, up])
+    x = Activation("relu", name="Block35_3_Activation")(x)
+
+    branch_0 = Conv2D(
+        32, 1, strides=1, padding="same", use_bias=False, name="Block35_4_Branch_0_Conv2d_1x1"
+    )(x)
+    branch_0 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block35_4_Branch_0_Conv2d_1x1_BatchNorm",
+    )(branch_0)
+    branch_0 = Activation("relu", name="Block35_4_Branch_0_Conv2d_1x1_Activation")(branch_0)
+    branch_1 = Conv2D(
+        32, 1, strides=1, padding="same", use_bias=False, name="Block35_4_Branch_1_Conv2d_0a_1x1"
+    )(x)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block35_4_Branch_1_Conv2d_0a_1x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block35_4_Branch_1_Conv2d_0a_1x1_Activation")(branch_1)
+    branch_1 = Conv2D(
+        32, 3, strides=1, padding="same", use_bias=False, name="Block35_4_Branch_1_Conv2d_0b_3x3"
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block35_4_Branch_1_Conv2d_0b_3x3_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block35_4_Branch_1_Conv2d_0b_3x3_Activation")(branch_1)
+    branch_2 = Conv2D(
+        32, 1, strides=1, padding="same", use_bias=False, name="Block35_4_Branch_2_Conv2d_0a_1x1"
+    )(x)
+    branch_2 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block35_4_Branch_2_Conv2d_0a_1x1_BatchNorm",
+    )(branch_2)
+    branch_2 = Activation("relu", name="Block35_4_Branch_2_Conv2d_0a_1x1_Activation")(branch_2)
+    branch_2 = Conv2D(
+        32, 3, strides=1, padding="same", use_bias=False, name="Block35_4_Branch_2_Conv2d_0b_3x3"
+    )(branch_2)
+    branch_2 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block35_4_Branch_2_Conv2d_0b_3x3_BatchNorm",
+    )(branch_2)
+    branch_2 = Activation("relu", name="Block35_4_Branch_2_Conv2d_0b_3x3_Activation")(branch_2)
+    branch_2 = Conv2D(
+        32, 3, strides=1, padding="same", use_bias=False, name="Block35_4_Branch_2_Conv2d_0c_3x3"
+    )(branch_2)
+    branch_2 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block35_4_Branch_2_Conv2d_0c_3x3_BatchNorm",
+    )(branch_2)
+    branch_2 = Activation("relu", name="Block35_4_Branch_2_Conv2d_0c_3x3_Activation")(branch_2)
+    branches = [branch_0, branch_1, branch_2]
+    mixed = Concatenate(axis=3, name="Block35_4_Concatenate")(branches)
+    up = Conv2D(256, 1, strides=1, padding="same", use_bias=True, name="Block35_4_Conv2d_1x1")(
+        mixed
+    )
+    up = Lambda(scaling, output_shape=K.int_shape(up)[1:], arguments={"scale": 0.17})(up)
+    x = add([x, up])
+    x = Activation("relu", name="Block35_4_Activation")(x)
+
+    branch_0 = Conv2D(
+        32, 1, strides=1, padding="same", use_bias=False, name="Block35_5_Branch_0_Conv2d_1x1"
+    )(x)
+    branch_0 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block35_5_Branch_0_Conv2d_1x1_BatchNorm",
+    )(branch_0)
+    branch_0 = Activation("relu", name="Block35_5_Branch_0_Conv2d_1x1_Activation")(branch_0)
+    branch_1 = Conv2D(
+        32, 1, strides=1, padding="same", use_bias=False, name="Block35_5_Branch_1_Conv2d_0a_1x1"
+    )(x)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block35_5_Branch_1_Conv2d_0a_1x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block35_5_Branch_1_Conv2d_0a_1x1_Activation")(branch_1)
+    branch_1 = Conv2D(
+        32, 3, strides=1, padding="same", use_bias=False, name="Block35_5_Branch_1_Conv2d_0b_3x3"
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block35_5_Branch_1_Conv2d_0b_3x3_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block35_5_Branch_1_Conv2d_0b_3x3_Activation")(branch_1)
+    branch_2 = Conv2D(
+        32, 1, strides=1, padding="same", use_bias=False, name="Block35_5_Branch_2_Conv2d_0a_1x1"
+    )(x)
+    branch_2 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block35_5_Branch_2_Conv2d_0a_1x1_BatchNorm",
+    )(branch_2)
+    branch_2 = Activation("relu", name="Block35_5_Branch_2_Conv2d_0a_1x1_Activation")(branch_2)
+    branch_2 = Conv2D(
+        32, 3, strides=1, padding="same", use_bias=False, name="Block35_5_Branch_2_Conv2d_0b_3x3"
+    )(branch_2)
+    branch_2 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block35_5_Branch_2_Conv2d_0b_3x3_BatchNorm",
+    )(branch_2)
+    branch_2 = Activation("relu", name="Block35_5_Branch_2_Conv2d_0b_3x3_Activation")(branch_2)
+    branch_2 = Conv2D(
+        32, 3, strides=1, padding="same", use_bias=False, name="Block35_5_Branch_2_Conv2d_0c_3x3"
+    )(branch_2)
+    branch_2 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block35_5_Branch_2_Conv2d_0c_3x3_BatchNorm",
+    )(branch_2)
+    branch_2 = Activation("relu", name="Block35_5_Branch_2_Conv2d_0c_3x3_Activation")(branch_2)
+    branches = [branch_0, branch_1, branch_2]
+    mixed = Concatenate(axis=3, name="Block35_5_Concatenate")(branches)
+    up = Conv2D(256, 1, strides=1, padding="same", use_bias=True, name="Block35_5_Conv2d_1x1")(
+        mixed
+    )
+    up = Lambda(scaling, output_shape=K.int_shape(up)[1:], arguments={"scale": 0.17})(up)
+    x = add([x, up])
+    x = Activation("relu", name="Block35_5_Activation")(x)
+
+    # Mixed 6a (Reduction-A block):
+    branch_0 = Conv2D(
+        384, 3, strides=2, padding="valid", use_bias=False, name="Mixed_6a_Branch_0_Conv2d_1a_3x3"
+    )(x)
+    branch_0 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Mixed_6a_Branch_0_Conv2d_1a_3x3_BatchNorm",
+    )(branch_0)
+    branch_0 = Activation("relu", name="Mixed_6a_Branch_0_Conv2d_1a_3x3_Activation")(branch_0)
+    branch_1 = Conv2D(
+        192, 1, strides=1, padding="same", use_bias=False, name="Mixed_6a_Branch_1_Conv2d_0a_1x1"
+    )(x)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Mixed_6a_Branch_1_Conv2d_0a_1x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Mixed_6a_Branch_1_Conv2d_0a_1x1_Activation")(branch_1)
+    branch_1 = Conv2D(
+        192, 3, strides=1, padding="same", use_bias=False, name="Mixed_6a_Branch_1_Conv2d_0b_3x3"
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Mixed_6a_Branch_1_Conv2d_0b_3x3_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Mixed_6a_Branch_1_Conv2d_0b_3x3_Activation")(branch_1)
+    branch_1 = Conv2D(
+        256, 3, strides=2, padding="valid", use_bias=False, name="Mixed_6a_Branch_1_Conv2d_1a_3x3"
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Mixed_6a_Branch_1_Conv2d_1a_3x3_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Mixed_6a_Branch_1_Conv2d_1a_3x3_Activation")(branch_1)
+    branch_pool = MaxPooling2D(
+        3, strides=2, padding="valid", name="Mixed_6a_Branch_2_MaxPool_1a_3x3"
+    )(x)
+    branches = [branch_0, branch_1, branch_pool]
+    x = Concatenate(axis=3, name="Mixed_6a")(branches)
+
+    # 10x Block17 (Inception-ResNet-B block):
+    branch_0 = Conv2D(
+        128, 1, strides=1, padding="same", use_bias=False, name="Block17_1_Branch_0_Conv2d_1x1"
+    )(x)
+    branch_0 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_1_Branch_0_Conv2d_1x1_BatchNorm",
+    )(branch_0)
+    branch_0 = Activation("relu", name="Block17_1_Branch_0_Conv2d_1x1_Activation")(branch_0)
+    branch_1 = Conv2D(
+        128, 1, strides=1, padding="same", use_bias=False, name="Block17_1_Branch_1_Conv2d_0a_1x1"
+    )(x)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_1_Branch_1_Conv2d_0a_1x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block17_1_Branch_1_Conv2d_0a_1x1_Activation")(branch_1)
+    branch_1 = Conv2D(
+        128,
+        [1, 7],
+        strides=1,
+        padding="same",
+        use_bias=False,
+        name="Block17_1_Branch_1_Conv2d_0b_1x7",
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_1_Branch_1_Conv2d_0b_1x7_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block17_1_Branch_1_Conv2d_0b_1x7_Activation")(branch_1)
+    branch_1 = Conv2D(
+        128,
+        [7, 1],
+        strides=1,
+        padding="same",
+        use_bias=False,
+        name="Block17_1_Branch_1_Conv2d_0c_7x1",
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_1_Branch_1_Conv2d_0c_7x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block17_1_Branch_1_Conv2d_0c_7x1_Activation")(branch_1)
+    branches = [branch_0, branch_1]
+    mixed = Concatenate(axis=3, name="Block17_1_Concatenate")(branches)
+    up = Conv2D(896, 1, strides=1, padding="same", use_bias=True, name="Block17_1_Conv2d_1x1")(
+        mixed
+    )
+    up = Lambda(scaling, output_shape=K.int_shape(up)[1:], arguments={"scale": 0.1})(up)
+    x = add([x, up])
+    x = Activation("relu", name="Block17_1_Activation")(x)
+
+    branch_0 = Conv2D(
+        128, 1, strides=1, padding="same", use_bias=False, name="Block17_2_Branch_0_Conv2d_1x1"
+    )(x)
+    branch_0 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_2_Branch_0_Conv2d_1x1_BatchNorm",
+    )(branch_0)
+    branch_0 = Activation("relu", name="Block17_2_Branch_0_Conv2d_1x1_Activation")(branch_0)
+    branch_1 = Conv2D(
+        128, 1, strides=1, padding="same", use_bias=False, name="Block17_2_Branch_2_Conv2d_0a_1x1"
+    )(x)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_2_Branch_2_Conv2d_0a_1x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block17_2_Branch_2_Conv2d_0a_1x1_Activation")(branch_1)
+    branch_1 = Conv2D(
+        128,
+        [1, 7],
+        strides=1,
+        padding="same",
+        use_bias=False,
+        name="Block17_2_Branch_2_Conv2d_0b_1x7",
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_2_Branch_2_Conv2d_0b_1x7_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block17_2_Branch_2_Conv2d_0b_1x7_Activation")(branch_1)
+    branch_1 = Conv2D(
+        128,
+        [7, 1],
+        strides=1,
+        padding="same",
+        use_bias=False,
+        name="Block17_2_Branch_2_Conv2d_0c_7x1",
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_2_Branch_2_Conv2d_0c_7x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block17_2_Branch_2_Conv2d_0c_7x1_Activation")(branch_1)
+    branches = [branch_0, branch_1]
+    mixed = Concatenate(axis=3, name="Block17_2_Concatenate")(branches)
+    up = Conv2D(896, 1, strides=1, padding="same", use_bias=True, name="Block17_2_Conv2d_1x1")(
+        mixed
+    )
+    up = Lambda(scaling, output_shape=K.int_shape(up)[1:], arguments={"scale": 0.1})(up)
+    x = add([x, up])
+    x = Activation("relu", name="Block17_2_Activation")(x)
+
+    branch_0 = Conv2D(
+        128, 1, strides=1, padding="same", use_bias=False, name="Block17_3_Branch_0_Conv2d_1x1"
+    )(x)
+    branch_0 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_3_Branch_0_Conv2d_1x1_BatchNorm",
+    )(branch_0)
+    branch_0 = Activation("relu", name="Block17_3_Branch_0_Conv2d_1x1_Activation")(branch_0)
+    branch_1 = Conv2D(
+        128, 1, strides=1, padding="same", use_bias=False, name="Block17_3_Branch_3_Conv2d_0a_1x1"
+    )(x)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_3_Branch_3_Conv2d_0a_1x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block17_3_Branch_3_Conv2d_0a_1x1_Activation")(branch_1)
+    branch_1 = Conv2D(
+        128,
+        [1, 7],
+        strides=1,
+        padding="same",
+        use_bias=False,
+        name="Block17_3_Branch_3_Conv2d_0b_1x7",
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_3_Branch_3_Conv2d_0b_1x7_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block17_3_Branch_3_Conv2d_0b_1x7_Activation")(branch_1)
+    branch_1 = Conv2D(
+        128,
+        [7, 1],
+        strides=1,
+        padding="same",
+        use_bias=False,
+        name="Block17_3_Branch_3_Conv2d_0c_7x1",
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_3_Branch_3_Conv2d_0c_7x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block17_3_Branch_3_Conv2d_0c_7x1_Activation")(branch_1)
+    branches = [branch_0, branch_1]
+    mixed = Concatenate(axis=3, name="Block17_3_Concatenate")(branches)
+    up = Conv2D(896, 1, strides=1, padding="same", use_bias=True, name="Block17_3_Conv2d_1x1")(
+        mixed
+    )
+    up = Lambda(scaling, output_shape=K.int_shape(up)[1:], arguments={"scale": 0.1})(up)
+    x = add([x, up])
+    x = Activation("relu", name="Block17_3_Activation")(x)
+
+    branch_0 = Conv2D(
+        128, 1, strides=1, padding="same", use_bias=False, name="Block17_4_Branch_0_Conv2d_1x1"
+    )(x)
+    branch_0 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_4_Branch_0_Conv2d_1x1_BatchNorm",
+    )(branch_0)
+    branch_0 = Activation("relu", name="Block17_4_Branch_0_Conv2d_1x1_Activation")(branch_0)
+    branch_1 = Conv2D(
+        128, 1, strides=1, padding="same", use_bias=False, name="Block17_4_Branch_4_Conv2d_0a_1x1"
+    )(x)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_4_Branch_4_Conv2d_0a_1x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block17_4_Branch_4_Conv2d_0a_1x1_Activation")(branch_1)
+    branch_1 = Conv2D(
+        128,
+        [1, 7],
+        strides=1,
+        padding="same",
+        use_bias=False,
+        name="Block17_4_Branch_4_Conv2d_0b_1x7",
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_4_Branch_4_Conv2d_0b_1x7_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block17_4_Branch_4_Conv2d_0b_1x7_Activation")(branch_1)
+    branch_1 = Conv2D(
+        128,
+        [7, 1],
+        strides=1,
+        padding="same",
+        use_bias=False,
+        name="Block17_4_Branch_4_Conv2d_0c_7x1",
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_4_Branch_4_Conv2d_0c_7x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block17_4_Branch_4_Conv2d_0c_7x1_Activation")(branch_1)
+    branches = [branch_0, branch_1]
+    mixed = Concatenate(axis=3, name="Block17_4_Concatenate")(branches)
+    up = Conv2D(896, 1, strides=1, padding="same", use_bias=True, name="Block17_4_Conv2d_1x1")(
+        mixed
+    )
+    up = Lambda(scaling, output_shape=K.int_shape(up)[1:], arguments={"scale": 0.1})(up)
+    x = add([x, up])
+    x = Activation("relu", name="Block17_4_Activation")(x)
+
+    branch_0 = Conv2D(
+        128, 1, strides=1, padding="same", use_bias=False, name="Block17_5_Branch_0_Conv2d_1x1"
+    )(x)
+    branch_0 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_5_Branch_0_Conv2d_1x1_BatchNorm",
+    )(branch_0)
+    branch_0 = Activation("relu", name="Block17_5_Branch_0_Conv2d_1x1_Activation")(branch_0)
+    branch_1 = Conv2D(
+        128, 1, strides=1, padding="same", use_bias=False, name="Block17_5_Branch_5_Conv2d_0a_1x1"
+    )(x)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_5_Branch_5_Conv2d_0a_1x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block17_5_Branch_5_Conv2d_0a_1x1_Activation")(branch_1)
+    branch_1 = Conv2D(
+        128,
+        [1, 7],
+        strides=1,
+        padding="same",
+        use_bias=False,
+        name="Block17_5_Branch_5_Conv2d_0b_1x7",
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_5_Branch_5_Conv2d_0b_1x7_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block17_5_Branch_5_Conv2d_0b_1x7_Activation")(branch_1)
+    branch_1 = Conv2D(
+        128,
+        [7, 1],
+        strides=1,
+        padding="same",
+        use_bias=False,
+        name="Block17_5_Branch_5_Conv2d_0c_7x1",
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_5_Branch_5_Conv2d_0c_7x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block17_5_Branch_5_Conv2d_0c_7x1_Activation")(branch_1)
+    branches = [branch_0, branch_1]
+    mixed = Concatenate(axis=3, name="Block17_5_Concatenate")(branches)
+    up = Conv2D(896, 1, strides=1, padding="same", use_bias=True, name="Block17_5_Conv2d_1x1")(
+        mixed
+    )
+    up = Lambda(scaling, output_shape=K.int_shape(up)[1:], arguments={"scale": 0.1})(up)
+    x = add([x, up])
+    x = Activation("relu", name="Block17_5_Activation")(x)
+
+    branch_0 = Conv2D(
+        128, 1, strides=1, padding="same", use_bias=False, name="Block17_6_Branch_0_Conv2d_1x1"
+    )(x)
+    branch_0 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_6_Branch_0_Conv2d_1x1_BatchNorm",
+    )(branch_0)
+    branch_0 = Activation("relu", name="Block17_6_Branch_0_Conv2d_1x1_Activation")(branch_0)
+    branch_1 = Conv2D(
+        128, 1, strides=1, padding="same", use_bias=False, name="Block17_6_Branch_6_Conv2d_0a_1x1"
+    )(x)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_6_Branch_6_Conv2d_0a_1x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block17_6_Branch_6_Conv2d_0a_1x1_Activation")(branch_1)
+    branch_1 = Conv2D(
+        128,
+        [1, 7],
+        strides=1,
+        padding="same",
+        use_bias=False,
+        name="Block17_6_Branch_6_Conv2d_0b_1x7",
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_6_Branch_6_Conv2d_0b_1x7_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block17_6_Branch_6_Conv2d_0b_1x7_Activation")(branch_1)
+    branch_1 = Conv2D(
+        128,
+        [7, 1],
+        strides=1,
+        padding="same",
+        use_bias=False,
+        name="Block17_6_Branch_6_Conv2d_0c_7x1",
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_6_Branch_6_Conv2d_0c_7x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block17_6_Branch_6_Conv2d_0c_7x1_Activation")(branch_1)
+    branches = [branch_0, branch_1]
+    mixed = Concatenate(axis=3, name="Block17_6_Concatenate")(branches)
+    up = Conv2D(896, 1, strides=1, padding="same", use_bias=True, name="Block17_6_Conv2d_1x1")(
+        mixed
+    )
+    up = Lambda(scaling, output_shape=K.int_shape(up)[1:], arguments={"scale": 0.1})(up)
+    x = add([x, up])
+    x = Activation("relu", name="Block17_6_Activation")(x)
+
+    branch_0 = Conv2D(
+        128, 1, strides=1, padding="same", use_bias=False, name="Block17_7_Branch_0_Conv2d_1x1"
+    )(x)
+    branch_0 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_7_Branch_0_Conv2d_1x1_BatchNorm",
+    )(branch_0)
+    branch_0 = Activation("relu", name="Block17_7_Branch_0_Conv2d_1x1_Activation")(branch_0)
+    branch_1 = Conv2D(
+        128, 1, strides=1, padding="same", use_bias=False, name="Block17_7_Branch_7_Conv2d_0a_1x1"
+    )(x)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_7_Branch_7_Conv2d_0a_1x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block17_7_Branch_7_Conv2d_0a_1x1_Activation")(branch_1)
+    branch_1 = Conv2D(
+        128,
+        [1, 7],
+        strides=1,
+        padding="same",
+        use_bias=False,
+        name="Block17_7_Branch_7_Conv2d_0b_1x7",
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_7_Branch_7_Conv2d_0b_1x7_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block17_7_Branch_7_Conv2d_0b_1x7_Activation")(branch_1)
+    branch_1 = Conv2D(
+        128,
+        [7, 1],
+        strides=1,
+        padding="same",
+        use_bias=False,
+        name="Block17_7_Branch_7_Conv2d_0c_7x1",
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_7_Branch_7_Conv2d_0c_7x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block17_7_Branch_7_Conv2d_0c_7x1_Activation")(branch_1)
+    branches = [branch_0, branch_1]
+    mixed = Concatenate(axis=3, name="Block17_7_Concatenate")(branches)
+    up = Conv2D(896, 1, strides=1, padding="same", use_bias=True, name="Block17_7_Conv2d_1x1")(
+        mixed
+    )
+    up = Lambda(scaling, output_shape=K.int_shape(up)[1:], arguments={"scale": 0.1})(up)
+    x = add([x, up])
+    x = Activation("relu", name="Block17_7_Activation")(x)
+
+    branch_0 = Conv2D(
+        128, 1, strides=1, padding="same", use_bias=False, name="Block17_8_Branch_0_Conv2d_1x1"
+    )(x)
+    branch_0 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_8_Branch_0_Conv2d_1x1_BatchNorm",
+    )(branch_0)
+    branch_0 = Activation("relu", name="Block17_8_Branch_0_Conv2d_1x1_Activation")(branch_0)
+    branch_1 = Conv2D(
+        128, 1, strides=1, padding="same", use_bias=False, name="Block17_8_Branch_8_Conv2d_0a_1x1"
+    )(x)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_8_Branch_8_Conv2d_0a_1x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block17_8_Branch_8_Conv2d_0a_1x1_Activation")(branch_1)
+    branch_1 = Conv2D(
+        128,
+        [1, 7],
+        strides=1,
+        padding="same",
+        use_bias=False,
+        name="Block17_8_Branch_8_Conv2d_0b_1x7",
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_8_Branch_8_Conv2d_0b_1x7_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block17_8_Branch_8_Conv2d_0b_1x7_Activation")(branch_1)
+    branch_1 = Conv2D(
+        128,
+        [7, 1],
+        strides=1,
+        padding="same",
+        use_bias=False,
+        name="Block17_8_Branch_8_Conv2d_0c_7x1",
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_8_Branch_8_Conv2d_0c_7x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block17_8_Branch_8_Conv2d_0c_7x1_Activation")(branch_1)
+    branches = [branch_0, branch_1]
+    mixed = Concatenate(axis=3, name="Block17_8_Concatenate")(branches)
+    up = Conv2D(896, 1, strides=1, padding="same", use_bias=True, name="Block17_8_Conv2d_1x1")(
+        mixed
+    )
+    up = Lambda(scaling, output_shape=K.int_shape(up)[1:], arguments={"scale": 0.1})(up)
+    x = add([x, up])
+    x = Activation("relu", name="Block17_8_Activation")(x)
+
+    branch_0 = Conv2D(
+        128, 1, strides=1, padding="same", use_bias=False, name="Block17_9_Branch_0_Conv2d_1x1"
+    )(x)
+    branch_0 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_9_Branch_0_Conv2d_1x1_BatchNorm",
+    )(branch_0)
+    branch_0 = Activation("relu", name="Block17_9_Branch_0_Conv2d_1x1_Activation")(branch_0)
+    branch_1 = Conv2D(
+        128, 1, strides=1, padding="same", use_bias=False, name="Block17_9_Branch_9_Conv2d_0a_1x1"
+    )(x)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_9_Branch_9_Conv2d_0a_1x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block17_9_Branch_9_Conv2d_0a_1x1_Activation")(branch_1)
+    branch_1 = Conv2D(
+        128,
+        [1, 7],
+        strides=1,
+        padding="same",
+        use_bias=False,
+        name="Block17_9_Branch_9_Conv2d_0b_1x7",
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_9_Branch_9_Conv2d_0b_1x7_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block17_9_Branch_9_Conv2d_0b_1x7_Activation")(branch_1)
+    branch_1 = Conv2D(
+        128,
+        [7, 1],
+        strides=1,
+        padding="same",
+        use_bias=False,
+        name="Block17_9_Branch_9_Conv2d_0c_7x1",
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_9_Branch_9_Conv2d_0c_7x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block17_9_Branch_9_Conv2d_0c_7x1_Activation")(branch_1)
+    branches = [branch_0, branch_1]
+    mixed = Concatenate(axis=3, name="Block17_9_Concatenate")(branches)
+    up = Conv2D(896, 1, strides=1, padding="same", use_bias=True, name="Block17_9_Conv2d_1x1")(
+        mixed
+    )
+    up = Lambda(scaling, output_shape=K.int_shape(up)[1:], arguments={"scale": 0.1})(up)
+    x = add([x, up])
+    x = Activation("relu", name="Block17_9_Activation")(x)
+
+    branch_0 = Conv2D(
+        128, 1, strides=1, padding="same", use_bias=False, name="Block17_10_Branch_0_Conv2d_1x1"
+    )(x)
+    branch_0 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_10_Branch_0_Conv2d_1x1_BatchNorm",
+    )(branch_0)
+    branch_0 = Activation("relu", name="Block17_10_Branch_0_Conv2d_1x1_Activation")(branch_0)
+    branch_1 = Conv2D(
+        128, 1, strides=1, padding="same", use_bias=False, name="Block17_10_Branch_10_Conv2d_0a_1x1"
+    )(x)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_10_Branch_10_Conv2d_0a_1x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block17_10_Branch_10_Conv2d_0a_1x1_Activation")(branch_1)
+    branch_1 = Conv2D(
+        128,
+        [1, 7],
+        strides=1,
+        padding="same",
+        use_bias=False,
+        name="Block17_10_Branch_10_Conv2d_0b_1x7",
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_10_Branch_10_Conv2d_0b_1x7_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block17_10_Branch_10_Conv2d_0b_1x7_Activation")(branch_1)
+    branch_1 = Conv2D(
+        128,
+        [7, 1],
+        strides=1,
+        padding="same",
+        use_bias=False,
+        name="Block17_10_Branch_10_Conv2d_0c_7x1",
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block17_10_Branch_10_Conv2d_0c_7x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block17_10_Branch_10_Conv2d_0c_7x1_Activation")(branch_1)
+    branches = [branch_0, branch_1]
+    mixed = Concatenate(axis=3, name="Block17_10_Concatenate")(branches)
+    up = Conv2D(896, 1, strides=1, padding="same", use_bias=True, name="Block17_10_Conv2d_1x1")(
+        mixed
+    )
+    up = Lambda(scaling, output_shape=K.int_shape(up)[1:], arguments={"scale": 0.1})(up)
+    x = add([x, up])
+    x = Activation("relu", name="Block17_10_Activation")(x)
+
+    # Mixed 7a (Reduction-B block): 8 x 8 x 2080
+    branch_0 = Conv2D(
+        256, 1, strides=1, padding="same", use_bias=False, name="Mixed_7a_Branch_0_Conv2d_0a_1x1"
+    )(x)
+    branch_0 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Mixed_7a_Branch_0_Conv2d_0a_1x1_BatchNorm",
+    )(branch_0)
+    branch_0 = Activation("relu", name="Mixed_7a_Branch_0_Conv2d_0a_1x1_Activation")(branch_0)
+    branch_0 = Conv2D(
+        384, 3, strides=2, padding="valid", use_bias=False, name="Mixed_7a_Branch_0_Conv2d_1a_3x3"
+    )(branch_0)
+    branch_0 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Mixed_7a_Branch_0_Conv2d_1a_3x3_BatchNorm",
+    )(branch_0)
+    branch_0 = Activation("relu", name="Mixed_7a_Branch_0_Conv2d_1a_3x3_Activation")(branch_0)
+    branch_1 = Conv2D(
+        256, 1, strides=1, padding="same", use_bias=False, name="Mixed_7a_Branch_1_Conv2d_0a_1x1"
+    )(x)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Mixed_7a_Branch_1_Conv2d_0a_1x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Mixed_7a_Branch_1_Conv2d_0a_1x1_Activation")(branch_1)
+    branch_1 = Conv2D(
+        256, 3, strides=2, padding="valid", use_bias=False, name="Mixed_7a_Branch_1_Conv2d_1a_3x3"
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Mixed_7a_Branch_1_Conv2d_1a_3x3_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Mixed_7a_Branch_1_Conv2d_1a_3x3_Activation")(branch_1)
+    branch_2 = Conv2D(
+        256, 1, strides=1, padding="same", use_bias=False, name="Mixed_7a_Branch_2_Conv2d_0a_1x1"
+    )(x)
+    branch_2 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Mixed_7a_Branch_2_Conv2d_0a_1x1_BatchNorm",
+    )(branch_2)
+    branch_2 = Activation("relu", name="Mixed_7a_Branch_2_Conv2d_0a_1x1_Activation")(branch_2)
+    branch_2 = Conv2D(
+        256, 3, strides=1, padding="same", use_bias=False, name="Mixed_7a_Branch_2_Conv2d_0b_3x3"
+    )(branch_2)
+    branch_2 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Mixed_7a_Branch_2_Conv2d_0b_3x3_BatchNorm",
+    )(branch_2)
+    branch_2 = Activation("relu", name="Mixed_7a_Branch_2_Conv2d_0b_3x3_Activation")(branch_2)
+    branch_2 = Conv2D(
+        256, 3, strides=2, padding="valid", use_bias=False, name="Mixed_7a_Branch_2_Conv2d_1a_3x3"
+    )(branch_2)
+    branch_2 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Mixed_7a_Branch_2_Conv2d_1a_3x3_BatchNorm",
+    )(branch_2)
+    branch_2 = Activation("relu", name="Mixed_7a_Branch_2_Conv2d_1a_3x3_Activation")(branch_2)
+    branch_pool = MaxPooling2D(
+        3, strides=2, padding="valid", name="Mixed_7a_Branch_3_MaxPool_1a_3x3"
+    )(x)
+    branches = [branch_0, branch_1, branch_2, branch_pool]
+    x = Concatenate(axis=3, name="Mixed_7a")(branches)
+
+    # 5x Block8 (Inception-ResNet-C block):
+
+    branch_0 = Conv2D(
+        192, 1, strides=1, padding="same", use_bias=False, name="Block8_1_Branch_0_Conv2d_1x1"
+    )(x)
+    branch_0 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block8_1_Branch_0_Conv2d_1x1_BatchNorm",
+    )(branch_0)
+    branch_0 = Activation("relu", name="Block8_1_Branch_0_Conv2d_1x1_Activation")(branch_0)
+    branch_1 = Conv2D(
+        192, 1, strides=1, padding="same", use_bias=False, name="Block8_1_Branch_1_Conv2d_0a_1x1"
+    )(x)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block8_1_Branch_1_Conv2d_0a_1x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block8_1_Branch_1_Conv2d_0a_1x1_Activation")(branch_1)
+    branch_1 = Conv2D(
+        192,
+        [1, 3],
+        strides=1,
+        padding="same",
+        use_bias=False,
+        name="Block8_1_Branch_1_Conv2d_0b_1x3",
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block8_1_Branch_1_Conv2d_0b_1x3_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block8_1_Branch_1_Conv2d_0b_1x3_Activation")(branch_1)
+    branch_1 = Conv2D(
+        192,
+        [3, 1],
+        strides=1,
+        padding="same",
+        use_bias=False,
+        name="Block8_1_Branch_1_Conv2d_0c_3x1",
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block8_1_Branch_1_Conv2d_0c_3x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block8_1_Branch_1_Conv2d_0c_3x1_Activation")(branch_1)
+    branches = [branch_0, branch_1]
+    mixed = Concatenate(axis=3, name="Block8_1_Concatenate")(branches)
+    up = Conv2D(1792, 1, strides=1, padding="same", use_bias=True, name="Block8_1_Conv2d_1x1")(
+        mixed
+    )
+    up = Lambda(scaling, output_shape=K.int_shape(up)[1:], arguments={"scale": 0.2})(up)
+    x = add([x, up])
+    x = Activation("relu", name="Block8_1_Activation")(x)
+
+    branch_0 = Conv2D(
+        192, 1, strides=1, padding="same", use_bias=False, name="Block8_2_Branch_0_Conv2d_1x1"
+    )(x)
+    branch_0 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block8_2_Branch_0_Conv2d_1x1_BatchNorm",
+    )(branch_0)
+    branch_0 = Activation("relu", name="Block8_2_Branch_0_Conv2d_1x1_Activation")(branch_0)
+    branch_1 = Conv2D(
+        192, 1, strides=1, padding="same", use_bias=False, name="Block8_2_Branch_2_Conv2d_0a_1x1"
+    )(x)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block8_2_Branch_2_Conv2d_0a_1x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block8_2_Branch_2_Conv2d_0a_1x1_Activation")(branch_1)
+    branch_1 = Conv2D(
+        192,
+        [1, 3],
+        strides=1,
+        padding="same",
+        use_bias=False,
+        name="Block8_2_Branch_2_Conv2d_0b_1x3",
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block8_2_Branch_2_Conv2d_0b_1x3_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block8_2_Branch_2_Conv2d_0b_1x3_Activation")(branch_1)
+    branch_1 = Conv2D(
+        192,
+        [3, 1],
+        strides=1,
+        padding="same",
+        use_bias=False,
+        name="Block8_2_Branch_2_Conv2d_0c_3x1",
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block8_2_Branch_2_Conv2d_0c_3x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block8_2_Branch_2_Conv2d_0c_3x1_Activation")(branch_1)
+    branches = [branch_0, branch_1]
+    mixed = Concatenate(axis=3, name="Block8_2_Concatenate")(branches)
+    up = Conv2D(1792, 1, strides=1, padding="same", use_bias=True, name="Block8_2_Conv2d_1x1")(
+        mixed
+    )
+    up = Lambda(scaling, output_shape=K.int_shape(up)[1:], arguments={"scale": 0.2})(up)
+    x = add([x, up])
+    x = Activation("relu", name="Block8_2_Activation")(x)
+
+    branch_0 = Conv2D(
+        192, 1, strides=1, padding="same", use_bias=False, name="Block8_3_Branch_0_Conv2d_1x1"
+    )(x)
+    branch_0 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block8_3_Branch_0_Conv2d_1x1_BatchNorm",
+    )(branch_0)
+    branch_0 = Activation("relu", name="Block8_3_Branch_0_Conv2d_1x1_Activation")(branch_0)
+    branch_1 = Conv2D(
+        192, 1, strides=1, padding="same", use_bias=False, name="Block8_3_Branch_3_Conv2d_0a_1x1"
+    )(x)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block8_3_Branch_3_Conv2d_0a_1x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block8_3_Branch_3_Conv2d_0a_1x1_Activation")(branch_1)
+    branch_1 = Conv2D(
+        192,
+        [1, 3],
+        strides=1,
+        padding="same",
+        use_bias=False,
+        name="Block8_3_Branch_3_Conv2d_0b_1x3",
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block8_3_Branch_3_Conv2d_0b_1x3_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block8_3_Branch_3_Conv2d_0b_1x3_Activation")(branch_1)
+    branch_1 = Conv2D(
+        192,
+        [3, 1],
+        strides=1,
+        padding="same",
+        use_bias=False,
+        name="Block8_3_Branch_3_Conv2d_0c_3x1",
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block8_3_Branch_3_Conv2d_0c_3x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block8_3_Branch_3_Conv2d_0c_3x1_Activation")(branch_1)
+    branches = [branch_0, branch_1]
+    mixed = Concatenate(axis=3, name="Block8_3_Concatenate")(branches)
+    up = Conv2D(1792, 1, strides=1, padding="same", use_bias=True, name="Block8_3_Conv2d_1x1")(
+        mixed
+    )
+    up = Lambda(scaling, output_shape=K.int_shape(up)[1:], arguments={"scale": 0.2})(up)
+    x = add([x, up])
+    x = Activation("relu", name="Block8_3_Activation")(x)
+
+    branch_0 = Conv2D(
+        192, 1, strides=1, padding="same", use_bias=False, name="Block8_4_Branch_0_Conv2d_1x1"
+    )(x)
+    branch_0 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block8_4_Branch_0_Conv2d_1x1_BatchNorm",
+    )(branch_0)
+    branch_0 = Activation("relu", name="Block8_4_Branch_0_Conv2d_1x1_Activation")(branch_0)
+    branch_1 = Conv2D(
+        192, 1, strides=1, padding="same", use_bias=False, name="Block8_4_Branch_4_Conv2d_0a_1x1"
+    )(x)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block8_4_Branch_4_Conv2d_0a_1x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block8_4_Branch_4_Conv2d_0a_1x1_Activation")(branch_1)
+    branch_1 = Conv2D(
+        192,
+        [1, 3],
+        strides=1,
+        padding="same",
+        use_bias=False,
+        name="Block8_4_Branch_4_Conv2d_0b_1x3",
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block8_4_Branch_4_Conv2d_0b_1x3_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block8_4_Branch_4_Conv2d_0b_1x3_Activation")(branch_1)
+    branch_1 = Conv2D(
+        192,
+        [3, 1],
+        strides=1,
+        padding="same",
+        use_bias=False,
+        name="Block8_4_Branch_4_Conv2d_0c_3x1",
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block8_4_Branch_4_Conv2d_0c_3x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block8_4_Branch_4_Conv2d_0c_3x1_Activation")(branch_1)
+    branches = [branch_0, branch_1]
+    mixed = Concatenate(axis=3, name="Block8_4_Concatenate")(branches)
+    up = Conv2D(1792, 1, strides=1, padding="same", use_bias=True, name="Block8_4_Conv2d_1x1")(
+        mixed
+    )
+    up = Lambda(scaling, output_shape=K.int_shape(up)[1:], arguments={"scale": 0.2})(up)
+    x = add([x, up])
+    x = Activation("relu", name="Block8_4_Activation")(x)
+
+    branch_0 = Conv2D(
+        192, 1, strides=1, padding="same", use_bias=False, name="Block8_5_Branch_0_Conv2d_1x1"
+    )(x)
+    branch_0 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block8_5_Branch_0_Conv2d_1x1_BatchNorm",
+    )(branch_0)
+    branch_0 = Activation("relu", name="Block8_5_Branch_0_Conv2d_1x1_Activation")(branch_0)
+    branch_1 = Conv2D(
+        192, 1, strides=1, padding="same", use_bias=False, name="Block8_5_Branch_5_Conv2d_0a_1x1"
+    )(x)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block8_5_Branch_5_Conv2d_0a_1x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block8_5_Branch_5_Conv2d_0a_1x1_Activation")(branch_1)
+    branch_1 = Conv2D(
+        192,
+        [1, 3],
+        strides=1,
+        padding="same",
+        use_bias=False,
+        name="Block8_5_Branch_5_Conv2d_0b_1x3",
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block8_5_Branch_5_Conv2d_0b_1x3_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block8_5_Branch_5_Conv2d_0b_1x3_Activation")(branch_1)
+    branch_1 = Conv2D(
+        192,
+        [3, 1],
+        strides=1,
+        padding="same",
+        use_bias=False,
+        name="Block8_5_Branch_5_Conv2d_0c_3x1",
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block8_5_Branch_5_Conv2d_0c_3x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block8_5_Branch_5_Conv2d_0c_3x1_Activation")(branch_1)
+    branches = [branch_0, branch_1]
+    mixed = Concatenate(axis=3, name="Block8_5_Concatenate")(branches)
+    up = Conv2D(1792, 1, strides=1, padding="same", use_bias=True, name="Block8_5_Conv2d_1x1")(
+        mixed
+    )
+    up = Lambda(scaling, output_shape=K.int_shape(up)[1:], arguments={"scale": 0.2})(up)
+    x = add([x, up])
+    x = Activation("relu", name="Block8_5_Activation")(x)
+
+    branch_0 = Conv2D(
+        192, 1, strides=1, padding="same", use_bias=False, name="Block8_6_Branch_0_Conv2d_1x1"
+    )(x)
+    branch_0 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block8_6_Branch_0_Conv2d_1x1_BatchNorm",
+    )(branch_0)
+    branch_0 = Activation("relu", name="Block8_6_Branch_0_Conv2d_1x1_Activation")(branch_0)
+    branch_1 = Conv2D(
+        192, 1, strides=1, padding="same", use_bias=False, name="Block8_6_Branch_1_Conv2d_0a_1x1"
+    )(x)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block8_6_Branch_1_Conv2d_0a_1x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block8_6_Branch_1_Conv2d_0a_1x1_Activation")(branch_1)
+    branch_1 = Conv2D(
+        192,
+        [1, 3],
+        strides=1,
+        padding="same",
+        use_bias=False,
+        name="Block8_6_Branch_1_Conv2d_0b_1x3",
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block8_6_Branch_1_Conv2d_0b_1x3_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block8_6_Branch_1_Conv2d_0b_1x3_Activation")(branch_1)
+    branch_1 = Conv2D(
+        192,
+        [3, 1],
+        strides=1,
+        padding="same",
+        use_bias=False,
+        name="Block8_6_Branch_1_Conv2d_0c_3x1",
+    )(branch_1)
+    branch_1 = BatchNormalization(
+        axis=3,
+        momentum=0.995,
+        epsilon=0.001,
+        scale=False,
+        name="Block8_6_Branch_1_Conv2d_0c_3x1_BatchNorm",
+    )(branch_1)
+    branch_1 = Activation("relu", name="Block8_6_Branch_1_Conv2d_0c_3x1_Activation")(branch_1)
+    branches = [branch_0, branch_1]
+    mixed = Concatenate(axis=3, name="Block8_6_Concatenate")(branches)
+    up = Conv2D(1792, 1, strides=1, padding="same", use_bias=True, name="Block8_6_Conv2d_1x1")(
+        mixed
+    )
+    up = Lambda(scaling, output_shape=K.int_shape(up)[1:], arguments={"scale": 1})(up)
+    x = add([x, up])
+
+    # Classification block
+    x = GlobalAveragePooling2D(name="AvgPool")(x)
+    x = Dropout(1.0 - 0.8, name="Dropout")(x)
+    # Bottleneck
+    x = Dense(dimension, use_bias=False, name="Bottleneck")(x)
+    x = BatchNormalization(momentum=0.995, epsilon=0.001, scale=False, name="Bottleneck_BatchNorm")(
+        x
+    )
+
+    # Create model
+    model = Model(inputs, x, name="inception_resnet_v1")
+
+    return model
+
+
+def load_facenet128d_model(
+    url="https://github.com/serengil/deepface_models/releases/download/v1.0/facenet_weights.h5",
+) -> Model:
+    """
+    Construct FaceNet-128d model, download weights and then load weights
+    Args:
+        dimension (int): construct FaceNet-128d or FaceNet-512d models
+    Returns:
+        model (Model)
+    """
+    model = InceptionResNetV1()
+
+    # -----------------------------------
+
+    home = folder_utils.get_deepface_home()
+
+    if os.path.isfile(home + "/.deepface/weights/facenet_weights.h5") != True:
+        logger.info("facenet_weights.h5 will be downloaded...")
+
+        output = home + "/.deepface/weights/facenet_weights.h5"
+        gdown.download(url, output, quiet=False)
+
+    # -----------------------------------
+
+    model.load_weights(home + "/.deepface/weights/facenet_weights.h5")
+
+    # -----------------------------------
+
+    return model
+
+
+def load_facenet512d_model(
+    url="https://github.com/serengil/deepface_models/releases/download/v1.0/facenet512_weights.h5",
+) -> Model:
+    """
+    Construct FaceNet-512d model, download its weights and load
+    Returns:
+        model (Model)
+    """
+
+    model = InceptionResNetV1(dimension=512)
+
+    # -------------------------
+
+    home = folder_utils.get_deepface_home()
+
+    if os.path.isfile(home + "/.deepface/weights/facenet512_weights.h5") != True:
+        logger.info("facenet512_weights.h5 will be downloaded...")
+
+        output = home + "/.deepface/weights/facenet512_weights.h5"
+        gdown.download(url, output, quiet=False)
+
+    # -------------------------
+
+    model.load_weights(home + "/.deepface/weights/facenet512_weights.h5")
+
+    # -------------------------
+
+    return model
diff --git a/basemodels/FbDeepFace.py b/basemodels/FbDeepFace.py
new file mode 100644
index 0000000000000000000000000000000000000000..f51a5112809314a9166fee965c1d07703db5bfb7
--- /dev/null
+++ b/basemodels/FbDeepFace.py
@@ -0,0 +1,105 @@
+import os
+import zipfile
+import gdown
+from deepface.commons import package_utils, folder_utils
+from deepface.models.FacialRecognition import FacialRecognition
+from deepface.commons import logger as log
+
+logger = log.get_singletonish_logger()
+
+# --------------------------------
+# dependency configuration
+
+tf_major = package_utils.get_tf_major_version()
+tf_minor = package_utils.get_tf_minor_version()
+
+if tf_major == 1:
+    from keras.models import Model, Sequential
+    from keras.layers import (
+        Convolution2D,
+        MaxPooling2D,
+        Flatten,
+        Dense,
+        Dropout,
+    )
+else:
+    from tensorflow.keras.models import Model, Sequential
+    from tensorflow.keras.layers import (
+        Convolution2D,
+        MaxPooling2D,
+        Flatten,
+        Dense,
+        Dropout,
+    )
+
+
+# -------------------------------------
+# pylint: disable=line-too-long, too-few-public-methods
+class DeepFaceClient(FacialRecognition):
+    """
+    Fb's DeepFace model class
+    """
+
+    def __init__(self):
+        # DeepFace requires tf 2.12 or less
+        if tf_major == 2 and tf_minor > 12:
+            # Ref: https://github.com/serengil/deepface/pull/1079
+            raise ValueError(
+                "DeepFace model requires LocallyConnected2D but it is no longer supported"
+                f" after tf 2.12 but you have {tf_major}.{tf_minor}. You need to downgrade your tf."
+            )
+
+        self.model = load_model()
+        self.model_name = "DeepFace"
+        self.input_shape = (152, 152)
+        self.output_shape = 4096
+
+
+def load_model(
+    url="https://github.com/swghosh/DeepFace/releases/download/weights-vggface2-2d-aligned/VGGFace2_DeepFace_weights_val-0.9034.h5.zip",
+) -> Model:
+    """
+    Construct DeepFace model, download its weights and load
+    """
+    # we have some checks for this dependency in the init of client
+    # putting this in global causes library initialization
+    if tf_major == 1:
+        from keras.layers import LocallyConnected2D
+    else:
+        from tensorflow.keras.layers import LocallyConnected2D
+
+    base_model = Sequential()
+    base_model.add(
+        Convolution2D(32, (11, 11), activation="relu", name="C1", input_shape=(152, 152, 3))
+    )
+    base_model.add(MaxPooling2D(pool_size=3, strides=2, padding="same", name="M2"))
+    base_model.add(Convolution2D(16, (9, 9), activation="relu", name="C3"))
+    base_model.add(LocallyConnected2D(16, (9, 9), activation="relu", name="L4"))
+    base_model.add(LocallyConnected2D(16, (7, 7), strides=2, activation="relu", name="L5"))
+    base_model.add(LocallyConnected2D(16, (5, 5), activation="relu", name="L6"))
+    base_model.add(Flatten(name="F0"))
+    base_model.add(Dense(4096, activation="relu", name="F7"))
+    base_model.add(Dropout(rate=0.5, name="D0"))
+    base_model.add(Dense(8631, activation="softmax", name="F8"))
+
+    # ---------------------------------
+
+    home = folder_utils.get_deepface_home()
+
+    if os.path.isfile(home + "/.deepface/weights/VGGFace2_DeepFace_weights_val-0.9034.h5") != True:
+        logger.info("VGGFace2_DeepFace_weights_val-0.9034.h5 will be downloaded...")
+
+        output = home + "/.deepface/weights/VGGFace2_DeepFace_weights_val-0.9034.h5.zip"
+
+        gdown.download(url, output, quiet=False)
+
+        # unzip VGGFace2_DeepFace_weights_val-0.9034.h5.zip
+        with zipfile.ZipFile(output, "r") as zip_ref:
+            zip_ref.extractall(home + "/.deepface/weights/")
+
+    base_model.load_weights(home + "/.deepface/weights/VGGFace2_DeepFace_weights_val-0.9034.h5")
+
+    # drop F8 and D0. F7 is the representation layer.
+    deepface_model = Model(inputs=base_model.layers[0].input, outputs=base_model.layers[-3].output)
+
+    return deepface_model
diff --git a/basemodels/GhostFaceNet.py b/basemodels/GhostFaceNet.py
new file mode 100644
index 0000000000000000000000000000000000000000..1917833845d03a4a106129e537891a2bce46b4e2
--- /dev/null
+++ b/basemodels/GhostFaceNet.py
@@ -0,0 +1,312 @@
+# built-in dependencies
+import os
+
+# 3rd party dependencies
+import gdown
+import tensorflow as tf
+
+# project dependencies
+from deepface.commons import package_utils, folder_utils
+from deepface.models.FacialRecognition import FacialRecognition
+from deepface.commons import logger as log
+
+logger = log.get_singletonish_logger()
+
+tf_major = package_utils.get_tf_major_version()
+if tf_major == 1:
+    import keras
+    from keras import backend as K
+    from keras.models import Model
+    from keras.layers import (
+        Activation,
+        Add,
+        BatchNormalization,
+        Concatenate,
+        Conv2D,
+        DepthwiseConv2D,
+        GlobalAveragePooling2D,
+        Input,
+        Reshape,
+        Multiply,
+        ReLU,
+        PReLU,
+    )
+else:
+    from tensorflow import keras
+    from tensorflow.keras import backend as K
+    from tensorflow.keras.models import Model
+    from tensorflow.keras.layers import (
+        Activation,
+        Add,
+        BatchNormalization,
+        Concatenate,
+        Conv2D,
+        DepthwiseConv2D,
+        GlobalAveragePooling2D,
+        Input,
+        Reshape,
+        Multiply,
+        ReLU,
+        PReLU,
+    )
+
+
+# pylint: disable=line-too-long, too-few-public-methods, no-else-return, unsubscriptable-object, comparison-with-callable
+PRETRAINED_WEIGHTS = "https://github.com/HamadYA/GhostFaceNets/releases/download/v1.2/GhostFaceNet_W1.3_S1_ArcFace.h5"
+
+
+class GhostFaceNetClient(FacialRecognition):
+    """
+    GhostFaceNet model (GhostFaceNetV1 backbone)
+    Repo: https://github.com/HamadYA/GhostFaceNets
+    Pre-trained weights: https://github.com/HamadYA/GhostFaceNets/releases/tag/v1.2
+        GhostFaceNet_W1.3_S1_ArcFace.h5 ~ 16.5MB
+        Author declared that this backbone and pre-trained weights got 99.7667% accuracy on LFW
+    """
+
+    def __init__(self):
+        self.model_name = "GhostFaceNet"
+        self.input_shape = (112, 112)
+        self.output_shape = 512
+        self.model = load_model()
+
+
+def load_model():
+    model = GhostFaceNetV1()
+
+    home = folder_utils.get_deepface_home()
+    output = home + "/.deepface/weights/ghostfacenet_v1.h5"
+
+    if os.path.isfile(output) is not True:
+        logger.info(f"Pre-trained weights is downloaded from {PRETRAINED_WEIGHTS} to {output}")
+        gdown.download(PRETRAINED_WEIGHTS, output, quiet=False)
+        logger.info(f"Pre-trained weights is just downloaded to {output}")
+
+    model.load_weights(output)
+
+    return model
+
+
+def GhostFaceNetV1() -> Model:
+    """
+    Build GhostFaceNetV1 model. Refactored from
+        github.com/HamadYA/GhostFaceNets/blob/main/backbones/ghost_model.py
+    Returns:
+        model (Model)
+    """
+    inputs = Input(shape=(112, 112, 3))
+
+    out_channel = 20
+
+    nn = Conv2D(
+        out_channel,
+        (3, 3),
+        strides=1,
+        padding="same",
+        use_bias=False,
+        kernel_initializer=keras.initializers.VarianceScaling(
+            scale=2.0, mode="fan_out", distribution="truncated_normal"
+        ),
+    )(inputs)
+
+    nn = BatchNormalization(axis=-1)(nn)
+    nn = Activation("relu")(nn)
+
+    dwkernels = [3, 3, 3, 5, 5, 3, 3, 3, 3, 3, 3, 5, 5, 5, 5, 5]
+    exps = [20, 64, 92, 92, 156, 312, 260, 240, 240, 624, 872, 872, 1248, 1248, 1248, 664]
+    outs = [20, 32, 32, 52, 52, 104, 104, 104, 104, 144, 144, 208, 208, 208, 208, 208]
+    strides_set = [1, 2, 1, 2, 1, 2, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1]
+    reductions = [0, 0, 0, 24, 40, 0, 0, 0, 0, 156, 220, 220, 0, 312, 0, 168]
+
+    pre_out = out_channel
+    for dwk, stride, exp, out, reduction in zip(dwkernels, strides_set, exps, outs, reductions):
+        shortcut = not (out == pre_out and stride == 1)
+        nn = ghost_bottleneck(nn, dwk, stride, exp, out, reduction, shortcut)
+        pre_out = out
+
+    nn = Conv2D(
+        664,
+        (1, 1),
+        strides=(1, 1),
+        padding="valid",
+        use_bias=False,
+        kernel_initializer=keras.initializers.VarianceScaling(
+            scale=2.0, mode="fan_out", distribution="truncated_normal"
+        ),
+    )(nn)
+    nn = BatchNormalization(axis=-1)(nn)
+    nn = Activation("relu")(nn)
+
+    xx = Model(inputs=inputs, outputs=nn, name="GhostFaceNetV1")
+
+    # post modelling
+    inputs = xx.inputs[0]
+    nn = xx.outputs[0]
+
+    nn = keras.layers.DepthwiseConv2D(nn.shape[1], use_bias=False, name="GDC_dw")(nn)
+    nn = keras.layers.BatchNormalization(momentum=0.99, epsilon=0.001, name="GDC_batchnorm")(nn)
+    nn = keras.layers.Conv2D(
+        512, 1, use_bias=True, kernel_initializer="glorot_normal", name="GDC_conv"
+    )(nn)
+    nn = keras.layers.Flatten(name="GDC_flatten")(nn)
+
+    embedding = keras.layers.BatchNormalization(
+        momentum=0.99, epsilon=0.001, scale=True, name="pre_embedding"
+    )(nn)
+    embedding_fp32 = keras.layers.Activation("linear", dtype="float32", name="embedding")(embedding)
+
+    model = keras.models.Model(inputs, embedding_fp32, name=xx.name)
+    model = replace_relu_with_prelu(model=model)
+    return model
+
+
+def se_module(inputs, reduction):
+    """
+    Refactored from github.com/HamadYA/GhostFaceNets/blob/main/backbones/ghost_model.py
+    """
+    # get the channel axis
+    channel_axis = 1 if K.image_data_format() == "channels_first" else -1
+    # filters = channel axis shape
+    filters = inputs.shape[channel_axis]
+
+    # from None x H x W x C to None x C
+    se = GlobalAveragePooling2D()(inputs)
+
+    # Reshape None x C to None 1 x 1 x C
+    se = Reshape((1, 1, filters))(se)
+
+    # Squeeze by using C*se_ratio. The size will be 1 x 1 x C*se_ratio
+    se = Conv2D(
+        reduction,
+        kernel_size=1,
+        use_bias=True,
+        kernel_initializer=keras.initializers.VarianceScaling(
+            scale=2.0, mode="fan_out", distribution="truncated_normal"
+        ),
+    )(se)
+    se = Activation("relu")(se)
+
+    # Excitation using C filters. The size will be 1 x 1 x C
+    se = Conv2D(
+        filters,
+        kernel_size=1,
+        use_bias=True,
+        kernel_initializer=keras.initializers.VarianceScaling(
+            scale=2.0, mode="fan_out", distribution="truncated_normal"
+        ),
+    )(se)
+    se = Activation("hard_sigmoid")(se)
+
+    return Multiply()([inputs, se])
+
+
+def ghost_module(inputs, out, convkernel=1, dwkernel=3, add_activation=True):
+    """
+    Refactored from github.com/HamadYA/GhostFaceNets/blob/main/backbones/ghost_model.py
+    """
+    conv_out_channel = out // 2
+    cc = Conv2D(
+        conv_out_channel,
+        convkernel,
+        use_bias=False,
+        strides=(1, 1),
+        padding="same",
+        kernel_initializer=keras.initializers.VarianceScaling(
+            scale=2.0, mode="fan_out", distribution="truncated_normal"
+        ),
+    )(inputs)
+    cc = BatchNormalization(axis=-1)(cc)
+    if add_activation:
+        cc = Activation("relu")(cc)
+
+    nn = DepthwiseConv2D(
+        dwkernel,
+        1,
+        padding="same",
+        use_bias=False,
+        depthwise_initializer=keras.initializers.VarianceScaling(
+            scale=2.0, mode="fan_out", distribution="truncated_normal"
+        ),
+    )(cc)
+    nn = BatchNormalization(axis=-1)(nn)
+    if add_activation:
+        nn = Activation("relu")(nn)
+    return Concatenate()([cc, nn])
+
+
+def ghost_bottleneck(inputs, dwkernel, strides, exp, out, reduction, shortcut=True):
+    """
+    Refactored from github.com/HamadYA/GhostFaceNets/blob/main/backbones/ghost_model.py
+    """
+    nn = ghost_module(inputs, exp, add_activation=True)
+    if strides > 1:
+        # Extra depth conv if strides higher than 1
+        nn = DepthwiseConv2D(
+            dwkernel,
+            strides,
+            padding="same",
+            use_bias=False,
+            depthwise_initializer=keras.initializers.VarianceScaling(
+                scale=2.0, mode="fan_out", distribution="truncated_normal"
+            ),
+        )(nn)
+        nn = BatchNormalization(axis=-1)(nn)
+
+    if reduction > 0:
+        # Squeeze and excite
+        nn = se_module(nn, reduction)
+
+    # Point-wise linear projection
+    nn = ghost_module(nn, out, add_activation=False)  # ghost2 = GhostModule(exp, out, relu=False)
+
+    if shortcut:
+        xx = DepthwiseConv2D(
+            dwkernel,
+            strides,
+            padding="same",
+            use_bias=False,
+            depthwise_initializer=keras.initializers.VarianceScaling(
+                scale=2.0, mode="fan_out", distribution="truncated_normal"
+            ),
+        )(inputs)
+        xx = BatchNormalization(axis=-1)(xx)
+        xx = Conv2D(
+            out,
+            (1, 1),
+            strides=(1, 1),
+            padding="valid",
+            use_bias=False,
+            kernel_initializer=keras.initializers.VarianceScaling(
+                scale=2.0, mode="fan_out", distribution="truncated_normal"
+            ),
+        )(xx)
+        xx = BatchNormalization(axis=-1)(xx)
+    else:
+        xx = inputs
+    return Add()([xx, nn])
+
+
+def replace_relu_with_prelu(model) -> Model:
+    """
+    Replaces relu activation function in the built model with prelu.
+        Refactored from github.com/HamadYA/GhostFaceNets/blob/main/backbones/ghost_model.py
+    Args:
+        model (Model): built model with relu activation functions
+    Returns
+        model (Model): built model with prelu activation functions
+    """
+
+    def convert_relu(layer):
+        if isinstance(layer, ReLU) or (
+            isinstance(layer, Activation) and layer.activation == keras.activations.relu
+        ):
+            layer_name = layer.name.replace("_relu", "_prelu")
+            return PReLU(
+                shared_axes=[1, 2],
+                alpha_initializer=tf.initializers.Constant(0.25),
+                name=layer_name,
+            )
+        return layer
+
+    input_tensors = keras.layers.Input(model.input_shape[1:])
+    return keras.models.clone_model(model, input_tensors=input_tensors, clone_function=convert_relu)
diff --git a/basemodels/OpenFace.py b/basemodels/OpenFace.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc335b6cda30ef5965a0f57058715ddc7840099c
--- /dev/null
+++ b/basemodels/OpenFace.py
@@ -0,0 +1,397 @@
+import os
+import gdown
+import tensorflow as tf
+from deepface.commons import package_utils, folder_utils
+from deepface.models.FacialRecognition import FacialRecognition
+from deepface.commons import logger as log
+
+logger = log.get_singletonish_logger()
+
+tf_version = package_utils.get_tf_major_version()
+if tf_version == 1:
+    from keras.models import Model
+    from keras.layers import Conv2D, ZeroPadding2D, Input, concatenate
+    from keras.layers import Dense, Activation, Lambda, Flatten, BatchNormalization
+    from keras.layers import MaxPooling2D, AveragePooling2D
+    from keras import backend as K
+else:
+    from tensorflow.keras.models import Model
+    from tensorflow.keras.layers import Conv2D, ZeroPadding2D, Input, concatenate
+    from tensorflow.keras.layers import Dense, Activation, Lambda, Flatten, BatchNormalization
+    from tensorflow.keras.layers import MaxPooling2D, AveragePooling2D
+    from tensorflow.keras import backend as K
+
+# pylint: disable=unnecessary-lambda
+
+# ---------------------------------------
+
+# pylint: disable=too-few-public-methods
+class OpenFaceClient(FacialRecognition):
+    """
+    OpenFace model class
+    """
+
+    def __init__(self):
+        self.model = load_model()
+        self.model_name = "OpenFace"
+        self.input_shape = (96, 96)
+        self.output_shape = 128
+
+
+def load_model(
+    url="https://github.com/serengil/deepface_models/releases/download/v1.0/openface_weights.h5",
+) -> Model:
+    """
+    Consturct OpenFace model, download its weights and load
+    Returns:
+        model (Model)
+    """
+    myInput = Input(shape=(96, 96, 3))
+
+    x = ZeroPadding2D(padding=(3, 3), input_shape=(96, 96, 3))(myInput)
+    x = Conv2D(64, (7, 7), strides=(2, 2), name="conv1")(x)
+    x = BatchNormalization(axis=3, epsilon=0.00001, name="bn1")(x)
+    x = Activation("relu")(x)
+    x = ZeroPadding2D(padding=(1, 1))(x)
+    x = MaxPooling2D(pool_size=3, strides=2)(x)
+    x = Lambda(lambda x: tf.nn.lrn(x, alpha=1e-4, beta=0.75), name="lrn_1")(x)
+    x = Conv2D(64, (1, 1), name="conv2")(x)
+    x = BatchNormalization(axis=3, epsilon=0.00001, name="bn2")(x)
+    x = Activation("relu")(x)
+    x = ZeroPadding2D(padding=(1, 1))(x)
+    x = Conv2D(192, (3, 3), name="conv3")(x)
+    x = BatchNormalization(axis=3, epsilon=0.00001, name="bn3")(x)
+    x = Activation("relu")(x)
+    x = Lambda(lambda x: tf.nn.lrn(x, alpha=1e-4, beta=0.75), name="lrn_2")(x)  # x is equal added
+    x = ZeroPadding2D(padding=(1, 1))(x)
+    x = MaxPooling2D(pool_size=3, strides=2)(x)
+
+    # Inception3a
+    inception_3a_3x3 = Conv2D(96, (1, 1), name="inception_3a_3x3_conv1")(x)
+    inception_3a_3x3 = BatchNormalization(axis=3, epsilon=0.00001, name="inception_3a_3x3_bn1")(
+        inception_3a_3x3
+    )
+    inception_3a_3x3 = Activation("relu")(inception_3a_3x3)
+    inception_3a_3x3 = ZeroPadding2D(padding=(1, 1))(inception_3a_3x3)
+    inception_3a_3x3 = Conv2D(128, (3, 3), name="inception_3a_3x3_conv2")(inception_3a_3x3)
+    inception_3a_3x3 = BatchNormalization(axis=3, epsilon=0.00001, name="inception_3a_3x3_bn2")(
+        inception_3a_3x3
+    )
+    inception_3a_3x3 = Activation("relu")(inception_3a_3x3)
+
+    inception_3a_5x5 = Conv2D(16, (1, 1), name="inception_3a_5x5_conv1")(x)
+    inception_3a_5x5 = BatchNormalization(axis=3, epsilon=0.00001, name="inception_3a_5x5_bn1")(
+        inception_3a_5x5
+    )
+    inception_3a_5x5 = Activation("relu")(inception_3a_5x5)
+    inception_3a_5x5 = ZeroPadding2D(padding=(2, 2))(inception_3a_5x5)
+    inception_3a_5x5 = Conv2D(32, (5, 5), name="inception_3a_5x5_conv2")(inception_3a_5x5)
+    inception_3a_5x5 = BatchNormalization(axis=3, epsilon=0.00001, name="inception_3a_5x5_bn2")(
+        inception_3a_5x5
+    )
+    inception_3a_5x5 = Activation("relu")(inception_3a_5x5)
+
+    inception_3a_pool = MaxPooling2D(pool_size=3, strides=2)(x)
+    inception_3a_pool = Conv2D(32, (1, 1), name="inception_3a_pool_conv")(inception_3a_pool)
+    inception_3a_pool = BatchNormalization(axis=3, epsilon=0.00001, name="inception_3a_pool_bn")(
+        inception_3a_pool
+    )
+    inception_3a_pool = Activation("relu")(inception_3a_pool)
+    inception_3a_pool = ZeroPadding2D(padding=((3, 4), (3, 4)))(inception_3a_pool)
+
+    inception_3a_1x1 = Conv2D(64, (1, 1), name="inception_3a_1x1_conv")(x)
+    inception_3a_1x1 = BatchNormalization(axis=3, epsilon=0.00001, name="inception_3a_1x1_bn")(
+        inception_3a_1x1
+    )
+    inception_3a_1x1 = Activation("relu")(inception_3a_1x1)
+
+    inception_3a = concatenate(
+        [inception_3a_3x3, inception_3a_5x5, inception_3a_pool, inception_3a_1x1], axis=3
+    )
+
+    # Inception3b
+    inception_3b_3x3 = Conv2D(96, (1, 1), name="inception_3b_3x3_conv1")(inception_3a)
+    inception_3b_3x3 = BatchNormalization(axis=3, epsilon=0.00001, name="inception_3b_3x3_bn1")(
+        inception_3b_3x3
+    )
+    inception_3b_3x3 = Activation("relu")(inception_3b_3x3)
+    inception_3b_3x3 = ZeroPadding2D(padding=(1, 1))(inception_3b_3x3)
+    inception_3b_3x3 = Conv2D(128, (3, 3), name="inception_3b_3x3_conv2")(inception_3b_3x3)
+    inception_3b_3x3 = BatchNormalization(axis=3, epsilon=0.00001, name="inception_3b_3x3_bn2")(
+        inception_3b_3x3
+    )
+    inception_3b_3x3 = Activation("relu")(inception_3b_3x3)
+
+    inception_3b_5x5 = Conv2D(32, (1, 1), name="inception_3b_5x5_conv1")(inception_3a)
+    inception_3b_5x5 = BatchNormalization(axis=3, epsilon=0.00001, name="inception_3b_5x5_bn1")(
+        inception_3b_5x5
+    )
+    inception_3b_5x5 = Activation("relu")(inception_3b_5x5)
+    inception_3b_5x5 = ZeroPadding2D(padding=(2, 2))(inception_3b_5x5)
+    inception_3b_5x5 = Conv2D(64, (5, 5), name="inception_3b_5x5_conv2")(inception_3b_5x5)
+    inception_3b_5x5 = BatchNormalization(axis=3, epsilon=0.00001, name="inception_3b_5x5_bn2")(
+        inception_3b_5x5
+    )
+    inception_3b_5x5 = Activation("relu")(inception_3b_5x5)
+
+    inception_3b_pool = Lambda(lambda x: x**2, name="power2_3b")(inception_3a)
+    inception_3b_pool = AveragePooling2D(pool_size=(3, 3), strides=(3, 3))(inception_3b_pool)
+    inception_3b_pool = Lambda(lambda x: x * 9, name="mult9_3b")(inception_3b_pool)
+    inception_3b_pool = Lambda(lambda x: K.sqrt(x), name="sqrt_3b")(inception_3b_pool)
+    inception_3b_pool = Conv2D(64, (1, 1), name="inception_3b_pool_conv")(inception_3b_pool)
+    inception_3b_pool = BatchNormalization(axis=3, epsilon=0.00001, name="inception_3b_pool_bn")(
+        inception_3b_pool
+    )
+    inception_3b_pool = Activation("relu")(inception_3b_pool)
+    inception_3b_pool = ZeroPadding2D(padding=(4, 4))(inception_3b_pool)
+
+    inception_3b_1x1 = Conv2D(64, (1, 1), name="inception_3b_1x1_conv")(inception_3a)
+    inception_3b_1x1 = BatchNormalization(axis=3, epsilon=0.00001, name="inception_3b_1x1_bn")(
+        inception_3b_1x1
+    )
+    inception_3b_1x1 = Activation("relu")(inception_3b_1x1)
+
+    inception_3b = concatenate(
+        [inception_3b_3x3, inception_3b_5x5, inception_3b_pool, inception_3b_1x1], axis=3
+    )
+
+    # Inception3c
+    inception_3c_3x3 = Conv2D(128, (1, 1), strides=(1, 1), name="inception_3c_3x3_conv1")(
+        inception_3b
+    )
+    inception_3c_3x3 = BatchNormalization(axis=3, epsilon=0.00001, name="inception_3c_3x3_bn1")(
+        inception_3c_3x3
+    )
+    inception_3c_3x3 = Activation("relu")(inception_3c_3x3)
+    inception_3c_3x3 = ZeroPadding2D(padding=(1, 1))(inception_3c_3x3)
+    inception_3c_3x3 = Conv2D(256, (3, 3), strides=(2, 2), name="inception_3c_3x3_conv" + "2")(
+        inception_3c_3x3
+    )
+    inception_3c_3x3 = BatchNormalization(
+        axis=3, epsilon=0.00001, name="inception_3c_3x3_bn" + "2"
+    )(inception_3c_3x3)
+    inception_3c_3x3 = Activation("relu")(inception_3c_3x3)
+
+    inception_3c_5x5 = Conv2D(32, (1, 1), strides=(1, 1), name="inception_3c_5x5_conv1")(
+        inception_3b
+    )
+    inception_3c_5x5 = BatchNormalization(axis=3, epsilon=0.00001, name="inception_3c_5x5_bn1")(
+        inception_3c_5x5
+    )
+    inception_3c_5x5 = Activation("relu")(inception_3c_5x5)
+    inception_3c_5x5 = ZeroPadding2D(padding=(2, 2))(inception_3c_5x5)
+    inception_3c_5x5 = Conv2D(64, (5, 5), strides=(2, 2), name="inception_3c_5x5_conv" + "2")(
+        inception_3c_5x5
+    )
+    inception_3c_5x5 = BatchNormalization(
+        axis=3, epsilon=0.00001, name="inception_3c_5x5_bn" + "2"
+    )(inception_3c_5x5)
+    inception_3c_5x5 = Activation("relu")(inception_3c_5x5)
+
+    inception_3c_pool = MaxPooling2D(pool_size=3, strides=2)(inception_3b)
+    inception_3c_pool = ZeroPadding2D(padding=((0, 1), (0, 1)))(inception_3c_pool)
+
+    inception_3c = concatenate([inception_3c_3x3, inception_3c_5x5, inception_3c_pool], axis=3)
+
+    # inception 4a
+    inception_4a_3x3 = Conv2D(96, (1, 1), strides=(1, 1), name="inception_4a_3x3_conv" + "1")(
+        inception_3c
+    )
+    inception_4a_3x3 = BatchNormalization(
+        axis=3, epsilon=0.00001, name="inception_4a_3x3_bn" + "1"
+    )(inception_4a_3x3)
+    inception_4a_3x3 = Activation("relu")(inception_4a_3x3)
+    inception_4a_3x3 = ZeroPadding2D(padding=(1, 1))(inception_4a_3x3)
+    inception_4a_3x3 = Conv2D(192, (3, 3), strides=(1, 1), name="inception_4a_3x3_conv" + "2")(
+        inception_4a_3x3
+    )
+    inception_4a_3x3 = BatchNormalization(
+        axis=3, epsilon=0.00001, name="inception_4a_3x3_bn" + "2"
+    )(inception_4a_3x3)
+    inception_4a_3x3 = Activation("relu")(inception_4a_3x3)
+
+    inception_4a_5x5 = Conv2D(32, (1, 1), strides=(1, 1), name="inception_4a_5x5_conv1")(
+        inception_3c
+    )
+    inception_4a_5x5 = BatchNormalization(axis=3, epsilon=0.00001, name="inception_4a_5x5_bn1")(
+        inception_4a_5x5
+    )
+    inception_4a_5x5 = Activation("relu")(inception_4a_5x5)
+    inception_4a_5x5 = ZeroPadding2D(padding=(2, 2))(inception_4a_5x5)
+    inception_4a_5x5 = Conv2D(64, (5, 5), strides=(1, 1), name="inception_4a_5x5_conv" + "2")(
+        inception_4a_5x5
+    )
+    inception_4a_5x5 = BatchNormalization(
+        axis=3, epsilon=0.00001, name="inception_4a_5x5_bn" + "2"
+    )(inception_4a_5x5)
+    inception_4a_5x5 = Activation("relu")(inception_4a_5x5)
+
+    inception_4a_pool = Lambda(lambda x: x**2, name="power2_4a")(inception_3c)
+    inception_4a_pool = AveragePooling2D(pool_size=(3, 3), strides=(3, 3))(inception_4a_pool)
+    inception_4a_pool = Lambda(lambda x: x * 9, name="mult9_4a")(inception_4a_pool)
+    inception_4a_pool = Lambda(lambda x: K.sqrt(x), name="sqrt_4a")(inception_4a_pool)
+
+    inception_4a_pool = Conv2D(128, (1, 1), strides=(1, 1), name="inception_4a_pool_conv" + "")(
+        inception_4a_pool
+    )
+    inception_4a_pool = BatchNormalization(
+        axis=3, epsilon=0.00001, name="inception_4a_pool_bn" + ""
+    )(inception_4a_pool)
+    inception_4a_pool = Activation("relu")(inception_4a_pool)
+    inception_4a_pool = ZeroPadding2D(padding=(2, 2))(inception_4a_pool)
+
+    inception_4a_1x1 = Conv2D(256, (1, 1), strides=(1, 1), name="inception_4a_1x1_conv" + "")(
+        inception_3c
+    )
+    inception_4a_1x1 = BatchNormalization(axis=3, epsilon=0.00001, name="inception_4a_1x1_bn" + "")(
+        inception_4a_1x1
+    )
+    inception_4a_1x1 = Activation("relu")(inception_4a_1x1)
+
+    inception_4a = concatenate(
+        [inception_4a_3x3, inception_4a_5x5, inception_4a_pool, inception_4a_1x1], axis=3
+    )
+
+    # inception4e
+    inception_4e_3x3 = Conv2D(160, (1, 1), strides=(1, 1), name="inception_4e_3x3_conv" + "1")(
+        inception_4a
+    )
+    inception_4e_3x3 = BatchNormalization(
+        axis=3, epsilon=0.00001, name="inception_4e_3x3_bn" + "1"
+    )(inception_4e_3x3)
+    inception_4e_3x3 = Activation("relu")(inception_4e_3x3)
+    inception_4e_3x3 = ZeroPadding2D(padding=(1, 1))(inception_4e_3x3)
+    inception_4e_3x3 = Conv2D(256, (3, 3), strides=(2, 2), name="inception_4e_3x3_conv" + "2")(
+        inception_4e_3x3
+    )
+    inception_4e_3x3 = BatchNormalization(
+        axis=3, epsilon=0.00001, name="inception_4e_3x3_bn" + "2"
+    )(inception_4e_3x3)
+    inception_4e_3x3 = Activation("relu")(inception_4e_3x3)
+
+    inception_4e_5x5 = Conv2D(64, (1, 1), strides=(1, 1), name="inception_4e_5x5_conv" + "1")(
+        inception_4a
+    )
+    inception_4e_5x5 = BatchNormalization(
+        axis=3, epsilon=0.00001, name="inception_4e_5x5_bn" + "1"
+    )(inception_4e_5x5)
+    inception_4e_5x5 = Activation("relu")(inception_4e_5x5)
+    inception_4e_5x5 = ZeroPadding2D(padding=(2, 2))(inception_4e_5x5)
+    inception_4e_5x5 = Conv2D(128, (5, 5), strides=(2, 2), name="inception_4e_5x5_conv" + "2")(
+        inception_4e_5x5
+    )
+    inception_4e_5x5 = BatchNormalization(
+        axis=3, epsilon=0.00001, name="inception_4e_5x5_bn" + "2"
+    )(inception_4e_5x5)
+    inception_4e_5x5 = Activation("relu")(inception_4e_5x5)
+
+    inception_4e_pool = MaxPooling2D(pool_size=3, strides=2)(inception_4a)
+    inception_4e_pool = ZeroPadding2D(padding=((0, 1), (0, 1)))(inception_4e_pool)
+
+    inception_4e = concatenate([inception_4e_3x3, inception_4e_5x5, inception_4e_pool], axis=3)
+
+    # inception5a
+    inception_5a_3x3 = Conv2D(96, (1, 1), strides=(1, 1), name="inception_5a_3x3_conv" + "1")(
+        inception_4e
+    )
+    inception_5a_3x3 = BatchNormalization(
+        axis=3, epsilon=0.00001, name="inception_5a_3x3_bn" + "1"
+    )(inception_5a_3x3)
+    inception_5a_3x3 = Activation("relu")(inception_5a_3x3)
+    inception_5a_3x3 = ZeroPadding2D(padding=(1, 1))(inception_5a_3x3)
+    inception_5a_3x3 = Conv2D(384, (3, 3), strides=(1, 1), name="inception_5a_3x3_conv" + "2")(
+        inception_5a_3x3
+    )
+    inception_5a_3x3 = BatchNormalization(
+        axis=3, epsilon=0.00001, name="inception_5a_3x3_bn" + "2"
+    )(inception_5a_3x3)
+    inception_5a_3x3 = Activation("relu")(inception_5a_3x3)
+
+    inception_5a_pool = Lambda(lambda x: x**2, name="power2_5a")(inception_4e)
+    inception_5a_pool = AveragePooling2D(pool_size=(3, 3), strides=(3, 3))(inception_5a_pool)
+    inception_5a_pool = Lambda(lambda x: x * 9, name="mult9_5a")(inception_5a_pool)
+    inception_5a_pool = Lambda(lambda x: K.sqrt(x), name="sqrt_5a")(inception_5a_pool)
+
+    inception_5a_pool = Conv2D(96, (1, 1), strides=(1, 1), name="inception_5a_pool_conv" + "")(
+        inception_5a_pool
+    )
+    inception_5a_pool = BatchNormalization(
+        axis=3, epsilon=0.00001, name="inception_5a_pool_bn" + ""
+    )(inception_5a_pool)
+    inception_5a_pool = Activation("relu")(inception_5a_pool)
+    inception_5a_pool = ZeroPadding2D(padding=(1, 1))(inception_5a_pool)
+
+    inception_5a_1x1 = Conv2D(256, (1, 1), strides=(1, 1), name="inception_5a_1x1_conv" + "")(
+        inception_4e
+    )
+    inception_5a_1x1 = BatchNormalization(axis=3, epsilon=0.00001, name="inception_5a_1x1_bn" + "")(
+        inception_5a_1x1
+    )
+    inception_5a_1x1 = Activation("relu")(inception_5a_1x1)
+
+    inception_5a = concatenate([inception_5a_3x3, inception_5a_pool, inception_5a_1x1], axis=3)
+
+    # inception_5b
+    inception_5b_3x3 = Conv2D(96, (1, 1), strides=(1, 1), name="inception_5b_3x3_conv" + "1")(
+        inception_5a
+    )
+    inception_5b_3x3 = BatchNormalization(
+        axis=3, epsilon=0.00001, name="inception_5b_3x3_bn" + "1"
+    )(inception_5b_3x3)
+    inception_5b_3x3 = Activation("relu")(inception_5b_3x3)
+    inception_5b_3x3 = ZeroPadding2D(padding=(1, 1))(inception_5b_3x3)
+    inception_5b_3x3 = Conv2D(384, (3, 3), strides=(1, 1), name="inception_5b_3x3_conv" + "2")(
+        inception_5b_3x3
+    )
+    inception_5b_3x3 = BatchNormalization(
+        axis=3, epsilon=0.00001, name="inception_5b_3x3_bn" + "2"
+    )(inception_5b_3x3)
+    inception_5b_3x3 = Activation("relu")(inception_5b_3x3)
+
+    inception_5b_pool = MaxPooling2D(pool_size=3, strides=2)(inception_5a)
+
+    inception_5b_pool = Conv2D(96, (1, 1), strides=(1, 1), name="inception_5b_pool_conv" + "")(
+        inception_5b_pool
+    )
+    inception_5b_pool = BatchNormalization(
+        axis=3, epsilon=0.00001, name="inception_5b_pool_bn" + ""
+    )(inception_5b_pool)
+    inception_5b_pool = Activation("relu")(inception_5b_pool)
+
+    inception_5b_pool = ZeroPadding2D(padding=(1, 1))(inception_5b_pool)
+
+    inception_5b_1x1 = Conv2D(256, (1, 1), strides=(1, 1), name="inception_5b_1x1_conv" + "")(
+        inception_5a
+    )
+    inception_5b_1x1 = BatchNormalization(axis=3, epsilon=0.00001, name="inception_5b_1x1_bn" + "")(
+        inception_5b_1x1
+    )
+    inception_5b_1x1 = Activation("relu")(inception_5b_1x1)
+
+    inception_5b = concatenate([inception_5b_3x3, inception_5b_pool, inception_5b_1x1], axis=3)
+
+    av_pool = AveragePooling2D(pool_size=(3, 3), strides=(1, 1))(inception_5b)
+    reshape_layer = Flatten()(av_pool)
+    dense_layer = Dense(128, name="dense_layer")(reshape_layer)
+    norm_layer = Lambda(lambda x: K.l2_normalize(x, axis=1), name="norm_layer")(dense_layer)
+
+    # Final Model
+    model = Model(inputs=[myInput], outputs=norm_layer)
+
+    # -----------------------------------
+
+    home = folder_utils.get_deepface_home()
+
+    if os.path.isfile(home + "/.deepface/weights/openface_weights.h5") != True:
+        logger.info("openface_weights.h5 will be downloaded...")
+
+        output = home + "/.deepface/weights/openface_weights.h5"
+        gdown.download(url, output, quiet=False)
+
+    # -----------------------------------
+
+    model.load_weights(home + "/.deepface/weights/openface_weights.h5")
+
+    # -----------------------------------
+
+    return model
diff --git a/basemodels/SFace.py b/basemodels/SFace.py
new file mode 100644
index 0000000000000000000000000000000000000000..ddd9360f17f3822c4c0d41d7bcc2ddce56b23e0b
--- /dev/null
+++ b/basemodels/SFace.py
@@ -0,0 +1,87 @@
+# built-in dependencies
+import os
+from typing import Any, List
+
+# 3rd party dependencies
+import numpy as np
+import cv2 as cv
+import gdown
+
+# project dependencies
+from deepface.commons import folder_utils
+from deepface.models.FacialRecognition import FacialRecognition
+from deepface.commons import logger as log
+
+logger = log.get_singletonish_logger()
+
+# pylint: disable=line-too-long, too-few-public-methods
+
+
+class SFaceClient(FacialRecognition):
+    """
+    SFace model class
+    """
+
+    def __init__(self):
+        self.model = load_model()
+        self.model_name = "SFace"
+        self.input_shape = (112, 112)
+        self.output_shape = 128
+
+    def forward(self, img: np.ndarray) -> List[float]:
+        """
+        Find embeddings with SFace model
+            This model necessitates the override of the forward method
+            because it is not a keras model.
+        Args:
+            img (np.ndarray): pre-loaded image in BGR
+        Returns
+            embeddings (list): multi-dimensional vector
+        """
+        # return self.model.predict(img)[0].tolist()
+
+        # revert the image to original format and preprocess using the model
+        input_blob = (img[0] * 255).astype(np.uint8)
+
+        embeddings = self.model.model.feature(input_blob)
+
+        return embeddings[0].tolist()
+
+
+def load_model(
+    url="https://github.com/opencv/opencv_zoo/raw/main/models/face_recognition_sface/face_recognition_sface_2021dec.onnx",
+) -> Any:
+    """
+    Construct SFace model, download its weights and load
+    """
+
+    home = folder_utils.get_deepface_home()
+
+    file_name = home + "/.deepface/weights/face_recognition_sface_2021dec.onnx"
+
+    if not os.path.isfile(file_name):
+
+        logger.info("sface weights will be downloaded...")
+
+        gdown.download(url, file_name, quiet=False)
+
+    model = SFaceWrapper(model_path=file_name)
+
+    return model
+
+
+class SFaceWrapper:
+    def __init__(self, model_path):
+        """
+        SFace wrapper covering model construction, layer infos and predict
+        """
+        try:
+            self.model = cv.FaceRecognizerSF.create(
+                model=model_path, config="", backend_id=0, target_id=0
+            )
+        except Exception as err:
+            raise ValueError(
+                "Exception while calling opencv.FaceRecognizerSF module."
+                + "This is an optional dependency."
+                + "You can install it as pip install opencv-contrib-python."
+            ) from err
diff --git a/basemodels/VGGFace.py b/basemodels/VGGFace.py
new file mode 100644
index 0000000000000000000000000000000000000000..819150e33bb3ac28c03c87e2dd615aa85534715d
--- /dev/null
+++ b/basemodels/VGGFace.py
@@ -0,0 +1,160 @@
+from typing import List
+import os
+import gdown
+import numpy as np
+from deepface.commons import package_utils, folder_utils
+from deepface.modules import verification
+from deepface.models.FacialRecognition import FacialRecognition
+from deepface.commons import logger as log
+
+logger = log.get_singletonish_logger()
+
+# ---------------------------------------
+
+tf_version = package_utils.get_tf_major_version()
+if tf_version == 1:
+    from keras.models import Model, Sequential
+    from keras.layers import (
+        Convolution2D,
+        ZeroPadding2D,
+        MaxPooling2D,
+        Flatten,
+        Dropout,
+        Activation,
+    )
+else:
+    from tensorflow.keras.models import Model, Sequential
+    from tensorflow.keras.layers import (
+        Convolution2D,
+        ZeroPadding2D,
+        MaxPooling2D,
+        Flatten,
+        Dropout,
+        Activation,
+    )
+
+# ---------------------------------------
+
+# pylint: disable=too-few-public-methods
+class VggFaceClient(FacialRecognition):
+    """
+    VGG-Face model class
+    """
+
+    def __init__(self):
+        self.model = load_model()
+        self.model_name = "VGG-Face"
+        self.input_shape = (224, 224)
+        self.output_shape = 4096
+
+    def forward(self, img: np.ndarray) -> List[float]:
+        """
+        Generates embeddings using the VGG-Face model.
+            This method incorporates an additional normalization layer,
+            necessitating the override of the forward method.
+
+        Args:
+            img (np.ndarray): pre-loaded image in BGR
+        Returns
+            embeddings (list): multi-dimensional vector
+        """
+        # model.predict causes memory issue when it is called in a for loop
+        # embedding = model.predict(img, verbose=0)[0].tolist()
+
+        # having normalization layer in descriptor troubles for some gpu users (e.g. issue 957, 966)
+        # instead we are now calculating it with traditional way not with keras backend
+        embedding = self.model(img, training=False).numpy()[0].tolist()
+        embedding = verification.l2_normalize(embedding)
+        return embedding.tolist()
+
+
+def base_model() -> Sequential:
+    """
+    Base model of VGG-Face being used for classification - not to find embeddings
+    Returns:
+        model (Sequential): model was trained to classify 2622 identities
+    """
+    model = Sequential()
+    model.add(ZeroPadding2D((1, 1), input_shape=(224, 224, 3)))
+    model.add(Convolution2D(64, (3, 3), activation="relu"))
+    model.add(ZeroPadding2D((1, 1)))
+    model.add(Convolution2D(64, (3, 3), activation="relu"))
+    model.add(MaxPooling2D((2, 2), strides=(2, 2)))
+
+    model.add(ZeroPadding2D((1, 1)))
+    model.add(Convolution2D(128, (3, 3), activation="relu"))
+    model.add(ZeroPadding2D((1, 1)))
+    model.add(Convolution2D(128, (3, 3), activation="relu"))
+    model.add(MaxPooling2D((2, 2), strides=(2, 2)))
+
+    model.add(ZeroPadding2D((1, 1)))
+    model.add(Convolution2D(256, (3, 3), activation="relu"))
+    model.add(ZeroPadding2D((1, 1)))
+    model.add(Convolution2D(256, (3, 3), activation="relu"))
+    model.add(ZeroPadding2D((1, 1)))
+    model.add(Convolution2D(256, (3, 3), activation="relu"))
+    model.add(MaxPooling2D((2, 2), strides=(2, 2)))
+
+    model.add(ZeroPadding2D((1, 1)))
+    model.add(Convolution2D(512, (3, 3), activation="relu"))
+    model.add(ZeroPadding2D((1, 1)))
+    model.add(Convolution2D(512, (3, 3), activation="relu"))
+    model.add(ZeroPadding2D((1, 1)))
+    model.add(Convolution2D(512, (3, 3), activation="relu"))
+    model.add(MaxPooling2D((2, 2), strides=(2, 2)))
+
+    model.add(ZeroPadding2D((1, 1)))
+    model.add(Convolution2D(512, (3, 3), activation="relu"))
+    model.add(ZeroPadding2D((1, 1)))
+    model.add(Convolution2D(512, (3, 3), activation="relu"))
+    model.add(ZeroPadding2D((1, 1)))
+    model.add(Convolution2D(512, (3, 3), activation="relu"))
+    model.add(MaxPooling2D((2, 2), strides=(2, 2)))
+
+    model.add(Convolution2D(4096, (7, 7), activation="relu"))
+    model.add(Dropout(0.5))
+    model.add(Convolution2D(4096, (1, 1), activation="relu"))
+    model.add(Dropout(0.5))
+    model.add(Convolution2D(2622, (1, 1)))
+    model.add(Flatten())
+    model.add(Activation("softmax"))
+
+    return model
+
+
+def load_model(
+    url="https://github.com/serengil/deepface_models/releases/download/v1.0/vgg_face_weights.h5",
+) -> Model:
+    """
+    Final VGG-Face model being used for finding embeddings
+    Returns:
+        model (Model): returning 4096 dimensional vectors
+    """
+
+    model = base_model()
+
+    home = folder_utils.get_deepface_home()
+    output = home + "/.deepface/weights/vgg_face_weights.h5"
+
+    if os.path.isfile(output) != True:
+        logger.info("vgg_face_weights.h5 will be downloaded...")
+        gdown.download(url, output, quiet=False)
+
+    model.load_weights(output)
+
+    # 2622d dimensional model
+    # vgg_face_descriptor = Model(inputs=model.layers[0].input, outputs=model.layers[-2].output)
+
+    # 4096 dimensional model offers 6% to 14% increasement on accuracy!
+    # - softmax causes underfitting
+    # - added normalization layer to avoid underfitting with euclidean
+    # as described here: https://github.com/serengil/deepface/issues/944
+    base_model_output = Sequential()
+    base_model_output = Flatten()(model.layers[-5].output)
+    # keras backend's l2 normalization layer troubles some gpu users (e.g. issue 957, 966)
+    # base_model_output = Lambda(lambda x: K.l2_normalize(x, axis=1), name="norm_layer")(
+    #     base_model_output
+    # )
+    vgg_face_descriptor = Model(inputs=model.input, outputs=base_model_output)
+
+    return vgg_face_descriptor
diff --git a/basemodels/__init__.py b/basemodels/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/basemodels/__pycache__/ArcFace.cpython-312.pyc b/basemodels/__pycache__/ArcFace.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..be1310431e4c589ca14dd236bd7414b1592ffaa4
Binary files /dev/null and b/basemodels/__pycache__/ArcFace.cpython-312.pyc differ
diff --git a/basemodels/__pycache__/DeepID.cpython-312.pyc b/basemodels/__pycache__/DeepID.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6c9465926ee1752c559db897c1a36662eb171e6b
Binary files /dev/null and b/basemodels/__pycache__/DeepID.cpython-312.pyc differ
diff --git a/basemodels/__pycache__/Dlib.cpython-312.pyc b/basemodels/__pycache__/Dlib.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..88a8f9993a9b8e9e94a40e97070a660969112c7f
Binary files /dev/null and b/basemodels/__pycache__/Dlib.cpython-312.pyc differ
diff --git a/basemodels/__pycache__/Facenet.cpython-312.pyc b/basemodels/__pycache__/Facenet.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9b98a1816d53adff3f919ee2664e5ddff6096792
Binary files /dev/null and b/basemodels/__pycache__/Facenet.cpython-312.pyc differ
diff --git a/basemodels/__pycache__/FbDeepFace.cpython-312.pyc b/basemodels/__pycache__/FbDeepFace.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..123a7ab941667ba718db0f002f6a7be35fecb981
Binary files /dev/null and b/basemodels/__pycache__/FbDeepFace.cpython-312.pyc differ
diff --git a/basemodels/__pycache__/GhostFaceNet.cpython-312.pyc b/basemodels/__pycache__/GhostFaceNet.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1b8261aca70ed9203b8d2435c8e09f26894ca14f
Binary files /dev/null and b/basemodels/__pycache__/GhostFaceNet.cpython-312.pyc differ
diff --git a/basemodels/__pycache__/OpenFace.cpython-312.pyc b/basemodels/__pycache__/OpenFace.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..af1be7b2e85a63476ee9f3150d1fadd2273109f7
Binary files /dev/null and b/basemodels/__pycache__/OpenFace.cpython-312.pyc differ
diff --git a/basemodels/__pycache__/SFace.cpython-312.pyc b/basemodels/__pycache__/SFace.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cbf759566c5cd94004455fa31f79b9adf5b197a2
Binary files /dev/null and b/basemodels/__pycache__/SFace.cpython-312.pyc differ
diff --git a/basemodels/__pycache__/VGGFace.cpython-312.pyc b/basemodels/__pycache__/VGGFace.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6d691944b09c1109cdb173f3ba5d303951695d8f
Binary files /dev/null and b/basemodels/__pycache__/VGGFace.cpython-312.pyc differ
diff --git a/basemodels/__pycache__/__init__.cpython-312.pyc b/basemodels/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2745ee3693ceef9f4c7d564f3011ce627cc9771d
Binary files /dev/null and b/basemodels/__pycache__/__init__.cpython-312.pyc differ
diff --git a/commons/__init__.py b/commons/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/commons/__pycache__/__init__.cpython-312.pyc b/commons/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6822571cd6b16a6ae15e675f7389374e20305391
Binary files /dev/null and b/commons/__pycache__/__init__.cpython-312.pyc differ
diff --git a/commons/__pycache__/file_utils.cpython-312.pyc b/commons/__pycache__/file_utils.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9ba8762a0835203b5db6c951af93a41cea0b0b5d
Binary files /dev/null and b/commons/__pycache__/file_utils.cpython-312.pyc differ
diff --git a/commons/__pycache__/folder_utils.cpython-312.pyc b/commons/__pycache__/folder_utils.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8fd4bc8a74f147a16a247c8e2e47c60c0e80a678
Binary files /dev/null and b/commons/__pycache__/folder_utils.cpython-312.pyc differ
diff --git a/commons/__pycache__/image_utils.cpython-312.pyc b/commons/__pycache__/image_utils.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cfc8eea499516194034fb16b9a5e8c979a981901
Binary files /dev/null and b/commons/__pycache__/image_utils.cpython-312.pyc differ
diff --git a/commons/__pycache__/logger.cpython-312.pyc b/commons/__pycache__/logger.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1ecd6dc6b06bbdc71b230fffe7df0c47ddc16bab
Binary files /dev/null and b/commons/__pycache__/logger.cpython-312.pyc differ
diff --git a/commons/__pycache__/os_path.cpython-312.pyc b/commons/__pycache__/os_path.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c1e954046f9f8a0862cc5715cff2c35c84a977f8
Binary files /dev/null and b/commons/__pycache__/os_path.cpython-312.pyc differ
diff --git a/commons/__pycache__/package_utils.cpython-312.pyc b/commons/__pycache__/package_utils.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..90619a9d518348a51be4092aa3ab056049f4beb5
Binary files /dev/null and b/commons/__pycache__/package_utils.cpython-312.pyc differ
diff --git a/commons/constant.py b/commons/constant.py
new file mode 100644
index 0000000000000000000000000000000000000000..22f63499f051c89d0bae3e7325aae8b46c7b678a
--- /dev/null
+++ b/commons/constant.py
@@ -0,0 +1,4 @@
+import os
+
+SRC_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+ROOT_DIR = os.path.dirname(SRC_DIR)
diff --git a/commons/folder_utils.py b/commons/folder_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..ef5fbc71bb11415199813e2f51c5dbaf6ad07640
--- /dev/null
+++ b/commons/folder_utils.py
@@ -0,0 +1,35 @@
+import os
+from pathlib import Path
+from deepface.commons import logger as log
+
+logger = log.get_singletonish_logger()
+
+
+def initialize_folder() -> None:
+    """
+    Initialize the folder for storing model weights.
+
+    Raises:
+        OSError: if the folder cannot be created.
+    """
+    home = get_deepface_home()
+    deepface_home_path = home + "/.deepface"
+    weights_path = deepface_home_path + "/weights"
+
+    if not os.path.exists(deepface_home_path):
+        os.makedirs(deepface_home_path, exist_ok=True)
+        logger.info(f"Directory {home}/.deepface created")
+
+    if not os.path.exists(weights_path):
+        os.makedirs(weights_path, exist_ok=True)
+        logger.info(f"Directory {home}/.deepface/weights created")
+
+
+def get_deepface_home() -> str:
+    """
+    Get the home directory for storing model weights
+
+    Returns:
+        str: the home directory.
+    """
+    return str(os.getenv("DEEPFACE_HOME", default=str(Path.home())))
diff --git a/commons/image_utils.py b/commons/image_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..c25e41167fcc70604ae64bce47a3d86531dd846f
--- /dev/null
+++ b/commons/image_utils.py
@@ -0,0 +1,149 @@
+# built-in dependencies
+import os
+import io
+from typing import List, Union, Tuple
+import hashlib
+import base64
+from pathlib import Path
+
+# 3rd party dependencies
+import requests
+import numpy as np
+import cv2
+from PIL import Image
+
+
+def list_images(path: str) -> List[str]:
+    """
+    List images in a given path
+    Args:
+        path (str): path's location
+    Returns:
+        images (list): list of exact image paths
+    """
+    images = []
+    for r, _, f in os.walk(path):
+        for file in f:
+            exact_path = os.path.join(r, file)
+
+            _, ext = os.path.splitext(exact_path)
+            ext_lower = ext.lower()
+
+            if ext_lower not in {".jpg", ".jpeg", ".png"}:
+                continue
+
+            with Image.open(exact_path) as img:  # lazy
+                if img.format.lower() in ["jpeg", "png"]:
+                    images.append(exact_path)
+    return images
+
+
+def find_image_hash(file_path: str) -> str:
+    """
+    Find the hash of given image file with its properties
+        finding the hash of image content is costly operation
+    Args:
+        file_path (str): exact image path
+    Returns:
+        hash (str): digest with sha1 algorithm
+    """
+    file_stats = os.stat(file_path)
+
+    # some properties
+    file_size = file_stats.st_size
+    creation_time = file_stats.st_ctime
+    modification_time = file_stats.st_mtime
+
+    properties = f"{file_size}-{creation_time}-{modification_time}"
+
+    hasher = hashlib.sha1()
+    hasher.update(properties.encode("utf-8"))
+    return hasher.hexdigest()
+
+
+def load_image(img: Union[str, np.ndarray]) -> Tuple[np.ndarray, str]:
+    """
+    Load image from path, url, base64 or numpy array.
+    Args:
+        img: a path, url, base64 or numpy array.
+    Returns:
+        image (numpy array): the loaded image in BGR format
+        image name (str): image name itself
+    """
+
+    # The image is already a numpy array
+    if isinstance(img, np.ndarray):
+        return img, "numpy array"
+
+    if isinstance(img, Path):
+        img = str(img)
+
+    if not isinstance(img, str):
+        raise ValueError(f"img must be numpy array or str but it is {type(img)}")
+
+    # The image is a base64 string
+    if img.startswith("data:image/"):
+        return load_image_from_base64(img), "base64 encoded string"
+
+    # The image is a url
+    if img.lower().startswith("http://") or img.lower().startswith("https://"):
+        return load_image_from_web(url=img), img
+
+    # The image is a path
+    if os.path.isfile(img) is not True:
+        raise ValueError(f"Confirm that {img} exists")
+
+    # image must be a file on the system then
+
+    # image name must have english characters
+    if img.isascii() is False:
+        raise ValueError(f"Input image must not have non-english characters - {img}")
+
+    img_obj_bgr = cv2.imread(img)
+    # img_obj_rgb = cv2.cvtColor(img_obj_bgr, cv2.COLOR_BGR2RGB)
+    return img_obj_bgr, img
+
+
+def load_image_from_base64(uri: str) -> np.ndarray:
+    """
+    Load image from base64 string.
+    Args:
+        uri: a base64 string.
+    Returns:
+        numpy array: the loaded image.
+    """
+
+    encoded_data_parts = uri.split(",")
+
+    if len(encoded_data_parts) < 2:
+        raise ValueError("format error in base64 encoded string")
+
+    encoded_data = encoded_data_parts[1]
+    decoded_bytes = base64.b64decode(encoded_data)
+
+    # similar to find functionality, we are just considering these extensions
+    # content type is safer option than file extension
+    with Image.open(io.BytesIO(decoded_bytes)) as img:
+        file_type = img.format.lower()
+        if file_type not in ["jpeg", "png"]:
+            raise ValueError(f"input image can be jpg or png, but it is {file_type}")
+
+    nparr = np.fromstring(decoded_bytes, np.uint8)
+    img_bgr = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+    # img_rgb = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
+    return img_bgr
+
+
+def load_image_from_web(url: str) -> np.ndarray:
+    """
+    Loading an image from web
+    Args:
+        url: link for the image
+    Returns:
+        img (np.ndarray): equivalent to pre-loaded image from opencv (BGR format)
+    """
+    response = requests.get(url, stream=True, timeout=60)
+    response.raise_for_status()
+    image_array = np.asarray(bytearray(response.raw.read()), dtype=np.uint8)
+    img = cv2.imdecode(image_array, cv2.IMREAD_COLOR)
+    return img
diff --git a/commons/logger.py b/commons/logger.py
new file mode 100644
index 0000000000000000000000000000000000000000..45339532d1c1392bfc3a14ff01ca7ec5dbbf8385
--- /dev/null
+++ b/commons/logger.py
@@ -0,0 +1,54 @@
+import os
+import logging
+from datetime import datetime
+
+# pylint: disable=broad-except
+class Logger:
+    def __init__(self, module=None):
+        self.module = module
+        log_level = os.environ.get("DEEPFACE_LOG_LEVEL", str(logging.INFO))
+        try:
+            self.log_level = int(log_level)
+        except Exception as err:
+            self.dump_log(
+                f"Exception while parsing $DEEPFACE_LOG_LEVEL."
+                f"Expected int but it is {log_level} ({str(err)})."
+                "Setting app log level to info."
+            )
+            self.log_level = logging.INFO
+
+    def info(self, message):
+        if self.log_level <= logging.INFO:
+            self.dump_log(f"{message}")
+
+    def debug(self, message):
+        if self.log_level <= logging.DEBUG:
+            self.dump_log(f"🕷️ {message}")
+
+    def warn(self, message):
+        if self.log_level <= logging.WARNING:
+            self.dump_log(f"⚠️ {message}")
+
+    def error(self, message):
+        if self.log_level <= logging.ERROR:
+            self.dump_log(f"🔴 {message}")
+
+    def critical(self, message):
+        if self.log_level <= logging.CRITICAL:
+            self.dump_log(f"💥 {message}")
+
+    def dump_log(self, message):
+        print(f"{str(datetime.now())[2:-7]} - {message}")
+
+
+def get_singletonish_logger():
+    # singleton design pattern
+    global model_obj
+
+    if not "model_obj" in globals():
+        model_obj = {}
+
+    if "logger" not in model_obj.keys():
+        model_obj["logger"] = Logger(module="Singleton")
+
+    return model_obj["logger"]
diff --git a/commons/os_path.py b/commons/os_path.py
new file mode 100644
index 0000000000000000000000000000000000000000..954bcf81d42fa5d3590048991909d7a6cd1fc53b
--- /dev/null
+++ b/commons/os_path.py
@@ -0,0 +1,10 @@
+import os
+
+class os_path :
+    
+    def get_main_directory():
+        path = os.path.abspath(__file__)
+        drive, _ = os.path.splitdrive(path)
+        if not drive.endswith(os.path.sep):
+            drive += os.path.sep
+        return drive
\ No newline at end of file
diff --git a/commons/package_utils.py b/commons/package_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..c35db8bc55114b58068d4eb3705c58e6b17030f3
--- /dev/null
+++ b/commons/package_utils.py
@@ -0,0 +1,46 @@
+# 3rd party dependencies
+import tensorflow as tf
+
+# package dependencies
+from deepface.commons import logger as log
+
+logger = log.get_singletonish_logger()
+
+
+def get_tf_major_version() -> int:
+    """
+    Find tensorflow's major version
+    Returns
+        major_version (int)
+    """
+    return int(tf.__version__.split(".", maxsplit=1)[0])
+
+
+def get_tf_minor_version() -> int:
+    """
+    Find tensorflow's minor version
+    Returns
+        minor_version (int)
+    """
+    return int(tf.__version__.split(".", maxsplit=-1)[1])
+
+
+def validate_for_keras3():
+    tf_major = get_tf_major_version()
+    tf_minor = get_tf_minor_version()
+
+    # tf_keras is a must dependency after tf 2.16
+    if tf_major == 1 or (tf_major == 2 and tf_minor < 16):
+        return
+
+    try:
+        import tf_keras
+
+        logger.debug(f"tf_keras is already available - {tf_keras.__version__}")
+    except ImportError as err:
+        # you may consider to install that package here
+        raise ValueError(
+            f"You have tensorflow {tf.__version__} and this requires "
+            "tf-keras package. Please run `pip install tf-keras` "
+            "or downgrade your tensorflow."
+        ) from err
diff --git a/commons/path.py b/commons/path.py
new file mode 100644
index 0000000000000000000000000000000000000000..30abbb198e9f3dbb0266485663cd4bb0a12686f2
--- /dev/null
+++ b/commons/path.py
@@ -0,0 +1,9 @@
+import os
+
+class path :
+
+def get_parent_path(path,levels=1):
+    for _ in range(levels):
+        path = os.path.dirname(path)
+    return path
+
diff --git a/detectors/CenterFace.py b/detectors/CenterFace.py
new file mode 100644
index 0000000000000000000000000000000000000000..84db3345c977841d9b2ca69aa60cdd0f2a6d7219
--- /dev/null
+++ b/detectors/CenterFace.py
@@ -0,0 +1,217 @@
+# built-in dependencies
+import os
+from typing import List
+
+# 3rd party dependencies
+import numpy as np
+import cv2
+import gdown
+
+# project dependencies
+from deepface.commons import folder_utils
+from deepface.models.Detector import Detector, FacialAreaRegion
+from deepface.commons import logger as log
+
+logger = log.get_singletonish_logger()
+
+# pylint: disable=c-extension-no-member
+
+WEIGHTS_URL = "https://github.com/Star-Clouds/CenterFace/raw/master/models/onnx/centerface.onnx"
+
+
+class CenterFaceClient(Detector):
+    def __init__(self):
+        # BUG: model must be flushed for each call
+        # self.model = self.build_model()
+        pass
+
+    def build_model(self):
+        """
+        Download pre-trained weights of CenterFace model if necessary and load built model
+        """
+        weights_path = f"{folder_utils.get_deepface_home()}/.deepface/weights/centerface.onnx"
+        if not os.path.isfile(weights_path):
+            logger.info(f"Downloading CenterFace weights from {WEIGHTS_URL} to {weights_path}...")
+            try:
+                gdown.download(WEIGHTS_URL, weights_path, quiet=False)
+            except Exception as err:
+                raise ValueError(
+                    f"Exception while downloading CenterFace weights from {WEIGHTS_URL}."
+                    f"You may consider to download it to {weights_path} manually."
+                ) from err
+            logger.info(f"CenterFace model is just downloaded to {os.path.basename(weights_path)}")
+
+        return CenterFace(weight_path=weights_path)
+
+    def detect_faces(self, img: np.ndarray) -> List["FacialAreaRegion"]:
+        """
+        Detect and align face with CenterFace
+
+        Args:
+            img (np.ndarray): pre-loaded image as numpy array
+
+        Returns:
+            results (List[FacialAreaRegion]): A list of FacialAreaRegion objects
+        """
+        resp = []
+
+        threshold = float(os.getenv("CENTERFACE_THRESHOLD", "0.80"))
+
+        # BUG: model causes problematic results from 2nd call if it is not flushed
+        # detections, landmarks = self.model.forward(
+        #     img, img.shape[0], img.shape[1], threshold=threshold
+        # )
+        detections, landmarks = self.build_model().forward(
+            img, img.shape[0], img.shape[1], threshold=threshold
+        )
+
+        for i, detection in enumerate(detections):
+            boxes, confidence = detection[:4], detection[4]
+
+            x = boxes[0]
+            y = boxes[1]
+            w = boxes[2] - x
+            h = boxes[3] - y
+
+            landmark = landmarks[i]
+
+            right_eye = (int(landmark[0]), int(landmark[1]))
+            left_eye = (int(landmark[2]), int(landmark[3]))
+            # nose = (int(landmark[4]), int(landmark [5]))
+            # mouth_right = (int(landmark[6]), int(landmark [7]))
+            # mouth_left = (int(landmark[8]), int(landmark [9]))
+
+            facial_area = FacialAreaRegion(
+                x=int(x),
+                y=int(y),
+                w=int(w),
+                h=int(h),
+                left_eye=left_eye,
+                right_eye=right_eye,
+                confidence=min(max(0, float(confidence)), 1.0),
+            )
+            resp.append(facial_area)
+
+        return resp
+
+
+class CenterFace:
+    """
+    This class is heavily inspired from
+        github.com/Star-Clouds/CenterFace/blob/master/prj-python/centerface.py
+    """
+
+    def __init__(self, weight_path: str):
+        self.net = cv2.dnn.readNetFromONNX(weight_path)
+        self.img_h_new, self.img_w_new, self.scale_h, self.scale_w = 0, 0, 0, 0
+
+    def forward(self, img, height, width, threshold=0.5):
+        self.img_h_new, self.img_w_new, self.scale_h, self.scale_w = self.transform(height, width)
+        return self.inference_opencv(img, threshold)
+
+    def inference_opencv(self, img, threshold):
+        blob = cv2.dnn.blobFromImage(
+            img,
+            scalefactor=1.0,
+            size=(self.img_w_new, self.img_h_new),
+            mean=(0, 0, 0),
+            swapRB=True,
+            crop=False,
+        )
+        self.net.setInput(blob)
+        heatmap, scale, offset, lms = self.net.forward(["537", "538", "539", "540"])
+        return self.postprocess(heatmap, lms, offset, scale, threshold)
+
+    def transform(self, h, w):
+        img_h_new, img_w_new = int(np.ceil(h / 32) * 32), int(np.ceil(w / 32) * 32)
+        scale_h, scale_w = img_h_new / h, img_w_new / w
+        return img_h_new, img_w_new, scale_h, scale_w
+
+    def postprocess(self, heatmap, lms, offset, scale, threshold):
+        dets, lms = self.decode(
+            heatmap, scale, offset, lms, (self.img_h_new, self.img_w_new), threshold=threshold
+        )
+        if len(dets) > 0:
+            dets[:, 0:4:2], dets[:, 1:4:2] = (
+                dets[:, 0:4:2] / self.scale_w,
+                dets[:, 1:4:2] / self.scale_h,
+            )
+            lms[:, 0:10:2], lms[:, 1:10:2] = (
+                lms[:, 0:10:2] / self.scale_w,
+                lms[:, 1:10:2] / self.scale_h,
+            )
+        else:
+            dets = np.empty(shape=[0, 5], dtype=np.float32)
+            lms = np.empty(shape=[0, 10], dtype=np.float32)
+        return dets, lms
+
+    def decode(self, heatmap, scale, offset, landmark, size, threshold=0.1):
+        heatmap = np.squeeze(heatmap)
+        scale0, scale1 = scale[0, 0, :, :], scale[0, 1, :, :]
+        offset0, offset1 = offset[0, 0, :, :], offset[0, 1, :, :]
+        c0, c1 = np.where(heatmap > threshold)
+        boxes, lms = [], []
+        if len(c0) > 0:
+            # pylint:disable=consider-using-enumerate
+            for i in range(len(c0)):
+                s0, s1 = np.exp(scale0[c0[i], c1[i]]) * 4, np.exp(scale1[c0[i], c1[i]]) * 4
+                o0, o1 = offset0[c0[i], c1[i]], offset1[c0[i], c1[i]]
+                s = heatmap[c0[i], c1[i]]
+                x1, y1 = max(0, (c1[i] + o1 + 0.5) * 4 - s1 / 2), max(
+                    0, (c0[i] + o0 + 0.5) * 4 - s0 / 2
+                )
+                x1, y1 = min(x1, size[1]), min(y1, size[0])
+                boxes.append([x1, y1, min(x1 + s1, size[1]), min(y1 + s0, size[0]), s])
+                lm = []
+                for j in range(5):
+                    lm.append(landmark[0, j * 2 + 1, c0[i], c1[i]] * s1 + x1)
+                    lm.append(landmark[0, j * 2, c0[i], c1[i]] * s0 + y1)
+                lms.append(lm)
+            boxes = np.asarray(boxes, dtype=np.float32)
+            keep = self.nms(boxes[:, :4], boxes[:, 4], 0.3)
+            boxes = boxes[keep, :]
+            lms = np.asarray(lms, dtype=np.float32)
+            lms = lms[keep, :]
+        return boxes, lms
+
+    def nms(self, boxes, scores, nms_thresh):
+        x1 = boxes[:, 0]
+        y1 = boxes[:, 1]
+        x2 = boxes[:, 2]
+        y2 = boxes[:, 3]
+        areas = (x2 - x1 + 1) * (y2 - y1 + 1)
+        order = np.argsort(scores)[::-1]
+        num_detections = boxes.shape[0]
+        suppressed = np.zeros((num_detections,), dtype=bool)
+
+        keep = []
+        for _i in range(num_detections):
+            i = order[_i]
+            if suppressed[i]:
+                continue
+            keep.append(i)
+
+            ix1 = x1[i]
+            iy1 = y1[i]
+            ix2 = x2[i]
+            iy2 = y2[i]
+            iarea = areas[i]
+
+            for _j in range(_i + 1, num_detections):
+                j = order[_j]
+                if suppressed[j]:
+                    continue
+
+                xx1 = max(ix1, x1[j])
+                yy1 = max(iy1, y1[j])
+                xx2 = min(ix2, x2[j])
+                yy2 = min(iy2, y2[j])
+                w = max(0, xx2 - xx1 + 1)
+                h = max(0, yy2 - yy1 + 1)
+
+                inter = w * h
+                ovr = inter / (iarea + areas[j] - inter)
+                if ovr >= nms_thresh:
+                    suppressed[j] = True
+
+        return keep
diff --git a/detectors/DetectorWrapper.py b/detectors/DetectorWrapper.py
new file mode 100644
index 0000000000000000000000000000000000000000..9a5c11b21a7537f4ee734def884f975fddde7920
--- /dev/null
+++ b/detectors/DetectorWrapper.py
@@ -0,0 +1,204 @@
+from typing import Any, List, Tuple
+import numpy as np
+from deepface.modules import detection
+from deepface.models.Detector import Detector, DetectedFace, FacialAreaRegion
+from deepface.detectors import (
+    FastMtCnn,
+    MediaPipe,
+    MtCnn,
+    OpenCv,
+    Dlib,
+    RetinaFace,
+    Ssd,
+    Yolo,
+    YuNet,
+    CenterFace,
+)
+from deepface.commons import logger as log
+
+logger = log.get_singletonish_logger()
+
+
+def build_model(detector_backend: str) -> Any:
+    """
+    Build a face detector model
+    Args:
+        detector_backend (str): backend detector name
+    Returns:
+        built detector (Any)
+    """
+    global face_detector_obj  # singleton design pattern
+
+    backends = {
+        "opencv": OpenCv.OpenCvClient,
+        "mtcnn": MtCnn.MtCnnClient,
+        "ssd": Ssd.SsdClient,
+        "dlib": Dlib.DlibClient,
+        "retinaface": RetinaFace.RetinaFaceClient,
+        "mediapipe": MediaPipe.MediaPipeClient,
+        "yolov8": Yolo.YoloClient,
+        "yunet": YuNet.YuNetClient,
+        "fastmtcnn": FastMtCnn.FastMtCnnClient,
+        "centerface": CenterFace.CenterFaceClient,
+    }
+
+    if not "face_detector_obj" in globals():
+        face_detector_obj = {}
+
+    built_models = list(face_detector_obj.keys())
+    if detector_backend not in built_models:
+        face_detector = backends.get(detector_backend)
+
+        if face_detector:
+            face_detector = face_detector()
+            face_detector_obj[detector_backend] = face_detector
+        else:
+            raise ValueError("invalid detector_backend passed - " + detector_backend)
+
+    return face_detector_obj[detector_backend]
+
+
+def detect_faces(
+    detector_backend: str, img: np.ndarray, align: bool = True, expand_percentage: int = 0
+) -> List[DetectedFace]:
+    """
+    Detect face(s) from a given image
+    Args:
+        detector_backend (str): detector name
+
+        img (np.ndarray): pre-loaded image
+
+        align (bool): enable or disable alignment after detection
+
+        expand_percentage (int): expand detected facial area with a percentage (default is 0).
+
+    Returns:
+        results (List[DetectedFace]): A list of DetectedFace objects
+            where each object contains:
+
+        - img (np.ndarray): The detected face as a NumPy array.
+
+        - facial_area (FacialAreaRegion): The facial area region represented as x, y, w, h,
+            left_eye and right eye. left eye and right eye are eyes on the left and right
+            with respect to the person instead of observer.
+
+        - confidence (float): The confidence score associated with the detected face.
+    """
+    face_detector: Detector = build_model(detector_backend)
+
+    # validate expand percentage score
+    if expand_percentage < 0:
+        logger.warn(
+            f"Expand percentage cannot be negative but you set it to {expand_percentage}."
+            "Overwritten it to 0."
+        )
+        expand_percentage = 0
+
+    # find facial areas of given image
+    facial_areas = face_detector.detect_faces(img)
+
+    results = []
+    for facial_area in facial_areas:
+        x = facial_area.x
+        y = facial_area.y
+        w = facial_area.w
+        h = facial_area.h
+        left_eye = facial_area.left_eye
+        right_eye = facial_area.right_eye
+        confidence = facial_area.confidence
+
+        if expand_percentage > 0:
+            # Expand the facial region height and width by the provided percentage
+            # ensuring that the expanded region stays within img.shape limits
+            expanded_w = w + int(w * expand_percentage / 100)
+            expanded_h = h + int(h * expand_percentage / 100)
+
+            x = max(0, x - int((expanded_w - w) / 2))
+            y = max(0, y - int((expanded_h - h) / 2))
+            w = min(img.shape[1] - x, expanded_w)
+            h = min(img.shape[0] - y, expanded_h)
+
+        # extract detected face unaligned
+        detected_face = img[int(y) : int(y + h), int(x) : int(x + w)]
+
+        # align original image, then find projection of detected face area after alignment
+        if align is True:  # and left_eye is not None and right_eye is not None:
+            aligned_img, angle = detection.align_face(
+                img=img, left_eye=left_eye, right_eye=right_eye
+            )
+            rotated_x1, rotated_y1, rotated_x2, rotated_y2 = rotate_facial_area(
+                facial_area=(x, y, x + w, y + h), angle=angle, size=(img.shape[0], img.shape[1])
+            )
+            detected_face = aligned_img[
+                int(rotated_y1) : int(rotated_y2), int(rotated_x1) : int(rotated_x2)
+            ]
+
+        result = DetectedFace(
+            img=detected_face,
+            facial_area=FacialAreaRegion(
+                x=x, y=y, h=h, w=w, confidence=confidence, left_eye=left_eye, right_eye=right_eye
+            ),
+            confidence=confidence,
+        )
+        results.append(result)
+    return results
+
+
+def rotate_facial_area(
+    facial_area: Tuple[int, int, int, int], angle: float, size: Tuple[int, int]
+) -> Tuple[int, int, int, int]:
+    """
+    Rotate the facial area around its center.
+    Inspried from the work of @UmutDeniz26 - github.com/serengil/retinaface/pull/80
+
+    Args:
+        facial_area (tuple of int): Representing the (x1, y1, x2, y2) of the facial area.
+            x2 is equal to x1 + w1, and y2 is equal to y1 + h1
+        angle (float): Angle of rotation in degrees. Its sign determines the direction of rotation.
+                       Note that angles > 360 degrees are normalized to the range [0, 360).
+        size (tuple of int): Tuple representing the size of the image (width, height).
+
+    Returns:
+        rotated_coordinates (tuple of int): Representing the new coordinates
+            (x1, y1, x2, y2) or (x1, y1, x1+w1, y1+h1) of the rotated facial area.
+    """
+
+    # Normalize the witdh of the angle so we don't have to
+    # worry about rotations greater than 360 degrees.
+    # We workaround the quirky behavior of the modulo operator
+    # for negative angle values.
+    direction = 1 if angle >= 0 else -1
+    angle = abs(angle) % 360
+    if angle == 0:
+        return facial_area
+
+    # Angle in radians
+    angle = angle * np.pi / 180
+
+    height, weight = size
+
+    # Translate the facial area to the center of the image
+    x = (facial_area[0] + facial_area[2]) / 2 - weight / 2
+    y = (facial_area[1] + facial_area[3]) / 2 - height / 2
+
+    # Rotate the facial area
+    x_new = x * np.cos(angle) + y * direction * np.sin(angle)
+    y_new = -x * direction * np.sin(angle) + y * np.cos(angle)
+
+    # Translate the facial area back to the original position
+    x_new = x_new + weight / 2
+    y_new = y_new + height / 2
+
+    # Calculate projected coordinates after alignment
+    x1 = x_new - (facial_area[2] - facial_area[0]) / 2
+    y1 = y_new - (facial_area[3] - facial_area[1]) / 2
+    x2 = x_new + (facial_area[2] - facial_area[0]) / 2
+    y2 = y_new + (facial_area[3] - facial_area[1]) / 2
+
+    # validate projected coordinates are in image's boundaries
+    x1 = max(int(x1), 0)
+    y1 = max(int(y1), 0)
+    x2 = min(int(x2), weight)
+    y2 = min(int(y2), height)
+
+    return (x1, y1, x2, y2)
diff --git a/detectors/Dlib.py b/detectors/Dlib.py
new file mode 100644
index 0000000000000000000000000000000000000000..0699efbb3f4e5ab7c6d86fb3c59dc2b567f5246f
--- /dev/null
+++ b/detectors/Dlib.py
@@ -0,0 +1,114 @@
+from typing import List
+import os
+import bz2
+import gdown
+import numpy as np
+from deepface.commons import folder_utils
+from deepface.models.Detector import Detector, FacialAreaRegion
+from deepface.commons import logger as log
+
+logger = log.get_singletonish_logger()
+
+
+class DlibClient(Detector):
+    def __init__(self):
+        self.model = self.build_model()
+
+    def build_model(self) -> dict:
+        """
+        Build a dlib hog face detector model
+        Returns:
+            model (Any)
+        """
+        home = folder_utils.get_deepface_home()
+
+        # this is not a must dependency. do not import it in the global level.
+        try:
+            import dlib
+        except ModuleNotFoundError as e:
+            raise ImportError(
+                "Dlib is an optional detector, ensure the library is installed."
+                "Please install using 'pip install dlib' "
+            ) from e
+
+        # check required file exists in the home/.deepface/weights folder
+        if os.path.isfile(home + "/.deepface/weights/shape_predictor_5_face_landmarks.dat") != True:
+
+            file_name = "shape_predictor_5_face_landmarks.dat.bz2"
+            logger.info(f"{file_name} is going to be downloaded")
+
+            url = f"http://dlib.net/files/{file_name}"
+            output = f"{home}/.deepface/weights/{file_name}"
+
+            gdown.download(url, output, quiet=False)
+
+            zipfile = bz2.BZ2File(output)
+            data = zipfile.read()
+            newfilepath = output[:-4]  # discard .bz2 extension
+            with open(newfilepath, "wb") as f:
+                f.write(data)
+
+        face_detector = dlib.get_frontal_face_detector()
+        sp = dlib.shape_predictor(home + "/.deepface/weights/shape_predictor_5_face_landmarks.dat")
+
+        detector = {}
+        detector["face_detector"] = face_detector
+        detector["sp"] = sp
+        return detector
+
+    def detect_faces(self, img: np.ndarray) -> List[FacialAreaRegion]:
+        """
+        Detect and align face with dlib
+
+        Args:
+            img (np.ndarray): pre-loaded image as numpy array
+
+        Returns:
+            results (List[FacialAreaRegion]): A list of FacialAreaRegion objects
+        """
+        resp = []
+
+        face_detector = self.model["face_detector"]
+
+        # note that, by design, dlib's fhog face detector scores are >0 but not capped at 1
+        detections, scores, _ = face_detector.run(img, 1)
+
+        if len(detections) > 0:
+
+            for idx, detection in enumerate(detections):
+                left = detection.left()
+                right = detection.right()
+                top = detection.top()
+                bottom = detection.bottom()
+
+                y = int(max(0, top))
+                h = int(min(bottom, img.shape[0]) - y)
+                x = int(max(0, left))
+                w = int(min(right, img.shape[1]) - x)
+
+                shape = self.model["sp"](img, detection)
+
+                right_eye = (
+                    int((shape.part(2).x + shape.part(3).x) // 2),
+                    int((shape.part(2).y + shape.part(3).y) // 2),
+                )
+                left_eye = (
+                    int((shape.part(0).x + shape.part(1).x) // 2),
+                    int((shape.part(0).y + shape.part(1).y) // 2),
+                )
+
+                # never saw confidence higher than +3.5 github.com/davisking/dlib/issues/761
+                confidence = scores[idx]
+
+                facial_area = FacialAreaRegion(
+                    x=x,
+                    y=y,
+                    w=w,
+                    h=h,
+                    left_eye=left_eye,
+                    right_eye=right_eye,
+                    confidence=min(max(0, confidence), 1.0),
+                )
+                resp.append(facial_area)
+
+        return resp
diff --git a/detectors/FastMtCnn.py b/detectors/FastMtCnn.py
new file mode 100644
index 0000000000000000000000000000000000000000..ee8e69c124f87b2f801c9ec0c89d334a1edfd8f5
--- /dev/null
+++ b/detectors/FastMtCnn.py
@@ -0,0 +1,89 @@
+from typing import Any, Union, List
+import cv2
+import numpy as np
+from deepface.models.Detector import Detector, FacialAreaRegion
+
+# Link -> https://github.com/timesler/facenet-pytorch
+# Examples https://www.kaggle.com/timesler/guide-to-mtcnn-in-facenet-pytorch
+
+
+class FastMtCnnClient(Detector):
+    def __init__(self):
+        self.model = self.build_model()
+
+    def detect_faces(self, img: np.ndarray) -> List[FacialAreaRegion]:
+        """
+        Detect and align face with mtcnn
+
+        Args:
+            img (np.ndarray): pre-loaded image as numpy array
+
+        Returns:
+            results (List[FacialAreaRegion]): A list of FacialAreaRegion objects
+        """
+        resp = []
+
+        img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)  # mtcnn expects RGB but OpenCV read BGR
+        detections = self.model.detect(
+            img_rgb, landmarks=True
+        )  # returns boundingbox, prob, landmark
+        if (
+            detections is not None
+            and len(detections) > 0
+            and not any(detection is None for detection in detections)  # issue 1043
+        ):
+            for regions, confidence, eyes in zip(*detections):
+                x, y, w, h = xyxy_to_xywh(regions)
+                right_eye = eyes[0]
+                left_eye = eyes[1]
+
+                left_eye = tuple(int(i) for i in left_eye)
+                right_eye = tuple(int(i) for i in right_eye)
+
+                facial_area = FacialAreaRegion(
+                    x=x,
+                    y=y,
+                    w=w,
+                    h=h,
+                    left_eye=left_eye,
+                    right_eye=right_eye,
+                    confidence=confidence,
+                )
+                resp.append(facial_area)
+
+        return resp
+
+    def build_model(self) -> Any:
+        """
+        Build a fast mtcnn face detector model
+        Returns:
+            model (Any)
+        """
+        # this is not a must dependency. do not import it in the global level.
+        try:
+            from facenet_pytorch import MTCNN as fast_mtcnn
+            import torch
+        except ModuleNotFoundError as e:
+            raise ImportError(
+                "FastMtcnn is an optional detector, ensure the library is installed."
+                "Please install using 'pip install facenet-pytorch' "
+            ) from e
+
+        device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
+        face_detector = fast_mtcnn(device=device)
+
+        return face_detector
+
+
+def xyxy_to_xywh(regions: Union[list, tuple]) -> tuple:
+    """
+    Convert (x1, y1, x2, y2) format to (x, y, w, h) format.
+    Args:
+        regions (list or tuple): facial area coordinates as x, y, x+w, y+h
+    Returns:
+        regions (tuple): facial area coordinates as x, y, w, h
+    """
+    x, y, x_plus_w, y_plus_h = regions[0], regions[1], regions[2], regions[3]
+    w = x_plus_w - x
+    h = y_plus_h - y
+    return (x, y, w, h)
diff --git a/detectors/MediaPipe.py b/detectors/MediaPipe.py
new file mode 100644
index 0000000000000000000000000000000000000000..099b0d40b158a28d5f0091136e1959d54ff18470
--- /dev/null
+++ b/detectors/MediaPipe.py
@@ -0,0 +1,76 @@
+from typing import Any, List
+import numpy as np
+from deepface.models.Detector import Detector, FacialAreaRegion
+
+# Link - https://google.github.io/mediapipe/solutions/face_detection
+
+
+class MediaPipeClient(Detector):
+    def __init__(self):
+        self.model = self.build_model()
+
+    def build_model(self) -> Any:
+        """
+        Build a mediapipe face detector model
+        Returns:
+            model (Any)
+        """
+        # this is not a must dependency. do not import it in the global level.
+        try:
+            import mediapipe as mp
+        except ModuleNotFoundError as e:
+            raise ImportError(
+                "MediaPipe is an optional detector, ensure the library is installed."
+                "Please install using 'pip install mediapipe' "
+            ) from e
+
+        mp_face_detection = mp.solutions.face_detection
+        face_detection = mp_face_detection.FaceDetection(min_detection_confidence=0.7)
+        return face_detection
+
+    def detect_faces(self, img: np.ndarray) -> List[FacialAreaRegion]:
+        """
+        Detect and align face with mediapipe
+
+        Args:
+            img (np.ndarray): pre-loaded image as numpy array
+
+        Returns:
+            results (List[FacialAreaRegion]): A list of FacialAreaRegion objects
+        """
+        resp = []
+
+        img_width = img.shape[1]
+        img_height = img.shape[0]
+
+        results = self.model.process(img)
+
+        # If no face has been detected, return an empty list
+        if results.detections is None:
+            return resp
+
+        # Extract the bounding box, the landmarks and the confidence score
+        for current_detection in results.detections:
+            (confidence,) = current_detection.score
+
+            bounding_box = current_detection.location_data.relative_bounding_box
+            landmarks = current_detection.location_data.relative_keypoints
+
+            x = int(bounding_box.xmin * img_width)
+            w = int(bounding_box.width * img_width)
+            y = int(bounding_box.ymin * img_height)
+            h = int(bounding_box.height * img_height)
+
+            right_eye = (int(landmarks[0].x * img_width), int(landmarks[0].y * img_height))
+            left_eye = (int(landmarks[1].x * img_width), int(landmarks[1].y * img_height))
+            # nose = (int(landmarks[2].x * img_width), int(landmarks[2].y * img_height))
+            # mouth = (int(landmarks[3].x * img_width), int(landmarks[3].y * img_height))
+            # right_ear = (int(landmarks[4].x * img_width), int(landmarks[4].y * img_height))
+            # left_ear = (int(landmarks[5].x * img_width), int(landmarks[5].y * img_height))
+
+            facial_area = FacialAreaRegion(
+                x=x, y=y, w=w, h=h, left_eye=left_eye, right_eye=right_eye, confidence=confidence
+            )
+            resp.append(facial_area)
+
+        return resp
diff --git a/detectors/MtCnn.py b/detectors/MtCnn.py
new file mode 100644
index 0000000000000000000000000000000000000000..527c9e5bf17078603b1d68051f217f461c364b5b
--- /dev/null
+++ b/detectors/MtCnn.py
@@ -0,0 +1,55 @@
+from typing import List
+import numpy as np
+from mtcnn import MTCNN
+from deepface.models.Detector import Detector, FacialAreaRegion
+
+# pylint: disable=too-few-public-methods
+class MtCnnClient(Detector):
+    """
+    Class to cover common face detection functionalitiy for MtCnn backend
+    """
+
+    def __init__(self):
+        self.model = MTCNN()
+
+    def detect_faces(self, img: np.ndarray) -> List[FacialAreaRegion]:
+        """
+        Detect and align face with mtcnn
+
+        Args:
+            img (np.ndarray): pre-loaded image as numpy array
+
+        Returns:
+            results (List[FacialAreaRegion]): A list of FacialAreaRegion objects
+        """
+
+        resp = []
+
+        # mtcnn expects RGB but OpenCV read BGR
+        # img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+        img_rgb = img[:, :, ::-1]
+        detections = self.model.detect_faces(img_rgb)
+
+        if detections is not None and len(detections) > 0:
+
+            for current_detection in detections:
+                x, y, w, h = current_detection["box"]
+                confidence = current_detection["confidence"]
+                # mtcnn detector assigns left eye with respect to the observer
+                # but we are setting it with respect to the person itself
+                left_eye = current_detection["keypoints"]["right_eye"]
+                right_eye = current_detection["keypoints"]["left_eye"]
+
+                facial_area = FacialAreaRegion(
+                    x=x,
+                    y=y,
+                    w=w,
+                    h=h,
+                    left_eye=left_eye,
+                    right_eye=right_eye,
+                    confidence=confidence,
+                )
+
+                resp.append(facial_area)
+
+        return resp
diff --git a/detectors/OpenCv.py b/detectors/OpenCv.py
new file mode 100644
index 0000000000000000000000000000000000000000..9b59d7da206f270a5e93428ba423845198c26e49
--- /dev/null
+++ b/detectors/OpenCv.py
@@ -0,0 +1,178 @@
+import os
+from typing import Any, List
+import cv2
+import numpy as np
+from deepface.models.Detector import Detector, FacialAreaRegion
+
+
+class OpenCvClient(Detector):
+    """
+    Class to cover common face detection functionalitiy for OpenCv backend
+    """
+
+    def __init__(self):
+        self.model = self.build_model()
+
+    def build_model(self):
+        """
+        Build opencv's face and eye detector models
+        Returns:
+            model (dict): including face_detector and eye_detector keys
+        """
+        detector = {}
+        detector["face_detector"] = self.__build_cascade("haarcascade")
+        detector["eye_detector"] = self.__build_cascade("haarcascade_eye")
+        return detector
+
+    def detect_faces(self, img: np.ndarray) -> List[FacialAreaRegion]:
+        """
+        Detect and align face with opencv
+
+        Args:
+            img (np.ndarray): pre-loaded image as numpy array
+
+        Returns:
+            results (List[FacialAreaRegion]): A list of FacialAreaRegion objects
+        """
+        resp = []
+
+        detected_face = None
+
+        faces = []
+        try:
+            # faces = detector["face_detector"].detectMultiScale(img, 1.3, 5)
+
+            # note that, by design, opencv's haarcascade scores are >0 but not capped at 1
+            faces, _, scores = self.model["face_detector"].detectMultiScale3(
+                img, 1.1, 10, outputRejectLevels=True
+            )
+        except:
+            pass
+
+        if len(faces) > 0:
+            for (x, y, w, h), confidence in zip(faces, scores):
+                detected_face = img[int(y) : int(y + h), int(x) : int(x + w)]
+                left_eye, right_eye = self.find_eyes(img=detected_face)
+
+                # eyes found in the detected face instead image itself
+                # detected face's coordinates should be added
+                if left_eye is not None:
+                    left_eye = (int(x + left_eye[0]), int(y + left_eye[1]))
+                if right_eye is not None:
+                    right_eye = (int(x + right_eye[0]), int(y + right_eye[1]))
+
+                facial_area = FacialAreaRegion(
+                    x=x,
+                    y=y,
+                    w=w,
+                    h=h,
+                    left_eye=left_eye,
+                    right_eye=right_eye,
+                    confidence=(100 - confidence) / 100,
+                )
+                resp.append(facial_area)
+
+        return resp
+
+    def find_eyes(self, img: np.ndarray) -> tuple:
+        """
+        Find the left and right eye coordinates of given image
+        Args:
+            img (np.ndarray): given image
+        Returns:
+            left and right eye (tuple)
+        """
+        left_eye = None
+        right_eye = None
+
+        # if image has unexpectedly 0 dimension then skip alignment
+        if img.shape[0] == 0 or img.shape[1] == 0:
+            return left_eye, right_eye
+
+        detected_face_gray = cv2.cvtColor(
+            img, cv2.COLOR_BGR2GRAY
+        )  # eye detector expects gray scale image
+
+        eyes = self.model["eye_detector"].detectMultiScale(detected_face_gray, 1.1, 10)
+
+        # ----------------------------------------------------------------
+
+        # opencv eye detection module is not strong. it might find more than 2 eyes!
+        # besides, it returns eyes with different order in each call (issue 435)
+        # this is an important issue because opencv is the default detector and ssd also uses this
+        # find the largest 2 eye. Thanks to @thelostpeace
+
+        eyes = sorted(eyes, key=lambda v: abs(v[2] * v[3]), reverse=True)
+
+        # ----------------------------------------------------------------
+        if len(eyes) >= 2:
+            # decide left and right eye
+
+            eye_1 = eyes[0]
+            eye_2 = eyes[1]
+
+            if eye_1[0] < eye_2[0]:
+                right_eye = eye_1
+                left_eye = eye_2
+            else:
+                right_eye = eye_2
+                left_eye = eye_1
+
+            # -----------------------
+            # find center of eyes
+            left_eye = (
+                int(left_eye[0] + (left_eye[2] / 2)),
+                int(left_eye[1] + (left_eye[3] / 2)),
+            )
+            right_eye = (
+                int(right_eye[0] + (right_eye[2] / 2)),
+                int(right_eye[1] + (right_eye[3] / 2)),
+            )
+        return left_eye, right_eye
+
+    def __build_cascade(self, model_name="haarcascade") -> Any:
+        """
+        Build a opencv face&eye detector models
+        Returns:
+            model (Any)
+        """
+        opencv_path = self.__get_opencv_path()
+        if model_name == "haarcascade":
+            face_detector_path = opencv_path + "haarcascade_frontalface_default.xml"
+            if os.path.isfile(face_detector_path) != True:
+                raise ValueError(
+                    "Confirm that opencv is installed on your environment! Expected path ",
+                    face_detector_path,
+                    " violated.",
+                )
+            detector = cv2.CascadeClassifier(face_detector_path)
+
+        elif model_name == "haarcascade_eye":
+            eye_detector_path = opencv_path + "haarcascade_eye.xml"
+            if os.path.isfile(eye_detector_path) != True:
+                raise ValueError(
+                    "Confirm that opencv is installed on your environment! Expected path ",
+                    eye_detector_path,
+                    " violated.",
+                )
+            detector = cv2.CascadeClassifier(eye_detector_path)
+
+        else:
+            raise ValueError(f"unimplemented model_name for build_cascade - {model_name}")
+
+        return detector
+
+    def __get_opencv_path(self) -> str:
+        """
+        Returns where opencv installed
+        Returns:
+            installation_path (str)
+        """
+        opencv_home = cv2.__file__
+        folders = opencv_home.split(os.path.sep)[0:-1]
+
+        path = folders[0]
+        for folder in folders[1:]:
+            path = path + "/" + folder
+
+        return path + "/data/"
diff --git a/detectors/RetinaFace.py b/detectors/RetinaFace.py
new file mode 100644
index 0000000000000000000000000000000000000000..a21a7931837f1099650bb440c7db1d82dea6629b
--- /dev/null
+++ b/detectors/RetinaFace.py
@@ -0,0 +1,59 @@
+from typing import List
+import numpy as np
+from retinaface import RetinaFace as rf
+from deepface.models.Detector import Detector, FacialAreaRegion
+
+# pylint: disable=too-few-public-methods
+class RetinaFaceClient(Detector):
+    def __init__(self):
+        self.model = rf.build_model()
+
+    def detect_faces(self, img: np.ndarray) -> List[FacialAreaRegion]:
+        """
+        Detect and align face with retinaface
+
+        Args:
+            img (np.ndarray): pre-loaded image as numpy array
+
+        Returns:
+            results (List[FacialAreaRegion]): A list of FacialAreaRegion objects
+        """
+        resp = []
+
+        obj = rf.detect_faces(img, model=self.model, threshold=0.9)
+
+        if not isinstance(obj, dict):
+            return resp
+
+        for face_idx in obj.keys():
+            identity = obj[face_idx]
+            detection = identity["facial_area"]
+
+            y = detection[1]
+            h = detection[3] - y
+            x = detection[0]
+            w = detection[2] - x
+
+            # retinaface sets left and right eyes with respect to the person
+            left_eye = identity["landmarks"]["left_eye"]
+            right_eye = identity["landmarks"]["right_eye"]
+
+            # eyes are list of float, need to cast them tuple of int
+            left_eye = tuple(int(i) for i in left_eye)
+            right_eye = tuple(int(i) for i in right_eye)
+
+            confidence = identity["score"]
+
+            facial_area = FacialAreaRegion(
+                x=x,
+                y=y,
+                w=w,
+                h=h,
+                left_eye=left_eye,
+                right_eye=right_eye,
+                confidence=confidence,
+            )
+
+            resp.append(facial_area)
+
+        return resp
diff --git a/detectors/Ssd.py b/detectors/Ssd.py
new file mode 100644
index 0000000000000000000000000000000000000000..a8d68eb0e0c57dab8b370e5b9bbbb409de256262
--- /dev/null
+++ b/detectors/Ssd.py
@@ -0,0 +1,153 @@
+from typing import List
+import os
+import gdown
+import cv2
+import pandas as pd
+import numpy as np
+from deepface.detectors import OpenCv
+from deepface.commons import folder_utils
+from deepface.models.Detector import Detector, FacialAreaRegion
+from deepface.commons import logger as log
+
+logger = log.get_singletonish_logger()
+
+# pylint: disable=line-too-long, c-extension-no-member
+
+
+class SsdClient(Detector):
+    def __init__(self):
+        self.model = self.build_model()
+
+    def build_model(self) -> dict:
+        """
+        Build a ssd detector model
+        Returns:
+            model (dict)
+        """
+
+        home = folder_utils.get_deepface_home()
+
+        # model structure
+        if os.path.isfile(home + "/.deepface/weights/deploy.prototxt") != True:
+
+            logger.info("deploy.prototxt will be downloaded...")
+
+            url = "https://github.com/opencv/opencv/raw/3.4.0/samples/dnn/face_detector/deploy.prototxt"
+
+            output = home + "/.deepface/weights/deploy.prototxt"
+
+            gdown.download(url, output, quiet=False)
+
+        # pre-trained weights
+        if (
+            os.path.isfile(home + "/.deepface/weights/res10_300x300_ssd_iter_140000.caffemodel")
+            != True
+        ):
+
+            logger.info("res10_300x300_ssd_iter_140000.caffemodel will be downloaded...")
+
+            url = "https://github.com/opencv/opencv_3rdparty/raw/dnn_samples_face_detector_20170830/res10_300x300_ssd_iter_140000.caffemodel"
+
+            output = home + "/.deepface/weights/res10_300x300_ssd_iter_140000.caffemodel"
+
+            gdown.download(url, output, quiet=False)
+
+        try:
+            face_detector = cv2.dnn.readNetFromCaffe(
+                home + "/.deepface/weights/deploy.prototxt",
+                home + "/.deepface/weights/res10_300x300_ssd_iter_140000.caffemodel",
+            )
+        except Exception as err:
+            raise ValueError(
+                "Exception while calling opencv.dnn module."
+                + "This is an optional dependency."
+                + "You can install it as pip install opencv-contrib-python."
+            ) from err
+
+        detector = {}
+        detector["face_detector"] = face_detector
+        detector["opencv_module"] = OpenCv.OpenCvClient()
+
+        return detector
+
+    def detect_faces(self, img: np.ndarray) -> List[FacialAreaRegion]:
+        """
+        Detect and align face with ssd
+
+        Args:
+            img (np.ndarray): pre-loaded image as numpy array
+
+        Returns:
+            results (List[FacialAreaRegion]): A list of FacialAreaRegion objects
+        """
+        opencv_module: OpenCv.OpenCvClient = self.model["opencv_module"]
+
+        resp = []
+
+        detected_face = None
+
+        ssd_labels = ["img_id", "is_face", "confidence", "left", "top", "right", "bottom"]
+
+        target_size = (300, 300)
+
+        original_size = img.shape
+
+        current_img = cv2.resize(img, target_size)
+
+        aspect_ratio_x = original_size[1] / target_size[1]
+        aspect_ratio_y = original_size[0] / target_size[0]
+
+        imageBlob = cv2.dnn.blobFromImage(image=current_img)
+
+        face_detector = self.model["face_detector"]
+        face_detector.setInput(imageBlob)
+        detections = face_detector.forward()
+
+        detections_df = pd.DataFrame(detections[0][0], columns=ssd_labels)
+
+        detections_df = detections_df[detections_df["is_face"] == 1]  # 0: background, 1: face
+        detections_df = detections_df[detections_df["confidence"] >= 0.90]
+
+        detections_df["left"] = (detections_df["left"] * 300).astype(int)
+        detections_df["bottom"] = (detections_df["bottom"] * 300).astype(int)
+        detections_df["right"] = (detections_df["right"] * 300).astype(int)
+        detections_df["top"] = (detections_df["top"] * 300).astype(int)
+
+        if detections_df.shape[0] > 0:
+
+            for _, instance in detections_df.iterrows():
+
+                left = instance["left"]
+                right = instance["right"]
+                bottom = instance["bottom"]
+                top = instance["top"]
+                confidence = instance["confidence"]
+
+                x = int(left * aspect_ratio_x)
+                y = int(top * aspect_ratio_y)
+                w = int(right * aspect_ratio_x) - int(left * aspect_ratio_x)
+                h = int(bottom * aspect_ratio_y) - int(top * aspect_ratio_y)
+
+                detected_face = img[int(y) : int(y + h), int(x) : int(x + w)]
+
+                left_eye, right_eye = opencv_module.find_eyes(detected_face)
+
+                # eyes found in the detected face instead image itself
+                # detected face's coordinates should be added
+                if left_eye is not None:
+                    left_eye = (int(x + left_eye[0]), int(y + left_eye[1]))
+                if right_eye is not None:
+                    right_eye = (int(x + right_eye[0]), int(y + right_eye[1]))
+
+                facial_area = FacialAreaRegion(
+                    x=x,
+                    y=y,
+                    w=w,
+                    h=h,
+                    left_eye=left_eye,
+                    right_eye=right_eye,
+                    confidence=confidence,
+                )
+                resp.append(facial_area)
+
+        return resp
diff --git a/detectors/Yolo.py b/detectors/Yolo.py
new file mode 100644
index 0000000000000000000000000000000000000000..5ff1c8079b7b1453573564889c74bec5131f7110
--- /dev/null
+++ b/detectors/Yolo.py
@@ -0,0 +1,101 @@
+import os
+from typing import Any, List
+import numpy as np
+import gdown
+from deepface.models.Detector import Detector, FacialAreaRegion
+from deepface.commons import folder_utils
+from deepface.commons import logger as log
+
+logger = log.get_singletonish_logger()
+
+# Model's weights paths
+PATH = "/.deepface/weights/yolov8n-face.pt"
+
+# Google Drive URL from repo (https://github.com/derronqi/yolov8-face) ~6MB
+WEIGHT_URL = "https://drive.google.com/uc?id=1qcr9DbgsX3ryrz2uU8w4Xm3cOrRywXqb"
+
+
+class YoloClient(Detector):
+    def __init__(self):
+        self.model = self.build_model()
+
+    def build_model(self) -> Any:
+        """
+        Build a yolo detector model
+        Returns:
+            model (Any)
+        """
+
+        # Import the Ultralytics YOLO model
+        try:
+            from ultralytics import YOLO
+        except ModuleNotFoundError as e:
+            raise ImportError(
+                "Yolo is an optional detector, ensure the library is installed. \
+                Please install using 'pip install ultralytics' "
+            ) from e
+
+        weight_path = f"{folder_utils.get_deepface_home()}{PATH}"
+
+        # Download the model's weights if they don't exist
+        if not os.path.isfile(weight_path):
+            logger.info(f"Downloading Yolo weights from {WEIGHT_URL} to {weight_path}...")
+            try:
+                gdown.download(WEIGHT_URL, weight_path, quiet=False)
+            except Exception as err:
+                raise ValueError(
+                    f"Exception while downloading Yolo weights from {WEIGHT_URL}."
+                    f"You may consider to download it to {weight_path} manually."
+                ) from err
+            logger.info(f"Yolo model is just downloaded to {os.path.basename(weight_path)}")
+
+        # Return face_detector
+        return YOLO(weight_path)
+
+    def detect_faces(self, img: np.ndarray) -> List[FacialAreaRegion]:
+        """
+        Detect and align face with yolo
+
+        Args:
+            img (np.ndarray): pre-loaded image as numpy array
+
+        Returns:
+            results (List[FacialAreaRegion]): A list of FacialAreaRegion objects
+        """
+        resp = []
+
+        # Detect faces
+        results = self.model.predict(img, verbose=False, show=False, conf=0.25)[0]
+
+        # For each face, extract the bounding box, the landmarks and confidence
+        for result in results:
+
+            if result.boxes is None or result.keypoints is None:
+                continue
+
+            # Extract the bounding box and the confidence
+            x, y, w, h = result.boxes.xywh.tolist()[0]
+            confidence = result.boxes.conf.tolist()[0]
+
+            # right_eye_conf = result.keypoints.conf[0][0]
+            # left_eye_conf = result.keypoints.conf[0][1]
+            right_eye = result.keypoints.xy[0][0].tolist()
+            left_eye = result.keypoints.xy[0][1].tolist()
+
+            # eyes are list of float, need to cast them tuple of int
+            left_eye = tuple(int(i) for i in left_eye)
+            right_eye = tuple(int(i) for i in right_eye)
+
+            x, y, w, h = int(x - w / 2), int(y - h / 2), int(w), int(h)
+            facial_area = FacialAreaRegion(
+                x=x,
+                y=y,
+                w=w,
+                h=h,
+                left_eye=left_eye,
+                right_eye=right_eye,
+                confidence=confidence,
+            )
+            resp.append(facial_area)
+
+        return resp
diff --git a/detectors/YuNet.py b/detectors/YuNet.py
new file mode 100644
index 0000000000000000000000000000000000000000..c43b80f026641a7d0a94b8fc129ea2310604c4c0
--- /dev/null
+++ b/detectors/YuNet.py
@@ -0,0 +1,133 @@
+# built-in dependencies
+import os
+from typing import Any, List
+
+# 3rd party dependencies
+import cv2
+import numpy as np
+import gdown
+
+# project dependencies
+from deepface.commons import folder_utils
+from deepface.models.Detector import Detector, FacialAreaRegion
+from deepface.commons import logger as log
+
+logger = log.get_singletonish_logger()
+
+
+class YuNetClient(Detector):
+    def __init__(self):
+        self.model = self.build_model()
+
+    def build_model(self) -> Any:
+        """
+        Build a yunet detector model
+        Returns:
+            model (Any)
+        """
+
+        opencv_version = cv2.__version__.split(".")
+        if not len(opencv_version) >= 2:
+            raise ValueError(
+                f"OpenCv's version must have major and minor values but it is {opencv_version}"
+            )
+
+        opencv_version_major = int(opencv_version[0])
+        opencv_version_minor = int(opencv_version[1])
+
+        if opencv_version_major < 4 or (opencv_version_major == 4 and opencv_version_minor < 8):
+            # min requirement: https://github.com/opencv/opencv_zoo/issues/172
+            raise ValueError(f"YuNet requires opencv-python >= 4.8 but you have {cv2.__version__}")
+
+        # pylint: disable=C0301
+        url = "https://github.com/opencv/opencv_zoo/raw/main/models/face_detection_yunet/face_detection_yunet_2023mar.onnx"
+        file_name = "face_detection_yunet_2023mar.onnx"
+        home = folder_utils.get_deepface_home()
+        if os.path.isfile(home + f"/.deepface/weights/{file_name}") is False:
+            logger.info(f"{file_name} will be downloaded...")
+            output = home + f"/.deepface/weights/{file_name}"
+            gdown.download(url, output, quiet=False)
+
+        try:
+            face_detector = cv2.FaceDetectorYN_create(
+                home + f"/.deepface/weights/{file_name}", "", (0, 0)
+            )
+        except Exception as err:
+            raise ValueError(
+                "Exception while calling opencv.FaceDetectorYN_create module."
+                + "This is an optional dependency."
+                + "You can install it as pip install opencv-contrib-python."
+            ) from err
+        return face_detector
+
+    def detect_faces(self, img: np.ndarray) -> List[FacialAreaRegion]:
+        """
+        Detect and align face with yunet
+
+        Args:
+            img (np.ndarray): pre-loaded image as numpy array
+
+        Returns:
+            results (List[FacialAreaRegion]): A list of FacialAreaRegion objects
+        """
+        # FaceDetector.detect_faces does not support score_threshold parameter.
+        # We can set it via environment variable.
+        score_threshold = float(os.environ.get("yunet_score_threshold", "0.9"))
+        resp = []
+        faces = []
+        height, width = img.shape[0], img.shape[1]
+        # resize image if it is too large (Yunet fails to detect faces on large input sometimes)
+        # I picked 640 as a threshold because it is the default value of max_size in Yunet.
+        resized = False
+        r = 1  # resize factor
+        if height > 640 or width > 640:
+            r = 640.0 / max(height, width)
+            img = cv2.resize(img, (int(width * r), int(height * r)))
+            height, width = img.shape[0], img.shape[1]
+            resized = True
+        self.model.setInputSize((width, height))
+        self.model.setScoreThreshold(score_threshold)
+        _, faces = self.model.detect(img)
+        if faces is None:
+            return resp
+        for face in faces:
+            # pylint: disable=W0105
+            """
+            The detection output faces is a two-dimension array of type CV_32F,
+            whose rows are the detected face instances, columns are the location
+            of a face and 5 facial landmarks.
+            The format of each row is as follows:
+            x1, y1, w, h, x_re, y_re, x_le, y_le, x_nt, y_nt,
+            x_rcm, y_rcm, x_lcm, y_lcm,
+            where x1, y1, w, h are the top-left coordinates, width and height of
+            the face bounding box,
+            {x, y}_{re, le, nt, rcm, lcm} stands for the coordinates of right eye,
+            left eye, nose tip, the right corner and left corner of the mouth respectively.
+            """
+            (x, y, w, h, x_le, y_le, x_re, y_re) = list(map(int, face[:8]))
+
+            # YuNet returns negative coordinates if it thinks part of the detected face
+            # is outside the frame.
+            x = max(x, 0)
+            y = max(y, 0)
+            if resized:
+                x, y, w, h = int(x / r), int(y / r), int(w / r), int(h / r)
+                x_re, y_re, x_le, y_le = (
+                    int(x_re / r),
+                    int(y_re / r),
+                    int(x_le / r),
+                    int(y_le / r),
+                )
+            confidence = float(face[-1])
+
+            facial_area = FacialAreaRegion(
+                x=x,
+                y=y,
+                w=w,
+                h=h,
+                confidence=confidence,
+                left_eye=(x_re, y_re),
+                right_eye=(x_le, y_le),
+            )
+            resp.append(facial_area)
+        return resp
diff --git a/detectors/__init__.py b/detectors/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/detectors/__pycache__/CenterFace.cpython-312.pyc b/detectors/__pycache__/CenterFace.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a322ed2382287f6ce47a4b99e7533d23f0861f71
Binary files /dev/null and b/detectors/__pycache__/CenterFace.cpython-312.pyc differ
diff --git a/detectors/__pycache__/DetectorWrapper.cpython-312.pyc b/detectors/__pycache__/DetectorWrapper.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7aa184cda0659d788087d358696e7184c3b4e0a7
Binary files /dev/null and b/detectors/__pycache__/DetectorWrapper.cpython-312.pyc differ
diff --git a/detectors/__pycache__/Dlib.cpython-312.pyc b/detectors/__pycache__/Dlib.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2db16a62096906c5bb697bdc3dc265305fc21256
Binary files /dev/null and b/detectors/__pycache__/Dlib.cpython-312.pyc differ
diff --git a/detectors/__pycache__/FastMtCnn.cpython-312.pyc b/detectors/__pycache__/FastMtCnn.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..03f0d44c45868123b766c4cf6de25fb533477576
Binary files /dev/null and b/detectors/__pycache__/FastMtCnn.cpython-312.pyc differ
diff --git a/detectors/__pycache__/MediaPipe.cpython-312.pyc b/detectors/__pycache__/MediaPipe.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2fb29f3184ed8749528f7b4c91ce60c6df078d92
Binary files /dev/null and b/detectors/__pycache__/MediaPipe.cpython-312.pyc differ
diff --git a/detectors/__pycache__/MtCnn.cpython-312.pyc b/detectors/__pycache__/MtCnn.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d9ffb41c88d4b0f06f9710f134b5acdcdda79c81
Binary files /dev/null and b/detectors/__pycache__/MtCnn.cpython-312.pyc differ
diff --git a/detectors/__pycache__/OpenCv.cpython-312.pyc b/detectors/__pycache__/OpenCv.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ecc629d7792e6d68a1f00c24ceca592fcce2f67b
Binary files /dev/null and b/detectors/__pycache__/OpenCv.cpython-312.pyc differ
diff --git a/detectors/__pycache__/RetinaFace.cpython-312.pyc b/detectors/__pycache__/RetinaFace.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..559badd3057cce3302d51f609ed7269f3cba9577
Binary files /dev/null and b/detectors/__pycache__/RetinaFace.cpython-312.pyc differ
diff --git a/detectors/__pycache__/Ssd.cpython-312.pyc b/detectors/__pycache__/Ssd.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fac51ca6e4eadc6b7e0e611ca3f36e8f0d295b29
Binary files /dev/null and b/detectors/__pycache__/Ssd.cpython-312.pyc differ
diff --git a/detectors/__pycache__/Yolo.cpython-312.pyc b/detectors/__pycache__/Yolo.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a49b6a7eaf056026a988cb620f046dbfafb9b98a
Binary files /dev/null and b/detectors/__pycache__/Yolo.cpython-312.pyc differ
diff --git a/detectors/__pycache__/YuNet.cpython-312.pyc b/detectors/__pycache__/YuNet.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a5d600ea1ad900e461ba391d0acf756386d929f9
Binary files /dev/null and b/detectors/__pycache__/YuNet.cpython-312.pyc differ
diff --git a/detectors/__pycache__/__init__.cpython-312.pyc b/detectors/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..28af10659b18bb1dfe8bb76501142836e7923abd
Binary files /dev/null and b/detectors/__pycache__/__init__.cpython-312.pyc differ
diff --git a/extendedmodels/Age.py b/extendedmodels/Age.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e99995ae93c7c5215d7a7038f91782d4ca022c1
--- /dev/null
+++ b/extendedmodels/Age.py
@@ -0,0 +1,92 @@
+import os
+import gdown
+import numpy as np
+from deepface.basemodels import VGGFace
+from deepface.commons import package_utils, folder_utils
+from deepface.models.Demography import Demography
+from deepface.commons import logger as log
+
+logger = log.get_singletonish_logger()
+
+# ----------------------------------------
+# dependency configurations
+
+tf_version = package_utils.get_tf_major_version()
+
+if tf_version == 1:
+    from keras.models import Model, Sequential
+    from keras.layers import Convolution2D, Flatten, Activation
+else:
+    from tensorflow.keras.models import Model, Sequential
+    from tensorflow.keras.layers import Convolution2D, Flatten, Activation
+
+# ----------------------------------------
+
+# pylint: disable=too-few-public-methods
+class ApparentAgeClient(Demography):
+    """
+    Age model class
+    """
+
+    def __init__(self):
+        self.model = load_model()
+        self.model_name = "Age"
+
+    def predict(self, img: np.ndarray) -> np.float64:
+        age_predictions = self.model.predict(img, verbose=0)[0, :]
+        return find_apparent_age(age_predictions)
+
+
+def load_model(
+    url="https://github.com/serengil/deepface_models/releases/download/v1.0/age_model_weights.h5",
+) -> Model:
+    """
+    Construct age model, download its weights and load
+    Returns:
+        model (Model)
+    """
+
+    model = VGGFace.base_model()
+
+    # --------------------------
+
+    classes = 101
+    base_model_output = Sequential()
+    base_model_output = Convolution2D(classes, (1, 1), name="predictions")(model.layers[-4].output)
+    base_model_output = Flatten()(base_model_output)
+    base_model_output = Activation("softmax")(base_model_output)
+
+    # --------------------------
+
+    age_model = Model(inputs=model.input, outputs=base_model_output)
+
+    # --------------------------
+
+    # load weights
+
+    home = folder_utils.get_deepface_home()
+
+    if os.path.isfile(home + "/.deepface/weights/age_model_weights.h5") != True:
+        logger.info("age_model_weights.h5 will be downloaded...")
+
+        output = home + "/.deepface/weights/age_model_weights.h5"
+        gdown.download(url, output, quiet=False)
+
+    age_model.load_weights(home + "/.deepface/weights/age_model_weights.h5")
+
+    return age_model
+
+    # --------------------------
+
+
+def find_apparent_age(age_predictions: np.ndarray) -> np.float64:
+    """
+    Find apparent age prediction from a given probas of ages
+    Args:
+        age_predictions (?)
+    Returns:
+        apparent_age (float)
+    """
+    output_indexes = np.array(list(range(0, 101)))
+    apparent_age = np.sum(age_predictions * output_indexes)
+    return apparent_age
diff --git a/extendedmodels/Emotion.py b/extendedmodels/Emotion.py
new file mode 100644
index 0000000000000000000000000000000000000000..e0b93bff2324bc2adda67ba854c89aa974e1d416
--- /dev/null
+++ b/extendedmodels/Emotion.py
@@ -0,0 +1,106 @@
+# built-in dependencies
+import os
+
+# 3rd party dependencies
+import gdown
+import numpy as np
+import cv2
+
+# project dependencies
+from deepface.commons import package_utils, folder_utils
+from deepface.models.Demography import Demography
+from deepface.commons import logger as log
+
+logger = log.get_singletonish_logger()
+
+# -------------------------------------------
+# pylint: disable=line-too-long
+# -------------------------------------------
+# dependency configuration
+tf_version = package_utils.get_tf_major_version()
+
+if tf_version == 1:
+    from keras.models import Sequential
+    from keras.layers import Conv2D, MaxPooling2D, AveragePooling2D, Flatten, Dense, Dropout
+else:
+    from tensorflow.keras.models import Sequential
+    from tensorflow.keras.layers import (
+        Conv2D,
+        MaxPooling2D,
+        AveragePooling2D,
+        Flatten,
+        Dense,
+        Dropout,
+    )
+# -------------------------------------------
+
+# Labels for the emotions that can be detected by the model.
+labels = ["angry", "disgust", "fear", "happy", "sad", "surprise", "neutral"]
+
+# pylint: disable=too-few-public-methods
+class EmotionClient(Demography):
+    """
+    Emotion model class
+    """
+
+    def __init__(self):
+        self.model = load_model()
+        self.model_name = "Emotion"
+
+    def predict(self, img: np.ndarray) -> np.ndarray:
+        img_gray = cv2.cvtColor(img[0], cv2.COLOR_BGR2GRAY)
+        img_gray = cv2.resize(img_gray, (48, 48))
+        img_gray = np.expand_dims(img_gray, axis=0)
+
+        emotion_predictions = self.model.predict(img_gray, verbose=0)[0, :]
+        return emotion_predictions
+
+
+def load_model(
+    url="https://github.com/serengil/deepface_models/releases/download/v1.0/facial_expression_model_weights.h5",
+) -> Sequential:
+    """
+    Consruct emotion model, download and load weights
+    """
+
+    num_classes = 7
+
+    model = Sequential()
+
+    # 1st convolution layer
+    model.add(Conv2D(64, (5, 5), activation="relu", input_shape=(48, 48, 1)))
+    model.add(MaxPooling2D(pool_size=(5, 5), strides=(2, 2)))
+
+    # 2nd convolution layer
+    model.add(Conv2D(64, (3, 3), activation="relu"))
+    model.add(Conv2D(64, (3, 3), activation="relu"))
+    model.add(AveragePooling2D(pool_size=(3, 3), strides=(2, 2)))
+
+    # 3rd convolution layer
+    model.add(Conv2D(128, (3, 3), activation="relu"))
+    model.add(Conv2D(128, (3, 3), activation="relu"))
+    model.add(AveragePooling2D(pool_size=(3, 3), strides=(2, 2)))
+
+    model.add(Flatten())
+
+    # fully connected neural networks
+    model.add(Dense(1024, activation="relu"))
+    model.add(Dropout(0.2))
+    model.add(Dense(1024, activation="relu"))
+    model.add(Dropout(0.2))
+
+    model.add(Dense(num_classes, activation="softmax"))
+
+    # ----------------------------
+
+    home = folder_utils.get_deepface_home()
+
+    if os.path.isfile(home + "/.deepface/weights/facial_expression_model_weights.h5") != True:
+        logger.info("facial_expression_model_weights.h5 will be downloaded...")
+
+        output = home + "/.deepface/weights/facial_expression_model_weights.h5"
+        gdown.download(url, output, quiet=False)
+
+    model.load_weights(home + "/.deepface/weights/facial_expression_model_weights.h5")
+
+    return model
diff --git a/extendedmodels/Gender.py b/extendedmodels/Gender.py
new file mode 100644
index 0000000000000000000000000000000000000000..84cb4465eacadcebb562629c6a94b7244ef42596
--- /dev/null
+++ b/extendedmodels/Gender.py
@@ -0,0 +1,84 @@
+# built-in dependencies
+import os
+
+# 3rd party dependencies
+import gdown
+import numpy as np
+
+# project dependencies
+from deepface.basemodels import VGGFace
+from deepface.commons import package_utils, folder_utils
+from deepface.models.Demography import Demography
+from deepface.commons import logger as log
+
+logger = log.get_singletonish_logger()
+
+# -------------------------------------
+# pylint: disable=line-too-long
+# -------------------------------------
+# dependency configurations
+
+tf_version = package_utils.get_tf_major_version()
+if tf_version == 1:
+    from keras.models import Model, Sequential
+    from keras.layers import Convolution2D, Flatten, Activation
+else:
+    from tensorflow.keras.models import Model, Sequential
+    from tensorflow.keras.layers import Convolution2D, Flatten, Activation
+# -------------------------------------
+
+# Labels for the genders that can be detected by the model.
+labels = ["Woman", "Man"]
+
+# pylint: disable=too-few-public-methods
+class GenderClient(Demography):
+    """
+    Gender model class
+    """
+
+    def __init__(self):
+        self.model = load_model()
+        self.model_name = "Gender"
+
+    def predict(self, img: np.ndarray) -> np.ndarray:
+        return self.model.predict(img, verbose=0)[0, :]
+
+
+def load_model(
+    url="https://github.com/serengil/deepface_models/releases/download/v1.0/gender_model_weights.h5",
+) -> Model:
+    """
+    Construct gender model, download its weights and load
+    Returns:
+        model (Model)
+    """
+
+    model = VGGFace.base_model()
+
+    # --------------------------
+
+    classes = 2
+    base_model_output = Sequential()
+    base_model_output = Convolution2D(classes, (1, 1), name="predictions")(model.layers[-4].output)
+    base_model_output = Flatten()(base_model_output)
+    base_model_output = Activation("softmax")(base_model_output)
+
+    # --------------------------
+
+    gender_model = Model(inputs=model.input, outputs=base_model_output)
+
+    # --------------------------
+
+    # load weights
+
+    home = folder_utils.get_deepface_home()
+
+    if os.path.isfile(home + "/.deepface/weights/gender_model_weights.h5") != True:
+        logger.info("gender_model_weights.h5 will be downloaded...")
+
+        output = home + "/.deepface/weights/gender_model_weights.h5"
+        gdown.download(url, output, quiet=False)
+
+    gender_model.load_weights(home + "/.deepface/weights/gender_model_weights.h5")
+
+    return gender_model
diff --git a/extendedmodels/Race.py b/extendedmodels/Race.py
new file mode 100644
index 0000000000000000000000000000000000000000..1943dea9ebb4fae37fc86de4a541917c0b6131be
--- /dev/null
+++ b/extendedmodels/Race.py
@@ -0,0 +1,81 @@
+# built-in dependencies
+import os
+
+# 3rd party dependencies
+import gdown
+import numpy as np
+
+# project dependencies
+from deepface.basemodels import VGGFace
+from deepface.commons import package_utils, folder_utils
+from deepface.models.Demography import Demography
+from deepface.commons import logger as log
+
+logger = log.get_singletonish_logger()
+
+# --------------------------
+# pylint: disable=line-too-long
+# --------------------------
+# dependency configurations
+tf_version = package_utils.get_tf_major_version()
+
+if tf_version == 1:
+    from keras.models import Model, Sequential
+    from keras.layers import Convolution2D, Flatten, Activation
+else:
+    from tensorflow.keras.models import Model, Sequential
+    from tensorflow.keras.layers import Convolution2D, Flatten, Activation
+# --------------------------
+# Labels for the ethnic phenotypes that can be detected by the model.
+labels = ["asian", "indian", "black", "white", "middle eastern", "latino hispanic"]
+
+# pylint: disable=too-few-public-methods
+class RaceClient(Demography):
+    """
+    Race model class
+    """
+
+    def __init__(self):
+        self.model = load_model()
+        self.model_name = "Race"
+
+    def predict(self, img: np.ndarray) -> np.ndarray:
+        return self.model.predict(img, verbose=0)[0, :]
+
+
+def load_model(
+    url="https://github.com/serengil/deepface_models/releases/download/v1.0/race_model_single_batch.h5",
+) -> Model:
+    """
+    Construct race model, download its weights and load
+    """
+
+    model = VGGFace.base_model()
+
+    # --------------------------
+
+    classes = 6
+    base_model_output = Sequential()
+    base_model_output = Convolution2D(classes, (1, 1), name="predictions")(model.layers[-4].output)
+    base_model_output = Flatten()(base_model_output)
+    base_model_output = Activation("softmax")(base_model_output)
+
+    # --------------------------
+
+    race_model = Model(inputs=model.input, outputs=base_model_output)
+
+    # --------------------------
+
+    # load weights
+
+    home = folder_utils.get_deepface_home()
+
+    if os.path.isfile(home + "/.deepface/weights/race_model_single_batch.h5") != True:
+        logger.info("race_model_single_batch.h5 will be downloaded...")
+
+        output = home + "/.deepface/weights/race_model_single_batch.h5"
+        gdown.download(url, output, quiet=False)
+
+    race_model.load_weights(home + "/.deepface/weights/race_model_single_batch.h5")
+
+    return race_model
diff --git a/extendedmodels/__init__.py b/extendedmodels/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/extendedmodels/__pycache__/Age.cpython-312.pyc b/extendedmodels/__pycache__/Age.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..55c63f3ed82d7fa82d4384f8f79f8b1c0c7db4a4
Binary files /dev/null and b/extendedmodels/__pycache__/Age.cpython-312.pyc differ
diff --git a/extendedmodels/__pycache__/Emotion.cpython-312.pyc b/extendedmodels/__pycache__/Emotion.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..12baf9ab35c2ccc7b18e18f3c09d9732900a648b
Binary files /dev/null and b/extendedmodels/__pycache__/Emotion.cpython-312.pyc differ
diff --git a/extendedmodels/__pycache__/Gender.cpython-312.pyc b/extendedmodels/__pycache__/Gender.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7c767f14c6d1c05c5360a809c0a107287a7532f7
Binary files /dev/null and b/extendedmodels/__pycache__/Gender.cpython-312.pyc differ
diff --git a/extendedmodels/__pycache__/Race.cpython-312.pyc b/extendedmodels/__pycache__/Race.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bebe66b8c639df068160ecd103dbdfda79bdff23
Binary files /dev/null and b/extendedmodels/__pycache__/Race.cpython-312.pyc differ
diff --git a/extendedmodels/__pycache__/__init__.cpython-312.pyc b/extendedmodels/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8338741c319b0bbce3b28144c3079f1ba99c935f
Binary files /dev/null and b/extendedmodels/__pycache__/__init__.cpython-312.pyc differ
diff --git a/models/Demography.py b/models/Demography.py
new file mode 100644
index 0000000000000000000000000000000000000000..ad9392029307f7539095e2d0372df1cec81ec0c0
--- /dev/null
+++ b/models/Demography.py
@@ -0,0 +1,22 @@
+from typing import Union
+from abc import ABC, abstractmethod
+import numpy as np
+from deepface.commons import package_utils
+
+tf_version = package_utils.get_tf_major_version()
+if tf_version == 1:
+    from keras.models import Model
+else:
+    from tensorflow.keras.models import Model
+
+# Notice that all facial attribute analysis models must be inherited from this class
+
+
+# pylint: disable=too-few-public-methods
+class Demography(ABC):
+    model: Model
+    model_name: str
+
+    @abstractmethod
+    def predict(self, img: np.ndarray) -> Union[np.ndarray, np.float64]:
+        pass
diff --git a/models/Detector.py b/models/Detector.py
new file mode 100644
index 0000000000000000000000000000000000000000..0a1e48d29b791cf5f0159f451a74a85bdc603432
--- /dev/null
+++ b/models/Detector.py
@@ -0,0 +1,89 @@
+from typing import List, Tuple, Optional
+from abc import ABC, abstractmethod
+import numpy as np
+
+# Notice that all facial detector models must be inherited from this class
+
+
+# pylint: disable=unnecessary-pass, too-few-public-methods
+class Detector(ABC):
+    @abstractmethod
+    def detect_faces(self, img: np.ndarray) -> List["FacialAreaRegion"]:
+        """
+        Interface for detect and align face
+
+        Args:
+            img (np.ndarray): pre-loaded image as numpy array
+
+        Returns:
+            results (List[FacialAreaRegion]): A list of FacialAreaRegion objects
+                where each object contains:
+
+            - facial_area (FacialAreaRegion): The facial area region represented
+                as x, y, w, h, left_eye and right_eye. left eye and right eye are
+                eyes on the left and right respectively with respect to the person
+                instead of observer.
+        """
+        pass
+
+
+class FacialAreaRegion:
+    x: int
+    y: int
+    w: int
+    h: int
+    left_eye: Tuple[int, int]
+    right_eye: Tuple[int, int]
+    confidence: float
+
+    def __init__(
+        self,
+        x: int,
+        y: int,
+        w: int,
+        h: int,
+        left_eye: Optional[Tuple[int, int]] = None,
+        right_eye: Optional[Tuple[int, int]] = None,
+        confidence: Optional[float] = None,
+    ):
+        """
+        Initialize a Face object.
+
+        Args:
+            x (int): The x-coordinate of the top-left corner of the bounding box.
+            y (int): The y-coordinate of the top-left corner of the bounding box.
+            w (int): The width of the bounding box.
+            h (int): The height of the bounding box.
+            left_eye (tuple): The coordinates (x, y) of the left eye with respect to
+                the person instead of observer. Default is None.
+            right_eye (tuple): The coordinates (x, y) of the right eye with respect to
+                the person instead of observer. Default is None.
+            confidence (float, optional): Confidence score associated with the face detection.
+                Default is None.
+        """
+        self.x = x
+        self.y = y
+        self.w = w
+        self.h = h
+        self.left_eye = left_eye
+        self.right_eye = right_eye
+        self.confidence = confidence
+
+
+class DetectedFace:
+    img: np.ndarray
+    facial_area: FacialAreaRegion
+    confidence: float
+
+    def __init__(self, img: np.ndarray, facial_area: FacialAreaRegion, confidence: float):
+        """
+        Initialize detected face object.
+
+        Args:
+            img (np.ndarray): detected face image as numpy array
+            facial_area (FacialAreaRegion): detected face's metadata (e.g. bounding box)
+            confidence (float): confidence score for face detection
+        """
+        self.img = img
+        self.facial_area = facial_area
+        self.confidence = confidence
diff --git a/models/FacialRecognition.py b/models/FacialRecognition.py
new file mode 100644
index 0000000000000000000000000000000000000000..a6ee7b59d3693cb63775d180a3a0089ca7b3ed53
--- /dev/null
+++ b/models/FacialRecognition.py
@@ -0,0 +1,29 @@
+from abc import ABC
+from typing import Any, Union, List, Tuple
+import numpy as np
+from deepface.commons import package_utils
+
+tf_version = package_utils.get_tf_major_version()
+if tf_version == 2:
+    from tensorflow.keras.models import Model
+else:
+    from keras.models import Model
+
+# Notice that all facial recognition models must be inherited from this class
+
+# pylint: disable=too-few-public-methods
+class FacialRecognition(ABC):
+    model: Union[Model, Any]
+    model_name: str
+    input_shape: Tuple[int, int]
+    output_shape: int
+
+    def forward(self, img: np.ndarray) -> List[float]:
+        if not isinstance(self.model, Model):
+            raise ValueError(
+                "You must overwrite forward method if it is not a keras model,"
+                f"but {self.model_name} not overwritten!"
+            )
+        # model.predict causes memory issue when it is called in a for loop
+        # embedding = model.predict(img, verbose=0)[0].tolist()
+        return self.model(img, training=False).numpy()[0].tolist()
diff --git a/models/__init__.py b/models/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/models/__pycache__/Demography.cpython-312.pyc b/models/__pycache__/Demography.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..af3b626079083735a56cbd3a6ca72d912264ac74
Binary files /dev/null and b/models/__pycache__/Demography.cpython-312.pyc differ
diff --git a/models/__pycache__/Detector.cpython-312.pyc b/models/__pycache__/Detector.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ef7ce08a87a7ce15e64fe83fad9d67fe47818591
Binary files /dev/null and b/models/__pycache__/Detector.cpython-312.pyc differ
diff --git a/models/__pycache__/FacialRecognition.cpython-312.pyc b/models/__pycache__/FacialRecognition.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8bc189c2232027e7ff27272299483eaee29c3f70
Binary files /dev/null and b/models/__pycache__/FacialRecognition.cpython-312.pyc differ
diff --git a/models/__pycache__/__init__.cpython-312.pyc b/models/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9e4ccf3993d51eb67e8ce722408aaddc827c0453
Binary files /dev/null and b/models/__pycache__/__init__.cpython-312.pyc differ
diff --git a/modules/__init__.py b/modules/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/modules/__pycache__/__init__.cpython-312.pyc b/modules/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..19226cb8175cb8050a724a3241862dca418cb84a
Binary files /dev/null and b/modules/__pycache__/__init__.cpython-312.pyc differ
diff --git a/modules/__pycache__/cloudservice.cpython-312.pyc b/modules/__pycache__/cloudservice.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..89872657e942464a835b0e4bd32ce403209385c9
Binary files /dev/null and b/modules/__pycache__/cloudservice.cpython-312.pyc differ
diff --git a/modules/__pycache__/demography.cpython-312.pyc b/modules/__pycache__/demography.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..eb30ea97362f9a5f6597c6d6928f8dd49ab527ea
Binary files /dev/null and b/modules/__pycache__/demography.cpython-312.pyc differ
diff --git a/modules/__pycache__/detection.cpython-312.pyc b/modules/__pycache__/detection.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6c0cacc02a9129f4945ad2e97098c539ad7a57fd
Binary files /dev/null and b/modules/__pycache__/detection.cpython-312.pyc differ
diff --git a/modules/__pycache__/modeling.cpython-312.pyc b/modules/__pycache__/modeling.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9104ed4d1b5c28ff59ef1401caf3edcb12bdccf9
Binary files /dev/null and b/modules/__pycache__/modeling.cpython-312.pyc differ
diff --git a/modules/__pycache__/preprocessing.cpython-312.pyc b/modules/__pycache__/preprocessing.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..13c64b0141c9fc2e7a2302c29f1c56fd7588fe40
Binary files /dev/null and b/modules/__pycache__/preprocessing.cpython-312.pyc differ
diff --git a/modules/__pycache__/recognition.cpython-312.pyc b/modules/__pycache__/recognition.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9c35bdce084985aea650eeb04bfd4426aab1d074
Binary files /dev/null and b/modules/__pycache__/recognition.cpython-312.pyc differ
diff --git a/modules/__pycache__/representation.cpython-312.pyc b/modules/__pycache__/representation.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0c74fb06a148093a808c1e53a2a4f53266176f1e
Binary files /dev/null and b/modules/__pycache__/representation.cpython-312.pyc differ
diff --git a/modules/__pycache__/streaming.cpython-312.pyc b/modules/__pycache__/streaming.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..182782529ece35d5aeeea77533116570e56420d6
Binary files /dev/null and b/modules/__pycache__/streaming.cpython-312.pyc differ
diff --git a/modules/__pycache__/verification.cpython-312.pyc b/modules/__pycache__/verification.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..16696d20450beb6f24c0c4503f631103aabe91b5
Binary files /dev/null and b/modules/__pycache__/verification.cpython-312.pyc differ
diff --git a/modules/cloudservice.py b/modules/cloudservice.py
new file mode 100644
index 0000000000000000000000000000000000000000..7a56708491b226a42e026c701c499607e225ba17
--- /dev/null
+++ b/modules/cloudservice.py
@@ -0,0 +1,154 @@
+# from flask import Flask, jsonify
+# import cloudinary
+# import cloudinary.api
+# import cloudinary.uploader
+# import os
+# import glob
+# import requests
+# from dotenv import load_dotenv
+# from deepface.commons.logger import Logger
+
+# logger = Logger(module="modules/cloudservice.py")
+
+# load_dotenv()
+
+# # Configure Cloudinary
+# cloudinary.config(
+#     cloud_name=os.getenv('CLOUDINARY_CLOUD_NAME'),
+#     api_key=os.getenv('CLOUDINARY_API_KEY'),
+#     api_secret=os.getenv('CLOUDINARY_API_SECRET')
+# )
+
+
+# def fetch_cloudinary_images(folder_name):
+
+#     resources = []
+
+#     res = cloudinary.api.resources(type='upload',  resource_type='image', prefix=f'mafqoud/images/{folder_name}')
+#     resources.extend(res.get('resources', []))
+#     return resources
+
+# def download_image(url, local_path):
+#     response = requests.get(url, stream=True)
+#     if response.status_code == 200:
+#         with open(local_path, 'wb') as file:
+#             for chunk in response:
+#                 file.write(chunk)
+
+# def sync_folder(folder_name, local_dir):
+#     cloudinary_images = fetch_cloudinary_images(folder_name)
+#     cloudinary_urls = {img['secure_url']: img['public_id'] for img in cloudinary_images}
+
+#     # Download new images and track downloaded image paths
+#     downloaded_paths = []
+#     for img in cloudinary_images:
+#         url = img['secure_url']
+#         public_id = img['public_id']
+#         file_name = url.split('/')[-1]  # Get the actual file name
+#         local_path = os.path.join(local_dir, file_name)
+#         print(local_path)
+        
+#         if not os.path.exists(local_path):
+#             download_image(url, local_path)
+#         downloaded_paths.append(local_path)
+    
+#     # Remove old images
+#     local_images = [os.path.join(local_dir, f) for f in os.listdir(local_dir) if os.path.isfile(os.path.join(local_dir, f))]
+#     for local_path in local_images:
+#         if local_path not in downloaded_paths and (local_path.endswith('.jpg') or local_path.endswith('.jpeg') or local_path.endswith('.png')):
+#             os.remove(local_path)
+
+# def delete_pkl_files(directory):
+#     """Delete all .pkl files in the specified directory."""
+#     pkl_files = glob.glob(os.path.join(directory, '*.pkl'))
+#     for pkl_file in pkl_files:
+#         os.remove(pkl_file)
+
+
+from flask import Flask, jsonify
+import cloudinary
+import cloudinary.api
+import cloudinary.uploader
+import os
+import glob
+import requests
+from dotenv import load_dotenv
+from deepface.commons.logger import Logger
+from deepface import DeepFace  # Assuming this is the correct import for training
+
+logger = Logger(module="modules/cloudservice.py")
+
+load_dotenv()
+
+# Configure Cloudinary
+cloudinary.config(
+    cloud_name=os.getenv('CLOUDINARY_CLOUD_NAME'),
+    api_key=os.getenv('CLOUDINARY_API_KEY'),
+    api_secret=os.getenv('CLOUDINARY_API_SECRET')
+)
+
+
+def fetch_cloudinary_images(folder_name):
+    resources = []
+    next_cursor = None
+
+    while True:
+        if next_cursor:
+            res = cloudinary.api.resources(
+                type='upload', 
+                resource_type='image', 
+                prefix=f'mafqoud/images/{folder_name}', 
+                max_results=500, 
+                next_cursor=next_cursor
+            )
+        else:
+            res = cloudinary.api.resources(
+                type='upload', 
+                resource_type='image', 
+                prefix=f'mafqoud/images/{folder_name}', 
+                max_results=500
+            )
+
+        resources.extend(res.get('resources', []))
+        next_cursor = res.get('next_cursor')
+
+        if not next_cursor:
+            break
+
+    return resources
+
+def download_image(url, local_path):
+    response = requests.get(url, stream=True)
+    if response.status_code == 200:
+        with open(local_path, 'wb') as file:
+            for chunk in response:
+                file.write(chunk)
+
+def sync_folder(folder_name, local_dir):
+    cloudinary_images = fetch_cloudinary_images(folder_name)
+    cloudinary_urls = {img['secure_url']: img['public_id'] for img in cloudinary_images}
+
+    # Download new images and track downloaded image paths
+    downloaded_paths = []
+    for img in cloudinary_images:
+        url = img['secure_url']
+        public_id = img['public_id']
+        file_name = url.split('/')[-1]  # Get the actual file name
+        local_path = os.path.join(local_dir, file_name)
+        print(local_path)
+        
+        if not os.path.exists(local_path):
+            download_image(url, local_path)
+        downloaded_paths.append(local_path)
+    
+    # Remove old images
+    local_images = [os.path.join(local_dir, f) for f in os.listdir(local_dir) if os.path.isfile(os.path.join(local_dir, f))]
+    for local_path in local_images:
+        if local_path not in downloaded_paths and (local_path.endswith('.jpg') or local_path.endswith('.jpeg') or local_path.endswith('.png')):
+            os.remove(local_path)
+
+def delete_pkl_files(directory):
+    """Delete all .pkl files in the specified directory."""
+    pkl_files = glob.glob(os.path.join(directory, '*.pkl'))
+    for pkl_file in pkl_files:
+        os.remove(pkl_file)
diff --git a/modules/demography.py b/modules/demography.py
new file mode 100644
index 0000000000000000000000000000000000000000..f11f71d1ee63e4df954d85b55ee0278b03d76da0
--- /dev/null
+++ b/modules/demography.py
@@ -0,0 +1,197 @@
+# built-in dependencies
+from typing import Any, Dict, List, Union
+
+# 3rd party dependencies
+import numpy as np
+from tqdm import tqdm
+
+# project dependencies
+from deepface.modules import modeling, detection, preprocessing
+from deepface.extendedmodels import Gender, Race, Emotion
+
+
+def analyze(
+    img_path: Union[str, np.ndarray],
+    actions: Union[tuple, list] = ("emotion", "age", "gender", "race"),
+    enforce_detection: bool = True,
+    detector_backend: str = "opencv",
+    align: bool = True,
+    expand_percentage: int = 0,
+    silent: bool = False,
+) -> List[Dict[str, Any]]:
+    """
+    Analyze facial attributes such as age, gender, emotion, and race in the provided image.
+
+    Args:
+        img_path (str or np.ndarray): The exact path to the image, a numpy array in BGR format,
+            or a base64 encoded image. If the source image contains multiple faces, the result will
+            include information for each detected face.
+
+        actions (tuple): Attributes to analyze. The default is ('age', 'gender', 'emotion', 'race').
+            You can exclude some of these attributes from the analysis if needed.
+
+        enforce_detection (boolean): If no face is detected in an image, raise an exception.
+            Set to False to avoid the exception for low-resolution images (default is True).
+
+        detector_backend (string): face detector backend. Options: 'opencv', 'retinaface',
+            'mtcnn', 'ssd', 'dlib', 'mediapipe', 'yolov8', 'centerface' or 'skip'
+            (default is opencv).
+
+        distance_metric (string): Metric for measuring similarity. Options: 'cosine',
+            'euclidean', 'euclidean_l2' (default is cosine).
+
+        align (boolean): Perform alignment based on the eye positions (default is True).
+
+        expand_percentage (int): expand detected facial area with a percentage (default is 0).
+
+        silent (boolean): Suppress or allow some log messages for a quieter analysis process
+            (default is False).
+
+    Returns:
+        results (List[Dict[str, Any]]): A list of dictionaries, where each dictionary represents
+           the analysis results for a detected face.
+
+           Each dictionary in the list contains the following keys:
+
+           - 'region' (dict): Represents the rectangular region of the detected face in the image.
+               - 'x': x-coordinate of the top-left corner of the face.
+               - 'y': y-coordinate of the top-left corner of the face.
+               - 'w': Width of the detected face region.
+               - 'h': Height of the detected face region.
+
+           - 'age' (float): Estimated age of the detected face.
+
+           - 'face_confidence' (float): Confidence score for the detected face.
+                Indicates the reliability of the face detection.
+
+           - 'dominant_gender' (str): The dominant gender in the detected face.
+                Either "Man" or "Woman."
+
+           - 'gender' (dict): Confidence scores for each gender category.
+               - 'Man': Confidence score for the male gender.
+               - 'Woman': Confidence score for the female gender.
+
+           - 'dominant_emotion' (str): The dominant emotion in the detected face.
+                Possible values include "sad," "angry," "surprise," "fear," "happy,"
+                "disgust," and "neutral."
+
+           - 'emotion' (dict): Confidence scores for each emotion category.
+               - 'sad': Confidence score for sadness.
+               - 'angry': Confidence score for anger.
+               - 'surprise': Confidence score for surprise.
+               - 'fear': Confidence score for fear.
+               - 'happy': Confidence score for happiness.
+               - 'disgust': Confidence score for disgust.
+               - 'neutral': Confidence score for neutrality.
+
+           - 'dominant_race' (str): The dominant race in the detected face.
+                Possible values include "indian," "asian," "latino hispanic,"
+                "black," "middle eastern," and "white."
+
+           - 'race' (dict): Confidence scores for each race category.
+               - 'indian': Confidence score for Indian ethnicity.
+               - 'asian': Confidence score for Asian ethnicity.
+               - 'latino hispanic': Confidence score for Latino/Hispanic ethnicity.
+               - 'black': Confidence score for Black ethnicity.
+               - 'middle eastern': Confidence score for Middle Eastern ethnicity.
+               - 'white': Confidence score for White ethnicity.
+    """
+
+    # if actions is passed as tuple with single item, interestingly it becomes str here
+    if isinstance(actions, str):
+        actions = (actions,)
+
+    # check if actions is not an iterable or empty.
+    if not hasattr(actions, "__getitem__") or not actions:
+        raise ValueError("`actions` must be a list of strings.")
+
+    actions = list(actions)
+
+    # For each action, check if it is valid
+    for action in actions:
+        if action not in ("emotion", "age", "gender", "race"):
+            raise ValueError(
+                f"Invalid action passed ({repr(action)})). "
+                "Valid actions are `emotion`, `age`, `gender`, `race`."
+            )
+    # ---------------------------------
+    resp_objects = []
+
+    img_objs = detection.extract_faces(
+        img_path=img_path,
+        detector_backend=detector_backend,
+        grayscale=False,
+        enforce_detection=enforce_detection,
+        align=align,
+        expand_percentage=expand_percentage,
+    )
+
+    for img_obj in img_objs:
+        img_content = img_obj["face"]
+        img_region = img_obj["facial_area"]
+        img_confidence = img_obj["confidence"]
+        if img_content.shape[0] == 0 or img_content.shape[1] == 0:
+            continue
+
+        # rgb to bgr
+        img_content = img_content[:, :, ::-1]
+
+        # resize input image
+        img_content = preprocessing.resize_image(img=img_content, target_size=(224, 224))
+
+        obj = {}
+        # facial attribute analysis
+        pbar = tqdm(
+            range(0, len(actions)),
+            desc="Finding actions",
+            disable=silent if len(actions) > 1 else True,
+        )
+        for index in pbar:
+            action = actions[index]
+            pbar.set_description(f"Action: {action}")
+
+            if action == "emotion":
+                emotion_predictions = modeling.build_model("Emotion").predict(img_content)
+                sum_of_predictions = emotion_predictions.sum()
+
+                obj["emotion"] = {}
+                for i, emotion_label in enumerate(Emotion.labels):
+                    emotion_prediction = 100 * emotion_predictions[i] / sum_of_predictions
+                    obj["emotion"][emotion_label] = emotion_prediction
+
+                obj["dominant_emotion"] = Emotion.labels[np.argmax(emotion_predictions)]
+
+            elif action == "age":
+                apparent_age = modeling.build_model("Age").predict(img_content)
+                # int cast is for exception - object of type 'float32' is not JSON serializable
+                obj["age"] = int(apparent_age)
+
+            elif action == "gender":
+                gender_predictions = modeling.build_model("Gender").predict(img_content)
+                obj["gender"] = {}
+                for i, gender_label in enumerate(Gender.labels):
+                    gender_prediction = 100 * gender_predictions[i]
+                    obj["gender"][gender_label] = gender_prediction
+
+                obj["dominant_gender"] = Gender.labels[np.argmax(gender_predictions)]
+
+            elif action == "race":
+                race_predictions = modeling.build_model("Race").predict(img_content)
+                sum_of_predictions = race_predictions.sum()
+
+                obj["race"] = {}
+                for i, race_label in enumerate(Race.labels):
+                    race_prediction = 100 * race_predictions[i] / sum_of_predictions
+                    obj["race"][race_label] = race_prediction
+
+                obj["dominant_race"] = Race.labels[np.argmax(race_predictions)]
+
+            # -----------------------------
+            # mention facial areas
+            obj["region"] = img_region
+            # include image confidence
+            obj["face_confidence"] = img_confidence
+
+        resp_objects.append(obj)
+
+    return resp_objects
diff --git a/modules/detection.py b/modules/detection.py
new file mode 100644
index 0000000000000000000000000000000000000000..ad4b28874796bd0015088abdf271ab33b4b1b404
--- /dev/null
+++ b/modules/detection.py
@@ -0,0 +1,160 @@
+# built-in dependencies
+from typing import Any, Dict, List, Tuple, Union
+
+# 3rd part dependencies
+import numpy as np
+import cv2
+from PIL import Image
+
+# project dependencies
+from deepface.models.Detector import DetectedFace, FacialAreaRegion
+from deepface.detectors import DetectorWrapper
+from deepface.commons import image_utils
+from deepface.commons import logger as log
+
+logger = log.get_singletonish_logger()
+
+# pylint: disable=no-else-raise
+
+
+def extract_faces(
+    img_path: Union[str, np.ndarray],
+    detector_backend: str = "opencv",
+    enforce_detection: bool = True,
+    align: bool = True,
+    expand_percentage: int = 0,
+    grayscale: bool = False,
+) -> List[Dict[str, Any]]:
+    """
+    Extract faces from a given image
+
+    Args:
+        img_path (str or np.ndarray): Path to the first image. Accepts exact image path
+            as a string, numpy array (BGR), or base64 encoded images.
+
+        detector_backend (string): face detector backend. Options: 'opencv', 'retinaface',
+            'mtcnn', 'ssd', 'dlib', 'mediapipe', 'yolov8', 'centerface' or 'skip'
+            (default is opencv)
+
+        enforce_detection (boolean): If no face is detected in an image, raise an exception.
+            Default is True. Set to False to avoid the exception for low-resolution images.
+
+        align (bool): Flag to enable face alignment (default is True).
+
+        expand_percentage (int): expand detected facial area with a percentage
+
+        grayscale (boolean): Flag to convert the image to grayscale before
+            processing (default is False).
+
+    Returns:
+        results (List[Dict[str, Any]]): A list of dictionaries, where each dictionary contains:
+
+        - "face" (np.ndarray): The detected face as a NumPy array in RGB format.
+
+        - "facial_area" (Dict[str, Any]): The detected face's regions as a dictionary containing:
+            - keys 'x', 'y', 'w', 'h' with int values
+            - keys 'left_eye', 'right_eye' with a tuple of 2 ints as values.
+                left eye and right eye are eyes on the left and right respectively with respect
+                to the person itself instead of observer.
+
+        - "confidence" (float): The confidence score associated with the detected face.
+    """
+
+    resp_objs = []
+
+    # img might be path, base64 or numpy array. Convert it to numpy whatever it is.
+    img, img_name = image_utils.load_image(img_path)
+
+    if img is None:
+        raise ValueError(f"Exception while loading {img_name}")
+
+    base_region = FacialAreaRegion(x=0, y=0, w=img.shape[1], h=img.shape[0], confidence=0)
+
+    if detector_backend == "skip":
+        face_objs = [DetectedFace(img=img, facial_area=base_region, confidence=0)]
+    else:
+        face_objs = DetectorWrapper.detect_faces(
+            detector_backend=detector_backend,
+            img=img,
+            align=align,
+            expand_percentage=expand_percentage,
+        )
+
+    # in case of no face found
+    if len(face_objs) == 0 and enforce_detection is True:
+        if img_name is not None:
+            raise ValueError(
+                f"Face could not be detected in {img_name}."
+                "Please confirm that the picture is a face photo "
+                "or consider to set enforce_detection param to False."
+            )
+        else:
+            raise ValueError(
+                "Face could not be detected. Please confirm that the picture is a face photo "
+                "or consider to set enforce_detection param to False."
+            )
+
+    if len(face_objs) == 0 and enforce_detection is False:
+        face_objs = [DetectedFace(img=img, facial_area=base_region, confidence=0)]
+
+    for face_obj in face_objs:
+        current_img = face_obj.img
+        current_region = face_obj.facial_area
+
+        if current_img.shape[0] == 0 or current_img.shape[1] == 0:
+            continue
+
+        if grayscale is True:
+            current_img = cv2.cvtColor(current_img, cv2.COLOR_BGR2GRAY)
+
+        current_img = current_img / 255  # normalize input in [0, 1]
+
+        resp_objs.append(
+            {
+                "face": current_img[:, :, ::-1],
+                "facial_area": {
+                    "x": int(current_region.x),
+                    "y": int(current_region.y),
+                    "w": int(current_region.w),
+                    "h": int(current_region.h),
+                    "left_eye": current_region.left_eye,
+                    "right_eye": current_region.right_eye,
+                },
+                "confidence": round(current_region.confidence, 2),
+            }
+        )
+
+    if len(resp_objs) == 0 and enforce_detection == True:
+        raise ValueError(
+            f"Exception while extracting faces from {img_name}."
+            "Consider to set enforce_detection arg to False."
+        )
+
+    return resp_objs
+
+
+def align_face(
+    img: np.ndarray,
+    left_eye: Union[list, tuple],
+    right_eye: Union[list, tuple],
+) -> Tuple[np.ndarray, float]:
+    """
+    Align a given image horizantally with respect to their left and right eye locations
+    Args:
+        img (np.ndarray): pre-loaded image with detected face
+        left_eye (list or tuple): coordinates of left eye with respect to the person itself
+        right_eye(list or tuple): coordinates of right eye with respect to the person itself
+    Returns:
+        img (np.ndarray): aligned facial image
+    """
+    # if eye could not be detected for the given image, return image itself
+    if left_eye is None or right_eye is None:
+        return img, 0
+
+    # sometimes unexpectedly detected images come with nil dimensions
+    if img.shape[0] == 0 or img.shape[1] == 0:
+        return img, 0
+
+    angle = float(np.degrees(np.arctan2(left_eye[1] - right_eye[1], left_eye[0] - right_eye[0])))
+    img = np.array(Image.fromarray(img).rotate(angle))
+    return img, angle
diff --git a/modules/modeling.py b/modules/modeling.py
new file mode 100644
index 0000000000000000000000000000000000000000..b40dcb5c249f1c1c15526fc98b1c75861fe3d347
--- /dev/null
+++ b/modules/modeling.py
@@ -0,0 +1,61 @@
+# built-in dependencies
+from typing import Any
+
+# project dependencies
+from deepface.basemodels import (
+    VGGFace,
+    OpenFace,
+    FbDeepFace,
+    DeepID,
+    ArcFace,
+    SFace,
+    Dlib,
+    Facenet,
+    GhostFaceNet
+)
+from deepface.extendedmodels import Age, Gender, Race, Emotion
+
+
+def build_model(model_name: str) -> Any:
+    """
+    This function builds a deepface model
+    Parameters:
+            model_name (string): face recognition or facial attribute model
+                    VGG-Face, Facenet, OpenFace, DeepFace, DeepID for face recognition
+                    Age, Gender, Emotion, Race for facial attributes
+
+    Returns:
+            built model class
+    """
+
+    # singleton design pattern
+    global model_obj
+
+    models = {
+        "VGG-Face": VGGFace.VggFaceClient,
+        "OpenFace": OpenFace.OpenFaceClient,
+        "Facenet": Facenet.FaceNet128dClient,
+        "Facenet512": Facenet.FaceNet512dClient,
+        "DeepFace": FbDeepFace.DeepFaceClient,
+        "DeepID": DeepID.DeepIdClient,
+        "Dlib": Dlib.DlibClient,
+        "ArcFace": ArcFace.ArcFaceClient,
+        "SFace": SFace.SFaceClient,
+        "GhostFaceNet": GhostFaceNet.GhostFaceNetClient,
+        "Emotion": Emotion.EmotionClient,
+        "Age": Age.ApparentAgeClient,
+        "Gender": Gender.GenderClient,
+        "Race": Race.RaceClient,
+    }
+
+    if not "model_obj" in globals():
+        model_obj = {}
+
+    if not model_name in model_obj.keys():
+        model = models.get(model_name)
+        if model:
+            model_obj[model_name] = model()
+        else:
+            raise ValueError(f"Invalid model_name passed - {model_name}")
+
+    return model_obj[model_name]
diff --git a/modules/preprocessing.py b/modules/preprocessing.py
new file mode 100644
index 0000000000000000000000000000000000000000..459adbab3e0dff3459e4ae21f413ece226bbf3b8
--- /dev/null
+++ b/modules/preprocessing.py
@@ -0,0 +1,121 @@
+# built-in dependencies
+from typing import Tuple
+
+# 3rd party
+import numpy as np
+import cv2
+
+# project dependencies
+from deepface.commons import package_utils
+
+
+tf_major_version = package_utils.get_tf_major_version()
+if tf_major_version == 1:
+    from keras.preprocessing import image
+elif tf_major_version == 2:
+    from tensorflow.keras.preprocessing import image
+
+
+def normalize_input(img: np.ndarray, normalization: str = "base") -> np.ndarray:
+    """Normalize input image.
+
+    Args:
+        img (numpy array): the input image.
+        normalization (str, optional): the normalization technique. Defaults to "base",
+        for no normalization.
+
+    Returns:
+        numpy array: the normalized image.
+    """
+
+    # issue 131 declares that some normalization techniques improves the accuracy
+
+    if normalization == "base":
+        return img
+
+    # @trevorgribble and @davedgd contributed this feature
+    # restore input in scale of [0, 255] because it was normalized in scale of
+    # [0, 1] in preprocess_face
+    img *= 255
+
+    if normalization == "raw":
+        pass  # return just restored pixels
+
+    elif normalization == "Facenet":
+        mean, std = img.mean(), img.std()
+        img = (img - mean) / std
+
+    elif normalization == "Facenet2018":
+        # simply / 127.5 - 1 (similar to facenet 2018 model preprocessing step as @iamrishab posted)
+        img /= 127.5
+        img -= 1
+
+    elif normalization == "VGGFace":
+        # mean subtraction based on VGGFace1 training data
+        img[..., 0] -= 93.5940
+        img[..., 1] -= 104.7624
+        img[..., 2] -= 129.1863
+
+    elif normalization == "VGGFace2":
+        # mean subtraction based on VGGFace2 training data
+        img[..., 0] -= 91.4953
+        img[..., 1] -= 103.8827
+        img[..., 2] -= 131.0912
+
+    elif normalization == "ArcFace":
+        # Reference study: The faces are cropped and resized to 112×112,
+        # and each pixel (ranged between [0, 255]) in RGB images is normalised
+        # by subtracting 127.5 then divided by 128.
+        img -= 127.5
+        img /= 128
+    else:
+        raise ValueError(f"unimplemented normalization type - {normalization}")
+
+    return img
+
+
+def resize_image(img: np.ndarray, target_size: Tuple[int, int]) -> np.ndarray:
+    """
+    Resize an image to expected size of a ml model with adding black pixels.
+    Args:
+        img (np.ndarray): pre-loaded image as numpy array
+        target_size (tuple): input shape of ml model
+    Returns:
+        img (np.ndarray): resized input image
+    """
+    factor_0 = target_size[0] / img.shape[0]
+    factor_1 = target_size[1] / img.shape[1]
+    factor = min(factor_0, factor_1)
+
+    dsize = (
+        int(img.shape[1] * factor),
+        int(img.shape[0] * factor),
+    )
+    img = cv2.resize(img, dsize)
+
+    diff_0 = target_size[0] - img.shape[0]
+    diff_1 = target_size[1] - img.shape[1]
+
+    # Put the base image in the middle of the padded image
+    img = np.pad(
+        img,
+        (
+            (diff_0 // 2, diff_0 - diff_0 // 2),
+            (diff_1 // 2, diff_1 - diff_1 // 2),
+            (0, 0),
+        ),
+        "constant",
+    )
+
+    # double check: if target image is not still the same size with target.
+    if img.shape[0:2] != target_size:
+        img = cv2.resize(img, target_size)
+
+    # make it 4-dimensional how ML models expect
+    img = image.img_to_array(img)
+    img = np.expand_dims(img, axis=0)
+
+    if img.max() > 1:
+        img = (img.astype(np.float32) / 255.0).astype(np.float32)
+
+    return img
diff --git a/modules/recognition.py b/modules/recognition.py
new file mode 100644
index 0000000000000000000000000000000000000000..011863445b882455e04da9d25d9a93bd7b60bb8a
--- /dev/null
+++ b/modules/recognition.py
@@ -0,0 +1,391 @@
+# built-in dependencies
+import os
+import pickle
+from typing import List, Union, Optional, Dict, Any
+import time
+
+# 3rd party dependencies
+import numpy as np
+import pandas as pd
+from tqdm import tqdm
+
+# project dependencies
+from deepface.commons import image_utils
+from deepface.modules import representation, detection, verification
+from deepface.commons import logger as log
+
+logger = log.get_singletonish_logger()
+
+
+def find(
+    img_path: Union[str, np.ndarray],
+    db_path: str,
+    model_name: str = "VGG-Face",
+    distance_metric: str = "cosine",
+    enforce_detection: bool = True,
+    detector_backend: str = "opencv",
+    align: bool = True,
+    expand_percentage: int = 0,
+    threshold: Optional[float] = None,
+    normalization: str = "base",
+    silent: bool = False,
+) -> List[pd.DataFrame]:
+    """
+    Identify individuals in a database
+
+    Args:
+        img_path (str or np.ndarray): The exact path to the image, a numpy array in BGR format,
+            or a base64 encoded image. If the source image contains multiple faces, the result will
+            include information for each detected face.
+
+        db_path (string): Path to the folder containing image files. All detected faces
+            in the database will be considered in the decision-making process.
+
+        model_name (str): Model for face recognition. Options: VGG-Face, Facenet, Facenet512,
+            OpenFace, DeepFace, DeepID, Dlib, ArcFace, SFace and GhostFaceNet (default is VGG-Face).
+
+        distance_metric (string): Metric for measuring similarity. Options: 'cosine',
+            'euclidean', 'euclidean_l2'.
+
+        enforce_detection (boolean): If no face is detected in an image, raise an exception.
+            Default is True. Set to False to avoid the exception for low-resolution images.
+
+        detector_backend (string): face detector backend. Options: 'opencv', 'retinaface',
+            'mtcnn', 'ssd', 'dlib', 'mediapipe', 'yolov8', 'centerface' or 'skip'.
+
+        align (boolean): Perform alignment based on the eye positions.
+
+        expand_percentage (int): expand detected facial area with a percentage (default is 0).
+
+        threshold (float): Specify a threshold to determine whether a pair represents the same
+            person or different individuals. This threshold is used for comparing distances.
+            If left unset, default pre-tuned threshold values will be applied based on the specified
+            model name and distance metric (default is None).
+
+        normalization (string): Normalize the input image before feeding it to the model.
+            Default is base. Options: base, raw, Facenet, Facenet2018, VGGFace, VGGFace2, ArcFace
+
+        silent (boolean): Suppress or allow some log messages for a quieter analysis process.
+
+    Returns:
+        results (List[pd.DataFrame]): A list of pandas dataframes. Each dataframe corresponds
+            to the identity information for an individual detected in the source image.
+            The DataFrame columns include:
+
+            - 'identity': Identity label of the detected individual.
+
+            - 'target_x', 'target_y', 'target_w', 'target_h': Bounding box coordinates of the
+                    target face in the database.
+
+            - 'source_x', 'source_y', 'source_w', 'source_h': Bounding box coordinates of the
+                    detected face in the source image.
+
+            - 'threshold': threshold to determine a pair whether same person or different persons
+
+            - 'distance': Similarity score between the faces based on the
+                    specified model and distance metric
+    """
+
+    tic = time.time()
+
+    if os.path.isdir(db_path) is not True:
+        raise ValueError("Passed db_path does not exist!")
+
+    file_parts = [
+        "ds",
+        "model",
+        model_name,
+        "detector",
+        detector_backend,
+        "aligned" if align else "unaligned",
+        "normalization",
+        normalization,
+        "expand",
+        str(expand_percentage),
+    ]
+
+    file_name = "_".join(file_parts) + ".pkl"
+    file_name = file_name.replace("-", "").lower()
+
+    datastore_path = os.path.join(db_path, file_name)
+    representations = []
+
+    # required columns for representations
+    df_cols = [
+        "identity",
+        "hash",
+        "embedding",
+        "target_x",
+        "target_y",
+        "target_w",
+        "target_h",
+    ]
+
+    # Ensure the proper pickle file exists
+    if not os.path.exists(datastore_path):
+        with open(datastore_path, "wb") as f:
+            pickle.dump([], f)
+
+    # Load the representations from the pickle file
+    with open(datastore_path, "rb") as f:
+        representations = pickle.load(f)
+
+    # check each item of representations list has required keys
+    for i, current_representation in enumerate(representations):
+        missing_keys = list(set(df_cols) - set(current_representation.keys()))
+        if len(missing_keys) > 0:
+            raise ValueError(
+                f"{i}-th item does not have some required keys - {missing_keys}."
+                f"Consider to delete {datastore_path}"
+            )
+
+    # embedded images
+    pickled_images = [representation["identity"] for representation in representations]
+
+    # Get the list of images on storage
+    storage_images = image_utils.list_images(path=db_path)
+
+    if len(storage_images) == 0:
+        raise ValueError(f"No item found in {db_path}")
+
+    # Enforce data consistency amongst on disk images and pickle file
+    must_save_pickle = False
+    new_images = list(set(storage_images) - set(pickled_images))  # images added to storage
+    old_images = list(set(pickled_images) - set(storage_images))  # images removed from storage
+
+    # detect replaced images
+    replaced_images = []
+    for current_representation in representations:
+        identity = current_representation["identity"]
+        if identity in old_images:
+            continue
+        alpha_hash = current_representation["hash"]
+        beta_hash = image_utils.find_image_hash(identity)
+        if alpha_hash != beta_hash:
+            logger.debug(f"Even though {identity} represented before, it's replaced later.")
+            replaced_images.append(identity)
+
+    if not silent and (len(new_images) > 0 or len(old_images) > 0 or len(replaced_images) > 0):
+        logger.info(
+            f"Found {len(new_images)} newly added image(s)"
+            f", {len(old_images)} removed image(s)"
+            f", {len(replaced_images)} replaced image(s)."
+        )
+
+    # append replaced images into both old and new images. these will be dropped and re-added.
+    new_images = new_images + replaced_images
+    old_images = old_images + replaced_images
+
+    # remove old images first
+    if len(old_images) > 0:
+        representations = [rep for rep in representations if rep["identity"] not in old_images]
+        must_save_pickle = True
+
+    # find representations for new images
+    if len(new_images) > 0:
+        representations += __find_bulk_embeddings(
+            employees=new_images,
+            model_name=model_name,
+            detector_backend=detector_backend,
+            enforce_detection=enforce_detection,
+            align=align,
+            expand_percentage=expand_percentage,
+            normalization=normalization,
+            silent=silent,
+        )  # add new images
+        must_save_pickle = True
+
+    if must_save_pickle:
+        with open(datastore_path, "wb") as f:
+            pickle.dump(representations, f)
+        if not silent:
+            logger.info(f"There are now {len(representations)} representations in {file_name}")
+
+    # Should we have no representations bailout
+    if len(representations) == 0:
+        if not silent:
+            toc = time.time()
+            logger.info(f"find function duration {toc - tic} seconds")
+        return []
+
+    # ----------------------------
+    # now, we got representations for facial database
+    df = pd.DataFrame(representations)
+
+    if silent is False:
+        logger.info(f"Searching {img_path} in {df.shape[0]} length datastore")
+
+    # img path might have more than once face
+    source_objs = detection.extract_faces(
+        img_path=img_path,
+        detector_backend=detector_backend,
+        grayscale=False,
+        enforce_detection=enforce_detection,
+        align=align,
+        expand_percentage=expand_percentage,
+    )
+
+    resp_obj = []
+
+    for source_obj in source_objs:
+        source_img = source_obj["face"]
+        source_region = source_obj["facial_area"]
+        target_embedding_obj = representation.represent(
+            img_path=source_img,
+            model_name=model_name,
+            enforce_detection=enforce_detection,
+            detector_backend="skip",
+            align=align,
+            normalization=normalization,
+        )
+
+        target_representation = target_embedding_obj[0]["embedding"]
+
+        result_df = df.copy()  # df will be filtered in each img
+        result_df["source_x"] = source_region["x"]
+        result_df["source_y"] = source_region["y"]
+        result_df["source_w"] = source_region["w"]
+        result_df["source_h"] = source_region["h"]
+
+        distances = []
+        for _, instance in df.iterrows():
+            source_representation = instance["embedding"]
+            if source_representation is None:
+                distances.append(float("inf"))  # no representation for this image
+                continue
+
+            target_dims = len(list(target_representation))
+            source_dims = len(list(source_representation))
+            if target_dims != source_dims:
+                raise ValueError(
+                    "Source and target embeddings must have same dimensions but "
+                    + f"{target_dims}:{source_dims}. Model structure may change"
+                    + " after pickle created. Delete the {file_name} and re-run."
+                )
+
+            distance = verification.find_distance(
+                source_representation, target_representation, distance_metric
+            )
+
+            distances.append(distance)
+
+            # ---------------------------
+        target_threshold = threshold or verification.find_threshold(model_name, distance_metric)
+
+        result_df["threshold"] = target_threshold
+        result_df["distance"] = distances
+
+        result_df = result_df.drop(columns=["embedding"])
+        # pylint: disable=unsubscriptable-object
+        result_df = result_df[result_df["distance"] <= target_threshold]
+        result_df = result_df.sort_values(by=["distance"], ascending=True).reset_index(drop=True)
+
+        resp_obj.append(result_df)
+
+    # -----------------------------------
+
+    if not silent:
+        toc = time.time()
+        logger.info(f"find function duration {toc - tic} seconds")
+
+    return resp_obj
+
+
+def __find_bulk_embeddings(
+    employees: List[str],
+    model_name: str = "VGG-Face",
+    detector_backend: str = "opencv",
+    enforce_detection: bool = True,
+    align: bool = True,
+    expand_percentage: int = 0,
+    normalization: str = "base",
+    silent: bool = False,
+) -> List[Dict["str", Any]]:
+    """
+    Find embeddings of a list of images
+
+    Args:
+        employees (list): list of exact image paths
+
+        model_name (str): Model for face recognition. Options: VGG-Face, Facenet, Facenet512,
+            OpenFace, DeepFace, DeepID, Dlib, ArcFace, SFace and GhostFaceNet (default is VGG-Face).
+
+        detector_backend (str): face detector model name
+
+        enforce_detection (bool): set this to False if you
+            want to proceed when you cannot detect any face
+
+        align (bool): enable or disable alignment of image
+            before feeding to facial recognition model
+
+        expand_percentage (int): expand detected facial area with a
+            percentage (default is 0).
+
+        normalization (bool): normalization technique
+
+        silent (bool): enable or disable informative logging
+    Returns:
+        representations (list): pivot list of dict with
+            image name, hash, embedding and detected face area's coordinates
+    """
+    representations = []
+    for employee in tqdm(
+        employees,
+        desc="Finding representations",
+        disable=silent,
+    ):
+        file_hash = image_utils.find_image_hash(employee)
+
+        try:
+            img_objs = detection.extract_faces(
+                img_path=employee,
+                detector_backend=detector_backend,
+                grayscale=False,
+                enforce_detection=enforce_detection,
+                align=align,
+                expand_percentage=expand_percentage,
+            )
+
+        except ValueError as err:
+            logger.error(f"Exception while extracting faces from {employee}: {str(err)}")
+            img_objs = []
+
+        if len(img_objs) == 0:
+            representations.append(
+                {
+                    "identity": employee,
+                    "hash": file_hash,
+                    "embedding": None,
+                    "target_x": 0,
+                    "target_y": 0,
+                    "target_w": 0,
+                    "target_h": 0,
+                }
+            )
+        else:
+            for img_obj in img_objs:
+                img_content = img_obj["face"]
+                img_region = img_obj["facial_area"]
+                embedding_obj = representation.represent(
+                    img_path=img_content,
+                    model_name=model_name,
+                    enforce_detection=enforce_detection,
+                    detector_backend="skip",
+                    align=align,
+                    normalization=normalization,
+                )
+
+                img_representation = embedding_obj[0]["embedding"]
+                representations.append(
+                    {
+                        "identity": employee,
+                        "hash": file_hash,
+                        "embedding": img_representation,
+                        "target_x": img_region["x"],
+                        "target_y": img_region["y"],
+                        "target_w": img_region["w"],
+                        "target_h": img_region["h"],
+                    }
+                )
+
+    return representations
diff --git a/modules/representation.py b/modules/representation.py
new file mode 100644
index 0000000000000000000000000000000000000000..9e8a1a6974f31962f3fc68a6f5261822132c09a6
--- /dev/null
+++ b/modules/representation.py
@@ -0,0 +1,120 @@
+# built-in dependencies
+from typing import Any, Dict, List, Union
+
+# 3rd party dependencies
+import numpy as np
+
+# project dependencies
+from deepface.commons import image_utils
+from deepface.modules import modeling, detection, preprocessing
+from deepface.models.FacialRecognition import FacialRecognition
+
+
+def represent(
+    img_path: Union[str, np.ndarray],
+    model_name: str = "VGG-Face",
+    enforce_detection: bool = True,
+    detector_backend: str = "opencv",
+    align: bool = True,
+    expand_percentage: int = 0,
+    normalization: str = "base",
+) -> List[Dict[str, Any]]:
+    """
+    Represent facial images as multi-dimensional vector embeddings.
+
+    Args:
+        img_path (str or np.ndarray): The exact path to the image, a numpy array in BGR format,
+            or a base64 encoded image. If the source image contains multiple faces, the result will
+            include information for each detected face.
+
+        model_name (str): Model for face recognition. Options: VGG-Face, Facenet, Facenet512,
+            OpenFace, DeepFace, DeepID, Dlib, ArcFace, SFace and GhostFaceNet
+
+        enforce_detection (boolean): If no face is detected in an image, raise an exception.
+            Default is True. Set to False to avoid the exception for low-resolution images.
+
+        detector_backend (string): face detector backend. Options: 'opencv', 'retinaface',
+            'mtcnn', 'ssd', 'dlib', 'mediapipe', 'yolov8', 'centerface' or 'skip'.
+
+        align (boolean): Perform alignment based on the eye positions.
+
+        expand_percentage (int): expand detected facial area with a percentage (default is 0).
+
+        normalization (string): Normalize the input image before feeding it to the model.
+            Default is base. Options: base, raw, Facenet, Facenet2018, VGGFace, VGGFace2, ArcFace
+
+    Returns:
+        results (List[Dict[str, Any]]): A list of dictionaries, each containing the
+            following fields:
+
+        - embedding (List[float]): Multidimensional vector representing facial features.
+            The number of dimensions varies based on the reference model
+            (e.g., FaceNet returns 128 dimensions, VGG-Face returns 4096 dimensions).
+        - facial_area (dict): Detected facial area by face detection in dictionary format.
+            Contains 'x' and 'y' as the left-corner point, and 'w' and 'h'
+            as the width and height. If `detector_backend` is set to 'skip', it represents
+            the full image area and is nonsensical.
+        - face_confidence (float): Confidence score of face detection. If `detector_backend` is set
+            to 'skip', the confidence will be 0 and is nonsensical.
+    """
+    resp_objs = []
+
+    model: FacialRecognition = modeling.build_model(model_name)
+
+    # ---------------------------------
+    # we have run pre-process in verification. so, this can be skipped if it is coming from verify.
+    target_size = model.input_shape
+    if detector_backend != "skip":
+        img_objs = detection.extract_faces(
+            img_path=img_path,
+            detector_backend=detector_backend,
+            grayscale=False,
+            enforce_detection=enforce_detection,
+            align=align,
+            expand_percentage=expand_percentage,
+        )
+    else:  # skip
+        # Try load. If load error, will raise exception internal
+        img, _ = image_utils.load_image(img_path)
+
+        if len(img.shape) != 3:
+            raise ValueError(f"Input img must be 3 dimensional but it is {img.shape}")
+
+        # make dummy region and confidence to keep compatibility with `extract_faces`
+        img_objs = [
+            {
+                "face": img,
+                "facial_area": {"x": 0, "y": 0, "w": img.shape[1], "h": img.shape[2]},
+                "confidence": 0,
+            }
+        ]
+    # ---------------------------------
+
+    for img_obj in img_objs:
+        img = img_obj["face"]
+
+        # rgb to bgr
+        img = img[:, :, ::-1]
+
+        region = img_obj["facial_area"]
+        confidence = img_obj["confidence"]
+
+        # resize to expected shape of ml model
+        img = preprocessing.resize_image(
+            img=img,
+            # thanks to DeepId (!)
+            target_size=(target_size[1], target_size[0]),
+        )
+
+        # custom normalization
+        img = preprocessing.normalize_input(img=img, normalization=normalization)
+
+        embedding = model.forward(img)
+
+        resp_obj = {}
+        resp_obj["embedding"] = embedding
+        resp_obj["facial_area"] = region
+        resp_obj["face_confidence"] = confidence
+        resp_objs.append(resp_obj)
+
+    return resp_objs
diff --git a/modules/streaming.py b/modules/streaming.py
new file mode 100644
index 0000000000000000000000000000000000000000..95d05d91c68a64a4c9fd2adc47484f5da0faf130
--- /dev/null
+++ b/modules/streaming.py
@@ -0,0 +1,980 @@
+# built-in dependencies
+import os
+import time
+from typing import List, Tuple, Optional
+
+# 3rd party dependencies
+import numpy as np
+import pandas as pd
+import cv2
+
+# project dependencies
+from deepface import DeepFace
+from deepface.commons import logger as log
+
+logger = log.get_singletonish_logger()
+
+# dependency configuration
+os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
+
+
+IDENTIFIED_IMG_SIZE = 112
+TEXT_COLOR = (255, 255, 255)
+
+
+def analysis(
+    db_path: str,
+    model_name="VGG-Face",
+    detector_backend="opencv",
+    distance_metric="cosine",
+    enable_face_analysis=True,
+    source=0,
+    time_threshold=5,
+    frame_threshold=5,
+):
+    """
+    Run real time face recognition and facial attribute analysis
+
+    Args:
+        db_path (string): Path to the folder containing image files. All detected faces
+            in the database will be considered in the decision-making process.
+
+        model_name (str): Model for face recognition. Options: VGG-Face, Facenet, Facenet512,
+            OpenFace, DeepFace, DeepID, Dlib, ArcFace, SFace and GhostFaceNet (default is VGG-Face).
+
+        detector_backend (string): face detector backend. Options: 'opencv', 'retinaface',
+            'mtcnn', 'ssd', 'dlib', 'mediapipe', 'yolov8', 'centerface' or 'skip'
+            (default is opencv).
+
+        distance_metric (string): Metric for measuring similarity. Options: 'cosine',
+            'euclidean', 'euclidean_l2' (default is cosine).
+
+        enable_face_analysis (bool): Flag to enable face analysis (default is True).
+
+        source (Any): The source for the video stream (default is 0, which represents the
+            default camera).
+
+        time_threshold (int): The time threshold (in seconds) for face recognition (default is 5).
+
+        frame_threshold (int): The frame threshold for face recognition (default is 5).
+    Returns:
+        None
+    """
+    # initialize models
+    build_demography_models(enable_face_analysis=enable_face_analysis)
+    build_facial_recognition_model(model_name=model_name)
+    # call a dummy find function for db_path once to create embeddings before starting webcam
+    _ = search_identity(
+        detected_face=np.zeros([224, 224, 3]),
+        db_path=db_path,
+        detector_backend=detector_backend,
+        distance_metric=distance_metric,
+        model_name=model_name,
+    )
+
+    freezed_img = None
+    freeze = False
+    num_frames_with_faces = 0
+    tic = time.time()
+
+    cap = cv2.VideoCapture(source)  # webcam
+    while True:
+        has_frame, img = cap.read()
+        if not has_frame:
+            break
+
+        # we are adding some figures into img such as identified facial image, age, gender
+        # that is why, we need raw image itself to make analysis
+        raw_img = img.copy()
+
+        faces_coordinates = []
+        if freeze is False:
+            faces_coordinates = grab_facial_areas(img=img, detector_backend=detector_backend)
+
+            # we will pass img to analyze modules (identity, demography) and add some illustrations
+            # that is why, we will not be able to extract detected face from img clearly
+            detected_faces = extract_facial_areas(img=img, faces_coordinates=faces_coordinates)
+
+            img = highlight_facial_areas(img=img, faces_coordinates=faces_coordinates)
+            img = countdown_to_freeze(
+                img=img,
+                faces_coordinates=faces_coordinates,
+                frame_threshold=frame_threshold,
+                num_frames_with_faces=num_frames_with_faces,
+            )
+
+            num_frames_with_faces = num_frames_with_faces + 1 if len(faces_coordinates) else 0
+
+            freeze = num_frames_with_faces > 0 and num_frames_with_faces % frame_threshold == 0
+            if freeze:
+                # add analyze results into img - derive from raw_img
+                img = highlight_facial_areas(img=raw_img, faces_coordinates=faces_coordinates)
+
+                # age, gender and emotion analysis
+                img = perform_demography_analysis(
+                    enable_face_analysis=enable_face_analysis,
+                    img=raw_img,
+                    faces_coordinates=faces_coordinates,
+                    detected_faces=detected_faces,
+                )
+                # facial recogntion analysis
+                img = perform_facial_recognition(
+                    img=img,
+                    faces_coordinates=faces_coordinates,
+                    detected_faces=detected_faces,
+                    db_path=db_path,
+                    detector_backend=detector_backend,
+                    distance_metric=distance_metric,
+                    model_name=model_name,
+                )
+
+                # freeze the img after analysis
+                freezed_img = img.copy()
+
+                # start counter for freezing
+                tic = time.time()
+                logger.info("freezed")
+
+        elif freeze is True and time.time() - tic > time_threshold:
+            freeze = False
+            freezed_img = None
+            # reset counter for freezing
+            tic = time.time()
+            logger.info("freeze released")
+
+        freezed_img = countdown_to_release(img=freezed_img, tic=tic, time_threshold=time_threshold)
+
+        cv2.imshow("img", img if freezed_img is None else freezed_img)
+
+        if cv2.waitKey(1) & 0xFF == ord("q"):  # press q to quit
+            break
+
+    # kill open cv things
+    cap.release()
+    cv2.destroyAllWindows()
+
+
+def build_facial_recognition_model(model_name: str) -> None:
+    """
+    Build facial recognition model
+    Args:
+        model_name (str): Model for face recognition. Options: VGG-Face, Facenet, Facenet512,
+            OpenFace, DeepFace, DeepID, Dlib, ArcFace, SFace and GhostFaceNet (default is VGG-Face).
+    Returns
+        input_shape (tuple): input shape of given facial recognitio n model.
+    """
+    _ = DeepFace.build_model(model_name=model_name)
+    logger.info(f"{model_name} is built")
+
+
+def search_identity(
+    detected_face: np.ndarray,
+    db_path: str,
+    model_name: str,
+    detector_backend: str,
+    distance_metric: str,
+) -> Tuple[Optional[str], Optional[np.ndarray]]:
+    """
+    Search an identity in facial database.
+    Args:
+        detected_face (np.ndarray): extracted individual facial image
+        db_path (string): Path to the folder containing image files. All detected faces
+            in the database will be considered in the decision-making process.
+        model_name (str): Model for face recognition. Options: VGG-Face, Facenet, Facenet512,
+            OpenFace, DeepFace, DeepID, Dlib, ArcFace, SFace and GhostFaceNet (default is VGG-Face).
+        detector_backend (string): face detector backend. Options: 'opencv', 'retinaface',
+            'mtcnn', 'ssd', 'dlib', 'mediapipe', 'yolov8', 'centerface' or 'skip'
+            (default is opencv).
+        distance_metric (string): Metric for measuring similarity. Options: 'cosine',
+            'euclidean', 'euclidean_l2' (default is cosine).
+    Returns:
+        result (tuple): result consisting of following objects
+            identified image path (str)
+            identified image itself (np.ndarray)
+    """
+    target_path = None
+    try:
+        dfs = DeepFace.find(
+            img_path=detected_face,
+            db_path=db_path,
+            model_name=model_name,
+            detector_backend=detector_backend,
+            distance_metric=distance_metric,
+            enforce_detection=False,
+            silent=True,
+        )
+    except ValueError as err:
+        if f"No item found in {db_path}" in str(err):
+            logger.warn(
+                f"No item is found in {db_path}."
+                "So, no facial recognition analysis will be performed."
+            )
+            dfs = []
+        else:
+            raise err
+    if len(dfs) == 0:
+        # you may consider to return unknown person's image here
+        return None, None
+
+    # detected face is coming from parent, safe to access 1st index
+    df = dfs[0]
+
+    if df.shape[0] == 0:
+        return None, None
+
+    candidate = df.iloc[0]
+    target_path = candidate["identity"]
+    logger.info(f"Hello, {target_path}")
+
+    # load found identity image - extracted if possible
+    target_objs = DeepFace.extract_faces(
+        img_path=target_path,
+        detector_backend=detector_backend,
+        enforce_detection=False,
+        align=True,
+    )
+
+    # extract facial area of the identified image if and only if it has one face
+    # otherwise, show image as is
+    if len(target_objs) == 1:
+        # extract 1st item directly
+        target_obj = target_objs[0]
+        target_img = target_obj["face"]
+        target_img = cv2.resize(target_img, (IDENTIFIED_IMG_SIZE, IDENTIFIED_IMG_SIZE))
+        target_img *= 255
+        target_img = target_img[:, :, ::-1]
+    else:
+        target_img = cv2.imread(target_path)
+
+    return target_path.split("/")[-1], target_img
+
+
+def build_demography_models(enable_face_analysis: bool) -> None:
+    """
+    Build demography analysis models
+    Args:
+        enable_face_analysis (bool): Flag to enable face analysis (default is True).
+    Returns:
+        None
+    """
+    if enable_face_analysis is False:
+        return
+    DeepFace.build_model(model_name="Age")
+    logger.info("Age model is just built")
+    DeepFace.build_model(model_name="Gender")
+    logger.info("Gender model is just built")
+    DeepFace.build_model(model_name="Emotion")
+    logger.info("Emotion model is just built")
+
+
+def highlight_facial_areas(
+    img: np.ndarray, faces_coordinates: List[Tuple[int, int, int, int]]
+) -> np.ndarray:
+    """
+    Highlight detected faces with rectangles in the given image
+    Args:
+        img (np.ndarray): image itself
+        faces_coordinates (list): list of face coordinates as tuple with x, y, w and h
+    Returns:
+        img (np.ndarray): image with highlighted facial areas
+    """
+    for x, y, w, h in faces_coordinates:
+        # highlight facial area with rectangle
+        cv2.rectangle(img, (x, y), (x + w, y + h), (67, 67, 67), 1)
+    return img
+
+
+def countdown_to_freeze(
+    img: np.ndarray,
+    faces_coordinates: List[Tuple[int, int, int, int]],
+    frame_threshold: int,
+    num_frames_with_faces: int,
+) -> np.ndarray:
+    """
+    Highlight time to freeze in the image's facial areas
+    Args:
+        img (np.ndarray): image itself
+        faces_coordinates (list): list of face coordinates as tuple with x, y, w and h
+        frame_threshold (int): how many sequantial frames required with face(s) to freeze
+        num_frames_with_faces (int): how many sequantial frames do we have with face(s)
+    Returns:
+        img (np.ndarray): image with counter values
+    """
+    for x, y, w, h in faces_coordinates:
+        cv2.putText(
+            img,
+            str(frame_threshold - (num_frames_with_faces % frame_threshold)),
+            (int(x + w / 4), int(y + h / 1.5)),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            4,
+            (255, 255, 255),
+            2,
+        )
+    return img
+
+
+def countdown_to_release(
+    img: Optional[np.ndarray], tic: float, time_threshold: int
+) -> Optional[np.ndarray]:
+    """
+    Highlight time to release the freezing in the image top left area
+    Args:
+        img (np.ndarray): image itself
+        tic (float): time specifying when freezing started
+        time_threshold (int): freeze time threshold
+    Returns:
+        img (np.ndarray): image with time to release the freezing
+    """
+    # do not take any action if it is not frozen yet
+    if img is None:
+        return img
+    toc = time.time()
+    time_left = int(time_threshold - (toc - tic) + 1)
+    cv2.rectangle(img, (10, 10), (90, 50), (67, 67, 67), -10)
+    cv2.putText(
+        img,
+        str(time_left),
+        (40, 40),
+        cv2.FONT_HERSHEY_SIMPLEX,
+        1,
+        (255, 255, 255),
+        1,
+    )
+    return img
+
+
+def grab_facial_areas(
+    img: np.ndarray, detector_backend: str, threshold: int = 130
+) -> List[Tuple[int, int, int, int]]:
+    """
+    Find facial area coordinates in the given image
+    Args:
+        img (np.ndarray): image itself
+        detector_backend (string): face detector backend. Options: 'opencv', 'retinaface',
+            'mtcnn', 'ssd', 'dlib', 'mediapipe', 'yolov8', 'centerface' or 'skip'
+            (default is opencv).
+        threshold (int): threshold for facial area, discard smaller ones
+    Returns
+        result (list): list of tuple with x, y, w and h coordinates
+    """
+    try:
+        face_objs = DeepFace.extract_faces(
+            img_path=img,
+            detector_backend=detector_backend,
+            # you may consider to extract with larger expanding value
+            expand_percentage=0,
+        )
+        faces = [
+            (
+                face_obj["facial_area"]["x"],
+                face_obj["facial_area"]["y"],
+                face_obj["facial_area"]["w"],
+                face_obj["facial_area"]["h"],
+            )
+            for face_obj in face_objs
+            if face_obj["facial_area"]["w"] > threshold
+        ]
+        return faces
+    except:  # to avoid exception if no face detected
+        return []
+
+
+def extract_facial_areas(
+    img: np.ndarray, faces_coordinates: List[Tuple[int, int, int, int]]
+) -> List[np.ndarray]:
+    """
+    Extract facial areas as numpy array from given image
+    Args:
+        img (np.ndarray): image itself
+        faces_coordinates (list): list of facial area coordinates as tuple with
+            x, y, w and h values
+    Returns:
+        detected_faces (list): list of detected facial area images
+    """
+    detected_faces = []
+    for x, y, w, h in faces_coordinates:
+        detected_face = img[int(y) : int(y + h), int(x) : int(x + w)]
+        detected_faces.append(detected_face)
+    return detected_faces
+
+
+def perform_facial_recognition(
+    img: np.ndarray,
+    detected_faces: List[np.ndarray],
+    faces_coordinates: List[Tuple[int, int, int, int]],
+    db_path: str,
+    detector_backend: str,
+    distance_metric: str,
+    model_name: str,
+) -> np.ndarray:
+    """
+    Perform facial recognition
+    Args:
+        img (np.ndarray): image itself
+        detected_faces (list): list of extracted detected face images as numpy
+        faces_coordinates (list): list of facial area coordinates as tuple with
+            x, y, w and h values
+        db_path (string): Path to the folder containing image files. All detected faces
+            in the database will be considered in the decision-making process.
+        detector_backend (string): face detector backend. Options: 'opencv', 'retinaface',
+            'mtcnn', 'ssd', 'dlib', 'mediapipe', 'yolov8', 'centerface' or 'skip'
+            (default is opencv).
+        distance_metric (string): Metric for measuring similarity. Options: 'cosine',
+            'euclidean', 'euclidean_l2' (default is cosine).
+        model_name (str): Model for face recognition. Options: VGG-Face, Facenet, Facenet512,
+            OpenFace, DeepFace, DeepID, Dlib, ArcFace, SFace and GhostFaceNet (default is VGG-Face).
+    Returns:
+        img (np.ndarray): image with identified face informations
+    """
+    for idx, (x, y, w, h) in enumerate(faces_coordinates):
+        detected_face = detected_faces[idx]
+        target_label, target_img = search_identity(
+            detected_face=detected_face,
+            db_path=db_path,
+            detector_backend=detector_backend,
+            distance_metric=distance_metric,
+            model_name=model_name,
+        )
+        if target_label is None:
+            continue
+
+        img = overlay_identified_face(
+            img=img,
+            target_img=target_img,
+            label=target_label,
+            x=x,
+            y=y,
+            w=w,
+            h=h,
+        )
+
+    return img
+
+
+def perform_demography_analysis(
+    enable_face_analysis: bool,
+    img: np.ndarray,
+    faces_coordinates: List[Tuple[int, int, int, int]],
+    detected_faces: List[np.ndarray],
+) -> np.ndarray:
+    """
+    Perform demography analysis on given image
+    Args:
+        enable_face_analysis (bool): Flag to enable face analysis.
+        img (np.ndarray): image itself
+        faces_coordinates (list): list of face coordinates as tuple with
+            x, y, w and h values
+        detected_faces (list): list of extracted detected face images as numpy
+    Returns:
+        img (np.ndarray): image with analyzed demography information
+    """
+    if enable_face_analysis is False:
+        return img
+    for idx, (x, y, w, h) in enumerate(faces_coordinates):
+        detected_face = detected_faces[idx]
+        demographies = DeepFace.analyze(
+            img_path=detected_face,
+            actions=("age", "gender", "emotion"),
+            detector_backend="skip",
+            enforce_detection=False,
+            silent=True,
+        )
+
+        if len(demographies) == 0:
+            continue
+
+        # safe to access 1st index because detector backend is skip
+        demography = demographies[0]
+
+        img = overlay_emotion(img=img, emotion_probas=demography["emotion"], x=x, y=y, w=w, h=h)
+        img = overlay_age_gender(
+            img=img,
+            apparent_age=demography["age"],
+            gender=demography["dominant_gender"][0:1],  # M or W
+            x=x,
+            y=y,
+            w=w,
+            h=h,
+        )
+    return img
+
+
+def overlay_identified_face(
+    img: np.ndarray,
+    target_img: np.ndarray,
+    label: str,
+    x: int,
+    y: int,
+    w: int,
+    h: int,
+) -> np.ndarray:
+    """
+    Overlay the identified face onto image itself
+    Args:
+        img (np.ndarray): image itself
+        target_img (np.ndarray): identified face's image
+        label (str): name of the identified face
+        x (int): x coordinate of the face on the given image
+        y (int): y coordinate of the face on the given image
+        w (int): w coordinate of the face on the given image
+        h (int): h coordinate of the face on the given image
+    Returns:
+        img (np.ndarray): image with overlayed identity
+    """
+    try:
+        if y - IDENTIFIED_IMG_SIZE > 0 and x + w + IDENTIFIED_IMG_SIZE < img.shape[1]:
+            # top right
+            img[
+                y - IDENTIFIED_IMG_SIZE : y,
+                x + w : x + w + IDENTIFIED_IMG_SIZE,
+            ] = target_img
+
+            overlay = img.copy()
+            opacity = 0.4
+            cv2.rectangle(
+                img,
+                (x + w, y),
+                (x + w + IDENTIFIED_IMG_SIZE, y + 20),
+                (46, 200, 255),
+                cv2.FILLED,
+            )
+            cv2.addWeighted(
+                overlay,
+                opacity,
+                img,
+                1 - opacity,
+                0,
+                img,
+            )
+
+            cv2.putText(
+                img,
+                label,
+                (x + w, y + 10),
+                cv2.FONT_HERSHEY_SIMPLEX,
+                0.5,
+                TEXT_COLOR,
+                1,
+            )
+
+            # connect face and text
+            cv2.line(
+                img,
+                (x + int(w / 2), y),
+                (x + 3 * int(w / 4), y - int(IDENTIFIED_IMG_SIZE / 2)),
+                (67, 67, 67),
+                1,
+            )
+            cv2.line(
+                img,
+                (x + 3 * int(w / 4), y - int(IDENTIFIED_IMG_SIZE / 2)),
+                (x + w, y - int(IDENTIFIED_IMG_SIZE / 2)),
+                (67, 67, 67),
+                1,
+            )
+
+        elif y + h + IDENTIFIED_IMG_SIZE < img.shape[0] and x - IDENTIFIED_IMG_SIZE > 0:
+            # bottom left
+            img[
+                y + h : y + h + IDENTIFIED_IMG_SIZE,
+                x - IDENTIFIED_IMG_SIZE : x,
+            ] = target_img
+
+            overlay = img.copy()
+            opacity = 0.4
+            cv2.rectangle(
+                img,
+                (x - IDENTIFIED_IMG_SIZE, y + h - 20),
+                (x, y + h),
+                (46, 200, 255),
+                cv2.FILLED,
+            )
+            cv2.addWeighted(
+                overlay,
+                opacity,
+                img,
+                1 - opacity,
+                0,
+                img,
+            )
+
+            cv2.putText(
+                img,
+                label,
+                (x - IDENTIFIED_IMG_SIZE, y + h - 10),
+                cv2.FONT_HERSHEY_SIMPLEX,
+                0.5,
+                TEXT_COLOR,
+                1,
+            )
+
+            # connect face and text
+            cv2.line(
+                img,
+                (x + int(w / 2), y + h),
+                (
+                    x + int(w / 2) - int(w / 4),
+                    y + h + int(IDENTIFIED_IMG_SIZE / 2),
+                ),
+                (67, 67, 67),
+                1,
+            )
+            cv2.line(
+                img,
+                (
+                    x + int(w / 2) - int(w / 4),
+                    y + h + int(IDENTIFIED_IMG_SIZE / 2),
+                ),
+                (x, y + h + int(IDENTIFIED_IMG_SIZE / 2)),
+                (67, 67, 67),
+                1,
+            )
+
+        elif y - IDENTIFIED_IMG_SIZE > 0 and x - IDENTIFIED_IMG_SIZE > 0:
+            # top left
+            img[y - IDENTIFIED_IMG_SIZE : y, x - IDENTIFIED_IMG_SIZE : x] = target_img
+
+            overlay = img.copy()
+            opacity = 0.4
+            cv2.rectangle(
+                img,
+                (x - IDENTIFIED_IMG_SIZE, y),
+                (x, y + 20),
+                (46, 200, 255),
+                cv2.FILLED,
+            )
+            cv2.addWeighted(
+                overlay,
+                opacity,
+                img,
+                1 - opacity,
+                0,
+                img,
+            )
+
+            cv2.putText(
+                img,
+                label,
+                (x - IDENTIFIED_IMG_SIZE, y + 10),
+                cv2.FONT_HERSHEY_SIMPLEX,
+                0.5,
+                TEXT_COLOR,
+                1,
+            )
+
+            # connect face and text
+            cv2.line(
+                img,
+                (x + int(w / 2), y),
+                (
+                    x + int(w / 2) - int(w / 4),
+                    y - int(IDENTIFIED_IMG_SIZE / 2),
+                ),
+                (67, 67, 67),
+                1,
+            )
+            cv2.line(
+                img,
+                (
+                    x + int(w / 2) - int(w / 4),
+                    y - int(IDENTIFIED_IMG_SIZE / 2),
+                ),
+                (x, y - int(IDENTIFIED_IMG_SIZE / 2)),
+                (67, 67, 67),
+                1,
+            )
+
+        elif (
+            x + w + IDENTIFIED_IMG_SIZE < img.shape[1]
+            and y + h + IDENTIFIED_IMG_SIZE < img.shape[0]
+        ):
+            # bottom righ
+            img[
+                y + h : y + h + IDENTIFIED_IMG_SIZE,
+                x + w : x + w + IDENTIFIED_IMG_SIZE,
+            ] = target_img
+
+            overlay = img.copy()
+            opacity = 0.4
+            cv2.rectangle(
+                img,
+                (x + w, y + h - 20),
+                (x + w + IDENTIFIED_IMG_SIZE, y + h),
+                (46, 200, 255),
+                cv2.FILLED,
+            )
+            cv2.addWeighted(
+                overlay,
+                opacity,
+                img,
+                1 - opacity,
+                0,
+                img,
+            )
+
+            cv2.putText(
+                img,
+                label,
+                (x + w, y + h - 10),
+                cv2.FONT_HERSHEY_SIMPLEX,
+                0.5,
+                TEXT_COLOR,
+                1,
+            )
+
+            # connect face and text
+            cv2.line(
+                img,
+                (x + int(w / 2), y + h),
+                (
+                    x + int(w / 2) + int(w / 4),
+                    y + h + int(IDENTIFIED_IMG_SIZE / 2),
+                ),
+                (67, 67, 67),
+                1,
+            )
+            cv2.line(
+                img,
+                (
+                    x + int(w / 2) + int(w / 4),
+                    y + h + int(IDENTIFIED_IMG_SIZE / 2),
+                ),
+                (x + w, y + h + int(IDENTIFIED_IMG_SIZE / 2)),
+                (67, 67, 67),
+                1,
+            )
+        else:
+            logger.info("cannot put facial recognition info on the image")
+    except Exception as err:  # pylint: disable=broad-except
+        logger.error(str(err))
+    return img
+
+
+def overlay_emotion(
+    img: np.ndarray, emotion_probas: dict, x: int, y: int, w: int, h: int
+) -> np.ndarray:
+    """
+    Overlay the analyzed emotion of face onto image itself
+    Args:
+        img (np.ndarray): image itself
+        emotion_probas (dict): probability of different emotionas dictionary
+        x (int): x coordinate of the face on the given image
+        y (int): y coordinate of the face on the given image
+        w (int): w coordinate of the face on the given image
+        h (int): h coordinate of the face on the given image
+    Returns:
+        img (np.ndarray): image with overlay emotion analsis results
+    """
+    emotion_df = pd.DataFrame(emotion_probas.items(), columns=["emotion", "score"])
+    emotion_df = emotion_df.sort_values(by=["score"], ascending=False).reset_index(drop=True)
+
+    # background of mood box
+
+    # transparency
+    overlay = img.copy()
+    opacity = 0.4
+
+    # put gray background to the right of the detected image
+    if x + w + IDENTIFIED_IMG_SIZE < img.shape[1]:
+        cv2.rectangle(
+            img,
+            (x + w, y),
+            (x + w + IDENTIFIED_IMG_SIZE, y + h),
+            (64, 64, 64),
+            cv2.FILLED,
+        )
+        cv2.addWeighted(overlay, opacity, img, 1 - opacity, 0, img)
+
+    # put gray background to the left of the detected image
+    elif x - IDENTIFIED_IMG_SIZE > 0:
+        cv2.rectangle(
+            img,
+            (x - IDENTIFIED_IMG_SIZE, y),
+            (x, y + h),
+            (64, 64, 64),
+            cv2.FILLED,
+        )
+        cv2.addWeighted(overlay, opacity, img, 1 - opacity, 0, img)
+
+    for index, instance in emotion_df.iterrows():
+        current_emotion = instance["emotion"]
+        emotion_label = f"{current_emotion} "
+        emotion_score = instance["score"] / 100
+
+        filled_bar_x = 35  # this is the size if an emotion is 100%
+        bar_x = int(filled_bar_x * emotion_score)
+
+        if x + w + IDENTIFIED_IMG_SIZE < img.shape[1]:
+
+            text_location_y = y + 20 + (index + 1) * 20
+            text_location_x = x + w
+
+            if text_location_y < y + h:
+                cv2.putText(
+                    img,
+                    emotion_label,
+                    (text_location_x, text_location_y),
+                    cv2.FONT_HERSHEY_SIMPLEX,
+                    0.5,
+                    (255, 255, 255),
+                    1,
+                )
+
+                cv2.rectangle(
+                    img,
+                    (x + w + 70, y + 13 + (index + 1) * 20),
+                    (
+                        x + w + 70 + bar_x,
+                        y + 13 + (index + 1) * 20 + 5,
+                    ),
+                    (255, 255, 255),
+                    cv2.FILLED,
+                )
+
+        elif x - IDENTIFIED_IMG_SIZE > 0:
+
+            text_location_y = y + 20 + (index + 1) * 20
+            text_location_x = x - IDENTIFIED_IMG_SIZE
+
+            if text_location_y <= y + h:
+                cv2.putText(
+                    img,
+                    emotion_label,
+                    (text_location_x, text_location_y),
+                    cv2.FONT_HERSHEY_SIMPLEX,
+                    0.5,
+                    (255, 255, 255),
+                    1,
+                )
+
+                cv2.rectangle(
+                    img,
+                    (
+                        x - IDENTIFIED_IMG_SIZE + 70,
+                        y + 13 + (index + 1) * 20,
+                    ),
+                    (
+                        x - IDENTIFIED_IMG_SIZE + 70 + bar_x,
+                        y + 13 + (index + 1) * 20 + 5,
+                    ),
+                    (255, 255, 255),
+                    cv2.FILLED,
+                )
+
+    return img
+
+
+def overlay_age_gender(
+    img: np.ndarray, apparent_age: float, gender: str, x: int, y: int, w: int, h: int
+) -> np.ndarray:
+    """
+    Overlay the analyzed age and gender of face onto image itself
+    Args:
+        img (np.ndarray): image itself
+        apparent_age (float): analyzed apparent age
+        gender (str): analyzed gender
+        x (int): x coordinate of the face on the given image
+        y (int): y coordinate of the face on the given image
+        w (int): w coordinate of the face on the given image
+        h (int): h coordinate of the face on the given image
+    Returns:
+        img (np.ndarray): image with overlay age and gender analsis results
+    """
+    logger.debug(f"{apparent_age} years old {gender}")
+    analysis_report = f"{int(apparent_age)} {gender}"
+
+    info_box_color = (46, 200, 255)
+
+    # show its age and gender on the top of the image
+    if y - IDENTIFIED_IMG_SIZE + int(IDENTIFIED_IMG_SIZE / 5) > 0:
+
+        triangle_coordinates = np.array(
+            [
+                (x + int(w / 2), y),
+                (
+                    x + int(w / 2) - int(w / 10),
+                    y - int(IDENTIFIED_IMG_SIZE / 3),
+                ),
+                (
+                    x + int(w / 2) + int(w / 10),
+                    y - int(IDENTIFIED_IMG_SIZE / 3),
+                ),
+            ]
+        )
+
+        cv2.drawContours(
+            img,
+            [triangle_coordinates],
+            0,
+            info_box_color,
+            -1,
+        )
+
+        cv2.rectangle(
+            img,
+            (
+                x + int(w / 5),
+                y - IDENTIFIED_IMG_SIZE + int(IDENTIFIED_IMG_SIZE / 5),
+            ),
+            (x + w - int(w / 5), y - int(IDENTIFIED_IMG_SIZE / 3)),
+            info_box_color,
+            cv2.FILLED,
+        )
+
+        cv2.putText(
+            img,
+            analysis_report,
+            (x + int(w / 3.5), y - int(IDENTIFIED_IMG_SIZE / 2.1)),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            1,
+            (0, 111, 255),
+            2,
+        )
+
+    # show its age and gender on the top of the image
+    elif y + h + IDENTIFIED_IMG_SIZE - int(IDENTIFIED_IMG_SIZE / 5) < img.shape[0]:
+
+        triangle_coordinates = np.array(
+            [
+                (x + int(w / 2), y + h),
+                (
+                    x + int(w / 2) - int(w / 10),
+                    y + h + int(IDENTIFIED_IMG_SIZE / 3),
+                ),
+                (
+                    x + int(w / 2) + int(w / 10),
+                    y + h + int(IDENTIFIED_IMG_SIZE / 3),
+                ),
+            ]
+        )
+
+        cv2.drawContours(
+            img,
+            [triangle_coordinates],
+            0,
+            info_box_color,
+            -1,
+        )
+
+        cv2.rectangle(
+            img,
+            (x + int(w / 5), y + h + int(IDENTIFIED_IMG_SIZE / 3)),
+            (
+                x + w - int(w / 5),
+                y + h + IDENTIFIED_IMG_SIZE - int(IDENTIFIED_IMG_SIZE / 5),
+            ),
+            info_box_color,
+            cv2.FILLED,
+        )
+
+        cv2.putText(
+            img,
+            analysis_report,
+            (x + int(w / 3.5), y + h + int(IDENTIFIED_IMG_SIZE / 1.5)),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            1,
+            (0, 111, 255),
+            2,
+        )
+
+    return img
diff --git a/modules/verification.py b/modules/verification.py
new file mode 100644
index 0000000000000000000000000000000000000000..6bb5248f4fa525cd2e3761af1fd92c737542aa6d
--- /dev/null
+++ b/modules/verification.py
@@ -0,0 +1,374 @@
+# built-in dependencies
+import time
+from typing import Any, Dict, Union, List, Tuple
+
+# 3rd party dependencies
+import numpy as np
+
+# project dependencies
+from deepface.modules import representation, detection, modeling
+from deepface.models.FacialRecognition import FacialRecognition
+from deepface.commons import logger as log
+
+logger = log.get_singletonish_logger()
+
+
+def verify(
+    img1_path: Union[str, np.ndarray, List[float]],
+    img2_path: Union[str, np.ndarray, List[float]],
+    model_name: str = "VGG-Face",
+    detector_backend: str = "opencv",
+    distance_metric: str = "cosine",
+    enforce_detection: bool = True,
+    align: bool = True,
+    expand_percentage: int = 0,
+    normalization: str = "base",
+    silent: bool = False,
+) -> Dict[str, Any]:
+    """
+    Verify if an image pair represents the same person or different persons.
+
+    The verification function converts facial images to vectors and calculates the similarity
+    between those vectors. Vectors of images of the same person should exhibit higher similarity
+    (or lower distance) than vectors of images of different persons.
+
+    Args:
+        img1_path (str or np.ndarray or List[float]): Path to the first image.
+            Accepts exact image path as a string, numpy array (BGR), base64 encoded images
+            or pre-calculated embeddings.
+
+        img2_path (str or np.ndarray or  or List[float]): Path to the second image.
+            Accepts exact image path as a string, numpy array (BGR), base64 encoded images
+            or pre-calculated embeddings.
+
+        model_name (str): Model for face recognition. Options: VGG-Face, Facenet, Facenet512,
+            OpenFace, DeepFace, DeepID, Dlib, ArcFace, SFace and GhostFaceNet (default is VGG-Face).
+
+        detector_backend (string): face detector backend. Options: 'opencv', 'retinaface',
+            'mtcnn', 'ssd', 'dlib', 'mediapipe', 'yolov8', 'centerface' or 'skip'
+            (default is opencv)
+
+        distance_metric (string): Metric for measuring similarity. Options: 'cosine',
+            'euclidean', 'euclidean_l2' (default is cosine).
+
+        enforce_detection (boolean): If no face is detected in an image, raise an exception.
+            Set to False to avoid the exception for low-resolution images (default is True).
+
+        align (bool): Flag to enable face alignment (default is True).
+
+        expand_percentage (int): expand detected facial area with a percentage (default is 0).
+
+        normalization (string): Normalize the input image before feeding it to the model.
+            Options: base, raw, Facenet, Facenet2018, VGGFace, VGGFace2, ArcFace (default is base)
+
+        silent (boolean): Suppress or allow some log messages for a quieter analysis process
+            (default is False).
+
+    Returns:
+        result (dict): A dictionary containing verification results.
+
+        - 'verified' (bool): Indicates whether the images represent the same person (True)
+            or different persons (False).
+
+        - 'distance' (float): The distance measure between the face vectors.
+            A lower distance indicates higher similarity.
+
+        - 'max_threshold_to_verify' (float): The maximum threshold used for verification.
+            If the distance is below this threshold, the images are considered a match.
+
+        - 'model' (str): The chosen face recognition model.
+
+        - 'similarity_metric' (str): The chosen similarity metric for measuring distances.
+
+        - 'facial_areas' (dict): Rectangular regions of interest for faces in both images.
+            - 'img1': {'x': int, 'y': int, 'w': int, 'h': int}
+                    Region of interest for the first image.
+            - 'img2': {'x': int, 'y': int, 'w': int, 'h': int}
+                    Region of interest for the second image.
+
+        - 'time' (float): Time taken for the verification process in seconds.
+    """
+
+    tic = time.time()
+
+    model: FacialRecognition = modeling.build_model(model_name)
+    dims = model.output_shape
+
+    # extract faces from img1
+    if isinstance(img1_path, list):
+        # given image is already pre-calculated embedding
+        if not all(isinstance(dim, float) for dim in img1_path):
+            raise ValueError(
+                "When passing img1_path as a list, ensure that all its items are of type float."
+            )
+
+        if silent is False:
+            logger.warn(
+                "You passed 1st image as pre-calculated embeddings."
+                f"Please ensure that embeddings have been calculated for the {model_name} model."
+            )
+
+        if len(img1_path) != dims:
+            raise ValueError(
+                f"embeddings of {model_name} should have {dims} dimensions,"
+                f" but it has {len(img1_path)} dimensions input"
+            )
+
+        img1_embeddings = [img1_path]
+        img1_facial_areas = [None]
+    else:
+        try:
+            img1_embeddings, img1_facial_areas = __extract_faces_and_embeddings(
+                img_path=img1_path,
+                model_name=model_name,
+                detector_backend=detector_backend,
+                enforce_detection=enforce_detection,
+                align=align,
+                expand_percentage=expand_percentage,
+                normalization=normalization,
+            )
+        except ValueError as err:
+            raise ValueError("Exception while processing img1_path") from err
+
+    # extract faces from img2
+    if isinstance(img2_path, list):
+        # given image is already pre-calculated embedding
+        if not all(isinstance(dim, float) for dim in img2_path):
+            raise ValueError(
+                "When passing img2_path as a list, ensure that all its items are of type float."
+            )
+
+        if silent is False:
+            logger.warn(
+                "You passed 2nd image as pre-calculated embeddings."
+                f"Please ensure that embeddings have been calculated for the {model_name} model."
+            )
+
+        if len(img2_path) != dims:
+            raise ValueError(
+                f"embeddings of {model_name} should have {dims} dimensions,"
+                f" but it has {len(img2_path)} dimensions input"
+            )
+
+        img2_embeddings = [img2_path]
+        img2_facial_areas = [None]
+    else:
+        try:
+            img2_embeddings, img2_facial_areas = __extract_faces_and_embeddings(
+                img_path=img2_path,
+                model_name=model_name,
+                detector_backend=detector_backend,
+                enforce_detection=enforce_detection,
+                align=align,
+                expand_percentage=expand_percentage,
+                normalization=normalization,
+            )
+        except ValueError as err:
+            raise ValueError("Exception while processing img2_path") from err
+
+    no_facial_area = {
+        "x": None,
+        "y": None,
+        "w": None,
+        "h": None,
+        "left_eye": None,
+        "right_eye": None,
+    }
+
+    distances = []
+    facial_areas = []
+    for idx, img1_embedding in enumerate(img1_embeddings):
+        for idy, img2_embedding in enumerate(img2_embeddings):
+            distance = find_distance(img1_embedding, img2_embedding, distance_metric)
+            distances.append(distance)
+            facial_areas.append(
+                (img1_facial_areas[idx] or no_facial_area, img2_facial_areas[idy] or no_facial_area)
+            )
+
+    # find the face pair with minimum distance
+    threshold = find_threshold(model_name, distance_metric)
+    distance = float(min(distances))  # best distance
+    facial_areas = facial_areas[np.argmin(distances)]
+
+    toc = time.time()
+
+    resp_obj = {
+        "verified": distance <= threshold,
+        "distance": distance,
+        "threshold": threshold,
+        "model": model_name,
+        "detector_backend": detector_backend,
+        "similarity_metric": distance_metric,
+        "facial_areas": {"img1": facial_areas[0], "img2": facial_areas[1]},
+        "time": round(toc - tic, 2),
+    }
+
+    return resp_obj
+
+
+def __extract_faces_and_embeddings(
+    img_path: Union[str, np.ndarray],
+    model_name: str = "VGG-Face",
+    detector_backend: str = "opencv",
+    enforce_detection: bool = True,
+    align: bool = True,
+    expand_percentage: int = 0,
+    normalization: str = "base",
+) -> Tuple[List[List[float]], List[dict]]:
+    """
+    Extract facial areas and find corresponding embeddings for given image
+    Returns:
+        embeddings (List[float])
+        facial areas (List[dict])
+    """
+    embeddings = []
+    facial_areas = []
+
+    img_objs = detection.extract_faces(
+        img_path=img_path,
+        detector_backend=detector_backend,
+        grayscale=False,
+        enforce_detection=enforce_detection,
+        align=align,
+        expand_percentage=expand_percentage,
+    )
+
+    # find embeddings for each face
+    for img_obj in img_objs:
+        img_embedding_obj = representation.represent(
+            img_path=img_obj["face"],
+            model_name=model_name,
+            enforce_detection=enforce_detection,
+            detector_backend="skip",
+            align=align,
+            normalization=normalization,
+        )
+        # already extracted face given, safe to access its 1st item
+        img_embedding = img_embedding_obj[0]["embedding"]
+        embeddings.append(img_embedding)
+        facial_areas.append(img_obj["facial_area"])
+
+    return embeddings, facial_areas
+
+
+def find_cosine_distance(
+    source_representation: Union[np.ndarray, list], test_representation: Union[np.ndarray, list]
+) -> np.float64:
+    """
+    Find cosine distance between two given vectors
+    Args:
+        source_representation (np.ndarray or list): 1st vector
+        test_representation (np.ndarray or list): 2nd vector
+    Returns
+        distance (np.float64): calculated cosine distance
+    """
+    if isinstance(source_representation, list):
+        source_representation = np.array(source_representation)
+
+    if isinstance(test_representation, list):
+        test_representation = np.array(test_representation)
+
+    a = np.matmul(np.transpose(source_representation), test_representation)
+    b = np.sum(np.multiply(source_representation, source_representation))
+    c = np.sum(np.multiply(test_representation, test_representation))
+    return 1 - (a / (np.sqrt(b) * np.sqrt(c)))
+
+
+def find_euclidean_distance(
+    source_representation: Union[np.ndarray, list], test_representation: Union[np.ndarray, list]
+) -> np.float64:
+    """
+    Find euclidean distance between two given vectors
+    Args:
+        source_representation (np.ndarray or list): 1st vector
+        test_representation (np.ndarray or list): 2nd vector
+    Returns
+        distance (np.float64): calculated euclidean distance
+    """
+    if isinstance(source_representation, list):
+        source_representation = np.array(source_representation)
+
+    if isinstance(test_representation, list):
+        test_representation = np.array(test_representation)
+
+    euclidean_distance = source_representation - test_representation
+    euclidean_distance = np.sum(np.multiply(euclidean_distance, euclidean_distance))
+    euclidean_distance = np.sqrt(euclidean_distance)
+    return euclidean_distance
+
+
+def l2_normalize(x: Union[np.ndarray, list]) -> np.ndarray:
+    """
+    Normalize input vector with l2
+    Args:
+        x (np.ndarray or list): given vector
+    Returns:
+        y (np.ndarray): l2 normalized vector
+    """
+    if isinstance(x, list):
+        x = np.array(x)
+    return x / np.sqrt(np.sum(np.multiply(x, x)))
+
+
+def find_distance(
+    alpha_embedding: Union[np.ndarray, list],
+    beta_embedding: Union[np.ndarray, list],
+    distance_metric: str,
+) -> np.float64:
+    """
+    Wrapper to find distance between vectors according to the given distance metric
+    Args:
+        source_representation (np.ndarray or list): 1st vector
+        test_representation (np.ndarray or list): 2nd vector
+    Returns
+        distance (np.float64): calculated cosine distance
+    """
+    if distance_metric == "cosine":
+        distance = find_cosine_distance(alpha_embedding, beta_embedding)
+    elif distance_metric == "euclidean":
+        distance = find_euclidean_distance(alpha_embedding, beta_embedding)
+    elif distance_metric == "euclidean_l2":
+        distance = find_euclidean_distance(
+            l2_normalize(alpha_embedding), l2_normalize(beta_embedding)
+        )
+    else:
+        raise ValueError("Invalid distance_metric passed - ", distance_metric)
+    return distance
+
+
+def find_threshold(model_name: str, distance_metric: str) -> float:
+    """
+    Retrieve pre-tuned threshold values for a model and distance metric pair
+    Args:
+        model_name (str): Model for face recognition. Options: VGG-Face, Facenet, Facenet512,
+            OpenFace, DeepFace, DeepID, Dlib, ArcFace, SFace and GhostFaceNet (default is VGG-Face).
+        distance_metric (str): distance metric name. Options are cosine, euclidean
+            and euclidean_l2.
+    Returns:
+        threshold (float): threshold value for that model name and distance metric
+            pair. Distances less than this threshold will be classified same person.
+    """
+
+    base_threshold = {"cosine": 0.40, "euclidean": 0.55, "euclidean_l2": 0.75}
+
+    thresholds = {
+        # "VGG-Face": {"cosine": 0.40, "euclidean": 0.60, "euclidean_l2": 0.86}, # 2622d
+        "VGG-Face": {
+            "cosine": 0.68,
+            "euclidean": 1.17,
+            "euclidean_l2": 1.17,
+        },  # 4096d - tuned with LFW
+        "Facenet": {"cosine": 0.40, "euclidean": 10, "euclidean_l2": 0.80},
+        "Facenet512": {"cosine": 0.30, "euclidean": 23.56, "euclidean_l2": 1.04},
+        "ArcFace": {"cosine": 0.68, "euclidean": 4.15, "euclidean_l2": 1.13},
+        "Dlib": {"cosine": 0.07, "euclidean": 0.6, "euclidean_l2": 0.4},
+        "SFace": {"cosine": 0.593, "euclidean": 10.734, "euclidean_l2": 1.055},
+        "OpenFace": {"cosine": 0.10, "euclidean": 0.55, "euclidean_l2": 0.55},
+        "DeepFace": {"cosine": 0.23, "euclidean": 64, "euclidean_l2": 0.64},
+        "DeepID": {"cosine": 0.015, "euclidean": 45, "euclidean_l2": 0.17},
+        "GhostFaceNet": {"cosine": 0.65, "euclidean": 35.71, "euclidean_l2": 1.10},
+    }
+
+    threshold = thresholds.get(model_name, base_threshold).get(distance_metric, 0.4)
+
+    return threshold
diff --git a/package_info.json b/package_info.json
new file mode 100644
index 0000000000000000000000000000000000000000..36c186393773faad2a29563b5a2868ae268f9c96
--- /dev/null
+++ b/package_info.json
@@ -0,0 +1,3 @@
+{
+    "version": "0.0.90"
+}
\ No newline at end of file
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0d1fefc5fdafa1ef09b193b827fd21de96ab9723
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,16 @@
+requests>=2.27.1
+numpy>=1.14.0
+pandas>=0.23.4
+gdown>=3.10.1
+tqdm>=4.30.0
+Pillow>=5.2.0
+opencv-python>=4.5.5.64
+tensorflow>=1.9.0
+keras>=2.2.0
+Flask>=1.1.2
+mtcnn>=0.1.0
+retina-face>=0.0.1
+fire>=0.4.0
+gunicorn>=20.1.0
+cloudinary>=1.40.0
+python-dotenv>=1.0.1
diff --git a/requirements_additional.txt b/requirements_additional.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0344661d6387c28115da5949aa75bf4dd31d5c1a
--- /dev/null
+++ b/requirements_additional.txt
@@ -0,0 +1,5 @@
+opencv-contrib-python>=4.3.0.36
+mediapipe>=0.8.7.3
+dlib>=19.20.0
+ultralytics>=8.0.122
+facenet-pytorch>=2.5.3
\ No newline at end of file
diff --git a/requirements_local b/requirements_local
new file mode 100644
index 0000000000000000000000000000000000000000..e869c3f4053c7f1fb74814e0783e9057f37b9fc4
--- /dev/null
+++ b/requirements_local
@@ -0,0 +1,6 @@
+numpy==1.22.3
+pandas==2.0.3
+Pillow==9.0.0
+opencv-python==4.9.0.80
+tensorflow==2.9.0
+keras==2.9.0
diff --git a/setup.py b/setup.py
new file mode 100644
index 0000000000000000000000000000000000000000..6424cecf31ddf8110307952e38e0da9ff2c5c68a
--- /dev/null
+++ b/setup.py
@@ -0,0 +1,37 @@
+import json
+import setuptools
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+with open("requirements.txt", "r", encoding="utf-8") as f:
+    requirements = f.read().split("\n")
+
+with open("package_info.json", "r", encoding="utf-8") as f:
+    package_info = json.load(f)
+
+setuptools.setup(
+    name="deepface",
+    version=package_info["version"],
+    author="Sefik Ilkin Serengil",
+    author_email="serengil@gmail.com",
+    description=(
+        "A Lightweight Face Recognition and Facial Attribute Analysis Framework"
+        " (Age, Gender, Emotion, Race) for Python"
+    ),
+    data_files=[("", ["README.md", "requirements.txt", "package_info.json"])],
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/serengil/deepface",
+    packages=setuptools.find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    entry_points={
+        "console_scripts": ["deepface = deepface.DeepFace:cli"],
+    },
+    python_requires=">=3.7",
+    install_requires=requirements,
+)
diff --git a/spoofmodels/__pycache__/FasNet.cpython-312.pyc b/spoofmodels/__pycache__/FasNet.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..644c8129a5e2160ea8fb954a2c412b8dcdffa9c4
Binary files /dev/null and b/spoofmodels/__pycache__/FasNet.cpython-312.pyc differ
diff --git a/spoofmodels/__pycache__/__init__.cpython-312.pyc b/spoofmodels/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..627b50816d636ae70da4eb2844948c8f3ca3644c
Binary files /dev/null and b/spoofmodels/__pycache__/__init__.cpython-312.pyc differ