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 test_batch_norm(self):
K.set_training(True)
x = K.placeholder((None, 8, 12))
y = N.BatchNorm()(x)
f = K.function(x, y)
z = f(np.random.rand(25, 8, 12))
self.assertEquals(z.shape, (25, 8, 12))
# ====== Not training ====== #
K.set_training(False)
x = K.placeholder((None, 8, 12))
y = N.BatchNorm()(x)
f = K.function(x, y)
z = f(np.random.rand(25, 8, 12))
self.assertEquals(z.shape, (25, 8, 12))
def test_dropout(self):
K.set_training(True)
x = K.placeholder((4, 6))
f1 = N.Dropout(level=0.5, noise_dims=0, rescale=True)
y = f1(x)
f = K.function(x, y)
z = f(np.ones((4, 6)))
z = z.tolist()
self.assertTrue(all(i == z[0] for i in z))
f1 = N.Dropout(level=0.5, noise_dims=1, rescale=True)
y = f1(x)
f = K.function(x, y)
z = f(np.ones((4, 6)))
z = z.T.tolist()
self.assertTrue(all(i == z[0] for i in z))
def test_noise(self):
K.set_training(True)
x = K.placeholder((2, 3))
f1 = N.Noise(level=0.5, noise_dims=0, noise_type='gaussian')
y = f1(x)
f = K.function(x, y)
z = f(np.ones((2, 3)))
z = z.tolist()
self.assertTrue(all(i == z[0] for i in z))
f1 = N.Noise(level=0.5, noise_dims=1, noise_type='gaussian')
y = f1(x)
f = K.function(x, y)
z = f(np.ones((2, 3)))
z = z.T.tolist()
self.assertTrue(all(i == z[0] for i in z))
def test_load_save2(self):
K.set_training(True)
X = K.placeholder((None, 1, 28, 28))
f = N.Dense(128, activation=K.relu)
y = f(X)
yT = f.T(y)
f1 = K.function(X, y)
f2 = K.function(X, yT)
f = cPickle.loads(cPickle.dumps(f))
y = f(X)
yT = f.T(y)
f3 = K.function(X, y)
f4 = K.function(X, yT)
x = np.random.rand(12, 1, 28, 28)
self.assertEqual(f1(x).sum(), f3(x).sum())
self.assertEqual(f2(x).sum(), f4(x).sum())
def test_load_save2(self):
K.set_training(True)
X = K.placeholder((None, 1, 28, 28))
f = N.Dense(128, activation=K.relu)
y = f(X)
yT = f.T(y)
f1 = K.function(X, y)
f2 = K.function(X, yT)
f = cPickle.loads(cPickle.dumps(f))
y = f(X)
yT = f.T(y)
f3 = K.function(X, y)
f4 = K.function(X, yT)
x = np.random.rand(12, 1, 28, 28)
self.assertEqual(f1(x).sum(), f3(x).sum())
self.assertEqual(f2(x).sum(), f4(x).sum())
def test_load_save1(self):
K.set_training(True)
X = K.placeholder((None, 1, 28, 28))
f = N.Dense(128, activation=K.relu)
y = f(X)
W, b = [K.get_value(p).sum() for p in K.ComputationGraph(y).parameters]
num_units = f.num_units
W_init = f.W_init
b_init = f.b_init
activation = f.activation
f = cPickle.loads(cPickle.dumps(f))
W1, b1 = [K.get_value(p).sum() for p in f.parameters]
num_units1 = f.num_units
W_init1 = f.W_init
b_init1 = f.b_init
activation1 = f.activation
self.assertEqual(W1, W)
self.assertEqual(b1, b)
self.assertEqual(num_units1, num_units)
self.assertEqual(W_init1.__name__, W_init.__name__)
self.assertEqual(b_init.__name__, b_init1.__name__)
self.assertEqual(activation1, activation)
def test_load_save1(self):
K.set_training(True)
X = K.placeholder((None, 1, 28, 28))
f = N.Dense(128, activation=K.relu)
y = f(X)
W, b = [K.get_value(p).sum() for p in K.ComputationGraph(y).parameters]
num_units = f.num_units
W_init = f.W_init
b_init = f.b_init
activation = f.activation
f = cPickle.loads(cPickle.dumps(f))
W1, b1 = [K.get_value(p).sum() for p in f.parameters]
num_units1 = f.num_units
W_init1 = f.W_init
b_init1 = f.b_init
activation1 = f.activation
self.assertEqual(W1, W)
self.assertEqual(b1, b)
self.assertEqual(num_units1, num_units)
self.assertEqual(W_init1.__name__, W_init.__name__)
self.assertEqual(b_init.__name__, b_init1.__name__)
self.assertEqual(activation1, activation)
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.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)
])
K.set_training(True)
y = f(X)
K.set_training(False)
yT = f.T(y)
f1 = K.function(X, y)
f2 = K.function(X, yT)
f = cPickle.loads(cPickle.dumps(f))
K.set_training(True)
y = f(X)
K.set_training(False)
yT = f.T(y)
f3 = K.function(X, y)
f4 = K.function(X, yT)
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(K.get_shape(y), (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(K.get_shape(yT), (None, 28, 28, 1))
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)
K.set_training(False)
y_pred = f(X)
cost_train = K.mean(K.categorical_crossentropy(y_train, y_true))
cost_pred = K.mean(K.categorical_accuracy(y_pred, y_true))
cost_eval = K.mean(K.categorical_crossentropy(y_pred, y_true))
parameters = f.parameters
print('Parameters:', [p.name for p in parameters])
optz = K.optimizers.RMSProp()
updates = optz.get_updates(cost_train, parameters)
print("Build training function ...")
f_train = K.function([X, y_true], cost_train, updates=updates)
from __future__ import print_function, division, absolute_import
import os
os.environ['ODIN'] = 'float32,gpu,tensorflow'
import numpy as np
from odin import nnet as N, backend as K, fuel as F
# ===========================================================================
# Data and const
# ===========================================================================
ds = F.load_mnist()
print(ds)
# ===========================================================================
# Model
# ===========================================================================
input_desc = [
N.VariableDesc(shape=(None, 28, 28), dtype='float32', name='X'),
N.VariableDesc(shape=(None,), dtype='float32', name='y')
]
model = N.get_model_descriptor('ladder1')
K.set_training(True); y_train, cost = model(input_desc)
K.set_training(False); y_score = model()
from __future__ import print_function, division, absolute_import
import os
os.environ['ODIN'] = 'theano,float32,cpu,seed=12082518'
from six.moves import cPickle
import numpy as np
from odin import backend as K
from odin import nnet as N
from odin import utils as U
np.random.seed(1208)
X = K.placeholder((None, 28, 28, 1))
x = np.random.rand(12, 28, 28, 1)
K.set_training(True)
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)
