def __init__(self, fin, fout, opt): super().__init__() # Attributes self.learned_shortcut = (fin != fout) fmiddle = min(fin, fout) # create conv layers self.conv_0 = nn.Conv2d(fin, fmiddle, kernel_size=3, padding=1) self.conv_1 = nn.Conv2d(fmiddle, fout, kernel_size=3, padding=1) if self.learned_shortcut: self.conv_s = nn.Conv2d(fin, fout, kernel_size=1, bias=False) # apply spectral norm if specified if 'spectral' in opt.norm_G: self.conv_0 = spectral_norm(self.conv_0) self.conv_1 = spectral_norm(self.conv_1) if self.learned_shortcut: self.conv_s = spectral_norm(self.conv_s) # define normalization layers spade_config_str = opt.norm_G.replace('spectral', '') self.norm_0 = SPADE(spade_config_str, fin, opt.semantic_nc) self.norm_1 = SPADE(spade_config_str, fmiddle, opt.semantic_nc) if self.learned_shortcut: self.norm_s = SPADE(spade_config_str, fin, opt.semantic_nc)
def __init__(self, fin, fout, opt): super().__init__() # Attributes self.learned_shortcut = (fin != fout) fmiddle = min(fin, fout) # create conv layers add_channels = 1 if (opt.norm_mode == 'clade' and not opt.no_instance) else 0 self.conv_0 = nn.Conv2d(fin + add_channels, fmiddle, kernel_size=3, padding=1) self.conv_1 = nn.Conv2d(fmiddle + add_channels, fout, kernel_size=3, padding=1) if self.learned_shortcut: self.conv_s = nn.Conv2d(fin + add_channels, fout, kernel_size=1, bias=False) # apply spectral norm if specified if 'spectral' in opt.norm_G: self.conv_0 = spectral_norm(self.conv_0) self.conv_1 = spectral_norm(self.conv_1) if self.learned_shortcut: self.conv_s = spectral_norm(self.conv_s) # define normalization layers spade_config_str = opt.norm_G.replace('spectral', '') if opt.norm_mode == 'spade': self.norm_0 = SPADE(spade_config_str, fin, opt.semantic_nc) self.norm_1 = SPADE(spade_config_str, fmiddle, opt.semantic_nc) if self.learned_shortcut: self.norm_s = SPADE(spade_config_str, fin, opt.semantic_nc) elif opt.norm_mode == 'clade': input_nc = opt.label_nc + (1 if opt.contain_dontcare_label else 0) self.norm_0 = SPADELight(spade_config_str, fin, input_nc, opt.no_instance, opt.add_dist) self.norm_1 = SPADELight(spade_config_str, fmiddle, input_nc, opt.no_instance, opt.add_dist) if self.learned_shortcut: self.norm_s = SPADELight(spade_config_str, fin, input_nc, opt.no_instance, opt.add_dist) else: raise ValueError('%s is not a defined normalization method' % opt.norm_mode)
def __init__(self, dim, semantic_nc, kernel_size=3): super().__init__() norm_G = 'spectralspadesyncbatch3x3' pw = (kernel_size - 1) // 2 self.conv_0 = nn.Conv2d(dim, dim, kernel_size=kernel_size) self.conv_1 = nn.Conv2d(dim, dim, kernel_size=kernel_size) self.padding = nn.ReflectionPad2d(pw) if 'spectral' in norm_G: self.add_module('conv_block1', spectral_norm(self.conv_0)) self.add_module('conv_block4', spectral_norm(self.conv_1)) # define normalization layers spade_config_str = norm_G.replace('spectral', '') self.norm_0 = SPADE(spade_config_str, dim, semantic_nc) self.norm_1 = SPADE(spade_config_str, dim, semantic_nc)
def __init__(self, fin, fout, opt): super().__init__() # Attributes self.learned_shortcut = (fin != fout) fmiddle = min(fin, fout) # create conv layers self.conv_0 = nn.Conv2d(fin, fmiddle, kernel_size=3, padding=1) self.conv_1 = nn.Conv2d(fmiddle, fout, kernel_size=3, padding=1) if self.learned_shortcut: self.conv_s = nn.Conv2d(fin, fout, kernel_size=1, bias=False) if opt.weight_norm_G == False: # apply spectral norm if specified if 'spectral' in opt.norm_G: self.conv_0 = spectral_norm(self.conv_0) self.conv_1 = spectral_norm(self.conv_1) if self.learned_shortcut: self.conv_s = spectral_norm(self.conv_s) else: if opt.weight_norm_g == 0: # g is learnable self.conv_0 = weight_norm_0(self.conv_0) self.conv_1 = weight_norm_0(self.conv_1) if self.learned_shortcut: self.conv_s = weight_norm_0(self.conv_s) elif opt.weight_norm_g == 1: # g == 1 self.conv_0 = weight_norm_1(self.conv_0) self.conv_1 = weight_norm_1(self.conv_1) if self.learned_shortcut: self.conv_s = weight_norm_1(self.conv_s) # define normalization layers norm_nc = opt.label_nc + (opt.orient_nc if not opt.no_orientation else 0) + (opt.feat_num if opt.use_instance_feat else 0) + (3 if 'spadebase' in opt.netG else 0) spade_config_str = opt.norm_G.replace('spectral', '') self.norm_0 = SPADE(spade_config_str, fin, norm_nc, opt.weight_norm_G) self.norm_1 = SPADE(spade_config_str, fmiddle, norm_nc, opt.weight_norm_G) if self.learned_shortcut: self.norm_s = SPADE(spade_config_str, fin, norm_nc, opt.weight_norm_G)
def __init__(self, fin, fout, opt): super().__init__() # Attributes self.learned_shortcut = (fin != fout) fmiddle = min(fin, fout) # create conv layers self.conv_0 = nn.Conv2d(fin, fmiddle, kernel_size=3, padding=1) self.conv_1 = nn.Conv2d(fmiddle, fout, kernel_size=3, padding=1) if self.learned_shortcut: self.conv_s = nn.Conv2d(fin, fout, kernel_size=1, bias=False) self.conv_0 = spectral_norm(self.conv_0) self.conv_1 = spectral_norm(self.conv_1) if self.learned_shortcut: self.conv_s = spectral_norm(self.conv_s) spade_config_str = 'batchnorm3x3' self.norm_0 = SPADE(spade_config_str, fin, opt.edge_nc, opt) self.norm_1 = SPADE(spade_config_str, fmiddle, opt.edge_nc, opt) if self.learned_shortcut: self.norm_s = SPADE(spade_config_str, fin, opt.edge_nc, opt)
def __init__(self, fin, fout, opt): super().__init__() self.learned_shortcut = (fin != fout) fmiddle = min(fin, fout) self.conv_0 = nn.Conv2d(fin, fmiddle, kernel_size=3, padding=1) self.conv_1 = nn.Conv2d(fmiddle, fout, kernel_size=3, padding=1) if self.learned_shortcut: self.conv_s = nn.Conv2d(fin, fout, kernel_size=1, bias=False) if 'spectral' in opt.norm_G: self.conv_0 = spectral_norm(self.conv_0) self.conv_1 = spectral_norm(self.conv_1) if self.learned_shortcut: self.conv_s = spectral_norm(self.conv_s) spade_config_str = opt.norm_G.replace('spectral', '') self.norm_0 = SPADE(spade_config_str, fin, opt.semantic_nc) self.norm_1 = SPADE(spade_config_str, fmiddle, opt.semantic_nc) if self.learned_shortcut: self.norm_s = SPADE(spade_config_str, fin, opt.semantic_nc)
def __init__(self, fin, fout, opt): super().__init__() # Attributes self.opt = opt self.learned_shortcut = (fin != fout) fmiddle = min(fin, fout) # create conv layers self.conv_0 = nn.Conv2d(fin, fmiddle, kernel_size=3, padding=1) self.conv_1 = nn.Conv2d(fmiddle, fout, kernel_size=3, padding=1) if self.learned_shortcut: self.conv_s = nn.Conv2d(fin, fout, kernel_size=1, bias=False) # apply spectral norm if specified if 'spectral' in opt.norm_G: self.conv_0 = spectral_norm(self.conv_0) self.conv_1 = spectral_norm(self.conv_1) if self.learned_shortcut: self.conv_s = spectral_norm(self.conv_s) # define normalization layers spade_config_str = opt.norm_G.replace('spectral', '') if opt.embed_attributes: attr_nc = opt.attr_nc else: attr_nc = 0 if opt.embed_captions: class_inst = SPADEAttention extra_args = [opt.attr_emb_dim, opt.attention_heads] else: class_inst = SPADE extra_args = [attr_nc, opt.attr_emb_dim] # Can be zero self.norm_0 = class_inst(spade_config_str, fin, opt.label_nc, opt.mask_emb_dim, *extra_args) self.norm_1 = class_inst(spade_config_str, fmiddle, opt.label_nc, opt.mask_emb_dim, *extra_args) if self.learned_shortcut: self.norm_s = SPADE(spade_config_str, fin, opt.label_nc, opt.mask_emb_dim, attr_nc, opt.attr_emb_dim)
def __init__(self, fin, fout, opt, semantic_nc): super().__init__() # Attributes self.learned_shortcut = (fin != fout) fmiddle = min(fin, fout) # layers to generate conditional convolution weights nhidden = 128 self.weight_channels = fmiddle * 9 self.gen_weights1 = nn.Sequential( nn.Conv2d(semantic_nc, nhidden, kernel_size=3, padding=1), nn.ReLU(), nn.Conv2d(nhidden, fin * 9, kernel_size=3, padding=1)) self.gen_weights2 = nn.Sequential( nn.Conv2d(semantic_nc, nhidden, kernel_size=3, padding=1), nn.ReLU(), nn.Conv2d(nhidden, fout * 9, kernel_size=3, padding=1)) self.gen_se_weights1 = nn.Sequential( nn.Conv2d(semantic_nc, nhidden, kernel_size=3, padding=1), nn.ReLU(), nn.Conv2d(nhidden, fmiddle, kernel_size=3, padding=1), nn.Sigmoid()) self.gen_se_weights2 = nn.Sequential( nn.Conv2d(semantic_nc, nhidden, kernel_size=3, padding=1), nn.ReLU(), nn.Conv2d(nhidden, fout, kernel_size=3, padding=1), nn.Sigmoid()) # create conv layers if opt.mpdist: BNFunc = nn.SyncBatchNorm else: BNFunc = nn.BatchNorm2d self.conv_0 = DepthConv(fin, opt) self.norm_0 = BNFunc(fmiddle, affine=True) self.conv_1 = nn.Conv2d(fin, fmiddle, kernel_size=1) self.norm_1 = BNFunc(fin, affine=True) self.conv_2 = DepthConv(fmiddle, opt) self.norm_2 = BNFunc(fmiddle, affine=True) self.conv_3 = nn.Conv2d(fmiddle, fout, kernel_size=1) if self.learned_shortcut: self.conv_s = spectral_norm( nn.Conv2d(fin, fout, kernel_size=1, bias=False)) self.norm_s = SPADE(fin, semantic_nc, opt)
def __init__(self, fin, fout, opt, use_se=False, dilation=1): super().__init__() # Attributes self.learned_shortcut = (fin != fout) fmiddle = min(fin, fout) self.opt = opt self.pad_type = 'zero' self.use_se = use_se # create conv layers if self.pad_type != 'zero': self.pad = nn.ReflectionPad2d(dilation) self.conv_0 = nn.Conv2d(fin, fmiddle, kernel_size=3, padding=0, dilation=dilation) self.conv_1 = nn.Conv2d(fmiddle, fout, kernel_size=3, padding=0, dilation=dilation) else: self.conv_0 = nn.Conv2d(fin, fmiddle, kernel_size=3, padding=dilation, dilation=dilation) self.conv_1 = nn.Conv2d(fmiddle, fout, kernel_size=3, padding=dilation, dilation=dilation) if self.learned_shortcut: self.conv_s = nn.Conv2d(fin, fout, kernel_size=1, bias=False) # apply spectral norm if specified if 'spectral' in opt.norm_G: if opt.eqlr_sn: self.conv_0 = equal_lr(self.conv_0) self.conv_1 = equal_lr(self.conv_1) if self.learned_shortcut: self.conv_s = equal_lr(self.conv_s) else: self.conv_0 = spectral_norm(self.conv_0) self.conv_1 = spectral_norm(self.conv_1) if self.learned_shortcut: self.conv_s = spectral_norm(self.conv_s) # define normalization layers spade_config_str = opt.norm_G.replace('spectral', '') if 'spade_ic' in opt: ic = opt.spade_ic else: ic = 0 + (3 if 'warp' in opt.CBN_intype else 0) + (opt.semantic_nc if 'mask' in opt.CBN_intype else 0) self.norm_0 = SPADE(spade_config_str, fin, ic, PONO=opt.PONO, use_apex=opt.apex) self.norm_1 = SPADE(spade_config_str, fmiddle, ic, PONO=opt.PONO, use_apex=opt.apex) if self.learned_shortcut: self.norm_s = SPADE(spade_config_str, fin, ic, PONO=opt.PONO, use_apex=opt.apex) if use_se: self.se_layar = SELayer(fout)
def __init__(self, fin, fout, opt, Block_Name=None, use_rgb=True): super().__init__() # sean switch if opt.norm_mode != 'sean': self.use_sean = False elif opt.norm_mode == 'sean': self.use_sean = True # SEAN/ ACE-block specific attributes self.use_rgb = use_rgb self.Block_Name = Block_Name self.status = opt.status # Attributes self.learned_shortcut = (fin != fout) fmiddle = min(fin, fout) # create conv layers # There is some weird line here that is only relevant when instance maps are used. # # add_channels = 1 if (opt.norm_mode == 'clade' and not opt.no_instance) else 0 self.conv_0 = nn.Conv2d(fin, fmiddle, kernel_size=3, padding=1) self.conv_1 = nn.Conv2d(fmiddle, fout, kernel_size=3, padding=1) if self.learned_shortcut: self.conv_s = nn.Conv2d(fin, fout, kernel_size=1, bias=False) # apply spectral norm if specified if 'spectral' in opt.norm_G: self.conv_0 = spectral_norm(self.conv_0) self.conv_1 = spectral_norm(self.conv_1) if self.learned_shortcut: self.conv_s = spectral_norm(self.conv_s) # define normalization layers # # Mike: Added the if else option of clades architecture.py # # Added the option to choose sean blocks spade_config_str = opt.norm_G.replace('spectral', '') if opt.norm_mode == 'spade': self.norm_0 = SPADE(spade_config_str, fin, opt.semantic_nc) self.norm_1 = SPADE(spade_config_str, fmiddle, opt.semantic_nc) if self.learned_shortcut: self.norm_s = SPADE(spade_config_str, fin, opt.semantic_nc) elif opt.norm_mode == 'clade': input_nc = opt.label_nc + (1 if opt.contain_dontcare_label else 0) self.norm_0 = SPADELight(spade_config_str, fin, input_nc, opt.no_instance, opt.add_dist) self.norm_1 = SPADELight(spade_config_str, fmiddle, input_nc, opt.no_instance, opt.add_dist) if self.learned_shortcut: self.norm_s = SPADELight(spade_config_str, fin, input_nc, opt.no_instance, opt.add_dist) elif opt.norm_mode == 'sean': self.use_sean = True our_norm_type = 'spadesyncbatch3x3' self.ace_0 = ACE(our_norm_type, fin, 3, ACE_Name= Block_Name + '_ACE_0', status=self.status, spade_params=[spade_config_str, fin, opt.semantic_nc], use_rgb=use_rgb) self.ace_1 = ACE(our_norm_type, fmiddle, 3, ACE_Name= Block_Name + '_ACE_1', status=self.status, spade_params=[spade_config_str, fmiddle, opt.semantic_nc], use_rgb=use_rgb) if self.learned_shortcut: self.ace_s = ACE(our_norm_type, fin, 3, ACE_Name= Block_Name + '_ACE_s', status=self.status, spade_params=[spade_config_str, fin, opt.semantic_nc], use_rgb=use_rgb) else: raise ValueError('%s is not a defined normalization method' % opt.norm_mode)