First commit

.gitattributes

@@ -1,34 +1,34 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,163 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Custom gitignore
+run_app.sh

01-🚀 Homepage.py

@@ -0,0 +1,149 @@
+import streamlit as st
+from streamlit_extras.switch_page_button import switch_page
+
+from utils.functional import generate_empty_space, set_page_config
+
+# Set page config
+set_page_config("Homepage", "🚀")
+
+# First Header
+st.markdown("# 😊 About Me")
+st.write(
+    """
+    👋 Hello everyone! My name is Hafidh Soekma Ardiansyah and I'm a student at Surabaya State University, majoring in Management Information Vocational Programs. 🎓
+
+I am excited to share with you all about my final project for the semester. 📚 My project is about classifying anime characters from the popular Hunter X Hunter anime series using various machine learning algorithms. 🤖
+
+To start the project, I collected a dataset of images featuring the characters from the series. 📷 Then, I preprocessed the data to ensure that the algorithms could efficiently process it. 💻
+
+After the data preparation, I used various algorithms such as Deep Learning, Prototypical Networks, and many more to classify the characters. 🧠
+
+Through this project, I hope to showcase my skills in machine learning and contribute to the community of anime fans who are interested in image classification. 🙌
+
+Thank you for your attention, and please feel free to ask me any questions about the project! 🤗
+
+    """
+)
+
+st.markdown("# 🕵️ About the Project")
+
+st.markdown("### 🦸 HxH Character Anime Classification with Prototypical Networks")
+st.write(
+    "Classify your favorite Hunter x Hunter characters with our cutting-edge Prototypical Networks! 🦸‍♂️🦸‍♀️"
+)
+go_to_page_0 = st.button(
+    "Go to page 0",
+)
+generate_empty_space(2)
+if go_to_page_0:
+    switch_page("hxh character anime classification with prototypical networks")
+
+st.markdown("### 🔎 HxH Character Anime Detection with Prototypical Networks")
+st.write(
+    "Detect the presence of your beloved Hunter x Hunter characters using Prototypical Networks! 🔎🕵️‍♂️🕵️‍♀️"
+)
+go_to_page_1 = st.button(
+    "Go to page 1",
+)
+generate_empty_space(2)
+if go_to_page_1:
+    switch_page("hxh character anime detection with prototypical networks")
+
+st.markdown("### 📊 Image Similarity with Prototypical Networks")
+st.write(
+    "Discover how similar your Images are to one another with our Prototypical Networks! 📊🤔"
+)
+go_to_page_2 = st.button(
+    "Go to page 2",
+)
+generate_empty_space(2)
+if go_to_page_2:
+    switch_page("image similarity with prototypical networks")
+
+st.markdown("### 🌌 Image Embeddings with Prototypical Networks")
+st.write(
+    "Unleash the power of image embeddings to represent Images in a whole new way with our Prototypical Networks! 🌌🤯"
+)
+go_to_page_3 = st.button(
+    "Go to page 3",
+)
+generate_empty_space(2)
+if go_to_page_3:
+    switch_page("image embeddings with prototypical networks")
+
+st.markdown("### 🤖 HxH Character Anime Classification with Deep Learning")
+st.write(
+    "Experience the next level of character classification with our Deep Learning models trained on Hunter x Hunter anime characters! 🤖📈"
+)
+go_to_page_4 = st.button(
+    "Go to page 4",
+)
+generate_empty_space(2)
+if go_to_page_4:
+    switch_page("hxh character anime classification with deep learning")
+
+st.markdown("### 📷 HxH Character Anime Detection with Deep Learning")
+st.write(
+    "Detect your favorite Hunter x Hunter characters with our Deep Learning models! 📷🕵️‍♂️🕵️‍♀️"
+)
+go_to_page_5 = st.button(
+    "Go to page 5",
+)
+generate_empty_space(2)
+if go_to_page_5:
+    switch_page("hxh character anime detection with deep learning")
+
+st.markdown("### 🖼️ Image Similarity with Deep Learning")
+st.write(
+    "Discover the similarities and differences between your Images with our Deep Learning models! 🖼️🧐"
+)
+go_to_page_6 = st.button(
+    "Go to page 6",
+)
+generate_empty_space(2)
+if go_to_page_6:
+    switch_page("image similarity with deep learning")
+
+st.markdown("### 📈 Image Embeddings with Deep Learning")
+st.write(
+    "Explore a new dimension of Images representations with our Deep Learning-based image embeddings! 📈🔍"
+)
+go_to_page_7 = st.button(
+    "Go to page 7",
+)
+generate_empty_space(2)
+if go_to_page_7:
+    switch_page("image embeddings with deep learning")
+
+st.markdown("### 🎯 Zero-Shot Image Classification with CLIP")
+st.write(
+    "Classify Images with zero training using CLIP, a state-of-the-art language-image model! 🎯🤯"
+)
+go_to_page_8 = st.button(
+    "Go to page 8",
+)
+generate_empty_space(2)
+if go_to_page_8:
+    switch_page("zero-shot image classification with clip")
+
+st.markdown("### 😊 More About Me")
+st.write(
+    "Curious to learn more about the person behind these amazing projects? Check out my bio and get to know me better! 😊🧑‍💼"
+)
+go_to_page_9 = st.button(
+    "Go to page 9",
+)
+generate_empty_space(2)
+if go_to_page_9:
+    switch_page("more about me")
+
+st.markdown("### 📚 Glossary")
+st.write(
+    "Not sure what some of the terms used in this project mean? Check out our glossary to learn more! 📚🤓"
+)
+go_to_page_10 = st.button(
+    "Go to page 10",
+)
+generate_empty_space(2)
+if go_to_page_10:
+    switch_page("glossary")

README.md

@@ -1,13 +1,77 @@
----
-title: Hunter X Hunter Anime Classification
-emoji: 🔥
-colorFrom: pink
-colorTo: green
-sdk: streamlit
-sdk_version: 1.19.0
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Hunter X Hunter Anime Classification
+emoji: 🔥
+colorFrom: white
+colorTo: green
+sdk: streamlit
+sdk_version: 1.19.0
+app_file: "01-🚀 Homepage.py"
+pinned: false
+license: mit
+python_version: 3.9.13
+---
+
+# Hunter X Hunter Anime Classification
+
+Welcome to the Hunter X Hunter Anime Classification application! This project focuses on classifying anime characters from the popular Hunter X Hunter anime series using various machine learning algorithms.
+
+## About Me
+
+👋 Hello everyone! My name is Hafidh Soekma Ardiansyah, and I'm a student at Surabaya State University, majoring in Management Information Vocational Programs.
+
+I am excited to share with you all about my final project for the semester. My project is about classifying anime characters from the Hunter X Hunter series using various machine learning algorithms. To accomplish this, I collected a dataset of images featuring the characters from the series and preprocessed the data to ensure efficient processing by the algorithms.
+
+## About the Project
+
+### HxH Character Anime Classification with Prototypical Networks
+
+Classify your favorite Hunter x Hunter characters with our cutting-edge Prototypical Networks! 🦸‍♂️🦸‍♀️
+
+### HxH Character Anime Detection with Prototypical Networks
+
+Detect the presence of your beloved Hunter x Hunter characters using Prototypical Networks! 🔎🕵️‍♂️🕵️‍♀️
+
+### Image Similarity with Prototypical Networks
+
+Discover how similar your images are to one another with our Prototypical Networks! 📊🤔
+
+### Image Embeddings with Prototypical Networks
+
+Unleash the power of image embeddings to represent images in a whole new way with our Prototypical Networks! 🌌🤯
+
+### HxH Character Anime Classification with Deep Learning
+
+Experience the next level of character classification with our Deep Learning models trained on Hunter x Hunter anime characters! 🤖📈
+
+### HxH Character Anime Detection with Deep Learning
+
+Detect your favorite Hunter x Hunter characters with our Deep Learning models! 📷🕵️‍♂️🕵️‍♀️
+
+### Image Similarity with Deep Learning
+
+Discover the similarities and differences between your images with our Deep Learning models! 🖼️🧐
+
+### Image Embeddings with Deep Learning
+
+Explore a new dimension of image representations with our Deep Learning-based image embeddings! 📈🔍
+
+### Zero-Shot Image Classification with CLIP
+
+Classify images with zero training using CLIP, a state-of-the-art language-image model! 🎯🤯
+
+### More About Me
+
+Curious to learn more about the person behind these amazing projects? Check out my bio and get to know me better! 😊🧑‍💼
+
+### Glossary
+
+Not sure what some of the terms used in this project mean? Check out our glossary to learn more! 📚🤓
+
+## How to Run the Application
+
+1. Clone the repository: `git clone hhttps://huggingface.co/spaces/hafidhsoekma/Hunter-X-Hunter-Anime-Classification`
+2. Install the required dependencies: `pip install -r requirements.txt`
+3. Run the application: `streamlit run "01-🚀 Homepage.py"`
+4. Open your web browser and navigate to the provided URL to access the application.
+
+Feel free to reach out to me if you have any questions or feedback. Enjoy exploring the Hunter X Hunter Anime Classification application!

models/anime_face_detection_model/__init__.py

@@ -0,0 +1 @@
+from .ssd_model import SingleShotDetectorModel

models/anime_face_detection_model/ssd_model.py

@@ -0,0 +1,454 @@
+import os
+import sys
+
+sys.path.append(os.path.join(os.path.dirname(__file__), "..", ".."))
+
+import time
+from itertools import product as product
+from math import ceil
+
+import cv2
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class BasicConv2d(nn.Module):
+    def __init__(self, in_channels, out_channels, **kwargs):
+        super(BasicConv2d, self).__init__()
+        self.conv = nn.Conv2d(in_channels, out_channels, bias=False, **kwargs)
+        self.bn = nn.BatchNorm2d(out_channels, eps=1e-5)
+
+    def forward(self, x):
+        x = self.conv(x)
+        x = self.bn(x)
+        return F.relu(x, inplace=True)
+
+
+class Inception(nn.Module):
+    def __init__(self):
+        super(Inception, self).__init__()
+        self.branch1x1 = BasicConv2d(128, 32, kernel_size=1, padding=0)
+        self.branch1x1_2 = BasicConv2d(128, 32, kernel_size=1, padding=0)
+        self.branch3x3_reduce = BasicConv2d(128, 24, kernel_size=1, padding=0)
+        self.branch3x3 = BasicConv2d(24, 32, kernel_size=3, padding=1)
+        self.branch3x3_reduce_2 = BasicConv2d(128, 24, kernel_size=1, padding=0)
+        self.branch3x3_2 = BasicConv2d(24, 32, kernel_size=3, padding=1)
+        self.branch3x3_3 = BasicConv2d(32, 32, kernel_size=3, padding=1)
+
+    def forward(self, x):
+        branch1x1 = self.branch1x1(x)
+
+        branch1x1_pool = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1)
+        branch1x1_2 = self.branch1x1_2(branch1x1_pool)
+
+        branch3x3_reduce = self.branch3x3_reduce(x)
+        branch3x3 = self.branch3x3(branch3x3_reduce)
+
+        branch3x3_reduce_2 = self.branch3x3_reduce_2(x)
+        branch3x3_2 = self.branch3x3_2(branch3x3_reduce_2)
+        branch3x3_3 = self.branch3x3_3(branch3x3_2)
+
+        outputs = (branch1x1, branch1x1_2, branch3x3, branch3x3_3)
+        return torch.cat(outputs, 1)
+
+
+class CRelu(nn.Module):
+    def __init__(self, in_channels, out_channels, **kwargs):
+        super(CRelu, self).__init__()
+        self.conv = nn.Conv2d(in_channels, out_channels, bias=False, **kwargs)
+        self.bn = nn.BatchNorm2d(out_channels, eps=1e-5)
+
+    def forward(self, x):
+        x = self.conv(x)
+        x = self.bn(x)
+        x = torch.cat((x, -x), 1)
+        x = F.relu(x, inplace=True)
+        return x
+
+
+class FaceBoxes(nn.Module):
+    def __init__(self, phase, size, num_classes):
+        super(FaceBoxes, self).__init__()
+        self.phase = phase
+        self.num_classes = num_classes
+        self.size = size
+
+        self.conv1 = CRelu(3, 24, kernel_size=7, stride=4, padding=3)
+        self.conv2 = CRelu(48, 64, kernel_size=5, stride=2, padding=2)
+
+        self.inception1 = Inception()
+        self.inception2 = Inception()
+        self.inception3 = Inception()
+
+        self.conv3_1 = BasicConv2d(128, 128, kernel_size=1, stride=1, padding=0)
+        self.conv3_2 = BasicConv2d(128, 256, kernel_size=3, stride=2, padding=1)
+
+        self.conv4_1 = BasicConv2d(256, 128, kernel_size=1, stride=1, padding=0)
+        self.conv4_2 = BasicConv2d(128, 256, kernel_size=3, stride=2, padding=1)
+
+        self.loc, self.conf = self.multibox(self.num_classes)
+
+        if self.phase == "test":
+            self.softmax = nn.Softmax(dim=-1)
+
+        if self.phase == "train":
+            for m in self.modules():
+                if isinstance(m, nn.Conv2d):
+                    if m.bias is not None:
+                        nn.init.xavier_normal_(m.weight.data)
+                        m.bias.data.fill_(0.02)
+                    else:
+                        m.weight.data.normal_(0, 0.01)
+                elif isinstance(m, nn.BatchNorm2d):
+                    m.weight.data.fill_(1)
+                    m.bias.data.zero_()
+
+    def multibox(self, num_classes):
+        loc_layers = []
+        conf_layers = []
+        loc_layers += [nn.Conv2d(128, 21 * 4, kernel_size=3, padding=1)]
+        conf_layers += [nn.Conv2d(128, 21 * num_classes, kernel_size=3, padding=1)]
+        loc_layers += [nn.Conv2d(256, 1 * 4, kernel_size=3, padding=1)]
+        conf_layers += [nn.Conv2d(256, 1 * num_classes, kernel_size=3, padding=1)]
+        loc_layers += [nn.Conv2d(256, 1 * 4, kernel_size=3, padding=1)]
+        conf_layers += [nn.Conv2d(256, 1 * num_classes, kernel_size=3, padding=1)]
+        return nn.Sequential(*loc_layers), nn.Sequential(*conf_layers)
+
+    def forward(self, x):
+        detection_sources = list()
+        loc = list()
+        conf = list()
+
+        x = self.conv1(x)
+        x = F.max_pool2d(x, kernel_size=3, stride=2, padding=1)
+        x = self.conv2(x)
+        x = F.max_pool2d(x, kernel_size=3, stride=2, padding=1)
+        x = self.inception1(x)
+        x = self.inception2(x)
+        x = self.inception3(x)
+        detection_sources.append(x)
+
+        x = self.conv3_1(x)
+        x = self.conv3_2(x)
+        detection_sources.append(x)
+
+        x = self.conv4_1(x)
+        x = self.conv4_2(x)
+        detection_sources.append(x)
+
+        for x, l, c in zip(detection_sources, self.loc, self.conf):
+            loc.append(l(x).permute(0, 2, 3, 1).contiguous())
+            conf.append(c(x).permute(0, 2, 3, 1).contiguous())
+
+        loc = torch.cat([o.view(o.size(0), -1) for o in loc], 1)
+        conf = torch.cat([o.view(o.size(0), -1) for o in conf], 1)
+
+        if self.phase == "test":
+            output = (
+                loc.view(loc.size(0), -1, 4),
+                self.softmax(conf.view(-1, self.num_classes)),
+            )
+        else:
+            output = (
+                loc.view(loc.size(0), -1, 4),
+                conf.view(conf.size(0), -1, self.num_classes),
+            )
+
+        return output
+
+
+class PriorBox(object):
+    def __init__(self, cfg, image_size=None, phase="train"):
+        super(PriorBox, self).__init__()
+        # self.aspect_ratios = cfg['aspect_ratios']
+        self.min_sizes = cfg["min_sizes"]
+        self.steps = cfg["steps"]
+        self.clip = cfg["clip"]
+        self.image_size = image_size
+        self.feature_maps = [
+            (ceil(self.image_size[0] / step), ceil(self.image_size[1] / step))
+            for step in self.steps
+        ]
+        self.feature_maps = tuple(self.feature_maps)
+
+    def forward(self):
+        anchors = []
+        for k, f in enumerate(self.feature_maps):
+            min_sizes = self.min_sizes[k]
+            for i, j in product(range(f[0]), range(f[1])):
+                for min_size in min_sizes:
+                    s_kx = min_size / self.image_size[1]
+                    s_ky = min_size / self.image_size[0]
+                    if min_size == 32:
+                        dense_cx = [
+                            x * self.steps[k] / self.image_size[1]
+                            for x in [j + 0, j + 0.25, j + 0.5, j + 0.75]
+                        ]
+                        dense_cy = [
+                            y * self.steps[k] / self.image_size[0]
+                            for y in [i + 0, i + 0.25, i + 0.5, i + 0.75]
+                        ]
+                        for cy, cx in product(dense_cy, dense_cx):
+                            anchors += [cx, cy, s_kx, s_ky]
+                    elif min_size == 64:
+                        dense_cx = [
+                            x * self.steps[k] / self.image_size[1]
+                            for x in [j + 0, j + 0.5]
+                        ]
+                        dense_cy = [
+                            y * self.steps[k] / self.image_size[0]
+                            for y in [i + 0, i + 0.5]
+                        ]
+                        for cy, cx in product(dense_cy, dense_cx):
+                            anchors += [cx, cy, s_kx, s_ky]
+                    else:
+                        cx = (j + 0.5) * self.steps[k] / self.image_size[1]
+                        cy = (i + 0.5) * self.steps[k] / self.image_size[0]
+                        anchors += [cx, cy, s_kx, s_ky]
+        # back to torch land
+        output = torch.Tensor(anchors).view(-1, 4)
+        if self.clip:
+            output.clamp_(max=1, min=0)
+        return output
+
+
+def mymax(a, b):
+    if a >= b:
+        return a
+    else:
+        return b
+
+
+def mymin(a, b):
+    if a >= b:
+        return b
+    else:
+        return a
+
+
+def cpu_nms(dets, thresh):
+    x1 = dets[:, 0]
+    y1 = dets[:, 1]
+    x2 = dets[:, 2]
+    y2 = dets[:, 3]
+    scores = dets[:, 4]
+    areas = (x2 - x1 + 1) * (y2 - y1 + 1)
+    order = scores.argsort()[::-1]
+    ndets = dets.shape[0]
+    suppressed = np.zeros((ndets), dtype=int)
+    keep = []
+    for _i in range(ndets):
+        i = order[_i]
+        if suppressed[i] == 1:
+            continue
+        keep.append(i)
+        ix1 = x1[i]
+        iy1 = y1[i]
+        ix2 = x2[i]
+        iy2 = y2[i]
+        iarea = areas[i]
+        for _j in range(_i + 1, ndets):
+            j = order[_j]
+            if suppressed[j] == 1:
+                continue
+            xx1 = mymax(ix1, x1[j])
+            yy1 = mymax(iy1, y1[j])
+            xx2 = mymin(ix2, x2[j])
+            yy2 = mymin(iy2, y2[j])
+            w = mymax(0.0, xx2 - xx1 + 1)
+            h = mymax(0.0, yy2 - yy1 + 1)
+            inter = w * h
+            ovr = inter / (iarea + areas[j] - inter)
+            if ovr >= thresh:
+                suppressed[j] = 1
+    return tuple(keep)
+
+
+def nms(dets, thresh, force_cpu=False):
+    """Dispatch to either CPU or GPU NMS implementations."""
+
+    if dets.shape[0] == 0:
+        return ()
+    if force_cpu:
+        # return cpu_soft_nms(dets, thresh, method = 0)
+        return cpu_nms(dets, thresh)
+    return cpu_nms(dets, thresh)
+
+
+# Adapted from https://github.com/Hakuyume/chainer-ssd
+def decode(loc, priors, variances):
+    """Decode locations from predictions using priors to undo
+    the encoding we did for offset regression at train time.
+    Args:
+        loc (tensor): location predictions for loc layers,
+            Shape: [num_priors,4]
+        priors (tensor): Prior boxes in center-offset form.
+            Shape: [num_priors,4].
+        variances: (list[float]) Variances of priorboxes
+    Return:
+        decoded bounding box predictions
+    """
+
+    boxes = torch.cat(
+        (
+            priors[:, :2] + loc[:, :2] * variances[0] * priors[:, 2:],
+            priors[:, 2:] * torch.exp(loc[:, 2:] * variances[1]),
+        ),
+        1,
+    )
+    boxes[:, :2] -= boxes[:, 2:] / 2
+    boxes[:, 2:] += boxes[:, :2]
+    return boxes
+
+
+def check_keys(model, pretrained_state_dict):
+    ckpt_keys = set(pretrained_state_dict.keys())
+    model_keys = set(model.state_dict().keys())
+    used_pretrained_keys = model_keys & ckpt_keys
+    unused_pretrained_keys = ckpt_keys - model_keys
+    missing_keys = model_keys - ckpt_keys
+    # print('Missing keys:{}'.format(len(missing_keys)))
+    # print('Unused checkpoint keys:{}'.format(len(unused_pretrained_keys)))
+    # print('Used keys:{}'.format(len(used_pretrained_keys)))
+    assert len(used_pretrained_keys) > 0, "load NONE from pretrained checkpoint"
+    return True
+
+
+def remove_prefix(state_dict, prefix):
+    """Old style model is stored with all names of parameters sharing common prefix 'module.'"""
+
+    # print('remove prefix \'{}\''.format(prefix))
+    def f(x):
+        return x.split(prefix, 1)[-1] if x.startswith(prefix) else x
+
+    return {f(key): value for key, value in state_dict.items()}
+
+
+def load_model(model, pretrained_path, load_to_cpu):
+    # print('Loading pretrained model from {}'.format(pretrained_path))
+    if load_to_cpu:
+        pretrained_dict = torch.load(
+            pretrained_path, map_location=lambda storage, loc: storage
+        )
+    else:
+        device = torch.cuda.current_device()
+        pretrained_dict = torch.load(
+            pretrained_path, map_location=lambda storage, loc: storage.cuda(device)
+        )
+    if "state_dict" in pretrained_dict.keys():
+        pretrained_dict = remove_prefix(pretrained_dict["state_dict"], "module.")
+    else:
+        pretrained_dict = remove_prefix(pretrained_dict, "module.")
+    check_keys(model, pretrained_dict)
+    model.load_state_dict(pretrained_dict, strict=False)
+    return model
+
+
+class SingleShotDetectorModel:
+    def __init__(
+        self,
+        path_to_weights: str = "./weights/anime_face_detection/ssd_anime_face_detect.pth",
+        confidence_threshold: float = 0.5,
+        nms_threshold: float = 0.3,
+        top_k: int = 5000,
+        keep_top_k: int = 750,
+    ):
+        self.path_to_weights = path_to_weights
+        self.confidence_threshold = confidence_threshold
+        self.nms_threshold = nms_threshold
+        self.top_k = top_k
+        self.keep_top_k = keep_top_k
+
+        self.cfg = {
+            "name": "FaceBoxes",
+            #'min_dim': 1024,
+            #'feature_maps': [[32, 32], [16, 16], [8, 8]],
+            # 'aspect_ratios': [[1], [1], [1]],
+            "min_sizes": [[32, 64, 128], [256], [512]],
+            "steps": [32, 64, 128],
+            "variance": [0.1, 0.2],
+            "clip": False,
+            "loc_weight": 2.0,
+            "gpu_train": True,
+        }
+
+        self.cpu = False if torch.cuda.is_available() else True
+        torch.set_grad_enabled(False)
+        self.net = FaceBoxes(phase="test", size=None, num_classes=2)
+        self.net = load_model(self.net, path_to_weights, self.cpu)
+        self.net.eval()
+        self.device = torch.device("cpu" if self.cpu else "cuda")
+        self.net = self.net.to(self.device)
+
+    def detect_anime_face(self, image: np.ndarray) -> dict:
+        image = np.float32(image)
+        im_height, im_width, _ = image.shape
+        scale = torch.Tensor(
+            (image.shape[1], image.shape[0], image.shape[1], image.shape[0])
+        )
+        image -= (104, 117, 123)
+        image = image.transpose(2, 0, 1)
+        image = torch.from_numpy(image).unsqueeze(0)
+        start_time = time.perf_counter()
+        image = image.to(self.device)
+        end_time = time.perf_counter() - start_time
+        scale = scale.to(self.device)
+
+        loc, conf = self.net(image)  # forward pass
+        priorbox = PriorBox(self.cfg, image_size=(im_height, im_width))
+        priors = priorbox.forward()
+        priors = priors.to(self.device)
+        prior_data = priors.data
+        boxes = decode(loc.data.squeeze(0), prior_data, self.cfg["variance"])
+        boxes = boxes * scale
+        boxes = boxes.cpu().numpy()
+        scores = conf.data.cpu().numpy()[:, 1]
+
+        # ignore low scores
+        inds = np.where(scores > self.confidence_threshold)[0]
+        boxes = boxes[inds]
+        scores = scores[inds]
+
+        # keep top-K before NMS
+        order = scores.argsort()[::-1][: self.top_k]
+        boxes = boxes[order]
+        scores = scores[order]
+
+        # do NMS
+        dets = np.hstack((boxes, scores[:, np.newaxis])).astype(np.float32, copy=False)
+        # keep = py_cpu_nms(dets, args.nms_threshold)
+        keep = nms(dets, self.nms_threshold, force_cpu=self.cpu)
+        dets = dets[keep, :]
+
+        # keep top-K faster NMS
+        dets = dets[: self.keep_top_k, :]
+
+        return_data = []
+        for k in range(dets.shape[0]):
+            xmin = dets[k, 0]
+            ymin = dets[k, 1]
+            xmax = dets[k, 2]
+            ymax = dets[k, 3]
+            ymin += 0.2 * (ymax - ymin + 1)
+            score = dets[k, 4]
+            return_data.append([xmin, ymin, xmax, ymax, score])
+
+        return {"anime_face": tuple(return_data), "inference_time": end_time}
+
+
+if __name__ == "__main__":
+    model = SingleShotDetectorModel()
+    image = cv2.imread(
+        "../../assets/example_images/others/d29492bbe7604505a6f1b5394f62b393.png"
+    )
+    data = model.detect_anime_face(image)
+    for d in data:
+        cv2.rectangle(
+            image, (int(d[0]), int(d[1])), (int(d[2]), int(d[3])), (0, 255, 0), 2
+        )
+    print(data)
+    cv2.imshow("image", image)
+    cv2.waitKey(0)
+    cv2.destroyAllWindows()

models/base_model/__init__.py

@@ -0,0 +1,4 @@
+from .grad_cam import BaseModelGradCAM
+from .image_embeddings import BaseModelImageEmbeddings
+from .image_similarity import BaseModelImageSimilarity
+from .main_model import BaseModelMainModel

models/base_model/grad_cam.py

@@ -0,0 +1,126 @@
+import os
+import sys
+
+sys.path.append(os.path.join(os.path.dirname(__file__), "..", ".."))
+
+from abc import ABC, abstractmethod
+
+import numpy as np
+from PIL import Image
+from pytorch_grad_cam import GradCAM
+from pytorch_grad_cam.utils.image import show_cam_on_image
+from pytorch_grad_cam.utils.model_targets import ClassifierOutputTarget
+
+from utils import configs
+from utils.functional import (
+    check_data_type_variable,
+    get_device,
+    image_augmentations,
+    normalize_image_to_zero_one,
+    reshape_transform,
+)
+
+
+class BaseModelGradCAM(ABC):
+    def __init__(
+        self,
+        name_model: str,
+        freeze_model: bool,
+        pretrained_model: bool,
+        support_set_method: str,
+    ):
+        self.name_model = name_model
+        self.freeze_model = freeze_model
+        self.pretrained_model = pretrained_model
+        self.support_set_method = support_set_method
+        self.model = None
+        self.device = get_device()
+
+        self.check_arguments()
+
+    def check_arguments(self):
+        check_data_type_variable(self.name_model, str)
+        check_data_type_variable(self.freeze_model, bool)
+        check_data_type_variable(self.pretrained_model, bool)
+        check_data_type_variable(self.support_set_method, str)
+
+        old_name_model = self.name_model
+        if self.name_model == configs.CLIP_NAME_MODEL:
+            old_name_model = self.name_model
+            self.name_model = "clip"
+        if self.name_model not in tuple(configs.NAME_MODELS.keys()):
+            raise ValueError(f"Model {self.name_model} not supported")
+        if self.support_set_method not in configs.SUPPORT_SET_METHODS:
+            raise ValueError(
+                f"Support set method {self.support_set_method} not supported"
+            )
+        self.name_model = old_name_model
+
+    @abstractmethod
+    def init_model(self):
+        pass
+
+    def set_grad_cam(self):
+        if self.name_model == "resnet50":
+            self.target_layers = (self.model.model.layer4[-1],)
+        elif self.name_model == "vgg16":
+            self.target_layers = (self.model.model.features[-1],)
+        elif self.name_model == "inception_v4":
+            self.target_layers = (self.model.model.features[-1],)
+        elif self.name_model == "efficientnet_b4":
+            self.target_layers = (self.model.model.blocks[-1],)
+        elif self.name_model == "mobilenetv3_large_100":
+            self.target_layers = (self.model.model.blocks[-1],)
+        elif self.name_model == "densenet121":
+            self.target_layers = (self.model.model.features[-1],)
+        elif self.name_model == "vit_base_patch16_224_dino":
+            self.target_layers = (self.model.model.blocks[-1].norm1,)
+        elif self.name_model == "clip":
+            self.target_layers = (
+                self.model.vision_model.encoder.layers[-1].layer_norm1,
+            )
+        else:
+            self.target_layers = (self.model.model.features[-1],)
+
+        if self.name_model in ("vit_base_patch16_224_dino", "clip"):
+            self.gradcam = GradCAM(
+                model=self.model,
+                target_layers=self.target_layers,
+                reshape_transform=reshape_transform,
+                use_cuda=True if self.device.type == "cuda" else False,
+            )
+        else:
+            self.gradcam = GradCAM(
+                model=self.model,
+                target_layers=self.target_layers,
+                use_cuda=True if self.device.type == "cuda" else False,
+            )
+
+    def get_grad_cam(self, image: np.ndarray) -> np.ndarray:
+        image = np.array(
+            Image.fromarray(image).resize((configs.SIZE_IMAGES, configs.SIZE_IMAGES))
+        )
+        image_input = image_augmentations()(image=image)["image"]
+        image_input = image_input.unsqueeze(axis=0).to(self.device)
+        gradcam = self.gradcam(image_input)
+        gradcam = gradcam[0, :]
+        gradcam = show_cam_on_image(
+            normalize_image_to_zero_one(image), gradcam, use_rgb=True
+        )
+        return gradcam
+
+    def get_grad_cam_with_output_target(
+        self, image: np.ndarray, index_class: int
+    ) -> np.ndarray:
+        image = np.array(
+            Image.fromarray(image).resize((configs.SIZE_IMAGES, configs.SIZE_IMAGES))
+        )
+        image_input = image_augmentations()(image=image)["image"]
+        image_input = image_input.unsqueeze(axis=0).to(self.device)
+        targets = (ClassifierOutputTarget(index_class),)
+        gradcam = self.gradcam(image_input, targets=targets)
+        gradcam = gradcam[0, :]
+        gradcam = show_cam_on_image(
+            normalize_image_to_zero_one(image), gradcam, use_rgb=True
+        )
+        return gradcam

models/base_model/image_embeddings.py

@@ -0,0 +1,67 @@
+import os
+import sys
+
+sys.path.append(os.path.join(os.path.dirname(__file__), "..", ".."))
+
+import time
+from abc import ABC, abstractmethod
+
+import numpy as np
+import torch
+
+from utils import configs
+from utils.functional import check_data_type_variable, get_device, image_augmentations
+
+
+class BaseModelImageEmbeddings(ABC):
+    def __init__(
+        self,
+        name_model: str,
+        freeze_model: bool,
+        pretrained_model: bool,
+        support_set_method: str,
+    ):
+        self.name_model = name_model
+        self.freeze_model = freeze_model
+        self.pretrained_model = pretrained_model
+        self.support_set_method = support_set_method
+        self.model = None
+        self.device = get_device()
+
+        self.check_arguments()
+
+    def check_arguments(self):
+        check_data_type_variable(self.name_model, str)
+        check_data_type_variable(self.freeze_model, bool)
+        check_data_type_variable(self.pretrained_model, bool)
+        check_data_type_variable(self.support_set_method, str)
+
+        old_name_model = self.name_model
+        if self.name_model == configs.CLIP_NAME_MODEL:
+            old_name_model = self.name_model
+            self.name_model = "clip"
+        if self.name_model not in tuple(configs.NAME_MODELS.keys()):
+            raise ValueError(f"Model {self.name_model} not supported")
+        if self.support_set_method not in configs.SUPPORT_SET_METHODS:
+            raise ValueError(
+                f"Support set method {self.support_set_method} not supported"
+            )
+        self.name_model = old_name_model
+
+    @abstractmethod
+    def init_model(self):
+        pass
+
+    def get_embeddings(self, image: np.ndarray) -> dict:
+        image_input = image_augmentations()(image=image)["image"]
+        image_input = image_input.unsqueeze(axis=0).to(self.device)
+        with torch.no_grad():
+            start_time = time.perf_counter()
+            embeddings = self.model(image_input)
+            end_time = time.perf_counter() - start_time
+
+        embeddings = embeddings.detach().cpu().numpy()
+        return {
+            "embeddings": embeddings,
+            "inference_time": end_time,
+        }

models/base_model/image_similarity.py

@@ -0,0 +1,86 @@
+import os
+import sys
+
+sys.path.append(os.path.join(os.path.dirname(__file__), "..", ".."))
+
+import time
+from abc import ABC, abstractmethod
+
+import numpy as np
+import torch
+
+from utils import configs
+from utils.functional import (
+    check_data_type_variable,
+    euclidean_distance_normalized,
+    get_device,
+    image_augmentations,
+)
+
+
+class BaseModelImageSimilarity(ABC):
+    def __init__(
+        self,
+        name_model: str,
+        freeze_model: bool,
+        pretrained_model: bool,
+        support_set_method: str,
+    ):
+        self.name_model = name_model
+        self.freeze_model = freeze_model
+        self.pretrained_model = pretrained_model
+        self.support_set_method = support_set_method
+        self.model = None
+        self.device = get_device()
+
+        self.check_arguments()
+
+    def check_arguments(self):
+        check_data_type_variable(self.name_model, str)
+        check_data_type_variable(self.freeze_model, bool)
+        check_data_type_variable(self.pretrained_model, bool)
+        check_data_type_variable(self.support_set_method, str)
+
+        old_name_model = self.name_model
+        if self.name_model == configs.CLIP_NAME_MODEL:
+            old_name_model = self.name_model
+            self.name_model = "clip"
+        if self.name_model not in tuple(configs.NAME_MODELS.keys()):
+            raise ValueError(f"Model {self.name_model} not supported")
+        if self.support_set_method not in configs.SUPPORT_SET_METHODS:
+            raise ValueError(
+                f"Support set method {self.support_set_method} not supported"
+            )
+        self.name_model = old_name_model
+
+    @abstractmethod
+    def init_model(self):
+        pass
+
+    def get_similarity(self, image1: np.ndarray, image2: np.ndarray) -> dict:
+        image1_input = image_augmentations()(image=image1)["image"]
+        image2_input = image_augmentations()(image=image2)["image"]
+
+        image1_input = image1_input.unsqueeze(axis=0).to(self.device)
+        image2_input = image2_input.unsqueeze(axis=0).to(self.device)
+
+        with torch.no_grad():
+            start_time = time.perf_counter()
+            image1_input = self.model(image1_input)
+            image2_input = self.model(image2_input)
+            end_time = time.perf_counter() - start_time
+
+        image1_input = image1_input.detach().cpu().numpy()
+        image2_input = image2_input.detach().cpu().numpy()
+        similarity = euclidean_distance_normalized(image1_input, image2_input)
+        result_similarity = (
+            "same image"
+            if similarity
+            > configs.NAME_MODELS[self.name_model]["image_similarity_threshold"]
+            else "not same image"
+        )
+        return {
+            "similarity": similarity,
+            "result_similarity": result_similarity,
+            "inference_time": end_time,
+        }

models/base_model/main_model.py

@@ -0,0 +1,52 @@
+import os
+import sys
+
+sys.path.append(os.path.join(os.path.dirname(__file__), "..", ".."))
+
+from abc import ABC, abstractmethod
+
+from utils import configs
+from utils.functional import check_data_type_variable, get_device
+
+
+class BaseModelMainModel(ABC):
+    def __init__(
+        self,
+        name_model: str,
+        freeze_model: bool,
+        pretrained_model: bool,
+        support_set_method: str,
+    ):
+        self.name_model = name_model
+        self.freeze_model = freeze_model
+        self.pretrained_model = pretrained_model
+        self.support_set_method = support_set_method
+        self.device = get_device()
+
+        self.check_arguments()
+
+    def check_arguments(self):
+        check_data_type_variable(self.name_model, str)
+        check_data_type_variable(self.freeze_model, bool)
+        check_data_type_variable(self.pretrained_model, bool)
+        check_data_type_variable(self.support_set_method, str)
+
+        old_name_model = self.name_model
+        if self.name_model == configs.CLIP_NAME_MODEL:
+            old_name_model = self.name_model
+            self.name_model = "clip"
+        if self.name_model not in tuple(configs.NAME_MODELS.keys()):
+            raise ValueError(f"Model {self.name_model} not supported")
+        if self.support_set_method not in configs.SUPPORT_SET_METHODS:
+            raise ValueError(
+                f"Support set method {self.support_set_method} not supported"
+            )
+        self.name_model = old_name_model
+
+    @abstractmethod
+    def init_model(self):
+        pass
+
+    @abstractmethod
+    def predict(self):
+        pass

models/deep_learning/__init__.py

@@ -0,0 +1,4 @@
+from .deep_learning import DeepLearningModel
+from .grad_cam import DeepLearningGradCAM
+from .image_embeddings import ImageEmbeddings
+from .image_similarity import ImageSimilarity

models/deep_learning/backbone_model.py

@@ -0,0 +1,109 @@
+import os
+import sys
+
+sys.path.append(os.path.join(os.path.dirname(__file__), "..", ".."))
+
+import timm
+import torch
+import torch.nn as nn
+from transformers import CLIPModel as CLIPTransformersModel
+
+from utils import configs
+from utils.functional import check_data_type_variable, get_device
+
+
+class CLIPModel(nn.Module):
+    def __init__(
+        self,
+        model_clip_name: str,
+        freeze_model: bool,
+        pretrained_model: bool,
+        num_classes: int,
+    ):
+        super().__init__()
+        self.model_clip_name = model_clip_name
+        self.freeze_model = freeze_model
+        self.pretrained_model = pretrained_model
+        self.num_classes = num_classes
+        self.device = get_device()
+
+        self.check_arguments()
+        self.init_model()
+
+    def check_arguments(self):
+        check_data_type_variable(self.model_clip_name, str)
+        check_data_type_variable(self.freeze_model, bool)
+        check_data_type_variable(self.pretrained_model, bool)
+        check_data_type_variable(self.num_classes, int)
+
+        if self.model_clip_name != configs.CLIP_NAME_MODEL:
+            raise ValueError(
+                f"Model clip name must be {configs.CLIP_NAME_MODEL}, but it is {self.model_clip_name}"
+            )
+
+    def init_model(self):
+        clip_model = CLIPTransformersModel.from_pretrained(self.model_clip_name)
+        for layer in clip_model.children():
+            if hasattr(layer, "reset_parameters") and not self.pretrained_model:
+                layer.reset_parameters()
+        for param in clip_model.parameters():
+            param.required_grad = False if not self.freeze_model else True
+        self.vision_model = clip_model.vision_model.to(self.device)
+        self.visual_projection = clip_model.visual_projection.to(self.device).to(
+            self.device
+        )
+        self.classifier = nn.Linear(
+            512, 1 if self.num_classes in (1, 2) else self.num_classes
+        ).to(self.device)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = self.vision_model(x)
+        x = self.visual_projection(x.pooler_output)
+        x = self.classifier(x)
+        return x
+
+
+class TorchModel(nn.Module):
+    def __init__(
+        self,
+        name_model: str,
+        freeze_model: bool,
+        pretrained_model: bool,
+        num_classes: int,
+    ):
+        super().__init__()
+        self.name_model = name_model
+        self.freeze_model = freeze_model
+        self.pretrained_model = pretrained_model
+        self.num_classes = num_classes
+        self.device = get_device()
+
+        self.check_arguments()
+        self.init_model()
+
+    def check_arguments(self):
+        check_data_type_variable(self.name_model, str)
+        check_data_type_variable(self.freeze_model, bool)
+        check_data_type_variable(self.pretrained_model, bool)
+        check_data_type_variable(self.num_classes, int)
+
+        if self.name_model not in tuple(configs.NAME_MODELS.keys()):
+            raise ValueError(
+                f"Name model must be in {tuple(configs.NAME_MODELS.keys())}, but it is {self.name_model}"
+            )
+
+    def init_model(self):
+        self.model = timm.create_model(
+            self.name_model, pretrained=self.pretrained_model, num_classes=0
+        ).to(self.device)
+        for param in self.model.parameters():
+            param.required_grad = False if not self.freeze_model else True
+        self.classifier = nn.Linear(
+            self.model.num_features,
+            1 if self.num_classes in (1, 2) else self.num_classes,
+        ).to(self.device)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = self.model(x)
+        x = self.classifier(x)
+        return x

models/deep_learning/deep_learning.py

@@ -0,0 +1,90 @@
+import os
+import sys
+
+sys.path.append(os.path.join(os.path.dirname(__file__), "..", ".."))
+
+import time
+
+import numpy as np
+import torch
+from PIL import Image
+
+from models.base_model import BaseModelMainModel
+from utils import configs
+from utils.functional import image_augmentations, active_learning_uncertainty
+
+from .lightning_module import ImageClassificationLightningModule
+
+
+class DeepLearningModel(BaseModelMainModel):
+    def __init__(
+        self,
+        name_model: str,
+        freeze_model: bool,
+        pretrained_model: bool,
+        support_set_method: str,
+    ):
+        super().__init__(name_model, freeze_model, pretrained_model, support_set_method)
+        self.init_model()
+
+    def init_model(self):
+        self.model = ImageClassificationLightningModule.load_from_checkpoint(
+            os.path.join(
+                configs.WEIGHTS_PATH,
+                self.name_model,
+                self.support_set_method,
+                "best.ckpt",
+            ),
+            name_model=self.name_model,
+            freeze_model=self.freeze_model,
+            pretrained_model=self.pretrained_model,
+        )
+        self.model = self.model.model
+        for layer in self.model.children():
+            if hasattr(layer, "reset_parameters") and not self.pretrained_model:
+                layer.reset_parameters()
+        for param in self.model.parameters():
+            param.required_grad = False if not self.freeze_model else True
+        self.model.to(self.device)
+        self.model.eval()
+
+    def predict(self, image: np.ndarray) -> dict:
+        image_input = image_augmentations()(image=image)["image"]
+        image_input = image_input.unsqueeze(axis=0).to(self.device)
+        with torch.no_grad():
+            start_time = time.perf_counter()
+            result = self.model(image_input)
+            end_time = time.perf_counter() - start_time
+            result = torch.softmax(result, dim=1)
+            result = result.detach().cpu().numpy()
+        result_index = np.argmax(result)
+        confidence = result[0][result_index]
+        uncertainty_score = active_learning_uncertainty(result[0])
+        uncertainty_score = uncertainty_score if uncertainty_score > 0 else 0
+        if (
+            uncertainty_score
+            > configs.NAME_MODELS[self.name_model][
+                "deep_learning_out_of_distribution_threshold"
+            ][self.support_set_method]
+        ):
+            return {
+                "character": configs.CLASS_CHARACTERS[-1],
+                "confidence": confidence,
+                "inference_time": end_time,
+            }
+        return {
+            "character": configs.CLASS_CHARACTERS[result_index],
+            "confidence": confidence,
+            "inference_time": end_time,
+        }
+
+
+if __name__ == "__main__":
+    model = DeepLearningModel("resnet50", True, True, "1_shot")
+    image = np.array(
+        Image.open(
+            "../../assets/example_images/gon/306e5d35-b301-4299-8022-0c89dc0b7690.png"
+        ).convert("RGB")
+    )
+    result = model.predict(image)
+    print(result)

models/deep_learning/grad_cam.py

@@ -0,0 +1,59 @@
+import os
+import sys
+
+sys.path.append(os.path.join(os.path.dirname(__file__), "..", ".."))
+
+import matplotlib.pyplot as plt
+import numpy as np
+from PIL import Image
+
+from models.base_model import BaseModelGradCAM
+from utils import configs
+
+from .lightning_module import ImageClassificationLightningModule
+
+
+class DeepLearningGradCAM(BaseModelGradCAM):
+    def __init__(
+        self,
+        name_model: str,
+        freeze_model: bool,
+        pretrained_model: bool,
+        support_set_method: str,
+    ):
+        super().__init__(name_model, freeze_model, pretrained_model, support_set_method)
+        self.init_model()
+        self.set_grad_cam()
+
+    def init_model(self):
+        self.model = ImageClassificationLightningModule.load_from_checkpoint(
+            os.path.join(
+                configs.WEIGHTS_PATH,
+                self.name_model,
+                self.support_set_method,
+                "best.ckpt",
+            ),
+            name_model=self.name_model,
+            freeze_model=self.freeze_model,
+            pretrained_model=self.pretrained_model,
+        )
+        self.model = self.model.model
+        for layer in self.model.children():
+            if hasattr(layer, "reset_parameters") and not self.pretrained_model:
+                layer.reset_parameters()
+        for param in self.model.parameters():
+            param.required_grad = False if not self.freeze_model else True
+        self.model.to(self.device)
+        self.model.eval()
+
+
+if __name__ == "__main__":
+    model = DeepLearningGradCAM("resnet50", False, True, "5_shot")
+    image = np.array(
+        Image.open(
+            "../../assets/example_images/gon/306e5d35-b301-4299-8022-0c89dc0b7690.png"
+        ).convert("RGB")
+    )
+    gradcam = model.get_grad_cam(image)
+    plt.imshow(gradcam)
+    plt.show()

models/deep_learning/image_embeddings.py

@@ -0,0 +1,58 @@
+import os
+import sys
+
+sys.path.append(os.path.join(os.path.dirname(__file__), "..", ".."))
+
+import numpy as np
+import torch.nn as nn
+from PIL import Image
+
+from models.base_model import BaseModelImageEmbeddings
+from utils import configs
+
+from .lightning_module import ImageClassificationLightningModule
+
+
+class ImageEmbeddings(BaseModelImageEmbeddings):
+    def __init__(
+        self,
+        name_model: str,
+        freeze_model: bool,
+        pretrained_model: bool,
+        support_set_method: str,
+    ):
+        super().__init__(name_model, freeze_model, pretrained_model, support_set_method)
+        self.init_model()
+
+    def init_model(self):
+        self.model = ImageClassificationLightningModule.load_from_checkpoint(
+            os.path.join(
+                configs.WEIGHTS_PATH,
+                self.name_model,
+                self.support_set_method,
+                "best.ckpt",
+            ),
+            name_model=self.name_model,
+            freeze_model=self.freeze_model,
+            pretrained_model=self.pretrained_model,
+        )
+        self.model = self.model.model
+        self.model.classifier = nn.Identity()
+        for layer in self.model.children():
+            if hasattr(layer, "reset_parameters") and not self.pretrained_model:
+                layer.reset_parameters()
+        for param in self.model.parameters():
+            param.required_grad = False if not self.freeze_model else True
+        self.model.to(self.device)
+        self.model.eval()
+
+
+if __name__ == "__main__":
+    model = ImageEmbeddings("resnet50", True, True, "1_shot")
+    image = np.array(
+        Image.open(
+            "../../assets/example_images/gon/306e5d35-b301-4299-8022-0c89dc0b7690.png"
+        ).convert("RGB")
+    )
+    result = model.get_embeddings(image)
+    print(result)

models/deep_learning/image_similarity.py

@@ -0,0 +1,63 @@
+import os
+import sys
+
+sys.path.append(os.path.join(os.path.dirname(__file__), "..", ".."))
+
+import numpy as np
+import torch.nn as nn
+from PIL import Image
+
+from models.base_model import BaseModelImageSimilarity
+from utils import configs
+
+from .lightning_module import ImageClassificationLightningModule
+
+
+class ImageSimilarity(BaseModelImageSimilarity):
+    def __init__(
+        self,
+        name_model: str,
+        freeze_model: bool,
+        pretrained_model: bool,
+        support_set_method: str,
+    ):
+        super().__init__(name_model, freeze_model, pretrained_model, support_set_method)
+        self.init_model()
+
+    def init_model(self):
+        self.model = ImageClassificationLightningModule.load_from_checkpoint(
+            os.path.join(
+                configs.WEIGHTS_PATH,
+                self.name_model,
+                self.support_set_method,
+                "best.ckpt",
+            ),
+            name_model=self.name_model,
+            freeze_model=self.freeze_model,
+            pretrained_model=self.pretrained_model,
+        )
+        self.model = self.model.model
+        self.model.classifier = nn.Identity()
+        for layer in self.model.children():
+            if hasattr(layer, "reset_parameters") and not self.pretrained_model:
+                layer.reset_parameters()
+        for param in self.model.parameters():
+            param.required_grad = False if not self.freeze_model else True
+        self.model.to(self.device)
+        self.model.eval()
+
+
+if __name__ == "__main__":
+    model = ImageSimilarity("resnet50", True, True, "1_shot")
+    image1 = np.array(
+        Image.open(
+            "../../assets/example_images/gon/306e5d35-b301-4299-8022-0c89dc0b7690.png"
+        ).convert("RGB")
+    )
+    image2 = np.array(
+        Image.open(
+            "../../assets/example_images/gon/306e5d35-b301-4299-8022-0c89dc0b7690.png"
+        ).convert("RGB")
+    )
+    result = model.get_similarity(image1, image2)
+    print(result)