def build(input_height, input_width, concat_var): """ Build the discriminator, all weights initialized from scratch :param input_width: :param input_height: :param concat_var: Theano symbolic tensor variable :return: Dictionary that contains the discriminator """ net = {'input': InputLayer((None, 4, input_height, input_width), input_var=concat_var)} print "Input: {}".format(net['input'].output_shape[1:]) net['merge'] = ConvLayer(net['input'], 3, 1, pad=0, flip_filters=False) print "merge: {}".format(net['merge'].output_shape[1:]) net['conv1'] = ConvLayer(net['merge'], 32, 3, pad=1) print "conv1: {}".format(net['conv1'].output_shape[1:]) net['pool1'] = PoolLayer(net['conv1'], 4) print "pool1: {}".format(net['pool1'].output_shape[1:]) net['conv2_1'] = ConvLayer(net['pool1'], 64, 3, pad=1) print "conv2_1: {}".format(net['conv2_1'].output_shape[1:]) net['conv2_2'] = ConvLayer(net['conv2_1'], 64, 3, pad=1) print "conv2_2: {}".format(net['conv2_2'].output_shape[1:]) net['pool2'] = PoolLayer(net['conv2_2'], 2) print "pool2: {}".format(net['pool2'].output_shape[1:]) net['conv3_1'] = nn.weight_norm(ConvLayer(net['pool2'], 64, 3, pad=1)) print "conv3_1: {}".format(net['conv3_1'].output_shape[1:]) net['conv3_2'] = nn.weight_norm(ConvLayer(net['conv3_1'], 64, 3, pad=1)) print "conv3_2: {}".format(net['conv3_2'].output_shape[1:]) net['pool3'] = PoolLayer(net['conv3_2'], 2) print "pool3: {}".format(net['pool3'].output_shape[1:]) net['fc4'] = DenseLayer(net['pool3'], num_units=100, nonlinearity=tanh) print "fc4: {}".format(net['fc4'].output_shape[1:]) net['fc5'] = DenseLayer(net['fc4'], num_units=2, nonlinearity=tanh) print "fc5: {}".format(net['fc5'].output_shape[1:]) net['prob'] = DenseLayer(net['fc5'], num_units=1, nonlinearity=sigmoid) print "prob: {}".format(net['prob'].output_shape[1:]) return net
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 _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 discriminator(input_var): network = lasagne.layers.InputLayer(shape=(None, 1, 28, 28), input_var=input_var) network = ll.DropoutLayer(network, p=0.5) network = nn.weight_norm(dnn.Conv2DDNNLayer(network, 64, (4,4), pad='valid', W=Normal(0.05), nonlinearity=nn.lrelu)) network = nn.weight_norm(dnn.Conv2DDNNLayer(network, 32, (5,5), stride=2, pad='valid', W=Normal(0.05), nonlinearity=nn.lrelu)) network = nn.weight_norm(dnn.Conv2DDNNLayer(network, 32, (5,5), pad='valid', W=Normal(0.05), nonlinearity=nn.lrelu)) network = nn.weight_norm(dnn.Conv2DDNNLayer(network, 32, (5,5), pad='valid', W=Normal(0.05), nonlinearity=nn.lrelu)) network = nn.weight_norm(dnn.Conv2DDNNLayer(network, 16, (3,3), pad='valid', W=Normal(0.05), nonlinearity=nn.lrelu)) network =nn.weight_norm(ll.DenseLayer(network, num_units=1, W=Normal(0.05), nonlinearity=None), train_g=True, init_stdv=0.1) return network
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: # print layer.params #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) gen_out_x_interpolation = ll.get_output(gen_layers[-1], { gen_in_y: sym_y_g,
nr_batches_train = int(trainx.shape[0]/args.batch_size) #50000.0/100 = 500 nr_batches_test = int(testx.shape[0]/args.batch_size) #10000.0/100 =100 # specify generative model noise_dim = (args.batch_size, 50) 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]) 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], 128, (3,3), pad=1, W=Normal(0.05), nonlinearity=nn.lrelu))) disc_layers.append(nn.weight_norm(dnn.Conv2DDNNLayer(disc_layers[-1], 128, (3,3), pad=1, W=Normal(0.05), nonlinearity=nn.lrelu))) disc_layers.append(nn.weight_norm(dnn.Conv2DDNNLayer(disc_layers[-1], 128, (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], 256, (3,3), pad=1, W=Normal(0.05), nonlinearity=nn.lrelu))) disc_layers.append(nn.weight_norm(dnn.Conv2DDNNLayer(disc_layers[-1], 256, (3,3), pad=1, W=Normal(0.05), nonlinearity=nn.lrelu))) disc_layers.append(nn.weight_norm(dnn.Conv2DDNNLayer(disc_layers[-1], 256, (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], 512, (3,3), pad=0, W=Normal(0.05), nonlinearity=nn.lrelu))) disc_layers.append(nn.weight_norm(ll.NINLayer(disc_layers[-1], num_units=256, W=Normal(0.05), nonlinearity=nn.lrelu))) disc_layers.append(nn.weight_norm(ll.NINLayer(disc_layers[-1], num_units=128, W=Normal(0.05), nonlinearity=nn.lrelu)))
trainx = np.concatenate([d['x'] for d in train_data],axis=0) trainy = np.concatenate([d['y'] for d in train_data]) test_data = unpickle('/home/ubuntu/data/cifar-10-python/cifar-10-batches-py/test_batch') testx = test_data['x'] testy = test_data['y'] nr_batches_train = int(trainx.shape[0]/args.batch_size) nr_batches_test = int(testx.shape[0]/args.batch_size) # whitening whitener = nn.ZCA(x=trainx) trainx_white = whitener.apply(trainx) testx_white = whitener.apply(testx) # specify model if args.norm_type=='weight_norm': normalizer = lambda l: nn.weight_norm(l) elif args.norm_type=='batch_norm': normalizer = lambda l: nn.batch_norm(l) elif args.norm_type=='mean_only_bn': normalizer = lambda l: nn.mean_only_bn(l) elif args.norm_type=='no_norm': normalizer = lambda l: nn.no_norm(l) else: raise NotImplementedError('incorrect norm type') layers = [ll.InputLayer(shape=(None, 3, 32, 32))] layers.append(ll.GaussianNoiseLayer(layers[-1], sigma=0.15)) layers.append(normalizer(dnn.Conv2DDNNLayer(layers[-1], 96, (3,3), pad=1, nonlinearity=nn.lrelu))) layers.append(normalizer(dnn.Conv2DDNNLayer(layers[-1], 96, (3,3), pad=1, nonlinearity=nn.lrelu))) layers.append(normalizer(dnn.Conv2DDNNLayer(layers[-1], 96, (3,3), pad=1, nonlinearity=nn.lrelu))) layers.append(ll.MaxPool2DLayer(layers[-1], 2))
classifier = build_network() # 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] 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 # discriminator xy2p: test a pair of input comes from p(x, y) instead of p_c or p_g dis_in_x = ll.InputLayer(shape=(None, in_channels) + dim_input) dis_in_y = ll.InputLayer(shape=(None,)) dis_layers = [dis_in_x] dis_layers.append(ll.DropoutLayer(dis_layers[-1], p=0.2, name='dis-00')) dis_layers.append(ConvConcatLayer([dis_layers[-1], dis_in_y], num_classes, name='dis-01')) dis_layers.append(nn.weight_norm(dnn.Conv2DDNNLayer(dis_layers[-1], 32, (3,3), pad=1, W=Normal(0.05), nonlinearity=nn.lrelu, name='dis-02'), name='dis-03')) dis_layers.append(ConvConcatLayer([dis_layers[-1], dis_in_y], num_classes, name='dis-20')) dis_layers.append(nn.weight_norm(dnn.Conv2DDNNLayer(dis_layers[-1], 32, (3,3), pad=1, stride=2, W=Normal(0.05), nonlinearity=nn.lrelu, name='dis-21'), name='dis-22')) dis_layers.append(ll.DropoutLayer(dis_layers[-1], p=0.2, name='dis-23')) dis_layers.append(ConvConcatLayer([dis_layers[-1], dis_in_y], num_classes, name='dis-30')) dis_layers.append(nn.weight_norm(dnn.Conv2DDNNLayer(dis_layers[-1], 64, (3,3), pad=1, W=Normal(0.05), nonlinearity=nn.lrelu, name='dis-31'), name='dis-32')) dis_layers.append(ConvConcatLayer([dis_layers[-1], dis_in_y], num_classes, name='dis-40')) dis_layers.append(nn.weight_norm(dnn.Conv2DDNNLayer(dis_layers[-1], 64, (3,3), pad=1, stride=2, W=Normal(0.05), nonlinearity=nn.lrelu, name='dis-41'), name='dis-42'))
def d_architecture2(self): ### Input input_shape = self.size_input # 50000*1*28*28 (channel=1, lenght=28,with=28) print(input_shape) discriminator_layers = [ lasagne.layers.InputLayer(shape=(None, input_shape[1], input_shape[2], input_shape[3]), input_var=self.input_var) ] # on passe de 3*32*32 a 96*32*32 car on a 96 filtres Tempw = lasagne.utils.create_param(lasagne.init.Normal(0.05), (1, 96, 32, 32), "W_D_conv1") Tempb = lasagne.utils.create_param(lasagne.init.Constant(0.0), (96, ), "b_D_conv1") discriminator_layers.append( lasagne.layers.Conv2DLayer(discriminator_layers[-1], num_filters=96, filter_size=(5, 5), nonlinearity=self.nonlinear, W=Tempw, b=Tempb)) # check if convolution type (full, same,valid) ######################### # on passe de 96*32*32 a 96*16*16 car pooling 2*2 #discriminator_layers.append(lasagne.layers.MaxPool2DLayer(discriminator_layers[-1], pool_size=(2,2))) # on passe de 96*32*32 a 192*32*32 Tempw = lasagne.utils.create_param(lasagne.init.Normal(0.05), (1, 192, 32, 32), "W_D_conv2") Tempb = lasagne.utils.create_param(lasagne.init.Constant(0.0), (192, ), "b_D_conv2") #Tempw = theano.shared(self.fonction_ini(0.05,1,(1,192,32,32)).astype('float32')) #Tempb = theano.shared(self.fonction_ini(0.05,1,(192,)).astype('float32')) discriminator_layers.append( lasagne.layers.Conv2DLayer(discriminator_layers[-1], num_filters=192, filter_size=(5, 5), nonlinearity=self.nonlinear, W=Tempw, b=Tempb)) # on passe de 192*32*32 a 192 Tempw = lasagne.utils.create_param(lasagne.init.Normal(0.05), (1, 192, 32, 32), "W_D_conv3") Tempb = lasagne.utils.create_param(lasagne.init.Constant(0.0), (192, ), "b_D_conv3") discriminator_layers.append( lasagne.layers.DropoutLayer(discriminator_layers[-1], p=.5)) discriminator_layers.append( lasagne.layers.Conv2DLayer(discriminator_layers[-1], num_filters=192, filter_size=(5, 5), nonlinearity=self.nonlinear, W=Tempw, b=Tempb)) # on passe de 192 a 192 Tempw = lasagne.utils.create_param(lasagne.init.Normal(0.05), (1, 192), "W_D_conv4") Tempb = lasagne.utils.create_param(lasagne.init.Constant(0.0), (1, ), "b_D_conv4") discriminator_layers.append( lasagne.layers.NINLayer(discriminator_layers[-1], num_units=192, nonlinearity=self.nonlinear, W=Tempw, b=Tempb)) discriminator_layers.append( lasagne.layers.GlobalPoolLayer(discriminator_layers[-1])) # on passe de 92 a 2 Tempw = lasagne.utils.create_param(lasagne.init.Normal(0.05), (1, 2), "W_D_conv5") Tempb = lasagne.utils.create_param(lasagne.init.Constant(0.0), (1, ), "b_D_conv5") discriminator_layers.append( lasagne.layers.DenseLayer(discriminator_layers[-1], num_units=2, W=Tempw, b=Tempb, nonlinearity=None)) print(input_shape) self.parameters = lasagne.layers.get_all_params(discriminator_layers, trainable=True) self.last_layer = discriminator_layers[-1] ########################## self.architecture = discriminator_layers input_shape = self.size_input # 50000*1*28*28 (channel=1, lenght=28,with=28) discriminator_layers = [ lasagne.layers.InputLayer(shape=(None, input_shape[1], input_shape[2], input_shape[3]), input_var=self.input_var) ] # on passe de 3*32*32 a 96*32*32 car on a 96 filtres discriminator_layers.append( lasagne.layers.DropoutLayer(discriminator_layers[-1], p=0.5)) discriminator_layers.append( nn.weight_norm( Conv2DDNNLayer( discriminator_layers[-1], 192, (3, 3), pad=1, W=lasagne.init.Normal(0.05), nonlinearity=lasagne.nonlinearities.Leakyrectify))) discriminator_layers.append( nn.weight_norm( Conv2DDNNLayer( discriminator_layers[-1], 192, (3, 3), pad=1, W=lasagne.init.Normal(0.05), nonlinearity=lasagne.nonlinearities.Leakyrectify))) discriminator_layers.append( nn.weight_norm( Conv2DDNNLayer( discriminator_layers[-1], 192, (3, 3), pad=1, stride=2, W=lasagne.init.Normal(0.05), nonlinearity=lasagne.nonlinearities.Leakyrectify))) discriminator_layers.append( nn.weight_norm( Conv2DDNNLayer(discriminator_layers[-1], 256, (3, 3), pad=1, W=lasagne.init.Normal(0.05), nonlinearity=lasagne.nonlinearities.rectify))) discriminator_layers.append( nn.weight_norm( Conv2DDNNLayer(discriminator_layers[-1], 256, (3, 3), pad=1, W=lasagne.init.Normal(0.05), nonlinearity=lasagne.nonlinearities.rectify))) discriminator_layers.append( nn.weight_norm( Conv2DDNNLayer(discriminator_layers[-1], 256, (3, 3), pad=1, stride=2, W=lasagne.init.Normal(0.05), nonlinearity=lasagne.nonlinearities.rectify))) discriminator_layers.append( lasagne.layers.DropoutLayer(discriminator_layers[-1], p=0.5)) discriminator_layers.append( nn.weight_norm( Conv2DDNNLayer(discriminator_layers[-1], 256, (3, 3), pad=0, W=lasagne.init.Normal(0.05), nonlinearity=lasagne.nonlinearities.rectify))) discriminator_layers.append( nn.weight_norm( lasagne.layers.NINLayer( discriminator_layers[-1], num_units=256, W=lasagne.init.Normal(0.05), nonlinearity=lasagne.nonlinearities.rectify))) discriminator_layers.append( nn.weight_norm( lasagne.layers.NINLayer( discriminator_layers[-1], num_units=256, W=lasagne.init.Normal(0.05), nonlinearity=lasagne.nonlinearities.rectify))) discriminator_layers.append( lasagne.layers.GlobalPoolLayer(discriminator_layers[-1])) self.architecture = disc_layers return
def get_discriminator_brown(num_feature=256): 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], 128, (3, 3), pad=1, W=Normal(0.05), nonlinearity=nn.lrelu))) disc_layers.append( nn.weight_norm( dnn.Conv2DDNNLayer(disc_layers[-1], 128, (3, 3), pad=1, W=Normal(0.05), nonlinearity=nn.lrelu))) disc_layers.append( nn.weight_norm( dnn.Conv2DDNNLayer(disc_layers[-1], 128, (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], 128, (3, 3), pad=0, W=Normal(0.05), nonlinearity=nn.lrelu))) disc_layers.append( nn.weight_norm( ll.NINLayer(disc_layers[-1], num_units=num_feature, W=Normal(0.05), nonlinearity=nn.lrelu))) disc_layers.append( nn.weight_norm( ll.NINLayer(disc_layers[-1], num_units=128, W=Normal(0.05), nonlinearity=nn.lrelu))) disc_layers.append(ll.GlobalPoolLayer(disc_layers[-1])) disc_layers.append( nn.weight_norm(ll.DenseLayer(disc_layers[-1], num_units=2, W=Normal(0.05), nonlinearity=None), train_g=True, init_stdv=0.1)) #disc_layers.append(ll.ReshapeLayer(disc_layers[-4], ([0], -1))) #disc_layers.append(ll.GlobalPoolLayer(disc_layers[-4])) disc_layer_features_low_dim = -4 disc_layer_features_high_dim = -5 return disc_layers, disc_layer_features_low_dim, disc_layer_features_high_dim
trainx = trainx[ind] trainy = trainy[ind] testx, testy = ddsm_data.load(args.data_dir, subset='test') nr_batches_train = int(trainx.shape[0] / args.batch_size) nr_batches_test = int(testx.shape[0] / args.batch_size) print("the train data is %d" % trainx.shape[0]) print("the test data is %d" % testx.shape[0]) print("compiling......") disc_layers = [ll.InputLayer(shape=(None, 1, 224, 224))] disc_layers.append(ll.GaussianNoiseLayer(disc_layers[-1], sigma=0.1)) disc_layers.append( nn.weight_norm( dnn.Conv2DDNNLayer(disc_layers[-1], 64, (5, 5), stride=2, pad=1, W=Normal(0.05), nonlinearity=nn.lrelu))) disc_layers.append( nn.weight_norm( dnn.Conv2DDNNLayer(disc_layers[-1], 128, (5, 5), stride=2, pad=1, W=Normal(0.05), nonlinearity=nn.lrelu))) disc_layers.append( nn.weight_norm( dnn.Conv2DDNNLayer(disc_layers[-1], 256, (5, 5),
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 disc_layers = [ll.InputLayer(shape=(None, 1, 224, 224))] disc_layers.append(ll.GaussianNoiseLayer(disc_layers[-1], sigma=0.2)) #uncomment this line if test without data augmentation disc_layers.append(nn.weight_norm(dnn.Conv2DDNNLayer(disc_layers[-1], 64, (5, 5), stride=2, pad=1, W=Normal(0.05), nonlinearity=nn.lrelu))) disc_layers.append(nn.weight_norm(dnn.Conv2DDNNLayer(disc_layers[-1], 128, (5, 5), stride=2,pad=1,W=Normal(0.05), nonlinearity=nn.lrelu))) disc_layers.append(nn.weight_norm(dnn.Conv2DDNNLayer(disc_layers[-1], 256, (5, 5),stride=2, pad=1, W=Normal(0.05), nonlinearity=nn.lrelu))) disc_layers.append(nn.weight_norm(dnn.Conv2DDNNLayer(disc_layers[-1], 512, (5, 5),stride=2, pad=1, W=Normal(0.05), nonlinearity=nn.lrelu))) disc_layers.append(ll.GlobalPoolLayer(disc_layers[-1])) disc_layers.append(nn.weight_norm(ll.DenseLayer(disc_layers[-1], num_units=2 * num_classes, W=Normal(0.05), nonlinearity=None), train_g=True, init_stdv=0.1)) # costs # init_updates = [u for l in disc_layers for u in getattr(l, 'init_updates', [])] gen_dat = ll.get_output(gen_layers[-1], {gen_in_y: labels_gen, gen_in_z: noise}) output_before_softmax_lab = ll.get_output(disc_layers[-1], x_lab)
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
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, name='g4'), train_g=True, init_stdv=0.1)) # 16 -> 32 gen_dat = ll.get_output(gen_layers[-1]) genz_layers = [x_input] genz_layers.append( dnn.Conv2DDNNLayer(genz_layers[-1], 128, (3, 3), pad=1, stride=2, W=Normal(0.05), nonlinearity=nn.lrelu, name='gz1')) genz_layers.append(
# 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)) disc_layers.append(nn.weight_norm(dnn.Conv2DDNNLayer(disc_layers[-1], 192, (3,3), pad=0, W=Normal(0.05), nonlinearity=nn.lrelu))) disc_layers.append(nn.weight_norm(ll.NINLayer(disc_layers[-1], num_units=192, W=Normal(0.05), nonlinearity=nn.lrelu)))
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,)) dis_layers = [dis_in_x] dis_layers.append(ll.DropoutLayer(dis_layers[-1], p=0.2, name='dis-00')) dis_layers.append(ConvConcatLayer([dis_layers[-1], dis_in_y], num_classes, name='dis-01')) dis_layers.append(nn.batch_norm(dnn.Conv2DDNNLayer(dis_layers[-1], 32, filter_size=4, stride=(2,2), pad=1, W=Normal(0.02), nonlinearity=nn.lrelu, name='dis-02'), name='dis-03')) dis_layers.append(ConvConcatLayer([dis_layers[-1], dis_in_y], num_classes, name='dis-20')) dis_layers.append(nn.batch_norm(dnn.Conv2DDNNLayer(dis_layers[-1], 64, filter_size=4, stride=(2,2), pad=1, W=Normal(0.02), nonlinearity=nn.lrelu, name='dis-02'), name='dis-03'))
def d_architecture(self): ### Input lrelu = lasagne.nonlinearities.LeakyRectify(0.2) input_shape = self.size_input # 50000*1*28*28 (channel=1, lenght=28,with=28) discriminator_layers = [ lasagne.layers.InputLayer(shape=(None, input_shape[1], input_shape[2], input_shape[3]), input_var=self.input_var) ] discriminator_layers.append( nn.weight_norm( Conv2DDNNLayer(discriminator_layers[-1], 64, (5, 5), pad=2, stride=2, W=lasagne.init.Normal(0.05), nonlinearity=lrelu))) discriminator_layers.append( nn.weight_norm( Conv2DDNNLayer(discriminator_layers[-1], 128, (5, 5), pad=2, stride=2, W=lasagne.init.Normal(0.05), nonlinearity=lrelu))) discriminator_layers.append( nn.weight_norm( Conv2DDNNLayer(discriminator_layers[-1], 256, (5, 5), pad=2, stride=2, W=lasagne.init.Normal(0.05), nonlinearity=lrelu))) discriminator_layers.append( nn.weight_norm( Conv2DDNNLayer(discriminator_layers[-1], 512, (5, 5), pad=2, stride=2, W=lasagne.init.Normal(0.05), nonlinearity=lrelu))) discriminator_layers.append( nn.weight_norm( Conv2DDNNLayer(discriminator_layers[-1], 1024, (5, 5), pad=2, stride=2, W=lasagne.init.Normal(0.05), nonlinearity=lrelu))) discriminator_layers.append( lasagne.layers.DropoutLayer(discriminator_layers[-1], p=0.2)) discriminator_layers.append( nn.weight_norm( lasagne.layers.NINLayer(discriminator_layers[-1], num_units=1024, W=lasagne.init.Normal(0.05), nonlinearity=lrelu))) discriminator_layers.append( lasagne.layers.GlobalPoolLayer(discriminator_layers[-1])) #discriminator_layers.append(lasagne.layers.batch_norm(lasagne.layers.DenseLayer(discriminator_layers[-1] , num_units=1, W=lasagne.init.Normal(0.05), nonlinearity=lasagne.nonlinearities.sigmoid))) discriminator_layers.append( nn.weight_norm(lasagne.layers.DenseLayer( discriminator_layers[-1], num_units=1, W=lasagne.init.Normal(0.05), nonlinearity=lasagne.nonlinearities.sigmoid), train_g=True, init_stdv=0.1)) self.architecture = discriminator_layers
rng_data = np.random.RandomState(args.seed_data) rng = np.random.RandomState(args.seed) theano_rng = MRG_RandomStreams(rng.randint(2 ** 15)) lasagne.random.set_rng(np.random.RandomState(rng.randint(2 ** 15))) # load CIFAR-10 ds_train = DataStream(d=args.data_dir, img_size=args.image_size, batch_size=args.batch_size, h5_name="train_sub.hdf5") ds_test = DataStream(d=args.data_dir, img_size=args.image_size, batch_size=args.batch_size, h5_name="val_sub.hdf5") print("DATA LOADERS CREATED") # specify discriminative model disc_layers = [ll.InputLayer(shape=(None, 1, args.image_size, args.image_size))] disc_layers.append(ll.DropoutLayer(disc_layers[-1], p=0.5)) disc_layers.append(nn.weight_norm(dnn.Conv2DDNNLayer(disc_layers[-1], 32, (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], 64, (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], 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(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(ll.DropoutLayer(disc_layers[-1], p=0.5)) 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)) disc_layers.append(nn.weight_norm(dnn.Conv2DDNNLayer(disc_layers[-1], 192, (3,3), pad=0, W=Normal(0.05), nonlinearity=nn.lrelu))) disc_layers.append(ll.DropoutLayer(disc_layers[-1], p=0.5)) disc_layers.append(nn.weight_norm(ll.NINLayer(disc_layers[-1], num_units=192, W=Normal(0.05), nonlinearity=nn.lrelu))) disc_layers.append(ll.DropoutLayer(disc_layers[-1], p=0.5))
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) gen_out_x_interpolation = ll.get_output(gen_layers[-1], {gen_in_y:sym_y_g, gen_in_z:sym_z_input}, deterministic=False) generate = theano.function(inputs=[sym_y_g], outputs=gen_out_x) generate_shared = theano.function(inputs=[sym_y_g], outputs=gen_out_x_shared) generate_interpolation = theano.function(inputs=[sym_y_g, sym_z_input], outputs=gen_out_x_interpolation)
def get_discriminator_binary(): 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)) disc_layers.append( nn.weight_norm( dnn.Conv2DDNNLayer(disc_layers[-1], 192, (3, 3), pad=0, W=Normal(0.05), nonlinearity=nn.lrelu))) disc_layers.append( nn.weight_norm( ll.NINLayer(disc_layers[-1], num_units=192, W=Normal(0.05), nonlinearity=nn.lrelu))) disc_layers.append( nn.weight_norm( ll.NINLayer(disc_layers[-1], num_units=192, W=Normal(0.05), nonlinearity=nn.lrelu))) disc_layers.append(ll.GlobalPoolLayer(disc_layers[-1])) disc_layers.append( nn.weight_norm(ll.DenseLayer(disc_layers[-1], num_units=2, W=Normal(0.05), nonlinearity=None), train_g=True, init_stdv=0.1)) disc_layers.append( ll.DenseLayer(disc_layers[-2], num_units=128, W=Normal(0.05), nonlinearity=T.nnet.sigmoid)) return disc_layers