|
import torch |
|
import torch.nn as nn |
|
|
|
from basicsr.utils.registry import ARCH_REGISTRY |
|
from .arch_util import ResidualBlockNoBN, make_layer |
|
|
|
|
|
class MeanShift(nn.Conv2d): |
|
""" Data normalization with mean and std. |
|
|
|
Args: |
|
rgb_range (int): Maximum value of RGB. |
|
rgb_mean (list[float]): Mean for RGB channels. |
|
rgb_std (list[float]): Std for RGB channels. |
|
sign (int): For subtraction, sign is -1, for addition, sign is 1. |
|
Default: -1. |
|
requires_grad (bool): Whether to update the self.weight and self.bias. |
|
Default: True. |
|
""" |
|
|
|
def __init__(self, rgb_range, rgb_mean, rgb_std, sign=-1, requires_grad=True): |
|
super(MeanShift, self).__init__(3, 3, kernel_size=1) |
|
std = torch.Tensor(rgb_std) |
|
self.weight.data = torch.eye(3).view(3, 3, 1, 1) |
|
self.weight.data.div_(std.view(3, 1, 1, 1)) |
|
self.bias.data = sign * rgb_range * torch.Tensor(rgb_mean) |
|
self.bias.data.div_(std) |
|
self.requires_grad = requires_grad |
|
|
|
|
|
class EResidualBlockNoBN(nn.Module): |
|
"""Enhanced Residual block without BN. |
|
|
|
There are three convolution layers in residual branch. |
|
""" |
|
|
|
def __init__(self, in_channels, out_channels): |
|
super(EResidualBlockNoBN, self).__init__() |
|
|
|
self.body = nn.Sequential( |
|
nn.Conv2d(in_channels, out_channels, 3, 1, 1), |
|
nn.ReLU(inplace=True), |
|
nn.Conv2d(out_channels, out_channels, 3, 1, 1), |
|
nn.ReLU(inplace=True), |
|
nn.Conv2d(out_channels, out_channels, 1, 1, 0), |
|
) |
|
self.relu = nn.ReLU(inplace=True) |
|
|
|
def forward(self, x): |
|
out = self.body(x) |
|
out = self.relu(out + x) |
|
return out |
|
|
|
|
|
class MergeRun(nn.Module): |
|
""" Merge-and-run unit. |
|
|
|
This unit contains two branches with different dilated convolutions, |
|
followed by a convolution to process the concatenated features. |
|
|
|
Paper: Real Image Denoising with Feature Attention |
|
Ref git repo: https://github.com/saeed-anwar/RIDNet |
|
""" |
|
|
|
def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, padding=1): |
|
super(MergeRun, self).__init__() |
|
|
|
self.dilation1 = nn.Sequential( |
|
nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding), nn.ReLU(inplace=True), |
|
nn.Conv2d(out_channels, out_channels, kernel_size, stride, 2, 2), nn.ReLU(inplace=True)) |
|
self.dilation2 = nn.Sequential( |
|
nn.Conv2d(in_channels, out_channels, kernel_size, stride, 3, 3), nn.ReLU(inplace=True), |
|
nn.Conv2d(out_channels, out_channels, kernel_size, stride, 4, 4), nn.ReLU(inplace=True)) |
|
|
|
self.aggregation = nn.Sequential( |
|
nn.Conv2d(out_channels * 2, out_channels, kernel_size, stride, padding), nn.ReLU(inplace=True)) |
|
|
|
def forward(self, x): |
|
dilation1 = self.dilation1(x) |
|
dilation2 = self.dilation2(x) |
|
out = torch.cat([dilation1, dilation2], dim=1) |
|
out = self.aggregation(out) |
|
out = out + x |
|
return out |
|
|
|
|
|
class ChannelAttention(nn.Module): |
|
"""Channel attention. |
|
|
|
Args: |
|
num_feat (int): Channel number of intermediate features. |
|
squeeze_factor (int): Channel squeeze factor. Default: |
|
""" |
|
|
|
def __init__(self, mid_channels, squeeze_factor=16): |
|
super(ChannelAttention, self).__init__() |
|
self.attention = nn.Sequential( |
|
nn.AdaptiveAvgPool2d(1), nn.Conv2d(mid_channels, mid_channels // squeeze_factor, 1, padding=0), |
|
nn.ReLU(inplace=True), nn.Conv2d(mid_channels // squeeze_factor, mid_channels, 1, padding=0), nn.Sigmoid()) |
|
|
|
def forward(self, x): |
|
y = self.attention(x) |
|
return x * y |
|
|
|
|
|
class EAM(nn.Module): |
|
"""Enhancement attention modules (EAM) in RIDNet. |
|
|
|
This module contains a merge-and-run unit, a residual block, |
|
an enhanced residual block and a feature attention unit. |
|
|
|
Attributes: |
|
merge: The merge-and-run unit. |
|
block1: The residual block. |
|
block2: The enhanced residual block. |
|
ca: The feature/channel attention unit. |
|
""" |
|
|
|
def __init__(self, in_channels, mid_channels, out_channels): |
|
super(EAM, self).__init__() |
|
|
|
self.merge = MergeRun(in_channels, mid_channels) |
|
self.block1 = ResidualBlockNoBN(mid_channels) |
|
self.block2 = EResidualBlockNoBN(mid_channels, out_channels) |
|
self.ca = ChannelAttention(out_channels) |
|
|
|
self.relu = nn.ReLU(inplace=True) |
|
|
|
def forward(self, x): |
|
out = self.merge(x) |
|
out = self.relu(self.block1(out)) |
|
out = self.block2(out) |
|
out = self.ca(out) |
|
return out |
|
|
|
|
|
@ARCH_REGISTRY.register() |
|
class RIDNet(nn.Module): |
|
"""RIDNet: Real Image Denoising with Feature Attention. |
|
|
|
Ref git repo: https://github.com/saeed-anwar/RIDNet |
|
|
|
Args: |
|
in_channels (int): Channel number of inputs. |
|
mid_channels (int): Channel number of EAM modules. |
|
Default: 64. |
|
out_channels (int): Channel number of outputs. |
|
num_block (int): Number of EAM. Default: 4. |
|
img_range (float): Image range. Default: 255. |
|
rgb_mean (tuple[float]): Image mean in RGB orders. |
|
Default: (0.4488, 0.4371, 0.4040), calculated from DIV2K dataset. |
|
""" |
|
|
|
def __init__(self, |
|
in_channels, |
|
mid_channels, |
|
out_channels, |
|
num_block=4, |
|
img_range=255., |
|
rgb_mean=(0.4488, 0.4371, 0.4040), |
|
rgb_std=(1.0, 1.0, 1.0)): |
|
super(RIDNet, self).__init__() |
|
|
|
self.sub_mean = MeanShift(img_range, rgb_mean, rgb_std) |
|
self.add_mean = MeanShift(img_range, rgb_mean, rgb_std, 1) |
|
|
|
self.head = nn.Conv2d(in_channels, mid_channels, 3, 1, 1) |
|
self.body = make_layer( |
|
EAM, num_block, in_channels=mid_channels, mid_channels=mid_channels, out_channels=mid_channels) |
|
self.tail = nn.Conv2d(mid_channels, out_channels, 3, 1, 1) |
|
|
|
self.relu = nn.ReLU(inplace=True) |
|
|
|
def forward(self, x): |
|
res = self.sub_mean(x) |
|
res = self.tail(self.body(self.relu(self.head(res)))) |
|
res = self.add_mean(res) |
|
|
|
out = x + res |
|
return out |
|
|
