Method forward

networks/sr_arch.py:99–236

(self, lq, priors64, priors32, locs)

        )

    def forward(self, lq, priors64, priors32, locs): #
        # lq_features:b*512*8*512 
        # priors: 8, 16,32,64,128
        # locs: b*32, center+width for 128*2048 0~1
        # locs: b*16, center for 128*2048, 0~2048

        
        single_sr = True

        
        lq_f_32 = self.conv_first_32(lq)
        lq_f_16 = self.conv_first_16(lq_f_32)
        lq_f_8 = self.conv_first_8(lq_f_16)

        sq_f_16 = self.conv_body_16(torch.cat([F.interpolate(lq_f_8, scale_factor=2, mode='bilinear'), lq_f_16], dim=1))
        sq_f_32 = self.conv_body_32(torch.cat([F.interpolate(sq_f_16, scale_factor=2, mode='bilinear'), lq_f_32], dim=1)) # 256*32*32


        if priors32 is not None:
            sq_f_32_ori = sq_f_32.clone()
            # sq_f_32_res = sq_f_32.clone().detach()*0
            prior_32_align = torch.zeros_like(sq_f_32_ori)
            prior_32_mask = torch.zeros((sq_f_32_ori.size(0), 1, sq_f_32_ori.size(2), sq_f_32_ori.size(3)), dtype=sq_f_32_ori.dtype, layout=sq_f_32_ori.layout, device=sq_f_32_ori.device)
            for b, p_32 in enumerate(priors32): #512*32*32, different batch
                p_32_256 = self.conv_32_to256(p_32.clone()) 
                for c in range(p_32_256.size(0)): #
                    center = (locs[b][c].detach()/4.0).int() #
                    width = 16

                    if center < width:
                        x1 = 0 #lq feature left
                        y1 = max(16 - center, 0)
                    else:
                        x1 = center - width
                        y1 = max(16 - width, 0)
                        # y1 = 16 - width
                    if center + width > sq_f_32.size(-1):
                        x2 = sq_f_32.size(-1) #lq feature right
                    else:
                        x2 = center + width
                    y2 = y1 + (x2 - x1)

                    ''&#x27;
                    center align
                    ''&#x27;
                    # y1 = 16 - torch.div(x2-x1, 2, rounding_mode='trunc')
                    y2 = y1 + x2 - x1

                    if single_sr:
                        char_prior_f = p_32_256[c:c+1, :, :, y1:y2].clone() #prior
                        char_lq_f = sq_f_32[b:b+1, :, :, x1:x2].clone()
                        adain_prior_f = adaptive_instance_normalization(char_prior_f, char_lq_f)
                        fuse_32_prior = self.conv_32_fuse(torch.cat((adain_prior_f, char_lq_f), dim=1))
                        scale = self.conv_32_scale(fuse_32_prior)
                        shift = self.conv_32_shift(fuse_32_prior)
                        prior_32_align[b, :, :, x1:x2] = prior_32_align[b, :, :, x1:x2] + sq_f_32[b, :, :, x1:x2].clone() * scale[0,...] + shift[0,...]
                    else:
                        prior_32_align[b, :, :, x1:x2] = prior_32_align[b, :, :, x1:x2] + p_32_256[c:c+1, :, :, y1:y2].clone()