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)