Add application files

.gitignore

@@ -0,0 +1,200 @@
+# Created by https://www.toptal.com/developers/gitignore/api/python,visualstudiocode,metals
+# Edit at https://www.toptal.com/developers/gitignore?templates=python,visualstudiocode,metals
+
+### Metals ###
+.metals/
+.bloop/
+project/**/metals.sbt
+
+### Python ###
+# 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/
+
+### Python Patch ###
+# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration
+poetry.toml
+
+# ruff
+.ruff_cache/
+
+# LSP config files
+pyrightconfig.json
+
+### VisualStudioCode ###
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+!.vscode/*.code-snippets
+
+# Local History for Visual Studio Code
+.history/
+
+# Built Visual Studio Code Extensions
+*.vsix
+
+### VisualStudioCode Patch ###
+# Ignore all local history of files
+.history
+.ionide
+
+# End of https://www.toptal.com/developers/gitignore/api/python,visualstudiocode,metals

Dockerfile

@@ -0,0 +1,24 @@
+FROM pytorch/pytorch:1.13.1-cuda11.6-cudnn8-devel
+
+# Arguments to build Docker Image using CUDA
+ARG USE_CUDA=0
+ARG TORCH_ARCH=
+
+ENV AM_I_DOCKER True
+ENV BUILD_WITH_CUDA "${USE_CUDA}"
+ENV TORCH_CUDA_ARCH_LIST "${TORCH_ARCH}"
+ENV CUDA_HOME /usr/local/cuda-11.6/
+
+RUN apt-get update && apt-get install --no-install-recommends wget ffmpeg=7:* \
+    libsm6=2:* libxext6=2:* git=1:* nano=2.* \
+    vim=2:* -y \
+    && apt-get clean && apt-get autoremove && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+COPY . /app
+
+RUN pip install -r requirements.txt
+
+# Expose the desired port (change it if needed)
+EXPOSE 7680
+CMD ["python3", "app.py"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Binh Le
+
+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.

app.py

@@ -0,0 +1,135 @@
+import os
+import cv2
+import gradio as gr
+from utils import get_upsampler, get_face_enhancer
+
+
+def inference(img, task, model_name, scale):
+    if scale > 4:
+        scale = 4  # avoid too large scale value
+    try:
+        img = cv2.imread(img, cv2.IMREAD_UNCHANGED)
+
+        h, w = img.shape[0:2]
+        if h > 3500 or w > 3500:
+            raise gr.Error(f"image too large: {w} * {h}")
+
+        if (h < 300 and w < 300) and model_name != "srcnn":
+            img = cv2.resize(img, (w * 2, h * 2), interpolation=cv2.INTER_LANCZOS4)
+            return cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+
+        if task == "face":
+            upsample_model_name = "realesr-general-x4v3"
+        else:
+            upsample_model_name = model_name
+        upsampler = get_upsampler(upsample_model_name)
+
+        if task == "face":
+            face_enhancer = get_face_enhancer(model_name, scale, upsampler)
+        else:
+            face_enhancer = None
+
+        try:
+            if face_enhancer is not None:
+                _, _, output = face_enhancer.enhance(
+                    img, has_aligned=False, only_center_face=False, paste_back=True
+                )
+            else:
+                output, _ = upsampler.enhance(img, outscale=scale)
+        except RuntimeError as error:
+            raise gr.Error(error)
+
+        output = cv2.cvtColor(output, cv2.COLOR_BGR2RGB)
+        return output
+    except Exception as error:
+        raise gr.Error(f"global exception: {error}")
+
+
+def on_task_change(task):
+    if task == "general":
+        return gr.Dropdown.update(
+            choices=[
+                "srcnn",
+                "RealESRGAN_x2plus",
+                "RealESRGAN_x4plus",
+                "RealESRNet_x4plus",
+                "realesr-general-x4v3",
+            ],
+            value="realesr-general-x4v3",
+        )
+    elif task == "face":
+        return gr.Dropdown.update(
+            choices=["GFPGANv1.3", "GFPGANv1.4", "RestoreFormer"], value="GFPGANv1.4"
+        )
+    elif task == "anime":
+        return gr.Dropdown.update(
+            choices=["srcnn", "RealESRGAN_x4plus_anime_6B", "realesr-animevideov3"],
+            value="RealESRGAN_x4plus_anime_6B",
+        )
+
+
+title = "ISR: General Image Super Resolution"
+description = r"""Gradio demo for <a href='https://github.com/TencentARC/GFPGAN' target='_blank'><b>GFPGAN: Towards Real-World Blind Face Restoration with Generative Facial Prior</b></a>.<br>
+It can be used to restore your **old photos** or improve **AI-generated faces**.<br>
+To use it, simply upload your image.<br>
+If GFPGAN is helpful, please help to ⭐ the <a href='https://github.com/TencentARC/GFPGAN' target='_blank'>Github Repo</a> and recommend it to your friends 😊
+"""
+article = r"""
+<center><img src='https://visitor-badge.glitch.me/badge?page_id=akhaliq_GFPGAN' alt='visitor badge'></center>
+"""
+
+with gr.Blocks(css="style.css", title=title) as demo:
+    with gr.Row(elem_classes=["container"]):
+        with gr.Column(scale=2):
+            input_image = gr.Image(type="filepath", label="Input")
+            # with gr.Row():
+            task = gr.Dropdown(
+                ["general", "face", "anime"],
+                type="value",
+                value="general",
+                label="task",
+            )
+            model_name = gr.Dropdown(
+                [
+                    "srcnn",
+                    "RealESRGAN_x2plus",
+                    "RealESRGAN_x4plus",
+                    "RealESRNet_x4plus",
+                    "realesr-general-x4v3",
+                ],
+                type="value",
+                value="realesr-general-x4v3",
+                label="model",
+            )
+            scale = gr.Slider(
+                minimum=1.5,
+                maximum=4,
+                value=2,
+                step=0.5,
+                label="Scale factor",
+                info="Scaling factor",
+            )
+            run_btn = gr.Button(value="Submit")
+
+        with gr.Column(scale=3):
+            output_image = gr.Image(type="numpy", label="Output image")
+
+    with gr.Row(elem_classes=["container"]):
+        gr.Examples(
+            [
+                ["examples/landscape.jpg", "general", 2],
+                ["examples/cat.jpg", "general", 2],
+                ["examples/cat2.jpg", "face", 2],
+                ["examples/AI-generate.png", "face", 2],
+                ["examples/Blake_Lively.png", "face", 2],
+                ["examples/old_image.jpg", "face", 2],
+                ["examples/naruto.png", "anime", 2],
+                ["examples/luffy2.jpg", "anime", 2],
+            ],
+            [input_image, task, scale],
+        )
+
+    run_btn.click(inference, [input_image, task, model_name, scale], [output_image])
+    task.change(on_task_change, [task], [model_name])
+
+demo.queue(concurrency_count=4).launch(debug=True, share=True)

config.py

@@ -0,0 +1,5 @@
+import os
+
+
+WEIGHT_DIR = "weights"
+ROOT_DIR = os.path.dirname(os.path.abspath(__file__))

requirements.txt

@@ -0,0 +1,20 @@
+accelerate
+gradio
+matplotlib
+numpy
+opencv_python
+Pillow
+requests
+torch
+torchvision
+transformers
+imutils
+argparse
+tqdm
+basicsr
+facexlib
+gfpgan
+realesrgan
+lmdb
+pyyaml
+yapf

srcnn.py

@@ -0,0 +1,94 @@
+from typing import Union
+import cv2
+import torch
+import numpy as np
+from torch import nn
+from torchvision import transforms as T
+
+
+class SRCNN(nn.Module):
+    def __init__(
+        self,
+        input_channels=3,
+        output_channels=3,
+        input_size=33,
+        label_size=21,
+        scale=2,
+        device=None,
+    ):
+        super().__init__()
+        self.input_size = input_size
+        self.label_size = label_size
+        self.pad = (self.input_size - self.label_size) // 2
+        self.scale = scale
+        self.model = nn.Sequential(
+            nn.Conv2d(input_channels, 64, 9),
+            nn.ReLU(),
+            nn.Conv2d(64, 32, 1),
+            nn.ReLU(),
+            nn.Conv2d(32, output_channels, 5),
+            nn.ReLU(),
+        )
+        self.transform = T.Compose(
+            [T.ToTensor()]  # Scale between [0, 1]
+        )
+
+        if device is None:
+            device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.device = device
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.model(x)
+
+    @torch.no_grad()
+    def pre_process(self, x: Union[np.ndarray, torch.Tensor]) -> torch.Tensor:
+        if torch.is_tensor(x):
+            return x / 255.0
+        else:
+            return self.transform(x)
+
+    @torch.no_grad()
+    def post_process(self, x: torch.Tensor) -> torch.Tensor:
+        return x.clip(0, 1) * 255.0
+
+    @torch.no_grad()
+    def enhance(self, image: np.ndarray, outscale: float = 2) -> np.ndarray:
+        (h, w) = image.shape[:2]
+        scale_w = int((w - w % self.label_size + self.input_size) * self.scale)
+        scale_h = int((h - h % self.label_size + self.input_size) * self.scale)
+        # resize the input image using bicubic interpolation
+        scaled = cv2.resize(image, (scale_w, scale_h), interpolation=cv2.INTER_CUBIC)
+        # Preprocessing
+        in_tensor = self.pre_process(scaled)  # (C, H, W)
+        out_tensor = torch.zeros_like(in_tensor)  # (C, H, W)
+
+        # slide a window from left-to-right and top-to-bottom
+        for y in range(0, scale_h - self.input_size + 1, self.label_size):
+            for x in range(0, scale_w - self.input_size + 1, self.label_size):
+                # crop ROI from our scaled image
+                crop = in_tensor[:, y : y + self.input_size, x : x + self.input_size]
+                # make a prediction on the crop and store it in our output
+                crop_inp = crop.unsqueeze(0).to(self.device)
+                pred = self.forward(crop_inp).cpu().squeeze()
+                out_tensor[
+                    :,
+                    y + self.pad : y + self.pad + self.label_size,
+                    x + self.pad : x + self.pad + self.label_size,
+                ] = pred
+
+        out_tensor = self.post_process(out_tensor)
+        output = out_tensor.permute(1, 2, 0).numpy()  # (C, H, W) to (H, W, C)
+        output = output[self.pad : -self.pad * 2, self.pad : -self.pad * 2]
+        output = np.clip(output, 0, 255).astype("uint8")
+
+        # Use openCV to upsample image if scaling factor different than 2
+        if outscale != 2:
+            interpolation = cv2.INTER_AREA if outscale < 2 else cv2.INTER_LANCZOS4
+            h, w = output.shape[0:2]
+            output = cv2.resize(
+                output,
+                (int(w * outscale / 2), int(h * outscale / 2)),
+                interpolation=interpolation,
+            )
+
+        return output, None

style.css

@@ -0,0 +1,11 @@
+.container {
+    max-width: 1368px;
+    margin-left: auto;
+    margin-right: auto;
+  }
+
+  #row-flex {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+  }

upsample.py

@@ -0,0 +1,144 @@
+import argparse
+import cv2
+import os
+
+from imutils import paths
+from tqdm import tqdm
+from config import *
+from utils import get_face_enhancer, get_upsampler
+
+
+def process(image_path, upsampler_name, face_enhancer_name=None, scale=2, device="cpu"):
+    if scale > 4:
+        scale = 4  # avoid too large scale value
+    try:
+        img = cv2.imread(image_path, cv2.IMREAD_UNCHANGED)
+
+        h, w = img.shape[0:2]
+        if h > 3500 or w > 3500:
+            output = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+            return output
+
+        if (h < 300 and w < 300) and upsampler_name != "srcnn":
+            img = cv2.resize(img, (w * 2, h * 2), interpolation=cv2.INTER_LANCZOS4)
+            return img
+
+        upsampler = get_upsampler(upsampler_name, device=device)
+
+        if face_enhancer_name:
+            face_enhancer = get_face_enhancer(
+                face_enhancer_name, scale, upsampler, device=device
+            )
+        else:
+            face_enhancer = None
+
+        try:
+            if face_enhancer is not None:
+                _, _, output = face_enhancer.enhance(
+                    img, has_aligned=False, only_center_face=False, paste_back=True
+                )
+            else:
+                output, _ = upsampler.enhance(img, outscale=scale)
+        except RuntimeError as error:
+            print(f"Runtime error: {error}")
+
+        return output
+    except Exception as error:
+        print(f"global exception: {error}")
+
+
+def main(args: argparse.Namespace) -> None:
+    device = args.device
+    scale = args.scale
+
+    upsampler_name = args.upsampler
+    face_enhancer_name = args.face_enhancer
+
+    if face_enhancer_name and ("srcnn" in upsampler_name or "anime" in upsampler_name):
+        print(
+            "Warnings: SRCNN and Anime model aren't compatible with face enhance. We will turn it off for you"
+        )
+        face_enhancer_name = None
+
+    os.makedirs(args.output, exist_ok=True)
+    if not os.path.exists(args.input):
+        raise ValueError("The input directory doesn't exist!")
+    elif not os.path.isdir(args.input):
+        image_paths = [args.input]
+    else:
+        image_paths = paths.list_images(args.input)
+
+    with tqdm(image_paths) as pbar:
+        for image_path in pbar:
+            filename = os.path.basename(image_path)
+            pbar.set_postfix_str(f"Processing {image_path}")
+            upsampled_image = process(
+                image_path=image_path,
+                upsampler_name=upsampler_name,
+                face_enhancer_name=face_enhancer_name,
+                scale=scale,
+                device=device,
+            )
+            if upsampled_image is not None:
+                save_path = os.path.join(args.output, filename)
+                cv2.imwrite(save_path, upsampled_image)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description=(
+            "Runs automatic detection and mask generation on an input image or directory of images"
+        )
+    )
+
+    parser.add_argument(
+        "--input",
+        "-i",
+        type=str,
+        required=True,
+        help="Path to either a single input image or folder of images.",
+    )
+
+    parser.add_argument(
+        "--output",
+        "-o",
+        type=str,
+        required=True,
+        help="Path to the output directory.",
+    )
+
+    parser.add_argument(
+        "--upsampler",
+        type=str,
+        default="realesr-general-x4v3",
+        choices=[
+            "srcnn",
+            "RealESRGAN_x2plus",
+            "RealESRGAN_x4plus",
+            "RealESRNet_x4plus",
+            "realesr-general-x4v3",
+            "RealESRGAN_x4plus_anime_6B",
+            "realesr-animevideov3",
+        ],
+        help="The type of upsampler model to load",
+    )
+
+    parser.add_argument(
+        "--face-enhancer",
+        type=str,
+        choices=["GFPGANv1.3", "GFPGANv1.4", "RestoreFormer"],
+        help="The type of face enhancer model to load",
+    )
+
+    parser.add_argument(
+        "--scale",
+        type=float,
+        default=2,
+        choices=[1.5, 2, 2.5, 3, 3.5, 4],
+        help="scaling factor",
+    )
+    parser.add_argument(
+        "--device", type=str, default="cuda", help="The device to run upsampling on."
+    )
+    args = parser.parse_args()
+    main(args)

utils.py

@@ -0,0 +1,165 @@
+import os
+import torch
+from basicsr.utils.download_util import load_file_from_url
+from basicsr.archs.rrdbnet_arch import RRDBNet
+from basicsr.archs.srvgg_arch import SRVGGNetCompact
+from gfpgan.utils import GFPGANer
+from realesrgan.utils import RealESRGANer
+
+from config import *
+from srcnn import SRCNN
+
+
+def get_upsampler(model_name, device=None):
+    if model_name == "RealESRGAN_x4plus":  # x4 RRDBNet model
+        model = RRDBNet(
+            num_in_ch=3,
+            num_out_ch=3,
+            num_feat=64,
+            num_block=23,
+            num_grow_ch=32,
+            scale=4,
+        )
+        netscale = 4
+        file_url = [
+            "https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth"
+        ]
+    elif model_name == "RealESRNet_x4plus":  # x4 RRDBNet model
+        model = RRDBNet(
+            num_in_ch=3,
+            num_out_ch=3,
+            num_feat=64,
+            num_block=23,
+            num_grow_ch=32,
+            scale=4,
+        )
+        netscale = 4
+        file_url = [
+            "https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.1/RealESRNet_x4plus.pth"
+        ]
+    elif model_name == "RealESRGAN_x4plus_anime_6B":  # x4 RRDBNet model with 6 blocks
+        model = RRDBNet(
+            num_in_ch=3, num_out_ch=3, num_feat=64, num_block=6, num_grow_ch=32, scale=4
+        )
+        netscale = 4
+        file_url = [
+            "https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.2.4/RealESRGAN_x4plus_anime_6B.pth"
+        ]
+    elif model_name == "RealESRGAN_x2plus":  # x2 RRDBNet model
+        model = RRDBNet(
+            num_in_ch=3,
+            num_out_ch=3,
+            num_feat=64,
+            num_block=23,
+            num_grow_ch=32,
+            scale=2,
+        )
+        netscale = 2
+        file_url = [
+            "https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.1/RealESRGAN_x2plus.pth"
+        ]
+    elif model_name == "realesr-animevideov3":  # x4 VGG-style model (XS size)
+        model = SRVGGNetCompact(
+            num_in_ch=3,
+            num_out_ch=3,
+            num_feat=64,
+            num_conv=16,
+            upscale=4,
+            act_type="prelu",
+        )
+        netscale = 4
+        file_url = [
+            "https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.5.0/realesr-animevideov3.pth"
+        ]
+    elif model_name == "realesr-general-x4v3":  # x4 VGG-style model (S size)
+        model = SRVGGNetCompact(
+            num_in_ch=3,
+            num_out_ch=3,
+            num_feat=64,
+            num_conv=32,
+            upscale=4,
+            act_type="prelu",
+        )
+        netscale = 4
+        file_url = [
+            "https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.5.0/realesr-general-wdn-x4v3.pth",
+            "https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.5.0/realesr-general-x4v3.pth",
+        ]
+    elif model_name == "srcnn":
+        model = SRCNN(device=device)
+        model_path = os.path.join(ROOT_DIR, WEIGHT_DIR, model_name + ".pth")
+        model.load_state_dict(torch.load(model_path, map_location=torch.device("cpu")))
+        if device:
+            model.to(device)
+        return model
+    else:
+        raise ValueError(f"Wrong model version {model_name}.")
+
+    model_path = os.path.join(ROOT_DIR, WEIGHT_DIR, model_name + ".pth")
+    if not os.path.exists(model_path):
+        print(f"Downloading weights for model {model_name}")
+
+        for url in file_url:
+            # model_path will be updated
+            model_path = load_file_from_url(
+                url=url,
+                model_dir=os.path.join(ROOT_DIR, WEIGHT_DIR),
+                progress=True,
+                file_name=None,
+            )
+
+    if model_name != "realesr-general-x4v3":
+        dni_weight = None
+    else:
+        dni_weight = [0.5, 0.5]
+        wdn_model_path = model_path.replace(
+            "realesr-general-x4v3", "realesr-general-wdn-x4v3"
+        )
+        model_path = [model_path, wdn_model_path]
+
+    half = "cuda" in str(device)
+
+    return RealESRGANer(
+        scale=netscale,
+        model_path=model_path,
+        dni_weight=dni_weight,
+        model=model,
+        half=half,
+        device=device,
+    )
+
+
+def get_face_enhancer(model_name, upscale=2, bg_upsampler=None, device=None):
+    if model_name == "GFPGANv1.3":
+        arch = "clean"
+        channel_multiplier = 2
+        file_url = "https://github.com/TencentARC/GFPGAN/releases/download/v1.3.0/GFPGANv1.3.pth"
+    elif model_name == "GFPGANv1.4":
+        arch = "clean"
+        channel_multiplier = 2
+        file_url = "https://github.com/TencentARC/GFPGAN/releases/download/v1.3.0/GFPGANv1.4.pth"
+    elif model_name == "RestoreFormer":
+        arch = "RestoreFormer"
+        channel_multiplier = 2
+        file_url = "https://github.com/TencentARC/GFPGAN/releases/download/v1.3.4/RestoreFormer.pth"
+    else:
+        raise ValueError(f"Wrong model version {model_name}.")
+
+    model_path = os.path.join(ROOT_DIR, WEIGHT_DIR, model_name + ".pth")
+    if not os.path.exists(model_path):
+        print(f"Downloading weights for model {model_name}")
+        model_path = load_file_from_url(
+            url=file_url,
+            model_dir=os.path.join(ROOT_DIR, WEIGHT_DIR),
+            progress=True,
+            file_name=None,
+        )
+
+    return GFPGANer(
+        model_path=model_path,
+        upscale=upscale,
+        arch=arch,
+        channel_multiplier=channel_multiplier,
+        bg_upsampler=bg_upsampler,
+        device=device,
+    )

weights/srcnn.pth

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