v1.3.8

README.md

@@ -35,7 +35,9 @@ It leverages rich and diverse priors encapsulated in a pretrained face GAN (*e.g
 
 :triangular_flag_on_post: **Updates**
 
-- :fire::fire::white_check_mark: Add **[V1.3 model](https://github.com/TencentARC/GFPGAN/releases/download/v1.3.0/GFPGANv1.3.pth)**, which produces **more natural** restoration results, and better results on *very low-quality* / *high-quality* inputs. See more in [Model zoo](#european_castle-model-zoo), [Comparisons.md](Comparisons.md)
+- :white_check_mark: Add [RestoreFormer](https://github.com/wzhouxiff/RestoreFormer) inference codes.
+- :white_check_mark: Add [V1.4 model](https://github.com/TencentARC/GFPGAN/releases/download/v1.3.0/GFPGANv1.4.pth), which produces slightly more details and better identity than V1.3.
+- :white_check_mark: Add **[V1.3 model](https://github.com/TencentARC/GFPGAN/releases/download/v1.3.0/GFPGANv1.3.pth)**, which produces **more natural** restoration results, and better results on *very low-quality* / *high-quality* inputs. See more in [Model zoo](#european_castle-model-zoo), [Comparisons.md](Comparisons.md)
 - :white_check_mark: Integrated to [Huggingface Spaces](https://huggingface.co/spaces) with [Gradio](https://github.com/gradio-app/gradio). See [Gradio Web Demo](https://huggingface.co/spaces/akhaliq/GFPGAN).
 - :white_check_mark: Support enhancing non-face regions (background) with [Real-ESRGAN](https://github.com/xinntao/Real-ESRGAN).
 - :white_check_mark: We provide a *clean* version of GFPGAN, which does not require CUDA extensions.

VERSION

@@ -1 +1 @@
-1.3.5
+1.3.8

cog_predict.py

@@ -27,6 +27,7 @@ except Exception:
 class Predictor(BasePredictor):
 
     def setup(self):
+        os.makedirs('output', exist_ok=True)
         # download weights
         if not os.path.exists('gfpgan/weights/realesr-general-x4v3.pth'):
             os.system(
@@ -41,6 +42,10 @@ class Predictor(BasePredictor):
         if not os.path.exists('gfpgan/weights/GFPGANv1.4.pth'):
             os.system(
                 'wget https://github.com/TencentARC/GFPGAN/releases/download/v1.3.0/GFPGANv1.4.pth -P ./gfpgan/weights')
+        if not os.path.exists('gfpgan/weights/RestoreFormer.pth'):
+            os.system(
+                'wget https://github.com/TencentARC/GFPGAN/releases/download/v1.3.4/RestoreFormer.pth -P ./gfpgan/weights'
+            )
 
         # background enhancer with RealESRGAN
         model = SRVGGNetCompact(num_in_ch=3, num_out_ch=3, num_feat=64, num_conv=32, upscale=4, act_type='prelu')
@@ -59,19 +64,24 @@ class Predictor(BasePredictor):
         self.current_version = 'v1.4'
 
     def predict(
-        self,
-        img: Path = Input(description='Input'),
-        version: str = Input(
-            description='GFPGAN version. v1.3: better quality. v1.4: more details and better identity.',
-            choices=['v1.2', 'v1.3', 'v1.4'],
-            default='v1.4'),
-        scale: float = Input(description='Rescaling factor', default=2)
+            self,
+            img: Path = Input(description='Input'),
+            version: str = Input(
+                description='GFPGAN version. v1.3: better quality. v1.4: more details and better identity.',
+                choices=['v1.2', 'v1.3', 'v1.4', 'RestoreFormer'],
+                default='v1.4'),
+            scale: float = Input(description='Rescaling factor', default=2),
     ) -> Path:
-        print(img, version, scale)
+        weight = 0.5
+        print(img, version, scale, weight)
         try:
+            extension = os.path.splitext(os.path.basename(str(img)))[1]
             img = cv2.imread(str(img), cv2.IMREAD_UNCHANGED)
             if len(img.shape) == 3 and img.shape[2] == 4:
                 img_mode = 'RGBA'
+            elif len(img.shape) == 2:
+                img_mode = None
+                img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
             else:
                 img_mode = None
 
@@ -104,14 +114,19 @@ class Predictor(BasePredictor):
                         channel_multiplier=2,
                         bg_upsampler=self.upsampler)
                     self.current_version = 'v1.4'
+                elif version == 'RestoreFormer':
+                    self.face_enhancer = GFPGANer(
+                        model_path='gfpgan/weights/RestoreFormer.pth',
+                        upscale=2,
+                        arch='RestoreFormer',
+                        channel_multiplier=2,
+                        bg_upsampler=self.upsampler)
 
             try:
                 _, _, output = self.face_enhancer.enhance(
-                    img, has_aligned=False, only_center_face=False, paste_back=True)
+                    img, has_aligned=False, only_center_face=False, paste_back=True, weight=weight)
             except RuntimeError as error:
                 print('Error', error)
-            else:
-                extension = 'png'
 
             try:
                 if scale != 2:
@@ -120,16 +135,15 @@ class Predictor(BasePredictor):
                     output = cv2.resize(output, (int(w * scale / 2), int(h * scale / 2)), interpolation=interpolation)
             except Exception as error:
                 print('wrong scale input.', error)
+
             if img_mode == 'RGBA':  # RGBA images should be saved in png format
                 extension = 'png'
-            else:
-                extension = 'jpg'
-            save_path = f'output/out.{extension}'
-            cv2.imwrite(save_path, output)
-            out_path = Path(tempfile.mkdtemp()) / 'output.png'
+            # save_path = f'output/out.{extension}'
+            # cv2.imwrite(save_path, output)
+            out_path = Path(tempfile.mkdtemp()) / f'out.{extension}'
             cv2.imwrite(str(out_path), output)
         except Exception as error:
-            print('global exception', error)
+            print('global exception: ', error)
         finally:
             clean_folder('output')
         return out_path

gfpgan/archs/gfpganv1_arch.py

@@ -350,7 +350,7 @@ class GFPGANv1(nn.Module):
                     ScaledLeakyReLU(0.2),
                     EqualConv2d(out_channels, sft_out_channels, 3, stride=1, padding=1, bias=True, bias_init_val=0)))
 
-    def forward(self, x, return_latents=False, return_rgb=True, randomize_noise=True):
+    def forward(self, x, return_latents=False, return_rgb=True, randomize_noise=True, **kwargs):
         """Forward function for GFPGANv1.
 
         Args:
@@ -416,7 +416,7 @@ class FacialComponentDiscriminator(nn.Module):
         self.conv5 = ConvLayer(256, 256, 3, downsample=False, resample_kernel=(1, 3, 3, 1), bias=True, activate=True)
         self.final_conv = ConvLayer(256, 1, 3, bias=True, activate=False)
 
-    def forward(self, x, return_feats=False):
+    def forward(self, x, return_feats=False, **kwargs):
         """Forward function for FacialComponentDiscriminator.
 
         Args:

gfpgan/archs/gfpganv1_clean_arch.py

@@ -274,7 +274,7 @@ class GFPGANv1Clean(nn.Module):
                     nn.Conv2d(out_channels, out_channels, 3, 1, 1), nn.LeakyReLU(0.2, True),
                     nn.Conv2d(out_channels, sft_out_channels, 3, 1, 1)))
 
-    def forward(self, x, return_latents=False, return_rgb=True, randomize_noise=True):
+    def forward(self, x, return_latents=False, return_rgb=True, randomize_noise=True, **kwargs):
         """Forward function for GFPGANv1Clean.
 
         Args:

gfpgan/archs/restoreformer_arch.py

@@ -0,0 +1,658 @@
+"""Modified from https://github.com/wzhouxiff/RestoreFormer
+"""
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class VectorQuantizer(nn.Module):
+    """
+    see https://github.com/MishaLaskin/vqvae/blob/d761a999e2267766400dc646d82d3ac3657771d4/models/quantizer.py
+    ____________________________________________
+    Discretization bottleneck part of the VQ-VAE.
+    Inputs:
+    - n_e : number of embeddings
+    - e_dim : dimension of embedding
+    - beta : commitment cost used in loss term, beta * ||z_e(x)-sg[e]||^2
+    _____________________________________________
+    """
+
+    def __init__(self, n_e, e_dim, beta):
+        super(VectorQuantizer, self).__init__()
+        self.n_e = n_e
+        self.e_dim = e_dim
+        self.beta = beta
+
+        self.embedding = nn.Embedding(self.n_e, self.e_dim)
+        self.embedding.weight.data.uniform_(-1.0 / self.n_e, 1.0 / self.n_e)
+
+    def forward(self, z):
+        """
+        Inputs the output of the encoder network z and maps it to a discrete
+        one-hot vector that is the index of the closest embedding vector e_j
+        z (continuous) -> z_q (discrete)
+        z.shape = (batch, channel, height, width)
+        quantization pipeline:
+            1. get encoder input (B,C,H,W)
+            2. flatten input to (B*H*W,C)
+        """
+        # reshape z -> (batch, height, width, channel) and flatten
+        z = z.permute(0, 2, 3, 1).contiguous()
+        z_flattened = z.view(-1, self.e_dim)
+        # distances from z to embeddings e_j (z - e)^2 = z^2 + e^2 - 2 e * z
+
+        d = torch.sum(z_flattened ** 2, dim=1, keepdim=True) + \
+            torch.sum(self.embedding.weight**2, dim=1) - 2 * \
+            torch.matmul(z_flattened, self.embedding.weight.t())
+
+        # could possible replace this here
+        # #\start...
+        # find closest encodings
+
+        min_value, min_encoding_indices = torch.min(d, dim=1)
+
+        min_encoding_indices = min_encoding_indices.unsqueeze(1)
+
+        min_encodings = torch.zeros(min_encoding_indices.shape[0], self.n_e).to(z)
+        min_encodings.scatter_(1, min_encoding_indices, 1)
+
+        # dtype min encodings: torch.float32
+        # min_encodings shape: torch.Size([2048, 512])
+        # min_encoding_indices.shape: torch.Size([2048, 1])
+
+        # get quantized latent vectors
+        z_q = torch.matmul(min_encodings, self.embedding.weight).view(z.shape)
+        # .........\end
+
+        # with:
+        # .........\start
+        # min_encoding_indices = torch.argmin(d, dim=1)
+        # z_q = self.embedding(min_encoding_indices)
+        # ......\end......... (TODO)
+
+        # compute loss for embedding
+        loss = torch.mean((z_q.detach() - z)**2) + self.beta * torch.mean((z_q - z.detach())**2)
+
+        # preserve gradients
+        z_q = z + (z_q - z).detach()
+
+        # perplexity
+
+        e_mean = torch.mean(min_encodings, dim=0)
+        perplexity = torch.exp(-torch.sum(e_mean * torch.log(e_mean + 1e-10)))
+
+        # reshape back to match original input shape
+        z_q = z_q.permute(0, 3, 1, 2).contiguous()
+
+        return z_q, loss, (perplexity, min_encodings, min_encoding_indices, d)
+
+    def get_codebook_entry(self, indices, shape):
+        # shape specifying (batch, height, width, channel)
+        # TODO: check for more easy handling with nn.Embedding
+        min_encodings = torch.zeros(indices.shape[0], self.n_e).to(indices)
+        min_encodings.scatter_(1, indices[:, None], 1)
+
+        # get quantized latent vectors
+        z_q = torch.matmul(min_encodings.float(), self.embedding.weight)
+
+        if shape is not None:
+            z_q = z_q.view(shape)
+
+            # reshape back to match original input shape
+            z_q = z_q.permute(0, 3, 1, 2).contiguous()
+
+        return z_q
+
+
+# pytorch_diffusion + derived encoder decoder
+def nonlinearity(x):
+    # swish
+    return x * torch.sigmoid(x)
+
+
+def Normalize(in_channels):
+    return torch.nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True)
+
+
+class Upsample(nn.Module):
+
+    def __init__(self, in_channels, with_conv):
+        super().__init__()
+        self.with_conv = with_conv
+        if self.with_conv:
+            self.conv = torch.nn.Conv2d(in_channels, in_channels, kernel_size=3, stride=1, padding=1)
+
+    def forward(self, x):
+        x = torch.nn.functional.interpolate(x, scale_factor=2.0, mode='nearest')
+        if self.with_conv:
+            x = self.conv(x)
+        return x
+
+
+class Downsample(nn.Module):
+
+    def __init__(self, in_channels, with_conv):
+        super().__init__()
+        self.with_conv = with_conv
+        if self.with_conv:
+            # no asymmetric padding in torch conv, must do it ourselves
+            self.conv = torch.nn.Conv2d(in_channels, in_channels, kernel_size=3, stride=2, padding=0)
+
+    def forward(self, x):
+        if self.with_conv:
+            pad = (0, 1, 0, 1)
+            x = torch.nn.functional.pad(x, pad, mode='constant', value=0)
+            x = self.conv(x)
+        else:
+            x = torch.nn.functional.avg_pool2d(x, kernel_size=2, stride=2)
+        return x
+
+
+class ResnetBlock(nn.Module):
+
+    def __init__(self, *, in_channels, out_channels=None, conv_shortcut=False, dropout, temb_channels=512):
+        super().__init__()
+        self.in_channels = in_channels
+        out_channels = in_channels if out_channels is None else out_channels
+        self.out_channels = out_channels
+        self.use_conv_shortcut = conv_shortcut
+
+        self.norm1 = Normalize(in_channels)
+        self.conv1 = torch.nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1)
+        if temb_channels > 0:
+            self.temb_proj = torch.nn.Linear(temb_channels, out_channels)
+        self.norm2 = Normalize(out_channels)
+        self.dropout = torch.nn.Dropout(dropout)
+        self.conv2 = torch.nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1)
+        if self.in_channels != self.out_channels:
+            if self.use_conv_shortcut:
+                self.conv_shortcut = torch.nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1)
+            else:
+                self.nin_shortcut = torch.nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, padding=0)
+
+    def forward(self, x, temb):
+        h = x
+        h = self.norm1(h)
+        h = nonlinearity(h)
+        h = self.conv1(h)
+
+        if temb is not None:
+            h = h + self.temb_proj(nonlinearity(temb))[:, :, None, None]
+
+        h = self.norm2(h)
+        h = nonlinearity(h)
+        h = self.dropout(h)
+        h = self.conv2(h)
+
+        if self.in_channels != self.out_channels:
+            if self.use_conv_shortcut:
+                x = self.conv_shortcut(x)
+            else:
+                x = self.nin_shortcut(x)
+
+        return x + h
+
+
+class MultiHeadAttnBlock(nn.Module):
+
+    def __init__(self, in_channels, head_size=1):
+        super().__init__()
+        self.in_channels = in_channels
+        self.head_size = head_size
+        self.att_size = in_channels // head_size
+        assert (in_channels % head_size == 0), 'The size of head should be divided by the number of channels.'
+
+        self.norm1 = Normalize(in_channels)
+        self.norm2 = Normalize(in_channels)
+
+        self.q = torch.nn.Conv2d(in_channels, in_channels, kernel_size=1, stride=1, padding=0)
+        self.k = torch.nn.Conv2d(in_channels, in_channels, kernel_size=1, stride=1, padding=0)
+        self.v = torch.nn.Conv2d(in_channels, in_channels, kernel_size=1, stride=1, padding=0)
+        self.proj_out = torch.nn.Conv2d(in_channels, in_channels, kernel_size=1, stride=1, padding=0)
+        self.num = 0
+
+    def forward(self, x, y=None):
+        h_ = x
+        h_ = self.norm1(h_)
+        if y is None:
+            y = h_
+        else:
+            y = self.norm2(y)
+
+        q = self.q(y)
+        k = self.k(h_)
+        v = self.v(h_)
+
+        # compute attention
+        b, c, h, w = q.shape
+        q = q.reshape(b, self.head_size, self.att_size, h * w)
+        q = q.permute(0, 3, 1, 2)  # b, hw, head, att
+
+        k = k.reshape(b, self.head_size, self.att_size, h * w)
+        k = k.permute(0, 3, 1, 2)
+
+        v = v.reshape(b, self.head_size, self.att_size, h * w)
+        v = v.permute(0, 3, 1, 2)
+
+        q = q.transpose(1, 2)
+        v = v.transpose(1, 2)
+        k = k.transpose(1, 2).transpose(2, 3)
+
+        scale = int(self.att_size)**(-0.5)
+        q.mul_(scale)
+        w_ = torch.matmul(q, k)
+        w_ = F.softmax(w_, dim=3)
+
+        w_ = w_.matmul(v)
+
+        w_ = w_.transpose(1, 2).contiguous()  # [b, h*w, head, att]
+        w_ = w_.view(b, h, w, -1)
+        w_ = w_.permute(0, 3, 1, 2)
+
+        w_ = self.proj_out(w_)
+
+        return x + w_
+
+
+class MultiHeadEncoder(nn.Module):
+
+    def __init__(self,
+                 ch,
+                 out_ch,
+                 ch_mult=(1, 2, 4, 8),
+                 num_res_blocks=2,
+                 attn_resolutions=(16, ),
+                 dropout=0.0,
+                 resamp_with_conv=True,
+                 in_channels=3,
+                 resolution=512,
+                 z_channels=256,
+                 double_z=True,
+                 enable_mid=True,
+                 head_size=1,
+                 **ignore_kwargs):
+        super().__init__()
+        self.ch = ch
+        self.temb_ch = 0
+        self.num_resolutions = len(ch_mult)
+        self.num_res_blocks = num_res_blocks
+        self.resolution = resolution
+        self.in_channels = in_channels
+        self.enable_mid = enable_mid
+
+        # downsampling
+        self.conv_in = torch.nn.Conv2d(in_channels, self.ch, kernel_size=3, stride=1, padding=1)
+
+        curr_res = resolution
+        in_ch_mult = (1, ) + tuple(ch_mult)
+        self.down = nn.ModuleList()
+        for i_level in range(self.num_resolutions):
+            block = nn.ModuleList()
+            attn = nn.ModuleList()
+            block_in = ch * in_ch_mult[i_level]
+            block_out = ch * ch_mult[i_level]
+            for i_block in range(self.num_res_blocks):
+                block.append(
+                    ResnetBlock(
+                        in_channels=block_in, out_channels=block_out, temb_channels=self.temb_ch, dropout=dropout))
+                block_in = block_out
+                if curr_res in attn_resolutions:
+                    attn.append(MultiHeadAttnBlock(block_in, head_size))
+            down = nn.Module()
+            down.block = block
+            down.attn = attn
+            if i_level != self.num_resolutions - 1:
+                down.downsample = Downsample(block_in, resamp_with_conv)
+                curr_res = curr_res // 2
+            self.down.append(down)
+
+        # middle
+        if self.enable_mid:
+            self.mid = nn.Module()
+            self.mid.block_1 = ResnetBlock(
+                in_channels=block_in, out_channels=block_in, temb_channels=self.temb_ch, dropout=dropout)
+            self.mid.attn_1 = MultiHeadAttnBlock(block_in, head_size)
+            self.mid.block_2 = ResnetBlock(
+                in_channels=block_in, out_channels=block_in, temb_channels=self.temb_ch, dropout=dropout)
+
+        # end
+        self.norm_out = Normalize(block_in)
+        self.conv_out = torch.nn.Conv2d(
+            block_in, 2 * z_channels if double_z else z_channels, kernel_size=3, stride=1, padding=1)
+
+    def forward(self, x):
+        hs = {}
+        # timestep embedding
+        temb = None
+
+        # downsampling
+        h = self.conv_in(x)
+        hs['in'] = h
+        for i_level in range(self.num_resolutions):
+            for i_block in range(self.num_res_blocks):
+                h = self.down[i_level].block[i_block](h, temb)
+                if len(self.down[i_level].attn) > 0:
+                    h = self.down[i_level].attn[i_block](h)
+
+            if i_level != self.num_resolutions - 1:
+                # hs.append(h)
+                hs['block_' + str(i_level)] = h
+                h = self.down[i_level].downsample(h)
+
+        # middle
+        # h = hs[-1]
+        if self.enable_mid:
+            h = self.mid.block_1(h, temb)
+            hs['block_' + str(i_level) + '_atten'] = h
+            h = self.mid.attn_1(h)
+            h = self.mid.block_2(h, temb)
+            hs['mid_atten'] = h
+
+        # end
+        h = self.norm_out(h)
+        h = nonlinearity(h)
+        h = self.conv_out(h)
+        # hs.append(h)
+        hs['out'] = h
+
+        return hs
+
+
+class MultiHeadDecoder(nn.Module):
+
+    def __init__(self,
+                 ch,
+                 out_ch,
+                 ch_mult=(1, 2, 4, 8),
+                 num_res_blocks=2,
+                 attn_resolutions=(16, ),
+                 dropout=0.0,
+                 resamp_with_conv=True,
+                 in_channels=3,
+                 resolution=512,
+                 z_channels=256,
+                 give_pre_end=False,
+                 enable_mid=True,
+                 head_size=1,
+                 **ignorekwargs):
+        super().__init__()
+        self.ch = ch
+        self.temb_ch = 0
+        self.num_resolutions = len(ch_mult)
+        self.num_res_blocks = num_res_blocks
+        self.resolution = resolution
+        self.in_channels = in_channels
+        self.give_pre_end = give_pre_end
+        self.enable_mid = enable_mid
+
+        # compute in_ch_mult, block_in and curr_res at lowest res
+        block_in = ch * ch_mult[self.num_resolutions - 1]
+        curr_res = resolution // 2**(self.num_resolutions - 1)
+        self.z_shape = (1, z_channels, curr_res, curr_res)
+        print('Working with z of shape {} = {} dimensions.'.format(self.z_shape, np.prod(self.z_shape)))
+
+        # z to block_in
+        self.conv_in = torch.nn.Conv2d(z_channels, block_in, kernel_size=3, stride=1, padding=1)
+
+        # middle
+        if self.enable_mid:
+            self.mid = nn.Module()
+            self.mid.block_1 = ResnetBlock(
+                in_channels=block_in, out_channels=block_in, temb_channels=self.temb_ch, dropout=dropout)
+            self.mid.attn_1 = MultiHeadAttnBlock(block_in, head_size)
+            self.mid.block_2 = ResnetBlock(
+                in_channels=block_in, out_channels=block_in, temb_channels=self.temb_ch, dropout=dropout)
+
+        # upsampling
+        self.up = nn.ModuleList()
+        for i_level in reversed(range(self.num_resolutions)):
+            block = nn.ModuleList()
+            attn = nn.ModuleList()
+            block_out = ch * ch_mult[i_level]
+            for i_block in range(self.num_res_blocks + 1):
+                block.append(
+                    ResnetBlock(
+                        in_channels=block_in, out_channels=block_out, temb_channels=self.temb_ch, dropout=dropout))
+                block_in = block_out
+                if curr_res in attn_resolutions:
+                    attn.append(MultiHeadAttnBlock(block_in, head_size))
+            up = nn.Module()
+            up.block = block
+            up.attn = attn
+            if i_level != 0:
+                up.upsample = Upsample(block_in, resamp_with_conv)
+                curr_res = curr_res * 2
+            self.up.insert(0, up)  # prepend to get consistent order
+
+        # end
+        self.norm_out = Normalize(block_in)
+        self.conv_out = torch.nn.Conv2d(block_in, out_ch, kernel_size=3, stride=1, padding=1)
+
+    def forward(self, z):
+        # assert z.shape[1:] == self.z_shape[1:]
+        self.last_z_shape = z.shape
+
+        # timestep embedding
+        temb = None
+
+        # z to block_in
+        h = self.conv_in(z)
+
+        # middle
+        if self.enable_mid:
+            h = self.mid.block_1(h, temb)
+            h = self.mid.attn_1(h)
+            h = self.mid.block_2(h, temb)
+
+        # upsampling
+        for i_level in reversed(range(self.num_resolutions)):
+            for i_block in range(self.num_res_blocks + 1):
+                h = self.up[i_level].block[i_block](h, temb)
+                if len(self.up[i_level].attn) > 0:
+                    h = self.up[i_level].attn[i_block](h)
+            if i_level != 0:
+                h = self.up[i_level].upsample(h)
+
+        # end
+        if self.give_pre_end:
+            return h
+
+        h = self.norm_out(h)
+        h = nonlinearity(h)
+        h = self.conv_out(h)
+        return h
+
+
+class MultiHeadDecoderTransformer(nn.Module):
+
+    def __init__(self,
+                 ch,
+                 out_ch,
+                 ch_mult=(1, 2, 4, 8),
+                 num_res_blocks=2,
+                 attn_resolutions=(16, ),
+                 dropout=0.0,
+                 resamp_with_conv=True,
+                 in_channels=3,
+                 resolution=512,
+                 z_channels=256,
+                 give_pre_end=False,
+                 enable_mid=True,
+                 head_size=1,
+                 **ignorekwargs):
+        super().__init__()
+        self.ch = ch
+        self.temb_ch = 0
+        self.num_resolutions = len(ch_mult)
+        self.num_res_blocks = num_res_blocks
+        self.resolution = resolution
+        self.in_channels = in_channels
+        self.give_pre_end = give_pre_end
+        self.enable_mid = enable_mid
+
+        # compute in_ch_mult, block_in and curr_res at lowest res
+        block_in = ch * ch_mult[self.num_resolutions - 1]
+        curr_res = resolution // 2**(self.num_resolutions - 1)
+        self.z_shape = (1, z_channels, curr_res, curr_res)
+        print('Working with z of shape {} = {} dimensions.'.format(self.z_shape, np.prod(self.z_shape)))
+
+        # z to block_in
+        self.conv_in = torch.nn.Conv2d(z_channels, block_in, kernel_size=3, stride=1, padding=1)
+
+        # middle
+        if self.enable_mid:
+            self.mid = nn.Module()
+            self.mid.block_1 = ResnetBlock(
+                in_channels=block_in, out_channels=block_in, temb_channels=self.temb_ch, dropout=dropout)
+            self.mid.attn_1 = MultiHeadAttnBlock(block_in, head_size)
+            self.mid.block_2 = ResnetBlock(
+                in_channels=block_in, out_channels=block_in, temb_channels=self.temb_ch, dropout=dropout)
+
+        # upsampling
+        self.up = nn.ModuleList()
+        for i_level in reversed(range(self.num_resolutions)):
+            block = nn.ModuleList()
+            attn = nn.ModuleList()
+            block_out = ch * ch_mult[i_level]
+            for i_block in range(self.num_res_blocks + 1):
+                block.append(
+                    ResnetBlock(
+                        in_channels=block_in, out_channels=block_out, temb_channels=self.temb_ch, dropout=dropout))
+                block_in = block_out
+                if curr_res in attn_resolutions:
+                    attn.append(MultiHeadAttnBlock(block_in, head_size))
+            up = nn.Module()
+            up.block = block
+            up.attn = attn
+            if i_level != 0:
+                up.upsample = Upsample(block_in, resamp_with_conv)
+                curr_res = curr_res * 2
+            self.up.insert(0, up)  # prepend to get consistent order
+
+        # end
+        self.norm_out = Normalize(block_in)
+        self.conv_out = torch.nn.Conv2d(block_in, out_ch, kernel_size=3, stride=1, padding=1)
+
+    def forward(self, z, hs):
+        # assert z.shape[1:] == self.z_shape[1:]
+        # self.last_z_shape = z.shape
+
+        # timestep embedding
+        temb = None
+
+        # z to block_in
+        h = self.conv_in(z)
+
+        # middle
+        if self.enable_mid:
+            h = self.mid.block_1(h, temb)
+            h = self.mid.attn_1(h, hs['mid_atten'])
+            h = self.mid.block_2(h, temb)
+
+        # upsampling
+        for i_level in reversed(range(self.num_resolutions)):
+            for i_block in range(self.num_res_blocks + 1):
+                h = self.up[i_level].block[i_block](h, temb)
+                if len(self.up[i_level].attn) > 0:
+                    h = self.up[i_level].attn[i_block](h, hs['block_' + str(i_level) + '_atten'])
+                    # hfeature = h.clone()
+            if i_level != 0:
+                h = self.up[i_level].upsample(h)
+
+        # end
+        if self.give_pre_end:
+            return h
+
+        h = self.norm_out(h)
+        h = nonlinearity(h)
+        h = self.conv_out(h)
+        return h
+
+
+class RestoreFormer(nn.Module):
+
+    def __init__(self,
+                 n_embed=1024,
+                 embed_dim=256,
+                 ch=64,
+                 out_ch=3,
+                 ch_mult=(1, 2, 2, 4, 4, 8),
+                 num_res_blocks=2,
+                 attn_resolutions=(16, ),
+                 dropout=0.0,
+                 in_channels=3,
+                 resolution=512,
+                 z_channels=256,
+                 double_z=False,
+                 enable_mid=True,
+                 fix_decoder=False,
+                 fix_codebook=True,
+                 fix_encoder=False,
+                 head_size=8):
+        super(RestoreFormer, self).__init__()
+
+        self.encoder = MultiHeadEncoder(
+            ch=ch,
+            out_ch=out_ch,
+            ch_mult=ch_mult,
+            num_res_blocks=num_res_blocks,
+            attn_resolutions=attn_resolutions,
+            dropout=dropout,
+            in_channels=in_channels,
+            resolution=resolution,
+            z_channels=z_channels,
+            double_z=double_z,
+            enable_mid=enable_mid,
+            head_size=head_size)
+        self.decoder = MultiHeadDecoderTransformer(
+            ch=ch,
+            out_ch=out_ch,
+            ch_mult=ch_mult,
+            num_res_blocks=num_res_blocks,
+            attn_resolutions=attn_resolutions,
+            dropout=dropout,
+            in_channels=in_channels,
+            resolution=resolution,
+            z_channels=z_channels,
+            enable_mid=enable_mid,
+            head_size=head_size)
+
+        self.quantize = VectorQuantizer(n_embed, embed_dim, beta=0.25)
+
+        self.quant_conv = torch.nn.Conv2d(z_channels, embed_dim, 1)
+        self.post_quant_conv = torch.nn.Conv2d(embed_dim, z_channels, 1)
+
+        if fix_decoder:
+            for _, param in self.decoder.named_parameters():
+                param.requires_grad = False
+            for _, param in self.post_quant_conv.named_parameters():
+                param.requires_grad = False
+            for _, param in self.quantize.named_parameters():
+                param.requires_grad = False
+        elif fix_codebook:
+            for _, param in self.quantize.named_parameters():
+                param.requires_grad = False
+
+        if fix_encoder:
+            for _, param in self.encoder.named_parameters():
+                param.requires_grad = False
+
+    def encode(self, x):
+
+        hs = self.encoder(x)
+        h = self.quant_conv(hs['out'])
+        quant, emb_loss, info = self.quantize(h)
+        return quant, emb_loss, info, hs
+
+    def decode(self, quant, hs):
+        quant = self.post_quant_conv(quant)
+        dec = self.decoder(quant, hs)
+
+        return dec
+
+    def forward(self, input, **kwargs):
+        quant, diff, info, hs = self.encode(input)
+        dec = self.decode(quant, hs)
+
+        return dec, None

gfpgan/utils.py

@@ -72,6 +72,9 @@ class GFPGANer():
                 different_w=True,
                 narrow=1,
                 sft_half=True)
+        elif arch == 'RestoreFormer':
+            from gfpgan.archs.restoreformer_arch import RestoreFormer
+            self.gfpgan = RestoreFormer()
         # initialize face helper
         self.face_helper = FaceRestoreHelper(
             upscale,
@@ -96,7 +99,7 @@ class GFPGANer():
         self.gfpgan = self.gfpgan.to(self.device)
 
     @torch.no_grad()
-    def enhance(self, img, has_aligned=False, only_center_face=False, paste_back=True):
+    def enhance(self, img, has_aligned=False, only_center_face=False, paste_back=True, weight=0.5):
         self.face_helper.clean_all()
 
         if has_aligned:  # the inputs are already aligned
@@ -119,7 +122,7 @@ class GFPGANer():
             cropped_face_t = cropped_face_t.unsqueeze(0).to(self.device)
 
             try:
-                output = self.gfpgan(cropped_face_t, return_rgb=False)[0]
+                output = self.gfpgan(cropped_face_t, return_rgb=False, weight=weight)[0]
                 # convert to image
                 restored_face = tensor2img(output.squeeze(0), rgb2bgr=True, min_max=(-1, 1))
             except RuntimeError as error:

inference_gfpgan.py

@@ -41,6 +41,7 @@ def main():
         type=str,
         default='auto',
         help='Image extension. Options: auto | jpg | png, auto means using the same extension as inputs. Default: auto')
+    parser.add_argument('-w', '--weight', type=float, default=0.5, help='Adjustable weights.')
     args = parser.parse_args()
 
     args = parser.parse_args()
@@ -82,23 +83,37 @@ def main():
         arch = 'original'
         channel_multiplier = 1
         model_name = 'GFPGANv1'
+        url = 'https://github.com/TencentARC/GFPGAN/releases/download/v0.1.0/GFPGANv1.pth'
     elif args.version == '1.2':
         arch = 'clean'
         channel_multiplier = 2
         model_name = 'GFPGANCleanv1-NoCE-C2'
+        url = 'https://github.com/TencentARC/GFPGAN/releases/download/v0.2.0/GFPGANCleanv1-NoCE-C2.pth'
     elif args.version == '1.3':
         arch = 'clean'
         channel_multiplier = 2
         model_name = 'GFPGANv1.3'
+        url = 'https://github.com/TencentARC/GFPGAN/releases/download/v1.3.0/GFPGANv1.3.pth'
+    elif args.version == '1.4':
+        arch = 'clean'
+        channel_multiplier = 2
+        model_name = 'GFPGANv1.4'
+        url = 'https://github.com/TencentARC/GFPGAN/releases/download/v1.3.0/GFPGANv1.4.pth'
+    elif args.version == 'RestoreFormer':
+        arch = 'RestoreFormer'
+        channel_multiplier = 2
+        model_name = 'RestoreFormer'
+        url = 'https://github.com/TencentARC/GFPGAN/releases/download/v1.3.4/RestoreFormer.pth'
     else:
         raise ValueError(f'Wrong model version {args.version}.')
 
     # determine model paths
     model_path = os.path.join('experiments/pretrained_models', model_name + '.pth')
     if not os.path.isfile(model_path):
-        model_path = os.path.join('realesrgan/weights', model_name + '.pth')
+        model_path = os.path.join('gfpgan/weights', model_name + '.pth')
     if not os.path.isfile(model_path):
-        raise ValueError(f'Model {model_name} does not exist.')
+        # download pre-trained models from url
+        model_path = url
 
     restorer = GFPGANer(
         model_path=model_path,
@@ -117,7 +132,11 @@ def main():
 
         # restore faces and background if necessary
         cropped_faces, restored_faces, restored_img = restorer.enhance(
-            input_img, has_aligned=args.aligned, only_center_face=args.only_center_face, paste_back=True)
+            input_img,
+            has_aligned=args.aligned,
+            only_center_face=args.only_center_face,
+            paste_back=True,
+            weight=args.weight)
 
         # save faces
         for idx, (cropped_face, restored_face) in enumerate(zip(cropped_faces, restored_faces)):