From bfb7f15d46048f27338eeac3a591a5943d03c5f1 Mon Sep 17 00:00:00 2001
From: d8ahazard <d8ahazard@gmail.com>
Date: Mon, 26 Sep 2022 09:29:22 -0500
Subject: Rename swinir -> swinir_model

---
 modules/swinir_model.py | 123 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 123 insertions(+)
 create mode 100644 modules/swinir_model.py

(limited to 'modules/swinir_model.py')

diff --git a/modules/swinir_model.py b/modules/swinir_model.py
new file mode 100644
index 00000000..e86d0789
--- /dev/null
+++ b/modules/swinir_model.py
@@ -0,0 +1,123 @@
+import sys
+import traceback
+import cv2
+import os
+import contextlib
+import numpy as np
+from PIL import Image
+import torch
+import modules.images
+from modules.shared import cmd_opts, opts, device
+from modules.swinir_arch import SwinIR as net
+
+precision_scope = (
+    torch.autocast if cmd_opts.precision == "autocast" else contextlib.nullcontext
+)
+
+
+def load_model(filename, scale=4):
+    model = net(
+        upscale=scale,
+        in_chans=3,
+        img_size=64,
+        window_size=8,
+        img_range=1.0,
+        depths=[6, 6, 6, 6, 6, 6, 6, 6, 6],
+        embed_dim=240,
+        num_heads=[8, 8, 8, 8, 8, 8, 8, 8, 8],
+        mlp_ratio=2,
+        upsampler="nearest+conv",
+        resi_connection="3conv",
+    )
+
+    pretrained_model = torch.load(filename)
+    model.load_state_dict(pretrained_model["params_ema"], strict=True)
+    if not cmd_opts.no_half:
+        model = model.half()
+    return model
+
+
+def load_models(dirname):
+    for file in os.listdir(dirname):
+        path = os.path.join(dirname, file)
+        model_name, extension = os.path.splitext(file)
+
+        if extension != ".pt" and extension != ".pth":
+            continue
+
+        try:
+            modules.shared.sd_upscalers.append(UpscalerSwin(path, model_name))
+        except Exception:
+            print(f"Error loading SwinIR model: {path}", file=sys.stderr)
+            print(traceback.format_exc(), file=sys.stderr)
+
+
+def upscale(
+    img,
+    model,
+    tile=opts.SWIN_tile,
+    tile_overlap=opts.SWIN_tile_overlap,
+    window_size=8,
+    scale=4,
+):
+    img = np.array(img)
+    img = img[:, :, ::-1]
+    img = np.moveaxis(img, 2, 0) / 255
+    img = torch.from_numpy(img).float()
+    img = img.unsqueeze(0).to(device)
+    with torch.no_grad(), precision_scope("cuda"):
+        _, _, h_old, w_old = img.size()
+        h_pad = (h_old // window_size + 1) * window_size - h_old
+        w_pad = (w_old // window_size + 1) * window_size - w_old
+        img = torch.cat([img, torch.flip(img, [2])], 2)[:, :, : h_old + h_pad, :]
+        img = torch.cat([img, torch.flip(img, [3])], 3)[:, :, :, : w_old + w_pad]
+        output = inference(img, model, tile, tile_overlap, window_size, scale)
+        output = output[..., : h_old * scale, : w_old * scale]
+        output = output.data.squeeze().float().cpu().clamp_(0, 1).numpy()
+        if output.ndim == 3:
+            output = np.transpose(
+                output[[2, 1, 0], :, :], (1, 2, 0)
+            )  # CHW-RGB to HCW-BGR
+        output = (output * 255.0).round().astype(np.uint8)  # float32 to uint8
+        return Image.fromarray(output, "RGB")
+
+
+def inference(img, model, tile, tile_overlap, window_size, scale):
+    # test the image tile by tile
+    b, c, h, w = img.size()
+    tile = min(tile, h, w)
+    assert tile % window_size == 0, "tile size should be a multiple of window_size"
+    sf = scale
+
+    stride = tile - tile_overlap
+    h_idx_list = list(range(0, h - tile, stride)) + [h - tile]
+    w_idx_list = list(range(0, w - tile, stride)) + [w - tile]
+    E = torch.zeros(b, c, h * sf, w * sf, dtype=torch.half, device=device).type_as(img)
+    W = torch.zeros_like(E, dtype=torch.half, device=device)
+
+    for h_idx in h_idx_list:
+        for w_idx in w_idx_list:
+            in_patch = img[..., h_idx : h_idx + tile, w_idx : w_idx + tile]
+            out_patch = model(in_patch)
+            out_patch_mask = torch.ones_like(out_patch)
+
+            E[
+                ..., h_idx * sf : (h_idx + tile) * sf, w_idx * sf : (w_idx + tile) * sf
+            ].add_(out_patch)
+            W[
+                ..., h_idx * sf : (h_idx + tile) * sf, w_idx * sf : (w_idx + tile) * sf
+            ].add_(out_patch_mask)
+    output = E.div_(W)
+
+    return output
+
+
+class UpscalerSwin(modules.images.Upscaler):
+    def __init__(self, filename, title):
+        self.name = title
+        self.model = load_model(filename)
+
+    def do_upscale(self, img):
+        model = self.model.to(device)
+        img = upscale(img, model)
+        return img
-- 
cgit v1.2.3


From 740070ea9cdb254209f66417418f2a4af8b099d6 Mon Sep 17 00:00:00 2001
From: d8ahazard <d8ahazard@gmail.com>
Date: Mon, 26 Sep 2022 09:29:50 -0500
Subject: Re-implement universal model loading

---
 modules/swinir_model.py | 75 ++++++++++++++++++++++++++++++++++++-------------
 1 file changed, 55 insertions(+), 20 deletions(-)

(limited to 'modules/swinir_model.py')

diff --git a/modules/swinir_model.py b/modules/swinir_model.py
index e86d0789..f515779e 100644
--- a/modules/swinir_model.py
+++ b/modules/swinir_model.py
@@ -1,21 +1,39 @@
+import contextlib
+import os
 import sys
 import traceback
-import cv2
-import os
-import contextlib
+
 import numpy as np
-from PIL import Image
 import torch
+from PIL import Image
+from basicsr.utils.download_util import load_file_from_url
+
 import modules.images
+from modules import modelloader
+from modules.paths import models_path
 from modules.shared import cmd_opts, opts, device
-from modules.swinir_arch import SwinIR as net
+from modules.swinir_model_arch import SwinIR as net
 
+model_dir = "SwinIR"
+model_url = "https://github.com/JingyunLiang/SwinIR/releases/download/v0.0/003_realSR_BSRGAN_DFOWMFC_s64w8_SwinIR-L_x4_GAN.pth"
+model_name = "SwinIR x4"
+model_path = os.path.join(models_path, model_dir)
+cmd_path = ""
 precision_scope = (
     torch.autocast if cmd_opts.precision == "autocast" else contextlib.nullcontext
 )
 
 
-def load_model(filename, scale=4):
+def load_model(path, scale=4):
+    global model_path
+    global model_name
+    if "http" in path:
+        dl_name = "%s%s" % (model_name.replace(" ", "_"), ".pth")
+        filename = load_file_from_url(url=path, model_dir=model_path, file_name=dl_name, progress=True)
+    else:
+        filename = path
+    if filename is None or not os.path.exists(filename):
+        return None
     model = net(
         upscale=scale,
         in_chans=3,
@@ -37,19 +55,29 @@ def load_model(filename, scale=4):
     return model
 
 
-def load_models(dirname):
-    for file in os.listdir(dirname):
-        path = os.path.join(dirname, file)
-        model_name, extension = os.path.splitext(file)
+def setup_model(dirname):
+    global model_path
+    global model_name
+    global cmd_path
+    if not os.path.exists(model_path):
+        os.makedirs(model_path)
+    cmd_path = dirname
+    model_file = ""
+    try:
+        models = modelloader.load_models(model_path, ext_filter=[".pt", ".pth"], command_path=cmd_path)
 
-        if extension != ".pt" and extension != ".pth":
-            continue
+        if len(models) != 0:
+            model_file = models[0]
+            name = modelloader.friendly_name(model_file)
+        else:
+            # Add the "default" model if none are found.
+            model_file = model_url
+            name = model_name
 
-        try:
-            modules.shared.sd_upscalers.append(UpscalerSwin(path, model_name))
-        except Exception:
-            print(f"Error loading SwinIR model: {path}", file=sys.stderr)
-            print(traceback.format_exc(), file=sys.stderr)
+        modules.shared.sd_upscalers.append(UpscalerSwin(model_file, name))
+    except Exception:
+        print(f"Error loading SwinIR model: {model_file}", file=sys.stderr)
+        print(traceback.format_exc(), file=sys.stderr)
 
 
 def upscale(
@@ -115,9 +143,16 @@ def inference(img, model, tile, tile_overlap, window_size, scale):
 class UpscalerSwin(modules.images.Upscaler):
     def __init__(self, filename, title):
         self.name = title
-        self.model = load_model(filename)
+        self.filename = filename
 
     def do_upscale(self, img):
-        model = self.model.to(device)
+        model = load_model(self.filename)
+        if model is None:
+            return img
+        model = model.to(device)
         img = upscale(img, model)
-        return img
+        try:
+            torch.cuda.empty_cache()
+        except:
+            pass
+        return img
\ No newline at end of file
-- 
cgit v1.2.3


From 0dce0df1ee63b2f158805c1a1f1a3743cc4a104b Mon Sep 17 00:00:00 2001
From: d8ahazard <d8ahazard@gmail.com>
Date: Thu, 29 Sep 2022 17:46:23 -0500
Subject: Holy $hit.

Yep.

Fix gfpgan_model_arch requirement(s).
Add Upscaler base class, move from images.
Add a lot of methods to Upscaler.
Re-work all the child upscalers to be proper classes.
Add BSRGAN scaler.
Add ldsr_model_arch class, removing the dependency for another repo that just uses regular latent-diffusion stuff.
Add one universal method that will always find and load new upscaler models without having to add new "setup_model" calls. Still need to add command line params, but that could probably be automated.
Add a "self.scale" property to all Upscalers so the scalers themselves can do "things" in response to the requested upscaling size.
Ensure LDSR doesn't get stuck in a longer loop of "upscale/downscale/upscale" as we try to reach the target upscale size.
Add typehints for IDE sanity.
PEP-8 improvements.
Moar.
---
 modules/swinir_model.py | 157 +++++++++++++++++++++---------------------------
 1 file changed, 69 insertions(+), 88 deletions(-)

(limited to 'modules/swinir_model.py')

diff --git a/modules/swinir_model.py b/modules/swinir_model.py
index f515779e..ea7b6301 100644
--- a/modules/swinir_model.py
+++ b/modules/swinir_model.py
@@ -1,92 +1,91 @@
 import contextlib
 import os
-import sys
-import traceback
 
 import numpy as np
 import torch
 from PIL import Image
 from basicsr.utils.download_util import load_file_from_url
 
-import modules.images
 from modules import modelloader
 from modules.paths import models_path
 from modules.shared import cmd_opts, opts, device
 from modules.swinir_model_arch import SwinIR as net
+from modules.upscaler import Upscaler, UpscalerData
 
-model_dir = "SwinIR"
-model_url = "https://github.com/JingyunLiang/SwinIR/releases/download/v0.0/003_realSR_BSRGAN_DFOWMFC_s64w8_SwinIR-L_x4_GAN.pth"
-model_name = "SwinIR x4"
-model_path = os.path.join(models_path, model_dir)
-cmd_path = ""
 precision_scope = (
     torch.autocast if cmd_opts.precision == "autocast" else contextlib.nullcontext
 )
 
 
-def load_model(path, scale=4):
-    global model_path
-    global model_name
-    if "http" in path:
-        dl_name = "%s%s" % (model_name.replace(" ", "_"), ".pth")
-        filename = load_file_from_url(url=path, model_dir=model_path, file_name=dl_name, progress=True)
-    else:
-        filename = path
-    if filename is None or not os.path.exists(filename):
-        return None
-    model = net(
-        upscale=scale,
-        in_chans=3,
-        img_size=64,
-        window_size=8,
-        img_range=1.0,
-        depths=[6, 6, 6, 6, 6, 6, 6, 6, 6],
-        embed_dim=240,
-        num_heads=[8, 8, 8, 8, 8, 8, 8, 8, 8],
-        mlp_ratio=2,
-        upsampler="nearest+conv",
-        resi_connection="3conv",
-    )
-
-    pretrained_model = torch.load(filename)
-    model.load_state_dict(pretrained_model["params_ema"], strict=True)
-    if not cmd_opts.no_half:
-        model = model.half()
-    return model
-
-
-def setup_model(dirname):
-    global model_path
-    global model_name
-    global cmd_path
-    if not os.path.exists(model_path):
-        os.makedirs(model_path)
-    cmd_path = dirname
-    model_file = ""
-    try:
-        models = modelloader.load_models(model_path, ext_filter=[".pt", ".pth"], command_path=cmd_path)
-
-        if len(models) != 0:
-            model_file = models[0]
-            name = modelloader.friendly_name(model_file)
-        else:
-            # Add the "default" model if none are found.
-            model_file = model_url
-            name = model_name
+class UpscalerSwinIR(Upscaler):
+    def __init__(self, dirname):
+        self.name = "SwinIR"
+        self.model_url = "https://github.com/JingyunLiang/SwinIR/releases/download/v0.0" \
+                         "/003_realSR_BSRGAN_DFOWMFC_s64w8_SwinIR" \
+                         "-L_x4_GAN.pth "
+        self.model_name = "SwinIR 4x"
+        self.model_path = os.path.join(models_path, self.name)
+        self.user_path = dirname
+        super().__init__()
+        scalers = []
+        model_files = self.find_models(ext_filter=[".pt", ".pth"])
+        for model in model_files:
+            if "http" in model:
+                name = self.model_name
+            else:
+                name = modelloader.friendly_name(model)
+            model_data = UpscalerData(name, model, self)
+            scalers.append(model_data)
+        self.scalers = scalers
+
+    def do_upscale(self, img, model_file):
+        model = self.load_model(model_file)
+        if model is None:
+            return img
+        model = model.to(device)
+        img = upscale(img, model)
+        try:
+            torch.cuda.empty_cache()
+        except:
+            pass
+        return img
 
-        modules.shared.sd_upscalers.append(UpscalerSwin(model_file, name))
-    except Exception:
-        print(f"Error loading SwinIR model: {model_file}", file=sys.stderr)
-        print(traceback.format_exc(), file=sys.stderr)
+    def load_model(self, path, scale=4):
+        if "http" in path:
+            dl_name = "%s%s" % (self.name.replace(" ", "_"), ".pth")
+            filename = load_file_from_url(url=path, model_dir=self.model_path, file_name=dl_name, progress=True)
+        else:
+            filename = path
+        if filename is None or not os.path.exists(filename):
+            return None
+        model = net(
+            upscale=scale,
+            in_chans=3,
+            img_size=64,
+            window_size=8,
+            img_range=1.0,
+            depths=[6, 6, 6, 6, 6, 6, 6, 6, 6],
+            embed_dim=240,
+            num_heads=[8, 8, 8, 8, 8, 8, 8, 8, 8],
+            mlp_ratio=2,
+            upsampler="nearest+conv",
+            resi_connection="3conv",
+        )
+
+        pretrained_model = torch.load(filename)
+        model.load_state_dict(pretrained_model["params_ema"], strict=True)
+        if not cmd_opts.no_half:
+            model = model.half()
+        return model
 
 
 def upscale(
-    img,
-    model,
-    tile=opts.SWIN_tile,
-    tile_overlap=opts.SWIN_tile_overlap,
-    window_size=8,
-    scale=4,
+        img,
+        model,
+        tile=opts.SWIN_tile,
+        tile_overlap=opts.SWIN_tile_overlap,
+        window_size=8,
+        scale=4,
 ):
     img = np.array(img)
     img = img[:, :, ::-1]
@@ -125,34 +124,16 @@ def inference(img, model, tile, tile_overlap, window_size, scale):
 
     for h_idx in h_idx_list:
         for w_idx in w_idx_list:
-            in_patch = img[..., h_idx : h_idx + tile, w_idx : w_idx + tile]
+            in_patch = img[..., h_idx: h_idx + tile, w_idx: w_idx + tile]
             out_patch = model(in_patch)
             out_patch_mask = torch.ones_like(out_patch)
 
             E[
-                ..., h_idx * sf : (h_idx + tile) * sf, w_idx * sf : (w_idx + tile) * sf
+            ..., h_idx * sf: (h_idx + tile) * sf, w_idx * sf: (w_idx + tile) * sf
             ].add_(out_patch)
             W[
-                ..., h_idx * sf : (h_idx + tile) * sf, w_idx * sf : (w_idx + tile) * sf
+            ..., h_idx * sf: (h_idx + tile) * sf, w_idx * sf: (w_idx + tile) * sf
             ].add_(out_patch_mask)
     output = E.div_(W)
 
     return output
-
-
-class UpscalerSwin(modules.images.Upscaler):
-    def __init__(self, filename, title):
-        self.name = title
-        self.filename = filename
-
-    def do_upscale(self, img):
-        model = load_model(self.filename)
-        if model is None:
-            return img
-        model = model.to(device)
-        img = upscale(img, model)
-        try:
-            torch.cuda.empty_cache()
-        except:
-            pass
-        return img
\ No newline at end of file
-- 
cgit v1.2.3


From 435fd2112aee9a0e61408ac56663e41beea1e446 Mon Sep 17 00:00:00 2001
From: d8ahazard <d8ahazard@gmail.com>
Date: Thu, 29 Sep 2022 19:59:53 -0500
Subject: Fixes, cleanup.

---
 modules/swinir_model.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'modules/swinir_model.py')

diff --git a/modules/swinir_model.py b/modules/swinir_model.py
index ea7b6301..41fda5a7 100644
--- a/modules/swinir_model.py
+++ b/modules/swinir_model.py
@@ -52,7 +52,7 @@ class UpscalerSwinIR(Upscaler):
 
     def load_model(self, path, scale=4):
         if "http" in path:
-            dl_name = "%s%s" % (self.name.replace(" ", "_"), ".pth")
+            dl_name = "%s%s" % (self.model_name.replace(" ", "_"), ".pth")
             filename = load_file_from_url(url=path, model_dir=self.model_path, file_name=dl_name, progress=True)
         else:
             filename = path
-- 
cgit v1.2.3


From 121ed7d36febe94995774973b5edc1ba2ba84aad Mon Sep 17 00:00:00 2001
From: Alexandre Simard <as.simard@outlook.com>
Date: Sat, 1 Oct 2022 14:04:20 -0400
Subject: Add progress bar for SwinIR in cmd

I do not know how to add them to the UI...
---
 modules/swinir_model.py | 27 +++++++++++++++------------
 1 file changed, 15 insertions(+), 12 deletions(-)

(limited to 'modules/swinir_model.py')

diff --git a/modules/swinir_model.py b/modules/swinir_model.py
index 41fda5a7..9bd454c6 100644
--- a/modules/swinir_model.py
+++ b/modules/swinir_model.py
@@ -5,6 +5,7 @@ import numpy as np
 import torch
 from PIL import Image
 from basicsr.utils.download_util import load_file_from_url
+from tqdm import tqdm
 
 from modules import modelloader
 from modules.paths import models_path
@@ -122,18 +123,20 @@ def inference(img, model, tile, tile_overlap, window_size, scale):
     E = torch.zeros(b, c, h * sf, w * sf, dtype=torch.half, device=device).type_as(img)
     W = torch.zeros_like(E, dtype=torch.half, device=device)
 
-    for h_idx in h_idx_list:
-        for w_idx in w_idx_list:
-            in_patch = img[..., h_idx: h_idx + tile, w_idx: w_idx + tile]
-            out_patch = model(in_patch)
-            out_patch_mask = torch.ones_like(out_patch)
-
-            E[
-            ..., h_idx * sf: (h_idx + tile) * sf, w_idx * sf: (w_idx + tile) * sf
-            ].add_(out_patch)
-            W[
-            ..., h_idx * sf: (h_idx + tile) * sf, w_idx * sf: (w_idx + tile) * sf
-            ].add_(out_patch_mask)
+    with tqdm(total=len(h_idx_list) * len(w_idx_list), desc="SwinIR tiles") as pbar:
+        for h_idx in h_idx_list:
+            for w_idx in w_idx_list:
+                in_patch = img[..., h_idx: h_idx + tile, w_idx: w_idx + tile]
+                out_patch = model(in_patch)
+                out_patch_mask = torch.ones_like(out_patch)
+
+                E[
+                ..., h_idx * sf: (h_idx + tile) * sf, w_idx * sf: (w_idx + tile) * sf
+                ].add_(out_patch)
+                W[
+                ..., h_idx * sf: (h_idx + tile) * sf, w_idx * sf: (w_idx + tile) * sf
+                ].add_(out_patch_mask)
+                pbar.update(1)
     output = E.div_(W)
 
     return output
-- 
cgit v1.2.3