def test_layer_noisy_input_bactivation(self):
input_size = 100
noise_std = 1.
input_p = tf.placeholder("float", (None, input_size))
layer = HiddenLayer(InputLayer(input_p), input_size,
weights=np.diag(np.ones(input_size, dtype=np.float32)),
bias=np.zeros(input_size, dtype=np.float32),
back_bias=np.zeros(input_size, dtype=np.float32),
session=self.session,
bactivate=True,
non_liniarity=tf.identity,
layer_noise_std=noise_std)
result_noisy = self.session.run(layer.bactivation_train,
feed_dict={
input_p: np.ones(input_size, dtype=np.float32).reshape((1, input_size))})
self.assertAlmostEqual(result_noisy.std(), noise_std, delta=noise_std / 4.,
msg="the result std should be the noise_std")
result_clean = self.session.run(layer.bactivation_predict, feed_dict={
input_p: np.ones(input_size, dtype=np.float32).reshape((1, input_size))})
self.assertAlmostEqual(result_clean.std(), 0., delta=0.1,
msg="When running in prediction mode there should be no noise in the bactivation")
def test_create_extra_weight_dimensions_fail_case(self):
output_nodes = 2
input_p = tf.placeholder("float", (None, 4))
layer = HiddenLayer(InputLayer(input_p), output_nodes, session=self.session,
weights=np.array([[10., 10.],
[10., 10.],
[10., 10.]], dtype=np.float32))
self.assertEqual(layer._weights.get_shape().as_list(), [4, 2])
def test_resize(self):
output_nodes = 10
input_p = tf.placeholder("float", (None, 10))
layer = HiddenLayer(InputLayer(input_p), output_nodes, session=self.session)
layer.resize(output_nodes + 1)
print layer._bias.get_shape()
self.assertEqual(layer.activation_predict.get_shape().as_list(), [None, output_nodes + 1])
self.assertEquals(layer.output_nodes, (output_nodes + 1,))
def test_save_load_network(self):
net1 = InputLayer(784)
net2 = HiddenLayer(net1, 20, self.session)
output_net = CategoricalOutputLayer(net2, 10, self.session)
data = output_net.get_network_pickle()
new_net = BaseLayer.load_network_from_pickle(data, self.session)
print new_net
def test_find_best_layer_size(self):
data = self.mnist_data
input_layer = InputLayer(data.features_shape)
layer = HiddenLayer(input_layer, 10, session=self.session, layer_noise_std=1.0, bactivate=False)
output = CategoricalOutputLayer(layer, data.labels_shape)
layer.find_best_size(data.train, data.test,
lambda m, d: output.evaluation_stats(d)[0] - log(output.get_parameters_all_layers()),
initial_learning_rate=0.1, tuning_learning_rate=0.1)
assert layer.get_resizable_dimension_size() > 10
def try_intermediate_layer(layer_num):
print "add layer at pos " + str(layer_num)
list(output.all_connected_layers)[layer_num].add_intermediate_layer(
lambda x: HiddenLayer(x, nodes_per_layer, session,
non_liniarity=non_liniarity,
batch_normalize_input=True))
output.train_till_convergence(data_set_collection.train, data_set_collection.validation,
learning_rate=0.0001)
output.save_checkpoints('cifar-100-layers')
print_stats(data_set_collection, output, layer_num)
output.set_network_state(state)
def test_resize_with_batch_norm_and_2_layers_resize_3(self):
input_layer = InputLayer(self.mnist_data.features_shape)
layer1 = HiddenLayer(input_layer, 2, session=self.session, batch_normalize_input=True)
layer2 = HiddenLayer(layer1, 3, session=self.session, batch_normalize_input=True)
optimizer = tf.train.AdamOptimizer()
loss = optimizer.minimize(layer2.activation_predict)
self.session.run(tf.initialize_variables(list(get_tf_optimizer_variables(optimizer))))
self.session.run(loss,
feed_dict={input_layer.input_placeholder: self.mnist_data.train.features[:3],
})
layer1.resize(4)
optimizer2 = tf.train.AdamOptimizer()
loss2 = optimizer2.minimize(layer2.activation_predict)
self.session.run(tf.initialize_variables(list(get_tf_optimizer_variables(optimizer2))))
self.session.run(loss2,
feed_dict={input_layer.input_placeholder: self.mnist_data.train.features[:3],
})
def test_weights_getter_and_setter(self):
weights_value = np.random.normal(size=(self.mnist_data.features_shape[0], 1))
input_layer = InputLayer(self.mnist_data.features_shape)
layer = HiddenLayer(input_layer, 1, session=self.session, weights=weights_value)
np.testing.assert_almost_equal(weights_value, layer.weights)
new_weights_value = np.random.normal(size=(self.mnist_data.features_shape[0], 1))
layer.weights = new_weights_value
np.testing.assert_almost_equal(new_weights_value, layer.weights)
def test_resize_with_batch_norm_and_2_layers_resize_1(self):
input_layer = InputLayer(self.mnist_data.features_shape)
layer1 = HiddenLayer(input_layer, 5, session=self.session, batch_normalize_input=True)
layer2 = HiddenLayer(layer1, 5, session=self.session, batch_normalize_input=True)
output = CategoricalOutputLayer(layer2, self.mnist_data.labels_shape, batch_normalize_input=False)
# output.train_till_convergence(self.mnist_data.train, learning_rate=0.1)
optimizer = tf.train.AdamOptimizer()
loss = optimizer.minimize(output.target_loss_op_predict)
self.session.run(tf.initialize_variables(list(get_tf_optimizer_variables(optimizer))))
self.session.run(loss,
feed_dict={output.input_placeholder: self.mnist_data.train.features[:3],
output.target_placeholder: self.mnist_data.train.labels[:3]})
layer1.resize(6)
optimizer2 = tf.train.AdamOptimizer()
loss2 = optimizer2.minimize(output.target_loss_op_predict)
self.session.run(tf.initialize_variables(list(get_tf_optimizer_variables(optimizer2))))
self.session.run(loss2,
feed_dict={output.input_placeholder: self.mnist_data.train.features[:3],
output.target_placeholder: self.mnist_data.train.labels[:3]})
def test_bug_issue_2(self):
last_layer = InputLayer((1,))
last_layer = HiddenLayer(last_layer, 2, self.session,
batch_normalize_input=True)
output = CategoricalOutputLayer(last_layer, (1,), self.session,
batch_normalize_input=True)
print output.activate_predict([[0.]])
last_layer.resize(4)
print output.activate_predict([[0.]])
def test_hessian(self):
layer = InputLayer(self.mnist_data.features_shape, layer_noise_std=1.)
layer = HiddenLayer(layer, 6, self.session,
batch_normalize_input=True)
output = CategoricalOutputLayer(layer, self.mnist_data.labels_shape, self.session,
batch_normalize_input=True)
hession_op = layer.hessien_with_respect_to_error_op
result = self.session.run(hession_op, feed_dict={output.input_placeholder:self.mnist_data.train.features,
output.target_placeholder: self.mnist_data.train.labels})
print result
def test_save_load_network_to_disk(self):
net1 = InputLayer(784)
net2 = HiddenLayer(net1, 20, self.session)
output_net = CategoricalOutputLayer(net2, 10, self.session)
data = output_net.get_network_pickle()
with open("temp", "w") as f:
f.write(data)
new_data = pickle.load(open("temp", "r"))
new_net = BaseLayer.load_network_from_state(new_data, self.session)
print new_net
def test_reshape(self):
output_nodes = 2
input_p = tf.placeholder("float", (None, 2))
layer = HiddenLayer(InputLayer(input_p), output_nodes, session=self.session,
weights=np.array([[100.0]], dtype=np.float32))
result1 = self.session.run(layer.activation_predict, feed_dict={layer.input_placeholder: [[1., 1.]]})
layer.resize(3)
result2 = self.session.run(layer.activation_predict, feed_dict={layer.input_placeholder: [[1., 1.]]})
print(result1)
print(result2)
self.assertEquals(len(result2[0]), 3)
def test_prune_layer(self):
# create layer and active in such a way that all but 1 output node is useless
self.INPUT_NODES = 3
self.OUTPUT_NODES = 1
x = np.zeros((self.INPUT_NODES, self.OUTPUT_NODES), np.float32)
for i in range(self.OUTPUT_NODES):
x[0, i - 1] = 1.0
y = np.zeros((self.OUTPUT_NODES, self.OUTPUT_NODES), np.float32)
np.fill_diagonal(y, 1.)
layer_1 = DuelStateReluLayer(InputLayer(self.INPUT_NODES), self.INPUT_NODES, session=self.session, weights=x,
width_regularizer_constant=1e-2)
layer_2 = HiddenLayer(layer_1, self.OUTPUT_NODES, weights=y, freeze=True)
trainer = CategoricalTrainer(layer_2, 0.1)
data_1 = [1.0] * self.INPUT_NODES
data_2 = [0.0] * self.INPUT_NODES
label_1 = [1.0] + [0.0] * (self.OUTPUT_NODES - 1) # only the first node is correlated with the input
label_2 = [0.0] * self.OUTPUT_NODES
inputs = [data_1, data_2]
labels = [label_1, label_2]
for i in range(500):
self.session.run([trainer._train],
feed_dict={layer_2.input_placeholder: inputs[:1],
trainer._target_placeholder: labels[:1],
trainer._learn_rate_placeholder: 0.05})
self.session.run([trainer._train],
feed_dict={layer_2.input_placeholder: inputs[1:],
trainer._target_placeholder: labels[1:],
trainer._learn_rate_placeholder: 0.05})
# layer should only have 1 active node
self.assertGreater(layer_1.width()[0], DuelStateReluLayer.ACTIVE_THRESHOLD)
self.assertEqual(layer_1.active_nodes(), 1)
activation_pre_prune = self.session.run([layer_2.activation_predict],
feed_dict={layer_1.input_placeholder: inputs})
# after pruning layer should have 2 nodes
layer_1.prune(inactive_nodes_to_leave=1)
self.assertEqual(layer_1.output_nodes, 2)
activation_post_prune = self.session.run([layer_2.activation_predict],
feed_dict={layer_1.input_placeholder: inputs})
np.testing.assert_array_almost_equal(activation_pre_prune, activation_post_prune, decimal=2)
def test_remove_layer_from_network(self):
input_layer = InputLayer(self.mnist_data.features_shape)
layer = HiddenLayer(input_layer, 10, session=self.session,
node_importance_func=node_importance_optimal_brain_damage)
output = CategoricalOutputLayer(layer, self.mnist_data.labels_shape, regularizer_weighting=0.0001)
activation = self.session.run(output.activation_predict,
feed_dict={output.input_placeholder: self.mnist_data.train.features[:1]})
layer.remove_layer_from_network()
activation = self.session.run(output.activation_predict,
feed_dict={output.input_placeholder: self.mnist_data.train.features[:1]})
self.assertEqual(output.layer_number, 1)
self.assertEqual(output.input_nodes, (784,))
def test_growing(self):
input_layer = InputLayer(self.mnist_data.features_shape)
layer = HiddenLayer(input_layer, 1, session=self.session,
node_importance_func=node_importance_optimal_brain_damage)
output = CategoricalOutputLayer(layer, self.mnist_data.labels_shape, regularizer_weighting=0.0001)
weights_hidden = layer._weights.eval()
bias_hidden = layer._bias.eval()
weights_output = output._weights.eval()
layer.resize(2)
new_weights_hidden = layer._weights.eval()
new_bias_hidden = layer._bias.eval()
new_weights_output = output._weights.eval()
np.testing.assert_almost_equal(new_weights_output[0], weights_output[0] / 2)
def test_reconstruction_of_single_input(self):
input_layer = InputLayer(1)
layer = HiddenLayer(input_layer, 1, bactivate=True, session=self.session, layer_noise_std=0.3)
cost_train = tf.reduce_mean(
tf.reduce_sum(tf.square(layer.bactivation_train - input_layer.activation_train), 1))
cost_predict = tf.reduce_mean(
tf.reduce_sum(tf.square(layer.bactivation_predict - input_layer.activation_predict), 1))
optimizer = tf.train.AdamOptimizer(0.1).minimize(cost_train)
self.session.run(tf.initialize_all_variables())
data = np.random.normal(0.5, 0.5, size=[200, 1])
for x in range(100):
self.session.run([optimizer], feed_dict={input_layer.input_placeholder: data})
result = self.session.run([cost_predict], feed_dict={input_layer.input_placeholder: data})
print result
def test_mnist(self):
data = self.mnist_data
input = InputLayer(self.MNIST_INPUT_NODES)
d_1 = DuelStateReluLayer(input, 3, width_regularizer_constant=1e-7, width_binarizer_constant=1e-10,
session=self.session)
d_2 = DuelStateReluLayer(d_1, 3, width_regularizer_constant=1e-7, width_binarizer_constant=1e-10, )
output = HiddenLayer(d_2, self.MNIST_OUTPUT_NODES)
trainer = CategoricalTrainer(output, 0.1)
end_epoch = data.train.epochs_completed + 20
while data.train.epochs_completed <= end_epoch:
train_x, train_y = data.train.next_batch(100)
trainer.train(train_x, train_y)
accuracy, cost = trainer.accuracy(data.test.features, data.test.labels)
print(accuracy, cost)
print("active nodes ", d_1.active_nodes())
self.assertGreater(accuracy, 70.)
def test_adding_hidden_layer_with_resize(self):
non_liniarity = tf.nn.relu
regularizer_coeff = None
layer = InputLayer(self.mnist_data.features_shape)
layer = HiddenLayer(layer, 100, self.session, non_liniarity=non_liniarity,
batch_normalize_input=False)
output = CategoricalOutputLayer(layer, self.mnist_data.labels_shape, self.session,
batch_normalize_input=True,
regularizer_weighting=regularizer_coeff)
output.train_till_convergence(self.mnist_data.train, self.mnist_data.validation,
learning_rate=.1)
layer.add_intermediate_cloned_layer()
layer.resize(110)
self.session.run(output.activation_predict,
feed_dict={output.input_placeholder: self.mnist_data.train.features[:3],
output.target_placeholder: self.mnist_data.train.labels[:3]})
def test_remove_unimportant_nodes_does_not_affect_test_error(self):
data = self.mnist_data
batch_normalize = False
input_layer = InputLayer(data.features_shape, drop_out_prob=None)
layer = HiddenLayer(input_layer, 800, session=self.session,
batch_normalize_input=batch_normalize,
# D.S TODO TEST
node_importance_func=node_importance_optimal_brain_damage)
output = CategoricalOutputLayer(layer, data.labels_shape, batch_normalize_input=batch_normalize)
output.train_till_convergence(data.train, data.test, learning_rate=0.001)
_, _, target_loss_before_resize = output.evaluation_stats(data.test) # Should this be on test or train?
print(target_loss_before_resize)
layer.resize(795, data_set_validation=data.test)
_, _, target_loss_after_resize = output.evaluation_stats(data.test)
print(target_loss_after_resize)
self.assertAlmostEqual(target_loss_before_resize, target_loss_after_resize, delta=10.0)
def test_bug_issue_with_state(self):
non_liniarity = tf.nn.relu
regularizer_coeff = 0.01
layer = InputLayer(self.mnist_data.features_shape, layer_noise_std=1.)
layer = HiddenLayer(layer, 6, self.session, non_liniarity=non_liniarity,
batch_normalize_input=True)
output = CategoricalOutputLayer(layer, self.mnist_data.labels_shape, self.session,
batch_normalize_input=True,
regularizer_weighting=regularizer_coeff)
state = output.get_network_state()
layer.resize(10)
output.train_till_convergence(self.mnist_data.train, self.mnist_data.validation,
learning_rate=.1)
output.set_network_state(state)
output.train_till_convergence(self.mnist_data.train, self.mnist_data.validation,
learning_rate=.1)
def test_mnist_start_large(self):
data = self.mnist_data
input_layer = InputLayer(784)
hidden_1 = DuelStateReluLayer(input_layer, 200, session=self.session, inactive_nodes_to_leave=200)
output = HiddenLayer(hidden_1, self.MNIST_OUTPUT_NODES, session=self.session)
trainer = CategoricalTrainer(output, 0.1)
end_epoch = data.train.epochs_completed + 5
print(trainer.accuracy(data.test.features, data.test.labels))
while data.train.epochs_completed <= end_epoch:
train_x, train_y = data.train.next_batch(100)
trainer.train(train_x, train_y)
accuracy, cost = trainer.accuracy(data.test.features, data.test.labels)
print(accuracy, cost)
# print(output.active_nodes())
print(hidden_1.active_nodes())
self.assertGreater(accuracy, 90.)
# self.assertEqual(output.active_nodes(), self.MNIST_OUTPUT_NODES, msg='expect all output nodes to be active')
self.assertLess(hidden_1.active_nodes(), hidden_1.output_nodes, msg='expect not all hidden nodes to be active')
node_importance_func=
node_importance_by_real_activation_from_input_layer_variance,
batch_normalize_input=True,
layer_noise_std=noise)
last_layer = MaxPoolLayer(last_layer)
if len(data_set_collection.features_shape) > 1:
last_layer = FlattenLayer(last_layer, session)
for _ in range(1):
last_layer = HiddenLayer(
last_layer,
10,
session,
non_liniarity=non_liniarity,
node_importance_func=
node_importance_by_real_activation_from_input_layer_variance,
layer_noise_std=noise,
batch_normalize_input=True)
output = CategoricalOutputLayer(
last_layer,
data_set_collection.labels_shape,
session,
batch_normalize_input=True,
loss_cross_entropy_or_log_prob=False,
layer_noise_std=noise,
regularizer_weighting=regularizer_coeff)
def get_file_root():
def main(file_name_all="pruning_tests_noise_%s-%s-%s.csv" % (LAYER_NOISE_STD, start, end), file_name_avg="pruning_tests_avg_noise_%s-%s-%s.csv" % (LAYER_NOISE_STD, start, end)):
data_set_collections = [get_mnist_data_set_collection(validation_ratio=.15),
get_cifar_100_data_set_collection(validation_ratio=.15)]
methods = [node_importance_by_dummy_activation_from_input_layer,
node_importance_by_real_activation_from_input_layer,
node_importance_by_square_sum,
node_importance_by_removal,
node_importance_random,
node_importance_optimal_brain_damage,
node_importance_full_taylor_series,
node_importance_by_real_activation_from_input_layer_variance,
node_importance_error_derrivative,
dummy_random_weights
]
final_dict = defaultdict(lambda: [])
with open(file_name_all, 'w') as result_file:
result_file.write(
'method, data_set, before_prune_train, before_prune_validation, before_prune_trest, after_prune_train, after_prune_validataion, after_prune_test, after_converge_train, after_converge_validataion, after_converge_test, converge_iterations\n')
for data in data_set_collections:
for _ in range(NUM_TRIES):
tf.reset_default_graph()
with tf.Session() as session:
input_layer = InputLayer(data.features_shape)
if len(data.features_shape) > 1:
input_layer = FlattenLayer(input_layer)
layer = HiddenLayer(input_layer, start, session=session,
layer_noise_std=LAYER_NOISE_STD,
node_importance_func=None,
non_liniarity=tf.nn.relu,
batch_normalize_input=True)
output = CategoricalOutputLayer(layer, data.labels_shape,
batch_normalize_input=True,
regularizer_weighting=0.01,
layer_noise_std=LAYER_NOISE_STD
)
output.train_till_convergence(data.train, data.validation, learning_rate=0.0001)
state = output.get_network_state()
for method in methods:
output.set_network_state(state)
layer._node_importance_func = method
_, _, target_loss_test_before_resize_test = output.evaluation_stats(data.test)
_, _, target_loss_test_before_resize_validation = output.evaluation_stats(data.validation)
_, _, target_loss_test_before_resize_train = output.evaluation_stats(data.train)
no_splitting_or_pruning = method == dummy_random_weights
layer.resize(end, data_set_train=data.train,
data_set_validation=data.validation,
no_splitting_or_pruning=no_splitting_or_pruning)
_, _, target_loss_test_after_resize_test = output.evaluation_stats(data.test)
_, _, target_loss_test_after_resize_validation = output.evaluation_stats(data.validation)
_, _, target_loss_test_after_resize_train = output.evaluation_stats(data.train)
error, iterations = output.train_till_convergence(data.train, data.validation,
learning_rate=0.0001)
_, _, after_converge_test = output.evaluation_stats(data.test)
_, _, after_converge_validation = output.evaluation_stats(data.validation)
_, _, after_converge_train = output.evaluation_stats(data.train)
final_dict[method.__name__].append((target_loss_test_before_resize_train,
target_loss_test_before_resize_validation,
target_loss_test_before_resize_test,
target_loss_test_after_resize_train,
target_loss_test_after_resize_validation,
target_loss_test_after_resize_test,
after_converge_train,
after_converge_validation,
after_converge_test))
result_file.write('%s,%s,%s,%s,%s,%s,%s,%s, %s, %s, %s, %s\n' % (
method.__name__, data.name, target_loss_test_before_resize_train,
target_loss_test_before_resize_validation,
target_loss_test_before_resize_test,
target_loss_test_after_resize_train,
target_loss_test_after_resize_validation,
target_loss_test_after_resize_test,
after_converge_train,
after_converge_validation,
after_converge_test,
iterations))
result_file.flush()
with open(file_name_avg, "w") as file_avg:
file_avg.write(
'method, before_prune_train, before_prune_validataion, before_prune_trest, after_prune_train, after_prune_validataion, after_prune_test, after_converge_train, after_converge_validataion, after_convert_test, test_diff\n')
for name, values in final_dict.iteritems():
v_len = float(len(values))
averages = tuple(sum(x[i] for x in values) / v_len for i in range(len(values[0])))
averages = averages + (averages[2] - averages[-2],)
file_avg.write('%s,%s,%s,%s,%s,%s,%s,%s, %s, %s, %s\n' % ((name,) + averages))
from tensor_dynamic.layers.input_layer import InputLayer
from tensor_dynamic.layers.hidden_layer import HiddenLayer
from tensor_dynamic.layers.max_pool_layer import MaxPoolLayer
from tensor_dynamic.layers.output_layer import OutputLayer
from tensor_dynamic.layers.binary_output_layer import BinaryOutputLayer
from tensor_dynamic.layers.categorical_output_layer import CategoricalOutputLayer
data_set_collection = get_two_spirals_data_set_collection()
with tf.Session() as session:
non_liniarity = tf.nn.tanh
regularizer_coeff = 0.001
last_layer = InputLayer(data_set_collection.features_shape, session)
last_layer = HiddenLayer(last_layer, 5, session, non_liniarity=non_liniarity)
last_layer = HiddenLayer(last_layer, 5, session, non_liniarity=non_liniarity)
last_layer = HiddenLayer(last_layer, 5, session, non_liniarity=non_liniarity)
#
# last_layer = Layer(last_layer, 300, session, non_liniarity=non_liniarity)
#
# last_layer = Layer(last_layer, 300, session, non_liniarity=non_liniarity)
#
# last_layer = Layer(last_layer, 300, session, non_liniarity=non_liniarity)
output = BinaryOutputLayer(last_layer, session, regularizer_weighting=regularizer_coeff)
output.train_till_convergence(data_set_collection.train, data_set_collection.test, learning_rate=0.0001,
continue_epochs=3)
validation_size=5000)
with tf.Session() as sess:
inputs = tf.placeholder(tf.float32, shape=(None, 784))
bactivate = True
noise_std = 0.3
beta = 0.5
gamma = 0.5
non_lin = tf.nn.sigmoid
input_layer = InputLayer(inputs)
bn1 = BatchNormLayer(input_layer, sess, beta=beta, gamma=gamma)
net1 = HiddenLayer(bn1,
1,
sess,
non_liniarity=non_lin,
bactivate=bactivate,
unsupervised_cost=.001,
noise_std=noise_std)
bn2 = BatchNormLayer(net1, sess, beta=beta, gamma=gamma)
net2 = HiddenLayer(bn2,
1,
sess,
non_liniarity=non_lin,
bactivate=bactivate,
unsupervised_cost=.001,
noise_std=noise_std)
bn3 = BatchNormLayer(net2, sess, beta=beta, gamma=gamma)
net3 = HiddenLayer(bn3,
1,
sess,
def test_create_layer(self):
output_nodes = 20
input_p = tf.placeholder("float", (None, 10))
layer = HiddenLayer(InputLayer(input_p), output_nodes, session=self.session)
self.assertEqual(layer.activation_predict.get_shape().as_list(), [None, output_nodes])
def _create_layer_for_test(self):
return HiddenLayer(self._input_layer, self.OUTPUT_NODES, session=self.session)
for _ in range(ITERATIONS):
with tf.Session() as session:
non_liniarity = tf.nn.relu
nodes_per_layer = 400
regularizer_coeff = 0.01
last_layer = InputLayer(data_set_collection.features_shape,
# drop_out_prob=.5,
# layer_noise_std=1.
)
last_layer = FlattenLayer(last_layer, session)
for _ in range(3):
last_layer = HiddenLayer(last_layer, nodes_per_layer, session, non_liniarity=non_liniarity,
layer_noise_std=NOISE,
batch_normalize_input=True)
output = CategoricalOutputLayer(last_layer, data_set_collection.labels_shape, session,
batch_normalize_input=True,
loss_cross_entropy_or_log_prob=True,
layer_noise_std=NOISE,
regularizer_weighting=regularizer_coeff)
output.train_till_convergence(data_set_collection.train, data_set_collection.validation,
learning_rate=0.0001)
state = output.get_network_state()
output.save_checkpoints('cifar-100-layers')
env = gym.make('CartPole-v0')
ACTIONS_COUNT = 2
FUTURE_REWARD_DISCOUNT = 0.9
LEARN_RATE = 0.01
STORE_SCORES_LEN = 20.
TOPOLOGY_UPDATE_EVERY_X = 50.
GAMES_PER_TRAINING = 3
INPUT_NODES = env.observation_space.shape[0]
HIDDEN_NODES = 1
session = tf.Session()
input_layer = InputLayer(INPUT_NODES, session)
hidden_layer = HiddenLayer(input_layer, HIDDEN_NODES, session)
output_layer = OutputLayer(hidden_layer, ACTIONS_COUNT, session)
best_state, best_score = output_layer.get_network_state(), -1
action_placeholder = output_layer.target_placeholder
advantage_placeholder = tf.placeholder("float", [None, 1])
policy_gradient = tf.reduce_mean(advantage_placeholder * action_placeholder *
tf.log(output_layer.activation_predict))
actor_train_operation = tf.train.AdamOptimizer(LEARN_RATE).minimize(
-policy_gradient)
scores = deque(maxlen=STORE_SCORES_LEN)
# set the first action to do nothing