def __init__(self, num_block, num_feature, scale, n_colors=15, res_scale=0.1, conv=common.default_conv, isTrain=True): super(EDSR, self).__init__() n_resblocks = num_block n_feats = num_feature scale = scale kernel_size = 3 act = nn.LeakyReLU(negative_slope=0.1, inplace=True) # define head module # define body module m_body = [ common.ResBlock(conv, n_feats, kernel_size, act=act, res_scale=res_scale) for _ in range(n_resblocks) ] m_body.append(conv(n_feats, n_feats, kernel_size)) self.body = nn.Sequential(*m_body) self.down_x2 = nn.Sequential( nn.Conv2d(n_feats, n_feats, kernel_size=3, stride=2, padding=1), act) self.up_x2 = common.Upsampler(conv, scale=2, n_feats=n_feats, act=act) self.down_x4 = nn.Sequential( nn.Conv2d(n_feats, n_feats, kernel_size=3, stride=2, padding=1), act) self.up_x4 = common.Upsampler(conv, scale=2, n_feats=n_feats, act=act) self.upsampler_2 = common.Upsampler(conv, scale=2, n_feats=n_feats, act=act) self.upsampler_4 = common.Upsampler(conv, scale=4, n_feats=n_feats, act=act) self.head_y = conv(5, n_feats, kernel_size) self.head_uv = conv(10, n_feats, kernel_size) self.y_out = conv(n_feats, 1, kernel_size) self.uv_out = conv(n_feats, 2, kernel_size) self.isTrain = isTrain
def __init__(self, num_block, num_feature, scale, n_colors=15, res_scale=0.1, conv=common.default_conv, isTrain=True): super(EDSR, self).__init__() n_resblocks = num_block n_feats = num_feature scale = scale kernel_size = 3 act = nn.ReLU(True) # define head module m_head = [conv(n_colors, n_feats, kernel_size)] # define body module m_body = [ common.ResBlock(conv, n_feats, kernel_size, act=act, res_scale=res_scale) for _ in range(n_resblocks) ] m_body.append(conv(n_feats, n_feats, kernel_size)) self.head = nn.Sequential(*m_head) self.body = nn.Sequential(*m_body) self.uv_up2 = common.Upsampler(conv, scale=2, n_feats=10, act=False) self.y_out_up4 = common.Upsampler(conv, scale=4, n_feats=n_feats, act=False) self.uv_out_up2 = common.Upsampler(conv, scale=2, n_feats=n_feats, act=False) self.y_res_up4 = nn.Sequential( common.Upsampler(conv, scale=4, n_feats=5, act=False), conv(5, n_feats, kernel_size)) self.y_out = conv(n_feats, 1, kernel_size) self.uv_res_up4 = nn.Sequential( common.Upsampler(conv, scale=4, n_feats=10, act=False), conv(10, n_feats, kernel_size)) self.uv_out = conv(n_feats, 2, kernel_size) self.isTrain = isTrain
def __init__(self, conv=default_conv, isTrain=True, num_feature=64): # 这个con是最最普通的那种卷积 super(RCAN, self).__init__() n_resgroups = 10 # 残差组的数量 n_resblocks = 20 # 残差块的数量 n_feats = num_feature # 特征的数量,即通道 kernel_size = 3 reduction = 16 # 论文中的那个r因子 scale = 4 # 默认只进行一个因子的训练 act = nn.ReLU(True) # True就是进行原位运算 # define head module modules_head = [conv(15, n_feats, 3)] # n_colors使用的通道数 # define body module modules_body = [ ResidualGroup( # act激活函数,残差缩放比例 conv, n_feats, kernel_size, reduction, act=act, res_scale=1, n_resblocks=n_resblocks) \ for _ in range(n_resgroups)] modules_body.append(conv(n_feats, n_feats, kernel_size)) # 主体尾巴那个小卷积层 self.uv_up2 = common.Upsampler(conv, scale=2, n_feats=10, act=False) self.y_out_up4 = common.Upsampler(conv, scale=4, n_feats=n_feats, act=False) self.uv_out_up2 = common.Upsampler(conv, scale=2, n_feats=n_feats, act=False) self.y_res_up4 = nn.Sequential( common.Upsampler(conv, scale=4, n_feats=5, act=False), conv(5, n_feats, kernel_size)) self.yy_out = conv(n_feats, 1, kernel_size) self.uv_res_up4 = nn.Sequential( common.Upsampler(conv, scale=4, n_feats=10, act=False), conv(10, n_feats, kernel_size)) self.uuv_out = conv(n_feats, 2, kernel_size) self.head = nn.Sequential(*modules_head) self.body = nn.Sequential(*modules_body) self.PS = nn.PixelShuffle(scale) self.isTrain = isTrain
def __init__(self, args, conv=common.default_conv): super(RCAN, self).__init__() n_resgroups = args['n_resgroups'] n_resblocks = args['n_resblocks'] n_feats = args['n_feats'] kernel_size = 3 reduction = args['reduction'] scale = args['scale'] act = nn.ReLU(True) # RGB mean for DIV2K rgb_mean = (0.4488, 0.4371, 0.4040) rgb_std = (1.0, 1.0, 1.0) self.sub_mean = common.MeanShift(args['rgb_range'], rgb_mean, rgb_std) #define head module modules_head = [conv(args['n_colors'], n_feats, kernel_size)] #define body module modules_body = [ ResidualGroup( conv, n_feats, kernel_size, reduction, act=act, res_scale=args['res_scale'], n_resblocks=n_resblocks ) for _ in range(n_resgroups) ] #define tail module modules_tail = [ common.Upsampler(conv, scale, n_feats, act=False), conv(n_feats, args['n_colors'], kernel_size) ] self.add_mean = common.MeanShift(args['rgb_range'], rgb_mean, rgb_std, 1) self.head = nn.Sequential(*modules_head) self.body = nn.Sequential(*modules_body) self.tail = nn.Sequential(*modules_tail)
def __init__(self, args, conv=common.default_conv): super(EDSR, self).__init__() self.args = args n_resblocks = args.n_resblocks n_feats = args.n_feats kernel_size = 3 scale = args.scale[0] act = nn.ReLU(True) self.sub_mean = common.MeanShift(args.rgb_range) self.add_mean = common.MeanShift(args.rgb_range, sign=1) # define head module m_head = [conv(args.n_colors, n_feats, kernel_size)] # define body module self.block_num = [ int(n_resblocks / 3), int(2 * n_resblocks / 3) - int(n_resblocks / 3), n_resblocks - int(2 * n_resblocks / 3) ] m_body1 = [ common.ResBlock(conv, n_feats, kernel_size, act=act, res_scale=args.res_scale) for _ in range(self.block_num[0]) ] m_body2 = [ common.ResBlock(conv, n_feats, kernel_size, act=act, res_scale=args.res_scale) for _ in range(self.block_num[1]) ] m_body3 = [ common.ResBlock(conv, n_feats, kernel_size, act=act, res_scale=args.res_scale) for _ in range(self.block_num[2]) ] m_body3.append(conv(n_feats, n_feats, kernel_size)) # define tail module m_tail = [ common.Upsampler(conv, scale, n_feats, act=False), conv(n_feats, args.n_colors, kernel_size) ] self.head = nn.Sequential(*m_head) self.body1 = nn.Sequential(*m_body1) self.body2 = nn.Sequential(*m_body2) self.body3 = nn.Sequential(*m_body3) self.tail = nn.Sequential(*m_tail)
def __init__(self, args, conv=common.default_conv): super(RCAN, self).__init__() self.args = args self.n_resgroups = args.n_resgroups n_resblocks = args.n_resblocks n_feats = args.n_feats kernel_size = 3 reduction = args.reduction scale = args.scale[0] act = nn.ReLU(True) # RGB mean for DIV2K self.sub_mean = common.MeanShift(args.rgb_range) # define head module modules_head = [conv(args.n_colors, n_feats, kernel_size)] # define body module for group_id in range(self.n_resgroups): setattr(self, 'body_group{}'.format(str(group_id)), ResidualGroup(conv, n_feats, kernel_size, reduction, act=act, res_scale=args.res_scale, n_resblocks=n_resblocks)) self.body_tail = conv(n_feats, n_feats, kernel_size) # define tail module modules_tail = [ common.Upsampler(conv, scale, n_feats, act=False), conv(n_feats, args.n_colors, kernel_size)] self.add_mean = common.MeanShift(args.rgb_range, sign=1) self.head = nn.Sequential(*modules_head) self.tail = nn.Sequential(*modules_tail)
def __init__(self, args, conv=common.default_conv): super(EDSR, self).__init__() n_resblock = args['n_resblocks'] n_feats = args['n_feats'] kernel_size = 3 scale = args['scale'] act = nn.ReLU(True) # RGB mean for DIV2K rgb_mean = (0.4488, 0.4371, 0.4040) rgb_std = (1.0, 1.0, 1.0) self.sub_mean = common.MeanShift(args['rgb_range'], rgb_mean, rgb_std) # define head module m_head = [conv(args['n_colors'], n_feats, kernel_size)] # define body module m_body = [ common.ResBlock(conv, n_feats, kernel_size, act=act, res_scale=args['res_scale']) for _ in range(n_resblock) ] m_body.append(conv(n_feats, n_feats, kernel_size)) # define tail module m_tail = [ common.Upsampler(conv, scale, n_feats, act=False), conv(n_feats, args['n_colors'], kernel_size) ] self.add_mean = common.MeanShift(args['rgb_range'], rgb_mean, rgb_std, 1) self.head = nn.Sequential(*m_head) self.body = nn.Sequential(*m_body) self.tail = nn.Sequential(*m_tail)
def __init__(self, num_block, num_feature, scale, n_colors=15, res_scale=0.1, conv=common.default_conv, isTrain=True): super(UNET, self).__init__() n_resblocks = num_block n_feats = num_feature scale = scale kernel_size = 3 act = nn.ReLU(True) self.head = common.default_conv(n_colors, n_feats, kernel_size) self.inc = common.inconv(num_feature, num_feature) self.down1 = common.down(num_feature, num_feature) self.down2 = common.down(num_feature, num_feature) self.up1 = common.up(num_feature, num_feature) self.up2 = common.up(num_feature, num_feature) self.uv_up2 = common.Upsampler(conv, scale=2, n_feats=10, act=False) self.y_out_up4 = common.Upsampler(conv, scale=4, n_feats=n_feats, act=False) self.uv_out_up2 = common.Upsampler(conv, scale=2, n_feats=n_feats, act=False) self.y_res_up4 = nn.Sequential( common.Upsampler(conv, scale=4, n_feats=5, act=False), conv(5, n_feats, kernel_size)) self.y_out = conv(n_feats, 1, kernel_size) self.uv_res_up4 = nn.Sequential( common.Upsampler(conv, scale=4, n_feats=10, act=False), conv(10, n_feats, kernel_size)) self.uv_out = conv(n_feats, 2, kernel_size) self.isTrain = isTrain
def __init__(self, args, conv=common.default_conv): super(SAN, self).__init__() n_resgroups = args.n_resgroups n_resblocks = args.n_resblocks n_feats = args.n_feats kernel_size = 3 reduction = args.reduction scale = args.scale[0] act = nn.ReLU(inplace=True) # RGB mean for DIV2K rgb_mean = (0.4488, 0.4371, 0.4040) rgb_std = (1.0, 1.0, 1.0) self.sub_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std) # self.soca= SOCA(n_feats, reduction=reduction) # define head module modules_head = [conv(args.n_colors, n_feats, kernel_size)] # define body module ## share-source skip connection ## self.gamma = nn.Parameter(torch.zeros(1)) # self.gamma = 0.2 self.n_resgroups = n_resgroups self.RG = nn.ModuleList([LSRAG(conv, n_feats, kernel_size, reduction, \ act=act, res_scale=args.res_scale, n_resblocks=n_resblocks) for _ in range(n_resgroups)]) self.conv_last = conv(n_feats, n_feats, kernel_size) # modules_body = [ # ResidualGroup( # conv, n_feats, kernel_size, reduction, act=act, res_scale=args.res_scale, n_resblocks=n_resblocks) \ # for _ in range(n_resgroups)] # modules_body.append(conv(n_feats, n_feats, kernel_size)) # define tail module modules_tail = [ common.Upsampler(conv, scale, n_feats, act=False), conv(n_feats, args.n_colors, kernel_size) ] self.add_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std, 1) self.non_local = Nonlocal_CA(in_feat=n_feats, inter_feat=n_feats // 4, reduction=8, sub_sample=False, bn_layer=False) self.head = nn.Sequential(*modules_head) # self.body = nn.Sequential(*modules_body) self.tail = nn.Sequential(*modules_tail) if n_resgroups == 20: self.pos = [6, 13] elif n_resgroups == 6: self.pos = [1, 3]
def __init__(self, args, conv=common.default_conv): conv = common.default_conv conv1x1 = common.conv_1x1_9_layer super(EDSR, self).__init__() self.args = args n_resblocks = args.n_resblocks n_feats = args.n_feats kernel_size = 3 scale = args.scale act = nn.ReLU(True) # url_name = 'r{}f{}x{}'.format(n_resblocks, n_feats, scale) # if url_name in url: # self.url = url[url_name] # else: # self.url = None self.sub_mean = common.MeanShift(args.rgb_range, args.rgb_mean, args.rgb_std) self.add_mean = common.MeanShift(args.rgb_range, args.rgb_mean, args.rgb_std, 1) # define head module m_head = [conv(args.n_colors, n_feats, kernel_size)] # define body module # 3x3 conv, secure receptive field modules (original) m_body = [ common.ResBlock(conv, n_feats, kernel_size, act=act, res_scale=args.res_scale) for _ in range(60) ] # 1x1 conv, secure depth modules m_body += [ common.ResBlock(conv1x1, n_feats, kernel_size, act=act, res_scale=args.res_scale) for _ in range(60, n_resblocks) ] m_body.append(conv1x1(n_feats, n_feats, kernel_size)) # define tail module m_tail = [ common.Upsampler(conv, scale, n_feats, act=False), conv(n_feats, args.n_colors, kernel_size) ] self.head = nn.Sequential(*m_head) self.body = nn.Sequential(*m_body) self.tail = nn.Sequential(*m_tail)
def __init__(self, args, conv=common.default_conv): conv = common.default_conv conv_1x1 = common.conv_1x1_9_layer super(RCAN, self).__init__() self.args = args n_resgroups = args.n_resgroups n_resblocks = args.n_resblocks n_feats = args.n_feats kernel_size = 3 reduction = args.reduction scale = args.scale if args.act_ver == 1: act = nn.ReLU(True) elif args.act_ver == 2: act = nn.LeakyReLU(negative_slope=0.01, inplace=True) elif args.act_ver == 3: act = nn.PReLU() # RGB mean for DIV2K # rgb_mean = (0.4488, 0.4371, 0.4040) # rgb_std = (1.0, 1.0, 1.0) self.sub_mean = common.MeanShift(args.rgb_range, args.rgb_mean, args.rgb_std) # define head module modules_head = [conv(args.n_colors, n_feats, kernel_size)] # define body module # 3x3 conv, secure receptive field modules (original) modules_body = [ ResidualGroup( conv, n_feats, kernel_size, reduction, act=act, res_scale=args.res_scale, n_resblocks=n_resblocks) \ for _ in range(3)] # 1x1 conv, secure depth modules modules_body += [ ResidualGroup_1x1( conv_1x1, n_feats, kernel_size, reduction, act=act, res_scale=args.res_scale, n_resblocks=n_resblocks) \ for _ in range(3, n_resgroups)] modules_body.append(conv_1x1(n_feats, n_feats, kernel_size)) # define tail module modules_tail = [ common.Upsampler(conv, scale, n_feats, act=False), conv(n_feats, args.n_colors, kernel_size) ] self.add_mean = common.MeanShift(args.rgb_range, args.rgb_mean, args.rgb_std, 1) self.head = nn.Sequential(*modules_head) self.body = nn.Sequential(*modules_body) self.tail = nn.Sequential(*modules_tail)
def __init__(self, args, conv=default_conv): super(RCANModule, self).__init__() n_resgroups = args['n_resgroups'] n_resblocks = args['n_resblocks'] n_feats = args['n_feats'] kernel_size = 3 reduction = args['reduction'] self.sr_factor = args['scale'] act = nn.ReLU(True) n_colors = args['n_colors'] in_size = args['in_size'] self.weight_3 = nn.Sequential( nn.Conv2d(n_colors * 3, n_colors, kernel_size=1, stride=1), nn.ReLU(True), nn.Conv2d(n_colors, 3, kernel_size=1, stride=1), nn.Softmax(dim=1)) # define head module modules_head = [conv(in_size, n_feats, kernel_size)] # define body module modules_body = [ ResidualGroup(conv, n_feats, kernel_size, reduction, act=act, res_scale=args['res_scale'], n_resblocks=n_resblocks) for _ in range(n_resgroups) ] # define tail module if self.sr_factor == 1: modules_tail = [ conv(n_feats, n_feats, 3), nn.ReLU(True), conv(n_feats, n_colors, 3) ] else: modules_tail = [ common.Upsampler(conv, self.sr_factor, n_feats, act=False), conv(n_feats, n_colors, 3) ] # self.add_mean = common.MeanShift(args['rgb_range'], rgb_mean, rgb_std, 1) self.head = nn.Sequential(*modules_head) self.body = nn.Sequential(*modules_body) self.tail = nn.Sequential(*modules_tail)
def __init__(self, n_colors, n_resgroups=10, n_resblocks=20, n_feats=64, reduction=16, upsampler_scale=1, conv=common.default_conv): super(RCAN, self).__init__() n_resgroups = n_resgroups n_resblocks = n_resblocks n_feats = n_feats kernel_size = 3 reduction = reduction scale = int(upsampler_scale) act = nn.ReLU(True) # # RGB mean for DIV2K # rgb_mean = (0.4488, 0.4371, 0.4040) # rgb_std = (1.0, 1.0, 1.0) # self.sub_mean = common.MeanShift(rgb_range, rgb_mean, rgb_std) # define head module modules_head = [conv(n_colors, n_feats, kernel_size)] # define body module modules_body = [ ResidualGroup(conv, n_feats, kernel_size, reduction, act=act, n_resblocks=n_resblocks) for _ in range(n_resgroups) ] modules_body.append(conv(n_feats, n_feats, kernel_size)) # define tail module modules_tail = [ common.Upsampler(conv, scale, n_feats, act=False), conv(n_feats, n_colors, kernel_size) ] # self.add_mean = common.MeanShift(rgb_range, rgb_mean, rgb_std, 1) self.head = nn.Sequential(*modules_head) self.body = nn.Sequential(*modules_body) self.tail = nn.Sequential(*modules_tail)
def __init__(self, conv=common.default_conv, n_resblock=8, n_filters=64, scale=4, rgb_range=255, n_colors=1, res_scale=1): super(EDSR, self).__init__() # n_resblock = args.n_resblocks # n_feats = args.n_feats kernel_size = 3 # scale = args.scale[0] act = nn.ReLU(True) rgb_mean = (0.4488, 0.4371, 0.4040) rgb_std = (1.0, 1.0, 1.0) # self.sub_mean = common.MeanShift(rgb_range, rgb_mean, -1) # rgb_std) # define head module m_head = [conv(n_colors, n_filters, kernel_size)] # define body module m_body = [ common.ResBlock(conv, n_filters, kernel_size, act=act, res_scale=res_scale) for _ in range(n_resblock) ] m_body.append(conv(n_filters, n_filters, kernel_size)) # define tail module m_tail = [ common.Upsampler(conv, scale, n_filters, act=False), conv(n_filters, n_colors, kernel_size) ] # self.add_mean = common.MeanShift(rgb_range, rgb_mean, 1) # rgb_std, 1) self.head = nn.Sequential(*m_head) self.body = nn.Sequential(*m_body) self.tail = nn.Sequential(*m_tail)
def __init__(self, block, layers, num_classes=2, zero_init_residual=False): super(ResNet, self).__init__() self.inplanes = 64 self.conv1 = nn.Conv2d(15, 64, kernel_size=7, stride=2, padding=3, bias=False) self.bn1 = nn.BatchNorm2d(64) self.relu = nn.ReLU(inplace=True) self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1) self.layer1 = self._make_layer(block, 64, layers[0]) self.layer2 = self._make_layer(block, 128, layers[1], stride=2) self.layer3 = self._make_layer(block, 256, layers[2], stride=2) self.layer4 = self._make_layer(block, 512, layers[3], stride=2) self.avgpool = nn.AdaptiveAvgPool2d((1, 1)) self.fc = nn.Linear(512 * block.expansion, num_classes) self.uv_up2 = common.Upsampler(common.default_conv, scale=2, n_feats=10, act=False) for m in self.modules(): if isinstance(m, nn.Conv2d): nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') elif isinstance(m, nn.BatchNorm2d): nn.init.constant_(m.weight, 1) nn.init.constant_(m.bias, 0) # Zero-initialize the last BN in each residual branch, # so that the residual branch starts with zeros, and each residual block behaves like an identity. # This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677 if zero_init_residual: for m in self.modules(): if isinstance(m, Bottleneck): nn.init.constant_(m.bn3.weight, 0) elif isinstance(m, BasicBlock): nn.init.constant_(m.bn2.weight, 0)
def __init__(self, args, conv=common.default_conv): super(RCAN, self).__init__() ##added # self.down4x = nn.Upsample(scale_factor=4, mode='bilinear') ### n_resgroups = args.n_resgroups n_resblocks = args.n_resblocks n_feats = args.n_feats kernel_size = 3 reduction = args.reduction scale = args.scale[0] act = nn.ReLU(True) # RGB mean for DIV2K rgb_mean = (0.4488, 0.4371, 0.4040) rgb_std = (1.0, 1.0, 1.0) self.sub_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std) # define head module modules_head = [conv(args.n_colors, n_feats, kernel_size)] # define body module modules_body = [ ResidualGroup( conv, n_feats, kernel_size, reduction, act=act, res_scale=args.res_scale, n_resblocks=n_resblocks) \ for _ in range(n_resgroups)] modules_body.append(conv(n_feats, n_feats, kernel_size)) # define tail module modules_tail = [ common.Upsampler(conv, scale, n_feats, act=False), conv(n_feats, args.n_colors, kernel_size) ] self.add_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std, 1) self.head = nn.Sequential(*modules_head) self.body = nn.Sequential(*modules_body) self.tail = nn.Sequential(*modules_tail)
def __init__(self, args, conv=common.default_conv): super(SWLA, self).__init__() self.args = args self.scale = args.scale self.lr_p_size = args.patch_size // self.scale self.device = torch.device('cpu' if args.cpu else 'cuda') n_resgroups = args.n_resgroups n_resblocks = args.n_resblocks n_feats = args.n_feats kernel_size = 3 act = nn.ReLU(True) # RGB mean for DIV2K # rgb_mean = (0.4488, 0.4371, 0.4040) # rgb_std = (1.0, 1.0, 1.0) self.sub_mean = common.MeanShift(args.rgb_range, args.rgb_mean, args.rgb_std) # define head module modules_head = [conv(args.n_colors, n_feats, kernel_size)] # define body module modules_body = [ ResidualGroup( conv, n_feats, kernel_size, act=act, res_scale=args.res_scale, n_resblocks=n_resblocks) \ for _ in range(n_resgroups)] modules_body.append(conv(n_feats, n_feats, kernel_size)) # define tail module modules_tail = [ common.Upsampler(conv, self.args.scale, n_feats, act=False), conv(n_feats, args.n_colors, kernel_size)] self.add_mean = common.MeanShift(args.rgb_range, args.rgb_mean, args.rgb_std, 1) self.head = nn.Sequential(*modules_head) self.body = nn.Sequential(*modules_body) self.tail = nn.Sequential(*modules_tail)
data_uv_2x = PS(data_uv_2x) data_yuv = torch.cat([data_y, data_uv_2x], dim=1) outputs = cls_net(data_yuv) # print(len(outputs), len(cls_label)) # print(outputs.size(), cls_label.squeeze().size()) loss = criterion(outputs, cls_label.squeeze()) optimizer.zero_grad() loss.backward() optimizer.step() if iteration % 20 == 0: print('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'.format( epoch, config.numEpoch, iteration + 1, total_step, loss.item())) upsample = common.Upsampler(common.default_conv, scale=2, n_feats=10, act=False) if epoch % 2 == 0: save_checkpoint(cls_net, None, epoch, config.checkpoint) correct = 0 total = 0 cls_net.eval() for iteration, batch in enumerate(test_data_loader, 1): data_y = batch[0] data_uv = batch[2] cls_label = batch[4] data_y = data_y.to(device) data_uv = data_uv.to(device) cls_label = cls_label.to(device) data_y -= 127.5
def __init__(self, args, conv=common.default_conv): super(SAN, self).__init__() self.args = args conv = common.default_conv conv1x1 = common.conv_1x1_9_layer n_resgroups = args.n_resgroups n_resblocks = args.n_resblocks n_feats = args.n_feats kernel_size = 3 reduction = args.reduction scale = args.scale act = nn.ReLU(inplace=True) # change it to leaky relu???!#!#!#!# if args.act_ver == 1: act = nn.ReLU(True) elif args.act_ver == 2: act = nn.LeakyReLU(negative_slope=0.2, inplace=True) elif args.act_ver == 3: act = nn.PReLU() # RGB mean for DIV2K # rgb_mean = (0.4488, 0.4371, 0.4040) # rgb_std = (1.0, 1.0, 1.0) self.sub_mean = common.MeanShift(args.rgb_range, args.rgb_mean, args.rgb_std) # self.soca= SOCA(n_feats, reduction=reduction) # define head module modules_head = [conv(args.n_colors, n_feats, kernel_size)] # define body module ## share-source skip connection ## self.gamma = nn.Parameter(torch.zeros(1)) # self.gamma = 0.2 self.n_resgroups = n_resgroups # 3x3 conv, secure proper receptive field area RG = [LSRAG(conv, n_feats, kernel_size, reduction, \ act=act, res_scale=args.res_scale, n_resblocks=n_resblocks) for _ in range(3)] # 1x1 conv, secure depth area RG += [LSRAG(conv1x1, n_feats, kernel_size, reduction, \ act=act, res_scale=args.res_scale, n_resblocks=n_resblocks) for _ in range(3, n_resgroups)] self.RG = nn.ModuleList(RG) self.conv_last = conv1x1(n_feats, n_feats, kernel_size) # modules_body = [ # ResidualGroup( # conv, n_feats, kernel_size, reduction, act=act, res_scale=args.res_scale, n_resblocks=n_resblocks) \ # for _ in range(n_resgroups)] # modules_body.append(conv(n_feats, n_feats, kernel_size)) # define tail module modules_tail = [ common.Upsampler(conv, scale, n_feats, act=False), conv(n_feats, args.n_colors, kernel_size) ] self.add_mean = common.MeanShift(args.rgb_range, args.rgb_mean, args.rgb_std, 1) self.non_local = Nonlocal_CA(in_feat=n_feats, inter_feat=n_feats // 8, reduction=8, sub_sample=False, bn_layer=False) self.head = nn.Sequential(*modules_head) # self.body = nn.Sequential(*modules_body) self.tail = nn.Sequential(*modules_tail)