def test_vae():
minibatch_size = 100
random_state = np.random.RandomState(1999)
graph = OrderedDict()
X_sym, y_sym = add_datasets_to_graph([X, y], ["X", "y"], graph)
l1_enc = relu_layer([X_sym, y_sym], graph, 'l1_enc', proj_dim=20,
random_state=random_state)
mu = linear_layer([l1_enc], graph, 'mu', proj_dim=10,
random_state=random_state)
log_sigma = linear_layer([l1_enc], graph, 'log_sigma', proj_dim=10,
random_state=random_state)
samp = gaussian_log_sample_layer([mu], [log_sigma], graph,
'gaussian_log_sample',
random_state=random_state)
l1_dec = relu_layer([samp], graph, 'l1_dec', proj_dim=20,
random_state=random_state)
out = sigmoid_layer([l1_dec], graph, 'out', proj_dim=X.shape[1],
random_state=random_state)
kl = gaussian_log_kl([mu], [log_sigma], graph, 'gaussian_kl').mean()
cost = binary_crossentropy(out, X_sym).mean() + kl
params, grads = get_params_and_grads(graph, cost)
learning_rate = 0.001
opt = sgd(params)
updates = opt.updates(params, grads, learning_rate)
train_function = theano.function([X_sym, y_sym], [cost], updates=updates,
mode="FAST_COMPILE")
iterate_function(train_function, [X, y], minibatch_size,
list_of_output_names=["cost"], n_epochs=1)
def test_gru_rnn():
# random state so script is deterministic
random_state = np.random.RandomState(1999)
# home of the computational graph
graph = OrderedDict()
# number of hidden features
n_hid = 10
# number of output_features = input_features
n_out = X.shape[-1]
# input (where first dimension is time)
datasets_list = [X, X_mask, y, y_mask]
names_list = ["X", "X_mask", "y", "y_mask"]
test_values_list = [X, X_mask, y, y_mask]
X_sym, X_mask_sym, y_sym, y_mask_sym = add_datasets_to_graph(
datasets_list, names_list, graph, list_of_test_values=test_values_list)
# Setup weights
l1 = linear_layer([X_sym], graph, 'l1_proj', n_hid, random_state)
h = gru_recurrent_layer([l1], X_mask_sym, n_hid, graph, 'l1_rec',
random_state)
# linear output activation
y_hat = linear_layer([h], graph, 'l2_proj', n_out, random_state)
# error between output and target
cost = squared_error(y_hat, y_sym)
cost = masked_cost(cost, y_mask_sym).mean()
# Parameters of the model
params, grads = get_params_and_grads(graph, cost)
# Use stochastic gradient descent to optimize
opt = sgd(params)
learning_rate = 0.01
updates = opt.updates(params, grads, learning_rate)
fit_function = theano.function([X_sym, X_mask_sym, y_sym, y_mask_sym],
[cost], updates=updates, mode="FAST_COMPILE")
iterate_function(fit_function, [X, X_mask, y, y_mask], minibatch_size,
list_of_output_names=["cost"], n_epochs=1)
def test_feedforward_classifier():
minibatch_size = 100
random_state = np.random.RandomState(1999)
graph = OrderedDict()
X_sym, y_sym = add_datasets_to_graph([X, y], ["X", "y"], graph)
l1_o = linear_layer([X_sym], graph, "l1", proj_dim=20, random_state=random_state)
y_pred = softmax_layer([l1_o], graph, "pred", n_classes, random_state=random_state)
cost = categorical_crossentropy(y_pred, y_sym).mean()
params, grads = get_params_and_grads(graph, cost)
learning_rate = 0.001
opt = sgd(params)
updates = opt.updates(params, grads, learning_rate)
train_function = theano.function([X_sym, y_sym], [cost], updates=updates, mode="FAST_COMPILE")
iterate_function(train_function, [X, y], minibatch_size, list_of_output_names=["cost"], n_epochs=1)
