In [1]:
%pylab inline
In [2]:
from io import BytesIO
from PIL import Image as PIL_Image
import numpy as np
from IPython.display import display, Image
def display_img_array(ima, **kwargs):
if ima.dtype == np.float32 or ima.dtype == np.float64:
ima = (np.clip(ima, 0., 1.)*255).astype(np.uint8)
im = PIL_Image.fromarray(ima)
bio = BytesIO()
im.save(bio, format='png')
display(Image(bio.getvalue(), format='png', **kwargs))
In [3]:
import pickle
train_X=[]
train_Y=[]
for i in range(1, 6):
dataset = "cifar-10-batches-py/data_batch_%d"%i
with open(dataset, 'rb') as f:
result = pickle.load(f, encoding='latin1')
train_X.extend(result['data']/255)
train_Y.extend(result['labels'])
r2 = result['data'].reshape(-1, 3, 32, 32)[:,:,:,::-1].reshape(-1, 3*32*32)
train_X.extend(r2/255)
train_Y.extend(result['labels'])
train_X=np.array(train_X, dtype='float32')
train_Y=np.array(train_Y, dtype='int32')
idx = np.arange(train_X.shape[0])
np.random.shuffle(idx)
train_X = train_X[idx]
train_Y = train_Y[idx]
train_set= (train_X, train_Y)
dataset = "cifar-10-batches-py/test_batch"
with open(dataset, 'rb') as f:
result = pickle.load(f, encoding='latin1')
test_set = (array(result['data'], dtype='float32')/255, array(result['labels'], dtype='int32'))
In [4]:
print("train_set", train_set[0].shape, train_set[1].shape)
print("test_set", test_set[0].shape, test_set[1].shape)
In [5]:
def show(x):
x = x.reshape(-1, 3, 32, 32)
w = min(x.shape[0]*100, 800)
x = x.swapaxes(0, 1).swapaxes(1,2)
x = x.reshape(3, 32, -1)
img = np.swapaxes(x, 0, 1)
img = np.swapaxes(img, 1, 2)
display_img_array(img, width=w)
for i in range(3):
print(train_set[1][i])
show(train_set[0][i])
show(train_set[0][:10])
In [6]:
import numpy as np
import theano
import theano.tensor as T
import lasagne
from lasagne.layers import DenseLayer, DropoutLayer, ReshapeLayer, InputLayer, FlattenLayer, Upscale2DLayer, LocalResponseNormalization2DLayer
floatX = theano.config.floatX
In [7]:
from lasagne.layers.dnn import MaxPool3DDNNLayer, Conv3DDNNLayer, MaxPool2DDNNLayer, Conv2DDNNLayer
In [ ]:
from lasagne.layers import Deconv2DLayer
In [8]:
from lasagne.layers import batch_norm
from lasagne.objectives import categorical_crossentropy, binary_crossentropy, categorical_accuracy, binary_accuracy
In [9]:
input_var = T.matrix()
_ = InputLayer(shape=(None, 3*32*32), input_var=input_var)
_ = ReshapeLayer(_, ([0], 3, 32, 32))
_ = batch_norm(Conv2DDNNLayer(_, 64, 3, pad='same'))
_ = batch_norm(Conv2DDNNLayer(_, 64, 3, pad='same'))
_ = MaxPool2DDNNLayer(_, 2)
_ = batch_norm(Conv2DDNNLayer(_, 128, 3, pad='same'))
_ = MaxPool2DDNNLayer(_, 2)
_ = batch_norm(Conv2DDNNLayer(_, 256, 3, pad='same'))
_ = batch_norm(Conv2DDNNLayer(_, 64, 3, pad='same'))
_ = FlattenLayer(_)
_ = DenseLayer(_, num_units=1000, nonlinearity=lasagne.nonlinearities.rectify)
l_discriminator = DenseLayer(_, num_units=1, nonlinearity=lasagne.nonlinearities.sigmoid)
NU=32
input_var2 = T.matrix()
_ = InputLayer(shape=(None, NU), input_var=input_var2)
_ = batch_norm(DenseLayer(_, num_units=1000, nonlinearity=lasagne.nonlinearities.rectify))
_ = batch_norm(DenseLayer(_, num_units=64*8*8, nonlinearity=lasagne.nonlinearities.rectify))
_ = ReshapeLayer(_, ([0], 64, 8, 8))
_ = batch_norm(Conv2DDNNLayer(_, 128, 3, pad='same'))
_ = Upscale2DLayer(_, 2)
_ = batch_norm(Conv2DDNNLayer(_, 128, 3, pad='same'))
_ = Upscale2DLayer(_, 2)
_ = batch_norm(Conv2DDNNLayer(_, 128, 3, pad='same'))
_ = batch_norm(Conv2DDNNLayer(_, 128, 3, pad='same'))
_ = batch_norm(Conv2DDNNLayer(_, 3, 3, pad='same', nonlinearity=lasagne.nonlinearities.sigmoid))
l_generator = FlattenLayer(_)
TINY=1e-8
def clip(x):
return T.clip(x, 1e-8, 1-1e-8)
output_discriminator = lasagne.layers.get_output(l_discriminator)
output_generator_deterministic = lasagne.layers.get_output(l_generator, deterministic=True)
output_generator = lasagne.layers.get_output(l_generator)
output_combined = lasagne.layers.get_output(l_discriminator, inputs=output_generator)
loss_discriminator = -T.log(output_discriminator + TINY).mean() - T.log(1. - output_combined + TINY).mean()
loss_combined = -T.log(output_combined + TINY).mean()
accuracy_combined = binary_accuracy(output_combined,
T.zeros_like(output_combined)).mean()
accuracy_discriminator = binary_accuracy(output_discriminator, T.ones_like(output_combined)).mean()
accuracy_discriminator = (accuracy_discriminator + accuracy_combined)/2
params_discriminator = lasagne.layers.get_all_params(l_discriminator, trainable=True)
params_generator = lasagne.layers.get_all_params(l_generator, trainable=True)
updates_generator = lasagne.updates.adam(loss_combined, params_generator,
learning_rate=1e-3, beta1=0.5)
updates_discriminator = lasagne.updates.adam(loss_discriminator, params_discriminator,
learning_rate=1e-4, beta1=0.5)
train_generator_fn = theano.function([input_var2], (loss_combined, accuracy_combined), updates=updates_generator)
train_discriminator_fn = theano.function([input_var, input_var2], (loss_discriminator, accuracy_discriminator), updates=updates_discriminator)
generator_fn = theano.function([input_var2], output_generator_deterministic)
In [10]:
import sys
from random import randint
batch_size=256
X=train_set[0] #[train_set[1]==5]
X2=test_set[0]
g_err=d_err=0.1
last_imgs = None
for j in range(1000*1000):
#print("discriminator phase")
d_acc = -1
for i in range(1):
x = X[np.random.randint(0, X.shape[0], size=batch_size)]
random_input = (np.random.uniform(low=-1, size=(batch_size, NU))).astype('float32')
d_err, d_acc0 = train_discriminator_fn(x, random_input)
if d_acc == -1:
d_acc = d_acc0
else:
d_acc = d_acc*0.9+0.1*d_acc0
if d_err < max(g_err, 0.1):
break
if i%100 == -1:
print(i, "d_err", d_err, g_err, d_acc)
#print("generator phase")
g_acc = -1
for i in range(5):
random_input = (np.random.uniform(low=-1, size=(batch_size, NU))).astype('float32')
g_err, g_acc0 = train_generator_fn(random_input)
if g_acc == -1:
g_acc = g_acc0
else:
g_acc = g_acc*0.9+0.1*g_acc0
#g_err = -g_err
if g_err < max(d_err, 0.1):
break
if i%1000 == -1:
print(i, "g_err", g_err, d_err, g_acc)
if j%100==0:
imgs = generator_fn(random_input)
print("j=", j)
show(imgs[:16])
print("g_err", g_err, d_err, g_acc)
print("d_err", d_err, g_err, d_acc)
In [11]:
for i in range(0, 100, 8):
show(imgs[i:i+8])
In [12]:
#np.savez('cifar10_gan_generator.npz', lasagne.layers.get_all_param_values(l_generator))
#np.savez('cifar10_gan_discriminator.npz', lasagne.layers.get_all_param_values(l_discriminator))
In [ ]: