def test_stacked_lstm(self):
x_train, x_test, y_train, y_test = self.data
network = algorithms.RMSProp(
[
layers.Input(self.n_time_steps),
layers.Embedding(self.n_categories, 10),
layers.LSTM(
n_units=10,
only_return_final=False,
input_weights=init.Normal(0.1),
hidden_weights=init.Normal(0.1),
),
layers.LSTM(
n_units=2,
input_weights=init.Normal(0.1),
hidden_weights=init.Normal(0.1),
),
layers.Sigmoid(1),
],
step=0.05,
verbose=False,
batch_size=1,
loss='binary_crossentropy',
)
network.train(x_train, y_train, x_test, y_test, epochs=20)
y_predicted = network.predict(x_test).round()
accuracy = (y_predicted.T == y_test).mean()
self.assertGreaterEqual(accuracy, 0.8)
def test_simple_rmsprop(self):
x_train, x_test, y_train, y_test = simple_classification()
mnet = algorithms.RMSProp(
(10, 20, 1),
step=0.02,
batch_size='full',
verbose=False,
epsilon=1e-5,
decay=0.9,
)
mnet.train(x_train, y_train, x_test, y_test, epochs=100)
self.assertGreater(0.11, mnet.validation_errors.last())
def test_simple_rmsprop(self):
x_train, _, y_train, _ = simple_classification()
mnet = algorithms.RMSProp(
(10, 20, 1),
step=.1,
batch_size='full',
verbose=False,
epsilon=1e-5,
decay=0.9,
)
mnet.train(x_train, y_train, epochs=100)
self.assertAlmostEqual(0.01, mnet.errors.last(), places=2)
def test_rmsprop(self):
x_train, x_test, y_train, y_test = simple_classification()
optimizer = algorithms.RMSProp(
self.network,
step=0.02,
batch_size=None,
verbose=False,
epsilon=1e-5,
decay=0.9,
)
optimizer.train(x_train, y_train, x_test, y_test, epochs=150)
self.assertGreater(0.15, optimizer.errors.valid[-1])
def train_lstm(self, data, **lstm_options):
x_train, x_test, y_train, y_test = data
network = algorithms.RMSProp(
[
layers.Input(self.n_time_steps),
layers.Embedding(self.n_categories, 10),
layers.LSTM(20, **lstm_options),
layers.Sigmoid(1),
],
step=0.05,
verbose=False,
batch_size=16,
error='binary_crossentropy',
)
network.train(x_train, y_train, x_test, y_test, epochs=20)
y_predicted = network.predict(x_test).round()
accuracy = (y_predicted.T == y_test).mean()
return accuracy
def select_algorithm(self, algorithm, options=None):
try:
self.network = algorithms.LevenbergMarquardt(self.layers)
opt = options
print(opt[1])
print("Wybrano optymalizator: " + str(algorithm))
except RecursionError:
print("Problem rekursji")
return None
if algorithm == 'GradientDescent':
self.network = algorithms.GradientDescent(self.layers)
if algorithm == 'LevenbergMarquardt':
self.network = algorithms.LevenbergMarquardt(connection=self.layers, mu=opt[0], mu_update_factor=opt[1])
if algorithm == 'Adam':
self.network = algorithms.Adam(self.layers)
if algorithm == 'QuasiNewton':
self.network = algorithms.QuasiNewton(self.layers)
if algorithm == 'Quickprop':
self.network = algorithms.Quickprop(self.layers)
if algorithm == 'MinibatchGradientDescent':
self.network = algorithms.MinibatchGradientDescent(self.layers)
if algorithm == 'ConjugateGradient':
self.network = algorithms.ConjugateGradient(self.layers)
if algorithm == 'Hessian':
self.network = algorithms.Hessian(self.layers)
if algorithm == 'HessianDiagonal':
self.network = algorithms.HessianDiagonal(self.layers)
if algorithm == 'Momentum':
self.network = algorithms.Momentum(self.layers)
if algorithm == 'RPROP':
self.network = algorithms.RPROP(self.layers)
if algorithm == 'IRPROPPlus':
self.network = algorithms.IRPROPPlus(self.layers)
if algorithm == 'Adadelta':
self.network = algorithms.Adadelta(self.layers)
if algorithm == 'Adagrad':
self.network = algorithms.Adagrad(self.layers)
if algorithm == 'RMSProp':
self.network = algorithms.RMSProp(self.layers)
if algorithm == 'Adamax':
self.network = algorithms.Adamax(self.layers)
def test_stacked_gru(self):
x_train, x_test, y_train, y_test = self.data
network = algorithms.RMSProp(
[
layers.Input(self.n_time_steps),
layers.Embedding(self.n_categories, 10),
layers.GRU(10, only_return_final=False),
layers.GRU(1),
layers.Sigmoid(1),
],
step=0.01,
verbose=False,
batch_size=1,
loss='binary_crossentropy',
)
network.train(x_train, y_train, x_test, y_test, epochs=10)
y_predicted = network.predict(x_test).round()
accuracy = (y_predicted.T == y_test).mean()
self.assertGreaterEqual(accuracy, 0.8)
def test_gru_with_4d_input(self):
x_train, x_test, y_train, y_test = self.data
network = algorithms.RMSProp(
[
layers.Input(self.n_time_steps),
layers.Embedding(self.n_categories, 10),
# Make 4D input
layers.Reshape((self.n_time_steps, 5, 2), name='reshape'),
layers.GRU(10),
layers.Sigmoid(1),
],
step=0.1,
verbose=False,
batch_size=1,
error='binary_crossentropy',
)
network.train(x_train, y_train, x_test, y_test, epochs=2)
reshape = network.connection.end('reshape')
# +1 for batch size
output_dimension = len(reshape.output_shape) + 1
self.assertEqual(4, output_dimension)
def train_network(parameters):
print("Parameters:")
pprint(parameters)
print()
step = parameters['step']
batch_size = int(parameters['batch_size'])
proba = parameters['dropout']
activation_layer = parameters['act_func_type']
layer_sizes = [int(n) for n in parameters['layers']['n_units_layer']]
network = layers.Input(784)
for layer_size in layer_sizes:
network = network > activation_layer(layer_size)
network = network > layers.Dropout(proba) > layers.Softmax(10)
mnet = algorithms.RMSProp(
network,
batch_size=batch_size,
step=step,
error='categorical_crossentropy',
shuffle_data=True,
epoch_end_signal=on_epoch_end,
)
mnet.train(x_train, y_train, epochs=50)
score = mnet.prediction_error(x_test, y_test)
y_predicted = mnet.predict(x_test).argmax(axis=1)
accuracy = metrics.accuracy_score(y_test.argmax(axis=1), y_predicted)
print("Final score: {}".format(score))
print("Accuracy: {:.2%}".format(accuracy))
return score
def on_epoch_end(network):
if network.errors.last() > 10:
raise StopTraining("Training was interrupted. Error is to high.")
mnet = algorithms.RMSProp(
network,
batch_size=batch_size,
step=step,
error='categorical_crossentropy',
shuffle_data=True,
epoch_end_signal=on_epoch_end,
)
mnet.train(x_train, y_train, epochs=50)
score = mnet.prediction_error(x_test, y_test)
y_predicted = mnet.predict(x_test).argmax(axis=1)
accuracy = metrics.accuracy_score(y_test.argmax(axis=1), y_predicted)
print("Final score: {}".format(score))
print("Accuracy: {:.2%}".format(accuracy))
return score
def test_stacked_gru_with_enabled_backwards_option(self):
x_train, x_test, y_train, y_test = self.data
x_train = x_train[:, ::-1]
x_test = x_test[:, ::-1]
network = algorithms.RMSProp(
[
layers.Input(self.n_time_steps),
layers.Embedding(self.n_categories, 10),
layers.GRU(10, only_return_final=False, backwards=True),
layers.GRU(2, backwards=True),
layers.Sigmoid(1),
],
step=0.1,
verbose=False,
batch_size=1,
error='binary_crossentropy',
)
network.train(x_train, y_train, x_test, y_test, epochs=20)
y_predicted = network.predict(x_test).round()
accuracy = (y_predicted.T == y_test).mean()
self.assertGreaterEqual(accuracy, 0.9)
x_train, x_test, y_train, y_test = train_test_split(data,
labels,
train_size=0.8)
n_categories = len(reber.avaliable_letters) + 1 # +1 for zero paddings
n_time_steps = x_train.shape[1]
network = algorithms.RMSProp(
[
layers.Input(n_time_steps),
# shape: (n_samples, n_time_steps)
layers.Embedding(n_categories, 10),
# shape: (n_samples, n_time_steps, 10)
# unroll_scan - speed up calculation for short sequences
layers.GRU(20, unroll_scan=True),
# shape: (n_samples, 20)
layers.Sigmoid(1),
# shape: (n_samples, 1)
],
step=0.05,
verbose=True,
batch_size=64,
error='binary_crossentropy',
)
network.train(x_train, y_train, x_test, y_test, epochs=20)
y_predicted = network.predict(x_test).round()
accuracy = (y_predicted.T == y_test).mean()
print("Test accuracy: {:.2%}".format(accuracy))
if __name__ == '__main__':
window_size = 40
print("Loading Shakespeare's text ...")
preprocessor = TextPreprocessing(filepath=TEXT_FILE)
n_characters = preprocessor.n_characters
x_train, x_test, y_train, y_test = preprocessor.load_samples(
window_size, stride=10)
network = algorithms.RMSProp(
[
layers.Input((window_size, n_characters)),
layers.LSTM(128),
layers.Softmax(n_characters),
],
step=0.01,
verbose=True,
batch_size=128,
loss='categorical_crossentropy',
)
network.train(x_train, y_train, x_test, y_test, epochs=10)
# Number of symbols that will be generated
n_new_symbols = 1000
# Which samples to use from the test data
test_sample_id = 0
test_sample = x_test[test_sample_id]
int_sequence = list(test_sample.argmax(axis=1))
x_train, s1_train, s2_train, y_train = load_data(env['train_data_file'])
x_test, s1_test, s2_test, y_test = load_data(env['test_data_file'])
print("Initializing VIN...")
network = algorithms.RMSProp(
create_VIN(
env['input_image_shape'],
n_hidden_filters=150,
n_state_filters=10,
k=env['k'],
),
verbose=True,
# Loss function applies categorical cross entropy
# in a bit more efficient way.
loss=loss_function,
# Shape of the target value might be different compare to the
# expected shape of the output. Without this change network will
# assume that target shape will be the same as network's output
# shape, which is (None, 8)
target=tf.placeholder(tf.float32, shape=(None, None)),
# Signal will ensure that step (learning rate) will be reduced
# after certain number of iterations
signals=on_epoch_end_from_steps(env['steps']),
**env['training_options'])
print("Training VIN...")
network.train(
(x_train, s1_train, s2_train),
args = parser.parse_args()
env = environments[args.imsize]
x_train, s1_train, s2_train, y_train = load_data(env['train_data_file'])
x_test, s1_test, s2_test, y_test = load_data(env['test_data_file'])
network = algorithms.RMSProp(
create_VIN(
env['input_image_shape'],
n_hidden_filters=150,
n_state_filters=10,
k=env['k'],
),
step=0.01,
verbose=True,
batch_size=12,
error=loss_function,
epoch_end_signal=on_epoch_end,
decay=0.9,
epsilon=1e-6,
)
network.train((x_train, s1_train, s2_train), y_train,
(x_test, s1_test, s2_test), y_test,
epochs=120)
if not os.path.exists(MODELS_DIR):
os.mkdir(MODELS_DIR)
'--pretrained',
dest='use_pretrained',
action='store_true',
help='load pretrained network from file and play without training')
args = parser.parse_args()
network = algorithms.RMSProp(
[
layers.Input(4),
layers.Relu(64),
layers.Relu(48),
layers.Relu(32),
layers.Relu(64) > layers.Dropout(0.2),
# Expecting two different actions:
# 1. Move left
# 2. Move right
layers.Linear(2),
],
step=0.001,
error='rmse',
batch_size=100,
decay_rate=0.1,
addons=[algorithms.WeightDecay],
)
env = gym.make('CartPole-v0')
env.seed(0) # To make results reproducible for the gym
memory_size = 1000 # Number of samples stored in the memory
memory = deque(maxlen=memory_size)
],
[
0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1,
0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
1, 0, 0, 0, 0, 0, 0, 0, 0, 0
],
[
0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0,
0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1,
1, 0, 0, 0, 0, 0, 0, 0, 0, 0
]])
y_train = np.array([1, 0, 2, 3])
normalizer = max(y_train)
y_train_normalized = y_train / normalizer
network = algorithms.RMSProp(
[
layers.Input(64),
layers.Sigmoid(2),
layers.Sigmoid(1),
],
step=0.1,
)
network.train(x_train, y_train_normalized, epochs=10000)
with open('network.pickle', 'wb') as f:
pickle.dump(network, f)
# Construct Variational Autoencoder
encoder = layers.Input(784) > layers.Tanh(500)
mu = layers.Linear(2, name='mu')
sigma = layers.Linear(2, name='sigma')
sampler = [mu, sigma] > GaussianSample()
decoder = layers.Tanh(500) > layers.Sigmoid(784)
# Train network
network = algorithms.RMSProp(
encoder > sampler > decoder,
error=vae_loss,
batch_size=128,
shuffle_data=True,
step=0.001,
verbose=True,
decay_rate=0.01,
addons=[algorithms.WeightDecay],
)
x_train, x_test = load_data()
network.train(x_train, x_train, x_test, x_test, epochs=50)
# Sample digits from the obtained distribution
generator = algorithms.GradientDescent(layers.Input(2) > decoder)
generate_and_plot_sampels(generator, 20, 20)
Linear(2, name='mu') >> Collect('mu'),
Linear(2, name='sigma') >> Collect('sigma'),
),
GaussianSample(),
# Decoder
# Note: Identity layer acts as a reference. Using it
# we can easily cut the decoder from the network
Identity('decoder'),
Tanh(256),
Sigmoid(784),
)
# Train network
optimizer = algorithms.RMSProp(
network,
loss=vae_loss,
regularizer=algorithms.l2(0.001),
batch_size=128,
shuffle_data=True,
step=0.001,
verbose=True,
)
x_train, x_test = load_data()
optimizer.train(x_train, x_train, x_test, x_test, epochs=50)
# Sample digits from the obtained distribution
generator = Input(2) >> network.start('decoder')
generate_and_plot_sampels(generator, 15, 15)
if __name__ == '__main__':
args = parser.parse_args()
env = environments[args.imsize]
print("Loading train and test data...")
x_train, s1_train, s2_train, y_train = load_data(env['train_data_file'])
x_test, s1_test, s2_test, y_test = load_data(env['test_data_file'])
print("Initializing VIN...")
network = algorithms.RMSProp(
create_VIN(
env['input_image_shape'],
n_hidden_filters=150,
n_state_filters=10,
k=env['k'],
),
verbose=True,
error=loss_function,
epoch_end_signal=on_epoch_end_from_steps(env['steps']),
**env['training_options']
)
print("Training VIN...")
network.train(
(x_train, s1_train, s2_train), y_train,
(x_test, s1_test, s2_test), y_test,
epochs=env['epochs'],
)
if not os.path.exists(MODELS_DIR):
'-p',
'--pretrained',
dest='use_pretrained',
action='store_true',
help='load pretrained network from file and play without training',
)
args = parser.parse_args()
network = algorithms.RMSProp(
[
layers.Input(4),
layers.Relu(64),
layers.Relu(48),
layers.Relu(32),
layers.Relu(64) > layers.Dropout(0.2),
# Expecting two different actions:
# 1. Move left
# 2. Move right
layers.Linear(2),
],
step=0.0005,
error='rmse',
batch_size='full',
verbose=False)
env = gym.make('CartPole-v0')
env.seed(0) # To make results reproducible for the gym
memory_size = 1000 # Number of samples stored in the memory
memory = deque(maxlen=memory_size)
