def play_game():
game = Jogo()
dino = DinoAgent(game)
game_state = GameState(dino, game)
model = buildmodel()
try:
train_network(model, game_state)
except StopIteration:
game.end()
def calc_tf_autoencoder(model, training_data, validation_data):
import sys
sys.path.append("../../src")
import os
import datetime
import pandas as pd
# import numpy as np
from example_lorenz import get_lorenz_data
from sindy_utils import library_size
from training import train_network
import tensorflow as tf
params = get_params_tf(training_data)
num_experiments = 1
df = pd.DataFrame()
for i in range(num_experiments):
print('EXPERIMENT %d' % i)
params['coefficient_mask'] = np.ones(
(params['library_dim'], params['latent_dim']))
params['save_name'] = 'lorenz_' + datetime.datetime.now().strftime(
"%Y_%m_%d_%H_%M_%S_%f")
tf.reset_default_graph()
results_dict, params_init = train_network(training_data,
validation_data, params)
df = df.append({**results_dict, **params}, ignore_index=True)
df.to_pickle('experiment_results_' +
datetime.datetime.now().strftime("%Y%m%d%H%M") + '.pkl')
model = inplace_params(model, params_init)
return model
def nn_train_evaluate_model(
model, tr_loader, va_loader, hparameters, dtype, device, loggers=None, logdir=None):
"""
The given model is then trained and evaluated on the validation set after each
epoch, so as to implement the early stropping strategy.
Args:
model (torch.nn.Module): the model to train and evaluate;
tr_loader (DataLoader): data loader for the training set;
va_loader (DataLoader): data loader for the validation set;
hparameters (dict): a dictionary with the training hyper-parameters.
...
***TODO: Run the models multiple times with different weight initialisation.***
Returns the trained model and the history of the training/validation loss.
"""
# setting loggers verbosity for the training/evaluation step
loggers = [False] * 3 if loggers is None else [False, True, True]
(net_trained, min_loss), hist = train_network(
model, tr_loader, va_loader, hparameters=hparameters,
dtype=dtype, device=device, loggers=loggers, log_dir=logdir
)
return net_trained, min_loss, hist
opt_con = keras.optimizers.Adam
opt_params = {} # default params
loss = custom_losses.dice_loss
metric = custom_metrics.dice_coef
epochs = 10000
batch_size = 3
aug_fn_args = [(aug.no_aug, {}), (aug.flip_aug, {'flip_type': 'left-right'})]
aug_mode = 'one'
aug_probs = (0.5, 0.5)
aug_val = False
aug_fly = True
train_params = tparams.TrainingParams(model_standard,
opt_con,
opt_params,
loss,
metric,
epochs,
batch_size,
model_save_best=True,
aug_fn_args=aug_fn_args,
aug_mode=aug_mode,
aug_probs=aug_probs,
aug_val=aug_val,
aug_fly=aug_fly)
training.train_network(train_imdb, val_imdb, train_params)
# training parameters
params['epoch_size'] = training_data['x'].shape[0]
params['batch_size'] = 1024
params['learning_rate'] = 1e-4
params['data_path'] = os.getcwd() + '/'
params['print_progress'] = True
params['print_frequency'] = 100
# training time cutoffs
params['max_epochs'] = 5001
params['refinement_epochs'] = 1001
num_experiments = 10
df = pd.DataFrame()
for i in range(num_experiments):
print('EXPERIMENT %d' % i)
params['coefficient_mask'] = np.ones((params['l'], params['d']))
params['save_name'] = 'pendulum_' + datetime.datetime.now().strftime(
"%Y_%m_%d_%H_%M_%S_%f")
tf.reset_default_graph()
results_dict = train_network(training_data, validation_data, params)
df = df.append({**results_dict, **params}, ignore_index=True)
df.to_pickle('experiment_results_' +
datetime.datetime.now().strftime("%Y%m%d%H%M") + '.pkl')
b_conv2)
pool2 = tf.nn.max_pool(conv2,
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding='SAME')
# Flatten the 2nd convolution layer
pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 64])
#Variables for the hidden dense layer
W_h = tf.Variable(tf.truncated_normal([7 * 7 * 64, hidden_size], stddev=0.1))
b_h = tf.Variable(tf.constant(0.1, shape=[hidden_size]))
# Hidden layer with reLU activation function
hidden = tf.nn.relu(tf.matmul(pool2_flat, W_h) + b_h)
# Dropout
keep_prob = tf.placeholder(tf.float32)
hidden_drop = tf.nn.dropout(hidden, keep_prob)
# Variables to be tuned
W = tf.Variable(tf.truncated_normal([hidden_size, labels_size], stddev=0.1))
b = tf.Variable(tf.constant(0.1, shape=[labels_size]))
# Connect hidden to the output layer
output = tf.matmul(hidden_drop, W) + b
# Train & test the network
import training
training.train_network(training_data, labels, output, keep_prob)
params['epoch_size'] = training_data['x'].shape[0]
params['batch_size'] = 1024
params['learning_rate'] = 1e-4
params['data_path'] = os.getcwd() + '/'
params['print_progress'] = True
params['print_frequency'] = 100
# training time cutoffs
params['max_epochs'] = 5001
params['refinement_epochs'] = 1001
num_experiments = 10
df = pd.DataFrame()
for i in range(num_experiments):
print('EXPERIMENT %d' % i)
params['coefficient_mask'] = np.ones((params['l'], params['d']))
params['save_name'] = 'pendulum_' + datetime.datetime.now().strftime("%Y_%m_%d_%H_%M_%S_%f")
tf.reset_default_graph()
num_epochs, x_norm, ddx_norm, decoder_loss, decoder_sindy_loss, sindy_regularization = train_network(training_data, val_data, params)
results_dict = {'num_epochs': num_epochs, 'x_norm': x_norm,
'ddx_norm': ddx_norm, 'decoder_loss': decoder_loss,
'decoder_sindy_loss': decoder_sindy_loss, 'sindy_regularization': sindy_regularization}
df = df.append({**results_dict, **params}, ignore_index=True)
df.to_pickle('experiment_results_' + datetime.datetime.now().strftime("%Y%m%d%H%M") + '.pkl')
import tensorflow as tf
image_size = 28
labels_size = 10
hidden_size = 1024 # 1024 "neurons"
# Define placeholders
# Input tensor - flatten the matrix of pixels from the digit image
training_data = tf.placeholder(tf.float32, [None, image_size * image_size])
# Output tensor
labels = tf.placeholder(tf.float32, [None, labels_size])
# Define another dense, hidden layer
# (dense = each receives inputs from all neurons from previous layer)
W_h = tf.Variable(
tf.truncated_normal([image_size * image_size, hidden_size], stddev=0.1))
b_h = tf.Variable(tf.constant(0.1, shape=[hidden_size]))
# Hidden layer with reLU activation function
hidden = tf.nn.relu(tf.matmul(training_data, W_h) + b_h)
# Variables for the output layer
W = tf.Variable(tf.truncated_normal([hidden_size, labels_size], stddev=0.1))
b = tf.Variable(tf.constant(0.1, shape=[labels_size]))
# Connect hidden to output layer
output = tf.matmul(hidden, W) + b
# Train & test the network
training.train_network(training_data, labels, output)
def main():
parser = CommandLineParser(name='MuProver Training Client',
game=True,
replay_buffer=True)
parser.add_argument('--logdir',
type=str,
metavar='PATH',
required=False,
help='Directory for TensorBoard logging.')
parser.add_argument(
'--min_games',
type=int,
default=1,
help='Minimum number of games required to start training')
parser.add_argument(
'--saved_models',
type=str,
metavar='PATH',
required=True,
help='Path to the models/ directory served by tensorflow serving.')
parser.add_argument(
'--resume',
action='store_true',
default=False,
help=
'Set this flag to resume training from the latest checkpoint in --logdir directory.'
)
parser.add_argument(
'--freeze-representation',
action='store_true',
default=False,
help='Set this flag to prevent training of the representation network.'
)
parser.add_argument(
'--freeze-dynamics',
action='store_true',
default=False,
help='Set this flag to prevent training of the dynamics network.')
parser.add_argument(
'--freeze-prediction',
action='store_true',
default=False,
help='Set this flag to prevent training of the prediction network.')
args = parser.parse_args()
if args.min_games < args.config.training_config.batch_size:
parser.error(
f'--min_games cannot be lower than the batch size {args.config.training_config.batch_size}'
)
local_network = args.config.make_uniform_network()
optimizer = args.config.training_config.optimizer
checkpoint = tf.train.Checkpoint(network=local_network.checkpoint,
optimizer=optimizer)
checkpoint_path = os.path.join(args.logdir,
'ckpt') if args.logdir else None
checkpoint_manager = tf.train.CheckpointManager(
checkpoint, checkpoint_path, max_to_keep=None) if args.logdir else None
if args.resume:
if not checkpoint_manager:
parser.error(
'A --logdir must be specified to --resume training from a checkpoint!'
)
else:
try:
checkpoint_manager.restore_or_initialize()
except tf.errors.NotFoundError:
parser.error(
f'unable to restore checkpoint from {checkpoint_path}!')
else:
print(f'Restored checkpoint from {checkpoint_path}!')
if args.freeze_representation:
local_network.representation.trainable = False
if args.freeze_dynamics:
local_network.dynamics.trainable = False
if args.freeze_prediction:
local_network.prediction.trainable = False
writer = tf.summary.create_file_writer(
args.logdir) if args.logdir else None
if writer:
hyperparameters = args.config.hyperparameters()
with writer.as_default():
hp.hparams(hyperparameters)
tf.summary.text(name='Networks/Representation',
data=tensorboard_model_summary(
local_network.representation),
step=0)
tf.summary.text(name='Networks/Dynamics',
data=tensorboard_model_summary(
local_network.dynamics),
step=0)
tf.summary.text(name='Networks/Prediction',
data=tensorboard_model_summary(
local_network.prediction),
step=0)
tf.summary.text(name='Networks/Initial inference',
data=tensorboard_model_summary(
local_network.initial_inference_model),
step=0)
tf.summary.text(name='Networks/Recurrent inference',
data=tensorboard_model_summary(
local_network.recurrent_inference_model),
step=0)
if not os.path.isdir(args.saved_models):
parser.error(
f'--saved_models {args.saved_models} does not point to a valid directory!'
)
local_network.save_tfx_models(args.saved_models)
remote_replay_buffer = RemoteReplayBuffer(args.replay_buffer)
try:
remote_replay_buffer.stats()
except RpcError:
parser.error(
f'Unable to connect to replay buffer at {args.replay_buffer}!')
else:
print(f'Connected to replay buffer at {args.replay_buffer}!')
while remote_replay_buffer.num_games() < args.min_games:
print(
f'Waiting for {args.min_games} games to be available on the replay buffer...'
)
time.sleep(60)
train_network(config=args.config,
network=local_network,
optimizer=optimizer,
replay_buffer=remote_replay_buffer,
saved_models_path=args.saved_models,
writer=writer,
checkpoint_manager=checkpoint_manager)
def _experiment(network,
latent_dim,
datagen,
metric_loss,
reconstruction_loss,
trainX,
trainY,
testX,
testY,
keys,
mu,
dataset,
trainLabels,
testLabels,
num_iters=20000,
batch_size=64,
device='cpu'):
"""Overall loop that runs one Embenc experiment. Parameters are as follows:
Args:
network ([type]): network being evaluated.
datagen ([type]): data generator object (either PairGenerator or TripletGenerator)
metric_loss ([type]): metric loss to be applied to the latent representations.
reconstruction_loss ([type]): reconstruction loss to be applied.
trainX ([type]): training data
trainY ([type]): training labels
testX ([type]): testing data
testY ([type]): test labels
keys ([type]): mapping between numeric categories in trainY/testY to label names.
mu ([type]): balancing parameter between reconstruction and metric losses.
dataset ([type]): name of the dataset
trainLabels ([type]): labels associated with trainY, in case composite labels were used for training
testLabels ([type]): labels associated with testY, in case composite labels were used for training
Returns:
dict:
model: trained model.
latent_info: dictionary with keys [train_data, train_label, test_data, test_label, plot_df]
latent_results: dictionary with output of run_knn on latents. keys are [train_acc, test_acc,
train_conf_mat, test_conf_mat]
"""
# default optimizer: Adam.
optimizer = optim.Adam(network.parameters(), lr=0.0001)
# train model
model, total_loss, recon_loss, metric_loss = train_network(
network,
datagen,
num_iters,
metric_loss=metric_loss,
reconstruction_loss=reconstruction_loss,
optimizer=optimizer,
mu=mu,
contractive=False,
device=device)
# plot losses
plot_losses(total_loss, metric_loss, recon_loss, num_iters)
# get predictions
model.eval()
model = model.cpu()
with torch.no_grad():
latent, reconstructed = model.get_full_pass(testX)
latent_train, reconstructed_train = model.get_full_pass(trainX)
# create dictionary for latent data.
latent = latent.cpu().numpy()
latent_train = latent_train.cpu().numpy()
testLabels = testLabels.cpu().numpy()
train_labels = trainLabels.cpu().numpy()
latent_info = {
"dim": latent_dim,
"mu": mu,
"dataset": dataset,
"train_data": latent_train,
"train_labels": train_labels,
"test_data": latent,
"test_labels": testLabels,
"keys": keys
}
if latent_dim == 2:
print('latent = 2, plotting directly.')
latent_info['plot_data'] = latent
else:
print("latent dim > 2, fitting tsne...")
tsne = TSNE(n_components=2, n_iter=3000, n_jobs=-1)
print(latent.shape)
tsne_projection = tsne.fit_transform(latent)
latent_info['plot_data'] = tsne_projection
# plot reconstruction if mnist.
if dataset == 'mnist':
fig = plt.figure()
ax1 = fig.add_subplot(1, 2, 1)
ax1.imshow(testX[0].cpu().numpy().reshape(28, 28))
ax1.set_title("Original Image")
ax2 = fig.add_subplot(1, 2, 2)
np_arr = reconstructed.cpu().numpy()[0]
ax2.imshow(np_arr.reshape(28, 28))
ax2.set_title("reconstruction")
plt.show()
# plot the embedding
plot_embeddings(latent_info)
# knn on the embedding.
if torch.is_tensor(trainY):
if trainY.is_cuda:
trainY = trainY.cpu()
trainY = trainY.numpy()
latent_results = run_knn(latent_train,
trainY,
latent,
testY,
labels=list(set(testY.flatten())),
experiment_name=dataset + ' mu=' + str(mu) +
' latent=' + str(latent_dim))
if dataset == 'mnist':
label_plot(testX.cpu().numpy(), latent_info['plot_data'],
testY.cpu().numpy(), 200, mu)
results = {
"model": model,
"latent_info": latent_info,
"latent_results": latent_results
}
return results
def launch_trainer_process(config, shared_storage, replay_buffer, writer):
logging.basicConfig(filename=TRAINER_LOG_PATH,
level=logging.DEBUG,
filemode='w')
train_network(config, shared_storage, replay_buffer, writer)
