def __init__(self, output_size, input_size, which_linear, eps=1e-5, momentum=0.1,
cross_replica=False, mybn=False, norm_style='bn', ):
super(ccbn, self).__init__()
self.output_size, self.input_size = output_size, input_size
# Prepare gain and bias layers
self.gain = which_linear(input_size, output_size)
self.bias = which_linear(input_size, output_size)
# epsilon to avoid dividing by 0
self.eps = eps
# Momentum
self.momentum = momentum
# Use cross-replica batchnorm?
self.cross_replica = cross_replica
# Use my batchnorm?
self.mybn = mybn
# Norm style?
self.norm_style = norm_style
if self.cross_replica:
self.bn = SyncBN2d(output_size, eps=self.eps, momentum=self.momentum, affine=False)
elif self.mybn:
self.bn = myBN(output_size, self.eps, self.momentum)
elif self.norm_style in ['bn', 'in']:
self.register_buffer('stored_mean', torch.zeros(output_size))
self.register_buffer('stored_var', torch.ones(output_size))
def __init__(self,
output_size,
eps=1e-5,
momentum=0.1,
cross_replica=False,
mybn=False):
super(bn, self).__init__()
self.output_size = output_size
# Prepare gain and bias layers
self.gain = P(torch.ones(output_size), requires_grad=True)
self.bias = P(torch.zeros(output_size), requires_grad=True)
# epsilon to avoid dividing by 0
self.eps = eps
# Momentum
self.momentum = momentum
# Use cross-replica batchnorm?
self.cross_replica = cross_replica
# Use my batchnorm?
self.mybn = mybn
if self.cross_replica:
self.bn = SyncBN2d(output_size,
eps=self.eps,
momentum=self.momentum,
affine=False)
elif mybn:
self.bn = myBN(output_size, self.eps, self.momentum)
# Register buffers if neither of the above
else:
self.register_buffer('stored_mean', torch.zeros(output_size))
self.register_buffer('stored_var', torch.ones(output_size))
def __init__(self, code_dim=100, n_class=100,nc=3, SN=True,Resolution=64,ch=64,SA_Resolution=256):
super().__init__()
self.ch = ch
rate=1.0
if SN == True:
self.lin_code = spectral_init(nn.Linear(code_dim, 4 * 4 * ch*4),rate=rate)
self.embedding = spectral_init(nn.Embedding(n_class, ch*4),rate=rate)
else:
self.lin_code = nn.Linear(code_dim, 4 * 4 * ch*4)
self.embedding = nn.Embedding(n_class, ch*4)
layer_num = int(math.log(Resolution/4,2))
SA_layer = int(math.log(SA_Resolution/4,2))
self.conv = []
for i in range(layer_num):
self.conv.append(ConvBlock(ch*4, ch*4, n_class=n_class,SN=SN,emb = self.embedding))
# if i+1 == SA_layer:
# self.conv.append(SelfAttention(ch*4, SN=SN))
# print('apply sa G')
self.conv = nn.ModuleList(self.conv)
self.bn = SyncBN2d(ch*4, eps=1e-5, momentum=0.5, affine=False)#nn.BatchNorm2d(ch*4)
if SN == True:
self.colorize = spectral_init(nn.Conv2d(ch*4, nc, [3, 3], padding=1),rate=rate)
else:
self.colorize = nn.Conv2d(ch*4, nc, [3, 3], padding=1)
self.optim = optim.Adam(params=self.parameters(), lr=1e-4,
betas=(0.0, 0.999), eps=1e-8)
self.init_weights()
def __init__(self, in_channel, n_class):
super().__init__()
self.bn = SyncBN2d(in_channel, eps=1e-5, momentum=0.5, affine=False)#nn.BatchNorm2d(in_channel, affine=False)
self.embed = nn.Embedding(n_class, in_channel * 2)
self.embed.weight.data[:, :in_channel] = 1
self.embed.weight.data[:, in_channel:] = 0
def __init__(self,
output_size,
input_size,
which_linear,
eps=1e-5,
momentum=0.1,
cross_replica=False,
mybn=False,
norm_style='bn',
style_linear=None,
dim_z=0,
no_conditional=False,
skip_z=False,
use_dog_cnt=False,
g_shared=False):
super(ccbn, self).__init__()
self.output_size, self.input_size = output_size, input_size
self.use_dog_cnt = use_dog_cnt
self.g_shared = g_shared
# Prepare gain and bias layers
self.gain = which_linear(input_size, output_size)
self.bias = which_linear(input_size, output_size)
if use_dog_cnt and not g_shared:
self.gain_dog_cnt = which_linear(input_size, output_size)
self.bias_dog_cnt = which_linear(input_size, output_size)
# epsilon to avoid dividing by 0
self.eps = eps
# Momentum
self.momentum = momentum
# Use cross-replica batchnorm?
self.cross_replica = cross_replica
# Use my batchnorm?
self.mybn = mybn
# Norm style?
self.norm_style = norm_style
self.no_conditional = no_conditional
if self.cross_replica:
self.bn = SyncBN2d(output_size,
eps=self.eps,
momentum=self.momentum,
affine=False)
elif self.mybn:
self.bn = myBN(output_size, self.eps, self.momentum)
elif self.norm_style in ['bn', 'in']:
self.register_buffer('stored_mean', torch.zeros(output_size))
self.register_buffer('stored_var', torch.ones(output_size))
if style_linear is not None:
if skip_z:
self.style = style_linear(dim_z * 2, output_size * 2)
else:
self.style = style_linear(dim_z, output_size * 2)
self.style.bias.data[:output_size] = 1
self.style.bias.data[output_size:] = 0
def __init__(self, in_channel, n_condition, cross_replica=False):
super().__init__()
if cross_replica:
self.bn = SyncBN2d(in_channel, affine=False)
else:
self.bn = nn.BatchNorm2d(in_channel,
affine=False) # no learning parameters
self.embed = nn.Linear(n_condition, in_channel * 2)
nn.init.orthogonal_(self.embed.weight.data[:, :in_channel], gain=1)
self.embed.weight.data[:, in_channel:].zero_()
