def get_generator(batch_size, theano_rng, noise_length=100): noise_dim = (batch_size, noise_length) noise = theano_rng.uniform(size=noise_dim) gen_layers = [ll.InputLayer(shape=noise_dim, input_var=noise)] gen_layers.append( nn.batch_norm(ll.DenseLayer(gen_layers[-1], num_units=4 * 4 * 512, W=Normal(0.05), nonlinearity=nn.relu), g=None)) gen_layers.append(ll.ReshapeLayer(gen_layers[-1], (batch_size, 512, 4, 4))) gen_layers.append( nn.batch_norm(nn.Deconv2DLayer(gen_layers[-1], (batch_size, 256, 8, 8), (5, 5), W=Normal(0.05), nonlinearity=nn.relu), g=None)) # 4 -> 8 gen_layers.append( nn.batch_norm(nn.Deconv2DLayer(gen_layers[-1], (batch_size, 128, 16, 16), (5, 5), W=Normal(0.05), nonlinearity=nn.relu), g=None)) # 8 -> 16 gen_layers.append( nn.weight_norm(nn.Deconv2DLayer(gen_layers[-1], (batch_size, 3, 32, 32), (5, 5), W=Normal(0.05), nonlinearity=T.tanh), train_g=True, init_stdv=0.1)) # 16 -> 32 return gen_layers
def g_architecture(self): # lrelu = lasagne.nonlinearities.LeakyRectify(0.2) # gen_layers = [lasagne.layers.InputLayer(shape=self.size_input, input_var=self.distribution)] # gen_layers.append(lasagne.layers.batch_norm(lasagne.layers.DenseLayer(gen_layers[-1], num_units=4*4*512, nonlinearity=lrelu))) # gen_layers.append(lasagne.layers.ReshapeLayer(gen_layers[-1], (-1,512,4,4))) # gen_layers.append(lasagne.layers.batch_norm(lasagne.layers.Deconv2DLayer(gen_layers[-1], num_filters=256, filter_size=5, stride=2, crop=2,output_size=8,nonlinearity=lasagne.nonlinearities.rectify))) # gen_layers.append(lasagne.layers.batch_norm(lasagne.layers.Deconv2DLayer(gen_layers[-1], num_filters=128, filter_size=5, stride=2, crop=2,output_size=16,nonlinearity=lasagne.nonlinearities.rectify))) # gen_layers.append(lasagne.layers.batch_norm(lasagne.layers.Deconv2DLayer(gen_layers[-1], num_filters=64, filter_size=5, stride=2, crop=2,output_size=32,nonlinearity=lasagne.nonlinearities.rectify))) # #gen_layers.append(lasagne.layers.batch_norm(lasagne.layers.Deconv2DLayer(gen_layers[-1], num_filters=3, filter_size=5, stride=2, crop=2,output_size=64,W=lasagne.init.Normal(0.05), nonlinearity=lasagne.nonlinearities.tanh))) # 16 -> 32 # gen_layers.append(nn.weight_norm(lasagne.layers.Deconv2DLayer(gen_layers[-1], num_filters=3, filter_size=5, stride=2, crop=2,output_size=64,W=lasagne.init.Normal(0.05), nonlinearity=T.tanh), train_g=True, init_stdv=0.1)) # self.architecture = gen_layers ### gen_layers.append(lasagne.layers.batch_norm(lasagne.layers.Deconv2DLayer(gen_layers[-1], num_filters=3, filter_size=5, stride=2, crop=2,output_size=32,nonlinearity=lasagne.nonlinearities.sigmoid))) # # self.architecture = gen_layers # #self.last_layer = gen_layers[-1] #self.parameters = lasagne.layers.get_all_params(gen_layers,trainable=True) # lrelu = lasagne.nonlinearities.LeakyRectify(0.2) gen_layers = [lasagne.layers.InputLayer(shape=self.size_input, input_var=self.distribution)] #gen_layers.append(lasagne.layers.DropoutLayer(gen_layers[-1], p=0.5)) gen_layers.append(lasagne.layers.batch_norm(lasagne.layers.DenseLayer(gen_layers[-1], num_units=4*4*512, nonlinearity=lasagne.nonlinearities.rectify))) gen_layers.append(lasagne.layers.ReshapeLayer(gen_layers[-1], (self.BATCH_SIZE,512,4,4))) gen_layers.append(lasagne.layers.batch_norm(nn.Deconv2DLayer(gen_layers[-1], (self.BATCH_SIZE,256,8,8), (5,5), W=lasagne.init.Normal(0.05), nonlinearity=lasagne.nonlinearities.rectify)))# 4 -> 8 gen_layers.append(lasagne.layers.batch_norm(nn.Deconv2DLayer(gen_layers[-1], (self.BATCH_SIZE,128,16,16), (5,5), W=lasagne.init.Normal(0.05), nonlinearity=lasagne.nonlinearities.rectify))) # 4 -> 8 gen_layers.append(lasagne.layers.batch_norm(nn.Deconv2DLayer(gen_layers[-1], (self.BATCH_SIZE,64,32,32), (5,5), W=lasagne.init.Normal(0.05), nonlinearity=lasagne.nonlinearities.rectify))) # 4 -> 8 #gen_layers.append(nn.weight_norm(nn.Deconv2DLayer(gen_layers[-1], (self.BATCH_SIZE,3,64,64), (5,5), W=init.Normal(0.05), nonlinearity=T.tanh), train_g=True, init_stdv=0.1)) gen_layers.append(nn.weight_norm(nn.Deconv2DLayer(gen_layers[-1], (self.BATCH_SIZE,3,64,64), (5,5), W=init.Normal(0.05), nonlinearity=T.tanh), train_g=True, init_stdv=0.1)) # 16 -> 32, train_g=True, init_stdv=0.1 self.architecture = gen_layers return
def get_generator(self, meanx, z0, y_1hot): ''' specify generator G0, gen_x = G0(z0, h1) ''' """ #z0 = theano_rng.uniform(size=(self.args.batch_size, 16)) # uniform noise gen0_layers = [LL.InputLayer(shape=(self.args.batch_size, 50), input_var=z0)] # Input layer for z0 gen0_layers.append(nn.batch_norm(LL.DenseLayer(nn.batch_norm(LL.DenseLayer(gen0_layers[0], num_units=128, W=Normal(0.02), nonlinearity=nn.relu)), num_units=128, W=Normal(0.02), nonlinearity=nn.relu))) # embedding, 50 -> 128 gen0_layer_z_embed = gen0_layers[-1] #gen0_layers.append(LL.InputLayer(shape=(self.args.batch_size, 256), input_var=real_fc3)) # Input layer for real_fc3 in independent training, gen_fc3 in joint training gen0_layers.append(LL.InputLayer(shape=(self.args.batch_size, 10), input_var=y_1hot)) # Input layer for real_fc3 in independent training, gen_fc3 in joint training gen0_layer_fc3 = gen0_layers[-1] gen0_layers.append(LL.ConcatLayer([gen0_layer_fc3,gen0_layer_z_embed], axis=1)) # concatenate noise and fc3 features gen0_layers.append(LL.ReshapeLayer(nn.batch_norm(LL.DenseLayer(gen0_layers[-1], num_units=256*5*5, W=Normal(0.02), nonlinearity=T.nnet.relu)), (self.args.batch_size,256,5,5))) # fc gen0_layers.append(nn.batch_norm(nn.Deconv2DLayer(gen0_layers[-1], (self.args.batch_size,256,10,10), (5,5), stride=(2, 2), padding = 'half', W=Normal(0.02), nonlinearity=nn.relu))) # deconv gen0_layers.append(nn.batch_norm(nn.Deconv2DLayer(gen0_layers[-1], (self.args.batch_size,128,14,14), (5,5), stride=(1, 1), padding = 'valid', W=Normal(0.02), nonlinearity=nn.relu))) # deconv gen0_layers.append(nn.batch_norm(nn.Deconv2DLayer(gen0_layers[-1], (self.args.batch_size,128,28,28), (5,5), stride=(2, 2), padding = 'half', W=Normal(0.02), nonlinearity=nn.relu))) # deconv gen0_layers.append(nn.Deconv2DLayer(gen0_layers[-1], (self.args.batch_size,3,32,32), (5,5), stride=(1, 1), padding = 'valid', W=Normal(0.02), nonlinearity=T.nnet.sigmoid)) # deconv gen_x_pre = LL.get_output(gen0_layers[-1], deterministic=False) gen_x = gen_x_pre - meanx # gen_x_joint = LL.get_output(gen0_layers[-1], {gen0_layer_fc3: gen_fc3}, deterministic=False) - meanx return gen0_layers, gen_x """ gen_x_layer_z = LL.InputLayer(shape=(self.args.batch_size, self.args.z0dim), input_var=z0) # z, 20 # gen_x_layer_z_embed = nn.batch_norm(LL.DenseLayer(gen_x_layer_z, num_units=128), g=None) # 20 -> 64 gen_x_layer_y = LL.InputLayer(shape=(self.args.batch_size, 10), input_var=y_1hot) # conditioned on real fc3 activations gen_x_layer_y_z = LL.ConcatLayer([gen_x_layer_y,gen_x_layer_z],axis=1) #512+256 = 768 gen_x_layer_pool2 = LL.ReshapeLayer(nn.batch_norm(LL.DenseLayer(gen_x_layer_y_z, num_units=256*5*5)), (self.args.batch_size,256,5,5)) gen_x_layer_dconv2_1 = nn.batch_norm(nn.Deconv2DLayer(gen_x_layer_pool2, (self.args.batch_size,256,10,10), (5,5), stride=(2, 2), padding = 'half', W=Normal(0.02), nonlinearity=nn.relu)) gen_x_layer_dconv2_2 = nn.batch_norm(nn.Deconv2DLayer(gen_x_layer_dconv2_1, (self.args.batch_size,128,14,14), (5,5), stride=(1, 1), padding = 'valid', W=Normal(0.02), nonlinearity=nn.relu)) gen_x_layer_dconv1_1 = nn.batch_norm(nn.Deconv2DLayer(gen_x_layer_dconv2_2, (self.args.batch_size,128,28,28), (5,5), stride=(2, 2), padding = 'half', W=Normal(0.02), nonlinearity=nn.relu)) gen_x_layer_x = nn.Deconv2DLayer(gen_x_layer_dconv1_1, (self.args.batch_size,3,32,32), (5,5), stride=(1, 1), padding = 'valid', W=Normal(0.02), nonlinearity=T.nnet.sigmoid) # gen_x_layer_x = dnn.Conv2DDNNLayer(gen_x_layer_dconv1_2, 3, (1,1), pad=0, stride=1, # W=Normal(0.02), nonlinearity=T.nnet.sigmoid) gen_x_layers = [gen_x_layer_z, gen_x_layer_y, gen_x_layer_y_z, gen_x_layer_pool2, gen_x_layer_dconv2_1, gen_x_layer_dconv2_2, gen_x_layer_dconv1_1, gen_x_layer_x] gen_x_pre = LL.get_output(gen_x_layer_x, deterministic=False) gen_x = gen_x_pre - meanx return gen_x_layers, gen_x
def _sample_trained_minibatch_gan(params_file, n, batch_size, rs): import lasagne from lasagne.init import Normal import lasagne.layers as ll import theano as th from theano.sandbox.rng_mrg import MRG_RandomStreams import theano.tensor as T import nn theano_rng = MRG_RandomStreams(rs.randint(2**15)) lasagne.random.set_rng(np.random.RandomState(rs.randint(2**15))) noise_dim = (batch_size, 100) noise = theano_rng.uniform(size=noise_dim) ls = [ll.InputLayer(shape=noise_dim, input_var=noise)] ls.append( nn.batch_norm(ll.DenseLayer(ls[-1], num_units=4 * 4 * 512, W=Normal(0.05), nonlinearity=nn.relu), g=None)) ls.append(ll.ReshapeLayer(ls[-1], (batch_size, 512, 4, 4))) ls.append( nn.batch_norm(nn.Deconv2DLayer(ls[-1], (batch_size, 256, 8, 8), (5, 5), W=Normal(0.05), nonlinearity=nn.relu), g=None)) # 4 -> 8 ls.append( nn.batch_norm(nn.Deconv2DLayer(ls[-1], (batch_size, 128, 16, 16), (5, 5), W=Normal(0.05), nonlinearity=nn.relu), g=None)) # 8 -> 16 ls.append( nn.weight_norm(nn.Deconv2DLayer(ls[-1], (batch_size, 3, 32, 32), (5, 5), W=Normal(0.05), nonlinearity=T.tanh), train_g=True, init_stdv=0.1)) # 16 -> 32 gen_dat = ll.get_output(ls[-1]) with np.load(params_file) as d: params = [d['arr_{}'.format(i)] for i in range(9)] ll.set_all_param_values(ls[-1], params, trainable=True) sample_batch = th.function(inputs=[], outputs=gen_dat) samps = [] while len(samps) < n: samps.extend(sample_batch()) samps = np.array(samps[:n]) return samps
def generator(input_var): network = lasagne.layers.InputLayer(shape=(None, NLAT,1,1), input_var=input_var) network = ll.DenseLayer(network, num_units=4*4*64, W=Normal(0.05), nonlinearity=nn.relu) #print(input_var.shape[0]) network = ll.ReshapeLayer(network, (batch_size,64,4,4)) network = nn.Deconv2DLayer(network, (batch_size,32,7,7), (4,4), stride=(1,1), pad='valid', W=Normal(0.05), nonlinearity=nn.relu) network = nn.Deconv2DLayer(network, (batch_size,32,11,11), (5,5), stride=(1,1), pad='valid', W=Normal(0.05), nonlinearity=nn.relu) network = nn.Deconv2DLayer(network, (batch_size,32,25,25), (5,5), stride=(2,2), pad='valid', W=Normal(0.05), nonlinearity=nn.relu) network = nn.Deconv2DLayer(network, (batch_size,1,28,28), (4,4), stride=(1,1), pad='valid', W=Normal(0.05), nonlinearity=sigmoid) #network =lasagne.layers.Conv2DLayer(network, num_filters=1, filter_size=1, stride=1, nonlinearity=sigmoid) return network
gen0_layers.append( LL.ConcatLayer([gen0_layer_fc3, gen0_layer_z_embed], axis=1)) # concatenate noise and fc3 features gen0_layers.append( LL.ReshapeLayer( nn.batch_norm( LL.DenseLayer(gen0_layers[-1], num_units=128 * 4 * 4, W=Normal(0.02), nonlinearity=T.nnet.relu)), (args.batch_size, 128, 4, 4))) # fc gen0_layers.append( nn.batch_norm( nn.Deconv2DLayer(gen0_layers[-1], (args.batch_size, 128, 8, 8), (5, 5), stride=(2, 2), padding='half', W=Normal(0.02), nonlinearity=nn.relu))) # deconv gen0_layers.append( nn.batch_norm( nn.Deconv2DLayer(gen0_layers[-1], (args.batch_size, 64, 12, 12), (5, 5), stride=(1, 1), padding='valid', W=Normal(0.02), nonlinearity=nn.relu))) # deconv gen0_layers.append( nn.batch_norm( nn.Deconv2DLayer(gen0_layers[-1], (args.batch_size, 64, 24, 24), (5, 5),
gen1_layers.append(LL.ConcatLayer([gen1_layer_z,gen1_layer_y],axis=1)) gen1_layers.append(nn.batch_norm(LL.DenseLayer(gen1_layers[-1], num_units=512, W=Normal(0.02), nonlinearity=T.nnet.relu))) gen1_layers.append(nn.batch_norm(LL.DenseLayer(gen1_layers[-1], num_units=512, W=Normal(0.02), nonlinearity=T.nnet.relu))) gen1_layers.append(LL.DenseLayer(gen1_layers[-1], num_units=256, W=Normal(0.02), nonlinearity=T.nnet.relu)) ''' specify generator G0, gen_x = G0(z0, h1) ''' z0 = theano_rng.uniform(size=(args.batch_size, 16)) # uniform noise gen0_layers = [LL.InputLayer(shape=(args.batch_size, 16), input_var=z0)] # Input layer for z0 gen0_layers.append(nn.batch_norm(LL.DenseLayer(nn.batch_norm(LL.DenseLayer(gen0_layers[0], num_units=128, W=Normal(0.02), nonlinearity=nn.relu)), num_units=128, W=Normal(0.02), nonlinearity=nn.relu))) # embedding, 50 -> 128 gen0_layer_z_embed = gen0_layers[-1] gen0_layers.append(LL.ConcatLayer([gen1_layers[-1],gen0_layer_z_embed], axis=1)) # concatenate noise and fc3 features gen0_layers.append(LL.ReshapeLayer(nn.batch_norm(LL.DenseLayer(gen0_layers[-1], num_units=256*5*5, W=Normal(0.02), nonlinearity=T.nnet.relu)), (args.batch_size,256,5,5))) # fc gen0_layers.append(nn.batch_norm(nn.Deconv2DLayer(gen0_layers[-1], (args.batch_size,256,10,10), (5,5), stride=(2, 2), padding = 'half', W=Normal(0.02), nonlinearity=nn.relu))) # deconv gen0_layers.append(nn.batch_norm(nn.Deconv2DLayer(gen0_layers[-1], (args.batch_size,128,14,14), (5,5), stride=(1, 1), padding = 'valid', W=Normal(0.02), nonlinearity=nn.relu))) # deconv gen0_layers.append(nn.batch_norm(nn.Deconv2DLayer(gen0_layers[-1], (args.batch_size,128,28,28), (5,5), stride=(2, 2), padding = 'half', W=Normal(0.02), nonlinearity=nn.relu))) # deconv gen0_layers.append(nn.Deconv2DLayer(gen0_layers[-1], (args.batch_size,3,32,32), (5,5), stride=(1, 1), padding = 'valid', W=Normal(0.02), nonlinearity=T.nnet.sigmoid)) # deconv gen_fc3, gen_x_pre = LL.get_output([gen1_layers[-1], gen0_layers[-1]], deterministic=True) gen_x = gen_x_pre - meanx weights_toload = np.load('pretrained/generator.npz') weights_list_toload = [weights_toload['arr_{}'.format(k)] for k in range(len(weights_toload.files))] LL.set_all_param_values(gen0_layers[-1], weights_list_toload)
nn.batch_norm(ll.DenseLayer(gen_layers[-1], num_units=4 * 4 * 512, W=Normal(0.05), nonlinearity=nn.relu, name='gen-01'), g=None, name='gen-02')) gen_layers.append( ll.ReshapeLayer(gen_layers[-1], (-1, 512, 4, 4), name='gen-03')) gen_layers.append( ConvConcatLayer([gen_layers[-1], gen_in_y], num_classes, name='gen-10')) gen_layers.append( nn.batch_norm(nn.Deconv2DLayer(gen_layers[-1], (None, 256, 8, 8), (5, 5), W=Normal(0.05), nonlinearity=nn.relu, name='gen-11'), g=None, name='gen-12')) # 4 -> 8 gen_layers.append( ConvConcatLayer([gen_layers[-1], gen_in_y], num_classes, name='gen-20')) gen_layers.append( nn.batch_norm(nn.Deconv2DLayer(gen_layers[-1], (None, 128, 16, 16), (5, 5), W=Normal(0.05), nonlinearity=nn.relu, name='gen-21'), g=None, name='gen-22')) # 8 -> 16
theano_rng = MRG_RandomStreams(rng.randint(2 ** 15)) lasagne.random.set_rng(np.random.RandomState(rng.randint(2 ** 15))) # load CIFAR-10 trainx, trainy = cifar10_data.load(args.data_dir, subset='train') trainx_unl = trainx.copy() nr_batches_train = int(trainx.shape[0]/args.batch_size) # specify generative model noise_dim = (args.batch_size, 100) noise = theano_rng.uniform(size=noise_dim) gen_layers = [ll.InputLayer(shape=noise_dim, input_var=noise)] gen_layers.append(nn.batch_norm(ll.DenseLayer(gen_layers[-1], num_units=4*4*512, W=Normal(0.05), nonlinearity=nn.relu), g=None)) gen_layers.append(ll.ReshapeLayer(gen_layers[-1], (args.batch_size,512,4,4))) gen_layers.append(nn.batch_norm(nn.Deconv2DLayer(gen_layers[-1], (args.batch_size,256,8,8), (5,5), W=Normal(0.05), nonlinearity=nn.relu), g=None)) # 4 -> 8 gen_layers.append(nn.batch_norm(nn.Deconv2DLayer(gen_layers[-1], (args.batch_size,128,16,16), (5,5), W=Normal(0.05), nonlinearity=nn.relu), g=None)) # 8 -> 16 gen_layers.append(nn.weight_norm(nn.Deconv2DLayer(gen_layers[-1], (args.batch_size,3,32,32), (5,5), W=Normal(0.05), nonlinearity=T.tanh), train_g=True, init_stdv=0.1)) # 16 -> 32 gen_dat = ll.get_output(gen_layers[-1]) # specify discriminative model disc_layers = [ll.InputLayer(shape=(None, 3, 32, 32))] disc_layers.append(ll.DropoutLayer(disc_layers[-1], p=0.2)) disc_layers.append(nn.weight_norm(dnn.Conv2DDNNLayer(disc_layers[-1], 96, (3,3), pad=1, W=Normal(0.05), nonlinearity=nn.lrelu))) disc_layers.append(nn.weight_norm(dnn.Conv2DDNNLayer(disc_layers[-1], 96, (3,3), pad=1, W=Normal(0.05), nonlinearity=nn.lrelu))) disc_layers.append(nn.weight_norm(dnn.Conv2DDNNLayer(disc_layers[-1], 96, (3,3), pad=1, stride=2, W=Normal(0.05), nonlinearity=nn.lrelu))) disc_layers.append(ll.DropoutLayer(disc_layers[-1], p=0.5)) disc_layers.append(nn.weight_norm(dnn.Conv2DDNNLayer(disc_layers[-1], 192, (3,3), pad=1, W=Normal(0.05), nonlinearity=nn.lrelu))) disc_layers.append(nn.weight_norm(dnn.Conv2DDNNLayer(disc_layers[-1], 192, (3,3), pad=1, W=Normal(0.05), nonlinearity=nn.lrelu))) disc_layers.append(nn.weight_norm(dnn.Conv2DDNNLayer(disc_layers[-1], 192, (3,3), pad=1, stride=2, W=Normal(0.05), nonlinearity=nn.lrelu))) disc_layers.append(ll.DropoutLayer(disc_layers[-1], p=0.5))
#y_pred, real_pool3 = LL.get_output([fc8, poo5], x, deterministic=False) # real_pool3 = LL.get_output(poo5, x, deterministic=False) #enc_error = T.mean(T.neq(T.argmax(y_pred,axis=1),y)) # classification error of the encoder, to make sure the encoder is working properly # specify generator, gen_x = G(z, real_pool3) z = theano_rng.uniform(size=(args.batch_size, 50)) # uniform noise # y_1hot = T.matrix() gen_x_layer_z = LL.InputLayer(shape=(args.batch_size, 50), input_var=z) # z, 20 # gen_x_layer_z_embed = nn.batch_norm(LL.DenseLayer(gen_x_layer_z, num_units=128), g=None) # 20 -> 64 gen_x_layer_y = LL.InputLayer(shape=(args.batch_size, 10), input_var=y_1hot) # conditioned on real fc3 activations gen_x_layer_y_z = LL.ConcatLayer([gen_x_layer_y,gen_x_layer_z],axis=1) #512+256 = 768 gen_x_layer_pool2 = LL.ReshapeLayer(nn.batch_norm(LL.DenseLayer(gen_x_layer_y_z, num_units=256*5*5)), (args.batch_size,256,5,5)) gen_x_layer_dconv2_1 = nn.batch_norm(nn.Deconv2DLayer(gen_x_layer_pool2, (args.batch_size,256,10,10), (5,5), stride=(2, 2), padding = 'half', W=Normal(0.02), nonlinearity=nn.relu)) gen_x_layer_dconv2_2 = nn.batch_norm(nn.Deconv2DLayer(gen_x_layer_dconv2_1, (args.batch_size,128,14,14), (5,5), stride=(1, 1), padding = 'valid', W=Normal(0.02), nonlinearity=nn.relu)) gen_x_layer_dconv1_1 = nn.batch_norm(nn.Deconv2DLayer(gen_x_layer_dconv2_2, (args.batch_size,128,28,28), (5,5), stride=(2, 2), padding = 'half', W=Normal(0.02), nonlinearity=nn.relu)) gen_x_layer_x = nn.Deconv2DLayer(gen_x_layer_dconv1_1, (args.batch_size,3,32,32), (5,5), stride=(1, 1), padding = 'valid', W=Normal(0.02), nonlinearity=T.nnet.sigmoid) # gen_x_layer_x = dnn.Conv2DDNNLayer(gen_x_layer_dconv1_2, 3, (1,1), pad=0, stride=1, # W=Normal(0.02), nonlinearity=T.nnet.sigmoid) print(gen_x_layer_x.output_shape) gen_x_layers = [gen_x_layer_z, gen_x_layer_y, gen_x_layer_y_z, gen_x_layer_pool2, gen_x_layer_dconv2_1, gen_x_layer_dconv2_2, gen_x_layer_dconv1_1, gen_x_layer_x]
gen_layers.append( nn.batch_norm(dnn.Conv2DDNNLayer(gen_layers[-1], 256, (3, 3), pad=1, W=Normal(0.05), nonlinearity=nn.lrelu), g=None)) gen_layers.append( nn.batch_norm( ll.NINLayer(gen_layers[-1], num_units=512, W=Normal(0.05), nonlinearity=nn.lrelu))) gen_layers.append( nn.batch_norm(nn.Deconv2DLayer(gen_layers[-1], (n_batch, 256, 8, 8), (5, 5), W=Normal(0.05), nonlinearity=nn.relu), g=None)) # 4 -> 8 gen_layers.append( nn.batch_norm(dnn.Conv2DDNNLayer(gen_layers[-1], 128, (3, 3), pad=1, W=Normal(0.05), nonlinearity=nn.lrelu), g=None)) gen_layers.append( nn.batch_norm( ll.NINLayer(gen_layers[-1], num_units=256, W=Normal(0.05), nonlinearity=nn.lrelu)))
# specify generative model noise_dim = (args.batch_size, 100) print("Compiling......") labels = T.ivector() x_lab = T.tensor4() labels_gen = T.ivector() gen_in_z = ll.InputLayer(shape=noise_dim) noise = theano_rng.uniform(size=noise_dim) gen_in_y = ll.InputLayer(shape=(args.batch_size,)) gen_layers = [gen_in_z] gen_layers.append(nn.MLPConcatLayer([gen_layers[-1], gen_in_y], num_classes)) gen_layers.append(ll.DenseLayer(gen_layers[-1], num_units=7 * 7 * 512, W=Normal(0.05), nonlinearity=nn.relu)) gen_layers.append(nn.batch_norm(gen_layers[-1], g=None)) gen_layers.append(ll.ReshapeLayer(gen_layers[-1], (args.batch_size, 512, 7, 7))) gen_layers.append(nn.ConvConcatLayer([gen_layers[-1], gen_in_y], num_classes)) gen_layers.append(nn.Deconv2DLayer(gen_layers[-1], (args.batch_size, 512, 14, 14), (5, 5), W=Normal(0.05), nonlinearity=nn.relu)) gen_layers.append(nn.batch_norm(gen_layers[-1], g=None)) gen_layers.append(nn.ConvConcatLayer([gen_layers[-1], gen_in_y], num_classes)) gen_layers.append(nn.Deconv2DLayer(gen_layers[-1], (args.batch_size, 256, 28, 28), (5, 5), W=Normal(0.05), nonlinearity=nn.relu)) gen_layers.append(nn.batch_norm(gen_layers[-1], g=None)) gen_layers.append(nn.ConvConcatLayer([gen_layers[-1], gen_in_y], num_classes)) gen_layers.append(nn.Deconv2DLayer(gen_layers[-1], (args.batch_size, 128, 56, 56), (5, 5), W=Normal(0.05), nonlinearity=nn.relu)) gen_layers.append(nn.batch_norm(gen_layers[-1], g=None)) gen_layers.append(nn.ConvConcatLayer([gen_layers[-1], gen_in_y], num_classes)) gen_layers.append(nn.Deconv2DLayer(gen_layers[-1], (args.batch_size, 128, 112, 112), (5, 5), W=Normal(0.05), nonlinearity=nn.relu)) gen_layers.append(nn.batch_norm(gen_layers[-1], g=None)) gen_layers.append(nn.ConvConcatLayer([gen_layers[-1], gen_in_y], num_classes)) gen_layers.append(nn.Deconv2DLayer(gen_layers[-1], (args.batch_size, 1, 224, 224), (5, 5), W=Normal(0.05), nonlinearity=T.tanh)) gen_layers.append(nn.weight_norm(gen_layers[-1], train_g=True, init_stdv=0.1)) # specify discriminative model
def build_network(self, X, Y): # Define the layers lrelu = lasagne.nonlinearities.LeakyRectify(0.1) input_shape = self.Size_Input #temp = input_shape[1]*input_shape[2]*input_shape[3] Auto_Enc_Layer = [ lasagne.layers.InputLayer(shape=(None, input_shape[1], input_shape[2], input_shape[3]), input_var=X) ] # Encode lasagne.nonlinearities.rectify Auto_Enc_Layer.append( nn.weight_norm( Conv2DDNNLayer(Auto_Enc_Layer[-1], 64, (3, 3), pad=1, W=lasagne.init.Normal(0.05), nonlinearity=lrelu))) Auto_Enc_Layer.append( nn.weight_norm( Conv2DDNNLayer(Auto_Enc_Layer[-2], 64, (3, 3), pad=1, W=lasagne.init.Normal(0.05), nonlinearity=lrelu))) Auto_Enc_Layer_Global0 = nn.weight_norm( lasagne.layers.NINLayer(Auto_Enc_Layer[-1], num_units=32, W=lasagne.init.Normal(0.05), nonlinearity=lrelu)) Auto_Enc_Layer_Global = lasagne.layers.GlobalPoolLayer( Auto_Enc_Layer_Global0) Auto_Enc_Layer.append( nn.weight_norm( Conv2DDNNLayer(Auto_Enc_Layer[-1], 64, (3, 3), pad=1, stride=2, W=lasagne.init.Normal(0.05), nonlinearity=lrelu))) Auto_Enc_Layer.append( lasagne.layers.DropoutLayer(Auto_Enc_Layer[-1], p=0.5)) Auto_Enc_Layer.append( nn.weight_norm( Conv2DDNNLayer(Auto_Enc_Layer[-1], 128, (3, 3), pad=1, W=lasagne.init.Normal(0.05), nonlinearity=lrelu))) Auto_Enc_Layer.append( nn.weight_norm( Conv2DDNNLayer(Auto_Enc_Layer[-1], 128, (3, 3), pad=1, W=lasagne.init.Normal(0.05), nonlinearity=lrelu))) Auto_Enc_Layer.append( nn.weight_norm( Conv2DDNNLayer(Auto_Enc_Layer[-1], 128, (3, 3), pad=1, stride=2, W=lasagne.init.Normal(0.05), nonlinearity=lrelu))) Auto_Enc_Layer_Local0 = nn.weight_norm( lasagne.layers.NINLayer(Auto_Enc_Layer[-1], num_units=128, W=lasagne.init.Normal(0.05), nonlinearity=lrelu)) Auto_Enc_Layer_Local = lasagne.layers.GlobalPoolLayer( Auto_Enc_Layer_Local0) Auto_Enc_Layer.append( nn.weight_norm( lasagne.layers.NINLayer(Auto_Enc_Layer[-1], num_units=512, W=lasagne.init.Normal(0.05), nonlinearity=lrelu))) Auto_Enc_Layer.append( lasagne.layers.GlobalPoolLayer(Auto_Enc_Layer[-1])) Auto_Enc_Layer.append( nn.weight_norm( DenseLayer(Auto_Enc_Layer_Local, num_units=32 * 16 * 16, W=lasagne.init.Normal(0.05), nonlinearity=lasagne.nonlinearities.tanh))) # Decccode Auto_Dec_Layer = [ (lasagne.layers.ReshapeLayer(Auto_Enc_Layer[-1], (self.Batch_Size, 32, 16, 16))) ] Auto_Dec_Layer.append( nn.weight_norm( nn.Deconv2DLayer(Auto_Dec_Layer[-1], (self.Batch_Size, 32, 32, 32), (3, 3), W=lasagne.init.Normal(0.05), nonlinearity=lrelu))) # 4 -> 8 Auto_Dec_Layer.append( nn.weight_norm( nn.Deconv2DLayer( Auto_Dec_Layer[-1], (self.Batch_Size, 3, 64, 64), (3, 3), W=lasagne.init.Normal(0.05), nonlinearity=lasagne.nonlinearities.tanh))) # 4 -> 8 all_params = lasagne.layers.get_all_params(Auto_Dec_Layer, trainable=True) network_output = lasagne.layers.get_output(Auto_Dec_Layer[-1], X, deterministic=False) encoded_output = lasagne.layers.get_output(Auto_Enc_Layer_Local, X, deterministic=True) encoded_output1 = lasagne.layers.get_output(Auto_Enc_Layer_Global, X, deterministic=True) #encoded_output1 = Auto_Enc_Layer_Global network_output1 = lasagne.layers.get_output(Auto_Dec_Layer[-1], X, deterministic=True) loss_A = T.mean( lasagne.objectives.squared_error( network_output[:, 0, :, :], Y[:, 0, :, :])) + T.mean( lasagne.objectives.squared_error( network_output[:, 1, :, :], Y[:, 1, :, :])) + T.mean( lasagne.objectives.squared_error( network_output[:, 2, :, :], Y[:, 2, :, :])) #loss_A = T.mean(lasagne.objectives.squared_error(network_output,Y)) loss = [loss_A, encoded_output, network_output] #Autoencodeur_params_updates = lasagne.updates.momentum(loss_A,all_params,learning_rate = 0.05,momentum = 0.5) Autoencodeur_params_updates = lasagne.updates.adam(loss_A, all_params, learning_rate=0.001, beta1=0.9) # Some Theano functions , self.generate_fn_X = theano.function([X], network_output) self.train = theano.function([X, Y], loss, updates=Autoencodeur_params_updates, allow_input_downcast=True) self.predict = theano.function([X], network_output1, allow_input_downcast=True) self.encode_L = theano.function([X], encoded_output, allow_input_downcast=True) self.encode_G = theano.function([X], encoded_output1, allow_input_downcast=True) #s#elf.encode_G = encoded_output1 self.network = Auto_Enc_Layer return
def build_generator(self, version=1, encode=False): #from lasagne.layers import TransposedConv2DLayer as Deconv2DLayer global mask if mask is None: mask = T.zeros(shape=(self.batch_size, 1, 64, 64), dtype=theano.config.floatX) mask = T.set_subtensor(mask[:, :, 16:48, 16:48], 1.) self.mask = mask noise_dim = (self.batch_size, 100) theano_rng = MRG_RandomStreams(rng.randint(2**15)) noise = theano_rng.uniform(size=noise_dim) # mask_color = T.cast(T.cast(theano_rng.uniform(size=(self.batch_size,), low=0., high=2.), 'int16').dimshuffle(0, 'x', 'x', 'x') * mask, dtype=theano.config.floatX) input = ll.InputLayer(shape=noise_dim, input_var=noise) cropped_image = T.cast(T.zeros_like(self.input_) * mask + (1. - mask) * self.input_, dtype=theano.config.floatX) encoder_input = T.concatenate([cropped_image, mask], axis=1) # shoudl concat wrt channels if version == 1: if encode: gen_layers = [ ll.InputLayer(shape=(self.batch_size, 4, 64, 64), input_var=encoder_input) ] # 3 x 64 x 64 --> 64 x 32 x 32 gen_layers.append( nn.batch_norm( ll.Conv2DLayer(gen_layers[-1], 64, 4, 2, pad=1, nonlinearity=nn.lrelu)) ) # 64 x 32 x 32 --> 128 x 16 x 16 gen_layers.append( nn.batch_norm( ll.Conv2DLayer(gen_layers[-1], 128, 4, 2, pad=1, nonlinearity=nn.lrelu)) ) # 128 x 16 x 16 --> 256 x 8 x 8 gen_layers.append( nn.batch_norm( ll.Conv2DLayer(gen_layers[-1], 256, 4, 2, pad=1, nonlinearity=nn.lrelu)) ) # 256 x 8 x 8 --> 512 x 4 x 4 gen_layers.append( nn.batch_norm( ll.Conv2DLayer(gen_layers[-1], 512, 4, 2, pad=1, nonlinearity=nn.lrelu)) ) # 512 x 4 x 4 --> 1024 x 2 x 2 gen_layers.append( nn.batch_norm( ll.Conv2DLayer(gen_layers[-1], 4000, 4, 4, pad=1, nonlinearity=nn.lrelu)) ) # 1024 x 2 x 2 --> 2048 x 1 x 1 #gen_layers.append(nn.batch_norm(ll.Conv2DLayer(gen_layers[-1], 2048, 4, 2, pad=1, nonlinearity=nn.lrelu))) # flatten this out #gen_layers.append(ll.FlattenLayer(gen_layers[-1])) gen_layers.append( nn.batch_norm( nn.Deconv2DLayer(gen_layers[-1], (self.batch_size, 128 * 4, 4, 4), (5, 5), stride=(4, 4)))) # concat with noise latent_size = 2048 else: gen_layers = [input] latent_size = 100 # TODO : put batchorm back on all layers, + g=None gen_layers.append( ll.DenseLayer(gen_layers[-1], 128 * 8 * 4 * 4, W=Normal(0.02))) gen_layers.append( ll.ReshapeLayer(gen_layers[-1], (self.batch_size, 128 * 8, 4, 4))) # creating array of mixing coefficients (shared Theano floats) that will be used for mixing generated_output and image at each layer mixing_coefs = [ theano.shared(lasagne.utils.floatX(0.05)) for i in range(2) ] # theano.shared(lasagne.utils.floatX(np.array([0.5]))) for i in range(3)] mixing_coefs.append(theano.shared(lasagne.utils.floatX(1))) border = 2 gen_layers.append( nn.batch_norm(nn.Deconv2DLayer( gen_layers[-1], (self.batch_size, 128 * 2, 8, 8), (5, 5), W=Normal(0.02), nonlinearity=nn.relu), g=None)) # 4 -> 8 #gen_layers.append(ll.DropoutLayer(gen_layers[-1],p=0.5)) #gen_layers.append(nn.ResetDeconvLayer(gen_layers[-1], cropped_image, mixing_coefs[0], border=border)) #layer_a = nn.ResetDeconvLayer(gen_layers[-1], cropped_image, mixing_coefs[0]) # all new #layer_concat_a = ll.ConcatLayer([layer_a, gen_layers[-1]], axis=1) #gen_layers.append(layer_concat_a) gen_layers.append( nn.batch_norm(nn.Deconv2DLayer(gen_layers[-1], (self.batch_size, 128, 16, 16), (5, 5), W=Normal(0.02), nonlinearity=nn.relu), g=None)) # 8 -> 16 #gen_layers.append(ll.DropoutLayer(gen_layers[-1],p=0.5)) #gen_layers.append(nn.ResetDeconvLayer(gen_layers[-1], cropped_image, mixing_coefs[1], border=border*2)) #layer_b = nn.ResetDeconvLayer(gen_layers[-1], cropped_image, mixing_coefs[1]) # all new #layer_concat_b = ll.ConcatLayer([layer_b, gen_layers[-1]], axis=1) #gen_layers.append(layer_concat_b) gen_layers.append( nn.batch_norm(nn.Deconv2DLayer(gen_layers[-1], (self.batch_size, 64, 32, 32), (5, 5), W=Normal(0.02), nonlinearity=nn.relu), g=None)) # 16 -> 32 #gen_layers.append(ll.DropoutLayer(gen_layers[-1],p=0.5)) #gen_layers.append(nn.ResetDeconvLayer(gen_layers[-1], cropped_image, mixing_coefs[2], border=border*2*2)) #layer_c = nn.ResetDeconvLayer(gen_layers[-1], cropped_image, mixing_coefs[1]) # all new #layer_concat_c = ll.ConcatLayer([layer_c, gen_layers[-1]], axis=1) #gen_layers.append(layer_concat_c) gen_layers.append( nn.Deconv2DLayer( gen_layers[-1], (self.batch_size, 3, 64, 64), (5, 5), W=Normal(0.02), nonlinearity=lasagne.nonlinearities.sigmoid)) # 32 -> 64 #gen_layers.append(ll.DropoutLayer(gen_layers[-1],p=0.5)) #gen_layers.append(nn.ResetDeconvLayer(gen_layers[-1], cropped_image, mixing_coefs[3], border=border*2*2*2, trainable=False)) for layer in gen_layers: print layer.output_shape print '' GAN.mixing_coefs = mixing_coefs return gen_layers
gen_in_z = ll.InputLayer(shape=(batch_size_g, n_z)) gen_in_y = ll.InputLayer(shape=(batch_size_g, )) gen_layers = [gen_in_z] # gen_layers = [(nn.MoGLayer(gen_in_z, noise_dim=(batch_size_g, n_z)))] gen_layers.append(nn.MLPConcatLayer([gen_layers[-1], gen_in_y], num_classes)) gen_layers.append( ll.DenseLayer(gen_layers[-1], num_units=4 * 4 * 512, W=Normal(0.05), nonlinearity=nn.relu)) gen_layers.append(nn.batch_norm(gen_layers[-1], g=None)) gen_layers.append(ll.ReshapeLayer(gen_layers[-1], (batch_size_g, 512, 4, 4))) gen_layers.append(nn.ConvConcatLayer([gen_layers[-1], gen_in_y], num_classes)) gen_layers.append( nn.Deconv2DLayer(gen_layers[-1], (batch_size_g, 256, 8, 8), (5, 5), W=Normal(0.05), nonlinearity=nn.relu)) gen_layers.append(nn.batch_norm(gen_layers[-1], g=None)) gen_layers.append(nn.ConvConcatLayer([gen_layers[-1], gen_in_y], num_classes)) gen_layers.append( nn.Deconv2DLayer(gen_layers[-1], (batch_size_g, 128, 16, 16), (5, 5), W=Normal(0.05), nonlinearity=nn.relu)) gen_layers.append(nn.batch_norm(gen_layers[-1], g=None)) gen_layers.append(nn.ConvConcatLayer([gen_layers[-1], gen_in_y], num_classes)) gen_layers.append( nn.Deconv2DLayer(gen_layers[-1], (batch_size_g, 3, 32, 32), (5, 5), W=Normal(0.05), nonlinearity=T.tanh)) gen_layers.append(nn.weight_norm(gen_layers[-1], train_g=True, init_stdv=0.1)) # for layer in gen_layers:
# specify generative model gen_layers = [z_input] gen_layers.append( nn.batch_norm(ll.DenseLayer(gen_layers[-1], num_units=4 * 4 * 512, W=Normal(0.05), nonlinearity=nn.relu, name='g1'), g=None)) gen_layers.append(ll.ReshapeLayer(gen_layers[-1], (args.batch_size, 512, 4, 4))) gen_layers.append( nn.batch_norm(nn.Deconv2DLayer(gen_layers[-1], (args.batch_size, 256, 8, 8), (5, 5), W=Normal(0.05), nonlinearity=nn.relu, name='g2'), g=None)) # 4 -> 8 gen_layers.append( nn.batch_norm(nn.Deconv2DLayer(gen_layers[-1], (args.batch_size, 128, 16, 16), (5, 5), W=Normal(0.05), nonlinearity=nn.relu, name='g3'), g=None)) # 8 -> 16 gen_layers.append( nn.weight_norm(nn.Deconv2DLayer(gen_layers[-1], (args.batch_size, 3, 32, 32), (5, 5), W=Normal(0.05), nonlinearity=T.tanh,
gen_layers = [ll.InputLayer(shape=noise_dim, input_var=noise)] gen_layers.append( nn.MoGLayer(gen_layers[-1], noise_dim=noise_dim, z=Z, sig=sig) ) # Comment this line when testing/training baseline GAN model gen_layers.append( nn.batch_norm(ll.DenseLayer(gen_layers[-1], num_units=4 * 4 * gen_dim * 4, W=Normal(0.05), nonlinearity=nn.relu), g=None)) gen_layers.append( ll.ReshapeLayer(gen_layers[-1], (args.batch_size, gen_dim * 4, 4, 4))) gen_layers.append( nn.batch_norm(nn.Deconv2DLayer(gen_layers[-1], (args.batch_size, gen_dim * 2, 8, 8), (5, 5), W=Normal(0.05), nonlinearity=nn.relu), g=None)) # 4 -> 8 gen_layers.append( nn.batch_norm(nn.Deconv2DLayer(gen_layers[-1], (args.batch_size, gen_dim, 16, 16), (5, 5), W=Normal(0.05), nonlinearity=nn.relu), g=None)) # 8 -> 16 gen_layers.append( nn.weight_norm(nn.Deconv2DLayer(gen_layers[-1], (args.batch_size, 1, 32, 32), (5, 5), W=Normal(0.05), nonlinearity=T.tanh), train_g=True,
nn.batch_norm(ll.DenseLayer(gen_layers[-1], num_units=512 * 4 * 4, nonlinearity=ln.linear, name='gen-6'), g=None, name='gen-61')) gen_layers.append( ll.ReshapeLayer(gen_layers[-1], (-1, 512, 4, 4), name='gen-7')) gen_layers.append( ConvConcatLayer([gen_layers[-1], gen_in_y], num_classes, name='gen-8')) gen_layers.append( nn.batch_norm(nn.Deconv2DLayer(gen_layers[-1], (None, 256, 8, 8), filter_size=(4, 4), stride=(2, 2), W=Normal(0.05), nonlinearity=nn.relu, name='gen-11'), g=None, name='gen-12')) gen_layers.append( ConvConcatLayer([gen_layers[-1], gen_in_y], num_classes, name='gen-9')) gen_layers.append( nn.batch_norm(nn.Deconv2DLayer(gen_layers[-1], (None, 128, 16, 16), filter_size=(4, 4), stride=(2, 2), W=Normal(0.05), nonlinearity=nn.relu, name='gen-11'), g=None,
cla_layers.append(ll.DenseLayer(cla_layers[-1], num_units=num_classes, W=lasagne.init.Normal(1e-2, 0), nonlinearity=ln.softmax, name='cla-6')) ################# Generator gen_in_z = ll.InputLayer(shape=(None, n_z)) gen_in_y = ll.InputLayer(shape=(None,)) gen_layers = [gen_in_z] gen_layers.append(MLPConcatLayer([gen_layers[-1], gen_in_y], num_classes, name='gen-5')) gen_layers.append(nn.batch_norm(ll.DenseLayer(gen_layers[-1], num_units=512*4*4, nonlinearity=ln.linear, name='gen-6'), g=None, name='gen-61')) gen_layers.append(ll.ReshapeLayer(gen_layers[-1], (-1, 512, 4, 4), name='gen-7')) gen_layers.append(ConvConcatLayer([gen_layers[-1], gen_in_y], num_classes, name='gen-8')) gen_layers.append(nn.batch_norm(nn.Deconv2DLayer(gen_layers[-1], (None, 256, 8, 8), filter_size=(4,4), stride=(2, 2), W=Normal(0.05), nonlinearity=nn.relu, name='gen-11'), g=None, name='gen-12')) gen_layers.append(ConvConcatLayer([gen_layers[-1], gen_in_y], num_classes, name='gen-9')) gen_layers.append(nn.batch_norm(nn.Deconv2DLayer(gen_layers[-1], (None, 128, 16, 16), filter_size=(4,4), stride=(2, 2), W=Normal(0.05), nonlinearity=nn.relu, name='gen-11'), g=None, name='gen-12')) gen_layers.append(ConvConcatLayer([gen_layers[-1], gen_in_y], num_classes, name='gen-10')) gen_layers.append(nn.batch_norm(nn.Deconv2DLayer(gen_layers[-1], (None, 64, 32, 32), filter_size=(4,4), stride=(2, 2), W=Normal(0.05), nonlinearity=nn.relu, name='gen-11'), g=None, name='gen-12')) gen_layers.append(ConvConcatLayer([gen_layers[-1], gen_in_y], num_classes, name='gen-11')) gen_layers.append(nn.weight_norm(nn.Deconv2DLayer(gen_layers[-1], (None, 1, 64, 64), filter_size=(4,4), stride=(2, 2), W=Normal(0.05), nonlinearity=gen_final_non, name='gen-31'), train_g=True, init_stdv=0.1, name='gen-32')) ########## Discriminators dis_in_x = ll.InputLayer(shape=(None, in_channels) + dim_input) dis_in_y = ll.InputLayer(shape=(None,))
# symbols sym_y_g = T.ivector() sym_z_input = T.matrix() sym_z_rand = theano_rng.uniform(size=(batch_size_g, n_z)) sym_z_shared = T.tile(theano_rng.uniform((batch_size_g/num_classes, n_z)), (num_classes, 1)) # generator y2x: p_g(x, y) = p(y) p_g(x | y) where x = G(z, y), z follows p_g(z) gen_in_z = ll.InputLayer(shape=(None, n_z)) gen_in_y = ll.InputLayer(shape=(None,)) gen_layers = [gen_in_z] if args.dataset == 'svhn' or args.dataset == 'cifar10': gen_layers.append(MLPConcatLayer([gen_layers[-1], gen_in_y], num_classes, name='gen-00')) gen_layers.append(nn.batch_norm(ll.DenseLayer(gen_layers[-1], num_units=4*4*512, W=Normal(0.05), nonlinearity=nn.relu, name='gen-01'), g=None, name='gen-02')) gen_layers.append(ll.ReshapeLayer(gen_layers[-1], (-1,512,4,4), name='gen-03')) gen_layers.append(ConvConcatLayer([gen_layers[-1], gen_in_y], num_classes, name='gen-10')) gen_layers.append(nn.batch_norm(nn.Deconv2DLayer(gen_layers[-1], (None,256,8,8), (5,5), W=Normal(0.05), nonlinearity=nn.relu, name='gen-11'), g=None, name='gen-12')) # 4 -> 8 gen_layers.append(ConvConcatLayer([gen_layers[-1], gen_in_y], num_classes, name='gen-20')) gen_layers.append(nn.batch_norm(nn.Deconv2DLayer(gen_layers[-1], (None,128,16,16), (5,5), W=Normal(0.05), nonlinearity=nn.relu, name='gen-21'), g=None, name='gen-22')) # 8 -> 16 gen_layers.append(ConvConcatLayer([gen_layers[-1], gen_in_y], num_classes, name='gen-30')) gen_layers.append(nn.weight_norm(nn.Deconv2DLayer(gen_layers[-1], (None,3,32,32), (5,5), W=Normal(0.05), nonlinearity=gen_final_non, name='gen-31'), train_g=True, init_stdv=0.1, name='gen-32')) # 16 -> 32 elif args.dataset == 'mnist': gen_layers.append(MLPConcatLayer([gen_layers[-1], gen_in_y], num_classes, name='gen-1')) gen_layers.append(ll.batch_norm(ll.DenseLayer(gen_layers[-1], num_units=500, nonlinearity=ln.softplus, name='gen-2'), name='gen-3')) gen_layers.append(MLPConcatLayer([gen_layers[-1], gen_in_y], num_classes, name='gen-4')) gen_layers.append(ll.batch_norm(ll.DenseLayer(gen_layers[-1], num_units=500, nonlinearity=ln.softplus, name='gen-5'), name='gen-6')) gen_layers.append(MLPConcatLayer([gen_layers[-1], gen_in_y], num_classes, name='gen-7')) gen_layers.append(nn.l2normalize(ll.DenseLayer(gen_layers[-1], num_units=28**2, nonlinearity=gen_final_non, name='gen-8'))) # outputs gen_out_x = ll.get_output(gen_layers[-1], {gen_in_y:sym_y_g, gen_in_z:sym_z_rand}, deterministic=False) gen_out_x_shared = ll.get_output(gen_layers[-1], {gen_in_y:sym_y_g, gen_in_z:sym_z_shared}, deterministic=False)
def build_generator(self, version=1, encode=False): #from lasagne.layers import TransposedConv2DLayer as Deconv2DLayer global mask if mask is None: mask = T.zeros(shape=(self.batch_size, 1, 64, 64), dtype=theano.config.floatX) mask = T.set_subtensor(mask[:, :, 16:48, 16:48], 1.) self.mask = mask noise_dim = (self.batch_size, 100) theano_rng = MRG_RandomStreams(rng.randint(2**15)) noise = theano_rng.uniform(size=noise_dim) input = ll.InputLayer(shape=noise_dim, input_var=noise) cropped_image = T.cast(T.zeros_like(self.input_) * mask + (1. - mask) * self.input_, dtype=theano.config.floatX) encoder_input = T.concatenate([cropped_image, mask], axis=1) if version == 1: if encode: gen_layers = [ ll.InputLayer(shape=(self.batch_size, 4, 64, 64), input_var=encoder_input) ] # 3 x 64 x 64 --> 64 x 32 x 32 gen_layers.append( nn.batch_norm( ll.Conv2DLayer(gen_layers[-1], 64, 4, 2, pad=1, nonlinearity=nn.lrelu)) ) # 64 x 32 x 32 --> 128 x 16 x 16 gen_layers.append( nn.batch_norm( ll.Conv2DLayer(gen_layers[-1], 128, 4, 2, pad=1, nonlinearity=nn.lrelu)) ) # 128 x 16 x 16 --> 256 x 8 x 8 gen_layers.append( nn.batch_norm( ll.Conv2DLayer(gen_layers[-1], 256, 4, 2, pad=1, nonlinearity=nn.lrelu)) ) # 256 x 8 x 8 --> 512 x 4 x 4 gen_layers.append( nn.batch_norm( ll.Conv2DLayer(gen_layers[-1], 512, 4, 2, pad=1, nonlinearity=nn.lrelu)) ) # 512 x 4 x 4 --> 1024 x 2 x 2 gen_layers.append( nn.batch_norm( ll.Conv2DLayer(gen_layers[-1], 4000, 4, 4, pad=1, nonlinearity=nn.lrelu)) ) # 1024 x 2 x 2 --> 2048 x 1 x 1 #gen_layers.append(nn.batch_norm(ll.Conv2DLayer(gen_layers[-1], 2048, 4, 2, pad=1, nonlinearity=nn.lrelu))) # flatten this out #gen_layers.append(ll.FlattenLayer(gen_layers[-1])) gen_layers.append( nn.batch_norm( nn.Deconv2DLayer(gen_layers[-1], (self.batch_size, 128 * 4, 4, 4), (5, 5), stride=(4, 4)))) # concat with noise latent_size = 2048 else: gen_layers = [input] latent_size = 100 gen_layers.append( nn.batch_norm( ll.DenseLayer(gen_layers[-1], 128 * 8 * 4 * 4, W=Normal(0.02)))) gen_layers.append( ll.ReshapeLayer(gen_layers[-1], (self.batch_size, 128 * 8, 4, 4))) # creating array of mixing coefficients (shared Theano floats) that will be used for mixing generated_output and image at each layer mixing_coefs = [ theano.shared(lasagne.utils.floatX(0.25)) for i in range(3) ] mixing_coefs.append(theano.shared(lasagne.utils.floatX(0.9))) border = 2 gen_layers.append( nn.batch_norm(nn.Deconv2DLayer( gen_layers[-1], (self.batch_size, 128 * 2, 8, 8), (5, 5), W=Normal(0.02), nonlinearity=nn.relu), g=None)) # 4 -> 8 #gen_layers.append(ll.DropoutLayer(gen_layers[-1],p=0.5)) if reset: gen_layers.append( nn.ResetDeconvLayer(gen_layers[-1], cropped_image, mixing_coefs[0])) gen_layers.append( nn.batch_norm(nn.Deconv2DLayer(gen_layers[-1], (self.batch_size, 128, 16, 16), (5, 5), W=Normal(0.02), nonlinearity=nn.relu), g=None)) # 8 -> 16 #gen_layers.append(ll.DropoutLayer(gen_layers[-1],p=0.5)) if reset: gen_layers.append( nn.ResetDeconvLayer(gen_layers[-1], cropped_image, mixing_coefs[1])) gen_layers.append( nn.batch_norm(nn.Deconv2DLayer(gen_layers[-1], (self.batch_size, 64, 32, 32), (5, 5), W=Normal(0.02), nonlinearity=nn.relu), g=None)) # 16 -> 32 #gen_layers.append(ll.DropoutLayer(gen_layers[-1],p=0.5)) if reset: gen_layers.append( nn.ResetDeconvLayer(gen_layers[-1], cropped_image, mixing_coefs[2])) gen_layers.append( nn.Deconv2DLayer(gen_layers[-1], (self.batch_size, 3, 64, 64), (5, 5), W=Normal(0.02), nonlinearity=T.tanh)) # 32 -> 64 #gen_layers.append(ll.DropoutLayer(gen_layers[-1],p=0.5)) if reset: gen_layers.append( nn.ResetDeconvLayer(gen_layers[-1], cropped_image, mixing_coefs[3], trainable=False)) for layer in gen_layers: print layer.output_shape print '' GAN.mixing_coefs = mixing_coefs return gen_layers