def __init__(self, in_size, out_size, cond_size, up=2, activation=func.relu_, normalization=nn.BatchNorm2d): r"""Single residual block of a BigGAN generator. Args: in_size (int): number of input features. out_size (int): number of output features. cond_size (int): number of condition features. up (int or None): upsampling scale. If None, does not perform upsampling. activation (function): nonlinear activation function. Defaults to ReLU. normalization (function): normalization function. Defaults to BatchNorm2d. """ super().__init__() self.up = up self.activation = activation self.in_mod = spectral_norm(nn.Linear(cond_size, 2 * in_size, bias=False)) self.out_mod = spectral_norm(nn.Linear(cond_size, 2 * in_size, bias=False)) self.in_norm = normalization(in_size, affine=False) self.out_norm = normalization(in_size, affine=False) self.in_conv = spectral_norm(nn.Conv2d(in_size, in_size, 3, padding=1, bias=False)) self.out_conv = spectral_norm(nn.Conv2d(in_size, out_size, 3, padding=1, bias=False)) self.skip_conv = spectral_norm(nn.Conv2d(in_size, out_size, 1, bias=False))
def __init__(self, input_size, hidden_sizes, output_size, hidden_act=nn.ReLU, output_act=None, hid_layer_norm=False, hid_spectral_norm=False, out_layer_norm=False, out_spectral_norm=False): super().__init__() if not isinstance(hidden_sizes, list): raise TypeError('hidden_sizes should be a list') in_size = input_size self.fcs = nn.ModuleList() for i, hid_size in enumerate(hidden_sizes): fc = nn.Linear(in_size, hid_size) if hid_spectral_norm: fc = spectral_norm(fc) in_size = hid_size self.fcs.append(fc) if hid_layer_norm: self.fcs.append(nn.LayerNorm(hid_size)) self.fcs.append(hidden_act()) last_fc = nn.Linear(in_size, output_size) if out_spectral_norm: last_fc = spectral_norm(last_fc) self.fcs.append(last_fc) if out_layer_norm: self.fcs.append(nn.LayerNorm(output_size)) if output_act is not None: self.fcs.append(output_act())
def __init__(self, input_nc=3, nef=64, n_style=1, n_blocks=4, norm_type='cbin'): super(StyleEncoder, self).__init__() norm_layer, _ = get_norm_layer(layer_type=norm_type) nl_layer = get_nl_layer(layer_type='lrelu') block = [ Conv2dBlock(input_nc, nef, kernel_size=4, stride=2, padding=1, bias=True) ] for n in range(1, n_blocks): input_nef = min(nef * n, 256) output_nef = min(nef * (n + 1), 256) block.append( DownResidualBlock(input_nef, output_nef, norm_layer, nl_layer)) block += [nl_layer(), nn.AdaptiveAvgPool2d(1)] self.encode = nn.Sequential(*block) self.fc = spectral_norm(nn.Linear(output_nef, n_style)) self.fcVar = spectral_norm(nn.Linear(output_nef, n_style))
def __init__(self, in_nc, out_nc, nf=32): super(Discriminator, self).__init__() self.input_nc = in_nc self.output_nc = out_nc self.nf = nf self.activation = nn.LeakyReLU(0.2, True) self.conv1 = nn.Sequential(nn.Conv2d(in_nc, nf, 3, 1, 1), nn.LeakyReLU(0.2, True)) self.conv2 = nn.Sequential( nn.Conv2d(nf, nf * 2, 3, 2, 1), nn.LeakyReLU(0.2, True), spectral_norm(nn.Conv2d(nf * 2, nf * 4, 3, 1, 1)), nn.LeakyReLU(0.2, True)) self.conv3 = nn.Sequential( nn.Conv2d(nf * 4, nf * 4, 3, 2, 1), nn.LeakyReLU(0.2, True), spectral_norm(nn.Conv2d(nf * 4, nf * 8, 3, 1, 1)), nn.LeakyReLU(0.2, True)) self.conv4 = nn.Sequential( spectral_norm(nn.Conv2d(nf * 8, nf * 8, 3, 1, 1)), nn.LeakyReLU(0.2, True)) self.conv5 = nn.Sequential(nn.Conv2d(nf * 8, out_nc, 3, 1, 1))
def __init__(self, in_channels, out_channels, kernel=3, use_spectral_norm=True): super(OptimizedD_Block, self).__init__() self.relu0 = nn.ReLU() conv1 = conv_layer(in_channels, out_channels, kernel, padding=1, stride=2) self.conv1 = spectral_norm(conv1) if use_spectral_norm else conv1 self.act1 = nn.ReLU() # same i/p -> o/p dimensions conv = conv_layer(out_channels, out_channels, kernel, padding=1, stride=1) self.conv = spectral_norm(conv) if use_spectral_norm else conv conv2 = conv_layer(in_channels, out_channels, kernel, padding=1, stride=2) self.conv2 = spectral_norm(conv2) if use_spectral_norm else conv2 '''
def conv_block(in_channels, out_channels, kernel_size=3, stride=1, dilation=1, bias=True): """Conv block used in MSDilationBlock.""" return nn.Sequential( spectral_norm( nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, stride=stride, dilation=dilation, padding=((kernel_size - 1) // 2) * dilation, bias=bias)), nn.LeakyReLU(0.2), spectral_norm( nn.Conv2d(out_channels, out_channels, kernel_size=kernel_size, stride=stride, dilation=dilation, padding=((kernel_size - 1) // 2) * dilation, bias=bias)), )
def __init__(self, in_channels, out_channels, stride=1): super(ResBlockDiscriminator, self).__init__() self.conv1 = nn.Conv2d(in_channels, out_channels, 3, 1, padding=1) self.conv2 = nn.Conv2d(out_channels, out_channels, 3, 1, padding=1) nn.init.xavier_uniform(self.conv1.weight.data, 1.) nn.init.xavier_uniform(self.conv2.weight.data, 1.) if stride == 1: self.model = nn.Sequential(nn.ReLU(), spectral_norm(self.conv1), nn.ReLU(), spectral_norm(self.conv2)) else: self.model = nn.Sequential( nn.ReLU(), spectral_norm(self.conv1), nn.ReLU(), spectral_norm(self.conv2), nn.AvgPool2d(2, stride=stride, padding=0)) self.bypass = nn.Sequential() if stride != 1: self.bypass_conv = nn.Conv2d(in_channels, out_channels, 1, 1, padding=0) nn.init.xavier_uniform(self.bypass_conv.weight.data, np.sqrt(2)) self.bypass = nn.Sequential( spectral_norm(self.bypass_conv), nn.AvgPool2d(2, stride=stride, padding=0))
def __init__(self, in_channels, out_channels, n_classes, kernel=3, use_spectral_norm=True, upsample=True, negative_slope=0.1): super(res_block_g, self).__init__() # self.bn0 = nn.BatchNorm2d(in_channels) # ConditionalBN(n_classes, in_channels) self.bn0 = ConditionalBN(n_classes, in_channels) self.relu0 = nn.ReLU() conv1 = conv_layer(in_channels, out_channels, kernel, padding=1) self.conv1 = spectral_norm(conv1) if use_spectral_norm else conv1 # self.bn1 = nn.BatchNorm2d(out_channels) # ConditionalBN(n_classes, num_features=out_channels) self.bn1 = ConditionalBN(n_classes, num_features=out_channels) self.act1 = nn.ReLU() conv2 = conv_layer(out_channels, out_channels, kernel, padding=1) self.conv2 = spectral_norm(conv2) if use_spectral_norm else conv2 self.learnable_sc = (in_channels != out_channels) or upsample if self.learnable_sc: conv_sc = conv_layer(in_channels, out_channels, 1, padding=0) self.conv_sc = spectral_norm( conv_sc) if use_spectral_norm else conv_sc if upsample: self.upsample0 = nn.Upsample(scale_factor=2) self.upsample1 = nn.Upsample(scale_factor=2) self.upsample = upsample
def __init__(self, in_channels, out_channels, kernel=3, use_spectral_norm=True, downsample=True, negative_slope=0.1): super(res_block_d, self).__init__() self.relu0 = nn.ReLU() conv1 = conv_layer(in_channels, out_channels, kernel, padding=1) self.conv1 = spectral_norm(conv1) if use_spectral_norm else conv1 self.act1 = nn.ReLU() conv2 = conv_layer(out_channels, out_channels, 1, padding=0) self.conv2 = spectral_norm(conv2) if use_spectral_norm else conv2 self.learnable_sc = (in_channels != out_channels) or downsample if self.learnable_sc: conv_sc = conv_layer(in_channels, out_channels, kernel, padding=1) self.conv_sc = spectral_norm( conv_sc) if use_spectral_norm else conv_sc if downsample: self.downsample0 = nn.AvgPool2d(kernel_size=2) self.downsample1 = nn.AvgPool2d(kernel_size=2) self.downsample = downsample
def __init__(self, C, use_spectral_norm=True, downsample=True): super(SelfAttention, self).__init__() self.C = C self.downsample = downsample self.gamma = nn.Parameter(torch.zeros(1), requires_grad=True) theta_conv = conv_layer(self.C, self.C // 8, kernel_size=1) self.theta_conv = spectral_norm( theta_conv) if use_spectral_norm else theta_conv phi_conv = conv_layer(self.C, self.C // 8, kernel_size=1) if self.downsample: self.mPool1 = nn.MaxPool2d(2) self.mPool2 = nn.MaxPool2d(2) self.phi_conv = spectral_norm( phi_conv) if use_spectral_norm else phi_conv g_conv = conv_layer(self.C, self.C // 2, kernel_size=1) self.g_conv = spectral_norm(g_conv) if use_spectral_norm else g_conv self.softmax = nn.Softmax(dim=-1) final_conv = conv_layer(self.C // 2, self.C, kernel_size=1) self.final_conv = spectral_norm( final_conv) if use_spectral_norm else final_conv
def __init__(self, ngpu): super(Generator, self).__init__() self.ngpu = ngpu self.main = nn.Sequential( # input is Z, going into a convolution spectral_norm(nn.ConvTranspose2d(nz, ngf * 8, 4, 1, 0, bias=False)), nn.BatchNorm2d(ngf * 8), nn.ReLU(True), # state size. (ngf*8) x 4 x 4 spectral_norm( nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False)), nn.BatchNorm2d(ngf * 4), nn.ReLU(True), # state size. (ngf*4) x 8 x 8 spectral_norm( nn.ConvTranspose2d(ngf * 4, ngf * 2, 4, 2, 1, bias=False)), nn.BatchNorm2d(ngf * 2), nn.ReLU(True), # state size. (ngf*2) x 16 x 16 spectral_norm(nn.ConvTranspose2d(ngf * 2, ngf, 4, 2, 1, bias=False)), nn.BatchNorm2d(ngf), nn.ReLU(True), # state size. (ngf) x 32 x 32 spectral_norm(nn.ConvTranspose2d(ngf, nc, 4, 2, 1, bias=False)), nn.Tanh() # state size. (nc) x 64 x 64 )
def __init__(self, num_classes, use_spectral_norm=True, use_attention=False, base_filters=64): super(Discriminator32_FakeClass, self).__init__() self.num_classes = num_classes self.use_attention = use_attention self.block1 = res_block_d(3, base_filters, use_spectral_norm=use_spectral_norm) # 16x16 self.block2 = res_block_d(base_filters, base_filters, use_spectral_norm=use_spectral_norm) # 8x8 self.block3 = res_block_d(base_filters, base_filters, use_spectral_norm=use_spectral_norm) # 4x4 final_linear = linear_layer(in_features=base_filters, out_features=1) self.final_linear = spectral_norm( final_linear) if use_spectral_norm else final_linear embedding = embedding_layer(num_embeddings=num_classes, embedding_dim=base_filters) self.embedding = spectral_norm( embedding) if use_spectral_norm else embedding if use_attention: self.att = SelfAttention(base_filters)
def __init__(self, depth=4, down=2, shape=64): super().__init__() self.preprocess = spectral_norm( nn.Conv2d(1 + 1 + 42, 128, 3, padding=1)) self.blocks = nn.ModuleList([ nn.Sequential( spectral_norm( nn.Conv2d(128 * 2**(idx // down), 128 * 2**(idx // down), 3, padding=1)), nn.LeakyReLU(), spectral_norm( nn.Conv2d(128 * 2**(idx // down), 128 * 2**(idx // down), 3, padding=1)), nn.LeakyReLU(), spectral_norm( nn.Conv2d(128 * 2**(idx // down), 128 * 2**((idx + 1) // down), 3, padding=1)), nn.LeakyReLU()) for idx in range(depth) ]) self.predict = spectral_norm(nn.Linear(128 * 2**(depth // down), 1)) self.shape = shape self.down = down
def __init__(self, ndf=512, nc=3): super(NetD, self).__init__() self.layer1 = self.layer(3, ndf // 8) self.layer2 = self.layer(ndf // 8, ndf // 4) self.layer3 = self.layer(ndf // 4, ndf // 2) self.layer4 = spectral_norm(nn.Conv2d(ndf // 2, ndf, nc, 1, 1)) self.linear = spectral_norm(nn.Linear(ndf * 4 * 4, 1))
def __init__(self, in_size, size): super().__init__() self.preprocess = spectral_norm(nn.Conv1d(in_size, size, 3, padding=1)) self.blocks = nn.ModuleList([ spectral_norm( nn.Conv1d(size, size, 3, dilation=2**idx, padding=2**idx)) for idx in range(4) ])
def __init__(self, input_nc, ndf=64, n_layers=3, norm_layer=nn.BatchNorm2d, use_sigmoid=False, getIntermFeat=False): super(NLayerDiscriminator, self).__init__() self.getIntermFeat = getIntermFeat self.n_layers = n_layers kw = 4 padw = int(np.ceil((kw - 1.0) / 2)) sequence = [[ nn.Conv2d(input_nc, ndf, kernel_size=kw, stride=2, padding=padw), nn.LeakyReLU(0.2, True) ]] nf = ndf for n in range(1, n_layers): nf_prev = nf nf = min(nf * 2, 512) sequence += [[ spectral_norm( nn.Conv2d(nf_prev, nf, kernel_size=kw, stride=2, padding=padw)), norm_layer(nf), nn.LeakyReLU(0.2, True) ]] nf_prev = nf nf = min(nf * 2, 512) sequence += [[ spectral_norm( nn.Conv2d(nf_prev, nf, kernel_size=kw, stride=1, padding=padw)), norm_layer(nf), nn.LeakyReLU(0.2, True) ]] sequence += [[ nn.Conv2d(nf, 1, kernel_size=kw, stride=1, padding=padw) ]] if use_sigmoid: sequence += [[nn.Sigmoid()]] if getIntermFeat: for n in range(len(sequence)): setattr(self, 'model' + str(n), nn.Sequential(*sequence[n])) else: sequence_stream = [] for n in range(len(sequence)): sequence_stream += sequence[n] self.model = nn.Sequential(*sequence_stream)
def build_discriminator(self): D = nn.Sequential( # 3 -> 8 spectral_norm( nn.Conv2d(3, self.ndf * 2, kernel_size=3, stride=2, padding=1, bias=False)), nn.BatchNorm2d(self.ndf * 2), nn.LeakyReLU(0.2, inplace=True), # 8 -> 16 spectral_norm( nn.Conv2d(self.ndf * 2, self.ndf * 4, kernel_size=3, stride=2, padding=1, bias=False)), nn.BatchNorm2d(self.ndf * 4), nn.LeakyReLU(0.2, inplace=True), # 16 -> 32 spectral_norm( nn.Conv2d(self.ndf * 4, self.ndf * 8, kernel_size=3, stride=2, padding=1, bias=False)), nn.BatchNorm2d(self.ndf * 8), nn.LeakyReLU(0.2, inplace=True), SelfAttention(C=self.ndf * 8), # 32 -> 64 spectral_norm( nn.Conv2d(self.ndf * 8, self.ndf * 16, kernel_size=3, stride=2, padding=1, bias=False)), nn.BatchNorm2d(self.ndf * 16), nn.LeakyReLU(0.2, inplace=True), SelfAttention(C=self.ndf * 16), spectral_norm( nn.Conv2d(self.ndf * 16, 1, kernel_size=2, stride=1, padding=0, bias=True))) return D
def build_generator(self): # merged_x -> (B, nZ, 1, 1) nZ = self.nZ self.conv1 = spectral_norm( nn.ConvTranspose2d(nZ, self.ndf * 32, kernel_size=4, stride=2, bias=False, padding=0)) self.bn1 = ConditionalBN(self.num_classes, self.ndf * 32) self.act1 = nn.ReLU() self.conv2 = spectral_norm( nn.ConvTranspose2d(self.ndf * 32, self.ndf * 16, kernel_size=4, stride=2, bias=False, padding=1)) self.bn2 = ConditionalBN(self.num_classes, self.ndf * 16) self.act2 = nn.ReLU() self.attn1 = SelfAttention(C=self.ndf * 16) self.conv3 = spectral_norm( nn.ConvTranspose2d(self.ndf * 16, self.ndf * 8, kernel_size=4, stride=2, padding=1, bias=False)) self.bn3 = ConditionalBN(self.num_classes, self.ndf * 8) self.act3 = nn.ReLU() self.attn2 = SelfAttention(C=self.ndf * 8) self.conv4 = spectral_norm( nn.ConvTranspose2d(self.ndf * 8, self.ndf * 4, kernel_size=4, stride=2, padding=1, bias=False)) self.bn4 = ConditionalBN(self.num_classes, self.ndf * 4) self.act4 = nn.ReLU() self.conv5 = nn.Conv2d(self.ndf * 4, 3, kernel_size=1, stride=1, padding=0, bias=True) self.tanh = nn.Tanh()
def build_norm_layer(norm_type, param=None, num_feats=None): if norm_type == 'bnorm': return nn.BatchNorm1d(num_feats) elif norm_type == 'snorm': spectral_norm(param) return None elif norm_type is None: return None else: raise TypeError('Unrecognized norm type: ', norm_type)
def __init__(self, in_channels, out_channels): super().__init__() self.shortcut = nn.Sequential( nn.AvgPool2d(2), spectral_norm(nn.Conv2d(in_channels, out_channels, 1, 1, 0))) self.residual = nn.Sequential( spectral_norm(nn.Conv2d(in_channels, out_channels, 3, 1, 1)), nn.ReLU(), spectral_norm(nn.Conv2d(out_channels, out_channels, 3, 1, 1)), nn.AvgPool2d(2))
def initialize(self): for m in self.residual.modules(): if isinstance(m, nn.Conv2d): init.xavier_uniform_(m.weight, math.sqrt(2)) init.zeros_(m.bias) spectral_norm(m) for m in self.shortcut.modules(): if isinstance(m, nn.Conv2d): init.xavier_uniform_(m.weight) init.zeros_(m.bias) spectral_norm(m)
def __init__(self, NUM_CLASSES=10): super(ProjectionDiscriminator_nobn, self).__init__() self.ndf = 64 self.embedding = spectral_norm(nn.Embedding(NUM_CLASSES, self.ndf * 16)) self.discriminator = self.build_discriminator() self.final_linear = spectral_norm( nn.Linear(self.ndf * 16, 1, bias=True))
def use_s_norm(self, inp, outp, k, s, p, b = None): if self.s_norm: if b is None: return spectral_norm(nn.Conv2d(inp, outp, kernel_size=k, stride=s, padding=p)) else: return spectral_norm(nn.Conv2d(inp, outp, kernel_size=k, stride=s, padding=p, bias = b)) else: if b is None: return nn.Conv2d(inp, outp, kernel_size=k, stride=s, padding=p) else: return nn.Conv2d(inp, outp, kernel_size=k, stride=s, padding=p, bias = b)
def build_generator(self): # merged_x -> (B, nZ, 1, 1) nZ = self.nZ G = nn.Sequential( # IN: (-1, nZ, 1, 1) spectral_norm( nn.ConvTranspose2d(nZ, self.ndf * 32, kernel_size=4, stride=2, bias=False, padding=0)), nn.BatchNorm2d(self.ndf * 32), nn.ReLU(inplace=True), spectral_norm( nn.ConvTranspose2d(self.ndf * 32, self.ndf * 16, kernel_size=4, stride=2, bias=False, padding=1)), nn.BatchNorm2d(self.ndf * 16), nn.ReLU(inplace=True), SelfAttention(C=self.ndf * 16), spectral_norm( nn.ConvTranspose2d(self.ndf * 16, self.ndf * 8, kernel_size=4, stride=2, padding=1, bias=False)), nn.BatchNorm2d(self.ndf * 8), nn.ReLU(inplace=True), SelfAttention(C=self.ndf * 8), spectral_norm( nn.ConvTranspose2d(self.ndf * 8, self.ndf * 4, kernel_size=4, stride=2, padding=1, bias=False)), nn.BatchNorm2d(self.ndf * 4), nn.ReLU(inplace=True), nn.Conv2d(self.ndf * 4, 3, kernel_size=1, stride=1, padding=0, bias=True), nn.Tanh()) return G
def __init__(self, num_classes, z_dim=64, base_width=8, base_filters=4, use_spectral_norm=True, use_attention=False): super(Generator, self).__init__() self.num_classes = num_classes self.base_width = base_width self.base_filters = base_filters self.use_attention = use_attention l1 = linear_layer(in_features=z_dim, out_features=(base_width**2) * 16 * base_filters) self.l1 = spectral_norm(l1) if use_spectral_norm else l1 self.block0 = res_block_g(16 * base_filters, 8 * base_filters, num_classes, use_spectral_norm=use_spectral_norm) # 16x16 self.block1 = res_block_g(8 * base_filters, 4 * base_filters, num_classes, use_spectral_norm=use_spectral_norm) # 32x32 self.block2 = res_block_g(4 * base_filters, 4 * base_filters, num_classes, use_spectral_norm=use_spectral_norm) # 64x64 self.block3 = res_block_g( 4 * base_filters, 2 * base_filters, num_classes, use_spectral_norm=use_spectral_norm) # 128x128 self.block4 = res_block_g( 2 * base_filters, base_filters, num_classes, use_spectral_norm=use_spectral_norm) # 256x256 # self.bn = ConditionalBN(num_classes, base_filters)# batch_norm(4*base_filters) self.bn = batch_norm(base_filters) self.act = nn.ReLU() conv_l = conv_layer(base_filters, 3, 3, padding=1) self.conv_l = spectral_norm(conv_l) if use_spectral_norm else conv_l self.tanh = nn.Tanh() if use_attention: # self.att = SelfAttention(4*base_filters, downsample=True) self.att2 = SelfAttention(4 * base_filters, downsample=True)
def __init__(self, num_features, num_con=8, eps=1e-5, momentum=0.1, track_running_stats=False): super(_AdaINorm, self).__init__(num_features, eps, momentum, affine, track_running_stats) self.num_con = num_con if num_con > 0: self.ConAlpha = spectral_norm(nn.Linear(num_con, num_features)) self.ConBeta = spectral_norm(nn.Linear(num_con, num_features))
def __init__(self, M=32): super().__init__() self.M = M self.main = nn.Sequential( # M spectral_norm(nn.Conv2d( 3, 64, kernel_size=3, stride=1, padding=1, bias=False)), nn.LeakyReLU(0.1, inplace=True), spectral_norm(nn.Conv2d( 64, 64, kernel_size=4, stride=2, padding=1, bias=False)), nn.LeakyReLU(0.1, inplace=True), # M / 2 spectral_norm(nn.Conv2d( 64, 128, kernel_size=3, stride=1, padding=1, bias=False)), nn.LeakyReLU(0.1, inplace=True), spectral_norm(nn.Conv2d( 128, 128, kernel_size=4, stride=2, padding=1, bias=False)), nn.LeakyReLU(0.1, inplace=True), # M / 4 spectral_norm(nn.Conv2d( 128, 256, kernel_size=3, stride=1, padding=1, bias=False)), nn.LeakyReLU(0.1, inplace=True), spectral_norm(nn.Conv2d( 256, 256, kernel_size=4, stride=2, padding=1, bias=False)), nn.LeakyReLU(0.1, inplace=True), # M / 8 spectral_norm(nn.Conv2d( 256, 512, kernel_size=3, stride=1, padding=1, bias=False)), nn.LeakyReLU(0.1, inplace=True)) self.linear = spectral_norm( nn.Linear(M // 8 * M // 8 * 512, 1, bias=False)) res_arch_init(self)
def __init__(self, embed_dim, max_seq_len, num_rep, vocab_size, padding_idx, norm='none',gpu=False, dropout=0.25): super(RelGAN_D, self).__init__(embed_dim, vocab_size, dis_filter_sizes, dis_num_filters, padding_idx, gpu, dropout) self.embed_dim = embed_dim self.max_seq_len = max_seq_len self.feature_dim = sum(dis_num_filters) self.emb_dim_single = int(embed_dim / num_rep) self.num_rep = num_rep self.embeddings = nn.Linear(vocab_size, embed_dim, bias=False) if norm == 'spectral': print('use spectral') self.convs = nn.ModuleList([ spectral_norm(nn.Conv2d(1, n, (f, self.emb_dim_single), stride=(1, self.emb_dim_single))) for (n, f) in zip(dis_num_filters, dis_filter_sizes) ]) else: self.convs = nn.ModuleList([ nn.Sequential( nn.Conv2d(1, n, (f, self.emb_dim_single), stride=(1, self.emb_dim_single)), ) for (n, f) in zip(dis_num_filters, dis_filter_sizes) ]) self.highway = nn.Linear(self.feature_dim, self.feature_dim) self.feature2out = nn.Linear(self.feature_dim, 100) self.out2logits = nn.Linear(100, 1) self.dropout = nn.Dropout(dropout) self.init_params()
def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, output_padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros'): super(MeanSpectralNormTransConv2d, self).__init__() self.conv = spectral_norm( nn.ConvTranspose2d(in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=padding, dilation=dilation, groups=groups, bias=bias, padding_mode=padding_mode, output_padding=output_padding)) self.bias = nn.Parameter(torch.zeros(out_channels, 1)) self.register_buffer('running_mean', torch.zeros(out_channels)) self.momentum = 0.1
def __init__(self, nZ=10, NUM_CLASSES=10): super(ConditionalGenerator, self).__init__() self.nZ = nZ self.ndf = 64 self.embedding = spectral_norm( nn.Embedding(num_embeddings=NUM_CLASSES, embedding_dim=self.nZ)) self.generator = self.build_generator()