def add_norm_layer(layer): nonlocal norm_type if norm_type.startswith('spectral'): layer = sn(layer) subnorm_type = norm_type[len('spectral'):] if subnorm_type == 'none' or len(subnorm_type) == 0: return layer # remove bias in the previous layer, which is meaningless # since it has no effect after normalization if getattr(layer, 'bias', None) is not None: delattr(layer, 'bias') layer.register_parameter('bias', None) if subnorm_type == 'batch': norm_layer = nn.BatchNorm2d(get_out_channel(layer), affine=True) elif subnorm_type == 'syncbatch': norm_layer = SynchronizedBatchNorm2d(get_out_channel(layer), affine=True) elif subnorm_type == 'instance': norm_layer = nn.InstanceNorm2d(get_out_channel(layer), affine=False) else: raise ValueError('normalization layer %s is not recognized' % subnorm_type) return nn.Sequential(layer, norm_layer)
def __init__(self, config_text, norm_nc, label_nc, use_weight_norm=False): super().__init__() assert config_text.startswith("spade") parsed = re.search("spade(\D+)(\d)x\d", config_text) param_free_norm_type = str(parsed.group(1)) ks = int(parsed.group(2)) if param_free_norm_type == "instance": self.param_free_norm = nn.InstanceNorm2d(norm_nc, affine=False) elif param_free_norm_type == "syncbatch": self.param_free_norm = SynchronizedBatchNorm2d(norm_nc, affine=False) elif param_free_norm_type == "batch": self.param_free_norm = nn.BatchNorm2d(norm_nc, affine=False) else: raise ValueError( "%s is not a recognized param-free norm type in SPADE" % param_free_norm_type) # The dimension of the intermediate embedding space. Yes, hardcoded. nhidden = 128 pw = ks // 2 self.mlp_shared = nn.Sequential( nn.Conv2d(label_nc, nhidden, kernel_size=ks, padding=pw), nn.ReLU()) self.mlp_gamma = nn.Conv2d(nhidden, norm_nc, kernel_size=ks, padding=pw) self.mlp_beta = nn.Conv2d(nhidden, norm_nc, kernel_size=ks, padding=pw) self.use_weight_norm = use_weight_norm
def __init__(self, config_text, norm_nc, label_nc, no_instance=True, add_dist=False): super().__init__() self.no_instance = no_instance self.add_dist = add_dist assert config_text.startswith('spade') parsed = re.search('spade(\D+)(\d)x\d', config_text) param_free_norm_type = str(parsed.group(1)) ks = int(parsed.group(2)) if param_free_norm_type == 'instance': self.param_free_norm = nn.InstanceNorm2d(norm_nc, affine=False) elif param_free_norm_type == 'syncbatch': self.param_free_norm = SynchronizedBatchNorm2d(norm_nc, affine=False) elif param_free_norm_type == 'batch': self.param_free_norm = nn.BatchNorm2d(norm_nc, affine=False) else: raise ValueError( '%s is not a recognized param-free norm type in SPADE' % param_free_norm_type) self.class_specified_affine = ClassAffine(label_nc, norm_nc, add_dist) if not no_instance: self.inst_conv = nn.Conv2d(1, 1, kernel_size=1, padding=0)
def add_norm_layer(layer): nonlocal norm_type if norm_type.startswith("spectral"): layer = spectral_norm(layer) subnorm_type = norm_type[len("spectral"):] else: subnorm_type = norm_type if subnorm_type == "none" or len(subnorm_type) == 0: return layer # remove bias in the previous layer, which is meaningless # since it has no effect after normalization if getattr(layer, "bias", None) is not None: delattr(layer, "bias") layer.register_parameter("bias", None) if subnorm_type == "batch": norm_layer = nn.BatchNorm2d(get_out_channel(layer), affine=True) elif subnorm_type == "sync_batch": norm_layer = SynchronizedBatchNorm2d(get_out_channel(layer), affine=True) elif subnorm_type == "instance": norm_layer = nn.InstanceNorm2d(get_out_channel(layer), affine=False) else: raise ValueError("normalization layer %s is not recognized" % subnorm_type) return nn.Sequential(layer, norm_layer)
def __init__(self, config_text, norm_nc, label_nc): super().__init__() assert config_text.startswith('fade') parsed = re.search('fade(\D+)(\d)x\d', config_text) param_free_norm_type = str(parsed.group(1)) ks = int(parsed.group(2)) if param_free_norm_type == 'instance': self.param_free_norm = nn.InstanceNorm2d(norm_nc, affine=False) elif param_free_norm_type == 'syncbatch': self.param_free_norm = SynchronizedBatchNorm2d(norm_nc, affine=False) elif param_free_norm_type == 'batch': self.param_free_norm = nn.BatchNorm2d(norm_nc, affine=False) else: raise ValueError( '%s is not a recognized param-free norm type in FADE' % param_free_norm_type) pw = ks // 2 self.mlp_gamma = nn.Conv2d(label_nc, norm_nc, kernel_size=ks, padding=pw) self.mlp_beta = nn.Conv2d(label_nc, norm_nc, kernel_size=ks, padding=pw)
def __init__(self, config_text, norm_nc, label_nc, opt, triple=False): super().__init__() assert config_text.startswith('spade') parsed = re.search('spade(\D+)(\d)x\d', config_text) param_free_norm_type = str(parsed.group(1)) ks = int(parsed.group(2)) if param_free_norm_type == 'instance': self.param_free_norm = nn.InstanceNorm2d(norm_nc, affine=False) elif param_free_norm_type == 'syncbatch': self.param_free_norm = SynchronizedBatchNorm2d(norm_nc, affine=False) elif param_free_norm_type == 'batch': self.param_free_norm = nn.BatchNorm2d(norm_nc, affine=False) else: raise ValueError( '%s is not a recognized param-free norm type in SPADE' % param_free_norm_type) # The dimension of the intermediate embedding space. Yes, hardcoded. nhidden = 128 pw = ks // 2 if opt.from_disp or triple: label_nc = opt.disp_nc + label_nc self.mlp_shared = nn.Sequential( nn.Conv2d(label_nc, nhidden, kernel_size=ks, padding=pw), nn.ReLU()) self.mlp_gamma = nn.Conv2d(nhidden, norm_nc, kernel_size=ks, padding=pw) self.mlp_beta = nn.Conv2d(nhidden, norm_nc, kernel_size=ks, padding=pw)
def __init__(self, config_text, norm_nc, label_nc, mask_emb_dim, attr_nc, attr_emb_dim): super().__init__() assert config_text.startswith('spade') parsed = re.search('spade(\D+)(\d)x\d', config_text) param_free_norm_type = str(parsed.group(1)) ks = int(parsed.group(2)) if param_free_norm_type == 'instance': self.param_free_norm = nn.InstanceNorm2d(norm_nc, affine=False) elif param_free_norm_type == 'syncbatch': self.param_free_norm = SynchronizedBatchNorm2d(norm_nc, affine=False) elif param_free_norm_type == 'batch': self.param_free_norm = nn.BatchNorm2d(norm_nc, affine=False) else: raise ValueError( '%s is not a recognized param-free norm type in SPADE' % param_free_norm_type) # The dimension of the intermediate embedding space. Yes, hardcoded. nhidden = 128 if attr_nc == 0: attr_emb_dim = 0 self.has_attr = False else: self.has_attr = True pw = ks // 2 self.emb = nn.Conv2d(label_nc, mask_emb_dim, 1, bias=False) if self.has_attr: self.emb_attr = nn.Conv2d(attr_nc, attr_emb_dim, 1, bias=False) self.mlp_shared = nn.Sequential( nn.Conv2d(mask_emb_dim + attr_emb_dim, nhidden, kernel_size=ks, padding=pw), nn.ReLU(inplace=True)) self.mlp_gamma = nn.Conv2d(nhidden, norm_nc, kernel_size=ks, padding=pw) self.mlp_beta = nn.Conv2d(nhidden, norm_nc, kernel_size=ks, padding=pw) self.mlp_shared_avg = nn.Sequential( nn.Conv2d(mask_emb_dim + attr_emb_dim, nhidden, kernel_size=ks, padding=pw), nn.ReLU(inplace=True)) self.mlp_gamma_avg = nn.Conv2d(nhidden, norm_nc, kernel_size=1, padding=0, bias=False) self.mlp_beta_avg = nn.Conv2d(nhidden, norm_nc, kernel_size=1, padding=0, bias=False)
def convlayer(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True): return nn.Sequential( SynchronizedBatchNorm2d(in_channels), Conv2d(in_channels, out_channels, kernel_size, stride, padding, dilation, groups, bias), nn.LeakyReLU(0.2))
def __init__(self, fin, fout, opt): super().__init__() # attributes self.learned_shortcut = (fin != fout) fmiddle = fin # 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_S: 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 subnorm_type = opt.norm_S.replace('spectral', '') if subnorm_type == 'batch': self.norm_layer_in = nn.BatchNorm2d(fin, affine=True) self.norm_layer_out = nn.BatchNorm2d(fout, affine=True) if self.learned_shortcut: self.norm_layer_s = nn.BatchNorm2d(fout, affine=True) elif subnorm_type == 'syncbatch': self.norm_layer_in = SynchronizedBatchNorm2d(fin, affine=True) self.norm_layer_out = SynchronizedBatchNorm2d(fout, affine=True) if self.learned_shortcut: self.norm_layer_s = SynchronizedBatchNorm2d(fout, affine=True) elif subnorm_type == 'instance': self.norm_layer_in = nn.InstanceNorm2d(fin, affine=False) self.norm_layer_out = nn.InstanceNorm2d(fout, affine=False) if self.learned_shortcut: self.norm_layer_s = nn.InstanceNorm2d(fout, affine=False) else: raise ValueError('normalization layer %s is not recognized' % subnorm_type)
def __init__(self, config_text, norm_nc, label_nc, ACE_Name=None, status='train', spade_params=None, use_rgb=True): super().__init__() self.ACE_Name = ACE_Name self.status = status self.save_npy = False self.Spade = SPADE(*spade_params) self.use_rgb = use_rgb self.style_length = 512 self.blending_gamma = nn.Parameter(torch.zeros(1), requires_grad=True) self.blending_beta = nn.Parameter(torch.zeros(1), requires_grad=True) self.noise_var = nn.Parameter(torch.zeros(norm_nc), requires_grad=True) assert config_text.startswith('spade') parsed = re.search('spade(\D+)(\d)x\d', config_text) param_free_norm_type = str(parsed.group(1)) ks = int(parsed.group(2)) pw = ks // 2 if param_free_norm_type == 'instance': self.param_free_norm = nn.InstanceNorm2d(norm_nc, affine=False) elif param_free_norm_type == 'syncbatch': self.param_free_norm = SynchronizedBatchNorm2d(norm_nc, affine=False) elif param_free_norm_type == 'batch': self.param_free_norm = nn.BatchNorm2d(norm_nc, affine=False) else: raise ValueError( '%s is not a recognized param-free norm type in SPADE' % param_free_norm_type) # The dimension of the intermediate embedding space. Yes, hardcoded. if self.use_rgb: self.create_gamma_beta_fc_layers() self.conv_gamma = nn.Conv2d(self.style_length, norm_nc, kernel_size=ks, padding=pw) self.conv_beta = nn.Conv2d(self.style_length, norm_nc, kernel_size=ks, padding=pw)
def __init__(self, opt): super().__init__() nf = opt.ngf kw = 4 if opt.domain_rela else 3 pw = int((kw - 1.0) / 2) self.feature = nn.Sequential(nn.Conv2d(4 * nf, 2 * nf, kw, stride=2, padding=pw), SynchronizedBatchNorm2d(2 * nf, affine=True), nn.LeakyReLU(0.2, False), nn.Conv2d(2 * nf, nf, kw, stride=2, padding=pw), SynchronizedBatchNorm2d(nf, affine=True), nn.LeakyReLU(0.2, False), nn.Conv2d(nf, int(nf // 2), kw, stride=2, padding=pw), SynchronizedBatchNorm2d(int(nf // 2), affine=True), nn.LeakyReLU(0.2, False)) #32*8*8 model = [nn.Linear(int(nf // 2) * 8 * 8, 100), SynchronizedBatchNorm1d(100, affine=True), nn.ReLU()] if opt.domain_rela: model += [nn.Linear(100, 1)] else: model += [nn.Linear(100, 2), nn.LogSoftmax(dim=1)] self.classifier = nn.Sequential(*model)
def __init__(self, config_text, norm_nc, image_nc, downsample_n): super().__init__() assert config_text.startswith('spade') parsed = re.search('spade(\D+)(\d)x\d', config_text) param_free_norm_type = str(parsed.group(1)) ks = int(parsed.group(2)) if param_free_norm_type == 'instance': self.param_free_norm = nn.InstanceNorm2d(norm_nc, affine=False) elif param_free_norm_type == 'syncbatch': self.param_free_norm = SynchronizedBatchNorm2d(norm_nc, affine=False) elif param_free_norm_type == 'batch': self.param_free_norm = nn.BatchNorm2d(norm_nc, affine=False) else: raise ValueError( '%s is not a recognized param-free norm type in SPADE' % param_free_norm_type) # The dimension of the intermediate embedding space. Yes, hardcoded. nhidden = 128 pw = ks // 2 self.mlp_shared = nn.Sequential( nn.Conv2d(image_nc, nhidden, kernel_size=ks, padding=pw), nn.ReLU()) self.middle = [] for i in range(downsample_n): self.middle += [ nn.Conv2d(nhidden, nhidden, kernel_size=3, padding=pw, stride=2) ] self.middle += [nn.ReLU()] self.middle = nn.Sequential(*self.middle) self.mlp_gamma = nn.Conv2d(nhidden, norm_nc, kernel_size=ks, padding=pw) self.mlp_beta = nn.Conv2d(nhidden, norm_nc, kernel_size=ks, padding=pw)
def __init__(self, norm_nc, hidden_nc=0, norm='batch', ks=3, params_free=False): super().__init__() pw = ks//2 if not isinstance(hidden_nc, list): hidden_nc = [hidden_nc] for i, nhidden in enumerate(hidden_nc): mlp_gamma = nn.Conv2d(nhidden, norm_nc, kernel_size=ks, padding=pw) mlp_beta = nn.Conv2d(nhidden, norm_nc, kernel_size=ks, padding=pw) if not params_free or (i != 0): s = str(i+1) if i > 0 else '' setattr(self, 'mlp_gamma%s' % s, mlp_gamma) setattr(self, 'mlp_beta%s' % s, mlp_beta) if 'batch' in norm: self.batch_norm = SynchronizedBatchNorm2d(norm_nc, affine=False) else: self.batch_norm = nn.InstanceNorm2d(norm_nc, affine=False) self.params_free = params_free self.hidden_nc = hidden_nc
def __init__(self, config_text, norm_nc, label_nc, PONO=False, use_apex=False): super().__init__() assert config_text.startswith('spade') parsed = re.search('spade(\D+)(\d)x\d', config_text) param_free_norm_type = str(parsed.group(1)) ks = int(parsed.group(2)) self.pad_type = 'zero' if PONO: self.param_free_norm = PositionalNorm2d elif param_free_norm_type == 'instance': self.param_free_norm = nn.InstanceNorm2d(norm_nc, affine=False) elif param_free_norm_type == 'syncbatch': if use_apex: self.param_free_norm = apex.parallel.SyncBatchNorm( norm_nc, affine=False) else: self.param_free_norm = SynchronizedBatchNorm2d(norm_nc, affine=False) elif param_free_norm_type == 'batch': self.param_free_norm = nn.BatchNorm2d(norm_nc, affine=False) else: raise ValueError( '%s is not a recognized param-free norm type in SPADE' % param_free_norm_type) # The dimension of the intermediate embedding space. Yes, hardcoded. nhidden = 128 pw = ks // 2 #print(ks, pw) if self.pad_type != 'zero': self.mlp_shared = nn.Sequential( nn.ReflectionPad2d(pw), nn.Conv2d(label_nc, nhidden, kernel_size=ks, padding=0), nn.ReLU()) self.pad = nn.ReflectionPad2d(pw) self.mlp_gamma = nn.Conv2d(nhidden, norm_nc, kernel_size=ks, padding=0) self.mlp_beta = nn.Conv2d(nhidden, norm_nc, kernel_size=ks, padding=0) else: self.mlp_shared = nn.Sequential( nn.Conv2d(label_nc, nhidden, kernel_size=ks, padding=pw), nn.ReLU()) self.mlp_gamma = nn.Conv2d(nhidden, norm_nc, kernel_size=ks, padding=pw) self.mlp_beta = nn.Conv2d(nhidden, norm_nc, kernel_size=ks, padding=pw)
def __init__(self, config_text, norm_nc, label_nc): super().__init__() assert config_text.startswith('spade') parsed = re.search('spade(\D+)(\d)x\d', config_text) param_free_norm_type = str(parsed.group(1)) ks = int(parsed.group(2)) if param_free_norm_type == 'instance': self.param_free_norm = nn.InstanceNorm2d(norm_nc, affine=False) elif param_free_norm_type == 'syncbatch': self.param_free_norm = SynchronizedBatchNorm2d(norm_nc, affine=False) elif param_free_norm_type == 'batch': self.param_free_norm = nn.BatchNorm2d(norm_nc, affine=False) else: raise ValueError( '%s is not a recognized param-free norm type in SPADE' % param_free_norm_type) # The dimension of the intermediate embedding space. Yes, hardcoded. nhidden = 128 pw = ks // 2 ''' self.mlp_shared_2 = nn.Sequential( nn.Conv2d(label_nc, nhidden, kernel_size=ks, padding=2, dilation = 2), nn.LeakyReLU(0.2) ) self.mlp_gamma_2 = nn.Conv2d(nhidden, norm_nc, kernel_size=ks, padding=2, dilation = 2) self.mlp_beta_2 = nn.Conv2d(nhidden, norm_nc, kernel_size=ks, padding=2, dilation = 2) self.mlp_shared_4 = nn.Sequential( nn.Conv2d(label_nc, nhidden, kernel_size=ks, padding=4, dilation = 4), nn.LeakyReLU(0.2) ) self.mlp_gamma_4 = nn.Conv2d(nhidden, norm_nc, kernel_size=ks, padding=4, dilation = 4) self.mlp_beta_4 = nn.Conv2d(nhidden, norm_nc, kernel_size=ks, padding=4, dilation = 4) self.mlp_shared_8 = nn.Sequential( nn.Conv2d(label_nc, nhidden, kernel_size=ks, padding=8, dilation = 8), nn.LeakyReLU(0.2) ) self.mlp_gamma_8 = nn.Conv2d(nhidden, norm_nc, kernel_size=ks, padding=8, dilation = 8) self.mlp_beta_8 = nn.Conv2d(nhidden, norm_nc, kernel_size=ks, padding=8, dilation = 8) self.mlp_shared_16 = nn.Sequential( nn.Conv2d(label_nc, nhidden, kernel_size=ks, padding=16, dilation = 16), nn.LeakyReLU(0.2) ) self.mlp_gamma_16 = nn.Conv2d(nhidden, norm_nc, kernel_size=ks, padding=16, dilation = 16) self.mlp_beta_16 = nn.Conv2d(nhidden, norm_nc, kernel_size=ks, padding=16, dilation = 16) ''' self.mlp_shared = nn.Sequential( nn.Conv2d(label_nc, nhidden, kernel_size=ks, padding=pw, dilation=1), nn.LeakyReLU(0.2)) self.mlp_gamma = nn.Conv2d(nhidden, norm_nc, kernel_size=ks, padding=pw, dilation=1) self.mlp_beta = nn.Conv2d(nhidden, norm_nc, kernel_size=ks, padding=pw, dilation=1)
def __init__(self, config_text, norm_nc, label_nc, group_num=0, use_instance=False, data_mode='deepfashion'): super().__init__() if group_num == 0: group_num = label_nc assert config_text.startswith('spade') parsed = re.search('spade(\D+)(\d)x\d', config_text) param_free_norm_type = str(parsed.group(1)) ks = int(parsed.group(2)) if param_free_norm_type == 'instance': self.param_free_norm = nn.InstanceNorm2d(norm_nc, affine=False) elif param_free_norm_type == 'syncbatch': self.param_free_norm = SynchronizedBatchNorm2d(norm_nc, affine=False) elif param_free_norm_type == 'batch': self.param_free_norm = nn.BatchNorm2d(norm_nc, affine=False) elif param_free_norm_type == 'group': self.param_free_norm = nn.GroupNorm(label_nc, norm_nc) else: raise ValueError( '%s is not a recognized param-free norm type in SPADE' % param_free_norm_type) # The dimension of the intermediate embedding space. Yes, hardcoded. if use_instance: seg_in_dim = label_nc * 2 else: seg_in_dim = label_nc pw = ks // 2 # print(data_mode) if data_mode == 'deepfashion': nhidden = 128 self.mlp_shared = nn.Sequential( nn.Conv2d(seg_in_dim, nhidden, kernel_size=ks, padding=pw, groups=group_num), nn.ReLU()) self.mlp_gamma = nn.Conv2d(nhidden, norm_nc, kernel_size=ks, padding=pw, groups=group_num) self.mlp_beta = nn.Conv2d(nhidden, norm_nc, kernel_size=ks, padding=pw, groups=group_num) elif data_mode == 'sketch': nhidden = 64 self.mlp_shared = nn.Sequential( nn.Conv2d(seg_in_dim, nhidden, kernel_size=ks, padding=pw, groups=group_num), nn.ReLU()) self.mlp_gamma = nn.Conv2d(nhidden, norm_nc, kernel_size=ks, padding=pw, groups=group_num) self.mlp_beta = nn.Conv2d(nhidden, norm_nc, kernel_size=ks, padding=pw, groups=group_num) elif data_mode == 'cityscapes': nhidden = label_nc * group_num # print(nhidden) self.mlp_shared = nn.Sequential( nn.Conv2d(seg_in_dim, nhidden, kernel_size=ks, padding=pw, groups=label_nc), # nn.Conv2d(seg_in_dim, nhidden, kernel_size=ks, padding=pw), nn.ReLU()) self.mlp_gamma = nn.Conv2d(nhidden, norm_nc, kernel_size=ks, padding=pw, groups=label_nc) self.mlp_beta = nn.Conv2d(nhidden, norm_nc, kernel_size=ks, padding=pw, groups=label_nc) elif data_mode == 'ade20k': if label_nc % group_num == 0: nhidden = label_nc * 2 else: nhidden = label_nc * group_num self.mlp_shared = nn.Sequential( nn.Conv2d(seg_in_dim, nhidden, kernel_size=ks, padding=pw, groups=label_nc), # nn.Conv2d(seg_in_dim, nhidden, kernel_size=ks, padding=pw), nn.ReLU()) self.mlp_gamma = nn.Conv2d(nhidden, norm_nc, kernel_size=ks, padding=pw, groups=group_num) self.mlp_beta = nn.Conv2d(nhidden, norm_nc, kernel_size=ks, padding=pw, groups=group_num)