Add display of execution time for the upscale and face enhancer models.

app.py

@@ -7,6 +7,7 @@ import gradio as gr
 import torch
 import traceback
 import math
+import time
 from collections import defaultdict
 from facexlib.utils.misc import download_from_url
 from basicsr.utils.realesrganer import RealESRGANer
@@ -58,40 +59,49 @@ Simple yet effective, GPEN outperforms state-of-the-art methods, delivering real
                           "https://github.com/wzhouxiff/RestoreFormerPlusPlus", "The same as RestoreFormer++ but legacy model"],
 }
 upscale_models = {
-    # SRVGGNet
+    # SRVGGNet(Compact)
     "realesr-general-x4v3.pth": ["https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.5.0/realesr-general-x4v3.pth",
                                 "https://github.com/xinntao/Real-ESRGAN/releases/tag/v0.3.0", 
-"""add realesr-general-x4v3 and realesr-general-wdn-x4v3. They are very tiny models for general scenes, and they may more robust. But as they are tiny models, their performance may be limited."""],
+"""Compression Removal, General Upscaler, JPEG, Realistic, Research, Restoration
+xinntao: add realesr-general-x4v3 and realesr-general-wdn-x4v3. They are very tiny models for general scenes, and they may more robust. But as they are tiny models, their performance may be limited."""],
 
     "realesr-animevideov3.pth": ["https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.5.0/realesr-animevideov3.pth",
                                 "https://github.com/xinntao/Real-ESRGAN/releases/tag/v0.2.5.0", 
-"""update the RealESRGAN AnimeVideo-v3 model, which can achieve better results with a faster inference speed."""],
+"""Anime, Cartoon, Compression Removal, General Upscaler, JPEG, Realistic, Research, Restoration
+xinntao: update the RealESRGAN AnimeVideo-v3 model, which can achieve better results with a faster inference speed."""],
     
     "4xLSDIRCompact.pth": ["https://github.com/Phhofm/models/releases/download/4xLSDIRCompact/4xLSDIRCompact.pth",
                                 "https://github.com/Phhofm/models/releases/tag/4xLSDIRCompact", 
-"""Phhofm: Upscale small good quality photos to 4x their size. This is my first ever released self-trained sisr upscaling model."""],
+"""Realistic
+Phhofm: Upscale small good quality photos to 4x their size. This is my first ever released self-trained sisr upscaling model."""],
      
     "4xLSDIRCompactC.pth": ["https://github.com/Phhofm/models/releases/download/4xLSDIRCompactC/4xLSDIRCompactC.pth",
                                 "https://github.com/Phhofm/models/releases/tag/4xLSDIRCompactC", 
-"""Phhofm: 4x photo upscaler that handler jpg compression. Trying to extend my previous model to be able to handle compression (JPG 100-30) by manually altering the training dataset, since 4xLSDIRCompact cant handle compression. Use this instead of 4xLSDIRCompact if your photo has compression (like an image from the web)."""],
+"""Compression Removal, JPEG, Realistic, Restoration
+Phhofm: 4x photo upscaler that handler jpg compression. Trying to extend my previous model to be able to handle compression (JPG 100-30) by manually altering the training dataset, since 4xLSDIRCompact cant handle compression. Use this instead of 4xLSDIRCompact if your photo has compression (like an image from the web)."""],
          
     "4xLSDIRCompactR.pth": ["https://github.com/Phhofm/models/releases/download/4xLSDIRCompactC/4xLSDIRCompactR.pth",
                                 "https://github.com/Phhofm/models/releases/tag/4xLSDIRCompactC", 
-"""Phhofm: 4x photo uspcaler that handles jpg compression, noise and slight. Extending my last 4xLSDIRCompact model to Real-ESRGAN, meaning trained on synthetic data instead to handle more kinds of degradations, it should be able to handle compression, noise, and slight blur."""],
+"""Compression Removal, Realistic, Restoration
+Phhofm: 4x photo uspcaler that handles jpg compression, noise and slight. Extending my last 4xLSDIRCompact model to Real-ESRGAN, meaning trained on synthetic data instead to handle more kinds of degradations, it should be able to handle compression, noise, and slight blur."""],
 
     "4xLSDIRCompactN.pth": ["https://github.com/Phhofm/models/releases/download/4xLSDIRCompact3/4xLSDIRCompactC3.pth",
                                 "https://github.com/Phhofm/models/releases/tag/4xLSDIRCompact3", 
-"""Phhofm: Upscale good quality input photos to x4 their size. The original 4xLSDIRCompact a bit more trained, cannot handle degradation.
+"""Realistic
+Phhofm: Upscale good quality input photos to x4 their size. The original 4xLSDIRCompact a bit more trained, cannot handle degradation.
 I am releasing the Series 3 from my 4xLSDIRCompact models. In general my suggestion is, if you have good quality input images use 4xLSDIRCompactN3, otherwise try 4xLSDIRCompactC3 which will be able to handle jpg compression and a bit of blur, or then 4xLSDIRCompactCR3, which is an interpolation between C3 and R3 to be able to handle a bit of noise additionally."""],
 
     "4xLSDIRCompactC3.pth": ["https://github.com/Phhofm/models/releases/download/4xLSDIRCompact3/4xLSDIRCompactC3.pth",
                                 "https://github.com/Phhofm/models/releases/tag/4xLSDIRCompact3", 
-"""Phhofm: Upscale compressed photos to x4 their size. Able to handle JPG compression (30-100).
+"""Compression Removal, 
+JPEG, Realistic, Restoration
+Phhofm: Upscale compressed photos to x4 their size. Able to handle JPG compression (30-100).
 I am releasing the Series 3 from my 4xLSDIRCompact models. In general my suggestion is, if you have good quality input images use 4xLSDIRCompactN3, otherwise try 4xLSDIRCompactC3 which will be able to handle jpg compression and a bit of blur, or then 4xLSDIRCompactCR3, which is an interpolation between C3 and R3 to be able to handle a bit of noise additionally."""],
 
     "4xLSDIRCompactR3.pth": ["https://github.com/Phhofm/models/releases/download/4xLSDIRCompact3/4xLSDIRCompactR3.pth",
                                 "https://github.com/Phhofm/models/releases/tag/4xLSDIRCompact3", 
-"""Phhofm: Upscale (degraded) photos to x4 their size. Trained on synthetic data, meant to handle more degradations.
+"""Realistic, Restoration
+Phhofm: Upscale (degraded) photos to x4 their size. Trained on synthetic data, meant to handle more degradations.
 I am releasing the Series 3 from my 4xLSDIRCompact models. In general my suggestion is, if you have good quality input images use 4xLSDIRCompactN3, otherwise try 4xLSDIRCompactC3 which will be able to handle jpg compression and a bit of blur, or then 4xLSDIRCompactCR3, which is an interpolation between C3 and R3 to be able to handle a bit of noise additionally."""],
 
     "4xLSDIRCompactCR3.pth": ["https://github.com/Phhofm/models/releases/download/4xLSDIRCompact3/4xLSDIRCompactCR3.pth",
@@ -100,125 +110,173 @@ I am releasing the Series 3 from my 4xLSDIRCompact models. In general my suggest
 
     "2xParimgCompact.pth": ["https://github.com/Phhofm/models/releases/download/2xParimgCompact/2xParimgCompact.pth",
                                 "https://github.com/Phhofm/models/releases/tag/2xParimgCompact", 
-"""Phhofm: A 2x photo upscaling compact model based on Microsoft's ImagePairs. This was one of the earliest models I started training and finished it now for release. As can be seen in the examples, this model will affect colors."""],
+"""Realistic
+Phhofm: A 2x photo upscaling compact model based on Microsoft's ImagePairs. This was one of the earliest models I started training and finished it now for release. As can be seen in the examples, this model will affect colors."""],
 
     "1xExposureCorrection_compact.pth": ["https://github.com/Phhofm/models/releases/download/1xExposureCorrection_compact/1xExposureCorrection_compact.pth",
-                                "https://github.com/Phhofm/models/releases/tag/1xExposureCorrection_compact", 
-"""Phhofm: This model is meant as an experiment to see if compact can be used to train on photos to exposure correct those using the pixel, perceptual, color, color and ldl losses. There is no brightness loss. Still it seems to kinda work."""],
+                                         "https://github.com/Phhofm/models/releases/tag/1xExposureCorrection_compact", 
+"""Restoration
+Phhofm: This model is meant as an experiment to see if compact can be used to train on photos to exposure correct those using the pixel, perceptual, color, color and ldl losses. There is no brightness loss. Still it seems to kinda work."""],
     
     "1xUnderExposureCorrection_compact.pth": ["https://github.com/Phhofm/models/releases/download/1xExposureCorrection_compact/1xUnderExposureCorrection_compact.pth",
-                                "https://github.com/Phhofm/models/releases/tag/1xExposureCorrection_compact", 
-"""Phhofm: This model is meant as an experiment to see if compact can be used to train on underexposed images to exposure correct those using the pixel, perceptual, color, color and ldl losses. There is no brightness loss. Still it seems to kinda work."""],
+                                              "https://github.com/Phhofm/models/releases/tag/1xExposureCorrection_compact", 
+"""Restoration
+Phhofm: This model is meant as an experiment to see if compact can be used to train on underexposed images to exposure correct those using the pixel, perceptual, color, color and ldl losses. There is no brightness loss. Still it seems to kinda work."""],
     
     "1xOverExposureCorrection_compact.pth": ["https://github.com/Phhofm/models/releases/download/1xExposureCorrection_compact/1xOverExposureCorrection_compact.pth",
-                                "https://github.com/Phhofm/models/releases/tag/1xExposureCorrection_compact", 
-"""Phhofm: This model is meant as an experiment to see if compact can be used to train on overexposed images to exposure correct those using the pixel, perceptual, color, color and ldl losses. There is no brightness loss. Still it seems to kinda work."""],
+                                             "https://github.com/Phhofm/models/releases/tag/1xExposureCorrection_compact", 
+"""Restoration
+Phhofm: This model is meant as an experiment to see if compact can be used to train on overexposed images to exposure correct those using the pixel, perceptual, color, color and ldl losses. There is no brightness loss. Still it seems to kinda work."""],
+
+    "2x-sudo-UltraCompact.pth": ["https://objectstorage.us-phoenix-1.oraclecloud.com/n/ax6ygfvpvzka/b/open-modeldb-files/o/2x-sudo-UltraCompact.pth",
+                                "https://openmodeldb.info/models/2x-sudo-UltraCompact", 
+"""Anime, Cartoon, Restoration
+sudo: Realtime animation restauration and doing stuff like deblur and compression artefact removal.
+My first attempt to make a REALTIME 2x upscaling model while also applying teacher student learning.
+(Teacher: RealESRGANv2-animevideo-xsx2.pth)"""],
+
+    "2x_AnimeJaNai_HD_V3_SuperUltraCompact.pth": ["https://github.com/the-database/mpv-upscale-2x_animejanai/releases/download/3.0.0/2x_AnimeJaNai_HD_V3_ModelsOnly.zip",
+                                                  "https://openmodeldb.info/models/2x-AnimeJaNai-HD-V3-SuperUltraCompact", 
+"""Anime, Compression Removal, Restoration
+the-database: Real-time 2x Real-ESRGAN Compact/UltraCompact/SuperUltraCompact models designed for upscaling 1080p anime to 4K.
+The aim of these models is to address scaling, blur, oversharpening, and compression artifacts while upscaling to deliver a result that appears as if the anime was originally mastered in 4K resolution."""],
+
+    "2x_AnimeJaNai_HD_V3_UltraCompact.pth": ["https://github.com/the-database/mpv-upscale-2x_animejanai/releases/download/3.0.0/2x_AnimeJaNai_HD_V3_ModelsOnly.zip",
+                                             "https://openmodeldb.info/models/2x-AnimeJaNai-HD-V3-UltraCompact", 
+"""Anime, Compression Removal, Restoration
+the-database: Real-time 2x Real-ESRGAN Compact/UltraCompact/SuperUltraCompact models designed for upscaling 1080p anime to 4K.
+The aim of these models is to address scaling, blur, oversharpening, and compression artifacts while upscaling to deliver a result that appears as if the anime was originally mastered in 4K resolution."""],
+
+    "2x_AnimeJaNai_HD_V3_Compact.pth": ["https://github.com/the-database/mpv-upscale-2x_animejanai/releases/download/3.0.0/2x_AnimeJaNai_HD_V3_ModelsOnly.zip",
+                                                  "https://openmodeldb.info/models/2x-AnimeJaNai-HD-V3-Compact", 
+"""Anime, Compression Removal, Restoration
+the-database: Real-time 2x Real-ESRGAN Compact/UltraCompact/SuperUltraCompact models designed for upscaling 1080p anime to 4K.
+The aim of these models is to address scaling, blur, oversharpening, and compression artifacts while upscaling to deliver a result that appears as if the anime was originally mastered in 4K resolution."""],
 
     # RRDBNet
     "RealESRGAN_x4plus_anime_6B.pth": ["https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.2.4/RealESRGAN_x4plus_anime_6B.pth",
                                       "https://github.com/xinntao/Real-ESRGAN/releases/tag/v0.2.2.4", 
-"""We add RealESRGAN_x4plus_anime_6B.pth, which is optimized for anime images with much smaller model size. More details and comparisons with waifu2x are in anime_model.md"""],
+"""Anime, Cartoon, Compression Removal, General Upscaler, JPEG, Realistic, Research, Restoration
+xinntao: We add RealESRGAN_x4plus_anime_6B.pth, which is optimized for anime images with much smaller model size. More details and comparisons with waifu2x are in anime_model.md"""],
 
     "RealESRGAN_x2plus.pth"         : ["https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.1/RealESRGAN_x2plus.pth",
                                       "https://github.com/xinntao/Real-ESRGAN/releases/tag/v0.2.1", 
-"""Add RealESRGAN_x2plus.pth model"""],
+"""Compression Removal, General Upscaler, JPEG, Realistic, Research, Restoration
+xinntao: Add RealESRGAN_x2plus.pth model"""],
 
     "RealESRNet_x4plus.pth"         : ["https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.1/RealESRNet_x4plus.pth",
                                       "https://github.com/xinntao/Real-ESRGAN/releases/tag/v0.1.1", 
-"""This release is mainly for storing pre-trained models and executable files."""],
+"""Compression Removal, General Upscaler, JPEG, Realistic, Research, Restoration
+xinntao: This release is mainly for storing pre-trained models and executable files."""],
 
     "RealESRGAN_x4plus.pth"         : ["https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth",
                                       "https://github.com/xinntao/Real-ESRGAN/releases/tag/v0.1.0", 
-"""This release is mainly for storing pre-trained models and executable files."""],
+"""Compression Removal, General Upscaler, JPEG, Realistic, Research, Restoration
+xinntao: This release is mainly for storing pre-trained models and executable files."""],
 
     # ESRGAN(oldRRDB)
     "4x-AnimeSharp.pth": ["https://huggingface.co/utnah/esrgan/resolve/main/4x-AnimeSharp.pth?download=true",
                          "https://openmodeldb.info/models/4x-AnimeSharp", 
-"""Interpolation between 4x-UltraSharp and 4x-TextSharp-v0.5. Works amazingly on anime. It also upscales text, but it's far better with anime content."""],
+"""Anime, Cartoon, Text
+Kim2091: Interpolation between 4x-UltraSharp and 4x-TextSharp-v0.5. Works amazingly on anime. It also upscales text, but it's far better with anime content."""],
 
     "4x_IllustrationJaNai_V1_ESRGAN_135k.pth": ["https://drive.google.com/uc?export=download&confirm=1&id=1qpioSqBkB_IkSBhEAewSSNFt6qgkBimP",
                                                "https://openmodeldb.info/models/4x-IllustrationJaNai-V1-DAT2", 
-"""Purpose: Illustrations, digital art, manga covers
-Model for color images including manga covers and color illustrations, digital art, visual novel art, artbooks, and more. 
+"""Anime, Cartoon, Compression Removal, Dehalftone, General Upscaler, JPEG, Manga, Restoration
+the-database: Model for color images including manga covers and color illustrations, digital art, visual novel art, artbooks, and more. 
 DAT2 version is the highest quality version but also the slowest. See the ESRGAN version for faster performance."""],
 
     "2x-sudo-RealESRGAN.pth": ["https://objectstorage.us-phoenix-1.oraclecloud.com/n/ax6ygfvpvzka/b/open-modeldb-files/o/2x-sudo-RealESRGAN.pth",
                                "https://openmodeldb.info/models/2x-sudo-RealESRGAN", 
-"""Pretrained: Pretrained_Model_G: RealESRGAN_x4plus_anime_6B.pth / RealESRGAN_x4plus_anime_6B.pth (sudo_RealESRGAN2x_3.332.758_G.pth)
-Tried to make the best 2x model there is for drawings. I think i archived that. 
+"""Anime, Cartoon
+sudo: Tried to make the best 2x model there is for drawings. I think i archived that. 
 And yes, it is nearly 3.8 million iterations (probably a record nobody will beat here), took me nearly half a year to train. 
 It can happen that in one edge is a noisy pattern in edges. You can use padding/crop for that. 
-I aimed for perceptual quality without zooming in like 400%. Since RealESRGAN is 4x, I downscaled these images with bicubic."""],
+I aimed for perceptual quality without zooming in like 400%. Since RealESRGAN is 4x, I downscaled these images with bicubic.
+Pretrained: Pretrained_Model_G: RealESRGAN_x4plus_anime_6B.pth / RealESRGAN_x4plus_anime_6B.pth (sudo_RealESRGAN2x_3.332.758_G.pth)"""],
     
     "2x-sudo-RealESRGAN-Dropout.pth": ["https://objectstorage.us-phoenix-1.oraclecloud.com/n/ax6ygfvpvzka/b/open-modeldb-files/o/2x-sudo-RealESRGAN-Dropout.pth",
                                "https://openmodeldb.info/models/2x-sudo-RealESRGAN-Dropout", 
-"""Pretrained: Pretrained_Model_G: RealESRGAN_x4plus_anime_6B.pth / RealESRGAN_x4plus_anime_6B.pth (sudo_RealESRGAN2x_3.332.758_G.pth)
-Tried to make the best 2x model there is for drawings. I think i archived that. 
+"""Anime, Cartoon
+sudo: Tried to make the best 2x model there is for drawings. I think i archived that. 
 And yes, it is nearly 3.8 million iterations (probably a record nobody will beat here), took me nearly half a year to train. 
 It can happen that in one edge is a noisy pattern in edges. You can use padding/crop for that. 
-I aimed for perceptual quality without zooming in like 400%. Since RealESRGAN is 4x, I downscaled these images with bicubic."""],
+I aimed for perceptual quality without zooming in like 400%. Since RealESRGAN is 4x, I downscaled these images with bicubic.
+Pretrained: Pretrained_Model_G: RealESRGAN_x4plus_anime_6B.pth / RealESRGAN_x4plus_anime_6B.pth (sudo_RealESRGAN2x_3.332.758_G.pth)"""],
 
     "4xNomos2_otf_esrgan.pth": ["https://github.com/Phhofm/models/releases/download/4xNomos2_otf_esrgan/4xNomos2_otf_esrgan.pth",
                                "https://github.com/Phhofm/models/releases/tag/4xNomos2_otf_esrgan", 
-"""Phhofm: Restoration, 4x ESRGAN model for photography, trained using the Real-ESRGAN otf degradation pipeline."""],
+"""Compression Removal, JPEG, Realistic, Restoration
+Phhofm: Restoration, 4x ESRGAN model for photography, trained using the Real-ESRGAN otf degradation pipeline."""],
 
     "4xNomosWebPhoto_esrgan.pth": ["https://github.com/Phhofm/models/releases/download/4xNomosWebPhoto_esrgan/4xNomosWebPhoto_esrgan.pth",
                                "https://github.com/Phhofm/models/releases/tag/4xNomosWebPhoto_esrgan", 
-"""Phhofm: Restoration, 4x ESRGAN model for photography, trained with realistic noise, lens blur, jpg and webp re-compression.
+"""Realistic, Restoration
+Phhofm: Restoration, 4x ESRGAN model for photography, trained with realistic noise, lens blur, jpg and webp re-compression.
 ESRGAN version of 4xNomosWebPhoto_RealPLKSR, trained on the same dataset and in the same way."""],
 
     # DATNet
     "4xNomos8kDAT.pth"                     : ["https://github.com/Phhofm/models/releases/download/4xNomos8kDAT/4xNomos8kDAT.pth",
                                              "https://openmodeldb.info/models/4x-Nomos8kDAT", 
-"""Phhofm: A 4x photo upscaler with otf jpg compression, blur and resize, trained on musl's Nomos8k_sfw dataset for realisic sr, this time based on the DAT arch, as a finetune on the official 4x DAT model."""],
+"""Anime, Compression Removal, General Upscaler, JPEG, Realistic, Restoration
+Phhofm: A 4x photo upscaler with otf jpg compression, blur and resize, trained on musl's Nomos8k_sfw dataset for realisic sr, this time based on the DAT arch, as a finetune on the official 4x DAT model."""],
 
     "4x-DWTP-DS-dat2-v3.pth"               : ["https://objectstorage.us-phoenix-1.oraclecloud.com/n/ax6ygfvpvzka/b/open-modeldb-files/o/4x-DWTP-DS-dat2-v3.pth",
                                              "https://openmodeldb.info/models/4x-DWTP-DS-dat2-v3", 
-"""DAT descreenton model, designed to reduce discrepancies on tiles due to too much loss of the first version, while getting rid of the removal of paper texture"""],
+"""Dehalftone, Restoration
+umzi.x.dead: DAT descreenton model, designed to reduce discrepancies on tiles due to too much loss of the first version, while getting rid of the removal of paper texture"""],
 
     "4xBHI_dat2_real.pth"                  : ["https://github.com/Phhofm/models/releases/download/4xBHI_dat2_real/4xBHI_dat2_real.pth",
                                              "https://github.com/Phhofm/models/releases/tag/4xBHI_dat2_real", 
-"""Phhofm: 4x dat2 upscaling model for web and realistic images. It handles realistic noise, some realistic blur, and webp and jpg (re)compression. Trained on my BHI dataset (390'035 training tiles) with degraded LR subset."""],
+"""Compression Removal, JPEG, Realistic
+Phhofm: 4x dat2 upscaling model for web and realistic images. It handles realistic noise, some realistic blur, and webp and jpg (re)compression. Trained on my BHI dataset (390'035 training tiles) with degraded LR subset."""],
 
     "4xBHI_dat2_otf.pth"                   : ["https://github.com/Phhofm/models/releases/download/4xBHI_dat2_otf/4xBHI_dat2_otf.pth",
                                              "https://github.com/Phhofm/models/releases/tag/4xBHI_dat2_otf", 
-"""Phhofm: 4x dat2 upscaling model, trained with the real-esrgan otf pipeline on my bhi dataset. Handles noise and compression."""],
+"""Compression Removal, JPEG
+Phhofm: 4x dat2 upscaling model, trained with the real-esrgan otf pipeline on my bhi dataset. Handles noise and compression."""],
 
     "4xBHI_dat2_multiblur.pth"             : ["https://github.com/Phhofm/models/releases/download/4xBHI_dat2_multiblurjpg/4xBHI_dat2_multiblur.pth",
                                              "https://github.com/Phhofm/models/releases/tag/4xBHI_dat2_multiblurjpg", 
-"""Phhofm: 4x dat2 upscaling model, trained with down_up,linear, cubic_mitchell, lanczos, gauss and box scaling algos, some average, gaussian and anisotropic blurs and jpg compression. Trained on my BHI sisr dataset."""],
+"""Phhofm: the 4xBHI_dat2_multiblur checkpoint (trained to 250000 iters), which cannot handle compression but might give just slightly better output on non-degraded input."""],
 
     "4xBHI_dat2_multiblurjpg.pth"          : ["https://github.com/Phhofm/models/releases/download/4xBHI_dat2_multiblurjpg/4xBHI_dat2_multiblurjpg.pth",
                                              "https://github.com/Phhofm/models/releases/tag/4xBHI_dat2_multiblurjpg", 
-"""Phhofm: 4x dat2 upscaling model, trained with down_up,linear, cubic_mitchell, lanczos, gauss and box scaling algos, some average, gaussian and anisotropic blurs and jpg compression. Trained on my BHI sisr dataset."""],
+"""Compression Removal, JPEG
+Phhofm: 4x dat2 upscaling model, trained with down_up,linear, cubic_mitchell, lanczos, gauss and box scaling algos, some average, gaussian and anisotropic blurs and jpg compression. Trained on my BHI sisr dataset."""],
 
     "4x_IllustrationJaNai_V1_DAT2_190k.pth": ["https://drive.google.com/uc?export=download&confirm=1&id=1qpioSqBkB_IkSBhEAewSSNFt6qgkBimP",
                                              "https://openmodeldb.info/models/4x-IllustrationJaNai-V1-DAT2", 
-"""Purpose: Illustrations, digital art, manga covers
-Model for color images including manga covers and color illustrations, digital art, visual novel art, artbooks, and more. 
+"""Anime, Cartoon, Compression Removal, Dehalftone, General Upscaler, JPEG, Manga, Restoration
+the-database: Model for color images including manga covers and color illustrations, digital art, visual novel art, artbooks, and more. 
 DAT2 version is the highest quality version but also the slowest. See the ESRGAN version for faster performance."""],
 
     "4x-PBRify_UpscalerDAT2_V1.pth": ["https://github.com/Kim2091/Kim2091-Models/releases/download/4x-PBRify_UpscalerDAT2_V1/4x-PBRify_UpscalerDAT2_V1.pth",
                                       "https://github.com/Kim2091/Kim2091-Models/releases/tag/4x-PBRify_UpscalerDAT2_V1", 
-"""Kim2091: Yet another model in the PBRify_Remix series. This is a new upscaler to replace the previous 4x-PBRify_UpscalerSIR-M_V2 model.
+"""Compression Removal, DDS, Game Textures, Restoration
+Kim2091: Yet another model in the PBRify_Remix series. This is a new upscaler to replace the previous 4x-PBRify_UpscalerSIR-M_V2 model.
 This model far exceeds the quality of the previous, with far more natural detail generation and better reconstruction of lines and edges."""],
 
     "4xBHI_dat2_otf_nn.pth": ["https://github.com/Phhofm/models/releases/download/4xBHI_dat2_otf_nn/4xBHI_dat2_otf_nn.pth",
                               "https://github.com/Phhofm/models/releases/tag/4xBHI_dat2_otf_nn", 
-"""Phhofm: 4x dat2 upscaling model, trained with the real-esrgan otf pipeline but without noise, on my bhi dataset. Handles resizes, and jpg compression."""],
+"""Compression Removal, JPEG
+Phhofm: 4x dat2 upscaling model, trained with the real-esrgan otf pipeline but without noise, on my bhi dataset. Handles resizes, and jpg compression."""],
 
     # HAT
     "4xNomos8kSCHAT-L.pth"  : ["https://github.com/Phhofm/models/releases/download/4xNomos8kSCHAT/4xNomos8kSCHAT-L.pth",
                               "https://openmodeldb.info/models/4x-Nomos8kSCHAT-L", 
-"""Phhofm: 4x photo upscaler with otf jpg compression and blur, trained on musl's Nomos8k_sfw dataset for realisic sr. Since this is a big model, upscaling might take a while."""],
+"""Anime, Compression Removal, General Upscaler, JPEG, Realistic, Restoration
+Phhofm: 4x photo upscaler with otf jpg compression and blur, trained on musl's Nomos8k_sfw dataset for realisic sr. Since this is a big model, upscaling might take a while."""],
 
     "4xNomos8kSCHAT-S.pth"  : ["https://github.com/Phhofm/models/releases/download/4xNomos8kSCHAT/4xNomos8kSCHAT-S.pth",
                               "https://openmodeldb.info/models/4x-Nomos8kSCHAT-S", 
-"""Phhofm: 4x photo upscaler with otf jpg compression and blur, trained on musl's Nomos8k_sfw dataset for realisic sr. HAT-S version/model."""],
+"""Anime, Compression Removal, General Upscaler, JPEG, Realistic, Restoration
+Phhofm: 4x photo upscaler with otf jpg compression and blur, trained on musl's Nomos8k_sfw dataset for realisic sr. HAT-S version/model."""],
 
     "4xNomos8kHAT-L_otf.pth": ["https://github.com/Phhofm/models/releases/download/4xNomos8kHAT-L_otf/4xNomos8kHAT-L_otf.pth",
                               "https://openmodeldb.info/models/4x-Nomos8kHAT-L-otf", 
-"""Phhofm: 4x photo upscaler trained with otf"""],
+"""Faces, General Upscaler, Realistic, Restoration
+Phhofm: 4x photo upscaler trained with otf, handles some jpg compression, some blur and some noise."""],
 
     "4xBHI_small_hat-l.pth": ["https://github.com/Phhofm/models/releases/download/4xBHI_small_hat-l/4xBHI_small_hat-l.pth",
                               "https://github.com/Phhofm/models/releases/tag/4xBHI_small_hat-l", 
@@ -230,116 +288,134 @@ also included in this release, which might still feel soft if you are used to sh
     # RealPLKSR_dysample
     "4xHFA2k_ludvae_realplksr_dysample.pth": ["https://github.com/Phhofm/models/releases/download/4xHFA2k_ludvae_realplksr_dysample/4xHFA2k_ludvae_realplksr_dysample.pth",
                                              "https://openmodeldb.info/models/4x-HFA2k-ludvae-realplksr-dysample", 
-"""Phhofm: A Dysample RealPLKSR 4x upscaling model for anime single-image resolution."""],
+"""Anime, Compression Removal, Restoration
+Phhofm: A Dysample RealPLKSR 4x upscaling model for anime single-image resolution."""],
 
     "4xArtFaces_realplksr_dysample.pth"    : ["https://github.com/Phhofm/models/releases/download/4xArtFaces_realplksr_dysample/4xArtFaces_realplksr_dysample.pth",
                                              "https://openmodeldb.info/models/4x-ArtFaces-realplksr-dysample", 
-"""Phhofm: A Dysample RealPLKSR 4x upscaling model for art / painted faces."""],
+"""ArtFaces
+Phhofm: A Dysample RealPLKSR 4x upscaling model for art / painted faces."""],
 
     "4x-PBRify_RPLKSRd_V3.pth"             : ["https://github.com/Kim2091/Kim2091-Models/releases/download/4x-PBRify_RPLKSRd_V3/4x-PBRify_RPLKSRd_V3.pth",
                                              "https://github.com/Kim2091/Kim2091-Models/releases/tag/4x-PBRify_RPLKSRd_V3", 
-"""Kim2091: This update brings a new upscaling model, 4x-PBRify_RPLKSRd_V3. This model is roughly 8x faster than the current DAT2 model, while being higher quality. 
+"""Compression Removal, DDS, Debanding, Dedither, Dehalo, Game Textures, Restoration
+Kim2091: This update brings a new upscaling model, 4x-PBRify_RPLKSRd_V3. This model is roughly 8x faster than the current DAT2 model, while being higher quality. 
 It produces far more natural detail, resolves lines and edges more smoothly, and cleans up compression artifacts better.
 As a result of those improvements, PBR is also much improved. It tends to be clearer with less defined artifacts."""],
 
     "4xNomos2_realplksr_dysample.pth"      : ["https://github.com/Phhofm/models/releases/download/4xNomos2_realplksr_dysample/4xNomos2_realplksr_dysample.pth",
                                              "https://openmodeldb.info/models/4x-Nomos2-realplksr-dysample", 
-"""Phhofm: A Dysample RealPLKSR 4x upscaling model that was trained with / handles jpg compression down to 70 on the Nomosv2 dataset, preserves DoF.
+"""Compression Removal, JPEG, Realistic, Restoration
+Phhofm: A Dysample RealPLKSR 4x upscaling model that was trained with / handles jpg compression down to 70 on the Nomosv2 dataset, preserves DoF.
 This model affects / saturate colors, which can be counteracted a bit by using wavelet color fix, as used in these examples."""],
 
     # RealPLKSR
     "2x-AnimeSharpV2_RPLKSR_Sharp.pth": ["https://github.com/Kim2091/Kim2091-Models/releases/download/2x-AnimeSharpV2_Set/2x-AnimeSharpV2_RPLKSR_Sharp.pth",
                                         "https://github.com/Kim2091/Kim2091-Models/releases/tag/2x-AnimeSharpV2_Set", 
-"""Kim2091: This is my first anime model in years. Hopefully you guys can find a good use-case for it.
+"""Anime, Compression Removal, Restoration
+Kim2091: This is my first anime model in years. Hopefully you guys can find a good use-case for it.
 RealPLKSR (Higher quality, slower) Sharp: For heavily degraded sources. Sharp models have issues depth of field but are best at removing artifacts
 """],
 
     "2x-AnimeSharpV2_RPLKSR_Soft.pth" : ["https://github.com/Kim2091/Kim2091-Models/releases/download/2x-AnimeSharpV2_Set/2x-AnimeSharpV2_RPLKSR_Soft.pth",
                                          "https://github.com/Kim2091/Kim2091-Models/releases/tag/2x-AnimeSharpV2_Set", 
-"""Kim2091: This is my first anime model in years. Hopefully you guys can find a good use-case for it.
+"""Anime, Compression Removal, Restoration
+Kim2091: This is my first anime model in years. Hopefully you guys can find a good use-case for it.
 RealPLKSR (Higher quality, slower) Soft: For cleaner sources. Soft models preserve depth of field but may not remove other artifacts as well"""],
 
     "4xPurePhoto-RealPLSKR.pth"       : ["https://github.com/starinspace/StarinspaceUpscale/releases/download/Models/4xPurePhoto-RealPLSKR.pth",
                                         "https://openmodeldb.info/models/4x-PurePhoto-RealPLSKR", 
-"""Skilled in working with cats, hair, parties, and creating clear images.
+"""AI Generated, Compression Removal, JPEG, Realistic, Restoration
+asterixcool: Skilled in working with cats, hair, parties, and creating clear images.
 Also proficient in resizing photos and enlarging large, sharp images.
 Can effectively improve images from small sizes as well (300px at smallest on one side, depending on the subject).
-Experienced in experimenting with techniques like upscaling with this model twice and \
+Experienced in experimenting with techniques like upscaling with this model twice and
 then reducing it by 50% to enhance details, especially in features like hair or animals."""],
 
     "2x_Text2HD_v.1-RealPLKSR.pth"    : ["https://github.com/starinspace/StarinspaceUpscale/releases/download/Models/2x_Text2HD_v.1-RealPLKSR.pth",
                                         "https://openmodeldb.info/models/2x-Text2HD-v-1", 
-"""Purpose: Upscale text in very low quality to normal quality.
-The upscale model is specifically designed to enhance lower-quality text images, \
+"""Compression Removal, Denoise, General Upscaler, JPEG, Restoration, Text
+asterixcool: The upscale model is specifically designed to enhance lower-quality text images,
 improving their clarity and readability by upscaling them by 2x.
 It excels at processing moderately sized text, effectively transforming it into high-quality, legible scans.
-However, the model may encounter challenges when dealing with very small text, \
-as its performance is optimized for text of a certain minimum size. For best results, \
+However, the model may encounter challenges when dealing with very small text,
+as its performance is optimized for text of a certain minimum size. For best results,
 input images should contain text that is not excessively small."""],
 
     "2xVHS2HD-RealPLKSR.pth"          : ["https://github.com/starinspace/StarinspaceUpscale/releases/download/Models/2xVHS2HD-RealPLKSR.pth",
                                         "https://openmodeldb.info/models/2x-VHS2HD", 
-"""An advanced VHS recording model designed to enhance video quality by reducing artifacts such as haloing, ghosting, and noise patterns.
+"""Compression Removal, Dehalo, Realistic, Restoration, Video Frame
+asterixcool: An advanced VHS recording model designed to enhance video quality by reducing artifacts such as haloing, ghosting, and noise patterns.
 Optimized primarily for PAL resolution (NTSC might work good as well)."""],
 
     "4xNomosWebPhoto_RealPLKSR.pth"   : ["https://github.com/Phhofm/models/releases/download/4xNomosWebPhoto_RealPLKSR/4xNomosWebPhoto_RealPLKSR.pth",
                                         "https://openmodeldb.info/models/4x-NomosWebPhoto-RealPLKSR", 
-"""Phhofm: 4x RealPLKSR model for photography, trained with realistic noise, lens blur, jpg and webp re-compression."""],
+"""Realistic, Restoration
+Phhofm: 4x RealPLKSR model for photography, trained with realistic noise, lens blur, jpg and webp re-compression."""],
 
     # DRCT
     "4xNomos2_hq_drct-l.pth"          : ["https://github.com/Phhofm/models/releases/download/4xNomos2_hq_drct-l/4xNomos2_hq_drct-l.pth", 
                                         "https://github.com/Phhofm/models/releases/tag/4xNomos2_hq_drct-l",
-"""Phhofm: An drct-l 4x upscaling model, similiar to the 4xNomos2_hq_atd, 4xNomos2_hq_dat2 and 4xNomos2_hq_mosr models, trained and for usage on non-degraded input to give good quality output.
+"""General Upscaler, Realistic
+Phhofm: An drct-l 4x upscaling model, similiar to the 4xNomos2_hq_atd, 4xNomos2_hq_dat2 and 4xNomos2_hq_mosr models, trained and for usage on non-degraded input to give good quality output.
 """],
 
     # ATD
     "4xNomos2_hq_atd.pth"             : ["https://github.com/Phhofm/models/releases/download/4xNomos2_hq_atd/4xNomos2_hq_atd.pth", 
                                          "https://github.com/Phhofm/models/releases/tag/4xNomos2_hq_atd",
-"""Phhofm: An atd 4x upscaling model, similiar to the 4xNomos2_hq_dat2 or 4xNomos2_hq_mosr models, trained and for usage on non-degraded input to give good quality output.
+"""General Upscaler, Realistic
+Phhofm: An atd 4x upscaling model, similiar to the 4xNomos2_hq_dat2 or 4xNomos2_hq_mosr models, trained and for usage on non-degraded input to give good quality output.
 """],
 
     # MoSR
     "4xNomos2_hq_mosr.pth"             : ["https://github.com/Phhofm/models/releases/download/4xNomos2_hq_mosr/4xNomos2_hq_mosr.pth", 
                                          "https://github.com/Phhofm/models/releases/tag/4xNomos2_hq_mosr",
-"""Phhofm: A 4x MoSR upscaling model, meant for non-degraded input, since this model was trained on non-degraded input to give good quality output.
+"""General Upscaler, Realistic
+Phhofm: A 4x MoSR upscaling model, meant for non-degraded input, since this model was trained on non-degraded input to give good quality output.
 """],
     
     "2x-AnimeSharpV2_MoSR_Sharp.pth"             : ["https://github.com/Kim2091/Kim2091-Models/releases/download/2x-AnimeSharpV2_Set/2x-AnimeSharpV2_MoSR_Sharp.pth", 
                                          "https://github.com/Kim2091/Kim2091-Models/releases/tag/2x-AnimeSharpV2_Set",
-"""Kim2091: This is my first anime model in years. Hopefully you guys can find a good use-case for it.
+"""Anime, Compression Removal, Restoration
+Kim2091: This is my first anime model in years. Hopefully you guys can find a good use-case for it.
 MoSR (Lower quality, faster), Sharp: For heavily degraded sources. Sharp models have issues depth of field but are best at removing artifacts
 """],
     
     "2x-AnimeSharpV2_MoSR_Soft.pth"             : ["https://github.com/Kim2091/Kim2091-Models/releases/download/2x-AnimeSharpV2_Set/2x-AnimeSharpV2_MoSR_Soft.pth", 
                                          "https://github.com/Kim2091/Kim2091-Models/releases/tag/2x-AnimeSharpV2_Set",
-"""Kim2091: This is my first anime model in years. Hopefully you guys can find a good use-case for it.
+"""Anime, Compression Removal, Restoration
+Kim2091: This is my first anime model in years. Hopefully you guys can find a good use-case for it.
 MoSR (Lower quality, faster), Soft: For cleaner sources. Soft models preserve depth of field but may not remove other artifacts as well
 """],
 
     # SRFormer
     "4xNomos8kSCSRFormer.pth"             : ["https://github.com/Phhofm/models/releases/download/4xNomos8kSCSRFormer/4xNomos8kSCSRFormer.pth", 
                                              "https://github.com/Phhofm/models/releases/tag/4xNomos8kSCSRFormer",
-"""Phhofm: 4x photo upscaler with otf jpg compression and blur, trained on musl's Nomos8k_sfw dataset for realisic sr.
+"""Anime, Compression Removal, General Upscaler, JPEG, Realistic, Restoration
+Phhofm: 4x photo upscaler with otf jpg compression and blur, trained on musl's Nomos8k_sfw dataset for realisic sr.
 """],
 
-#     "4xFrankendata_FullDegradation_g_460000.pth" : ["https://drive.google.com/uc?export=download&confirm=1&id=1PZrj-8ofxhORv_OgTVSoRt3dYi-BtiDj", 
-#                                                     "https://openmodeldb.info/models/4x-Frankendata-FullDegradation-SRFormer",
-# """Description: 4x realistic upscaler that may also work for general purpose usage. 
-# It was trained with OTF random degradation with a very low to very high range of degradations, including blur, noise, and compression. 
-# Trained with the same Frankendata dataset that I used for the pretrain model.
-# """],
-
-#     "FrankendataPretrainer_SRFormer400K_g.pth" : ["https://drive.google.com/uc?export=download&confirm=1&id=1SaKvpYYIm2Vj2m9GifUMlNCbmkE6JZmr", 
-#                                                     "https://openmodeldb.info/models/4x-FrankendataPretainer-SRFormer",
-# """Description: 4x realistic upscaler that may also work for general purpose usage. 
-# It was trained with OTF random degradation with a very low to very high range of degradations, including blur, noise, and compression. 
-# Trained with the same Frankendata dataset that I used for the pretrain model.
-# """],
-
-#     "1xFrankenfixer_SRFormerLight_g.pth" : ["https://drive.google.com/uc?export=download&confirm=1&id=1UJ0iyFn4IGNhPIgNgrQrBxYsdDloFc9I", 
-#                                                   "https://openmodeldb.info/models/1x-Frankenfixer-SRFormerLight",
-# """A 1x model designed to reduce artifacts and restore detail to images upscaled by 4xFrankendata_FullDegradation_SRFormer. It could possibly work with other upscaling models too.
-# """],
+    "4xFrankendataFullDegradation_SRFormer460K_g.pth" : ["https://drive.google.com/uc?export=download&confirm=1&id=1PZrj-8ofxhORv_OgTVSoRt3dYi-BtiDj", 
+                                                    "https://openmodeldb.info/models/4x-Frankendata-FullDegradation-SRFormer",
+"""Compression Removal, Denoise, Realistic, Restoration
+Crustaceous D: 4x realistic upscaler that may also work for general purpose usage. 
+It was trained with OTF random degradation with a very low to very high range of degradations, including blur, noise, and compression. 
+Trained with the same Frankendata dataset that I used for the pretrain model.
+"""],
+
+    "4xFrankendataPretrainer_SRFormer400K_g.pth" : ["https://drive.google.com/uc?export=download&confirm=1&id=1SaKvpYYIm2Vj2m9GifUMlNCbmkE6JZmr", 
+                                                    "https://openmodeldb.info/models/4x-FrankendataPretainer-SRFormer",
+"""Realistic, Restoration
+Crustaceous D: 4x realistic upscaler that may also work for general purpose usage. 
+It was trained with OTF random degradation with a very low to very high range of degradations, including blur, noise, and compression. 
+Trained with the same Frankendata dataset that I used for the pretrain model.
+"""],
+
+    "1xFrankenfixer_SRFormerLight_g.pth" : ["https://drive.google.com/uc?export=download&confirm=1&id=1UJ0iyFn4IGNhPIgNgrQrBxYsdDloFc9I", 
+                                                  "https://openmodeldb.info/models/1x-Frankenfixer-SRFormerLight",
+"""Realistic, Restoration
+Crustaceous D: A 1x model designed to reduce artifacts and restore detail to images upscaled by 4xFrankendata_FullDegradation_SRFormer. It could possibly work with other upscaling models too.
+"""],
 }
 
 example_list = ["images/a01.jpg", "images/a02.jpg", "images/a03.jpg", "images/a04.jpg", "images/bus.jpg", "images/zidane.jpg", 
@@ -361,7 +437,7 @@ def get_model_type(model_name):
         model_type = "RealPLKSR"
     elif any(value in model_name.lower() for value in ("realesrgan", "realesrnet")):
         model_type = "RRDB"
-    elif any(value in model_name.lower() for value in ("realesr", "exposurecorrection", "parimgcompact", "lsdircompact")):
+    elif any(value in model_name.lower() for value in ("realesr", "compact")):
         model_type = "SRVGG"
     elif "esrgan" in model_name.lower():
         model_type = "ESRGAN"
@@ -385,6 +461,10 @@ class Upscale:
         print(img)
         print(face_restoration, upscale_model, scale)
         try:
+            if not img or (not face_restoration and not upscale_model):
+                raise ValueError("Invalid parameter setting")
+
+            timer = Timer()  # Create a timer
             self.scale = scale
             self.img_name = os.path.basename(str(img))
             self.basename, self.extension = os.path.splitext(self.img_name)
@@ -396,282 +476,297 @@ class Upscale:
                 img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
 
             self.h_input, self.w_input = img.shape[0:2]
+            self.realesrganer = None
 
-            if face_restoration:
-                download_from_url(face_models[face_restoration][0], face_restoration, os.path.join("weights", "face"))
-                
             modelInUse = ""
             upscale_type = None
+            is_auto_split_upscale = True
             if upscale_model:
                 upscale_type, upscale_model = upscale_model.split(", ", 1)
                 download_from_url(upscale_models[upscale_model][0], upscale_model, os.path.join("weights", "upscale"))
                 modelInUse = f"_{os.path.splitext(upscale_model)[0]}"
             
-            self.netscale = 1 if any(sub in upscale_model.lower() for sub in ("x1", "1x")) else (2 if any(sub in upscale_model.lower() for sub in ("x2", "2x")) else 4)
-            model = None
-            is_auto_split_upscale = True
-            half = True if torch.cuda.is_available() else False
-            if upscale_type:
-                # The values of the following hyperparameters are based on the research findings of the Spandrel project.
-                # https://github.com/chaiNNer-org/spandrel/tree/main/libs/spandrel/spandrel/architectures
-                from basicsr.archs.rrdbnet_arch import RRDBNet
-                loadnet = torch.load(os.path.join("weights", "upscale", upscale_model), map_location=torch.device('cpu'), weights_only=True)
-                if 'params_ema' in loadnet or 'params' in loadnet:
-                    loadnet = loadnet['params_ema'] if 'params_ema' in loadnet else loadnet['params']
-                # for key in loadnet_origin.keys():
-                #     print(f"{key}, {loadnet_origin[key].shape}")
-                if upscale_type == "SRVGG":
-                    from basicsr.archs.srvgg_arch import SRVGGNetCompact
-                    body_max_num = self.find_max_numbers(loadnet, "body")
-                    num_feat     = loadnet["body.0.weight"].shape[0]
-                    num_in_ch    = loadnet["body.0.weight"].shape[1]
-                    num_conv     = body_max_num // 2 - 1
-                    model        = SRVGGNetCompact(num_in_ch=num_in_ch, num_out_ch=3, num_feat=num_feat, num_conv=num_conv, upscale=self.netscale, act_type='prelu')
-                elif upscale_type == "RRDB" or upscale_type == "ESRGAN":
-                    if upscale_type == "RRDB":
-                        num_block = self.find_max_numbers(loadnet, "body") + 1
-                        num_feat  = loadnet["conv_first.weight"].shape[0]
-                    else:
-                        num_block = self.find_max_numbers(loadnet, "model.1.sub")
-                        num_feat  = loadnet["model.0.weight"].shape[0]
-                    model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=num_feat, num_block=num_block, num_grow_ch=32, scale=self.netscale, is_real_esrgan=upscale_type == "RRDB")
-                elif upscale_type == "DAT":
-                    from basicsr.archs.dat_arch import DAT
-                    half = False
-
-                    in_chans   = loadnet["conv_first.weight"].shape[1]
-                    embed_dim  = loadnet["conv_first.weight"].shape[0]
-                    num_layers = self.find_max_numbers(loadnet, "layers") + 1
-                    depth      = [6] * num_layers
-                    num_heads  = [6] * num_layers
-                    for i in range(num_layers):
-                        depth[i] = self.find_max_numbers(loadnet, f"layers.{i}.blocks") + 1
-                        num_heads[i] = loadnet[f"layers.{i}.blocks.1.attn.temperature"].shape[0] if depth[i] >= 2 else \
-                                       loadnet[f"layers.{i}.blocks.0.attn.attns.0.pos.pos3.2.weight"].shape[0] * 2
-
-                    upsampler        = "pixelshuffle" if "conv_last.weight" in loadnet else "pixelshuffledirect"
-                    resi_connection  = "1conv" if "conv_after_body.weight" in loadnet else "3conv"
-                    qkv_bias         = "layers.0.blocks.0.attn.qkv.bias" in loadnet
-                    expansion_factor = float(loadnet["layers.0.blocks.0.ffn.fc1.weight"].shape[0] / embed_dim)
-
-                    img_size = 64
-                    if "layers.0.blocks.2.attn.attn_mask_0" in loadnet:
-                        attn_mask_0_x, attn_mask_0_y, _attn_mask_0_z = loadnet["layers.0.blocks.2.attn.attn_mask_0"].shape
-                        img_size = int(math.sqrt(attn_mask_0_x * attn_mask_0_y))
-
-                    split_size = [2, 4]
-                    if "layers.0.blocks.0.attn.attns.0.rpe_biases" in loadnet:
-                        split_sizes = loadnet["layers.0.blocks.0.attn.attns.0.rpe_biases"][-1] + 1
-                        split_size = [int(x) for x in split_sizes]
-
-                    model = DAT(img_size=img_size, in_chans=in_chans, embed_dim=embed_dim, split_size=split_size, depth=depth, num_heads=num_heads, expansion_factor=expansion_factor, 
-                                qkv_bias=qkv_bias, resi_connection=resi_connection, upsampler=upsampler, upscale=self.netscale)
-                elif upscale_type == "HAT":
-                    half = False
-                    from basicsr.archs.hat_arch import HAT
-                    in_chans = loadnet["conv_first.weight"].shape[1]
-                    embed_dim = loadnet["conv_first.weight"].shape[0]
-                    window_size = int(math.sqrt(loadnet["relative_position_index_SA"].shape[0]))
-                    num_layers = self.find_max_numbers(loadnet, "layers") + 1
-                    depths      = [6] * num_layers
-                    num_heads   = [6] * num_layers
-                    for i in range(num_layers):
-                        depths[i] = self.find_max_numbers(loadnet, f"layers.{i}.residual_group.blocks") + 1
-                        num_heads[i] = loadnet[f"layers.{i}.residual_group.overlap_attn.relative_position_bias_table"].shape[1]
-                    resi_connection = "1conv" if "conv_after_body.weight" in loadnet else "identity"
-
-                    qkv_bias = "layers.0.residual_group.blocks.0.attn.qkv.bias" in loadnet
-                    patch_norm = "patch_embed.norm.weight" in loadnet
-                    ape = "absolute_pos_embed" in loadnet
-
-                    mlp_hidden_dim = int(loadnet["layers.0.residual_group.blocks.0.mlp.fc1.weight"].shape[0])
-                    mlp_ratio = mlp_hidden_dim / embed_dim
-                    upsampler = "pixelshuffle"
-
-                    if "hat-l" in upscale_model.lower():
-                        compress_ratio = 3
-                        squeeze_factor = 30
-                    elif "hat-s" in upscale_model.lower():
-                        compress_ratio = 24
-                        squeeze_factor = 24
-                    model = HAT(img_size=64, patch_size=1, in_chans=in_chans, embed_dim=embed_dim, depths=depths, num_heads=num_heads, window_size=window_size, compress_ratio=compress_ratio,
-                                squeeze_factor=squeeze_factor, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, ape=ape, patch_norm=patch_norm,
-                                upsampler=upsampler, resi_connection=resi_connection, upscale=self.netscale,)
-                elif "RealPLKSR" in upscale_type:
-                    from basicsr.archs.realplksr_arch import realplksr
-                    half = False if "RealPLSKR" in upscale_model else half
-                    use_ea       = "feats.1.attn.f.0.weight" in loadnet
-                    dim          = loadnet["feats.0.weight"].shape[0]
-                    num_feats    = self.find_max_numbers(loadnet, "feats") + 1
-                    n_blocks     = num_feats - 3
-                    kernel_size  = loadnet["feats.1.lk.conv.weight"].shape[2]
-                    split_ratio  = loadnet["feats.1.lk.conv.weight"].shape[0] / dim
-                    use_dysample = "to_img.init_pos" in loadnet
-
-                    model = realplksr(upscaling_factor=self.netscale, dim=dim, n_blocks=n_blocks, kernel_size=kernel_size, split_ratio=split_ratio, use_ea=use_ea, dysample=use_dysample)
-                elif upscale_type == "DRCT":
-                    half = False
-                    from basicsr.archs.DRCT_arch import DRCT
-
-                    in_chans    = loadnet["conv_first.weight"].shape[1]
-                    embed_dim   = loadnet["conv_first.weight"].shape[0]
-                    num_layers  = self.find_max_numbers(loadnet, "layers") + 1
-                    depths      = (6,) * num_layers
-                    num_heads   = []
-                    for i in range(num_layers):
-                        num_heads.append(loadnet[f"layers.{i}.swin1.attn.relative_position_bias_table"].shape[1])
-
-                    mlp_ratio       = loadnet["layers.0.swin1.mlp.fc1.weight"].shape[0] / embed_dim
-                    window_square   = loadnet["layers.0.swin1.attn.relative_position_bias_table"].shape[0]
-                    window_size     = (math.isqrt(window_square) + 1) // 2
-                    upsampler       = "pixelshuffle" if "conv_last.weight" in loadnet else ""
-                    resi_connection = "1conv" if "conv_after_body.weight" in loadnet else ""
-                    qkv_bias        = "layers.0.swin1.attn.qkv.bias" in loadnet
-                    gc_adjust1      = loadnet["layers.0.adjust1.weight"].shape[0]
-                    patch_norm      = "patch_embed.norm.weight" in loadnet
-                    ape             = "absolute_pos_embed" in loadnet
-
-                    model = DRCT(in_chans=in_chans,  img_size= 64, window_size=window_size, compress_ratio=3,squeeze_factor=30,
-                        conv_scale= 0.01, overlap_ratio= 0.5, img_range= 1., depths=depths, embed_dim=embed_dim, num_heads=num_heads, 
-                        mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, ape=ape, patch_norm=patch_norm, use_checkpoint=False,
-                        upscale=self.netscale, upsampler=upsampler, resi_connection=resi_connection, gc =gc_adjust1,)
-                elif upscale_type == "ATD":
-                    half = False
-                    from basicsr.archs.atd_arch import ATD
-                    in_chans    = loadnet["conv_first.weight"].shape[1]
-                    embed_dim   = loadnet["conv_first.weight"].shape[0]
-                    window_size = math.isqrt(loadnet["relative_position_index_SA"].shape[0])
-                    num_layers  = self.find_max_numbers(loadnet, "layers") + 1
-                    depths      = [6] * num_layers
-                    num_heads   = [6] * num_layers
-                    for i in range(num_layers):
-                        depths[i] = self.find_max_numbers(loadnet, f"layers.{i}.residual_group.layers") + 1
-                        num_heads[i] = loadnet[f"layers.{i}.residual_group.layers.0.attn_win.relative_position_bias_table"].shape[1]
-                    num_tokens          = loadnet["layers.0.residual_group.layers.0.attn_atd.scale"].shape[0]
-                    reducted_dim        = loadnet["layers.0.residual_group.layers.0.attn_atd.wq.weight"].shape[0]
-                    convffn_kernel_size = loadnet["layers.0.residual_group.layers.0.convffn.dwconv.depthwise_conv.0.weight"].shape[2]
-                    mlp_ratio           = (loadnet["layers.0.residual_group.layers.0.convffn.fc1.weight"].shape[0] / embed_dim)
-                    qkv_bias            = "layers.0.residual_group.layers.0.wqkv.bias" in loadnet
-                    ape                 = "absolute_pos_embed" in loadnet
-                    patch_norm          = "patch_embed.norm.weight" in loadnet
-                    resi_connection     = "1conv" if "layers.0.conv.weight" in loadnet else "3conv"
-
-                    if "conv_up1.weight" in loadnet:
-                        upsampler = "nearest+conv"
-                    elif "conv_before_upsample.0.weight" in loadnet:
-                        upsampler = "pixelshuffle"
-                    elif "conv_last.weight" in loadnet:
-                        upsampler = ""
-                    else:
-                        upsampler = "pixelshuffledirect"
-
-                    is_light = upsampler == "pixelshuffledirect" and embed_dim == 48
-                    category_size = 128 if is_light else 256
-
-                    model = ATD(in_chans=in_chans, embed_dim=embed_dim, depths=depths, num_heads=num_heads, window_size=window_size, category_size=category_size,
-                                num_tokens=num_tokens, reducted_dim=reducted_dim, convffn_kernel_size=convffn_kernel_size, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, ape=ape,
-                                patch_norm=patch_norm, use_checkpoint=False, upscale=self.netscale, upsampler=upsampler, resi_connection='1conv',)
-                elif upscale_type == "MoSR":
-                    from basicsr.archs.mosr_arch import mosr
-                    n_block         = self.find_max_numbers(loadnet, "gblocks") - 5
-                    in_ch           = loadnet["gblocks.0.weight"].shape[1]
-                    out_ch          = loadnet["upsampler.end_conv.weight"].shape[0] if "upsampler.init_pos" in loadnet else in_ch
-                    dim             = loadnet["gblocks.0.weight"].shape[0]
-                    expansion_ratio = (loadnet["gblocks.1.fc1.weight"].shape[0] / loadnet["gblocks.1.fc1.weight"].shape[1]) / 2
-                    conv_ratio      = loadnet["gblocks.1.conv.weight"].shape[0] / dim
-                    kernel_size     = loadnet["gblocks.1.conv.weight"].shape[2]
-                    upsampler       = "dys" if "upsampler.init_pos" in loadnet else ("gps" if "upsampler.in_to_k.weight" in loadnet else "ps")
-
-                    model = mosr(in_ch = in_ch, out_ch = out_ch, upscale = self.netscale, n_block = n_block, dim = dim,
-                                upsampler = upsampler, kernel_size = kernel_size, expansion_ratio = expansion_ratio, conv_ratio = conv_ratio,)
-                elif upscale_type == "SRFormer":
-                    half = False
-                    from basicsr.archs.srformer_arch import SRFormer
-                    in_chans   = loadnet["conv_first.weight"].shape[1]
-                    embed_dim  = loadnet["conv_first.weight"].shape[0]
-                    ape        = "absolute_pos_embed" in loadnet
-                    patch_norm = "patch_embed.norm.weight" in loadnet
-                    qkv_bias   = "layers.0.residual_group.blocks.0.attn.q.bias" in loadnet
-                    mlp_ratio  = float(loadnet["layers.0.residual_group.blocks.0.mlp.fc1.weight"].shape[0] / embed_dim)
-
-                    num_layers = self.find_max_numbers(loadnet, "layers") + 1
-                    depths     = [6] * num_layers
-                    num_heads  = [6] * num_layers
-                    for i in range(num_layers):
-                        depths[i] = self.find_max_numbers(loadnet, f"layers.{i}.residual_group.blocks") + 1
-                        num_heads[i] = loadnet[f"layers.{i}.residual_group.blocks.0.attn.relative_position_bias_table"].shape[1]
-
-                    if "conv_hr.weight" in loadnet:
-                        upsampler = "nearest+conv"
-                    elif "conv_before_upsample.0.weight" in loadnet:
+                self.netscale = 1 if any(sub in upscale_model.lower() for sub in ("x1", "1x")) else (2 if any(sub in upscale_model.lower() for sub in ("x2", "2x")) else 4)
+                model = None
+                half = True if torch.cuda.is_available() else False
+                if upscale_type:
+                    # The values of the following hyperparameters are based on the research findings of the Spandrel project.
+                    # https://github.com/chaiNNer-org/spandrel/tree/main/libs/spandrel/spandrel/architectures
+                    from basicsr.archs.rrdbnet_arch import RRDBNet
+                    loadnet = torch.load(os.path.join("weights", "upscale", upscale_model), map_location=torch.device('cpu'), weights_only=True)
+                    if 'params_ema' in loadnet or 'params' in loadnet:
+                        loadnet = loadnet['params_ema'] if 'params_ema' in loadnet else loadnet['params']
+
+                    if upscale_type == "SRVGG":
+                        from basicsr.archs.srvgg_arch import SRVGGNetCompact
+                        body_max_num = self.find_max_numbers(loadnet, "body")
+                        num_feat     = loadnet["body.0.weight"].shape[0]
+                        num_in_ch    = loadnet["body.0.weight"].shape[1]
+                        num_conv     = body_max_num // 2 - 1
+                        model        = SRVGGNetCompact(num_in_ch=num_in_ch, num_out_ch=3, num_feat=num_feat, num_conv=num_conv, upscale=self.netscale, act_type='prelu')
+                    elif upscale_type == "RRDB" or upscale_type == "ESRGAN":
+                        if upscale_type == "RRDB":
+                            num_block = self.find_max_numbers(loadnet, "body") + 1
+                            num_feat  = loadnet["conv_first.weight"].shape[0]
+                        else:
+                            num_block = self.find_max_numbers(loadnet, "model.1.sub")
+                            num_feat  = loadnet["model.0.weight"].shape[0]
+                        model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=num_feat, num_block=num_block, num_grow_ch=32, scale=self.netscale, is_real_esrgan=upscale_type == "RRDB")
+                    elif upscale_type == "DAT":
+                        from basicsr.archs.dat_arch import DAT
+                        half = False
+
+                        in_chans   = loadnet["conv_first.weight"].shape[1]
+                        embed_dim  = loadnet["conv_first.weight"].shape[0]
+                        num_layers = self.find_max_numbers(loadnet, "layers") + 1
+                        depth      = [6] * num_layers
+                        num_heads  = [6] * num_layers
+                        for i in range(num_layers):
+                            depth[i] = self.find_max_numbers(loadnet, f"layers.{i}.blocks") + 1
+                            num_heads[i] = loadnet[f"layers.{i}.blocks.1.attn.temperature"].shape[0] if depth[i] >= 2 else \
+                                           loadnet[f"layers.{i}.blocks.0.attn.attns.0.pos.pos3.2.weight"].shape[0] * 2
+
+                        upsampler        = "pixelshuffle" if "conv_last.weight" in loadnet else "pixelshuffledirect"
+                        resi_connection  = "1conv" if "conv_after_body.weight" in loadnet else "3conv"
+                        qkv_bias         = "layers.0.blocks.0.attn.qkv.bias" in loadnet
+                        expansion_factor = float(loadnet["layers.0.blocks.0.ffn.fc1.weight"].shape[0] / embed_dim)
+
+                        img_size = 64
+                        if "layers.0.blocks.2.attn.attn_mask_0" in loadnet:
+                            attn_mask_0_x, attn_mask_0_y, _attn_mask_0_z = loadnet["layers.0.blocks.2.attn.attn_mask_0"].shape
+                            img_size = int(math.sqrt(attn_mask_0_x * attn_mask_0_y))
+
+                        split_size = [2, 4]
+                        if "layers.0.blocks.0.attn.attns.0.rpe_biases" in loadnet:
+                            split_sizes = loadnet["layers.0.blocks.0.attn.attns.0.rpe_biases"][-1] + 1
+                            split_size = [int(x) for x in split_sizes]
+
+                        model = DAT(img_size=img_size, in_chans=in_chans, embed_dim=embed_dim, split_size=split_size, depth=depth, num_heads=num_heads, expansion_factor=expansion_factor, 
+                                    qkv_bias=qkv_bias, resi_connection=resi_connection, upsampler=upsampler, upscale=self.netscale)
+                    elif upscale_type == "HAT":
+                        half = False
+                        from basicsr.archs.hat_arch import HAT
+                        in_chans = loadnet["conv_first.weight"].shape[1]
+                        embed_dim = loadnet["conv_first.weight"].shape[0]
+                        window_size = int(math.sqrt(loadnet["relative_position_index_SA"].shape[0]))
+                        num_layers = self.find_max_numbers(loadnet, "layers") + 1
+                        depths      = [6] * num_layers
+                        num_heads   = [6] * num_layers
+                        for i in range(num_layers):
+                            depths[i] = self.find_max_numbers(loadnet, f"layers.{i}.residual_group.blocks") + 1
+                            num_heads[i] = loadnet[f"layers.{i}.residual_group.overlap_attn.relative_position_bias_table"].shape[1]
+                        resi_connection = "1conv" if "conv_after_body.weight" in loadnet else "identity"
+
+                        compress_ratio = self.find_divisor_for_quotient(embed_dim, loadnet["layers.0.residual_group.blocks.0.conv_block.cab.0.weight"].shape[0],)
+                        squeeze_factor = self.find_divisor_for_quotient(embed_dim, loadnet["layers.0.residual_group.blocks.0.conv_block.cab.3.attention.1.weight"].shape[0],)
+
+                        qkv_bias = "layers.0.residual_group.blocks.0.attn.qkv.bias" in loadnet
+                        patch_norm = "patch_embed.norm.weight" in loadnet
+                        ape = "absolute_pos_embed" in loadnet
+
+                        mlp_hidden_dim = int(loadnet["layers.0.residual_group.blocks.0.mlp.fc1.weight"].shape[0])
+                        mlp_ratio = mlp_hidden_dim / embed_dim
                         upsampler = "pixelshuffle"
-                    elif "upsample.0.weight" in loadnet:
-                        upsampler = "pixelshuffledirect"
-                    resi_connection = "1conv" if "conv_after_body.weight" in loadnet else "3conv"
-
-                    window_size = int(math.sqrt(loadnet["layers.0.residual_group.blocks.0.attn.relative_position_bias_table"].shape[0])) + 1
-
-                    model = SRFormer(img_size=64, in_chans=in_chans, embed_dim=embed_dim, depths=depths, num_heads=num_heads, window_size=window_size, mlp_ratio=mlp_ratio, 
-                                 qkv_bias=qkv_bias, qk_scale=None, ape=ape, patch_norm=patch_norm, upscale=self.netscale, upsampler=upsampler, resi_connection=resi_connection,)
-
-            self.upsampler = None
-            if model:
-                self.upsampler = RealESRGANer(scale=self.netscale, model_path=os.path.join("weights", "upscale", upscale_model), model=model, tile=0, tile_pad=10, pre_pad=0, half=half)
-            elif upscale_model:
-                self.upsampler = None
-                import PIL
-                from image_gen_aux import UpscaleWithModel
-                class UpscaleWithModel_Gfpgan(UpscaleWithModel):
-                    def cv2pil(self, image):
-                        ''' OpenCV type -> PIL type
-                        https://qiita.com/derodero24/items/f22c22b22451609908ee
-                        '''
-                        new_image = image.copy()
-                        if new_image.ndim == 2:  # Grayscale
-                            pass
-                        elif new_image.shape[2] == 3:  # Color
-                            new_image = cv2.cvtColor(new_image, cv2.COLOR_BGR2RGB)
-                        elif new_image.shape[2] == 4:  # Transparency
-                            new_image = cv2.cvtColor(new_image, cv2.COLOR_BGRA2RGBA)
-                        new_image = PIL.Image.fromarray(new_image)
-                        return new_image
-
-                    def pil2cv(self, image):
-                        ''' PIL type -> OpenCV type
-                        https://qiita.com/derodero24/items/f22c22b22451609908ee
-                        '''
-                        new_image = np.array(image, dtype=np.uint8)
-                        if new_image.ndim == 2:  # Grayscale
-                            pass
-                        elif new_image.shape[2] == 3:  # Color
-                            new_image = cv2.cvtColor(new_image, cv2.COLOR_RGB2BGR)
-                        elif new_image.shape[2] == 4:  # Transparency
-                            new_image = cv2.cvtColor(new_image, cv2.COLOR_RGBA2BGRA)
-                        return new_image
-
-                    def enhance(self_, img, outscale=None):
-                        # img: numpy
-                        h_input, w_input = img.shape[0:2]
-                        pil_img = self.cv2pil(img)
-                        pil_img = self_.__call__(pil_img)
-                        cv_image = self.pil2cv(pil_img)
-                        if outscale is not None and outscale != float(self.netscale):
-                            interpolation = cv2.INTER_AREA if outscale < float(self.netscale) else cv2.INTER_LANCZOS4
-                            cv_image = cv2.resize(
-                                cv_image, (
-                                    int(w_input * outscale),
-                                    int(h_input * outscale),
-                                ), interpolation=interpolation)
-                        return cv_image, None
-
-                device = "cuda" if torch.cuda.is_available() else "cpu"
-                upscaler = UpscaleWithModel.from_pretrained(os.path.join("weights", "upscale", upscale_model)).to(device)
-                upscaler.__class__ = UpscaleWithModel_Gfpgan
-                self.upsampler = upscaler
+
+                        model = HAT(img_size=64, patch_size=1, in_chans=in_chans, embed_dim=embed_dim, depths=depths, num_heads=num_heads, window_size=window_size, compress_ratio=compress_ratio,
+                                    squeeze_factor=squeeze_factor, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, ape=ape, patch_norm=patch_norm,
+                                    upsampler=upsampler, resi_connection=resi_connection, upscale=self.netscale,)
+                    elif "RealPLKSR" in upscale_type:
+                        from basicsr.archs.realplksr_arch import realplksr
+                        half = False if "RealPLSKR" in upscale_model else half
+                        use_ea       = "feats.1.attn.f.0.weight" in loadnet
+                        dim          = loadnet["feats.0.weight"].shape[0]
+                        num_feats    = self.find_max_numbers(loadnet, "feats") + 1
+                        n_blocks     = num_feats - 3
+                        kernel_size  = loadnet["feats.1.lk.conv.weight"].shape[2]
+                        split_ratio  = loadnet["feats.1.lk.conv.weight"].shape[0] / dim
+                        use_dysample = "to_img.init_pos" in loadnet
+
+                        model = realplksr(upscaling_factor=self.netscale, dim=dim, n_blocks=n_blocks, kernel_size=kernel_size, split_ratio=split_ratio, use_ea=use_ea, dysample=use_dysample)
+                    elif upscale_type == "DRCT":
+                        half = False
+                        from basicsr.archs.DRCT_arch import DRCT
+
+                        in_chans    = loadnet["conv_first.weight"].shape[1]
+                        embed_dim   = loadnet["conv_first.weight"].shape[0]
+                        num_layers  = self.find_max_numbers(loadnet, "layers") + 1
+                        depths      = (6,) * num_layers
+                        num_heads   = []
+                        for i in range(num_layers):
+                            num_heads.append(loadnet[f"layers.{i}.swin1.attn.relative_position_bias_table"].shape[1])
+
+                        mlp_ratio       = loadnet["layers.0.swin1.mlp.fc1.weight"].shape[0] / embed_dim
+                        window_square   = loadnet["layers.0.swin1.attn.relative_position_bias_table"].shape[0]
+                        window_size     = (math.isqrt(window_square) + 1) // 2
+                        upsampler       = "pixelshuffle" if "conv_last.weight" in loadnet else ""
+                        resi_connection = "1conv" if "conv_after_body.weight" in loadnet else ""
+                        qkv_bias        = "layers.0.swin1.attn.qkv.bias" in loadnet
+                        gc_adjust1      = loadnet["layers.0.adjust1.weight"].shape[0]
+                        patch_norm      = "patch_embed.norm.weight" in loadnet
+                        ape             = "absolute_pos_embed" in loadnet
+
+                        model = DRCT(in_chans=in_chans,  img_size= 64, window_size=window_size, compress_ratio=3,squeeze_factor=30,
+                            conv_scale= 0.01, overlap_ratio= 0.5, img_range= 1., depths=depths, embed_dim=embed_dim, num_heads=num_heads, 
+                            mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, ape=ape, patch_norm=patch_norm, use_checkpoint=False,
+                            upscale=self.netscale, upsampler=upsampler, resi_connection=resi_connection, gc =gc_adjust1,)
+                    elif upscale_type == "ATD":
+                        half = False
+                        from basicsr.archs.atd_arch import ATD
+                        in_chans    = loadnet["conv_first.weight"].shape[1]
+                        embed_dim   = loadnet["conv_first.weight"].shape[0]
+                        window_size = math.isqrt(loadnet["relative_position_index_SA"].shape[0])
+                        num_layers  = self.find_max_numbers(loadnet, "layers") + 1
+                        depths      = [6] * num_layers
+                        num_heads   = [6] * num_layers
+                        for i in range(num_layers):
+                            depths[i] = self.find_max_numbers(loadnet, f"layers.{i}.residual_group.layers") + 1
+                            num_heads[i] = loadnet[f"layers.{i}.residual_group.layers.0.attn_win.relative_position_bias_table"].shape[1]
+                        num_tokens          = loadnet["layers.0.residual_group.layers.0.attn_atd.scale"].shape[0]
+                        reducted_dim        = loadnet["layers.0.residual_group.layers.0.attn_atd.wq.weight"].shape[0]
+                        convffn_kernel_size = loadnet["layers.0.residual_group.layers.0.convffn.dwconv.depthwise_conv.0.weight"].shape[2]
+                        mlp_ratio           = (loadnet["layers.0.residual_group.layers.0.convffn.fc1.weight"].shape[0] / embed_dim)
+                        qkv_bias            = "layers.0.residual_group.layers.0.wqkv.bias" in loadnet
+                        ape                 = "absolute_pos_embed" in loadnet
+                        patch_norm          = "patch_embed.norm.weight" in loadnet
+                        resi_connection     = "1conv" if "layers.0.conv.weight" in loadnet else "3conv"
+
+                        if "conv_up1.weight" in loadnet:
+                            upsampler = "nearest+conv"
+                        elif "conv_before_upsample.0.weight" in loadnet:
+                            upsampler = "pixelshuffle"
+                        elif "conv_last.weight" in loadnet:
+                            upsampler = ""
+                        else:
+                            upsampler = "pixelshuffledirect"
+
+                        is_light = upsampler == "pixelshuffledirect" and embed_dim == 48
+                        category_size = 128 if is_light else 256
+
+                        model = ATD(in_chans=in_chans, embed_dim=embed_dim, depths=depths, num_heads=num_heads, window_size=window_size, category_size=category_size,
+                                    num_tokens=num_tokens, reducted_dim=reducted_dim, convffn_kernel_size=convffn_kernel_size, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, ape=ape,
+                                    patch_norm=patch_norm, use_checkpoint=False, upscale=self.netscale, upsampler=upsampler, resi_connection='1conv',)
+                    elif upscale_type == "MoSR":
+                        from basicsr.archs.mosr_arch import mosr
+                        n_block         = self.find_max_numbers(loadnet, "gblocks") - 5
+                        in_ch           = loadnet["gblocks.0.weight"].shape[1]
+                        out_ch          = loadnet["upsampler.end_conv.weight"].shape[0] if "upsampler.init_pos" in loadnet else in_ch
+                        dim             = loadnet["gblocks.0.weight"].shape[0]
+                        expansion_ratio = (loadnet["gblocks.1.fc1.weight"].shape[0] / loadnet["gblocks.1.fc1.weight"].shape[1]) / 2
+                        conv_ratio      = loadnet["gblocks.1.conv.weight"].shape[0] / dim
+                        kernel_size     = loadnet["gblocks.1.conv.weight"].shape[2]
+                        upsampler       = "dys" if "upsampler.init_pos" in loadnet else ("gps" if "upsampler.in_to_k.weight" in loadnet else "ps")
+
+                        model = mosr(in_ch = in_ch, out_ch = out_ch, upscale = self.netscale, n_block = n_block, dim = dim,
+                                    upsampler = upsampler, kernel_size = kernel_size, expansion_ratio = expansion_ratio, conv_ratio = conv_ratio,)
+                    elif upscale_type == "SRFormer":
+                        half = False
+                        from basicsr.archs.srformer_arch import SRFormer
+                        in_chans   = loadnet["conv_first.weight"].shape[1]
+                        embed_dim  = loadnet["conv_first.weight"].shape[0]
+                        ape        = "absolute_pos_embed" in loadnet
+                        patch_norm = "patch_embed.norm.weight" in loadnet
+                        qkv_bias   = "layers.0.residual_group.blocks.0.attn.q.bias" in loadnet
+                        mlp_ratio  = float(loadnet["layers.0.residual_group.blocks.0.mlp.fc1.weight"].shape[0] / embed_dim)
+
+                        num_layers = self.find_max_numbers(loadnet, "layers") + 1
+                        depths     = [6] * num_layers
+                        num_heads  = [6] * num_layers
+                        for i in range(num_layers):
+                            depths[i] = self.find_max_numbers(loadnet, f"layers.{i}.residual_group.blocks") + 1
+                            num_heads[i] = loadnet[f"layers.{i}.residual_group.blocks.0.attn.relative_position_bias_table"].shape[1]
+
+                        if "conv_hr.weight" in loadnet:
+                            upsampler = "nearest+conv"
+                        elif "conv_before_upsample.0.weight" in loadnet:
+                            upsampler = "pixelshuffle"
+                        elif "upsample.0.weight" in loadnet:
+                            upsampler = "pixelshuffledirect"
+                        resi_connection = "1conv" if "conv_after_body.weight" in loadnet else "3conv"
+
+                        window_size = int(math.sqrt(loadnet["layers.0.residual_group.blocks.0.attn.relative_position_bias_table"].shape[0])) + 1
+
+                        if "layers.0.residual_group.blocks.1.attn_mask" in loadnet:
+                            attn_mask_0 = loadnet["layers.0.residual_group.blocks.1.attn_mask"].shape[0]
+                            patches_resolution = int(math.sqrt(attn_mask_0) * window_size)
+                        else:
+                            patches_resolution = window_size
+                            if ape:
+                                pos_embed_value = loadnet.get("absolute_pos_embed", [None, None])[1]
+                                if pos_embed_value:
+                                    patches_resolution = int(math.sqrt(pos_embed_value))
+
+                        img_size = patches_resolution
+                        if img_size % window_size != 0:
+                            for nice_number in [512, 256, 128, 96, 64, 48, 32, 24, 16]:
+                                if nice_number % window_size != 0:
+                                    nice_number += window_size - (nice_number % window_size)
+                                if nice_number == patches_resolution:
+                                    img_size = nice_number
+                                    break
+
+                        model = SRFormer(img_size=img_size, in_chans=in_chans, embed_dim=embed_dim, depths=depths, num_heads=num_heads, window_size=window_size, mlp_ratio=mlp_ratio, 
+                                     qkv_bias=qkv_bias, qk_scale=None, ape=ape, patch_norm=patch_norm, upscale=self.netscale, upsampler=upsampler, resi_connection=resi_connection,)
+
+                if model:
+                    self.realesrganer = RealESRGANer(scale=self.netscale, model_path=os.path.join("weights", "upscale", upscale_model), model=model, tile=0, tile_pad=10, pre_pad=0, half=half)
+                elif upscale_model:
+                    import PIL
+                    from image_gen_aux import UpscaleWithModel
+                    class UpscaleWithModel_Gfpgan(UpscaleWithModel):
+                        def cv2pil(self, image):
+                            ''' OpenCV type -> PIL type
+                            https://qiita.com/derodero24/items/f22c22b22451609908ee
+                            '''
+                            new_image = image.copy()
+                            if new_image.ndim == 2:  # Grayscale
+                                pass
+                            elif new_image.shape[2] == 3:  # Color
+                                new_image = cv2.cvtColor(new_image, cv2.COLOR_BGR2RGB)
+                            elif new_image.shape[2] == 4:  # Transparency
+                                new_image = cv2.cvtColor(new_image, cv2.COLOR_BGRA2RGBA)
+                            new_image = PIL.Image.fromarray(new_image)
+                            return new_image
+
+                        def pil2cv(self, image):
+                            ''' PIL type -> OpenCV type
+                            https://qiita.com/derodero24/items/f22c22b22451609908ee
+                            '''
+                            new_image = np.array(image, dtype=np.uint8)
+                            if new_image.ndim == 2:  # Grayscale
+                                pass
+                            elif new_image.shape[2] == 3:  # Color
+                                new_image = cv2.cvtColor(new_image, cv2.COLOR_RGB2BGR)
+                            elif new_image.shape[2] == 4:  # Transparency
+                                new_image = cv2.cvtColor(new_image, cv2.COLOR_RGBA2BGRA)
+                            return new_image
+
+                        def enhance(self_, img, outscale=None):
+                            # img: numpy
+                            h_input, w_input = img.shape[0:2]
+                            pil_img = self_.cv2pil(img)
+                            pil_img = self_.__call__(pil_img)
+                            cv_image = self_.pil2cv(pil_img)
+                            if outscale is not None and outscale != float(self.netscale):
+                                interpolation = cv2.INTER_AREA if outscale < float(self.netscale) else cv2.INTER_LANCZOS4
+                                cv_image = cv2.resize(
+                                    cv_image, (
+                                        int(w_input * outscale),
+                                        int(h_input * outscale),
+                                    ), interpolation=interpolation)
+                            return cv_image, None
+
+                    device = "cuda" if torch.cuda.is_available() else "cpu"
+                    upscaler = UpscaleWithModel.from_pretrained(os.path.join("weights", "upscale", upscale_model)).to(device)
+                    upscaler.__class__ = UpscaleWithModel_Gfpgan
+                    self.realesrganer = upscaler
+                timer.checkpoint("Initialize BG upscale model")
+
             self.face_enhancer = None
 
-            resolution = 512
             if face_restoration:
+                download_from_url(face_models[face_restoration][0], face_restoration, os.path.join("weights", "face"))
+                
+                resolution = 512
                 modelInUse = f"_{os.path.splitext(face_restoration)[0]}" + modelInUse
                 from gfpgan.utils import GFPGANer
                 model_rootpath = os.path.join("weights", "face")
@@ -696,6 +791,7 @@ class Upscale:
                         resolution = 2048
 
                 self.face_enhancer = GFPGANer(model_path=model_path, upscale=self.scale, arch=arch, channel_multiplier=channel_multiplier, model_rootpath=model_rootpath, det_model=face_detection, resolution=resolution)
+                timer.checkpoint("Initialize face enhancer model")
 
             files = []
             if not outputWithModelName:
@@ -703,9 +799,10 @@ class Upscale:
 
             try:
                 bg_upsample_img = None
-                if self.upsampler and hasattr(self.upsampler, "enhance"):
+                if self.realesrganer and hasattr(self.realesrganer, "enhance"):
                     from utils.dataops import auto_split_upscale
-                    bg_upsample_img, _ = auto_split_upscale(img, self.upsampler.enhance, self.scale) if is_auto_split_upscale else self.upsampler.enhance(img, outscale=self.scale)
+                    bg_upsample_img, _ = auto_split_upscale(img, self.realesrganer.enhance, self.scale) if is_auto_split_upscale else self.realesrganer.enhance(img, outscale=self.scale)
+                    timer.checkpoint("Background upscale Section")
 
                 if self.face_enhancer:
                     cropped_faces, restored_aligned, bg_upsample_img = self.face_enhancer.enhance(img, has_aligned=False, only_center_face=face_detection_only_center, paste_back=True, bg_upsample_img=bg_upsample_img, eye_dist_threshold=face_detection_threshold)
@@ -726,6 +823,7 @@ class Upscale:
                             files.append(save_crop_path)
                             files.append(save_restore_path)
                             files.append(save_cmp_path)
+                    timer.checkpoint("Face enhancer Section")
 
                 restored_img = bg_upsample_img
             except RuntimeError as error:
@@ -746,10 +844,11 @@ class Upscale:
 
             restored_img = cv2.cvtColor(restored_img, cv2.COLOR_BGR2RGB)
             files.append(save_path)
+            timer.report()  # Print all recorded times
             return files, files
         except Exception as error:
             print(traceback.format_exc())
-            print("global exception", error)
+            print("global exception: ", error)
             return None, None
 
     def find_max_numbers(self, state_dict, findkeys):
@@ -766,12 +865,70 @@ class Upscale:
 
         return tuple(max_values[findkey] for findkey in findkeys) if len(findkeys) > 1 else max_values[findkeys[0]]
 
+    def find_divisor_for_quotient(self, a: int, c: int):
+        """
+        Returns a number `b` such that `a // b == c`.
+        If `b` is an integer, return it as an `int`, otherwise return a `float`.
+        """
+        if c == 0:
+            raise ValueError("c cannot be zero to avoid division by zero.")
+
+        b_float = a / c
+
+        # Check if b is an integer
+        if b_float.is_integer():
+            return int(b_float)
+
+        # Try using ceil and floor
+        ceil_b = math.ceil(b_float)
+        floor_b = math.floor(b_float)
+
+        if a // ceil_b == c:
+            return ceil_b if ceil_b == b_float else float(ceil_b)
+        if a // floor_b == c:
+            return floor_b if floor_b == b_float else float(floor_b)
+
+        # account for rounding errors
+        if c == a // b_float:
+            return b_float
+        if c == a // (b_float - 0.01):
+            return b_float - 0.01
+        if c == a // (b_float + 0.01):
+            return b_float + 0.01
+
+        raise ValueError(f"Could not find a number b such that a // b == c. a={a}, c={c}")
+
     def imwriteUTF8(self, save_path, image): # `cv2.imwrite` does not support writing files to UTF-8 file paths.
         img_name = os.path.basename(save_path)
         _, extension = os.path.splitext(img_name)
         is_success, im_buf_arr = cv2.imencode(extension, image)
         if (is_success): im_buf_arr.tofile(save_path)
 
+class Timer:
+    def __init__(self):
+        self.start_time  = time.perf_counter()  # Record the start time
+        self.checkpoints = [("Start", self.start_time)]  # Store checkpoints
+
+    def checkpoint(self, label="Checkpoint"):
+        """Record a checkpoint with a given label."""
+        now = time.perf_counter()
+        self.checkpoints.append((label, now))
+
+    def report(self):
+        """Print all recorded checkpoints and total execution time with aligned formatting."""
+        print("\n> Execution Time Report:")
+
+        # Determine the max label width for alignment
+        max_label_length = max(len(label) for label, _ in self.checkpoints)
+
+        prev_time = self.start_time
+        for label, curr_time in self.checkpoints[1:]:
+            elapsed = curr_time - prev_time
+            print(f"{label.ljust(max_label_length)}: {elapsed:.3f} seconds")
+            prev_time = curr_time
+        
+        total_time = self.checkpoints[-1][1] - self.start_time
+        print(f"{'Total Execution Time'.ljust(max_label_length)}: {total_time:.3f} seconds\n")
 
 def main():
     if torch.cuda.is_available():
@@ -793,6 +950,13 @@ def main():
     Practically, the aforementioned algorithm is used to restore your **old photos** or improve **AI-generated faces**.<br>
     To use it, simply just upload the concerned image.<br>
     """
+    # Custom CSS to set the height of the gr.Dropdown menu
+    css = """
+    ul.options {
+        max-height: 500px !important;  /* Set the maximum height of the dropdown menu */
+        overflow-y: auto !important;   /* Enable vertical scrolling if the content exceeds the height */
+    }
+    """
 
     upscale = Upscale()
     
@@ -814,13 +978,13 @@ def main():
     upscale_model_header = f"| Upscale Model Name | Info, Type: {tmptype}, Model execution speed: {speed} | Download URL |\n|------------|------|--------------|"
     upscale_model_tables.append(upscale_model_header + "\n" + "\n".join(rows))
 
-    with gr.Blocks(title = title) as demo:
+    with gr.Blocks(title = title, css = css) as demo:
         gr.Markdown(value=f"<h1 style=\"text-align:center;\">{title}</h1><br>{description}")
         with gr.Row():
             with gr.Column(variant         ="panel"):
                 input_image                = gr.Image(type="filepath", label="Input", format="png")
-                face_model                 = gr.Dropdown(list(face_models.keys())+[None], type="value", value='GFPGANv1.4.pth', label='Face Restoration version', info="Face Restoration and RealESR can be freely combined in different ways, or one can be set to \"None\" to use only the other model. Face Restoration is primarily used for face restoration in real-life images, while RealESR serves as a background restoration model.")
-                upscale_model              = gr.Dropdown(list(typed_upscale_models.keys())+[None], type="value", value='SRVGG, realesr-general-x4v3.pth', label='UpScale version')
+                face_model                 = gr.Dropdown([None]+list(face_models.keys()), type="value", value='GFPGANv1.4.pth', label='Face Restoration version', info="Face Restoration and RealESR can be freely combined in different ways, or one can be set to \"None\" to use only the other model. Face Restoration is primarily used for face restoration in real-life images, while RealESR serves as a background restoration model.")
+                upscale_model              = gr.Dropdown([None]+list(typed_upscale_models.keys()), type="value", value='SRVGG, realesr-general-x4v3.pth', label='UpScale version')
                 upscale_scale              = gr.Number(label="Rescaling factor", value=4)
                 face_detection             = gr.Dropdown(["retinaface_resnet50", "YOLOv5l", "YOLOv5n"], type="value", value="retinaface_resnet50", label="Face Detection type")
                 face_detection_threshold   = gr.Number(label="Face eye dist threshold", value=10, info="A threshold to filter out faces with too small an eye distance (e.g., side faces).")

utils/dataops.py

@@ -39,16 +39,20 @@ def auto_split_upscale(
     overlap: int = 32,
     max_depth: int = None,
     current_depth: int = 1,
+    current_tile: int = 1,  # Tracks the current tile being processed
+    total_tiles: int = 1,  # Total number of tiles at this depth level
 ):
     # Attempt to upscale if unknown depth or if reached known max depth
     if max_depth is None or max_depth == current_depth:
         try:
-            print(f"auto_split_upscale, current depth: {current_depth}")
+            print(f"auto_split_upscale depth: {current_depth}", end=" ", flush=True)
             result, _ = upscale_function(lr_img, scale)
+            print(f"progress: {current_tile}/{total_tiles}")
             return result, current_depth
         except RuntimeError as e:
             # Check to see if its actually the CUDA out of memory error
             if "CUDA" in str(e):
+                print("RuntimeError: CUDA out of memory...")
                 # Collect garbage (clear VRAM)
                 torch.cuda.empty_cache()
                 gc.collect()
@@ -60,68 +64,47 @@ def auto_split_upscale(
             torch.cuda.empty_cache()
             gc.collect()
 
-    h, w, c = lr_img.shape
-
-    # Split image into 4ths
-    top_left = lr_img[: h // 2 + overlap, : w // 2 + overlap, :]
-    top_right = lr_img[: h // 2 + overlap, w // 2 - overlap :, :]
-    bottom_left = lr_img[h // 2 - overlap :, : w // 2 + overlap, :]
-    bottom_right = lr_img[h // 2 - overlap :, w // 2 - overlap :, :]
-
-    # Recursively upscale the quadrants
+    input_h, input_w, input_c = lr_img.shape
+    
+    # Split the image into 4 quadrants with some overlap
+    top_left      = lr_img[: input_h // 2 + overlap, : input_w // 2 + overlap, :]
+    top_right     = lr_img[: input_h // 2 + overlap, input_w // 2 - overlap :, :]
+    bottom_left   = lr_img[input_h // 2 - overlap :, : input_w // 2 + overlap, :]
+    bottom_right  = lr_img[input_h // 2 - overlap :, input_w // 2 - overlap :, :]
+    current_depth = current_depth + 1
+    current_tile  = (current_tile - 1) * 4
+    total_tiles   = total_tiles * 4
+
+    # Recursively upscale each quadrant and track the current tile number
     # After we go through the top left quadrant, we know the maximum depth and no longer need to test for out-of-memory
     top_left_rlt, depth = auto_split_upscale(
-        top_left,
-        upscale_function,
-        scale=scale,
-        overlap=overlap,
-        max_depth=max_depth,
-        current_depth=current_depth + 1,
+        top_left, upscale_function, scale=scale, overlap=overlap, max_depth=max_depth,
+        current_depth=current_depth, current_tile=current_tile + 1, total_tiles=total_tiles,
     )
     top_right_rlt, _ = auto_split_upscale(
-        top_right,
-        upscale_function,
-        scale=scale,
-        overlap=overlap,
-        max_depth=depth,
-        current_depth=current_depth + 1,
+        top_right, upscale_function, scale=scale, overlap=overlap, max_depth=depth,
+        current_depth=current_depth, current_tile=current_tile + 2, total_tiles=total_tiles,
     )
     bottom_left_rlt, _ = auto_split_upscale(
-        bottom_left,
-        upscale_function,
-        scale=scale,
-        overlap=overlap,
-        max_depth=depth,
-        current_depth=current_depth + 1,
+        bottom_left, upscale_function, scale=scale, overlap=overlap, max_depth=depth,
+        current_depth=current_depth, current_tile=current_tile + 3, total_tiles=total_tiles,
     )
     bottom_right_rlt, _ = auto_split_upscale(
-        bottom_right,
-        upscale_function,
-        scale=scale,
-        overlap=overlap,
-        max_depth=depth,
-        current_depth=current_depth + 1,
+        bottom_right, upscale_function, scale=scale, overlap=overlap, max_depth=depth,
+        current_depth=current_depth, current_tile=current_tile + 4, total_tiles=total_tiles,
     )
-
-    # Define output shape
-    out_h = h * scale
-    out_w = w * scale
-
-    # Create blank output image
-    output_img = np.zeros((out_h, out_w, c), np.uint8)
-
-    # Fill output image with tiles, cropping out the overlaps
-    output_img[: out_h // 2, : out_w // 2, :] = top_left_rlt[
-        : out_h // 2, : out_w // 2, :
-    ]
-    output_img[: out_h // 2, -out_w // 2 :, :] = top_right_rlt[
-        : out_h // 2, -out_w // 2 :, :
-    ]
-    output_img[-out_h // 2 :, : out_w // 2, :] = bottom_left_rlt[
-        -out_h // 2 :, : out_w // 2, :
-    ]
-    output_img[-out_h // 2 :, -out_w // 2 :, :] = bottom_right_rlt[
-        -out_h // 2 :, -out_w // 2 :, :
-    ]
+    
+    # Define the output image size
+    out_h = input_h * scale
+    out_w = input_w * scale
+    
+    # Create an empty output image
+    output_img = np.zeros((out_h, out_w, input_c), np.uint8)
+
+    # Fill the output image with the upscaled quadrants, removing overlap regions
+    output_img[: out_h // 2, : out_w // 2, :]   = top_left_rlt[: out_h // 2, : out_w // 2, :]
+    output_img[: out_h // 2, -out_w // 2 :, :]  = top_right_rlt[: out_h // 2, -out_w // 2 :, :]
+    output_img[-out_h // 2 :, : out_w // 2, :]  = bottom_left_rlt[-out_h // 2 :, : out_w // 2, :]
+    output_img[-out_h // 2 :, -out_w // 2 :, :] = bottom_right_rlt[-out_h // 2 :, -out_w // 2 :, :]
 
     return output_img, depth