def __init__(self, in_size=3, ndf=64): super(Discriminator_WITHOUT_FC_x64, self).__init__() self.in_size = in_size self.ndf = ndf self.main = nn.Sequential( # input size is in_size x 64 x 64 SpectralNorm(nn.Conv2d(self.in_size, self.ndf, 4, 2, 1)), nn.LeakyReLU(0.2, inplace=True), # state size: ndf x 32 x 32 Self_Attention(self.ndf), SpectralNorm(nn.Conv2d(self.ndf, self.ndf * 2, 4, 2, 1)), nn.InstanceNorm2d(self.ndf * 2), nn.LeakyReLU(0.2, inplace=True), # state size: (ndf * 2) x 16 x 16 SpectralNorm(nn.Conv2d(self.ndf * 2, self.ndf * 4, 4, 2, 1)), nn.InstanceNorm2d(self.ndf * 4), nn.LeakyReLU(0.2, inplace=True), # state size: (ndf * 4) x 8 x 8 SpectralNorm(nn.Conv2d(self.ndf * 4, self.ndf * 8, 4, 2, 1)), nn.InstanceNorm2d(self.ndf * 8), nn.LeakyReLU(0.2, inplace=True), # sate size: (ndf * 8) x 4 x 4 ) self.last = SpectralNorm(nn.Conv2d(self.ndf * 8, 1, 4, 1, 0))
def __init__(self, in_size=6, ndf=64): super(Discriminator_WITHOUT_FC_x64_video, self).__init__() self.in_size = in_size self.ndf = ndf self.layer1 = nn.Sequential( # input size is in_size x 64 x 64 SpectralNorm(nn.Conv2d(self.in_size, self.ndf, 4, 2, 1)), nn.LeakyReLU(0.2, inplace=True), ) self.layer2 = nn.Sequential( # state size: ndf x 32 x 32 SpectralNorm(nn.Conv2d(self.ndf, self.ndf * 2, 4, 2, 1)), nn.InstanceNorm2d(self.ndf * 2), nn.LeakyReLU(0.2, inplace=True), ) self.layer3 = nn.Sequential( # state size: (ndf * 2) x 16 x 16 SpectralNorm(nn.Conv2d(self.ndf * 2, self.ndf * 4, 4, 2, 1)), nn.InstanceNorm2d(self.ndf * 4), nn.LeakyReLU(0.2, inplace=True), ) self.layer4 = nn.Sequential( # state size: (ndf * 4) x 8 x 8 # Self_Attention(self.ndf * 4, 'relu'), SpectralNorm(nn.Conv2d(self.ndf * 4, self.ndf * 8, 4, 2, 1)), nn.InstanceNorm2d(self.ndf * 8), nn.LeakyReLU(0.2, inplace=True), ) self.last = SpectralNorm(nn.Conv2d(self.ndf * 8, 1, [3, 6], 1, 0))
def __init__(self, num_inputs, hidden_size=(128, 128), encode_size=64, activation='tanh', normalize=False, dropout=False, slope=0.1, dprob=0.2): super().__init__() if activation == 'tanh': self.activation = nn.Tanh() #torch.tanh elif activation == 'relu': self.activation = nn.ReLU() #torch.relu: function, nn.ReLU: layer elif activation == 'sigmoid': self.activation = nn.Sigmoid() #torch.sigmoid elif activation == 'leakyrelu': self.activation = nn.LeakyReLU(slope) self.encode_size = encode_size self.encoder = nn.Sequential() last_dim = num_inputs for ih, nh in enumerate(hidden_size): self.encoder.add_module('enc_lin' + str(ih), SpectralNorm(nn.Linear(last_dim, nh))) if normalize: self.encoder.add_module('enc_norm' + str(ih), nn.BatchNorm1d(nh)) self.encoder.add_module('enc_act' + str(ih), self.activation) if dropout: self.encoder.add_module('enc_dro' + str(ih), nn.Dropout(p=dprob)) last_dim = nh self.encoder.add_module('encoder_out', SpectralNorm(nn.Linear(last_dim, encode_size))) #self.dec_layers = nn.Modulelist() #last_dim = encode_size #for nh in hidden_size: # self.dec_layers.append(SpectralNorm(nn.Linear(last_dim, nh))) # self.dec_layers.append(self.activation) # if dropout: # self.dec_layers.append(nn.Dropout(p=dprob)) # last_dim = nh #self.decoder = nn.Sequential(self.dec_layers) self.decoder = nn.Sequential() last_dim = encode_size for ih, nh in enumerate(hidden_size): self.decoder.add_module('dec_lin' + str(ih), SpectralNorm(nn.Linear(last_dim, nh))) if normalize: self.decoder.add_module('dec_norm' + str(ih), nn.BatchNorm1d(nh)) self.decoder.add_module('dec_act' + str(ih), self.activation) if dropout: self.decoder.add_module('dec_dro' + str(ih), nn.Dropout(p=dprob)) last_dim = nh self.logic = nn.Linear(last_dim, num_inputs) #self.logic.weight.data.mul_(0.1) #self.logic.bias.data.mul_(0.0) self.decoder.add_module('decoder_out', SpectralNorm(self.logic))
def __init__(self, in_dim): super(Self_Attention, self).__init__() self.chanel_in = in_dim self.query_conv = SpectralNorm( nn.Conv2d(in_channels=in_dim, out_channels=in_dim // 1, kernel_size=1)) self.key_conv = SpectralNorm( nn.Conv2d(in_channels=in_dim, out_channels=in_dim // 1, kernel_size=1)) self.value_conv = SpectralNorm( nn.Conv2d(in_channels=in_dim, out_channels=in_dim, kernel_size=1)) self.gamma = nn.Parameter(torch.zeros(1)) self.softmax = nn.Softmax(dim=-1) #
def __init__(self, in_size=3, ndf=64): super(Discriminator_WITHOUT_FC_x64_BIG, self).__init__() self.in_size = in_size self.ndf = ndf self.main = nn.Sequential( # 256 X 256 SpectralNorm(nn.Conv2d(self.in_size, self.ndf, 4, 2, 1)), nn.LeakyReLU(0.2, inplace=True), # 128 X 128 SpectralNorm(nn.Conv2d(self.ndf, self.ndf, 4, 2, 1)), nn.InstanceNorm2d(self.ndf), nn.LeakyReLU(0.2, inplace=True), # 64 X 64 Self_Attention(self.ndf), SpectralNorm(nn.Conv2d(self.ndf, self.ndf * 2, 4, 2, 1)), nn.InstanceNorm2d(self.ndf * 2), nn.LeakyReLU(0.2, inplace=True), # 32 X 32 SpectralNorm(nn.Conv2d(self.ndf * 2, self.ndf * 4, 4, 2, 1)), nn.InstanceNorm2d(self.ndf * 4), nn.LeakyReLU(0.2, inplace=True), # 16 X 16 SpectralNorm(nn.Conv2d(self.ndf * 4, self.ndf * 8, 4, 2, 1)), nn.InstanceNorm2d(self.ndf * 8), nn.LeakyReLU(0.2, inplace=True), # 8 X 8 SpectralNorm(nn.Conv2d(self.ndf * 8, self.ndf * 16, 4, 2, 1)), nn.InstanceNorm2d(self.ndf * 16), nn.LeakyReLU(0.2, inplace=True), ) # 4 X 4 self.last = SpectralNorm(nn.Conv2d(self.ndf * 16, 1, 4, 1, 0))
def __init__(self, config): super(Discriminator, self).__init__() self.ngpu = int(config['ngpu']) ndf = int(config['ndf']) nc = int(config['nc']) label_nc = int(config['label_nc']) self.main = nn.Sequential( # input is (nc) x 128 x 128 # nn.Conv2d(nc, ndf, 4, 2, 1, bias=False), # nn.LeakyReLU(0.2, inplace=True), # state size. (ndf) x 64 x 64 SpectralNorm(nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False)), # nn.BatchNorm2d(ndf * 2), nn.LeakyReLU(0.2, inplace=True), # state size. (ndf*2) x 32 x 32 SpectralNorm(nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False)), # nn.BatchNorm2d(ndf * 4), nn.LeakyReLU(0.2, inplace=True), # state size. (ndf*4) x 16 x 16 SpectralNorm(nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 1, bias=False)), # nn.BatchNorm2d(ndf * 8), nn.LeakyReLU(0.2, inplace=True), # state size. (ndf*8) x 8 x 8 SpectralNorm(nn.Conv2d(ndf * 8, ndf * 16, 4, 2, 1, bias=False)), # nn.BatchNorm2d(ndf * 16), nn.LeakyReLU(0.2, inplace=True), # state size. (ndf*16) x 4 x 4 SpectralNorm(nn.Conv2d(ndf * 16, 1, 4, 1, 0, bias=False)), nn.Sigmoid() # output: 1x1x1 ) self.input_conv = nn.Sequential( # input is (nc) x 128 x 128 nn.Conv2d(nc, ndf // 2, 4, 2, 1, bias=False), nn.LeakyReLU(0.2, inplace=True) # state size. (ndf/2) x 64 x 64 ) self.label_conv = nn.Sequential( # input is Z, going into a convolution nn.Conv2d(label_nc, ndf // 2, 4, 2, 1, bias=False), nn.LeakyReLU(0.2, inplace=True) # state size. (ndf/2) x 64 x 64 )
def __init__(self, d=64): super(discriminator_snIns, self).__init__() #self.conv1 = nn.Conv2d(6, d, 4, 2, 1) self.conv1 = SpectralNorm(nn.Conv2d(3, d, 4, 2, 1)) self.conv2 = SpectralNorm(nn.Conv2d(d, d, 4, 2, 1)) self.conv2_in = nn.InstanceNorm2d(d) self.conv3 = SpectralNorm(nn.Conv2d(d, d * 2, 3, 1, 1)) self.conv3_in = nn.InstanceNorm2d(d * 2) self.conv4 = SpectralNorm(nn.Conv2d(d * 2, d * 2, 4, 1, 1)) self.conv4_in = nn.InstanceNorm2d(d * 2) self.conv5 = SpectralNorm(nn.Conv2d(d * 2, d * 4, 3, 1, 1)) self.conv5_in = nn.InstanceNorm2d(d * 4) self.conv6 = SpectralNorm(nn.Conv2d(d * 4, d * 4, 2, 1, 1)) self.conv6_in = nn.InstanceNorm2d(d * 4) self.conv7 = SpectralNorm(nn.Conv2d(d * 4, d * 4, 3, 1, 1)) self.conv7_in = nn.InstanceNorm2d(d * 4) self.conv8 = SpectralNorm(nn.Conv2d(d * 4, d * 8, 4, 2, 1)) self.fc = SpectralNorm(nn.Linear(4 * 4 * d * 8, 1))
def __init__(self, num_inputs, hidden_size=(128, 128), encode_size=64, activation='tanh', dropout=False, slope=0.1, dprob=0.2, sn=True): super().__init__() if activation == 'tanh': self.activation = nn.Tanh() #torch.tanh elif activation == 'relu': self.activation = nn.ReLU() #torch.relu: function, nn.ReLU: layer elif activation == 'sigmoid': self.activation = nn.Sigmoid() #torch.sigmoid elif activation == 'leakyrelu': self.activation = nn.LeakyReLU(slope) self.encode_size = encode_size self.encoder = nn.Sequential() last_dim = num_inputs for ih, nh in enumerate(hidden_size): if sn: self.encoder.add_module('enc_lin' + str(ih), SpectralNorm(nn.Linear(last_dim, nh))) else: self.encoder.add_module('enc_lin' + str(ih), nn.Linear(last_dim, nh)) self.encoder.add_module('enc_act' + str(ih), self.activation) if dropout: self.encoder.add_module('enc_dro' + str(ih), nn.Dropout(p=dprob)) last_dim = nh if sn: self.encoder.add_module( 'encoder_out', SpectralNorm(nn.Linear(last_dim, encode_size))) else: self.encoder.add_module('encoder_out', nn.Linear(last_dim, encode_size))
def __init__(self): super(Discriminator, self).__init__() self.conv1 = SpectralNorm( nn.Conv2d(channels, 64, 3, stride=1, padding=(1, 1))) self.conv2 = SpectralNorm( nn.Conv2d(64, 64, 4, stride=2, padding=(1, 1))) self.conv3 = SpectralNorm( nn.Conv2d(64, 128, 3, stride=1, padding=(1, 1))) self.conv4 = SpectralNorm( nn.Conv2d(128, 128, 4, stride=2, padding=(1, 1))) self.conv5 = SpectralNorm( nn.Conv2d(128, 256, 3, stride=1, padding=(1, 1))) self.conv6 = SpectralNorm( nn.Conv2d(256, 256, 4, stride=2, padding=(1, 1))) self.conv7 = SpectralNorm( nn.Conv2d(256, 256, 3, stride=1, padding=(1, 1))) self.conv8 = SpectralNorm( nn.Conv2d(256, 512, 4, stride=2, padding=(1, 1))) self.fc = SpectralNorm(nn.Linear(w_g * w_g * 512, 1))
def __init__(self, in_size=6, ndf=64): super(Discriminator_WITHOUT_FC_x64_video_BIG, self).__init__() self.in_size = in_size self.ndf = ndf self.layer1 = nn.Sequential( SpectralNorm(nn.Conv2d(self.in_size, self.ndf, 4, 2, 1)), nn.LeakyReLU(0.2, inplace=True)) self.layer2 = nn.Sequential( SpectralNorm(nn.Conv2d(self.ndf, self.ndf, 4, 2, 1)), nn.InstanceNorm2d(self.ndf), nn.LeakyReLU(0.2, inplace=True), ) self.attention = Self_Attention(self.ndf) self.layer3 = nn.Sequential( SpectralNorm(nn.Conv2d(self.ndf, self.ndf * 2, 4, 2, 1)), nn.InstanceNorm2d(self.ndf * 2), nn.LeakyReLU(0.2, inplace=True), ) self.layer4 = nn.Sequential( SpectralNorm(nn.Conv2d(self.ndf * 2, self.ndf * 4, 4, 2, 1)), nn.InstanceNorm2d(self.ndf * 4), nn.LeakyReLU(0.2, inplace=True), ) self.layer5 = nn.Sequential( SpectralNorm(nn.Conv2d(self.ndf * 4, self.ndf * 8, 4, 2, 1)), nn.InstanceNorm2d(self.ndf * 8), nn.LeakyReLU(0.2, inplace=True), ) self.layer6 = nn.Sequential( SpectralNorm(nn.Conv2d(self.ndf * 8, self.ndf * 16, 4, 2, 1)), nn.InstanceNorm2d(self.ndf * 16), nn.LeakyReLU(0.2, inplace=True), ) self.last = SpectralNorm(nn.Conv2d(self.ndf * 16, 1, [3, 6], 1, 0))
def __init__(self, num_inputs, num_outputs, sigmoid_out=True, sn=False, w_init=False, test=True, hidden_size_enc=(64, ), hidden_size_dec=(64, ), encode_size=64, activation='tanh', dropout=False, slope=0.1, dprob=0.2): super().__init__() if activation == 'tanh': self.activation = nn.Tanh() #torch.tanh elif activation == 'relu': self.activation = nn.ReLU() #torch.relu: function, nn.ReLU: layer elif activation == 'sigmoid': self.activation = nn.Sigmoid() #torch.sigmoid elif activation == 'leakyrelu': self.activation = nn.LeakyReLU(slope) self.encode_size = encode_size self.sigmoid_out = sigmoid_out """ class Q(nn.Module): def __init__(self): super(Q,self).__init__() def forward(self,x): """ self.encoder = nn.Sequential() last_dim = num_inputs for ih, nh in enumerate(hidden_size_enc): if sn: self.encoder.add_module( 'enc_lin' + str(ih), SpectralNorm(nn.Linear(last_dim, nh), w_init)) else: self.encoder.add_module('enc_lin' + str(ih), nn.Linear(last_dim, nh)) self.encoder.add_module('enc_act' + str(ih), self.activation) if dropout: self.encoder.add_module('enc_dro' + str(ih), nn.Dropout(p=dprob)) last_dim = nh if sn: self.encoder.add_module( 'encoder_out', SpectralNorm(nn.Linear(last_dim, encode_size * 2), w_init)) else: self.encoder.add_module('encoder_out', nn.Linear(last_dim, encode_size * 2)) self.decoder = nn.Sequential() last_dim = encode_size # to be deleted if test: self.decoder.add_module('dec_act', self.activation) if dropout: self.decoder.add_module('dec_dro', nn.Dropout(p=dprob)) for ih, nh in enumerate(hidden_size_dec): if sn: self.decoder.add_module( 'dec_lin' + str(ih), SpectralNorm(nn.Linear(last_dim, nh), w_init)) else: self.decoder.add_module('dec_lin' + str(ih), nn.Linear(last_dim, nh)) self.decoder.add_module('dec_act' + str(ih), self.activation) if dropout: self.decoder.add_module('dec_dro' + str(ih), nn.Dropout(p=dprob)) last_dim = nh self.logic = nn.Linear(last_dim, num_outputs) if sn: self.decoder.add_module('decoder_out', SpectralNorm(self.logic, w_init)) else: self.decoder.add_module('decoder_out', self.logic)