Upload 22 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+figs/DSCF_arch.png filter=lfs diff=lfs merge=lfs -text
+utils/test.bmp filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 BinRen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,3 +1,70 @@
----
-license: mit
----
+<!--
+ * @Author: Yaozzz666
+ * @Date: 2025-03-21 13:49:25
+ * @LastEditors: Yaozzz666
+ * @LastEditTime: 2025-03-22 11:11:04
+ * 
+ * Copyright (c) 2025 by ${Yaozzz666}, All Rights Reserved. 
+-->
+# [NTIRE 2025 Challenge on Efficient Super-Resolution](https://cvlai.net/ntire/2025/) @ [CVPR 2025](https://cvpr.thecvf.com/)
+
+## Distillation Supervised ConvLora Finetuning for SR
+
+<div align=center>
+<img src="https://github.com/Yaozzz666/DSCF-SR/blob/main/figs/DSCF_arch.png" width="800px"/> 
+</div>
+
+- An overview of our DSCF-SR
+
+## The Environments
+
+The evaluation environments adopted by us is recorded in the `requirements.txt`. After you built your own basic Python (Python = 3.9 in our setting) setup via either *virtual environment* or *anaconda*, please try to keep similar to it via:
+
+- Step1: install Pytorch first:
+`pip install torch==1.13.1+cu117 torchvision==0.14.1+cu117 torchaudio==0.13.1 --extra-index-url https://download.pytorch.org/whl/cu117`
+
+- Step2: install other libs via:
+```pip install -r requirements.txt```
+
+or take it as a reference based on your original environments.
+
+## How to test the model?
+1. Run the [`run.sh`](./run.sh)
+    ```bash
+    CUDA_VISIBLE_DEVICES=0 python test_demo.py --data_dir [path to your data dir] --save_dir [path to your save dir] --model_id 23
+    ```
+    - Be sure the change the directories `--data_dir` and `--save_dir`.
+
+## How to calculate the number of parameters, FLOPs, and activations
+
+```python
+    from utils.model_summary import get_model_flops, get_model_activation
+    from models.team00_EFDN import EFDN
+    from fvcore.nn import FlopCountAnalysis
+
+    model = EFDN()
+    
+    input_dim = (3, 256, 256)  # set the input dimension
+    activations, num_conv = get_model_activation(model, input_dim)
+    activations = activations / 10 ** 6
+    print("{:>16s} : {:<.4f} [M]".format("#Activations", activations))
+    print("{:>16s} : {:<d}".format("#Conv2d", num_conv))
+
+    # The FLOPs calculation in previous NTIRE_ESR Challenge
+    # flops = get_model_flops(model, input_dim, False)
+    # flops = flops / 10 ** 9
+    # print("{:>16s} : {:<.4f} [G]".format("FLOPs", flops))
+
+    # fvcore is used in NTIRE2025_ESR for FLOPs calculation
+    input_fake = torch.rand(1, 3, 256, 256).to(device)
+    flops = FlopCountAnalysis(model, input_fake).total()
+    flops = flops/10**9
+    print("{:>16s} : {:<.4f} [G]".format("FLOPs", flops))
+
+    num_parameters = sum(map(lambda x: x.numel(), model.parameters()))
+    num_parameters = num_parameters / 10 ** 6
+    print("{:>16s} : {:<.4f} [M]".format("#Params", num_parameters))
+```
+
+## License and Acknowledgement
+This code repository is release under [MIT License](LICENSE). 

model_zoo/team00_EFDN.pth

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

model_zoo/team23_DSCF.pth

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

models/team00_EFDN.py

@@ -0,0 +1,410 @@
+# -*- coding: utf-8 -*-
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class ESA(nn.Module):
+    def __init__(self, n_feats, conv):
+        super(ESA, self).__init__()
+        f = n_feats // 4
+        self.conv1 = conv(n_feats, f, kernel_size=1)
+        self.conv_f = conv(f, f, kernel_size=1)
+        self.conv_max = conv(f, f, kernel_size=3, padding=1)
+        self.conv2 = conv(f, f, kernel_size=3, stride=2, padding=0)
+        self.conv3 = conv(f, f, kernel_size=3, padding=1)
+        self.conv3_ = conv(f, f, kernel_size=3, padding=1)
+        self.conv4 = conv(f, n_feats, kernel_size=1)
+        self.sigmoid = nn.Sigmoid()
+        self.relu = nn.ReLU(inplace=True)
+
+    def forward(self, x):
+        c1_ = (self.conv1(x))
+        c1 = self.conv2(c1_)
+        v_max = F.max_pool2d(c1, kernel_size=7, stride=3)
+        v_range = self.relu(self.conv_max(v_max))
+        c3 = self.relu(self.conv3(v_range))
+        c3 = self.conv3_(c3)
+        c3 = F.interpolate(c3, (x.size(2), x.size(3)), mode='bilinear', align_corners=False) 
+        cf = self.conv_f(c1_)
+        c4 = self.conv4(c3+cf)
+        m = self.sigmoid(c4)
+
+        return x * m
+
+          
+class conv(nn.Module):
+    def __init__(self, n_feats):
+        super(conv, self).__init__()
+        self.conv1x1 = nn.Conv2d(n_feats, n_feats, 1, 1, 0) 
+        self.act = nn.PReLU(num_parameters=n_feats)
+    def forward(self, x):
+        return self.act(self.conv1x1(x))
+
+
+class Cell(nn.Module):
+    def __init__(self, n_feats=48, dynamic = True, deploy = False, L= None, with_13=False):
+        super(Cell, self).__init__()
+        
+        self.conv1 = conv(n_feats)#nn.Conv2d(n_feats, n_feats, 1, 1, 0) 
+        self.conv2 = EDBB_deploy(n_feats,n_feats)
+        self.conv3 = EDBB_deploy(n_feats,n_feats)
+
+        self.fuse = nn.Conv2d(n_feats*2, n_feats, 1, 1, 0)
+
+        self.att = ESA(n_feats, nn.Conv2d) #MAB(n_feats)# ENLCA(n_feats)  #CoordAtt(n_feats,n_feats,10)# 
+
+        self.branch = nn.ModuleList([nn.Conv2d(n_feats, n_feats//2, 1, 1, 0) for _ in range(4)])
+
+    def forward(self, x):
+        out1 = self.conv1(x)
+        out2 = self.conv2(out1)
+        out3 = self.conv3(out2)
+
+        # fuse [x, out1, out2, out3]
+        out = self.fuse(torch.cat([self.branch[0](x), self.branch[1](out1), self.branch[2](out2), self.branch[3](out3)], dim=1))
+        out = self.att(out)
+        out += x
+
+        return out
+
+
+class EFDN(nn.Module):
+    def __init__(self, scale=4, in_channels=3, n_feats=48, out_channels=3):
+        super(EFDN, self).__init__()
+        self.head = nn.Conv2d(in_channels, n_feats, 3, 1, 1)
+        # body cells
+        self.cells = nn.ModuleList([Cell(n_feats) for _ in range(4)])
+        
+        # fusion
+        self.local_fuse = nn.ModuleList([nn.Conv2d(n_feats*2, n_feats, 1, 1, 0) for _ in range(3)])
+
+        self.tail = nn.Sequential(
+            nn.Conv2d(n_feats, out_channels*(scale**2), 3, 1, 1),
+            nn.PixelShuffle(scale)
+        )
+
+    def forward(self, x):
+        # head
+        out0 = self.head(x)
+
+        # body cells
+        out1 = self.cells[0](out0)
+        out2 = self.cells[1](out1)
+        out2_fuse = self.local_fuse[0](torch.cat([out1, out2], dim=1))
+        out3 = self.cells[2](out2_fuse)
+        out3_fuse = self.local_fuse[1](torch.cat([out2, out3], dim=1))
+        out4 = self.cells[3](out3_fuse)
+        out4_fuse = self.local_fuse[2](torch.cat([out2, out4], dim=1))
+
+        out = out4_fuse + out0      
+
+        # tail
+        out = self.tail(out)
+
+        return out.clamp(0,1)
+   
+
+# -------------------------------------------------
+#This part code based on DBB(https://github.com/DingXiaoH/DiverseBranchBlock) and ECB(https://github.com/xindongzhang/ECBSR)
+def multiscale(kernel, target_kernel_size):
+    H_pixels_to_pad = (target_kernel_size - kernel.size(2)) // 2
+    W_pixels_to_pad = (target_kernel_size - kernel.size(3)) // 2
+    return F.pad(kernel, [H_pixels_to_pad, H_pixels_to_pad, W_pixels_to_pad, W_pixels_to_pad])
+
+
+class SeqConv3x3(nn.Module):
+    def __init__(self, seq_type, inp_planes, out_planes, depth_multiplier):
+        super(SeqConv3x3, self).__init__()
+
+        self.type = seq_type
+        self.inp_planes = inp_planes
+        self.out_planes = out_planes
+
+        if self.type == 'conv1x1-conv3x3':
+            self.mid_planes = int(out_planes * depth_multiplier)
+            conv0 = torch.nn.Conv2d(self.inp_planes, self.mid_planes, kernel_size=1, padding=0)
+            self.k0 = conv0.weight
+            self.b0 = conv0.bias
+
+            conv1 = torch.nn.Conv2d(self.mid_planes, self.out_planes, kernel_size=3)
+            self.k1 = conv1.weight
+            self.b1 = conv1.bias
+            
+        elif self.type == 'conv1x1-sobelx':
+            conv0 = torch.nn.Conv2d(self.inp_planes, self.out_planes, kernel_size=1, padding=0)
+            self.k0 = conv0.weight
+            self.b0 = conv0.bias
+
+            # init scale & bias
+            scale = torch.randn(size=(self.out_planes, 1, 1, 1)) * 1e-3
+            self.scale = nn.Parameter(scale)
+            # bias = 0.0
+            # bias = [bias for c in range(self.out_planes)]
+            # bias = torch.FloatTensor(bias)
+            bias = torch.randn(self.out_planes) * 1e-3
+            bias = torch.reshape(bias, (self.out_planes,))
+            self.bias = nn.Parameter(bias)
+            # init mask
+            self.mask = torch.zeros((self.out_planes, 1, 3, 3), dtype=torch.float32)
+            for i in range(self.out_planes):
+                self.mask[i, 0, 0, 0] = 1.0
+                self.mask[i, 0, 1, 0] = 2.0
+                self.mask[i, 0, 2, 0] = 1.0
+                self.mask[i, 0, 0, 2] = -1.0
+                self.mask[i, 0, 1, 2] = -2.0
+                self.mask[i, 0, 2, 2] = -1.0
+            self.mask = nn.Parameter(data=self.mask, requires_grad=False)
+
+        elif self.type == 'conv1x1-sobely':
+            conv0 = torch.nn.Conv2d(self.inp_planes, self.out_planes, kernel_size=1, padding=0)
+            self.k0 = conv0.weight
+            self.b0 = conv0.bias
+
+            # init scale & bias
+            scale = torch.randn(size=(self.out_planes, 1, 1, 1)) * 1e-3
+            self.scale = nn.Parameter(torch.FloatTensor(scale))
+            # bias = 0.0
+            # bias = [bias for c in range(self.out_planes)]
+            # bias = torch.FloatTensor(bias)
+            bias = torch.randn(self.out_planes) * 1e-3
+            bias = torch.reshape(bias, (self.out_planes,))
+            self.bias = nn.Parameter(torch.FloatTensor(bias))
+            # init mask
+            self.mask = torch.zeros((self.out_planes, 1, 3, 3), dtype=torch.float32)
+            for i in range(self.out_planes):
+                self.mask[i, 0, 0, 0] = 1.0
+                self.mask[i, 0, 0, 1] = 2.0
+                self.mask[i, 0, 0, 2] = 1.0
+                self.mask[i, 0, 2, 0] = -1.0
+                self.mask[i, 0, 2, 1] = -2.0
+                self.mask[i, 0, 2, 2] = -1.0
+            self.mask = nn.Parameter(data=self.mask, requires_grad=False)
+
+        elif self.type == 'conv1x1-laplacian':
+            conv0 = torch.nn.Conv2d(self.inp_planes, self.out_planes, kernel_size=1, padding=0)
+            self.k0 = conv0.weight
+            self.b0 = conv0.bias
+
+            # init scale & bias
+            scale = torch.randn(size=(self.out_planes, 1, 1, 1)) * 1e-3
+            self.scale = nn.Parameter(torch.FloatTensor(scale))
+            # bias = 0.0
+            # bias = [bias for c in range(self.out_planes)]
+            # bias = torch.FloatTensor(bias)
+            bias = torch.randn(self.out_planes) * 1e-3
+            bias = torch.reshape(bias, (self.out_planes,))
+            self.bias = nn.Parameter(torch.FloatTensor(bias))
+            # init mask
+            self.mask = torch.zeros((self.out_planes, 1, 3, 3), dtype=torch.float32)
+            for i in range(self.out_planes):
+                self.mask[i, 0, 0, 1] = 1.0
+                self.mask[i, 0, 1, 0] = 1.0
+                self.mask[i, 0, 1, 2] = 1.0
+                self.mask[i, 0, 2, 1] = 1.0
+                self.mask[i, 0, 1, 1] = -4.0
+            self.mask = nn.Parameter(data=self.mask, requires_grad=False)
+        else:
+            raise ValueError('the type of seqconv is not supported!')
+
+    def forward(self, x):
+        if self.type == 'conv1x1-conv3x3':
+            # conv-1x1
+            y0 = F.conv2d(input=x, weight=self.k0, bias=self.b0, stride=1)
+            # explicitly padding with bias
+            y0 = F.pad(y0, (1, 1, 1, 1), 'constant', 0)
+            b0_pad = self.b0.view(1, -1, 1, 1)
+            y0[:, :, 0:1, :] = b0_pad
+            y0[:, :, -1:, :] = b0_pad
+            y0[:, :, :, 0:1] = b0_pad
+            y0[:, :, :, -1:] = b0_pad
+            # conv-3x3
+            y1 = F.conv2d(input=y0, weight=self.k1, bias=self.b1, stride=1)
+        else:
+            y0 = F.conv2d(input=x, weight=self.k0, bias=self.b0, stride=1)
+            # explicitly padding with bias
+            y0 = F.pad(y0, (1, 1, 1, 1), 'constant', 0)
+            b0_pad = self.b0.view(1, -1, 1, 1)
+            y0[:, :, 0:1, :] = b0_pad
+            y0[:, :, -1:, :] = b0_pad
+            y0[:, :, :, 0:1] = b0_pad
+            y0[:, :, :, -1:] = b0_pad
+            # conv-3x3
+            y1 = F.conv2d(input=y0, weight=self.scale * self.mask, bias=self.bias, stride=1, groups=self.out_planes)
+        return y1
+    
+    def rep_params(self):
+        device = self.k0.get_device()
+        if device < 0:
+            device = None
+
+        if self.type == 'conv1x1-conv3x3':
+            # re-param conv kernel
+            RK = F.conv2d(input=self.k1, weight=self.k0.permute(1, 0, 2, 3))
+            # re-param conv bias
+            RB = torch.ones(1, self.mid_planes, 3, 3, device=device) * self.b0.view(1, -1, 1, 1)
+            RB = F.conv2d(input=RB, weight=self.k1).view(-1,) + self.b1
+        else:
+            tmp = self.scale * self.mask
+            k1 = torch.zeros((self.out_planes, self.out_planes, 3, 3), device=device)
+            for i in range(self.out_planes):
+                k1[i, i, :, :] = tmp[i, 0, :, :]
+            b1 = self.bias
+            # re-param conv kernel
+            RK = F.conv2d(input=k1, weight=self.k0.permute(1, 0, 2, 3))
+            # re-param conv bias
+            RB = torch.ones(1, self.out_planes, 3, 3, device=device) * self.b0.view(1, -1, 1, 1)
+            RB = F.conv2d(input=RB, weight=k1).view(-1,) + b1
+        return RK, RB
+
+
+class EDBB(nn.Module):
+    def __init__(self, inp_planes, out_planes, depth_multiplier=None, act_type='prelu', with_idt = False, deploy=False, with_13=False, gv=False):
+        super(EDBB, self).__init__()
+        
+        self.deploy = deploy
+        self.act_type = act_type
+        
+        self.inp_planes = inp_planes
+        self.out_planes = out_planes
+
+        self.gv = gv          
+
+        if depth_multiplier is None:
+            self.depth_multiplier = 1.0
+        else: 
+            self.depth_multiplier = depth_multiplier   # For mobilenet, it is better to have 2X internal channels
+        
+        if deploy:
+            self.rep_conv = nn.Conv2d(in_channels=inp_planes, out_channels=out_planes, kernel_size=3, stride=1,
+                                      padding=1, bias=True)
+        else: 
+            self.with_13 = with_13
+            if with_idt and (self.inp_planes == self.out_planes):
+                self.with_idt = True
+            else:
+                self.with_idt = False
+
+            self.rep_conv = nn.Conv2d(self.inp_planes, self.out_planes, kernel_size=3, padding=1)
+            self.conv1x1 = nn.Conv2d(self.inp_planes, self.out_planes, kernel_size=1, padding=0)
+            self.conv1x1_3x3 = SeqConv3x3('conv1x1-conv3x3', self.inp_planes, self.out_planes, self.depth_multiplier)
+            self.conv1x1_sbx = SeqConv3x3('conv1x1-sobelx', self.inp_planes, self.out_planes, -1)
+            self.conv1x1_sby = SeqConv3x3('conv1x1-sobely', self.inp_planes, self.out_planes, -1)
+            self.conv1x1_lpl = SeqConv3x3('conv1x1-laplacian', self.inp_planes, self.out_planes, -1)
+
+        if self.act_type == 'prelu':
+            self.act = nn.PReLU(num_parameters=self.out_planes)
+        elif self.act_type == 'relu':
+            self.act = nn.ReLU(inplace=True)
+        elif self.act_type == 'rrelu':
+            self.act = nn.RReLU(lower=-0.05, upper=0.05)
+        elif self.act_type == 'softplus':
+            self.act = nn.Softplus()
+        elif self.act_type == 'linear':
+            pass
+        else:
+            raise ValueError('The type of activation if not support!')
+
+    def forward(self, x):
+        if self.deploy:
+            y = self.rep_conv(x)
+        elif self.gv:
+            y = self.rep_conv(x)     + \
+                self.conv1x1_sbx(x) + \
+                self.conv1x1_sby(x) + \
+                self.conv1x1_lpl(x) + x 
+        else:
+            y = self.rep_conv(x)     + \
+                self.conv1x1(x)     + \
+                self.conv1x1_sbx(x) + \
+                self.conv1x1_sby(x) + \
+                self.conv1x1_lpl(x)            
+                #self.conv1x1_3x3(x) + \
+            if self.with_idt:
+                y += x
+            if self.with_13:
+                y += self.conv1x1_3x3(x)
+
+        if self.act_type != 'linear':
+            y = self.act(y)
+        return y
+    
+    def switch_to_gv(self):
+        if self.gv:
+            return
+        self.gv = True
+        
+        K0, B0 = self.rep_conv.weight, self.rep_conv.bias
+        K1, B1 = self.conv1x1_3x3.rep_params()
+        K5, B5 = multiscale(self.conv1x1.weight,3), self.conv1x1.bias
+        RK, RB = (K0+K5), (B0+B5) 
+        if self.with_13:
+            RK, RB = RK + K1, RB + B1
+
+        self.rep_conv.weight.data = RK
+        self.rep_conv.bias.data = RB
+        
+        for para in self.parameters():
+            para.detach_()
+      
+    
+    def switch_to_deploy(self):
+
+        if self.deploy:
+            return
+        self.deploy = True
+        
+        K0, B0 = self.rep_conv.weight, self.rep_conv.bias
+        K1, B1 = self.conv1x1_3x3.rep_params()
+        K2, B2 = self.conv1x1_sbx.rep_params()
+        K3, B3 = self.conv1x1_sby.rep_params()
+        K4, B4 = self.conv1x1_lpl.rep_params()
+        K5, B5 = multiscale(self.conv1x1.weight,3), self.conv1x1.bias
+        if self.gv:
+            RK, RB = (K0+K2+K3+K4), (B0+B2+B3+B4) 
+        else:
+            RK, RB = (K0+K2+K3+K4+K5), (B0+B2+B3+B4+B5) 
+            if self.with_13:
+                RK, RB = RK + K1, RB + B1
+        if self.with_idt:
+            device = RK.get_device()
+            if device < 0:
+                device = None
+            K_idt = torch.zeros(self.out_planes, self.out_planes, 3, 3, device=device)
+            for i in range(self.out_planes):
+                K_idt[i, i, 1, 1] = 1.0
+            B_idt = 0.0
+            RK, RB = RK + K_idt, RB + B_idt        
+            
+
+        self.rep_conv = nn.Conv2d(in_channels=self.inp_planes, out_channels=self.out_planes, kernel_size=3, stride=1,
+                                      padding=1, bias=True)
+        self.rep_conv.weight.data = RK
+        self.rep_conv.bias.data = RB
+        
+        for para in self.parameters():
+            para.detach_()
+            
+        #self.__delattr__('conv3x3')
+        self.__delattr__('conv1x1_3x3')
+        self.__delattr__('conv1x1')
+        self.__delattr__('conv1x1_sbx')
+        self.__delattr__('conv1x1_sby')
+        self.__delattr__('conv1x1_lpl')
+
+
+class EDBB_deploy(nn.Module):
+    def __init__(self, inp_planes, out_planes):
+        super(EDBB_deploy, self).__init__()
+               
+        self.rep_conv = nn.Conv2d(in_channels=inp_planes, out_channels=out_planes, kernel_size=3, stride=1,
+                                      padding=1, bias=True)
+ 
+        self.act = nn.PReLU(num_parameters=out_planes)
+
+    def forward(self, x):
+        y = self.rep_conv(x)
+        y = self.act(y)
+        
+        return y
+# -------------------------------------------------

models/team23_DSCF.py

@@ -0,0 +1,466 @@
+from collections import OrderedDict
+import torch
+from torch import nn as nn
+import torch.nn.functional as F
+import math
+from typing import Optional, List
+# from IPython import embed
+
+class LoRALayer():
+    def __init__(
+        self, 
+        r: int, 
+        lora_alpha: int, 
+        lora_dropout: float,
+        merge_weights: bool,
+    ):
+        self.r = r
+        self.lora_alpha = lora_alpha
+        # Optional dropout
+        if lora_dropout > 0.:
+            self.lora_dropout = nn.Dropout(p=lora_dropout)
+        else:
+            self.lora_dropout = lambda x: x
+        # Mark the weight as unmerged
+        self.merged = False
+        self.merge_weights = merge_weights
+
+class Lora_Conv2d(nn.Conv2d, LoRALayer):
+    # LoRA implemented in a dense layer
+    def __init__(
+        self, 
+        in_channels: int, 
+        out_channels: int,
+        kernel_size: int,
+        r: int = 0, 
+        lora_alpha: int = 1, 
+        lora_dropout: float = 0.,
+        merge_weights: bool = True,
+        **kwargs
+    ):
+        nn.Conv2d.__init__(self, in_channels, out_channels, kernel_size, **kwargs)
+        LoRALayer.__init__(self, r=r, lora_alpha=lora_alpha, lora_dropout=lora_dropout,
+                           merge_weights=merge_weights)
+        assert type(kernel_size) is int
+        # print("in init")
+        # embed()
+        # Actual trainable parameters
+        if r > 0:
+            self.lora_A = nn.Parameter(
+                self.weight.new_zeros((r*kernel_size, in_channels*kernel_size))
+            )
+            self.lora_B = nn.Parameter(
+                self.weight.new_zeros((out_channels*kernel_size, r*kernel_size))
+            )
+            self.scaling = self.lora_alpha / self.r
+            # Freezing the pre-trained weight matrix
+            self.weight.requires_grad = False
+        # Freeze the bias
+        # if self.bias is not None:
+        #     self.bias.requires_grad = False
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        nn.Conv2d.reset_parameters(self)
+        if hasattr(self, 'lora_A'):
+            # initialize A the same way as the default for nn.Linear and B to zero
+            nn.init.kaiming_uniform_(self.lora_A, a=math.sqrt(5))
+            nn.init.zeros_(self.lora_B)
+
+    def train(self, mode: bool = True): # True for train and False for eval
+ 
+        nn.Conv2d.train(self, mode)
+        if mode:
+            if self.merge_weights and self.merged:
+                # Make sure that the weights are not merged
+                self.weight.data -= (self.lora_B @ self.lora_A).view(self.weight.shape) * self.scaling
+                self.merged = False
+        else:
+            # print("test")
+            # embed()
+            if self.merge_weights and not self.merged:
+                # print("merging")
+                # embed()
+                # Merge the weights and mark it
+                self.weight.data += (self.lora_B @ self.lora_A).view(self.weight.shape) * self.scaling
+                self.merged = True
+
+    def forward(self, x: torch.Tensor):
+        # print(f"LoRA merged status: {self.merged}")
+        if self.r > 0 and not self.merged:
+            # print(f"lora_A: {self.lora_A}")
+            # print(f"lora_B: {self.lora_B}")
+            # print(f"LoRA contribution: {(self.lora_B @ self.lora_A).view(self.weight.shape) * self.scaling}")
+            return F.conv2d(
+                x, 
+                self.weight + (self.lora_B @ self.lora_A).view(self.weight.shape) * self.scaling,
+                self.bias, self.stride, self.padding, self.dilation, self.groups
+            )
+        
+        return nn.Conv2d.forward(self, x)
+def _make_pair(value):
+    if isinstance(value, int):
+        value = (value,) * 2
+    return value
+
+
+def conv_layer(in_channels,
+               out_channels,
+               kernel_size,
+               bias=True):
+    """
+    Re-write convolution layer for adaptive `padding`.
+    """
+    kernel_size = _make_pair(kernel_size)
+    padding = (int((kernel_size[0] - 1) / 2),
+               int((kernel_size[1] - 1) / 2))
+    return nn.Conv2d(in_channels,
+                     out_channels,
+                     kernel_size,
+                     padding=padding,
+                     bias=bias)
+
+
+def activation(act_type, inplace=True, neg_slope=0.05, n_prelu=1):
+    """
+    Activation functions for ['relu', 'lrelu', 'prelu'].
+    Parameters
+    ----------
+    act_type: str
+        one of ['relu', 'lrelu', 'prelu'].
+    inplace: bool
+        whether to use inplace operator.
+    neg_slope: float
+        slope of negative region for `lrelu` or `prelu`.
+    n_prelu: int
+        `num_parameters` for `prelu`.
+    ----------
+    """
+    act_type = act_type.lower()
+    if act_type == 'relu':
+        layer = nn.ReLU(inplace)
+    elif act_type == 'lrelu':
+        layer = nn.LeakyReLU(neg_slope, inplace)
+    elif act_type == 'prelu':
+        layer = nn.PReLU(num_parameters=n_prelu, init=neg_slope)
+    else:
+        raise NotImplementedError(
+            'activation layer [{:s}] is not found'.format(act_type))
+    return layer
+
+
+def sequential(*args):
+    """
+    Modules will be added to the a Sequential Container in the order they
+    are passed.
+
+    Parameters
+    ----------
+    args: Definition of Modules in order.
+    -------
+    """
+    if len(args) == 1:
+        if isinstance(args[0], OrderedDict):
+            raise NotImplementedError(
+                'sequential does not support OrderedDict input.')
+        return args[0]
+    modules = []
+    for module in args:
+        if isinstance(module, nn.Sequential):
+            for submodule in module.children():
+                modules.append(submodule)
+        elif isinstance(module, nn.Module):
+            modules.append(module)
+    return nn.Sequential(*modules)
+
+
+def pixelshuffle_block(in_channels,
+                       out_channels,
+                       upscale_factor=2,
+                       kernel_size=3):
+    """
+    Upsample features according to `upscale_factor`.
+    """
+    conv = conv_layer(in_channels,
+                      out_channels * (upscale_factor ** 2),
+                      kernel_size)
+    pixel_shuffle = nn.PixelShuffle(upscale_factor)
+    return sequential(conv, pixel_shuffle)
+
+class Conv3XC(nn.Module):
+    def __init__(self, c_in, c_out, gain1=1, gain2=0, s=1, bias=True, relu=False):
+        super(Conv3XC, self).__init__()
+        self.weight_concat = None
+        self.bias_concat = None
+        self.update_params_flag = False
+        self.stride = s
+        self.has_relu = relu
+  
+
+        self.eval_conv = nn.Conv2d(in_channels=c_in, out_channels=c_out, kernel_size=3, padding=1, stride=s, bias=bias)
+
+    def forward(self, x):
+        out = self.eval_conv(x)
+        if self.has_relu:
+            out = F.leaky_relu(out, negative_slope=0.05)
+        return out 
+
+
+class SPAB(nn.Module):
+    def __init__(self,
+                 in_channels,
+                 mid_channels=None,
+                 out_channels=None,
+                 bias=False):
+        super(SPAB, self).__init__()
+        if mid_channels is None:
+            mid_channels = in_channels
+        if out_channels is None:
+            out_channels = in_channels
+
+        self.in_channels = in_channels
+        self.c1_r = Conv3XC(in_channels, mid_channels, gain1=2, s=1)
+        self.c2_r = Conv3XC(mid_channels, mid_channels, gain1=2, s=1)
+        self.c3_r = Conv3XC(mid_channels, out_channels, gain1=2, s=1)
+        self.act1 = torch.nn.SiLU(inplace=True)
+        # self.act2 = activation('lrelu', neg_slope=0.1, inplace=True)
+
+    def forward(self, x):
+        out1 = (self.c1_r(x))
+        out1_act = self.act1(out1)
+
+        out2 = (self.c2_r(out1_act))
+        out2_act = self.act1(out2)
+
+        out3 = (self.c3_r(out2_act))
+
+        sim_att = torch.sigmoid(out3) - 0.5
+        out = (out3 + x) * sim_att
+        # out = out3 * sim_att
+        # return out, out1, sim_att
+        return out, out1, out2,out3
+
+
+class DSCF(nn.Module):
+    """
+    Swift Parameter-free Attention Network for Efficient Super-Resolution
+    """
+
+    def __init__(self,
+                 num_in_ch,
+                 num_out_ch,
+                 feature_channels=26,
+                 upscale=4,
+                 bias=True,
+                 img_range=255.,
+                 rgb_mean=(0.4488, 0.4371, 0.4040)
+                 ):
+        super(DSCF, self).__init__()
+
+        in_channels = num_in_ch
+        out_channels = num_out_ch
+        self.img_range = img_range
+        self.mean = torch.Tensor(rgb_mean).view(1, 3, 1, 1)
+
+        self.conv_1 = Conv3XC(in_channels, feature_channels, gain1=2, s=1)
+        self.block_1 = SPAB(feature_channels, bias=bias)
+        self.block_2 = SPAB(feature_channels, bias=bias)
+        self.block_3 = SPAB(feature_channels, bias=bias)
+        self.block_4 = SPAB(feature_channels, bias=bias)
+        self.block_5 = SPAB(feature_channels, bias=bias)
+        self.block_6 = SPAB(feature_channels, bias=bias)
+
+        self.conv_cat = conv_layer(feature_channels * 4, feature_channels, kernel_size=1, bias=True)
+        self.conv_2 = Conv3XC(feature_channels, feature_channels, gain1=2, s=1)
+        
+        self.upsampler = pixelshuffle_block(feature_channels, out_channels, upscale_factor=upscale)
+        
+        # 指定需要替换 LoRA 层的子模块名称
+        # desired_submodules = ["conv_1.eval_conv",
+        #                       "block_1.c1_r.eval_conv","block_1.c2_r.eval_conv","block_1.c3_r.eval_conv",
+        #                       "block_2.c1_r.eval_conv","block_2.c2_r.eval_conv","block_2.c3_r.eval_conv",
+        #                       "block_3.c1_r.eval_conv","block_3.c2_r.eval_conv","block_3.c3_r.eval_conv",
+        #                       "block_4.c1_r.eval_conv","block_4.c2_r.eval_conv","block_4.c3_r.eval_conv",
+        #                       "block_5.c1_r.eval_conv","block_5.c2_r.eval_conv","block_5.c3_r.eval_conv",
+        #                       "block_6.c1_r.eval_conv","block_6.c2_r.eval_conv","block_6.c3_r.eval_conv",
+        #                       "conv_2.eval_conv",
+        #                       "conv_cat", 
+        #                       "upsampler.0"]
+        
+        # desired_submodules = ["conv_2.eval_conv","upsampler.0"]
+        # # 替换需要 LoRA 处理的层
+        # self.replace_layers(desired_submodules)
+        
+        # self.mark_only_lora_as_trainable(bias='none')
+        # 分层LoRA配置字典（模块名: (r, lora_alpha)）
+        # self.lora_config = {
+        #     # 高频重建核心层 (最高优先级)
+        #     "conv_2.eval_conv": (8, 16),  # 最大秩
+        #     "upsampler.0": (8, 16),       # 高秩
+            
+        #     # 中间处理层 (梯度传播关键路径)
+        #     **{f"block_{i}.c{j}_r.eval_conv": (2, 4) 
+        #     for i in [2,3,4,5]          # block_2到block_5
+        #     for j in [1,2,3]},          # 每个block的三个卷积
+            
+        #     # 首尾层 (适度调整)
+        #     "block_1.c1_r.eval_conv": (2, 4),
+        #     "block_1.c2_r.eval_conv": (2, 4),
+        #     "block_1.c3_r.eval_conv": (2, 4),
+        #     "block_6.c1_r.eval_conv": (2, 4),
+        #     "block_6.c2_r.eval_conv": (2, 4),
+        #     "block_6.c3_r.eval_conv": (2, 4),
+        # }
+        
+        # # 替换需要 LoRA 处理的层
+        # self.replace_layers_with_strategy()
+        
+        # 冻结非LoRA参数
+        # self.mark_only_lora_as_trainable(bias='none')
+        # self.cuda()(torch.randn(1, 3, 256, 256).cuda())
+        # self.eval().cuda()
+        self.eval().cuda()
+        input_tensor = torch.randn(1, 3, 256, 256).cuda()
+        output = self(input_tensor)
+        # 确保 LoRA 层参数可训练
+        # print("可训练参数:")
+        # for name, param in self.named_parameters():
+        #     if param.requires_grad:
+        #         print(f"{name}: {param.shape}")
+                
+
+    # def replace_layers_with_strategy(self):
+    #     """根据分层策略替换卷积层"""
+    #     for full_name, (r, alpha) in self.lora_config.items():
+    #         parent, child_name = self._get_parent_and_child(full_name)
+    #         if parent is None:
+    #             # print(f"⚠️ Skip {full_name}: module not found")
+    #             continue
+                
+    #         original_conv = getattr(parent, child_name, None)
+    #         if not isinstance(original_conv, nn.Conv2d):
+    #             # print(f"⚠️ {full_name} is not Conv2d (found {type(original_conv)})")
+    #             continue
+                
+    #         # 动态设置参数
+    #         new_layer = Lora_Conv2d(
+    #             in_channels=original_conv.in_channels,
+    #             out_channels=original_conv.out_channels,
+    #             kernel_size=original_conv.kernel_size[0],
+    #             stride=original_conv.stride,
+    #             padding=original_conv.padding,
+    #             bias=original_conv.bias is not None,
+    #             r=r,  # 动态设置秩
+    #             lora_alpha=alpha  # 动态设置缩放系数
+    #         )
+            
+    #         # 继承原始权重
+    #         with torch.no_grad():
+    #             new_layer.weight.copy_(original_conv.weight)
+    #             if original_conv.bias is not None:
+    #                 new_layer.bias.copy_(original_conv.bias)
+            
+    #         setattr(parent, child_name, new_layer)
+    #         # print(f"✅ {full_name} => r={r}, alpha={alpha}")
+
+    # def _get_parent_and_child(self, module_name):
+    #     """
+    #     获取模块的父级模块和子模块名称
+    #     例如：
+    #     module_name = "block_5.c1_r.eval_conv"
+    #     则返回 (model.block_5.c1_r, "eval_conv")
+    #     """
+    #     parts = module_name.split(".")
+    #     parent = self
+    #     for part in parts[:-1]:  # 遍历到倒数第二个
+    #         if hasattr(parent, part):
+    #             parent = getattr(parent, part)
+    #         else:
+    #             return None, None  # 没找到路径
+    #     return parent, parts[-1]  # 返回父模块和子模块名称
+
+    # def replace_layers(self, desired_submodules):
+    #     """
+    #     遍历模型的子模块，将符合条件的层替换为 Lora_Conv2d
+    #     """
+    #     # 替换conv_layer
+    #     for name, module in self._modules.items():
+    #         if name in desired_submodules:
+    #             print('--------------------self._modules.items--------------------------')
+    #             print(name)
+    #         if isinstance(module, nn.Conv2d):
+    #             print(f"Replacing {name} with Lora_Conv2d")
+    #             setattr(self, name, Lora_Conv2d(
+    #                 module.in_channels,
+    #                 module.out_channels,
+    #                 kernel_size=module.kernel_size[0],
+    #                 stride=module.stride,
+    #                 padding=module.padding,
+    #                 bias=True,
+    #                 r=2,
+    #                 lora_alpha=2
+    #             ))
+                                    
+    # def mark_only_lora_as_trainable(self, bias: str = 'none'):
+    #     """
+    #     只训练 LoRA 相关参数，而冻结所有其他参数。
+        
+    #     参数:
+    #     - bias: 'none' (不训练 bias), 'all' (训练所有 bias), 'lora_only' (只训练 LoRA 层的 bias)
+    #     """
+    #     # 冻结所有非 LoRA 参数
+    #     # for n, p in self.named_parameters():
+    #     #     if 'lora_' not in n:
+    #     #         p.requires_grad = False
+    #     for n, p in self.named_parameters():
+    #         if 'lora_' not in n:  
+    #             p.requires_grad = False  # 冻结非 LoRA 参数
+    #         else:
+    #             p.requires_grad = True  # 解冻 LoRA 参数
+
+    #     if bias == 'none':
+    #         return
+    #     elif bias == 'all':
+    #         for n, p in self.named_parameters():
+    #             if 'bias' in n:
+    #                 p.requires_grad = True
+    #     elif bias == 'lora_only':
+    #         for m in self.modules():
+    #             if isinstance(m, LoRALayer) and hasattr(m, 'bias') and m.bias is not None:
+    #                 m.bias.requires_grad = True
+    #     else:
+    #         raise NotImplementedError(f"未知 bias 选项: {bias}")
+    def forward(self, x, return_features=False):
+        # features = []
+        self.mean = self.mean.type_as(x)
+        x = (x - self.mean) * self.img_range
+
+        out_feature = self.conv_1(x)
+
+        out_b1, out_b1_1, out_b1_2, out_b1_3 = self.block_1(out_feature)
+        out_b2, out_b2_1, out_b2_2, out_b2_3 = self.block_2(out_b1)
+        out_b3, out_b3_1, out_b3_2, out_b3_3 = self.block_3(out_b2)
+
+        out_b4, _, _, _ = self.block_4(out_b3)
+        out_b5, _, _, _ = self.block_5(out_b4)
+        out_b6, out_b5_2, _, _ = self.block_6(out_b5)
+
+        out_b6 = self.conv_2(out_b6)
+        out = self.conv_cat(torch.cat([out_feature, out_b6, out_b1, out_b5_2], 1))
+        output = self.upsampler(out)
+        
+        # features.append(out_b1_1)
+        # features.append(out_b1_2)
+        # features.append(out_b1_3)
+        # features.append(out_b2_1)
+        # features.append(out_b2_2)
+        # features.append(out_b2_3)
+        # features.append(out_b3_1)
+        # features.append(out_b3_2)
+        # features.append(out_b3_3)
+ 
+
+        if return_features:
+            return output, features  # Return output and intermediate features
+        return output
+    

requirements.txt

@@ -0,0 +1,136 @@
+absl-py==2.0.0
+anyio==4.0.0
+appdirs==1.4.4
+beartype==0.16.4
+blessed==1.20.0
+brotlipy==0.7.0
+cachetools==5.3.1
+certifi==2023.7.22
+cffi==1.15.1
+charset-normalizer==2.0.4
+click==8.1.7
+clip==0.2.0
+cmake==3.27.7
+contourpy==1.1.1
+cryptography==41.0.3
+cycler==0.12.1
+docker-pycreds==0.4.0
+dpcpp-cpp-rt==2024.0.2
+einops==0.7.0
+ema-pytorch==0.3.1
+exceptiongroup==1.1.3
+filelock==3.12.4
+fonttools==4.43.1
+fsspec==2023.9.2
+ftfy==6.1.1
+fvcore==0.1.5.post20221221
+gitdb==4.0.10
+GitPython==3.1.40
+google-auth==2.23.3
+google-auth-oauthlib==1.0.0
+gpustat==1.1.1
+grpcio==1.59.0
+h11==0.14.0
+h5py==3.10.0
+huggingface-hub==0.18.0
+idna==3.4
+imageio==2.31.5
+importlib-metadata==6.8.0
+importlib-resources==6.1.0
+intel-cmplr-lib-rt==2024.0.2
+intel-cmplr-lic-rt==2024.0.2
+intel-opencl-rt==2024.0.2
+intel-openmp==2024.0.2
+iopath==0.1.10
+itsdangerous==2.1.2
+kiwisolver==1.4.5
+lit==17.0.3
+lpips==0.1.4
+Markdown==3.5
+markdown-it-py==2.2.0
+MarkupSafe==2.1.3
+matplotlib==3.7.3
+mdurl==0.1.2
+mkl==2024.0.0
+mkl-fft==1.3.6
+mkl-random==1.2.2
+mkl-service==2.4.0
+mpmath==1.3.0
+multidict==6.0.4
+networkx==3.1
+numpy==1.24.3
+nvidia-ml-py==12.535.108
+oauthlib==3.2.2
+opencv-python==4.8.1.78
+ordered-set==4.1.0
+orjson==3.8.9
+packaging==23.1
+pandas==1.5.3
+pathtools==0.1.2
+Pillow==9.4.0
+portalocker==2.8.2
+protobuf==4.24.4
+psutil==5.9.6
+py-cpuinfo==9.0.0
+pyasn1==0.5.0
+pyasn1-modules==0.3.0
+pycparser==2.21
+pydantic==1.10.7
+Pygments==2.16.1
+PyJWT==2.6.0
+pyOpenSSL==23.2.0
+pyparsing==3.0.9
+PySocks==1.7.1
+python-dateutil==2.8.2
+pytorch-fid==0.3.0
+pytz==2023.3.post1
+PyWavelets==1.4.1
+PyYAML==6.0
+readchar==4.0.5
+regex==2023.10.3
+requests==2.28.2
+requests-oauthlib==1.3.1
+rfc3986==1.5.0
+rich==13.3.3
+rsa==4.9
+scikit-image==0.19.3
+scikit-video==1.1.11
+scipy==1.10.1
+seaborn==0.12.2
+sentry-sdk==1.14.0
+setproctitle==1.3.2
+six==1.16.0
+smmap==5.0.0
+sniffio==1.3.0
+soupsieve==2.4
+starlette==0.22.0
+starsessions==1.3.0
+sympy==1.11.1
+tabulate==0.9.0
+tbb==2021.11.0
+tensorboard==2.14.0
+tensorboard-data-server==0.7.1
+termcolor==2.4.0
+tifffile==2023.1.23.1
+timm==0.6.12
+torchmetrics==0.11.4
+torchsummary==1.5.1
+tqdm==4.66.1
+triton==2.0.0
+tsnecuda==3.0.1
+typing_extensions==4.5.0
+ujson==5.7.0
+urllib3==1.26.14
+uvicorn==0.21.1
+uvloop==0.17.0
+wandb==0.13.9
+warmup-scheduler==0.3
+watchfiles==0.19.0
+wcwidth==0.2.8
+websocket-client==1.5.1
+websockets==11.0.1
+Werkzeug==3.0.0
+yacs==0.1.8
+yapf==0.32.0
+yarl==1.8.2
+zipp==3.17.0

results.txt

@@ -0,0 +1,3 @@
+Model               	Val PSNR  	Val Time [ms] 	Params [M]	FLOPs [G] 	Acts [M]	Mem [M] 	Conv    
+00_EFDN_baseline    	26.93     	34.31         	0.276     	16.70     	111.12  	662.89  	  65    
+23_DSCF             	26.92     	8.37          	0.131     	8.54      	38.93   	728.41  	  22    

run.sh

@@ -0,0 +1,29 @@
+# --- Evaluation on LSDIR_DIV2K_valid datasets for One Method: ---
+CUDA_VISIBLE_DEVICES=0 python test_demo.py \
+    --data_dir ../ \
+    --save_dir ../results \
+    --model_id 23
+
+
+# --- When only LSDIR_DIV2K_test datasets are included (For Organizer) ---
+# CUDA_VISIBLE_DEVICES=0 python test_demo.py \
+#     --data_dir ../ \
+#     --save_dir ../results \
+#     --include_test \
+#     --model_id 0
+
+# --- Test all the methods (For Organizer) ---
+#!/bin/bash
+# DATA_DIR="/Your/Validate/Datasets/Path"
+# SAVE_DIR="./results"
+# MODEL_IDS=(
+#     0 1 3 4 5 7 10 11 13 15 
+#     16 17 18 19 21 23 25 26 
+#     28 29 30 31 33 34 38 39 
+#     41 42 43 44 45 46 48
+# )
+
+# for model_id in "${MODEL_IDS[@]}"
+# do
+#     CUDA_VISIBLE_DEVICES=0 python test_demo.py --data_dir "$DATA_DIR" --save_dir "$SAVE_DIR" --include_test --model_id "$model_id"
+# done

test_demo.py

@@ -0,0 +1,299 @@
+import os.path
+import logging
+import torch
+import argparse
+import json
+import glob
+
+from pprint import pprint
+from fvcore.nn import FlopCountAnalysis
+from utils.model_summary import get_model_activation, get_model_flops
+from utils import utils_logger
+from utils import utils_image as util
+
+
+def select_model(args, device):
+    # Model ID is assigned according to the order of the submissions.
+    # Different networks are trained with input range of either [0,1] or [0,255]. The range is determined manually.
+    model_id = args.model_id
+    if model_id == 0:
+        # Baseline: The 1st Place of the `Overall Performance`` of the NTIRE 2023 Efficient SR Challenge 
+        # Edge-enhanced Feature Distillation Network for Efficient Super-Resolution
+        # arXiv: https://arxiv.org/pdf/2204.08759
+        # Original Code: https://github.com/icandle/EFDN
+        # Ckpts: EFDN_gv.pth
+        from models.team00_EFDN import EFDN
+        name, data_range = f"{model_id:02}_EFDN_baseline", 1.0
+        model_path = os.path.join('model_zoo', 'team00_EFDN.pth')
+        model = EFDN()
+        model.load_state_dict(torch.load(model_path), strict=True)
+    elif model_id == 23:
+        from models.team23_DSCF import DSCF
+        
+        name, data_range = f"{model_id:02}_DSCF", 1.0
+        model_path = os.path.join('model_zoo', 'team23_DSCF.pth')
+        model = DSCF(3,3,feature_channels=26,upscale=4)
+        state_dict = torch.load(model_path)
+
+        model.load_state_dict(state_dict, strict=False)
+    else:
+        raise NotImplementedError(f"Model {model_id} is not implemented.")
+    
+    # print(model)
+    model.eval()
+    tile = None
+    for k, v in model.named_parameters():
+        v.requires_grad = False
+    model = model.to(device)
+    return model, name, data_range, tile
+
+
+def select_dataset(data_dir, mode):
+    # inference on the DIV2K_LSDIR_test set
+    if mode == "test":
+        path = [
+            (
+                p.replace("_HR", "_LR").replace(".png", "x4.png"),
+                p
+            ) for p in sorted(glob.glob(os.path.join(data_dir, "DIV2K_LSDIR_test_HR/*.png")))
+        ]
+
+    # inference on the DIV2K_LSDIR_valid set
+    elif mode == "valid":
+        path = [
+            (
+                p.replace("_HR", "_LR").replace(".png", "x4.png"),
+                p
+            ) for p in sorted(glob.glob(os.path.join(data_dir, "DIV2K_LSDIR_valid_HR/*.png")))
+        ]
+    else:
+        raise NotImplementedError(f"{mode} is not implemented in select_dataset")
+    
+    return path
+
+
+def forward(img_lq, model, tile=None, tile_overlap=32, scale=4):
+    if tile is None:
+        # test the image as a whole
+        output = model(img_lq)
+    else:
+        # test the image tile by tile
+        b, c, h, w = img_lq.size()
+        tile = min(tile, h, w)
+        tile_overlap = tile_overlap
+        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).type_as(img_lq)
+        W = torch.zeros_like(E)
+
+        for h_idx in h_idx_list:
+            for w_idx in w_idx_list:
+                in_patch = img_lq[..., 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
+
+def run(model, model_name, data_range, tile, logger, device, args, mode="test"):
+
+    sf = 4
+    border = sf
+    results = dict()
+    results[f"{mode}_runtime"] = []
+    results[f"{mode}_psnr"] = []
+    if args.ssim:
+        results[f"{mode}_ssim"] = []
+    # results[f"{mode}_psnr_y"] = []
+    # results[f"{mode}_ssim_y"] = []
+
+    # --------------------------------
+    # dataset path
+    # --------------------------------
+    data_path = select_dataset(args.data_dir, mode)
+    save_path = os.path.join(args.save_dir, model_name, mode)
+    util.mkdir(save_path)
+
+    start = torch.cuda.Event(enable_timing=True)
+    end = torch.cuda.Event(enable_timing=True)
+
+    for i, (img_lr, img_hr) in enumerate(data_path):
+
+        # --------------------------------
+        # (1) img_lr
+        # --------------------------------
+        img_name, ext = os.path.splitext(os.path.basename(img_hr))
+        img_lr = util.imread_uint(img_lr, n_channels=3)
+        img_lr = util.uint2tensor4(img_lr, data_range)
+        img_lr = img_lr.to(device)
+
+        # --------------------------------
+        # (2) img_sr
+        # --------------------------------
+        start.record()
+        img_sr = forward(img_lr, model, tile)
+        end.record()
+        torch.cuda.synchronize()
+        results[f"{mode}_runtime"].append(start.elapsed_time(end))  # milliseconds
+        img_sr = util.tensor2uint(img_sr, data_range)
+
+        # --------------------------------
+        # (3) img_hr
+        # --------------------------------
+        img_hr = util.imread_uint(img_hr, n_channels=3)
+        img_hr = img_hr.squeeze()
+        img_hr = util.modcrop(img_hr, sf)
+
+        # --------------------------------
+        # PSNR and SSIM
+        # --------------------------------
+
+        # print(img_sr.shape, img_hr.shape)
+        psnr = util.calculate_psnr(img_sr, img_hr, border=border)
+        results[f"{mode}_psnr"].append(psnr)
+
+        if args.ssim:
+            ssim = util.calculate_ssim(img_sr, img_hr, border=border)
+            results[f"{mode}_ssim"].append(ssim)
+            logger.info("{:s} - PSNR: {:.2f} dB; SSIM: {:.4f}.".format(img_name + ext, psnr, ssim))
+        else:
+            logger.info("{:s} - PSNR: {:.2f} dB".format(img_name + ext, psnr))
+
+        # if np.ndim(img_hr) == 3:  # RGB image
+        #     img_sr_y = util.rgb2ycbcr(img_sr, only_y=True)
+        #     img_hr_y = util.rgb2ycbcr(img_hr, only_y=True)
+        #     psnr_y = util.calculate_psnr(img_sr_y, img_hr_y, border=border)
+        #     ssim_y = util.calculate_ssim(img_sr_y, img_hr_y, border=border)
+        #     results[f"{mode}_psnr_y"].append(psnr_y)
+        #     results[f"{mode}_ssim_y"].append(ssim_y)
+        # print(os.path.join(save_path, img_name+ext))
+            
+        # --- Save Restored Images ---
+        # util.imsave(img_sr, os.path.join(save_path, img_name+ext))
+
+    results[f"{mode}_memory"] = torch.cuda.max_memory_allocated(torch.cuda.current_device()) / 1024 ** 2
+    results[f"{mode}_ave_runtime"] = sum(results[f"{mode}_runtime"]) / len(results[f"{mode}_runtime"]) #/ 1000.0
+    results[f"{mode}_ave_psnr"] = sum(results[f"{mode}_psnr"]) / len(results[f"{mode}_psnr"])
+    if args.ssim:
+        results[f"{mode}_ave_ssim"] = sum(results[f"{mode}_ssim"]) / len(results[f"{mode}_ssim"])
+    # results[f"{mode}_ave_psnr_y"] = sum(results[f"{mode}_psnr_y"]) / len(results[f"{mode}_psnr_y"])
+    # results[f"{mode}_ave_ssim_y"] = sum(results[f"{mode}_ssim_y"]) / len(results[f"{mode}_ssim_y"])
+    logger.info("{:>16s} : {:<.3f} [M]".format("Max Memory", results[f"{mode}_memory"]))  # Memery
+    logger.info("------> Average runtime of ({}) is : {:.6f} milliseconds".format("test" if mode == "test" else "valid", results[f"{mode}_ave_runtime"]))
+    logger.info("------> Average PSNR of ({}) is : {:.6f} dB".format("test" if mode == "test" else "valid", results[f"{mode}_ave_psnr"]))
+
+    return results
+
+
+def main(args):
+
+    utils_logger.logger_info("NTIRE2025-EfficientSR", log_path="NTIRE2025-EfficientSR.log")
+    logger = logging.getLogger("NTIRE2025-EfficientSR")
+
+    # --------------------------------
+    # basic settings
+    # --------------------------------
+    torch.cuda.current_device()
+    torch.cuda.empty_cache()
+    torch.backends.cudnn.benchmark = False
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    json_dir = os.path.join(os.getcwd(), "results.json")
+    if not os.path.exists(json_dir):
+        results = dict()
+    else:
+        with open(json_dir, "r") as f:
+            results = json.load(f)
+
+    # --------------------------------
+    # load model
+    # --------------------------------
+    model, model_name, data_range, tile = select_model(args, device)
+    logger.info(model_name)
+
+    # if model not in results:
+    if True:
+        # --------------------------------
+        # restore image
+        # --------------------------------
+
+        # inference on the DIV2K_LSDIR_valid set
+        valid_results = run(model, model_name, data_range, tile, logger, device, args, mode="valid")
+        # record PSNR, runtime
+        results[model_name] = valid_results
+
+        # inference conducted by the Organizer on DIV2K_LSDIR_test set
+        if args.include_test:
+            test_results = run(model, model_name, data_range, tile, logger, device, args, mode="test")
+            results[model_name].update(test_results)
+
+        input_dim = (3, 256, 256)  # set the input dimension
+        activations, num_conv = get_model_activation(model, input_dim)
+        activations = activations/10**6
+        logger.info("{:>16s} : {:<.4f} [M]".format("#Activations", activations))
+        logger.info("{:>16s} : {:<d}".format("#Conv2d", num_conv))
+
+        # The FLOPs calculation in previous NTIRE_ESR Challenge
+        # flops = get_model_flops(model, input_dim, False)
+        # flops = flops/10**9
+        # logger.info("{:>16s} : {:<.4f} [G]".format("FLOPs", flops))
+
+        # fvcore is used in NTIRE2025_ESR for FLOPs calculation
+        input_fake = torch.rand(1, 3, 256, 256).to(device)
+        flops = FlopCountAnalysis(model, input_fake).total()
+        flops = flops/10**9
+        logger.info("{:>16s} : {:<.4f} [G]".format("FLOPs", flops))
+
+        num_parameters = sum(map(lambda x: x.numel(), model.parameters()))
+        num_parameters = num_parameters/10**6
+        logger.info("{:>16s} : {:<.4f} [M]".format("#Params", num_parameters))
+        results[model_name].update({"activations": activations, "num_conv": num_conv, "flops": flops, "num_parameters": num_parameters})
+
+        with open(json_dir, "w") as f:
+            json.dump(results, f)
+    if args.include_test:
+        fmt = "{:20s}\t{:10s}\t{:10s}\t{:14s}\t{:14s}\t{:14s}\t{:10s}\t{:10s}\t{:8s}\t{:8s}\t{:8s}\n"
+        s = fmt.format("Model", "Val PSNR", "Test PSNR", "Val Time [ms]", "Test Time [ms]", "Ave Time [ms]",
+                       "Params [M]", "FLOPs [G]", "Acts [M]", "Mem [M]", "Conv")
+    else:
+        fmt = "{:20s}\t{:10s}\t{:14s}\t{:10s}\t{:10s}\t{:8s}\t{:8s}\t{:8s}\n"
+        s = fmt.format("Model", "Val PSNR", "Val Time [ms]", "Params [M]", "FLOPs [G]", "Acts [M]", "Mem [M]", "Conv")
+    for k, v in results.items():
+        val_psnr = f"{v['valid_ave_psnr']:2.2f}"
+        val_time = f"{v['valid_ave_runtime']:3.2f}"
+        mem = f"{v['valid_memory']:2.2f}"
+        
+        num_param = f"{v['num_parameters']:2.3f}"
+        flops = f"{v['flops']:2.2f}"
+        acts = f"{v['activations']:2.2f}"
+        conv = f"{v['num_conv']:4d}"
+        if args.include_test:
+            # from IPython import embed; embed()
+            test_psnr = f"{v['test_ave_psnr']:2.2f}"
+            test_time = f"{v['test_ave_runtime']:3.2f}"
+            ave_time = f"{(v['valid_ave_runtime'] + v['test_ave_runtime']) / 2:3.2f}"
+            s += fmt.format(k, val_psnr, test_psnr, val_time, test_time, ave_time, num_param, flops, acts, mem, conv)
+        else:
+            s += fmt.format(k, val_psnr, val_time, num_param, flops, acts, mem, conv)
+    with open(os.path.join(os.getcwd(), 'results.txt'), "w") as f:
+        f.write(s)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser("NTIRE2025-EfficientSR")
+    parser.add_argument("--data_dir", default="../", type=str)
+    parser.add_argument("--save_dir", default="../results", type=str)
+    parser.add_argument("--model_id", default=0, type=int)
+    parser.add_argument("--include_test", action="store_true", help="Inference on the `DIV2K_LSDIR_test` set")
+    parser.add_argument("--ssim", action="store_true", help="Calculate SSIM")
+
+    args = parser.parse_args()
+    pprint(args)
+
+    main(args)

utils/model_summary.py

@@ -0,0 +1,465 @@
+import torch.nn as nn
+import torch
+import numpy as np
+
+'''
+---- 1) FLOPs: floating point operations
+---- 2) #Activations: the number of elements of all ‘Conv2d’ outputs
+---- 3) #Conv2d: the number of ‘Conv2d’ layers
+'''
+
+def get_model_flops(model, input_res, print_per_layer_stat=True,
+                              input_constructor=None):
+    assert type(input_res) is tuple, 'Please provide the size of the input image.'
+    assert len(input_res) >= 3, 'Input image should have 3 dimensions.'
+    flops_model = add_flops_counting_methods(model)
+    flops_model.eval().start_flops_count()
+    if input_constructor:
+        input = input_constructor(input_res)
+        _ = flops_model(**input)
+    else:
+        device = list(flops_model.parameters())[-1].device
+        batch = torch.FloatTensor(1, *input_res).to(device)
+        _ = flops_model(batch)
+
+    if print_per_layer_stat:
+        print_model_with_flops(flops_model)
+    flops_count = flops_model.compute_average_flops_cost()
+    flops_model.stop_flops_count()
+
+    return flops_count
+
+def get_model_activation(model, input_res, input_constructor=None):
+    assert type(input_res) is tuple, 'Please provide the size of the input image.'
+    assert len(input_res) >= 3, 'Input image should have 3 dimensions.'
+    activation_model = add_activation_counting_methods(model)
+    activation_model.eval().start_activation_count()
+    if input_constructor:
+        input = input_constructor(input_res)
+        _ = activation_model(**input)
+    else:
+        device = list(activation_model.parameters())[-1].device
+        batch = torch.FloatTensor(1, *input_res).to(device)
+        _ = activation_model(batch)
+
+    activation_count, num_conv = activation_model.compute_average_activation_cost()
+    activation_model.stop_activation_count()
+
+    return activation_count, num_conv
+
+
+def get_model_complexity_info(model, input_res, print_per_layer_stat=True, as_strings=True,
+                              input_constructor=None):
+    assert type(input_res) is tuple
+    assert len(input_res) >= 3
+    flops_model = add_flops_counting_methods(model)
+    flops_model.eval().start_flops_count()
+    if input_constructor:
+        input = input_constructor(input_res)
+        _ = flops_model(**input)
+    else:
+        batch = torch.FloatTensor(1, *input_res)
+        _ = flops_model(batch)
+
+    if print_per_layer_stat:
+        print_model_with_flops(flops_model)
+    flops_count = flops_model.compute_average_flops_cost()
+    params_count = get_model_parameters_number(flops_model)
+    flops_model.stop_flops_count()
+
+    if as_strings:
+        return flops_to_string(flops_count), params_to_string(params_count)
+
+    return flops_count, params_count
+
+
+def flops_to_string(flops, units='GMac', precision=2):
+    if units is None:
+        if flops // 10**9 > 0:
+            return str(round(flops / 10.**9, precision)) + ' GMac'
+        elif flops // 10**6 > 0:
+            return str(round(flops / 10.**6, precision)) + ' MMac'
+        elif flops // 10**3 > 0:
+            return str(round(flops / 10.**3, precision)) + ' KMac'
+        else:
+            return str(flops) + ' Mac'
+    else:
+        if units == 'GMac':
+            return str(round(flops / 10.**9, precision)) + ' ' + units
+        elif units == 'MMac':
+            return str(round(flops / 10.**6, precision)) + ' ' + units
+        elif units == 'KMac':
+            return str(round(flops / 10.**3, precision)) + ' ' + units
+        else:
+            return str(flops) + ' Mac'
+
+
+def params_to_string(params_num):
+    if params_num // 10 ** 6 > 0:
+        return str(round(params_num / 10 ** 6, 2)) + ' M'
+    elif params_num // 10 ** 3:
+        return str(round(params_num / 10 ** 3, 2)) + ' k'
+    else:
+        return str(params_num)
+
+
+def print_model_with_flops(model, units='GMac', precision=3):
+    total_flops = model.compute_average_flops_cost()
+
+    def accumulate_flops(self):
+        if is_supported_instance(self):
+            return self.__flops__ / model.__batch_counter__
+        else:
+            sum = 0
+            for m in self.children():
+                sum += m.accumulate_flops()
+            return sum
+
+    def flops_repr(self):
+        accumulated_flops_cost = self.accumulate_flops()
+        return ', '.join([flops_to_string(accumulated_flops_cost, units=units, precision=precision),
+                          '{:.3%} MACs'.format(accumulated_flops_cost / total_flops),
+                          self.original_extra_repr()])
+
+    def add_extra_repr(m):
+        m.accumulate_flops = accumulate_flops.__get__(m)
+        flops_extra_repr = flops_repr.__get__(m)
+        if m.extra_repr != flops_extra_repr:
+            m.original_extra_repr = m.extra_repr
+            m.extra_repr = flops_extra_repr
+            assert m.extra_repr != m.original_extra_repr
+
+    def del_extra_repr(m):
+        if hasattr(m, 'original_extra_repr'):
+            m.extra_repr = m.original_extra_repr
+            del m.original_extra_repr
+        if hasattr(m, 'accumulate_flops'):
+            del m.accumulate_flops
+
+    model.apply(add_extra_repr)
+    print(model)
+    model.apply(del_extra_repr)
+
+
+def get_model_parameters_number(model):
+    params_num = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    return params_num
+
+
+def add_flops_counting_methods(net_main_module):
+    # adding additional methods to the existing module object,
+    # this is done this way so that each function has access to self object
+    # embed()
+    net_main_module.start_flops_count = start_flops_count.__get__(net_main_module)
+    net_main_module.stop_flops_count = stop_flops_count.__get__(net_main_module)
+    net_main_module.reset_flops_count = reset_flops_count.__get__(net_main_module)
+    net_main_module.compute_average_flops_cost = compute_average_flops_cost.__get__(net_main_module)
+
+    net_main_module.reset_flops_count()
+    return net_main_module
+
+
+def compute_average_flops_cost(self):
+    """
+    A method that will be available after add_flops_counting_methods() is called
+    on a desired net object.
+
+    Returns current mean flops consumption per image.
+
+    """
+
+    flops_sum = 0
+    for module in self.modules():
+        if is_supported_instance(module):
+            flops_sum += module.__flops__
+
+    return flops_sum
+
+
+def start_flops_count(self):
+    """
+    A method that will be available after add_flops_counting_methods() is called
+    on a desired net object.
+
+    Activates the computation of mean flops consumption per image.
+    Call it before you run the network.
+
+    """
+    self.apply(add_flops_counter_hook_function)
+
+
+def stop_flops_count(self):
+    """
+    A method that will be available after add_flops_counting_methods() is called
+    on a desired net object.
+
+    Stops computing the mean flops consumption per image.
+    Call whenever you want to pause the computation.
+
+    """
+    self.apply(remove_flops_counter_hook_function)
+
+
+def reset_flops_count(self):
+    """
+    A method that will be available after add_flops_counting_methods() is called
+    on a desired net object.
+
+    Resets statistics computed so far.
+
+    """
+    self.apply(add_flops_counter_variable_or_reset)
+
+
+def add_flops_counter_hook_function(module):
+    if is_supported_instance(module):
+        if hasattr(module, '__flops_handle__'):
+            return
+
+        if isinstance(module, (nn.Conv2d, nn.Conv3d, nn.ConvTranspose2d)):
+            handle = module.register_forward_hook(conv_flops_counter_hook)
+        elif isinstance(module, (nn.ReLU, nn.PReLU, nn.ELU, nn.LeakyReLU, nn.ReLU6)):
+            handle = module.register_forward_hook(relu_flops_counter_hook)
+        elif isinstance(module, nn.Linear):
+            handle = module.register_forward_hook(linear_flops_counter_hook)
+        elif isinstance(module, (nn.BatchNorm2d)):
+            handle = module.register_forward_hook(bn_flops_counter_hook)
+        else:
+            handle = module.register_forward_hook(empty_flops_counter_hook)
+        module.__flops_handle__ = handle
+
+
+def remove_flops_counter_hook_function(module):
+    if is_supported_instance(module):
+        if hasattr(module, '__flops_handle__'):
+            module.__flops_handle__.remove()
+            del module.__flops_handle__
+
+
+def add_flops_counter_variable_or_reset(module):
+    if is_supported_instance(module):
+        module.__flops__ = 0
+
+
+# ---- Internal functions
+def is_supported_instance(module):
+    if isinstance(module,
+                  (
+                          nn.Conv2d, nn.ConvTranspose2d,
+                          nn.BatchNorm2d,
+                          nn.Linear,
+                          nn.ReLU, nn.PReLU, nn.ELU, nn.LeakyReLU, nn.ReLU6,
+                  )):
+        return True
+
+    return False
+
+
+def conv_flops_counter_hook(conv_module, input, output):
+    # Can have multiple inputs, getting the first one
+    # input = input[0]
+
+    batch_size = output.shape[0]
+    output_dims = list(output.shape[2:])
+
+    kernel_dims = list(conv_module.kernel_size)
+    in_channels = conv_module.in_channels
+    out_channels = conv_module.out_channels
+    groups = conv_module.groups
+
+    filters_per_channel = out_channels // groups
+    conv_per_position_flops = np.prod(kernel_dims) * in_channels * filters_per_channel
+
+    active_elements_count = batch_size * np.prod(output_dims)
+    overall_conv_flops = int(conv_per_position_flops) * int(active_elements_count)
+
+    # overall_flops = overall_conv_flops
+
+    conv_module.__flops__ += int(overall_conv_flops)
+    # conv_module.__output_dims__ = output_dims
+
+
+def relu_flops_counter_hook(module, input, output):
+    active_elements_count = output.numel()
+    module.__flops__ += int(active_elements_count)
+    # print(module.__flops__, id(module))
+    # print(module)
+
+
+def linear_flops_counter_hook(module, input, output):
+    input = input[0]
+    if len(input.shape) == 1:
+        batch_size = 1
+        module.__flops__ += int(batch_size * input.shape[0] * output.shape[0])
+    else:
+        batch_size = input.shape[0]
+        module.__flops__ += int(batch_size * input.shape[1] * output.shape[1])
+
+
+def bn_flops_counter_hook(module, input, output):
+    # input = input[0]
+    # TODO: need to check here
+    # batch_flops = np.prod(input.shape)
+    # if module.affine:
+    #     batch_flops *= 2
+    # module.__flops__ += int(batch_flops)
+    batch = output.shape[0]
+    output_dims = output.shape[2:]
+    channels = module.num_features
+    batch_flops = batch * channels * np.prod(output_dims)
+    if module.affine:
+        batch_flops *= 2
+    module.__flops__ += int(batch_flops)
+
+
+# ---- Count the number of convolutional layers and the activation
+def add_activation_counting_methods(net_main_module):
+    # adding additional methods to the existing module object,
+    # this is done this way so that each function has access to self object
+    # embed()
+    net_main_module.start_activation_count = start_activation_count.__get__(net_main_module)
+    net_main_module.stop_activation_count = stop_activation_count.__get__(net_main_module)
+    net_main_module.reset_activation_count = reset_activation_count.__get__(net_main_module)
+    net_main_module.compute_average_activation_cost = compute_average_activation_cost.__get__(net_main_module)
+
+    net_main_module.reset_activation_count()
+    return net_main_module
+
+
+def compute_average_activation_cost(self):
+    """
+    A method that will be available after add_activation_counting_methods() is called
+    on a desired net object.
+
+    Returns current mean activation consumption per image.
+
+    """
+
+    activation_sum = 0
+    num_conv = 0
+    for module in self.modules():
+        if is_supported_instance_for_activation(module):
+            activation_sum += module.__activation__
+            num_conv += module.__num_conv__
+    return activation_sum, num_conv
+
+
+def start_activation_count(self):
+    """
+    A method that will be available after add_activation_counting_methods() is called
+    on a desired net object.
+
+    Activates the computation of mean activation consumption per image.
+    Call it before you run the network.
+
+    """
+    self.apply(add_activation_counter_hook_function)
+
+
+def stop_activation_count(self):
+    """
+    A method that will be available after add_activation_counting_methods() is called
+    on a desired net object.
+
+    Stops computing the mean activation consumption per image.
+    Call whenever you want to pause the computation.
+
+    """
+    self.apply(remove_activation_counter_hook_function)
+
+
+def reset_activation_count(self):
+    """
+    A method that will be available after add_activation_counting_methods() is called
+    on a desired net object.
+
+    Resets statistics computed so far.
+
+    """
+    self.apply(add_activation_counter_variable_or_reset)
+
+
+def add_activation_counter_hook_function(module):
+    if is_supported_instance_for_activation(module):
+        if hasattr(module, '__activation_handle__'):
+            return
+
+        if isinstance(module, (nn.Conv2d, nn.ConvTranspose2d)):
+            handle = module.register_forward_hook(conv_activation_counter_hook)
+            module.__activation_handle__ = handle
+
+
+def remove_activation_counter_hook_function(module):
+    if is_supported_instance_for_activation(module):
+        if hasattr(module, '__activation_handle__'):
+            module.__activation_handle__.remove()
+            del module.__activation_handle__
+
+
+def add_activation_counter_variable_or_reset(module):
+    if is_supported_instance_for_activation(module):
+        module.__activation__ = 0
+        module.__num_conv__ = 0
+
+
+def is_supported_instance_for_activation(module):
+    if isinstance(module,
+                  (
+                          nn.Conv2d, nn.ConvTranspose2d, nn.Conv1d, nn.Linear, nn.ConvTranspose1d
+                  )):
+        return True
+
+    return False
+
+def conv_activation_counter_hook(module, input, output):
+    """
+    Calculate the activations in the convolutional operation.
+    Reference: Ilija Radosavovic, Raj Prateek Kosaraju, Ross Girshick, Kaiming He, Piotr Dollár, Designing Network Design Spaces.
+    :param module:
+    :param input:
+    :param output:
+    :return:
+    """
+    module.__activation__ += output.numel()
+    module.__num_conv__ += 1
+
+
+def empty_flops_counter_hook(module, input, output):
+    module.__flops__ += 0
+
+
+def upsample_flops_counter_hook(module, input, output):
+    output_size = output[0]
+    batch_size = output_size.shape[0]
+    output_elements_count = batch_size
+    for val in output_size.shape[1:]:
+        output_elements_count *= val
+    module.__flops__ += int(output_elements_count)
+
+
+def pool_flops_counter_hook(module, input, output):
+    input = input[0]
+    module.__flops__ += int(np.prod(input.shape))
+
+
+def dconv_flops_counter_hook(dconv_module, input, output):
+    input = input[0]
+
+    batch_size = input.shape[0]
+    output_dims = list(output.shape[2:])
+
+    m_channels, in_channels, kernel_dim1, _, = dconv_module.weight.shape
+    out_channels, _, kernel_dim2, _, = dconv_module.projection.shape
+    # groups = dconv_module.groups
+
+    # filters_per_channel = out_channels // groups
+    conv_per_position_flops1 = kernel_dim1 ** 2 * in_channels * m_channels
+    conv_per_position_flops2 = kernel_dim2 ** 2 * out_channels * m_channels
+    active_elements_count = batch_size * np.prod(output_dims)
+
+    overall_conv_flops = (conv_per_position_flops1 + conv_per_position_flops2) * active_elements_count
+    overall_flops = overall_conv_flops
+
+    dconv_module.__flops__ += int(overall_flops)
+    # dconv_module.__output_dims__ = output_dims
+    

utils/utils_image.py

@@ -0,0 +1,772 @@
+import os
+import math
+import random
+import numpy as np
+import torch
+import cv2
+from torchvision.utils import make_grid
+from datetime import datetime
+# import torchvision.transforms as transforms
+import matplotlib.pyplot as plt
+
+
+IMG_EXTENSIONS = ['.jpg', '.JPG', '.jpeg', '.JPEG', '.png', '.PNG', '.ppm', '.PPM', '.bmp', '.BMP']
+
+
+def is_image_file(filename):
+    return any(filename.endswith(extension) for extension in IMG_EXTENSIONS)
+
+
+def get_timestamp():
+    return datetime.now().strftime('%y%m%d-%H%M%S')
+
+
+def imshow(x, title=None, cbar=False, figsize=None):
+    plt.figure(figsize=figsize)
+    plt.imshow(np.squeeze(x), interpolation='nearest', cmap='gray')
+    if title:
+        plt.title(title)
+    if cbar:
+        plt.colorbar()
+    plt.show()
+
+
+'''
+# =======================================
+# get image pathes of files
+# =======================================
+'''
+
+
+def get_image_paths(dataroot):
+    paths = None  # return None if dataroot is None
+    if dataroot is not None:
+        paths = sorted(_get_paths_from_images(dataroot))
+    return paths
+
+
+def _get_paths_from_images(path):
+    assert os.path.isdir(path), '{:s} is not a valid directory'.format(path)
+    images = []
+    for dirpath, _, fnames in sorted(os.walk(path)):
+        for fname in sorted(fnames):
+            if is_image_file(fname):
+                img_path = os.path.join(dirpath, fname)
+                images.append(img_path)
+    assert images, '{:s} has no valid image file'.format(path)
+    return images
+
+
+'''
+# =======================================
+# makedir
+# =======================================
+'''
+
+
+def mkdir(path):
+    if not os.path.exists(path):
+        os.makedirs(path)
+
+
+def mkdirs(paths):
+    if isinstance(paths, str):
+        mkdir(paths)
+    else:
+        for path in paths:
+            mkdir(path)
+
+
+def mkdir_and_rename(path):
+    if os.path.exists(path):
+        new_name = path + '_archived_' + get_timestamp()
+        print('Path already exists. Rename it to [{:s}]'.format(new_name))
+        os.rename(path, new_name)
+    os.makedirs(path)
+
+
+'''
+# =======================================
+# read image from path
+# Note: opencv is fast
+# but read BGR numpy image
+# =======================================
+'''
+
+
+# ----------------------------------------
+# get single image of size HxWxn_channles (BGR)
+# ----------------------------------------
+def read_img(path):
+    # read image by cv2
+    # return: Numpy float32, HWC, BGR, [0,1]
+    img = cv2.imread(path, cv2.IMREAD_UNCHANGED)  # cv2.IMREAD_GRAYSCALE
+    img = img.astype(np.float32) / 255.
+    if img.ndim == 2:
+        img = np.expand_dims(img, axis=2)
+    # some images have 4 channels
+    if img.shape[2] > 3:
+        img = img[:, :, :3]
+    return img
+
+
+# ----------------------------------------
+# get uint8 image of size HxWxn_channles (RGB)
+# ----------------------------------------
+def imread_uint(path, n_channels=3):
+    #  input: path
+    # output: HxWx3(RGB or GGG), or HxWx1 (G)
+    if n_channels == 1:
+        img = cv2.imread(path, 0)  # cv2.IMREAD_GRAYSCALE
+        img = np.expand_dims(img, axis=2)  # HxWx1
+    elif n_channels == 3:
+        img = cv2.imread(path, cv2.IMREAD_UNCHANGED)  # BGR or G
+        if img.ndim == 2:
+            img = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB)  # GGG
+        else:
+            img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)  # RGB
+    return img
+
+
+def imsave(img, img_path):
+    img = np.squeeze(img)
+    if img.ndim == 3:
+        img = img[:, :, [2, 1, 0]]
+    cv2.imwrite(img_path, img)
+
+
+'''
+# =======================================
+# numpy(single) <--->  numpy(uint)
+# numpy(single) <--->  tensor
+# numpy(uint)   <--->  tensor
+# =======================================
+'''
+
+
+# --------------------------------
+# numpy(single) <--->  numpy(uint)
+# --------------------------------
+
+
+def uint2single(img):
+
+    return np.float32(img/255.)
+
+
+def uint2single1(img):
+
+    return np.float32(np.squeeze(img)/255.)
+
+
+def single2uint(img):
+
+    return np.uint8((img.clip(0, 1)*255.).round())
+
+
+def uint162single(img):
+
+    return np.float32(img/65535.)
+
+
+def single2uint16(img):
+
+    return np.uint8((img.clip(0, 1)*65535.).round())
+
+
+# --------------------------------
+# numpy(uint) <--->  tensor
+# uint (HxWxn_channels (RGB) or G)
+# --------------------------------
+
+
+# convert uint (HxWxn_channels) to 4-dimensional torch tensor
+def uint2tensor4(img, data_range):
+    if img.ndim == 2:
+        img = np.expand_dims(img, axis=2)
+    return torch.from_numpy(np.ascontiguousarray(img)).permute(2, 0, 1).float().div(255./data_range).unsqueeze(0)
+
+
+# convert uint (HxWxn_channels) to 3-dimensional torch tensor
+def uint2tensor3(img):
+    if img.ndim == 2:
+        img = np.expand_dims(img, axis=2)
+    return torch.from_numpy(np.ascontiguousarray(img)).permute(2, 0, 1).float().div(255.)
+
+
+# convert torch tensor to uint
+def tensor2uint(img, data_range):
+    img = img.data.squeeze().float().clamp_(0, 1*data_range).cpu().numpy()
+    if img.ndim == 3:
+        img = np.transpose(img, (1, 2, 0))
+    return np.uint8((img*255.0/data_range).round())
+
+
+# --------------------------------
+# numpy(single) <--->  tensor
+# single (HxWxn_channels (RGB) or G)
+# --------------------------------
+
+
+# convert single (HxWxn_channels) to 4-dimensional torch tensor
+def single2tensor4(img):
+    return torch.from_numpy(np.ascontiguousarray(img)).permute(2, 0, 1).float().unsqueeze(0)
+
+
+# convert single (HxWxn_channels) to 3-dimensional torch tensor
+def single2tensor3(img):
+    return torch.from_numpy(np.ascontiguousarray(img)).permute(2, 0, 1).float()
+
+
+# convert torch tensor to single
+def tensor2single(img):
+    img = img.data.squeeze().float().clamp_(0, 1).cpu().numpy()
+    if img.ndim == 3:
+        img = np.transpose(img, (1, 2, 0))
+
+    return img
+
+def tensor2single3(img):
+    img = img.data.squeeze().float().clamp_(0, 1).cpu().numpy()
+    if img.ndim == 3:
+        img = np.transpose(img, (1, 2, 0))
+    elif img.ndim == 2:
+        img = np.expand_dims(img, axis=2)
+    return img
+
+
+# from skimage.io import imread, imsave
+def tensor2img(tensor, out_type=np.uint8, min_max=(0, 1)):
+    '''
+    Converts a torch Tensor into an image Numpy array of BGR channel order
+    Input: 4D(B,(3/1),H,W), 3D(C,H,W), or 2D(H,W), any range, RGB channel order
+    Output: 3D(H,W,C) or 2D(H,W), [0,255], np.uint8 (default)
+    '''
+    tensor = tensor.squeeze().float().cpu().clamp_(*min_max)  # squeeze first, then clamp
+    tensor = (tensor - min_max[0]) / (min_max[1] - min_max[0])  # to range [0,1]
+    n_dim = tensor.dim()
+    if n_dim == 4:
+        n_img = len(tensor)
+        img_np = make_grid(tensor, nrow=int(math.sqrt(n_img)), normalize=False).numpy()
+        img_np = np.transpose(img_np[[2, 1, 0], :, :], (1, 2, 0))  # HWC, BGR
+    elif n_dim == 3:
+        img_np = tensor.numpy()
+        img_np = np.transpose(img_np[[2, 1, 0], :, :], (1, 2, 0))  # HWC, BGR
+    elif n_dim == 2:
+        img_np = tensor.numpy()
+    else:
+        raise TypeError(
+            'Only support 4D, 3D and 2D tensor. But received with dimension: {:d}'.format(n_dim))
+    if out_type == np.uint8:
+        img_np = (img_np * 255.0).round()
+        # Important. Unlike matlab, numpy.uint8() WILL NOT round by default.
+    return img_np.astype(out_type)
+
+
+'''
+# =======================================
+# image processing process on numpy image
+# augment(img_list, hflip=True, rot=True):
+# =======================================
+'''
+
+
+def augment_img(img, mode=0):
+    if mode == 0:
+        return img
+    elif mode == 1:
+        return np.flipud(np.rot90(img))
+    elif mode == 2:
+        return np.flipud(img)
+    elif mode == 3:
+        return np.rot90(img, k=3)
+    elif mode == 4:
+        return np.flipud(np.rot90(img, k=2))
+    elif mode == 5:
+        return np.rot90(img)
+    elif mode == 6:
+        return np.rot90(img, k=2)
+    elif mode == 7:
+        return np.flipud(np.rot90(img, k=3))
+
+
+def augment_img_np3(img, mode=0):
+    if mode == 0:
+        return img
+    elif mode == 1:
+        return img.transpose(1, 0, 2)
+    elif mode == 2:
+        return img[::-1, :, :]
+    elif mode == 3:
+        img = img[::-1, :, :]
+        img = img.transpose(1, 0, 2)
+        return img
+    elif mode == 4:
+        return img[:, ::-1, :]
+    elif mode == 5:
+        img = img[:, ::-1, :]
+        img = img.transpose(1, 0, 2)
+        return img
+    elif mode == 6:
+        img = img[:, ::-1, :]
+        img = img[::-1, :, :]
+        return img
+    elif mode == 7:
+        img = img[:, ::-1, :]
+        img = img[::-1, :, :]
+        img = img.transpose(1, 0, 2)
+        return img
+
+
+def augment_img_tensor(img, mode=0):
+    img_size = img.size()
+    img_np = img.data.cpu().numpy()
+    if len(img_size) == 3:
+        img_np = np.transpose(img_np, (1, 2, 0))
+    elif len(img_size) == 4:
+        img_np = np.transpose(img_np, (2, 3, 1, 0))
+    img_np = augment_img(img_np, mode=mode)
+    img_tensor = torch.from_numpy(np.ascontiguousarray(img_np))
+    if len(img_size) == 3:
+        img_tensor = img_tensor.permute(2, 0, 1)
+    elif len(img_size) == 4:
+        img_tensor = img_tensor.permute(3, 2, 0, 1)
+
+    return img_tensor.type_as(img)
+
+
+def augment_imgs(img_list, hflip=True, rot=True):
+    # horizontal flip OR rotate
+    hflip = hflip and random.random() < 0.5
+    vflip = rot and random.random() < 0.5
+    rot90 = rot and random.random() < 0.5
+
+    def _augment(img):
+        if hflip:
+            img = img[:, ::-1, :]
+        if vflip:
+            img = img[::-1, :, :]
+        if rot90:
+            img = img.transpose(1, 0, 2)
+        return img
+
+    return [_augment(img) for img in img_list]
+
+
+'''
+# =======================================
+# image processing process on numpy image
+# channel_convert(in_c, tar_type, img_list):
+# rgb2ycbcr(img, only_y=True):
+# bgr2ycbcr(img, only_y=True):
+# ycbcr2rgb(img):
+# modcrop(img_in, scale):
+# =======================================
+'''
+
+
+def rgb2ycbcr(img, only_y=True):
+    '''same as matlab rgb2ycbcr
+    only_y: only return Y channel
+    Input:
+        uint8, [0, 255]
+        float, [0, 1]
+    '''
+    in_img_type = img.dtype
+    img.astype(np.float32)
+    if in_img_type != np.uint8:
+        img *= 255.
+    # convert
+    if only_y:
+        rlt = np.dot(img, [65.481, 128.553, 24.966]) / 255.0 + 16.0
+    else:
+        rlt = np.matmul(img, [[65.481, -37.797, 112.0], [128.553, -74.203, -93.786],
+                              [24.966, 112.0, -18.214]]) / 255.0 + [16, 128, 128]
+    if in_img_type == np.uint8:
+        rlt = rlt.round()
+    else:
+        rlt /= 255.
+    return rlt.astype(in_img_type)
+
+
+def ycbcr2rgb(img):
+    '''same as matlab ycbcr2rgb
+    Input:
+        uint8, [0, 255]
+        float, [0, 1]
+    '''
+    in_img_type = img.dtype
+    img.astype(np.float32)
+    if in_img_type != np.uint8:
+        img *= 255.
+    # convert
+    rlt = np.matmul(img, [[0.00456621, 0.00456621, 0.00456621], [0, -0.00153632, 0.00791071],
+                          [0.00625893, -0.00318811, 0]]) * 255.0 + [-222.921, 135.576, -276.836]
+    if in_img_type == np.uint8:
+        rlt = rlt.round()
+    else:
+        rlt /= 255.
+    return rlt.astype(in_img_type)
+
+
+def bgr2ycbcr(img, only_y=True):
+    '''bgr version of rgb2ycbcr
+    only_y: only return Y channel
+    Input:
+        uint8, [0, 255]
+        float, [0, 1]
+    '''
+    in_img_type = img.dtype
+    img.astype(np.float32)
+    if in_img_type != np.uint8:
+        img *= 255.
+    # convert
+    if only_y:
+        rlt = np.dot(img, [24.966, 128.553, 65.481]) / 255.0 + 16.0
+    else:
+        rlt = np.matmul(img, [[24.966, 112.0, -18.214], [128.553, -74.203, -93.786],
+                              [65.481, -37.797, 112.0]]) / 255.0 + [16, 128, 128]
+    if in_img_type == np.uint8:
+        rlt = rlt.round()
+    else:
+        rlt /= 255.
+    return rlt.astype(in_img_type)
+
+
+def modcrop(img_in, scale):
+    # img_in: Numpy, HWC or HW
+    img = np.copy(img_in)
+    if img.ndim == 2:
+        H, W = img.shape
+        H_r, W_r = H % scale, W % scale
+        img = img[:H - H_r, :W - W_r]
+    elif img.ndim == 3:
+        H, W, C = img.shape
+        H_r, W_r = H % scale, W % scale
+        img = img[:H - H_r, :W - W_r, :]
+    else:
+        raise ValueError('Wrong img ndim: [{:d}].'.format(img.ndim))
+    return img
+
+
+def shave(img_in, border=0):
+    # img_in: Numpy, HWC or HW
+    img = np.copy(img_in)
+    h, w = img.shape[:2]
+    img = img[border:h-border, border:w-border]
+    return img
+
+
+def channel_convert(in_c, tar_type, img_list):
+    # conversion among BGR, gray and y
+    if in_c == 3 and tar_type == 'gray':  # BGR to gray
+        gray_list = [cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) for img in img_list]
+        return [np.expand_dims(img, axis=2) for img in gray_list]
+    elif in_c == 3 and tar_type == 'y':  # BGR to y
+        y_list = [bgr2ycbcr(img, only_y=True) for img in img_list]
+        return [np.expand_dims(img, axis=2) for img in y_list]
+    elif in_c == 1 and tar_type == 'RGB':  # gray/y to BGR
+        return [cv2.cvtColor(img, cv2.COLOR_GRAY2BGR) for img in img_list]
+    else:
+        return img_list
+
+
+'''
+# =======================================
+# metric, PSNR and SSIM
+# =======================================
+'''
+
+
+# ----------
+# PSNR
+# ----------
+def calculate_psnr(img1, img2, border=0):
+    # img1 and img2 have range [0, 255]
+    if not img1.shape == img2.shape:
+        raise ValueError('Input images must have the same dimensions.')
+    h, w = img1.shape[:2]
+    img1 = img1[border:h-border, border:w-border]
+    img2 = img2[border:h-border, border:w-border]
+
+    img1 = img1.astype(np.float64)
+    img2 = img2.astype(np.float64)
+    mse = np.mean((img1 - img2)**2)
+    if mse == 0:
+        return float('inf')
+    return 20 * math.log10(255.0 / math.sqrt(mse))
+
+
+# ----------
+# SSIM
+# ----------
+def calculate_ssim(img1, img2, border=0):
+    '''calculate SSIM
+    the same outputs as MATLAB's
+    img1, img2: [0, 255]
+    '''
+    if not img1.shape == img2.shape:
+        raise ValueError('Input images must have the same dimensions.')
+    h, w = img1.shape[:2]
+    img1 = img1[border:h-border, border:w-border]
+    img2 = img2[border:h-border, border:w-border]
+
+    if img1.ndim == 2:
+        return ssim(img1, img2)
+    elif img1.ndim == 3:
+        if img1.shape[2] == 3:
+            ssims = []
+            for i in range(3):
+                ssims.append(ssim(img1, img2))
+            return np.array(ssims).mean()
+        elif img1.shape[2] == 1:
+            return ssim(np.squeeze(img1), np.squeeze(img2))
+    else:
+        raise ValueError('Wrong input image dimensions.')
+
+
+def ssim(img1, img2):
+    C1 = (0.01 * 255)**2
+    C2 = (0.03 * 255)**2
+
+    img1 = img1.astype(np.float64)
+    img2 = img2.astype(np.float64)
+    kernel = cv2.getGaussianKernel(11, 1.5)
+    window = np.outer(kernel, kernel.transpose())
+
+    mu1 = cv2.filter2D(img1, -1, window)[5:-5, 5:-5]  # valid
+    mu2 = cv2.filter2D(img2, -1, window)[5:-5, 5:-5]
+    mu1_sq = mu1**2
+    mu2_sq = mu2**2
+    mu1_mu2 = mu1 * mu2
+    sigma1_sq = cv2.filter2D(img1**2, -1, window)[5:-5, 5:-5] - mu1_sq
+    sigma2_sq = cv2.filter2D(img2**2, -1, window)[5:-5, 5:-5] - mu2_sq
+    sigma12 = cv2.filter2D(img1 * img2, -1, window)[5:-5, 5:-5] - mu1_mu2
+
+    ssim_map = ((2 * mu1_mu2 + C1) * (2 * sigma12 + C2)) / ((mu1_sq + mu2_sq + C1) *
+                                                            (sigma1_sq + sigma2_sq + C2))
+    return ssim_map.mean()
+
+
+'''
+# =======================================
+# pytorch version of matlab imresize
+# =======================================
+'''
+
+
+# matlab 'imresize' function, now only support 'bicubic'
+def cubic(x):
+    absx = torch.abs(x)
+    absx2 = absx**2
+    absx3 = absx**3
+    return (1.5*absx3 - 2.5*absx2 + 1) * ((absx <= 1).type_as(absx)) + \
+        (-0.5*absx3 + 2.5*absx2 - 4*absx + 2) * (((absx > 1)*(absx <= 2)).type_as(absx))
+
+
+def calculate_weights_indices(in_length, out_length, scale, kernel, kernel_width, antialiasing):
+    if (scale < 1) and (antialiasing):
+        # Use a modified kernel to simultaneously interpolate and antialias- larger kernel width
+        kernel_width = kernel_width / scale
+
+    # Output-space coordinates
+    x = torch.linspace(1, out_length, out_length)
+
+    # Input-space coordinates. Calculate the inverse mapping such that 0.5
+    # in output space maps to 0.5 in input space, and 0.5+scale in output
+    # space maps to 1.5 in input space.
+    u = x / scale + 0.5 * (1 - 1 / scale)
+
+    # What is the left-most pixel that can be involved in the computation?
+    left = torch.floor(u - kernel_width / 2)
+
+    # What is the maximum number of pixels that can be involved in the
+    # computation?  Note: it's OK to use an extra pixel here; if the
+    # corresponding weights are all zero, it will be eliminated at the end
+    # of this function.
+    P = math.ceil(kernel_width) + 2
+
+    # The indices of the input pixels involved in computing the k-th output
+    # pixel are in row k of the indices matrix.
+    indices = left.view(out_length, 1).expand(out_length, P) + torch.linspace(0, P - 1, P).view(
+        1, P).expand(out_length, P)
+
+    # The weights used to compute the k-th output pixel are in row k of the
+    # weights matrix.
+    distance_to_center = u.view(out_length, 1).expand(out_length, P) - indices
+    # apply cubic kernel
+    if (scale < 1) and (antialiasing):
+        weights = scale * cubic(distance_to_center * scale)
+    else:
+        weights = cubic(distance_to_center)
+    # Normalize the weights matrix so that each row sums to 1.
+    weights_sum = torch.sum(weights, 1).view(out_length, 1)
+    weights = weights / weights_sum.expand(out_length, P)
+
+    # If a column in weights is all zero, get rid of it. only consider the first and last column.
+    weights_zero_tmp = torch.sum((weights == 0), 0)
+    if not math.isclose(weights_zero_tmp[0], 0, rel_tol=1e-6):
+        indices = indices.narrow(1, 1, P - 2)
+        weights = weights.narrow(1, 1, P - 2)
+    if not math.isclose(weights_zero_tmp[-1], 0, rel_tol=1e-6):
+        indices = indices.narrow(1, 0, P - 2)
+        weights = weights.narrow(1, 0, P - 2)
+    weights = weights.contiguous()
+    indices = indices.contiguous()
+    sym_len_s = -indices.min() + 1
+    sym_len_e = indices.max() - in_length
+    indices = indices + sym_len_s - 1
+    return weights, indices, int(sym_len_s), int(sym_len_e)
+
+
+# --------------------------------
+# imresize for tensor image
+# --------------------------------
+def imresize(img, scale, antialiasing=True):
+    # Now the scale should be the same for H and W
+    # input: img: pytorch tensor, CHW or HW [0,1]
+    # output: CHW or HW [0,1] w/o round
+    need_squeeze = True if img.dim() == 2 else False
+    if need_squeeze:
+        img.unsqueeze_(0)
+    in_C, in_H, in_W = img.size()
+    out_C, out_H, out_W = in_C, math.ceil(in_H * scale), math.ceil(in_W * scale)
+    kernel_width = 4
+    kernel = 'cubic'
+
+    # Return the desired dimension order for performing the resize.  The
+    # strategy is to perform the resize first along the dimension with the
+    # smallest scale factor.
+    # Now we do not support this.
+
+    # get weights and indices
+    weights_H, indices_H, sym_len_Hs, sym_len_He = calculate_weights_indices(
+        in_H, out_H, scale, kernel, kernel_width, antialiasing)
+    weights_W, indices_W, sym_len_Ws, sym_len_We = calculate_weights_indices(
+        in_W, out_W, scale, kernel, kernel_width, antialiasing)
+    # process H dimension
+    # symmetric copying
+    img_aug = torch.FloatTensor(in_C, in_H + sym_len_Hs + sym_len_He, in_W)
+    img_aug.narrow(1, sym_len_Hs, in_H).copy_(img)
+
+    sym_patch = img[:, :sym_len_Hs, :]
+    inv_idx = torch.arange(sym_patch.size(1) - 1, -1, -1).long()
+    sym_patch_inv = sym_patch.index_select(1, inv_idx)
+    img_aug.narrow(1, 0, sym_len_Hs).copy_(sym_patch_inv)
+
+    sym_patch = img[:, -sym_len_He:, :]
+    inv_idx = torch.arange(sym_patch.size(1) - 1, -1, -1).long()
+    sym_patch_inv = sym_patch.index_select(1, inv_idx)
+    img_aug.narrow(1, sym_len_Hs + in_H, sym_len_He).copy_(sym_patch_inv)
+
+    out_1 = torch.FloatTensor(in_C, out_H, in_W)
+    kernel_width = weights_H.size(1)
+    for i in range(out_H):
+        idx = int(indices_H[i][0])
+        for j in range(out_C):
+            out_1[j, i, :] = img_aug[j, idx:idx + kernel_width, :].transpose(0, 1).mv(weights_H[i])
+
+    # process W dimension
+    # symmetric copying
+    out_1_aug = torch.FloatTensor(in_C, out_H, in_W + sym_len_Ws + sym_len_We)
+    out_1_aug.narrow(2, sym_len_Ws, in_W).copy_(out_1)
+
+    sym_patch = out_1[:, :, :sym_len_Ws]
+    inv_idx = torch.arange(sym_patch.size(2) - 1, -1, -1).long()
+    sym_patch_inv = sym_patch.index_select(2, inv_idx)
+    out_1_aug.narrow(2, 0, sym_len_Ws).copy_(sym_patch_inv)
+
+    sym_patch = out_1[:, :, -sym_len_We:]
+    inv_idx = torch.arange(sym_patch.size(2) - 1, -1, -1).long()
+    sym_patch_inv = sym_patch.index_select(2, inv_idx)
+    out_1_aug.narrow(2, sym_len_Ws + in_W, sym_len_We).copy_(sym_patch_inv)
+
+    out_2 = torch.FloatTensor(in_C, out_H, out_W)
+    kernel_width = weights_W.size(1)
+    for i in range(out_W):
+        idx = int(indices_W[i][0])
+        for j in range(out_C):
+            out_2[j, :, i] = out_1_aug[j, :, idx:idx + kernel_width].mv(weights_W[i])
+    if need_squeeze:
+        out_2.squeeze_()
+    return out_2
+
+
+# --------------------------------
+# imresize for numpy image
+# --------------------------------
+def imresize_np(img, scale, antialiasing=True):
+    # Now the scale should be the same for H and W
+    # input: img: Numpy, HWC or HW [0,1]
+    # output: HWC or HW [0,1] w/o round
+    img = torch.from_numpy(img)
+    need_squeeze = True if img.dim() == 2 else False
+    if need_squeeze:
+        img.unsqueeze_(2)
+
+    in_H, in_W, in_C = img.size()
+    out_C, out_H, out_W = in_C, math.ceil(in_H * scale), math.ceil(in_W * scale)
+    kernel_width = 4
+    kernel = 'cubic'
+
+    # Return the desired dimension order for performing the resize.  The
+    # strategy is to perform the resize first along the dimension with the
+    # smallest scale factor.
+    # Now we do not support this.
+
+    # get weights and indices
+    weights_H, indices_H, sym_len_Hs, sym_len_He = calculate_weights_indices(
+        in_H, out_H, scale, kernel, kernel_width, antialiasing)
+    weights_W, indices_W, sym_len_Ws, sym_len_We = calculate_weights_indices(
+        in_W, out_W, scale, kernel, kernel_width, antialiasing)
+    # process H dimension
+    # symmetric copying
+    img_aug = torch.FloatTensor(in_H + sym_len_Hs + sym_len_He, in_W, in_C)
+    img_aug.narrow(0, sym_len_Hs, in_H).copy_(img)
+
+    sym_patch = img[:sym_len_Hs, :, :]
+    inv_idx = torch.arange(sym_patch.size(0) - 1, -1, -1).long()
+    sym_patch_inv = sym_patch.index_select(0, inv_idx)
+    img_aug.narrow(0, 0, sym_len_Hs).copy_(sym_patch_inv)
+
+    sym_patch = img[-sym_len_He:, :, :]
+    inv_idx = torch.arange(sym_patch.size(0) - 1, -1, -1).long()
+    sym_patch_inv = sym_patch.index_select(0, inv_idx)
+    img_aug.narrow(0, sym_len_Hs + in_H, sym_len_He).copy_(sym_patch_inv)
+
+    out_1 = torch.FloatTensor(out_H, in_W, in_C)
+    kernel_width = weights_H.size(1)
+    for i in range(out_H):
+        idx = int(indices_H[i][0])
+        for j in range(out_C):
+            out_1[i, :, j] = img_aug[idx:idx + kernel_width, :, j].transpose(0, 1).mv(weights_H[i])
+
+    # process W dimension
+    # symmetric copying
+    out_1_aug = torch.FloatTensor(out_H, in_W + sym_len_Ws + sym_len_We, in_C)
+    out_1_aug.narrow(1, sym_len_Ws, in_W).copy_(out_1)
+
+    sym_patch = out_1[:, :sym_len_Ws, :]
+    inv_idx = torch.arange(sym_patch.size(1) - 1, -1, -1).long()
+    sym_patch_inv = sym_patch.index_select(1, inv_idx)
+    out_1_aug.narrow(1, 0, sym_len_Ws).copy_(sym_patch_inv)
+
+    sym_patch = out_1[:, -sym_len_We:, :]
+    inv_idx = torch.arange(sym_patch.size(1) - 1, -1, -1).long()
+    sym_patch_inv = sym_patch.index_select(1, inv_idx)
+    out_1_aug.narrow(1, sym_len_Ws + in_W, sym_len_We).copy_(sym_patch_inv)
+
+    out_2 = torch.FloatTensor(out_H, out_W, in_C)
+    kernel_width = weights_W.size(1)
+    for i in range(out_W):
+        idx = int(indices_W[i][0])
+        for j in range(out_C):
+            out_2[:, i, j] = out_1_aug[:, idx:idx + kernel_width, j].mv(weights_W[i])
+    if need_squeeze:
+        out_2.squeeze_()
+
+    return out_2.numpy()
+
+
+if __name__ == '__main__':
+    img = imread_uint('test.bmp',3)

utils/utils_logger.py

@@ -0,0 +1,58 @@
+import os
+import sys
+import datetime
+import logging
+
+
+def log(*args, **kwargs):
+    print(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S:"), *args, **kwargs)
+
+
+'''
+# ===============================
+# logger
+# logger_name = None = 'base' ???
+# ===============================
+'''
+
+
+def logger_info(logger_name, log_path='default_logger.log'):
+    ''' set up logger
+    modified by Kai Zhang (github: https://github.com/cszn)
+    '''
+    log = logging.getLogger(logger_name)
+    if log.hasHandlers():
+        print('LogHandlers exist!')
+    else:
+        print('LogHandlers setup!')
+        level = logging.INFO
+        formatter = logging.Formatter('%(asctime)s.%(msecs)03d : %(message)s', datefmt='%y-%m-%d %H:%M:%S')
+        fh = logging.FileHandler(log_path, mode='a')
+        fh.setFormatter(formatter)
+        log.setLevel(level)
+        log.addHandler(fh)
+        # print(len(log.handlers))
+
+        sh = logging.StreamHandler()
+        sh.setFormatter(formatter)
+        log.addHandler(sh)
+
+
+'''
+# ===============================
+# print to file and std_out simultaneously
+# ===============================
+'''
+
+
+class logger_print(object):
+    def __init__(self, log_path="default.log"):
+        self.terminal = sys.stdout
+        self.log = open(log_path, 'a')
+
+    def write(self, message):
+        self.terminal.write(message)
+        self.log.write(message)  # write the message
+
+    def flush(self):
+        pass