实验笔记之——octave layer（4路数据）

最新推荐文章于 2022-07-24 15:18:48 发布
最新推荐文章于 2022-07-24 15:18:48 发布
阅读量437 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gwplovekimi/article/details/90598762
版权

本博文为将octave layer改为四路数据的实验记录

实验python train.py -opt options/train/train_sr.json

先激活虚拟环境source activate pytorch

tensorboard --logdir tb_logger/ --port 6008

浏览器打开http://172.20.36.203:6008/#scalars
 

首先给出代码

原版代码

##################################################################################
##################################################################################
#modified octave
# Block for OctConv
####################
class M_NP_OctaveConv(nn.Module):
    def __init__(self, in_nc, out_nc, kernel_size, alpha=0.5, stride=1, dilation=1, groups=1, \
                    bias=True, pad_type='zero', norm_type=None, act_type='prelu', mode='CNA'):
        super(M_NP_OctaveConv, self).__init__()
        assert mode in ['CNA', 'NAC', 'CNAC'], 'Wong conv mode [{:s}]'.format(mode)
        padding = get_valid_padding(kernel_size, dilation) if pad_type == 'zero' else 0
        self.h2g_pool = nn.AvgPool2d(kernel_size=(2, 2), stride=2)
        self.h2g_pool2 = nn.AvgPool2d(kernel_size=(2, 2), stride=2)
        #self.upsample = nn.Upsample(scale_factor=2, mode='nearest')
        self.upsample = nn.Upsample(scale_factor=4, mode='nearest')#double pool
        self.stride = stride
 
        self.l2l = nn.Conv2d(int(alpha * in_nc), int(alpha * out_nc),
                                kernel_size, 1, padding, dilation, groups, bias)
        self.l2h = nn.Conv2d(int(alpha * in_nc), out_nc - int(alpha * out_nc),
                                kernel_size, 1, padding, dilation, groups, bias)
        self.h2l = nn.Conv2d(in_nc - int(alpha * in_nc), int(alpha * out_nc),
                                kernel_size, 1, padding, dilation, groups, bias)
        self.h2h = nn.Conv2d(in_nc - int(alpha * in_nc), out_nc - int(alpha * out_nc),
                                kernel_size, 1, padding, dilation, groups, bias)
        self.a = act(act_type) if act_type else None
        self.n_h = norm(norm_type, int(out_nc*(1 - alpha))) if norm_type else None
        self.n_l = norm(norm_type, int(out_nc*alpha)) if norm_type else None
 
    def forward(self, x):
        X_h, X_l = x
 
        #if self.stride ==2:
            #X_h, X_l = self.h2g_pool(X_h), self.h2g_pool(X_l)
 
        X_h2h = self.h2h(X_h)
        #X_l2h = self.upsample(self.l2h(X_l))
        #X_l2h = self.l2h(X_l)
        X_l2h = self.upsample(self.l2h(X_l))
 
        X_l2l = self.l2l(X_l)
        #X_h2l = self.h2l(self.h2g_pool(X_h))
        #X_h2l = self.h2l(X_h)
        X_h2l = self.h2l(self.h2g_pool2(self.h2g_pool(X_h)))
        
        #print(X_l2h.shape,"~~~~",X_h2h.shape)
        X_h = X_l2h + X_h2h
        X_l = X_h2l + X_l2l
 
        if self.n_h and self.n_l:
            X_h = self.n_h(X_h)
            X_l = self.n_l(X_l)
 
        if self.a:
            X_h = self.a(X_h)
            X_l = self.a(X_l)
 
        return X_h, X_l
 
 
class M_NP_FirstOctaveConv(nn.Module):
    def __init__(self, in_nc, out_nc, kernel_size, alpha=0.5, stride=1, dilation=1, groups=1, \
                    bias=True, pad_type='zero', norm_type=None, act_type='prelu', mode='CNA'):
        super(M_NP_FirstOctaveConv, self).__init__()
        assert mode in ['CNA', 'NAC', 'CNAC'], 'Wong conv mode [{:s}]'.format(mode)
        padding = get_valid_padding(kernel_size, dilation) if pad_type == 'zero' else 0
        self.h2g_pool = nn.AvgPool2d(kernel_size=(2, 2), stride=2)
        self.h2g_pool2 = nn.AvgPool2d(kernel_size=(2, 2), stride=2)
        self.stride = stride
        ###low frequency
        self.h2l = nn.Conv2d(in_nc, int(alpha * out_nc),
                                kernel_size, 1, padding, dilation, groups, bias)
        ###high frequency
        self.h2h = nn.Conv2d(in_nc, out_nc - int(alpha * out_nc),
                                kernel_size, 1, padding, dilation, groups, bias)
        self.a = act(act_type) if act_type else None
        self.n_h = norm(norm_type, int(out_nc*(1 - alpha))) if norm_type else None
        self.n_l = norm(norm_type, int(out_nc*alpha)) if norm_type else None
 
    def forward(self, x):
        #if self.stride ==2:
            #x = self.h2g_pool(x)
 
        X_h = self.h2h(x)
        #X_l = self.h2l(self.h2g_pool(x))
        #X_l = self.h2l(x)#without pool
        X_l = self.h2l(self.h2g_pool2(self.h2g_pool(x)))#double pool
 
        if self.n_h and self.n_l:##batch norm
            X_h = self.n_h(X_h)
            X_l = self.n_l(X_l)
 
        if self.a:#Activation layer
            X_h = self.a(X_h)
            X_l = self.a(X_l)
 
        return X_h, X_l
 
 
class M_NP_LastOctaveConv(nn.Module):
    def __init__(self, in_nc, out_nc, kernel_size, alpha=0.5, stride=1, dilation=1, groups=1, \
                    bias=True, pad_type='zero', norm_type=None, act_type='prelu', mode='CNA'):
        super(M_NP_LastOctaveConv, self).__init__()
        assert mode in ['CNA', 'NAC', 'CNAC'], 'Wong conv mode [{:s}]'.format(mode)
        padding = get_valid_padding(kernel_size, dilation) if pad_type == 'zero' else 0
        self.h2g_pool = nn.AvgPool2d(kernel_size=(2,2), stride=2)
        self.h2g_pool2 = nn.AvgPool2d(kernel_size=(2, 2), stride=2)
        #self.upsample = nn.Upsample(scale_factor=2, mode='nearest')
        self.upsample = nn.Upsample(scale_factor=4, mode='nearest')##double pool
        self.stride = stride
 
        self.l2h = nn.Conv2d(int(alpha * in_nc), out_nc,
                                kernel_size, 1, padding, dilation, groups, bias)
        self.h2h = nn.Conv2d(in_nc - int(alpha * in_nc), out_nc,
                                kernel_size, 1, padding, dilation, groups, bias)
 
        self.a = act(act_type) if act_type else None
        self.n_h = norm(norm_type, out_nc) if norm_type else None
 
    def forward(self, x):
        X_h, X_l = x
 
        #if self.stride ==2:
            #X_h, X_l = self.h2g_pool(X_h), self.h2g_pool(X_l)
        
        X_h2h = self.h2h(X_h)
        X_l2h = self.upsample(self.l2h(X_l))
        #X_l2h = self.l2h(X_l)
        
        X_h = X_h2h + X_l2h
 
        if self.n_h:
            X_h = self.n_h(X_h)
 
        if self.a:
            X_h = self.a(X_h)
 
        return X_h
 
class M_NP_octave_ResidualDenseBlockTiny_4C(nn.Module):
    '''
    Residual Dense Block
    style: 4 convs
    The core module of paper: (Residual Dense Network for Image Super-Resolution, CVPR 18)
    '''
 
    def __init__(self, nc, kernel_size=3, gc=16,alpha=0.5, stride=1, bias=True, pad_type='zero', \
            norm_type=None, act_type='leakyrelu', mode='CNA'):
        super(M_NP_octave_ResidualDenseBlockTiny_4C, self).__init__()
        # gc: growth channel, i.e. intermediate channels
        self.conv1 =M_NP_OctaveConv(nc, gc, kernel_size, alpha, stride, bias=bias, pad_type=pad_type, \
             norm_type=norm_type, act_type=act_type, mode=mode) 
        # conv_block(nc, gc, kernel_size, stride, bias=bias, pad_type=pad_type, \
        #     norm_type=norm_type, act_type=act_type, mode=mode)
        self.conv2 = M_NP_OctaveConv(nc+gc, gc, kernel_size, alpha, stride, bias=bias, pad_type=pad_type, \
             norm_type=norm_type, act_type=act_type, mode=mode) 
        # conv_block(nc+gc, gc, kernel_size, stride, bias=bias, pad_type=pad_type, \
        #     norm_type=norm_type, act_type=act_type, mode=mode)
        self.conv3 = M_NP_OctaveConv(nc+2*gc, gc, kernel_size, alpha, stride, bias=bias, pad_type=pad_type, \
             norm_type=norm_type, act_type=act_type, mode=mode) 
        # conv_block(nc+2*gc, gc, kernel_size, stride, bias=bias, pad_type=pad_type, \
        #     norm_type=norm_type, act_type=act_type, mode=mode)
        if mode == 'CNA':
            last_act = None
        else:
            last_act = act_type
        self.conv4 = M_NP_OctaveConv(nc+3*gc, nc, kernel_size, alpha, stride, bias=bias, pad_type=pad_type, \
             norm_type=norm_type, act_type=act_type, mode=mode) 
        # conv_block(nc+3*gc, nc, 3, stride, bias=bias, pad_type=pad_type, \
        #     norm_type=norm_type, act_type=last_act, mode=mode)
 
    def forward(self, x):
        x1 = self.conv1(x)
        x2 = self.conv2((torch.cat((x[0], x1[0]), dim=1),(torch.cat((x[1], x1[1]), dim=1))))
        x3 = self.conv3((torch.cat((x[0], x1[0],x2[0]), dim=1),(torch.cat((x[1], x1[1],x2[1]), dim=1))))
        x4 = self.conv4((torch.cat((x[0], x1[0],x2[0],x3[0]), dim=1),(torch.cat((x[1], x1[1],x2[1],x3[1]), dim=1))))
 
        res = (x4[0].mul(0.2), x4[1].mul(0.2))
        x = (x[0] + res[0], x[1] + res[1])
        #print(len(x),"~~~",len(res),"~~~",len(x + res))
 
        #return (x[0] + res[0], x[1]+res[1])
        return x
 
 
class M_NP_octave_RRDBTiny(nn.Module):
    '''
    Residual in Residual Dense Block
    (ESRGAN: Enhanced Super-Resolution Generative Adversarial Networks)
    '''
 
    def __init__(self, nc, kernel_size=3, gc=16, stride=1, alpha=0.5, bias=True, pad_type='zero', \
            norm_type=None, act_type='leakyrelu', mode='CNA'):
        super(M_NP_octave_RRDBTiny, self).__init__()
        self.RDB1 = M_NP_octave_ResidualDenseBlockTiny_4C(nc=nc, kernel_size=kernel_size,alpha=alpha, gc=gc, stride=stride, bias=bias, pad_type=pad_type, \
            norm_type=norm_type, act_type=act_type, mode=mode)
        self.RDB2 = M_NP_octave_ResidualDenseBlockTiny_4C(nc=nc, kernel_size=kernel_size,alpha=alpha, gc=gc, stride=stride, bias=bias, pad_type=pad_type, \
            norm_type=norm_type, act_type=act_type, mode=mode)
 
    def forward(self, x):
        out = self.RDB1(x)
        out = self.RDB2(out)
 
        res = (out[0].mul(0.2), out[1].mul(0.2))
        x = (x[0] + res[0], x[1] + res[1])
        #print(len(x),"~~~",len(res),"~~~",len(x + res))
 
        #return (x[0] + res[0], x[1]+res[1])
        return x

 
class M_NP_OctaveCascadeBlock(nn.Module):
    """
    OctaveCascadeBlock, 3-3 style
    """
    def __init__(self, nc, gc, kernel_size=3, alpha=0.75, stride=1, dilation=1, groups=1, \
            bias=True, pad_type='zero', norm_type=None, act_type='prelu', mode='CNA', res_scale=1):
        super(M_NP_OctaveCascadeBlock, self).__init__()
        self.nc = nc
        self.ResBlocks = nn.ModuleList([M_NP_OctaveResBlock(gc, gc, gc, kernel_size, alpha, stride, dilation, \
            groups, bias, pad_type, norm_type, act_type, mode, res_scale) for _ in range(nc)])
        self.CatBlocks = nn.ModuleList([M_NP_OctaveConv((i + 2)*gc, gc, kernel_size=1, alpha=alpha, bias=bias, \
            pad_type=pad_type, norm_type=norm_type, act_type=act_type, mode=mode) for i in range(nc)])

    def forward(self, x):
        pre_fea = x
        for i in range(self.nc):
            res = self.ResBlocks[i](x)
            pre_fea = (torch.cat((pre_fea[0], res[0]), dim=1), \
                        torch.cat((pre_fea[1], res[1]), dim=1))
            x = self.CatBlocks[i](pre_fea)
        return x

class M_NP_OctaveResBlock(nn.Module):
    '''
    ResNet Block, 3-3 style
    with extra residual scaling used in EDSR
    (Enhanced Deep Residual Networks for Single Image Super-Resolution, CVPRW 17)
    '''
    def __init__(self, in_nc, mid_nc, out_nc, kernel_size=3, alpha=0.75, stride=1, dilation=1, groups=1, \
            bias=True, pad_type='zero', norm_type=None, act_type='prelu', mode='CNA', res_scale=1):
        super(M_NP_OctaveResBlock, self).__init__()
        conv0 = M_NP_OctaveConv(in_nc, mid_nc, kernel_size, alpha, stride, dilation, groups, bias, pad_type, \
            norm_type, act_type, mode)
        if mode == 'CNA':
            act_type = None
        if mode == 'CNAC':  # Residual path: |-CNAC-|
            act_type = None
            norm_type = None
        conv1 = M_NP_OctaveConv(mid_nc, out_nc, kernel_size, alpha, stride, dilation, groups, bias, pad_type, \
            norm_type, act_type, mode)

        self.res = sequential(conv0, conv1)
        self.res_scale = res_scale

    def forward(self, x):
        #if(len(x)>2):
            #print(x[0].shape,"  ",x[1].shape,"  ",x[2].shape,"  ",x[3].shape)
        #print(len(x))
        res = self.res(x)
        res = (res[0].mul(self.res_scale), res[1].mul(self.res_scale))
        x = (x[0] + res[0], x[1] + res[1])
        #print(len(x),"~~~",len(res),"~~~",len(x + res))

        #return (x[0] + res[0], x[1]+res[1])
        return x

改进后代码

##################################################################################
##################################################################################
##################################################################################
#modified octave
# Block for OctConv
####################
class M_NP_OctaveConv(nn.Module):
    def __init__(self, in_nc, out_nc, kernel_size, alpha=0.5, stride=1, dilation=1, groups=1, \
                    bias=True, pad_type='zero', norm_type=None, act_type='prelu', mode='CNA'):
        super(M_NP_OctaveConv, self).__init__()
        assert mode in ['CNA', 'NAC', 'CNAC'], 'Wong conv mode [{:s}]'.format(mode)
        padding = get_valid_padding(kernel_size, dilation) if pad_type == 'zero' else 0
        self.h2g_pool = nn.AvgPool2d(kernel_size=(2, 2), stride=2)
        self.h2g_pool2 = nn.AvgPool2d(kernel_size=(2, 2), stride=2)
        self.h2g_pool3 = nn.AvgPool2d(kernel_size=(2, 2), stride=2)
        #self.upsample = nn.Upsample(scale_factor=2, mode='nearest')
        self.upsample = nn.Upsample(scale_factor=2, mode='nearest')## pool
        self.upsample2 = nn.Upsample(scale_factor=4, mode='nearest')##double pool
        self.upsample3 = nn.Upsample(scale_factor=8, mode='nearest')##triple pool
        self.stride = stride

        # self.l2l = nn.Conv2d(int(alpha * in_nc), int(alpha * out_nc),
        #                         kernel_size, 1, padding, dilation, groups, bias)
        # self.l2h = nn.Conv2d(int(alpha * in_nc), out_nc - int(alpha * out_nc),
        #                         kernel_size, 1, padding, dilation, groups, bias)
        # self.h2l = nn.Conv2d(in_nc - int(alpha * in_nc), int(alpha * out_nc),
        #                         kernel_size, 1, padding, dilation, groups, bias)
        # self.h2h = nn.Conv2d(in_nc - int(alpha * in_nc), out_nc - int(alpha * out_nc),
        #                         kernel_size, 1, padding, dilation, groups, bias)
#########for h
        self.h2h = nn.Conv2d(int(0.5*(in_nc - int(alpha * in_nc))), int(0.5*(out_nc - int(alpha * out_nc))),
                                kernel_size, 1, padding, dilation, groups, bias)
        self.l12h = nn.Conv2d(int(0.5*(in_nc - int(alpha * in_nc))), int(0.5*(out_nc - int(alpha * out_nc))),
                                kernel_size, 1, padding, dilation, groups, bias)
        self.l22h = nn.Conv2d(int(0.5*int(alpha * in_nc)), int(0.5*(out_nc - int(alpha * out_nc))),
                                kernel_size, 1, padding, dilation, groups, bias)
        self.l32h = nn.Conv2d(int(0.5*int(alpha * in_nc)), int(0.5*(out_nc - int(alpha * out_nc))),
                                kernel_size, 1, padding, dilation, groups, bias)
###########for l1
        self.h2l1 = nn.Conv2d(int(0.5*(in_nc - int(alpha * in_nc))), int(0.5*(out_nc - int(alpha * out_nc))),
                                kernel_size, 1, padding, dilation, groups, bias)
        self.l12l1 = nn.Conv2d(int(0.5*(in_nc - int(alpha * in_nc))), int(0.5*(out_nc - int(alpha * out_nc))),
                                kernel_size, 1, padding, dilation, groups, bias)
        self.l22l1 = nn.Conv2d(int(0.5*int(alpha * in_nc)), int(0.5*(out_nc - int(alpha * out_nc))),
                                kernel_size, 1, padding, dilation, groups, bias)
        self.l32l1 = nn.Conv2d(int(0.5*int(alpha * in_nc)), int(0.5*(out_nc - int(alpha * out_nc))),
                                kernel_size, 1, padding, dilation, groups, bias)
###########for l2
        self.h2l2 = nn.Conv2d(int(0.5*(in_nc - int(alpha * in_nc))), int(0.5*int(alpha * out_nc)),
                                kernel_size, 1, padding, dilation, groups, bias)
        self.l12l2 = nn.Conv2d(int(0.5*(in_nc - int(alpha * in_nc))), int(0.5*int(alpha * out_nc)),
                                kernel_size, 1, padding, dilation, groups, bias)
        self.l22l2 = nn.Conv2d(int(0.5*int(alpha * in_nc)), int(0.5*int(alpha * out_nc)),
                                kernel_size, 1, padding, dilation, groups, bias)
        self.l32l2 = nn.Conv2d(int(0.5*int(alpha * in_nc)), int(0.5*int(alpha * out_nc)),
                                kernel_size, 1, padding, dilation, groups, bias)
###########for l3
        self.h2l3 = nn.Conv2d(int(0.5*(in_nc - int(alpha * in_nc))), int(0.5*int(alpha * out_nc)),
                                kernel_size, 1, padding, dilation, groups, bias)
        self.l12l3 = nn.Conv2d(int(0.5*(in_nc - int(alpha * in_nc))), int(0.5*int(alpha * out_nc)),
                                kernel_size, 1, padding, dilation, groups, bias)
        self.l22l3 = nn.Conv2d(int(0.5*int(alpha * in_nc)), int(0.5*int(alpha * out_nc)),
                                kernel_size, 1, padding, dilation, groups, bias)
        self.l32l3 = nn.Conv2d(int(0.5*int(alpha * in_nc)), int(0.5*int(alpha * out_nc)),
                                kernel_size, 1, padding, dilation, groups, bias)



        self.a = act(act_type) if act_type else None
        self.n_h = norm(norm_type, int(out_nc*(1 - alpha))) if norm_type else None
        self.n_l = norm(norm_type, int(out_nc*alpha)) if norm_type else None
 
    def forward(self, x):
        X_h, X_l1,X_l2,X_l3 = x
 
        #if self.stride ==2:
            #X_h, X_l = self.h2g_pool(X_h), self.h2g_pool(X_l)
 
 #######for h
        X_h2h = self.h2h(X_h)
        X_l12h=self.l12h(self.upsample(X_l1))
        X_l22h=self.l22h(self.upsample2(X_l2))
        X_l32h=self.l32h(self.upsample3(X_l3))

 #######for l1
        X_h2l1 = self.h2l1(self.h2g_pool(X_h))
        X_l12l1=self.l12l1(X_l1)
        X_l22l1=self.l22l1(self.upsample(X_l2))
        X_l32l1=self.l32l1(self.upsample2(X_l3))

#######for l2
        X_h2l2 = self.h2l2(self.h2g_pool2(self.h2g_pool(X_h)))
        X_l12l2=self.l12l2(self.h2g_pool(X_l1))
        X_l22l2=self.l22l2(X_l2)
        X_l32l2=self.l32l2(self.upsample(X_l3))

#######for l3
        X_h2l3 = self.h2l3(self.h2g_pool3(self.h2g_pool2(self.h2g_pool(X_h))))
        X_l12l3=self.l12l3(self.h2g_pool2(self.h2g_pool(X_l1)))
        X_l22l3=self.l22l3(self.h2g_pool(X_l2))
        X_l32l3=self.l32l3(X_l3)


        
        #print(X_l2h.shape,"~~~~",X_h2h.shape)
        X_h = X_h2h + X_l12h+X_l22h+X_l32h
        X_l1 = X_h2l1+X_l12l1+X_l22l1+X_l32l1
        X_l2=X_h2l2+X_l12l2+X_l22l2+X_l32l2
        X_l3=X_h2l3+X_l12l3+X_l22l3+X_l32l3
 
        if self.n_h and self.n_l:
            X_h = self.n_h(X_h)
            X_l1 = self.n_l(X_l1)
            X_l2 = self.n_l(X_l2)
            X_l3 = self.n_l(X_l3)
 
        if self.a:
            X_h = self.a(X_h)
            X_l1 = self.a(X_l1)
            X_l2 = self.a(X_l2)
            X_l3 = self.a(X_l3)
 
        return X_h, X_l1,X_l2,X_l3
 
 
class M_NP_FirstOctaveConv(nn.Module):
    def __init__(self, in_nc, out_nc, kernel_size, alpha=0.5, stride=1, dilation=1, groups=1, \
                    bias=True, pad_type='zero', norm_type=None, act_type='prelu', mode='CNA'):
        super(M_NP_FirstOctaveConv, self).__init__()
        assert mode in ['CNA', 'NAC', 'CNAC'], 'Wong conv mode [{:s}]'.format(mode)
        padding = get_valid_padding(kernel_size, dilation) if pad_type == 'zero' else 0
        self.h2g_pool = nn.AvgPool2d(kernel_size=(2, 2), stride=2)
        self.h2g_pool2 = nn.AvgPool2d(kernel_size=(2, 2), stride=2)
        self.h2g_pool3 = nn.AvgPool2d(kernel_size=(2, 2), stride=2)
        self.stride = stride
        ###low frequency
        self.h2l2 = nn.Conv2d(in_nc, int(0.5*alpha * out_nc),
                                kernel_size, 1, padding, dilation, groups, bias)
        self.h2l3 = nn.Conv2d(in_nc, int(0.5*alpha * out_nc),
                                kernel_size, 1, padding, dilation, groups, bias)
        ###high frequency
        self.h2h = nn.Conv2d(in_nc, int(0.5*out_nc - int(0.5*alpha * out_nc)),
                                kernel_size, 1, padding, dilation, groups, bias)
        self.h2l1 = nn.Conv2d(in_nc, int(0.5*out_nc - int(0.5*alpha * out_nc)),
                                kernel_size, 1, padding, dilation, groups, bias)
        self.a = act(act_type) if act_type else None
        self.n_h = norm(norm_type, int(out_nc*(1 - alpha))) if norm_type else None
        self.n_l = norm(norm_type, int(out_nc*alpha)) if norm_type else None
 
    def forward(self, x):
        #if self.stride ==2:
            #x = self.h2g_pool(x)
 
        X_h = self.h2h(x)
        X_l1=self.h2l1(self.h2g_pool(x))
        X_l2=self.h2l2(self.h2g_pool2(self.h2g_pool(x)))
        X_l3=self.h2l3(self.h2g_pool3(self.h2g_pool2(self.h2g_pool(x))))
        #X_l = self.h2l(self.h2g_pool2(self.h2g_pool(x)))#double pool
 
        if self.n_h and self.n_l:##batch norm
            X_h = self.n_h(X_h)
            X_l1 = self.n_l(X_l1)
            X_l2 = self.n_l(X_l2)
            X_l3 = self.n_l(X_l3)
 
        if self.a:#Activation layer
            X_h = self.a(X_h)
            X_l1 = self.a(X_l1)
            X_l2 = self.a(X_l2)
            X_l3 = self.a(X_l3)
 
        return X_h, X_l1,X_l2,X_l3
 
 
class M_NP_LastOctaveConv(nn.Module):
    def __init__(self, in_nc, out_nc, kernel_size, alpha=0.5, stride=1, dilation=1, groups=1, \
                    bias=True, pad_type='zero', norm_type=None, act_type='prelu', mode='CNA'):
        super(M_NP_LastOctaveConv, self).__init__()
        assert mode in ['CNA', 'NAC', 'CNAC'], 'Wong conv mode [{:s}]'.format(mode)
        padding = get_valid_padding(kernel_size, dilation) if pad_type == 'zero' else 0
        # self.h2g_pool = nn.AvgPool2d(kernel_size=(2,2), stride=2)
        # self.h2g_pool2 = nn.AvgPool2d(kernel_size=(2, 2), stride=2)
        #self.upsample = nn.Upsample(scale_factor=2, mode='nearest')
        self.upsample = nn.Upsample(scale_factor=2, mode='nearest')## pool
        self.upsample2 = nn.Upsample(scale_factor=4, mode='nearest')##double pool
        self.upsample3 = nn.Upsample(scale_factor=8, mode='nearest')##triple pool
        self.stride = stride
 
        self.l22h = nn.Conv2d(int(0.5*int(alpha * in_nc)), out_nc,
                                kernel_size, 1, padding, dilation, groups, bias)
        self.l32h = nn.Conv2d(int(0.5*int(alpha * in_nc)), out_nc,
                                kernel_size, 1, padding, dilation, groups, bias)
        self.h2h = nn.Conv2d(int(0.5*(in_nc - int(alpha * in_nc))), out_nc,
                                kernel_size, 1, padding, dilation, groups, bias)
        self.l12h = nn.Conv2d(int(0.5*(in_nc - int(alpha * in_nc))), out_nc,
                                kernel_size, 1, padding, dilation, groups, bias)
 
        self.a = act(act_type) if act_type else None
        self.n_h = norm(norm_type, out_nc) if norm_type else None
 
    def forward(self, x):
        X_h, X_l1,X_l2,X_l3 = x
 
        #if self.stride ==2:
            #X_h, X_l = self.h2g_pool(X_h), self.h2g_pool(X_l)
        
        X_h2h = self.h2h(X_h)
        X_l12h = self.upsample(self.l12h(X_l1))
        X_l22h = self.upsample2(self.l22h(X_l2))
        X_l32h = self.upsample3(self.l32h(X_l3))
        #X_l2h = self.l2h(X_l)
        
        X_h = X_h2h + X_l12h+X_l22h+X_l32h
 
        if self.n_h:
            X_h = self.n_h(X_h)
 
        if self.a:
            X_h = self.a(X_h)
 
        return X_h


class M_NP_OctaveResBlock(nn.Module):
    '''
    ResNet Block, 3-3 style
    with extra residual scaling used in EDSR
    (Enhanced Deep Residual Networks for Single Image Super-Resolution, CVPRW 17)
    '''
    def __init__(self, in_nc, mid_nc, out_nc, kernel_size=3, alpha=0.75, stride=1, dilation=1, groups=1, \
            bias=True, pad_type='zero', norm_type=None, act_type='prelu', mode='CNA', res_scale=1):
        super(M_NP_OctaveResBlock, self).__init__()
        conv0 = M_NP_OctaveConv(in_nc, mid_nc, kernel_size, alpha, stride, dilation, groups, bias, pad_type, \
            norm_type, act_type, mode)
        if mode == 'CNA':
            act_type = None
        if mode == 'CNAC':  # Residual path: |-CNAC-|
            act_type = None
            norm_type = None
        conv1 = M_NP_OctaveConv(mid_nc, out_nc, kernel_size, alpha, stride, dilation, groups, bias, pad_type, \
            norm_type, act_type, mode)

        self.res = sequential(conv0, conv1)
        self.res_scale = res_scale

    def forward(self, x):
        #if(len(x)>2):
            #print(x[0].shape,"  ",x[1].shape,"  ",x[2].shape,"  ",x[3].shape)
        #print(len(x))
        res = self.res(x)
        res = (res[0].mul(self.res_scale), res[1].mul(self.res_scale),res[2].mul(self.res_scale),res[3].mul(self.res_scale))
        x = (x[0] + res[0], x[1] + res[1],x[2] + res[2],x[3] + res[3])
        #print(len(x),"~~~",len(res),"~~~",len(x + res))

        #return (x[0] + res[0], x[1]+res[1])
        return x

 

 

 

 

 

 

 

 

 

gwpscut
关注
专栏目录
UE4 Material 101学习笔记——19-22 程序化噪声的使用（Noise节点）
清清！的博客
02-02 3909
UE4 Material 101学习笔记——19Lec19 程序化噪声 Procedural Noise19.1 What is it?19.2 Optimized for Real-Time19.3 Back to UnrealLec20 枯木积雪着色器 Snowy Tree Trunk ShaderLec21 层积岩着色器 Rock Layer ShaderLec22 与世界坐标对齐 World-Aligned Shader 本系列学习资料来源，Ben Cloward的油管空间，B站的搬运翻译 Lec1
python gdal教程_GDAL python教程（1）——用OGR读写矢量数据
weixin_40007541的博客
12-17 641
本教程的讲义和源码都是取自Utah State University的openGIS课程本人只是做点翻译，写写学习体会而已，版权属于原作者。欢迎转载，不过别忘了上面这段话。==================================================为什么用open source？优点免费，适合个人和小公司强大的开发工具，找bug更容易跨平台，windows和linux都能用...
Tensorflow中两种Padding运算方式
固本培元的专栏
07-25 3212
原文：  https://blog.csdn.net/jiandanjinxin/article/details/77519629 边界补充问题 原始图片尺寸为7*7，卷积核的大小为3*3，当卷积核沿着图片滑动后只能滑动出一个5*5的图片出来，这就造成了卷积后的图片和卷积前的图片尺寸不一致，这显然不是我们想要的结果，所以为了避免这种情况，需要先对原始图片做边界填充处理。在上面的情况中，我们需要...
实验——基于pytorch的SRResNet的复现
gwpscut的博客
11-27 8226
本博文是对xintao前辈的这套代码中的SRResNet做实验时的笔记~代码如链接所示https://github.com/xinntao/BasicSR 先给出SRGAN paper的链接（https://arxiv.org/pdf/1609.04802.pdf）。作者在原文中是这样定义SRResNet的： “We set a new state of the art for image S...
实验笔记之——基于DWT的octave layer（DWT在pytorch中实现）
gwpscut的博客
05-13 5037
之前的博文《论文阅读笔记之——《Multi-level Wavelet-CNN for Image Restoration》及基于pytorch的复现》曾经研究过WMCNN。本博文就是采用DWT变换代替octave中的pooling 代码 类似于博文《实验笔记之——octave conv （without pooling）》对octave layer的结构进行改进如下： pytorch中实现...
为什么 SIFT 算法在 OctaveLayers 为 1 时消耗更多的时间
mightbxg的博客
07-22 550
本文是本人在 StackOverflow 上提的一个问题和回答，参见： Why SIFT costs more time with fewer octave layers? SIFT 算法原理有很多不错的资料都解释地很详细了，比如： SIFT特征提取分析 - Rachel-Zhang SIFT特征点提取 - 粼粼淇 前段时间在使用 OpenCV SIFT 时，遇到一个有点反直觉的问题，特此记录。 问题描述 众所周知，SIFT 计算速度慢一直都是制约其应用的重要缺点。为了降低其计算时耗，我首先想到的是.
pytorch torch.nn 实现上采样——nn.Upsample
云中寻雾的博客
08-19 2万+
Vision layers 1）Upsample CLASS torch.nn.Upsample(size=None, scale_factor=None, mode='nearest', align_corners=None) 上采样一个给定的多通道的1D (temporal,如向量数据), 2D (spatial，如jpg、png等图像数据) or 3D (volumetric，如点云数据)数据 假设输入数据的格式为minibatch x channels x [optional depth].
斯坦福大学吴恩达机器学习教程中文笔记——week5——神经网络的学习
Laic Zhang的博客
04-22 1547
第5周 文章目录第5周@[toc] 九、神经网络的学习(Neural Networks: Learning)9.1 代价函数9.2 反向传播算法9.3 反向传播算法的直观理解9.4 实现注意：展开参数9.5 梯度检验9.6 随机初始化9.7 综合起来9.8 自主驾驶 九、神经网络的学习(Neural Networks: Learning) 9.1 代价函数 参考视频: 9 - 1 - Cost F...
吴恩达机器学习系列课程笔记——第九章：神经网络的学习(Neural Networks: Learning)
weixin_43895667的博客
07-24 318
吴恩达机器学习系列课程笔记——第九章：神经网络的学习(Neural Networks: Learning)
机器学习编程作业ex4(matlab/octave实现)-吴恩达coursera
weixin_43808279的博客
04-11 1906
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
pytorch进行上采样的种类实例
09-17
今天小编就为大家分享一篇pytorch进行上采样的种类实例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
nn.Upsample
热门推荐
芒果干的博客
12-19 2万+
写在前面：在PyTorch中有两种上采样/下采样的方法，一种是Upsample，另一种是interpolate 这两个函数的使用方法略有差异，这里仅介绍Upsample Upsample torch.nn.Upsample(size=None, scale_factor=None, mode='nearest', align_corners=None) size - output spatial sizes（int or tuple(int, int)） scale_factor - multiplier
Tensorflow中padding的两种类型SAME和VALID
jiandanjinxin的专栏
08-24 2万+
边界补充问题 原始图片尺寸为7*7，卷积核的大小为3*3，当卷积核沿着图片滑动后只能滑动出一个5*5的图片出来，这就造成了卷积后的图片和卷积前的图片尺寸不一致，这显然不是我们想要的结果，所以为了避免这种情况，需要先对原始图片做边界填充处理。在上面的情况中，我们需要先把原始图像填充为9*9的尺寸。 常用的区域填充方法包括： 用3*3定义原始图像的尺寸，补充为9*9的尺寸，图片上的颜色只为方便观
torch.nn.Upsample实现上采样
liming_2464的博客
01-06 3652
参考链接:https://www.cnblogs.com/wanghui-garcia/p/11399053.html 官方文档：https://pytorch.apachecn.org/docs/1.0/nn.html torch.nn.Upsample(size=None, scale_factor=None, mode='nearest', align_corners=None) # siz...
TensorFlow中CNN的两种padding方式“SAME”和“VALID”
HK_John的博客
10-10 1534
转载请标明出处：http://blog.csdn.net/wuzqchom/article/details/74785643 在用tensorflow写CNN的时候，调用卷积核api的时候，会有填padding方式的参数，找到源码中的函数定义如下（max pooling也是一样）： def conv2d(input, filter, strides, padding, us
实验笔记之——octave conv （double pooling）
gwpscut的博客
05-13 717
本博文类似于博文《实验笔记之——octave conv （without pooling）》唯一不同的是，本博文是采用4倍的scale（ocatve 采用2倍scale） 代码 ################################################################################## #########################...
实验笔记之——参数量为0.1M的超分网络（octave layer）
gwpscut的博客
05-21 824
本博文为实验笔记 实验python train.py -opt options/train/train_sr.json 先激活虚拟环境source activate pytorch tensorboard --logdir tb_logger/ --port 6008 浏览器打开http://172.20.36.203:6008/#scalars 参数量为176,234 参数量为1...
(deeplearning 基础网络结构) OctConv 论文阅读笔记
Bryce1010's Blog
04-22 1831
Drop an Ocatve: Reducing Spatial Redundancy in Convolutional Neural Networks with Octave Convolution paper: https://arxiv.org/abs/1904.05049 github: MXNet实现 https://github.com/terrychenism/OctaveCon...
Octave入门：数据保存与命令重复
Octave是一个用于科学计算的语言，它支持向量和矩阵运算，适合数值分析、数据可视化以及编写科学计算脚本。 ### 3.4 载入和保存数据 在Octave中，用户可以保存和加载数据以便在不同会话间继续工作。若要保存当前...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值