def gender(X, f, **kwargs):
nb_gender = kwargs.get('nb_gender', 4)
if f is None:
f = N.Sequence([
N.Dimshuffle(pattern=(0, 1, 2, 'x')),
N.Conv(num_filters=32,
filter_size=3,
strides=1,
b_init=None,
pad='valid'),
N.BatchNorm(activation=K.relu),
N.Pool(pool_size=2, mode='avg'),
N.Conv(num_filters=64,
filter_size=3,
strides=1,
b_init=None,
pad='valid'),
N.BatchNorm(activation=K.relu),
N.Pool(pool_size=2, mode='avg'),
N.Flatten(outdim=3),
N.Dense(num_units=512, b_init=None),
N.BatchNorm(axes=(0, 1)),
N.AutoRNN(num_units=128,
rnn_mode='gru',
num_layers=2,
input_mode='linear',
direction_mode='unidirectional'),
N.Flatten(outdim=2),
N.Dense(num_units=nb_gender, activation=K.softmax)
],
debug=True)
return f(X), f
def cnn(X, y):
nb_classes = y.shape.as_list()[-1]
with N.args_scope(['Conv', dict(b_init=None, activation=K.linear)],
['BatchNorm', dict(activation=K.relu)]):
f = N.Sequence([
N.Dimshuffle(pattern=(0, 2, 3, 1)),
N.Conv(32, (3, 3), pad='same', stride=(1, 1)),
N.BatchNorm(),
N.Conv(32, (3, 3), pad='same', stride=(1, 1),
b_init=0, activation=K.relu),
N.Pool(pool_size=(2, 2), strides=None, mode='max'),
N.Dropout(level=0.25),
#
N.Conv(64, (3, 3), pad='same', stride=(1, 1)),
N.BatchNorm(),
N.Conv(64, (3, 3), pad='same', stride=(1, 1),
b_init=0., activation=K.relu),
N.Pool(pool_size=(2, 2), strides=None, mode='max'),
N.Dropout(level=0.25),
#
N.Flatten(outdim=2),
N.Dense(512, activation=K.relu),
N.Dropout(level=0.5),
N.Dense(nb_classes, activation=K.linear)
], debug=1)
logit = f(X)
prob = tf.nn.softmax(logit)
return {'logit': logit, 'prob': prob}
def test_seq(self):
X = K.placeholder((None, 28, 28, 1))
f = N.Sequence([
N.Conv(8, (3, 3), strides=1, pad='same'),
N.Dimshuffle(pattern=(0, 3, 1, 2)),
N.Flatten(outdim=2),
N.Noise(level=0.3, noise_dims=None, noise_type='gaussian'),
N.Dense(128, activation=tf.nn.relu),
N.Dropout(level=0.3, noise_dims=None),
N.Dense(10, activation=tf.nn.softmax)
])
y = f(X)
yT = f.T(y)
f1 = K.function(X, y, defaults={K.is_training(): True})
f2 = K.function(X, yT, defaults={K.is_training(): False})
f = cPickle.loads(cPickle.dumps(f))
y = f(X)
yT = f.T(y)
f3 = K.function(X, y, defaults={K.is_training(): True})
f4 = K.function(X, yT, defaults={K.is_training(): False})
x = np.random.rand(12, 28, 28, 1)
self.assertEquals(f1(x).shape, (2688, 10))
self.assertEquals(f3(x).shape, (2688, 10))
self.assertEqual(np.round(f1(x).sum(), 4), np.round(f3(x).sum(), 4))
self.assertEquals(y.shape.as_list(), (None, 10))
self.assertEquals(f2(x).shape, (12, 28, 28, 1))
self.assertEquals(f4(x).shape, (12, 28, 28, 1))
self.assertEqual(str(f2(x).sum())[:4], str(f4(x).sum())[:4])
self.assertEquals(yT.shape.as_list(), (None, 28, 28, 1))
def test_computational_graph3(self):
# validate the number of updates found by ComputationGraph
X = K.placeholder(shape=(None, 28, 28, 3))
f = N.Sequence([
N.Conv(32, 3, pad='same', activation=K.linear),
N.BatchNorm(activation=K.relu),
N.Flatten(outdim=2),
N.Dense(16),
N.BatchNorm(),
N.Dense(10)
])
K.set_training(True)
y_train = f(X)
K.set_training(False)
y_score = f(X)
self.assertTrue(
K.get_shape(y_train) == K.get_shape(y_score)
and K.get_shape(y_score) == (None, 10))
cc_train = K.ComputationGraph(y_train)
cc_score = K.ComputationGraph(y_score)
self.assertTrue(len(cc_score.updates) == 0)
self.assertTrue(len(cc_train.updates) == 4)
# create real function
fn_train = K.function(X, y_train)
fn_score = K.function(X, y_score)
shape1 = fn_train(np.random.rand(12, 28, 28, 3)).shape
shape2 = fn_score(np.random.rand(12, 28, 28, 3)).shape
self.assertTrue(shape1 == shape2 and shape1 == (12, 10))
def odin_net2():
"CNN"
f = N.Sequence([
N.Dimshuffle((0, 1, 2, 'x')),
N.Conv(12, (3, 3), strides=(1, 1), pad='same',
untie_biases=False,
W_init=random(3, 3, 1, 12),
activation=K.relu),
N.Pool(pool_size=(2, 2), strides=None, mode='max',
ignore_border=True),
N.Conv(16, (3, 3), strides=(1, 1), pad='same',
untie_biases=False,
W_init=random(3, 3, 12, 16),
activation=K.sigmoid),
N.Dimshuffle((0, 3, 1, 2))
])
return X1, f(X1)
def test_dilatedConv(self):
x = K.placeholder((None, 28, 28, 3))
f1 = N.Conv(16, (3, 3), dilation=(2, 2))
y = f1(x)
f = K.function(x, y)
z = f(np.random.rand(12, 28, 28, 3))
self.assertEquals(z.shape, (12, 24, 24, 16))
self.assertEquals(y.shape.as_list(), [None, 24, 24, 16])
def test_conv3D(self):
x = K.placeholder((None, 28, 28, 28, 3))
f1 = N.Conv(16, (3, 3, 3), strides=1, pad='valid')
y = f1(x)
f = K.function(x, y)
z = f(np.random.rand(12, 28, 28, 28, 3))
self.assertEquals(z.shape, (12, 26, 26, 26, 16))
self.assertEquals(y.shape.as_list(), [None, 26, 26, 26, 16])
def test_conv_deconv_transpose(self):
def feval(X, y):
f = K.function(X, y)
shape = (np.random.randint(8, 18), ) + tuple(X.shape.as_list()[1:])
x = np.random.rand(*shape)
return f(x)
prog = Progbar(target=2 * 3 * 3 * 2 * 2, print_report=True)
for X in (K.placeholder(shape=(None, 13, 12, 25)),
K.placeholder(shape=(None, 13, 12, 8, 25))):
for strides in (1, 2, 3):
for filter_size in (3, 4, 5):
for num_filters in (8, 25):
for pad in ("same", "valid"):
for dilation in (1, ):
# ====== progress ====== #
prog['test'] = "#Dim:%d;Stride:%d;Filter:%d;Channel:%d;Pad:%s" % \
(X.shape.ndims, strides, filter_size, num_filters, pad)
prog.add(1)
# ====== test Conv ====== #
f = N.Conv(num_filters=num_filters,
filter_size=filter_size,
pad=pad,
strides=strides,
activation=tf.nn.relu,
dilation=dilation)
fT = f.T
y = f(X)
self.assertEqual(
feval(X, y).shape[1:],
tuple(y.shape.as_list()[1:]))
yT = fT(y)
self.assertEqual(
feval(X, yT).shape[1:],
tuple(yT.shape.as_list()[1:]))
self.assertEqual(X.shape.as_list(),
yT.shape.as_list())
# ====== test Transpose ====== #
f = N.TransposeConv(num_filters=num_filters,
filter_size=filter_size,
pad=pad,
strides=strides,
activation=K.relu,
dilation=dilation)
fT = f.T
y = f(X)
self.assertEqual(
feval(X, y).shape[1:],
tuple(y.shape.as_list()[1:]))
yT = fT(y)
self.assertEqual(
feval(X, yT).shape[1:],
tuple(yT.shape.as_list()[1:]))
self.assertEqual(X.shape.as_list(),
yT.shape.as_list())
def test_slice_ops(self):
X = K.placeholder(shape=(None, 28, 28, 28, 3))
f = N.Sequence([
N.Conv(32, 3, pad='same', activation=K.linear),
N.BatchNorm(activation=tf.nn.relu),
N.Flatten(outdim=4)[:, 8:12, 18:25, 13:],
])
y = f(X)
fn = K.function(X, y)
self.assertTrue(
fn(np.random.rand(12, 28, 28, 28, 3)).shape[1:] == tuple(
y.shape.as_list()[1:]))
self.assertEqual(y.shape.as_list()[1:], [4, 7, 883])
def test_conv2D(self):
x = K.placeholder((None, 28, 28, 3))
f1 = N.Conv(16, (3, 3), strides=(2, 2), pad='same')
y = f1(x)
f = K.function(x, y)
z = f(np.random.rand(12, 28, 28, 3))
self.assertEquals(z.shape, (12, 14, 14, 16))
self.assertEquals(y.shape.as_list(), [None, 14, 14, 16])
# ====== transpose convolution ====== #
y = f1.T(y)
f = K.function(x, y)
z = f(np.random.rand(12, 28, 28, 3))
self.assertEquals(z.shape, (12, 28, 28, 3))
self.assertEquals(y.shape.as_list(), [None, 28, 28, 3])
def test_load_save3(self):
X = K.placeholder(shape=(None, 28, 28))
ops = N.Sequence([
N.Dimshuffle(pattern=(0, 1, 2, 'x')),
N.Conv(8, (3, 3), strides=(1, 1), pad='same', activation=K.relu),
K.pool2d,
N.Flatten(outdim=2),
N.Dense(64, activation=K.relu),
N.Dense(10, activation=K.softmax)
])
y = ops(X)
f1 = K.function(X, y)
ops_ = cPickle.loads(
cPickle.dumps(ops, protocol=cPickle.HIGHEST_PROTOCOL))
y_ = ops_(X)
f2 = K.function(X, y_)
x = np.random.rand(32, 28, 28)
self.assertEqual(np.sum(f1(x) - f2(x)), 0.)
def create():
f = N.Sequence([
N.Conv(8, (3, 3), strides=1, pad='same'),
N.Dimshuffle(pattern=(0, 3, 1, 2)),
N.FlattenLeft(outdim=2),
N.Noise(level=0.3, noise_dims=None, noise_type='gaussian'),
N.Dense(128, activation=K.relu),
N.Dropout(level=0.3, noise_dims=None),
N.Dense(10, activation=K.softmax)
],
debug=True)
y = f(X)
yT = f.T(y)
f1 = K.function(X, y)
f2 = K.function(X, yT)
cPickle.dump(f, open(U.get_modelpath('dummy.ai', override=True), 'w'))
_ = f1(x)
print(_.shape, _.sum())
_ = f2(x)
print(_.shape, _.sum())
E = tk.embed(embedding)
# these numbers must be the same for all time
print('Tokenizer:', np.sum(E), np.sum(X_train), np.sum(y_train),
np.sum(X_valid), np.sum(y_valid))
# ===========================================================================
# Building model
# ===========================================================================
X = K.placeholder(shape=(None, MAX_SEQ_LEN), dtype='int32', name='X')
y = K.placeholder(shape=(None, nb_labels), dtype='float32', name='y')
f = N.Sequence([
N.Embedding(tk.nb_words, embedding_dims, W_init=E),
N.Dimshuffle(pattern=(0, 1, 'x', 2)),
N.Conv(num_filters=128,
filter_size=(5, 1),
strides=1,
pad='valid',
activation=K.relu),
N.Pool(pool_size=(5, 1), pad='valid', mode='max'),
N.Conv(num_filters=128,
filter_size=(5, 1),
strides=1,
pad='valid',
activation=K.relu),
N.Pool(pool_size=(5, 1), pad='valid', mode='max'),
N.Conv(num_filters=128,
filter_size=(5, 1),
strides=1,
pad='valid',
activation=K.relu),
N.Pool(pool_size=(35, 1), pad='valid', mode='max'),
def convolutional_vae(X, saved_states, **kwargs):
""" convolutional_vae
Return
------
[y_encoder, y_decoder]
States
------
[f_inference (encoder), f_generative (decoder)]
"""
n = kwargs.get('n', 10)
batch_size = K.get_shape(X)[0]
if batch_size is None:
raise ValueError(
"You must specify batch_size dimension for the input placeholder.")
# ====== init ====== #
if saved_states is None:
# Encoder
f_inference = N.Sequence([
N.Reshape(shape=(-1, 28, 28, 1)),
N.Conv(num_filters=32,
filter_size=3,
strides=1,
pad='valid',
b_init=init_ops.constant_initializer(0.),
activation=K.elu),
N.Conv(num_filters=64,
filter_size=5,
strides=2,
pad='same',
b_init=init_ops.constant_initializer(0.),
activation=K.elu),
N.Dropout(level=0.1),
N.Flatten(outdim=2),
N.Dense(num_units=n * 2, b_init=None),
N.BatchNorm(axes=0)
],
debug=True,
name='Encoder')
# Decoder
f_generative = N.Sequence([
N.Dimshuffle(pattern=(0, 'x', 'x', 1)),
N.TransposeConv(num_filters=64,
filter_size=3,
strides=1,
pad='valid',
b_init=init_ops.constant_initializer(0.),
activation=K.elu),
N.TransposeConv(num_filters=32,
filter_size=5,
strides=2,
pad='same',
b_init=init_ops.constant_initializer(0.),
activation=K.elu),
N.TransposeConv(num_filters=1,
filter_size=13,
strides=3,
pad='valid',
b_init=None),
N.BatchNorm(activation=K.linear),
N.Flatten(outdim=3)
],
debug=True,
name="Decoder")
else:
f_inference, f_generative = saved_states
# ====== Perfrom ====== #
# Encoder
y_encoder = f_inference(K.cast(X, 'float32'))
mu = y_encoder[:, :n]
sigma = K.softplus(y_encoder[:, n:])
qz = Normal(mu=mu, sigma=sigma, name='Normal_qz')
# Decoder
z = Normal(mu=K.zeros(shape=(batch_size, n)),
sigma=K.ones(shape=(batch_size, n)),
name="Normal_pz")
logits = f_generative(z)
X_reconstruct = Bernoulli(logits=logits)
# inference
params = f_inference.parameters + f_generative.parameters
inference = ed.KLqp(latent_vars={z: qz}, data={X_reconstruct: X})
# ====== get cost for training ====== #
# Bind p(x, z) and q(z | x) to the same placeholder for x.
if K.is_training():
import tensorflow as tf
inference.initialize()
if True:
optimizer = tf.train.AdamOptimizer(0.01, epsilon=1.0)
updates = optimizer.apply_gradients(
optimizer.compute_gradients(inference.loss, var_list=params))
init = tf.global_variables_initializer()
init.run()
f_train = K.function(X, inference.loss, updates)
else:
optimizer = tf.train.AdamOptimizer(0.01, epsilon=1.0)
inference.initialize(optimizer=optimizer, var_list=params)
init = tf.global_variables_initializer()
init.run()
f_train = lambda x: inference.update(feed_dict={X: x})['loss']
samples = K.sigmoid(logits)
return (samples, z, qz), (f_inference, f_generative)
name='X_train')
X_score = K.placeholder(shape=(None, ) + ds['X_train'].shape[1:],
name='X_score')
y = K.placeholder(shape=(None, ), name='y', dtype='int32')
# ===========================================================================
# Build model
# ===========================================================================
f = N.Sequence(
[
N.Embedding(max_features, embedding_size),
N.Dropout(0.25),
N.Dimshuffle(pattern=(0, 1, 'x', 2)), # convolution on time dimension
N.Conv(nb_filter,
filter_size=(filter_length, 1),
pad='valid',
stride=(1, 1),
activation=K.relu),
N.Pool(pool_size=(pool_length, 1), mode='max'),
N.Flatten(outdim=3),
N.Merge(
[
N.Dense(lstm_output_size, activation=K.linear,
name='ingate'), # input-gate
N.Dense(lstm_output_size,
activation=K.linear,
name='forgetgate'), # forget-gate
N.Dense(lstm_output_size,
activation=K.linear,
name='cellupdate'), # cell-update
N.Dense(lstm_output_size, activation=K.linear,
# ===========================================================================
# Create model
# ===========================================================================
inputs = [K.placeholder(shape=(None,) + shape[1:], dtype='float32', name='input%d' % i)
for i, shape in enumerate(as_tuple_of_shape(train.shape))]
X = inputs[0]
y = inputs[1]
print("Inputs:", ctext(inputs, 'cyan'))
# ====== create the networks ====== #
with N.args_scope(
[('Conv', 'Dense'), dict(b_init=None, activation=K.linear, pad='same')],
['BatchNorm', dict(activation=K.relu)]):
f = N.Sequence([
N.Dimshuffle(pattern=(0, 1, 2, 'x')),
N.Conv(num_filters=32, filter_size=(9, 7)), N.BatchNorm(),
N.Pool(pool_size=(3, 2), strides=2),
N.Conv(num_filters=64, filter_size=(5, 3)), N.BatchNorm(),
N.Pool(pool_size=(3, 1), strides=(2, 1), name='PoolOutput1'),
N.Conv(num_filters=64, filter_size=(5, 3)), N.BatchNorm(),
N.Pool(pool_size=(3, 2), strides=(2, 2), name='PoolOutput2'),
N.Flatten(outdim=2),
N.Dense(512, name="LatentDense"), N.BatchNorm(),
N.Dense(512), N.BatchNorm(),
N.Dense(n_classes)
], debug=1)
# ====== create outputs ====== #
y_logit = f(X)
train.set_recipes(recipes)
valid.set_recipes(recipes)
test.set_recipes(recipes)
# ===========================================================================
# Create model
# ===========================================================================
inputs = [
K.placeholder(shape=(None, ) + shape[1:],
dtype='float32',
name='input%d' % i) for i, shape in enumerate(train.shape)
]
print("Inputs:", ctext(inputs, 'cyan'))
# ====== create the network ====== #
f_encoder = N.Sequence([
N.Dimshuffle(pattern=(0, 1, 2, 'x')),
N.Conv(
num_filters=32, filter_size=(7, 7), b_init=None, activation=K.linear),
N.BatchNorm(),
N.Pool(pool_size=(3, 2), strides=2),
],
debug=True,
name='Encoder')
f_latent = N.Sequence([
N.Flatten(outdim=3),
N.CudnnRNN(
num_units=128, num_layers=1, is_bidirectional=False, rnn_mode='lstm'),
],
debug=True,
name='Latent')
f_decoder = N.Sequence([
N.Flatten(outdim=2),
N.Dense(num_units=1024, b_init=None, activation=K.linear),
valid_feeder.set_recipes(recipes)
print('Feature shape:', train_feeder.shape)
feat_shape = (None, ) + train_feeder.shape[1:]
X = K.placeholder(shape=feat_shape, name='X')
y = K.placeholder(shape=(None, ), dtype='int32', name='y')
# ===========================================================================
# Create network
# ===========================================================================
f = N.Sequence(
[
N.Dimshuffle(pattern=(0, 1, 2, 'x')),
N.Conv(num_filters=32,
filter_size=3,
pad='same',
strides=1,
activation=K.linear),
N.BatchNorm(activation=K.relu),
N.Conv(num_filters=64,
filter_size=3,
pad='same',
strides=1,
activation=K.linear),
N.BatchNorm(activation=K.relu),
N.Pool(pool_size=2, strides=None, pad='valid', mode='max'),
N.Flatten(outdim=3),
# ====== RNN ====== #
N.AutoRNN(128,
rnn_mode='lstm',
ds = F.CIFAR10.get_dataset()
USE_MNIST_DATA = False
print(ds)
X = K.placeholder(shape=(None, ) + ds['X_train'].shape[1:], name='X')
y = K.placeholder(shape=(None, ), name='y', dtype='int32')
y_onehot = tf.one_hot(y, depth=10)
# ===========================================================================
# Build network
# ===========================================================================
if not arg.rnn:
ops = N.Sequence([
N.Dimshuffle((0, 1, 2, 'x')) if USE_MNIST_DATA else N.Dimshuffle(
(0, 2, 3, 1)),
N.BatchNorm(axes='auto'),
N.Conv(32, (3, 3), strides=(1, 1), pad='same', activation=tf.nn.relu),
N.Pool(pool_size=(2, 2), strides=None),
N.Conv(64, (3, 3), strides=(1, 1), pad='same', activation=tf.nn.relu),
N.Pool(pool_size=(2, 2), strides=None),
N.Dropout(level=0.5),
N.Flatten(outdim=2),
N.Dense(256, activation=tf.nn.relu),
N.Dense(10, activation=K.linear)
],
debug=True)
else:
ops = N.Sequence([
N.Dimshuffle((0, 1, 2, 'x')) if USE_MNIST_DATA else N.Dimshuffle(
(0, 2, 3, 1)),
N.Conv(32, filter_size=3, strides=1, pad='same', activation=K.linear),
N.BatchNorm(axes='auto', activation=K.relu),
inputs = [
K.placeholder(shape=(None, ) + shape[1:],
dtype='float32',
name='input%d' % i)
for i, shape in enumerate(as_tuple_of_shape(train.shape))
]
X = inputs[0]
y = inputs[1]
print("Inputs:", ctext(inputs, 'cyan'))
# ====== create the networks ====== #
with N.args_scope([('Conv', 'Dense'),
dict(b_init=None, activation=K.linear, pad='same')],
['BatchNorm', dict(activation=K.relu)]):
f = N.Sequence([
N.Dimshuffle(pattern=(0, 1, 2, 'x')),
N.Conv(num_filters=32, filter_size=(9, 7)),
N.BatchNorm(),
N.Pool(pool_size=(3, 2), strides=2),
N.Conv(num_filters=64, filter_size=(5, 3)),
N.BatchNorm(),
N.Pool(pool_size=(3, 1), strides=(2, 1), name='PoolOutput1'),
N.Conv(num_filters=64, filter_size=(5, 3)),
N.BatchNorm(),
N.Pool(pool_size=(3, 2), strides=(2, 2), name='PoolOutput2'),
N.Flatten(outdim=2),
N.Dense(512, name="LatentDense"),
N.BatchNorm(),
N.Dense(512),
N.BatchNorm(),
N.Dense(n_classes)
],
ds = F.load_cifar10()
print(ds)
X_learn = ds['X_train'][:].astype('float32') / 255.
y_learn = ds['y_train']
X_test = ds['X_test'][:].astype('float32') / 255.
y_test = ds['y_test']
# ===========================================================================
# Create network
# ===========================================================================
X = K.placeholder(shape=(None, ) + X_learn.shape[1:], name='X')
y_true = K.placeholder(shape=(None, ), name='y_true', dtype='int32')
f = N.Sequence([
N.Dimshuffle(pattern=(0, 2, 3, 1)),
N.Conv(32, (3, 3), pad='same', stride=(1, 1), activation=K.relu),
N.Conv(32, (3, 3), pad='same', stride=(1, 1), activation=K.relu),
N.Pool(pool_size=(2, 2), ignore_border=True, strides=None, mode='max'),
N.Dropout(level=0.25),
N.Conv(64, (3, 3), pad='same', stride=(1, 1), activation=K.relu),
N.Conv(64, (3, 3), pad='same', stride=(1, 1), activation=K.relu),
N.Pool(pool_size=(2, 2), ignore_border=True, strides=None, mode='max'),
N.Dropout(level=0.25),
N.Flatten(outdim=2),
N.Dense(512, activation=K.relu),
N.Dropout(level=0.5),
N.Dense(10, activation=K.softmax)
],
debug=True)
K.set_training(True)
y_train = f(X)
if USE_MNIST_DATA:
ds = fuel.load_mnist()
else:
ds = fuel.load_cifar10()
print(ds)
X = K.placeholder(shape=(None, ) + ds['X_train'].shape[1:], name='X')
y = K.placeholder(shape=(None, ), name='y', dtype='int32')
# ===========================================================================
# Build network
# ===========================================================================
ops = N.Sequence([
N.Dimshuffle((0, 1, 2, 'x')) if USE_MNIST_DATA else N.Dimshuffle(
(0, 2, 3, 1)),
N.Conv(32, filter_size=3, strides=1, pad='same', activation=K.linear),
N.BatchNorm(axes='auto', activation=K.relu),
N.Pool(pool_size=2, strides=None),
N.Dimshuffle(pattern=(0, 3, 1, 2)),
N.Flatten(outdim=3),
N.CudnnRNN(18,
initial_states=None,
rnn_mode='lstm',
num_layers=2,
input_mode='linear',
direction_mode='unidirectional',
params_split=False),
N.Flatten(outdim=2),
N.Dense(128, activation=K.relu),
N.Dense(10, activation=K.softmax)
],
# ====== create basic tensor ====== #
X = K.placeholder(shape=(None,) + input_shape[1:], name='X_input')
y = K.placeholder(shape=(None,), name='y_input')
# ===========================================================================
# Create the network
# ===========================================================================
LATENT_DROPOUT = 0.3
if args.cnn:
with N.args_scope(([N.Conv, N.Dense], dict(b_init=None, activation=K.linear)),
(N.BatchNorm, dict(activation=tf.nn.elu)),
(N.Pool, dict(mode='max', pool_size=2))):
f_encoder = N.Sequence([
N.Dropout(level=0.5),
N.Dimshuffle((0, 2, 3, 1)) if is_cifar10 else N.Dimshuffle((0, 1, 2, 'x')),
N.Conv(num_filters=32, filter_size=3, pad='valid'),
N.Pool(),
N.BatchNorm(),
N.Conv(num_filters=64, filter_size=3, pad='same'),
N.BatchNorm(),
N.Conv(num_filters=64, filter_size=3, pad='valid'),
N.BatchNorm(activation=tf.nn.elu),
N.Pool(),
N.Flatten(outdim=2),
N.Dense(num_units=args.dim)
], debug=True, name='EncoderNetwork')
f_decoder = N.Sequence([
# ===========================================================================
# ODIN
# ===========================================================================
X = K.placeholder(shape=(None, ) + ds['X_train'].shape[1:],
name='X',
dtype='int32')
y = K.placeholder(shape=(None, ), name='y', dtype='int32')
net_odin = N.Sequence(
[
N.Embedding(input_size=max_features, output_size=embedding_size),
N.Dropout(level=0.25),
N.Dimshuffle(pattern=(0, 1, 'x', 2)),
N.Conv(nb_filter, (filter_length, 1),
strides=1,
pad='valid',
activation=K.relu),
N.Pool(pool_size=(pool_length, 1), pad='valid', mode='max'),
N.Flatten(outdim=3),
# ====== LSTM ====== #
N.Merge(
[
N.Dense(lstm_output_size, activation=K.linear,
name='ingate'), # input-gate
N.Dense(lstm_output_size,
activation=K.linear,
name='forgetgate'), # forget-gate
N.Dense(lstm_output_size,
activation=K.linear,
name='cellupdate'), # cell-update
N.Dense(lstm_output_size, activation=K.linear,
