init

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)
+

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.

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

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)

__init__.py

@@ -0,0 +1 @@
+__version__ = "0.0.90"

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": []
+		}
+	]
+}

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)

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
+

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)

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

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")

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

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

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

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

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)

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

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

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