def disc_shared_structure(state):
model = nn.Sequential()
model.add(nn.Convolutional(filter_size=(3, 3),
num_filters=state['d_num_filters'],
num_channels=state['input_channels'],
step=(1, 1), border_mode=(1, 1),
weight=state['d_conv_init'], use_bias=False))
model.add(nn.BatchNorm(state['d_num_filters']))
# model.add(nn.Expression(T.nnet.relu))
model.add(nn.LeakyRectify())
# out_shape == (b, num_filters, 28, 28)
model.add(nn.Convolutional(filter_size=(4, 4),
num_filters=state['d_num_filters']*2,
num_channels=state['d_num_filters'],
step=(2, 2), border_mode=(1, 1),
weight=state['d_conv_init'], use_bias=False))
model.add(nn.BatchNorm(state['d_num_filters']*2))
# model.add(nn.Expression(T.nnet.relu))
model.add(nn.LeakyRectify())
# out_shape == (b, num_filters, 14, 14)
model.add(nn.Convolutional(filter_size=(4, 4),
num_filters=state['d_num_filters']*4,
num_channels=state['d_num_filters']*2,
step=(2, 2), border_mode=(1, 1),
weight=state['d_conv_init'], use_bias=False))
model.add(nn.BatchNorm(state['d_num_filters']*4))
# model.add(nn.Expression(T.nnet.relu))
model.add(nn.LeakyRectify())
# out_shape == (b, num_filters, 7, 7)
model.add(nn.Expression(lambda x: T.flatten(x, 2)))
return model
def init_gen_model(state):
gen_model = nn.Sequential()
gen_model.add(
nn.Linear(state['noise_size'],
state['g_num_filters'] * 4 * 7 * 7,
weight=state['g_init'],
use_bias=False))
gen_model.add(nn.BatchNorm(state['g_num_filters'] * 4 * 7 * 7))
gen_model.add(nn.Expression(T.nnet.relu))
gen_model.add(
nn.Expression(lambda x: T.reshape(x, (x.shape[0], state['g_num_filters'
] * 4, 7, 7))))
gen_model.add(
nn.Deconvolutional(filter_size=(4, 4),
num_filters=state['g_num_filters'] * 4,
num_channels=state['g_num_filters'] * 2,
step=(2, 2),
border_mode=(1, 1),
use_bias=False,
weight=state['g_conv_init']))
gen_model.add(nn.BatchNorm(state['g_num_filters'] * 2))
gen_model.add(nn.Expression(T.nnet.relu))
# out_shape == (b, num_filters, 14, 14)
gen_model.add(
nn.Deconvolutional(filter_size=(4, 4),
num_filters=state['g_num_filters'] * 2,
num_channels=state['g_num_filters'],
step=(2, 2),
border_mode=(1, 1),
use_bias=False,
weight=state['g_conv_init']))
gen_model.add(nn.BatchNorm(state['g_num_filters']))
gen_model.add(nn.Expression(T.nnet.relu))
# out_shape == (b, input_channels, 28, 28)
gen_model.add(
nn.Deconvolutional(filter_size=(3, 3),
num_filters=state['g_num_filters'],
num_channels=state['input_channels'],
step=(1, 1),
border_mode=(1, 1),
use_bias=True,
weight=state['g_conv_init']))
# gen_model.add(nn.Expression(T.nnet.sigmoid))
# out_shape == (b, input_channels, 28, 28)
return gen_model
def init_encoder(state):
# inp_shape == (b, input_channels, 64, 64)
model = nn.Sequential()
model.add(
nn.Convolutional(filter_size=(4, 4),
num_filters=state['d_num_filters'],
num_channels=state['input_channels'],
step=(2, 2),
border_mode=(1, 1),
weight=state['d_conv_init'],
use_bias=False,
name='d_enc_conv1'))
model.add(nn.BatchNorm(state['d_num_filters']))
model.add(nn.LeakyRectify())
# model.add(nn.Expression(T.nnet.relu))
# out_shape == (b, d_num_filters, 32, 32)
model.add(
nn.Convolutional(filter_size=(4, 4),
num_filters=state['d_num_filters'] * 2,
num_channels=state['d_num_filters'],
step=(2, 2),
border_mode=(1, 1),
weight=state['d_conv_init'],
use_bias=False,
name='d_enc_conv2'))
model.add(nn.BatchNorm(state['d_num_filters'] * 2))
model.add(nn.LeakyRectify())
# model.add(nn.Expression(T.nnet.relu))
# out_shape == (b, d_num_filters*2, 16, 16)
model.add(
nn.Convolutional(filter_size=(4, 4),
num_filters=state['d_num_filters'] * 4,
num_channels=state['d_num_filters'] * 2,
step=(2, 2),
border_mode=(1, 1),
weight=state['d_conv_init'],
use_bias=False,
name='d_enc_conv3'))
model.add(nn.BatchNorm(state['d_num_filters'] * 4))
model.add(nn.LeakyRectify())
# model.add(nn.Expression(T.nnet.relu))
# out_shape == (b, d_num_filters*4, 8, 8)
return model
def init_gen_model(state):
gen_model = nn.Sequential()
gen_model.add(
nn.Linear(state['noise_size'],
state['hidden_size'],
weight=state['init_g']))
gen_model.add(nn.BatchNorm(state['hidden_size']))
gen_model.add(nn.Expression(T.nnet.relu))
gen_model.add(
nn.Linear(state['hidden_size'],
state['hidden_size'],
weight=state['init_g']))
gen_model.add(nn.BatchNorm(state['hidden_size']))
gen_model.add(nn.Expression(T.nnet.relu))
gen_model.add(
nn.Linear(state['hidden_size'],
state['input_size'],
weight=state['init_g']))
return gen_model
def __init__(self):
super().__init__()
self.layers = [
nn.Dense(3072, 100), # layer1
nn.BatchNorm(100),
nn.ReLU(),
nn.Dropout(0.75),
nn.Dense(100, 100), # layer2
nn.BatchNorm(100),
nn.ReLU(),
nn.Dropout(0.75),
nn.Dense(100, 100), # layer3
nn.BatchNorm(100),
nn.ReLU(),
nn.Dropout(0.75),
nn.Dense(100, 100), # layer4
nn.BatchNorm(100),
nn.ReLU(),
nn.Dropout(0.75),
nn.Dense(100, 10), # layer5
]
def init_gen_model(state):
gen_model = nn.Sequential()
gen_model.add(
nn.Linear(state['noise_size'],
state['g_num_filters'] * 4 * 4 * 4,
weight=state['g_init'],
use_bias=False))
gen_model.add(nn.BatchNorm(state['g_num_filters'] * 4 * 4 * 4))
gen_model.add(nn.Expression(T.nnet.relu))
gen_model.add(
nn.Expression(lambda x: T.reshape(x, (x.shape[0], state['g_num_filters'
] * 4, 4, 4))))
gen_model.add(
nn.Deconvolutional(filter_size=(4, 4),
num_filters=state['g_num_filters'] * 4,
num_channels=state['g_num_filters'] * 4,
step=(2, 2),
border_mode=(1, 1),
use_bias=False,
weight=state['g_conv_init']))
gen_model.add(nn.BatchNorm(state['g_num_filters'] * 4))
gen_model.add(nn.Expression(T.nnet.relu))
# out_shape == (b, g_num_filters*6, 8, 8)
gen_model.add(
nn.Deconvolutional(filter_size=(4, 4),
num_filters=state['g_num_filters'] * 4,
num_channels=state['g_num_filters'] * 2,
step=(2, 2),
border_mode=(1, 1),
use_bias=False,
weight=state['g_conv_init']))
gen_model.add(nn.BatchNorm(state['g_num_filters'] * 2))
gen_model.add(nn.Expression(T.nnet.relu))
# out_shape == (b, g_num_filters*2, 16, 16)
gen_model.add(
nn.Deconvolutional(filter_size=(4, 4),
num_filters=state['g_num_filters'] * 2,
num_channels=state['g_num_filters'],
step=(2, 2),
border_mode=(1, 1),
use_bias=False,
weight=state['g_conv_init']))
gen_model.add(nn.BatchNorm(state['g_num_filters']))
gen_model.add(nn.Expression(T.nnet.relu))
# out_shape == (b, g_num_filters, 32, 32)
gen_model.add(
nn.Deconvolutional(filter_size=(4, 4),
num_filters=state['g_num_filters'],
num_channels=state['input_channels'],
step=(2, 2),
border_mode=(1, 1),
use_bias=True,
weight=state['g_conv_init']))
gen_model.add(nn.Expression(T.tanh))
# out_shape == (b, input_channels, 64, 64)
return gen_model
def disc_shared_structure(state):
# inp_shape == (b, input_channels, 64, 64)
model = nn.Sequential()
if state['dropout'] > 0:
model.add(nn.Dropout(state['dropout']))
model.add(
nn.Convolutional(filter_size=(4, 4),
num_filters=state['d_num_filters'],
num_channels=state['input_channels'],
step=(2, 2),
border_mode=(1, 1),
weight=state['d_conv_init'],
use_bias=False,
name='d_conv1'))
model.add(nn.BatchNorm(state['d_num_filters']))
# model.add(nn.LeakyRectify())
model.add(nn.Expression(T.nnet.relu))
# out_shape == (b, num_filters, 32, 32)
model.add(
nn.Convolutional(filter_size=(4, 4),
num_filters=state['d_num_filters'] * 2,
num_channels=state['d_num_filters'],
step=(2, 2),
border_mode=(1, 1),
weight=state['d_conv_init'],
use_bias=False,
name='d_conv2'))
model.add(nn.BatchNorm(state['d_num_filters'] * 2))
# model.add(nn.LeakyRectify())
model.add(nn.Expression(T.nnet.relu))
# out_shape == (b, num_filters, 16, 16)
model.add(
nn.Convolutional(filter_size=(4, 4),
num_filters=state['d_num_filters'] * 4,
num_channels=state['d_num_filters'] * 2,
step=(2, 2),
border_mode=(1, 1),
weight=state['d_conv_init'],
use_bias=False))
model.add(nn.BatchNorm(state['d_num_filters'] * 4))
# model.add(nn.LeakyRectify())
model.add(nn.Expression(T.nnet.relu))
# out_shape == (b, num_filters, 8, 8)
model.add(
nn.Convolutional(filter_size=(4, 4),
num_filters=state['d_num_filters'] * 4,
num_channels=state['d_num_filters'] * 4,
step=(2, 2),
border_mode=(1, 1),
weight=state['d_conv_init'],
use_bias=False))
model.add(nn.BatchNorm(state['d_num_filters'] * 4))
# model.add(nn.LeakyRectify())
model.add(nn.Expression(T.nnet.relu))
# out_shape == (b, num_filters, 4, 4)
model.add(nn.Expression(lambda x: T.flatten(x, 2)))
return model
def cifar10(
path, # pylint: disable=invalid-name
conv_channels=None,
linear_layers=None,
batch_norm=True,
batch_size=128,
num_threads=4,
min_queue_examples=1000,
mode="train"):
"""Cifar10 classification with a convolutional network."""
# Data.
_maybe_download_cifar10(path)
# Read images and labels from disk.
if mode == "train":
filenames = [
os.path.join(path, CIFAR10_FOLDER, "data_batch_{}.bin".format(i))
for i in xrange(1, 6)
]
elif mode == "test":
filenames = [os.path.join(path, "test_batch.bin")]
else:
raise ValueError("Mode {} not recognised".format(mode))
depth = 3
height = 32
width = 32
label_bytes = 1
image_bytes = depth * height * width
record_bytes = label_bytes + image_bytes
reader = tf.FixedLengthRecordReader(record_bytes=record_bytes)
_, record = reader.read(tf.train.string_input_producer(filenames))
record_bytes = tf.decode_raw(record, tf.uint8)
label = tf.cast(tf.slice(record_bytes, [0], [label_bytes]), tf.int32)
raw_image = tf.slice(record_bytes, [label_bytes], [image_bytes])
image = tf.cast(tf.reshape(raw_image, [depth, height, width]), tf.float32)
# height x width x depth.
image = tf.transpose(image, [1, 2, 0])
image = tf.div(image, 255)
queue = tf.RandomShuffleQueue(
capacity=min_queue_examples + 3 * batch_size,
min_after_dequeue=min_queue_examples,
dtypes=[tf.float32, tf.int32],
shapes=[image.get_shape(), label.get_shape()])
enqueue_ops = [queue.enqueue([image, label]) for _ in xrange(num_threads)]
tf.train.add_queue_runner(tf.train.QueueRunner(queue, enqueue_ops))
# Network.
def _conv_activation(x): # pylint: disable=invalid-name
return tf.nn.max_pool(tf.nn.relu(x),
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding="SAME")
conv = nn.ConvNet2D(output_channels=conv_channels,
kernel_shapes=[5],
strides=[1],
paddings=[nn.SAME],
activation=_conv_activation,
activate_final=True,
initializers=_nn_initializers,
use_batch_norm=batch_norm)
if batch_norm:
linear_activation = lambda x: tf.nn.relu(nn.BatchNorm()(x))
else:
linear_activation = tf.nn.relu
mlp = nn.MLP(list(linear_layers) + [10],
activation=linear_activation,
initializers=_nn_initializers)
network = nn.Sequential([conv, nn.BatchFlatten(), mlp])
def build():
image_batch, label_batch = queue.dequeue_many(batch_size)
label_batch = tf.reshape(label_batch, [batch_size])
output = network(image_batch)
return _xent_loss(output, label_batch)
return build
np.random.seed(12345)
############################
# Init model & parameters
############################
# 1) Eneregy discriminator
disc_model = nn.Sequential()
disc_model.add(nn.Convolutional(filter_size=(3, 3),
num_filters=state['d_num_filters'],
num_channels=state['input_channels'],
step=(1, 1), border_mode=(1, 1),
weight=state['d_init'], use_bias=False,
name='d_conv1'))
disc_model.add(nn.BatchNorm(state['d_num_filters'], name='d_bn1'))
disc_model.add(nn.Expression(T.nnet.relu))
# out_shape == (b, num_filters, 32, 32)
disc_model.add(nn.Convolutional(filter_size=(4, 4),
num_filters=state['d_num_filters']*2,
num_channels=state['d_num_filters'],
step=(2, 2), border_mode=(1, 1),
weight=state['d_init'], use_bias=False,
name='d_conv2'))
disc_model.add(nn.BatchNorm(state['d_num_filters']*2, name='d_bn2'))
disc_model.add(nn.Expression(T.nnet.relu))
# out_shape == (b, num_filters, 16, 16)
disc_model.add(nn.Convolutional(filter_size=(4, 4),
num_filters=state['d_num_filters']*4,
