def fit(self, x_train, y_train, batch_size=32, epochs=100, validation_data=None, class_weight=None): history = self.model.fit(x=x_train, y=y_train, batch_size=batch_size, epochs=epochs, callbacks=self.callback_list, validation_data=validation_data) utils.plot_metrics(history.history)
def main(epochs, load_data, opt_adam, lr, weight_decay, read_from_saved, read_from_file, force_cpu, nosave): if force_cpu: device = torch.device("cpu") else: device = torch.device("cuda" if torch.cuda.is_available() else "cpu") dtype = torch.float print("Running on:", device) if read_from_file is not None: network = SNN.from_file(read_from_file) elif read_from_saved: network = SNN.from_file('logs/save_network.net', device=device, dtype=dtype) else: network = SNN.from_last_checkpoint(device=device, dtype=dtype) network.time_expector = time_expector # network.notifier = notify # FIXME if opt_adam: opt = RAdam(network.get_trainable_parameters(lr, weight_decay)) else: opt = torch.optim.SGD(network.get_trainable_parameters( lr, weight_decay), lr=lr, momentum=0.9) if not nosave: with open('logs/results.log', 'a+') as f: res_metrics = network.fit(load_data, epochs=epochs, optimizer=opt, result_file=f, save_checkpoints=True) else: res_metrics = network.fit(load_data, epochs=epochs, optimizer=opt, save_checkpoints=False) plot_metrics(res_metrics, save_plot_path=None if nosave else './logs/metrics_C_') if not nosave: network.save('logs/save_network.net')
def run_modelpat(train_generatorp, test_generatorp, val_generatorp): adam = Adam(lr=3e-5) #randomly shuffling training data #X_train , y_train = shuffle(X_train , y_train) scores = [] print("current running model is model pat ") model = make_unet(img_shape) #model.load_weights('/tmp/weights25th_logging'+str(i)+'.hdf5') model.compile(optimizer=adam, loss=soft_dice_loss, metrics=[dice_coeff, 'acc', sp, sn]) model.summary() save_model_path = 'Other/unetartery.hdf5' earlystopper = EarlyStopping(patience=15, verbose=1) cp = ModelCheckpoint(filepath=save_model_path, monitor='val_loss', save_best_only=True, verbose=1) history = model.fit_generator( train_generatorp, steps_per_epoch=90, epochs=200, validation_data=val_generatorp, validation_steps=25, callbacks=[cp, earlystopper]) # , #earlystopper])#,tensorboard_callback]) scores.append( model.evaluate_generator(test_generatorp, steps=12, workers=1, verbose=1)) save_all(model, 25) plot_metrics(history, 25) print("finished model ") #model.reset_states() return scores, model
def train_and_test_model(model, save_dir, data_loader, learning_rate=0.01, epochs=2, gpu=False, plot=False): # initialize weights and biases for layer in iter(model.classifier.children()): if len(layer.state_dict()) > 0: layer.bias.data.fill_(0) layer.weight.data.normal_(std=0.01) # freeze vgg's parameters so that we can initialize the last layer's weights for param in model.parameters(): param.requires_grad = False # enable training the classifier with the new output for param in model.classifier[-1].parameters(): param.requires_grad_() best_acc_epoch = 0 best_acc = 0.0 avg_loss_val = 0 avg_acc_val = 0 train_losses = [] train_accuracy = [] valid_losses = [] valid_accuracy = [] best_model_wts = copy.deepcopy(model.state_dict()) print("TRAINING MODEL with following parameters") print("\tsave_dir (for checkpoints):", save_dir) print("\tlearning_rate:", learning_rate) print("\tepochs:", epochs) print("\tgpu:", gpu) if gpu and not torch.cuda.is_available(): print("Sorry, no cuda enabled gpu is available.") print("Training on the cpu...") gpu = False if gpu: model.cuda() criterion = nn.CrossEntropyLoss() optimizer_ft = optim.SGD(model.classifier[-1].parameters(), lr=0.01, momentum=0.9) since = time.time() for e in range(epochs): for phase in ['train', 'valid']: correct = 0 running_loss = 0 for inputs,labels in data_loader[phase]: batch_loss, batch_correct = run_batch(phase, gpu, inputs, labels, optimizer_ft, model, criterion) running_loss += batch_loss # loss.item() # for computing accuracy correct += batch_correct # torch.sum(preds == labels.data) # free gpu resources torch.cuda.empty_cache() epoch_acc = float(correct) / float(dataset_sizes[phase]) if phase == "train": train_losses.append(running_loss) train_accuracy.append(epoch_acc) else: # "valid" valid_losses.append(running_loss) valid_accuracy.append(epoch_acc) if epoch_acc > best_acc: best_acc = epoch_acc best_acc_epoch = e best_model_wts = copy.deepcopy(model.state_dict()) print("Epoch {}: {}\n\tTotal Loss: {:4f}\n\tAccuracy: {:d}/{:d} = {:4f}\n".format( e, phase.upper(), running_loss, correct, dataset_sizes[phase], epoch_acc)) time_elapsed = time.time() - since print('Training complete in {:.0f}m {:.0f}s'.format(time_elapsed // 60, time_elapsed % 60)) print("Best Accuracy: {} in epoch {}".format(round(best_acc, 3), best_acc_epoch)) if plot: utils.plot_metrics(train_losses, valid_losses, train_accuracy, valid_accuracy, e) # Test data phase = 'test' correct = 0 for inputs,labels in data_loader[phase]: batch_loss, batch_correct = run_batch(phase, gpu, inputs, labels, optimizer_ft, model, criterion) running_loss += batch_loss # for computing accuracy correct += batch_correct # free gpu resources torch.cuda.empty_cache() test_acc = float(correct) / float(dataset_sizes[phase]) print("{}\nTotal Loss: {:4f}\nAccuracy: {:d}/{:d} = {:4f}".format(phase.upper(), running_loss, correct, dataset_sizes[phase], test_acc)) return model, optimizer_ft, e
def train(self, X_train, Y_train, X_val, Y_val, max_epochs, batch_size, learning_rate_init, reg_param=0, learning_rate_decay_type='inverse', learning_rate_decay_parameter=10, early_stopping=True, save_path='./UNet', reset_parameters=False, check_val_every_n_batches=5, seed=0, data_on_GPU=True): ''' Trains the network on the given data, provided as numpy arrays. It is assumed all preprocessing has already been done, including shuffling and splitting of the data into training/validation sets. ''' # (Re)load base graph from file print('Loading graph...') saver = self.load_graph(save_path) with self.G.as_default(): print('Inserting data augmentation operations...') # Load data onto GPU, replace the input placeholder with an index into the data on the GPU (if applicable) m_train, height, width, n_channels = X_train.shape m_val = X_val.shape[0] m = m_train + m_val n_classes = Y_train.shape[-1] if data_on_GPU: X_train_t = tf.constant(X_train, dtype=tf.uint8) X_val_t = tf.constant(X_val, dtype=tf.uint8) Y_train_t = tf.constant(Y_train, dtype=tf.bool) Y_val_t = tf.constant(Y_val, dtype=tf.bool) del X_train, X_val, Y_train, Y_val train_idx = tf.placeholder_with_default([0], shape=[None]) X_train_t = tf.gather(X_train_t, train_idx, axis=0) Y_train_t = tf.gather(Y_train_t, train_idx, axis=0) else: X_train_t = tf.placeholder_with_default(np.zeros( [0, height, width, n_channels], dtype=np.uint8), shape=self.input.shape, name='X_train_input') X_val_t = tf.placeholder_with_default(np.zeros( [0, height, width, n_channels], dtype=np.uint8), shape=self.input.shape, name='X_val_input') Y_train_t = tf.placeholder_with_default( np.zeros([0, height, width, n_classes], dtype=np.bool), shape=self.labels.shape, name='Y_train_input') Y_val_t = tf.placeholder_with_default(np.zeros( [0, height, width, n_classes], dtype=np.bool), shape=self.labels.shape, name='Y_val_input') # Insert data augmentation steps to graph train_or_val_idx = tf.placeholder(dtype=tf.int32, shape=[None]) X_train_aug, Y_train_aug = self.data_augmentation( X_train_t, Y_train_t) X = tf.cast( tf.gather(tf.concat([X_train_aug, X_val_t], axis=0), train_or_val_idx), tf.float32) Y = tf.cast( tf.gather(tf.concat([Y_train_aug, Y_val_t], axis=0), train_or_val_idx), tf.float32) ge.swap_ts([X, Y], [self.input, self.labels]) # Use X and Y from now on! # Write to log file with open(str(save_path) + '.log', 'w+') as fo: fo.write('Training log\n\n') fo.write('Dataset metrics:\n') fo.write('Training data shape: {}\n'.format(X_train.shape)) fo.write('Validation set size: {}\n'.format(m_val)) # fo.write('X_mean: {}\n'.format(X_mean)) # fo.write('X_std: {}\n\n'.format(X_std)) fo.write('Hyperparameters:\n') fo.write('Batch size: {}\n'.format(batch_size)) fo.write('Learning rate: {}\n'.format(learning_rate_init)) fo.write('Learning rate annealed every N epochs: {}\n'.format( learning_rate_decay_parameter)) fo.write('Learning rate anneal type: {}\n'.format( learning_rate_decay_type)) # fo.write('Stepped anneal: {}\n'.format(STEPPED_ANNEAL)) # fo.write('Regularization type: {}\n'.format(REGULARIZATION_TYPE)) fo.write('Regularization parameter: {}\n'.format(reg_param)) # fo.write('Input noise variance: {:.2f}\n'.format(INPUT_NOISE_MAGNITUDE**2)) # fo.write('Weight noise variance: {:.2f}\n'.format(WEIGHT_NOISE_MAGNITUDE**2)) # for n in range(1,len(KEEP_PROB)+1): # fo.write('Dropout keep prob. group {}: {:.2f}\n'.format(n, KEEP_PROB[n])) fo.write('Logging frequency: {} global steps\n'.format( check_val_every_n_batches)) fo.write('Random seed: {}\n'.format(seed)) # Initialize control flow variables and logs # max_val_accuracy = -1 # max_val_conf = -1 best_val_loss = np.inf global_step = 0 # with open(str(save_path)+'_val_accuracy.log', 'w+') as fo: # fo.write('') with open(str(save_path) + '_val_loss.log', 'w+') as fo: fo.write('') # with open(str(save_path)+'_val_confidence.log', 'w+') as fo: # fo.write('') # with open(str(save_path)+'_train_accuracy.log', 'w+') as fo: # fo.write('') with open(str(save_path) + '_train_loss.log', 'w+') as fo: fo.write('') # with open(str(save_path)+'_train_confidence.log', 'w+') as fo: # fo.write('') with open(str(save_path) + '_learning_rate.log', 'w+') as fo: fo.write('') # Start tensorflow session, reset_parameters or reload checkpoint print('Starting tensorflow session...') with tf.Session() as sess: if reset_parameters: saver = tf.train.Saver() sess.run(tf.global_variables_initializer()) else: saver.restore(sess, save_path) uninitialized_vars = [] for var in tf.global_variables(): try: sess.run(var) except tf.errors.FailedPreconditionError: uninitialized_vars.append(var) sess.run(tf.variables_initializer(uninitialized_vars)) # Iterate over training epochs best_val_loss = np.inf for epoch in range(max_epochs): if learning_rate_decay_type == 'inverse': learning_rate = learning_rate_init / ( 1 + epoch / learning_rate_decay_parameter) elif learning_rate_decay_type == 'constant': learning_rate = learning_rate_init elif learning_rate_decay_type == 'exponential': learning_rate = learning_rate_init * np.exp( -epoch / learning_rate_decay_parameter) else: raise Exception('Unknown learning rate decay function') # Iterate over batches: n_batches = math.ceil(m_train / batch_size) for b in range(n_batches): train_idx_i = b * batch_size train_idx_f = min((b + 1) * batch_size, m_train) if data_on_GPU: feed_dict = { train_idx: range(train_idx_i, train_idx_f + 1), train_or_val_idx: range(train_idx_f - train_idx_i), self.learning_rate: learning_rate, self.reg_param: reg_param } else: feed_dict = { X_train_t: X_train[train_idx_i:train_idx_f], Y_train_t: Y_train[train_idx_i:train_idx_f], train_or_val_idx: range(train_idx_f - train_idx_i), self.learning_rate: learning_rate, self.reg_param: reg_param } train_loss, _ = sess.run([self.loss, self.train_op], feed_dict=feed_dict) print('Epoch {}, batch {}/{}: loss={:.3e}'.format( epoch + 1, b, n_batches, train_loss)) if np.isnan(train_loss) or np.isinf(train_loss): print('Detected nan, exiting training') quit() exit() break if (global_step % check_val_every_n_batches) == 0: if data_on_GPU: feed_dict = { train_or_val_idx: range(1, m_val + 1), self.reg_param: reg_param } else: feed_dict = { X_val_t: X_val, Y_val_t: Y_val, train_or_val_idx: range(m_val), self.reg_param: reg_param } val_loss = sess.run(self.loss, feed_dict=feed_dict) if early_stopping and (val_loss < best_val_loss): best_val_loss = val_loss print( 'New best validation loss: {:.3e}! Saving...' .format(val_loss)) saver.save(sess, save_path, write_meta_graph=False) # Write to logs everytime validation set run with open(str(save_path) + '_train_loss.log', 'a') as fo: fo.write(str(train_loss) + '\n') # with open(str(save_path)+'_train_accuracy.log', 'a') as fo: # fo.write(str(train_accuracy)+'\n') # with open(str(save_path)+'_train_confidence.log', 'a') as fo: # fo.write(str(train_conf)+'\n') # with open(str(save_path)+'_val_accuracy.log', 'a') as fo: # fo.write(str(val_accuracy)+'\n') with open(str(save_path) + '_val_loss.log', 'a') as fo: fo.write(str(val_loss) + '\n') # with open(str(save_path)+'_val_confidence.log', 'a') as fo: # fo.write(str(val_conf)+'\n') with open( str(save_path) + '_learning_rate.log', 'a') as fo: fo.write(str(learning_rate) + '\n') u.plot_metrics(str(save_path)) global_step += 1
logger.add_scalar(epoch, 'train.loss', train_loss) logger.add_scalar(epoch, 'val.loss', val_loss) logger.add_scalar(epoch, 'train.acc', train_acc) logger.add_scalar(epoch, 'val.acc', val_acc) if args.odenet: logger.add_scalar(epoch, 'train.forward_nfe', train_forward_nfe.avg) logger.add_scalar(epoch, 'train.backward_nfe', train_backward_nfe.avg) logger.add_scalar(epoch, 'val.forward_nfe', val_nfe) logger.add_scalar(epoch, 'time', time.time() - t0) t0 = time.time() logger.iter_info() logger.save() if epoch % args.vis_each == 0 or epoch == 1 or epoch == args.epochs: utils.plot_metrics(logger.scalar_metrics, args.odenet) plt.savefig(os.path.join(args.root, 'training_curves.png')) plt.close() torch.save(model.state_dict(), os.path.join(args.root, 'model_final.torch')) torch.save(optimizer.state_dict(), os.path.join(args.root, 'optimizer_final.torch')) if args.verbose: print(model) for param in model.named_parameters(): print(param) parser.done()
def main(): st.title("Binary Classification Web App") st.sidebar.title("Binary Classification Web App") st.markdown("Are your mushrooms edible or poisonous? 🍄") st.sidebar.markdown("Are your mushrooms edible or poisonous? 🍄") df = utils.load_data() x_train, x_test, y_train, y_test = utils.split(df) class_names = ["edible", "poisonous"] st.sidebar.subheader("Choose Classifier") classifier = st.sidebar.selectbox( "Classifier", ("Support Vector Machine (SVM)", "Logistic Regression", "Random Forest Classification")) if classifier == 'Support Vector Machine (SVM)': st.sidebar.subheader("Model Hyperparameters") C = st.sidebar.number_input("C (Regularization parameter)", 0.01, 10.0, step=0.01, key='C') kernel = st.sidebar.radio("Kernel", ("rbf", "linear"), key='kernel') gamma = st.sidebar.radio("Gamma (Kernel Coefficient)", ("scale", "auto"), key='gamma') metrics = st.sidebar.multiselect( "What matrix to plot?", ("Confusion Matrix", "ROC Curve", "Precision-Recall Curve")) if st.sidebar.button("Classify", key="classify"): st.subheader("Support Vector Machine (SVM) Results") model = SVC(C=C, kernel=kernel, gamma=gamma) model.fit(x_train, y_train) accuracy = model.score(x_test, y_test) y_pred = model.predict(x_test) st.write("Accuracy: ", accuracy.round(2)) st.write( "Precision: ", precision_score(y_test, y_pred, labels=class_names).round(2)) st.write("Recall: ", recall_score(y_test, y_pred, labels=class_names).round(2)) utils.plot_metrics(metrics, model, x_test, y_test, class_names) if classifier == 'Logistic Regression': st.sidebar.subheader("Model Hyperparameters") C = st.sidebar.number_input("C (Regularization parameter)", 0.01, 10.0, step=0.01, key='Lr') max_iter = st.sidebar.slider("Maximum no. of iterations", 100, 500, key='max_iter') metrics = st.sidebar.multiselect( "What matrix to plot?", ("Confusion Matrix", "ROC Curve", "Precision-Recall Curve")) if st.sidebar.button("Classify", key="classify"): st.subheader("Logistic Regression Results") model = LogisticRegression(C=C, max_iter=max_iter) model.fit(x_train, y_train) accuracy = model.score(x_test, y_test) y_pred = model.predict(x_test) st.write("Accuracy: ", accuracy.round(2)) st.write( "Precision: ", precision_score(y_test, y_pred, labels=class_names).round(2)) st.write("Recall: ", recall_score(y_test, y_pred, labels=class_names).round(2)) utils.plot_metrics(metrics, model, x_test, y_test, class_names) if classifier == 'Random Forest Classification': st.sidebar.subheader("Model Hyperparameters") n_estimators = st.sidebar.number_input( "This is the number of trees in the forest", 100, 5000, step=10, key='n_estimators') max_depth = st.sidebar.number_input("The maximum depth of the tree", 1, 100, step=2, key='max_depth') bootstrap = st.sidebar.radio("Bootstrap samples when building trees", ("True", "False"), key='bootstrap') metrics = st.sidebar.multiselect( "What matrix to plot?", ("Confusion Matrix", "ROC Curve", "Precision-Recall Curve")) if st.sidebar.button("Classify", key="classify"): st.subheader("Random Forest Results") model = RandomForestClassifier(n_estimators=n_estimators, max_depth=max_depth, bootstrap=bootstrap, n_jobs=-1) model.fit(x_train, y_train) accuracy = model.score(x_test, y_test) y_pred = model.predict(x_test) st.write("Accuracy: ", accuracy.round(2)) st.write( "Precision: ", precision_score(y_test, y_pred, labels=class_names).round(2)) st.write("Recall: ", recall_score(y_test, y_pred, labels=class_names).round(2)) utils.plot_metrics(metrics, model, x_test, y_test, class_names) if st.sidebar.checkbox("Show raw data", False): st.subheader("Mushroom Data Set (Classification)") st.write(df)
eps_history.append(agent_dqn.epsilon) avg_score = np.mean( score_history[-100:]) # moving average over last 100 games print('game-episode: ', i, 'episode-score: ', score, ' || average-score %.2f' % avg_score, 'max-score %.2f' % max_score, ' || epsilon %.2f' % agent_dqn.epsilon, 'num_steps', num_steps) if score > max_score: max_score = score # Possible improvemen - short moving max_score average agent_dqn.save_network_checkpoints() print("Training done!") plot_metrics(steps_arr, score_history, eps_history, figure_file_name) # Capturing the agent playing if create_capture: img_arr = [] agent_dqn.epsilon = 0.0001 observation = env.reset() for i in range(1000): frame = np.uint8(observation[0] * 255) frame = cv2.cvtColor(frame, cv2.COLOR_GRAY2BGR) img_arr.append(frame) action = agent_dqn.choose_action(observation) observation, _, _, _ = env.step(action)
setproctitle("(hwijeen) word drop") logging.basicConfig( format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', datefmt='%m/%d/%Y %H:%M:%S', level=logging.INFO) logger = logging.getLogger(__name__) if __name__ == "__main__": DATA_DIR = '/home/nlpgpu5/hwijeen/MulDocSumm/data/' FILE = 'rottentomatoes_prepared' DEVICE = torch.device('cuda:1') EPOCH = 50 WORD_DROP = 0.2 data = MulSumData(DATA_DIR, FILE, 99, DEVICE) selfattnCVAE = build_SelfAttnCVAE(len(data.vocab), hidden_dim=600, latent_dim=300, enc_bidirectional=True, word_drop=WORD_DROP, device=DEVICE) trainer = Trainer(selfattnCVAE, data, lr=0.001, to_record=['recon_loss', 'kl_loss']) results = trainer.train(num_epoch=EPOCH, verbose=True) plot_learning_curve(results['train_losses'], results['valid_losses']) plot_metrics(results['train_metrics'], results['valid_metrics']) plot_kl_loss(trainer.stats.stats['kl_loss'])
def main(config): # For Reproducibility # random.seed(config.seed) np.random.seed(config.seed) torch.manual_seed(config.seed) if torch.cuda.is_available(): torch.cuda.manual_seed(config.seed) # Weights and Plots Path # paths = [config.weights_path, config.plots_path] for path in paths: make_dirs(path) # Prepare Data Loader # if config.dataset == 'cifar': train_loader, val_loader, test_loader = cifar_loader( config.num_classes, config.batch_size) input_size = 32 # Prepare Networks # if config.model == 'vit': model = VisionTransformer(in_channels=config.in_channels, embed_dim=config.embed_dim, patch_size=config.patch_size, num_layers=config.num_layers, num_heads=config.num_heads, mlp_dim=config.mlp_dim, dropout=config.drop_out, input_size=input_size, num_classes=config.num_classes).to(device) elif config.model == 'efficient': model = EfficientNet.from_name( 'efficientnet-b0', num_classes=config.num_classes).to(device) elif config.model == 'resnet': model = resnet34(pretrained=False).to(device) model.fc = nn.Linear(config.mlp_dim, config.num_classes).to(device) else: raise NotImplementedError # Weight Initialization # if not config.model == 'efficient': if config.init == 'normal': model.apply(init_weights_normal) elif config.init == 'xavier': model.apply(init_weights_xavier) elif config.init == 'he': model.apply(init_weights_kaiming) else: raise NotImplementedError # Train # if config.phase == 'train': # Loss Function # criterion = nn.CrossEntropyLoss() # Optimizers # if config.num_classes == 10: optimizer = torch.optim.Adam(model.parameters(), lr=config.lr, betas=(0.5, 0.999)) optimizer_scheduler = get_lr_scheduler(config.lr_scheduler, optimizer) elif config.num_classes == 100: optimizer = torch.optim.SGD(model.parameters(), lr=config.lr, momentum=0.9, weight_decay=5e-4) optimizer_scheduler = get_lr_scheduler('step', optimizer) # Constants # best_top1_acc = 0 # Lists # train_losses, val_losses = list(), list() train_top1_accs, train_top5_accs = list(), list() val_top1_accs, val_top5_accs = list(), list() # Train and Validation # print("Training {} has started.".format(model.__class__.__name__)) for epoch in range(config.num_epochs): # Train # train_loss, train_top1_acc, train_top5_acc = train( train_loader, model, optimizer, criterion, epoch, config) # Validation # val_loss, val_top1_acc, val_top5_acc = validate( val_loader, model, criterion, epoch, config) # Add items to Lists # train_losses.append(train_loss) val_losses.append(val_loss) train_top1_accs.append(train_top1_acc) train_top5_accs.append(train_top5_acc) val_top1_accs.append(val_top1_acc) val_top5_accs.append(val_top5_acc) # If Best Top 1 Accuracy # if val_top1_acc > best_top1_acc: best_top1_acc = max(val_top1_acc, best_top1_acc) # Save Models # print("The best model is saved!") torch.save( model.state_dict(), os.path.join( config.weights_path, 'BEST_{}_{}_{}.pkl'.format(model.__class__.__name__, str(config.dataset).upper(), config.num_classes))) print("Best Top 1 Accuracy {:.2f}%\n".format(best_top1_acc)) # Optimizer Scheduler # optimizer_scheduler.step() # Plot Losses and Accuracies # losses = (train_losses, val_losses) accs = (train_top1_accs, train_top5_accs, val_top1_accs, val_top5_accs) plot_metrics(losses, accs, config.plots_path, model, config.dataset, config.num_classes) print("Training {} using {} {} finished.".format( model.__class__.__name__, str(config.dataset).upper(), config.num_classes)) # Test # elif config.phase == 'test': test(test_loader, model, config) else: raise NotImplementedError
def train(G, max_episodes, save_path): ''' Trains a DQN to play pong. Periodically saves progress to a checkpoint file, and saves plots of several metrics to monitor training. Input: G: computational graph by which the action-value function Q is calculated. max_episodes: the maximum number of episodes to run for before terminating training save_path: a file path to the location of the checkpoint files Output: none ''' # Define some constants, lists, metrics, etc action_map = {1: 'x', 2: '^', 3: 'v'} # Stay, up, down replay_memory = u.ReplayMemory(max_exp_len=REPLAY_MEM_LEN) step_list = [] reward_list = [] avg_reward = None val_Q_list = [] episode_length_list = [] episode_time_list = [] avg_episode_length_list = [] avg_episode_length = None episode_score_list = {'player': [], 'computer': []} X_val = u.load_validation_screens() # Initialize the Pong gym environment, set seeds env = gym.make('Pong-v0') np.random.seed(SEED) tf.set_random_seed(SEED) plt.ioff() # Gather screens # Initialize computational graph with G.as_default(): # Get input/output tensors X = G.get_tensor_by_name('X:0') Y = G.get_tensor_by_name('Y:0') Q = G.get_tensor_by_name('Q:0') A = G.get_tensor_by_name('A:0') L = G.get_tensor_by_name('L:0') LR = G.get_tensor_by_name('LR:0') train_op = G.get_operation_by_name('TrainOp') saver = tf.train.Saver() # Initialize TF session with tf.Session() as sess: # Reload/initialize variables if RELOAD_PARAMETERS: print('Reloading from last checkpoint...') saver.restore(sess, save_path) else: print('Initializing variables...') sess.run(tf.global_variables_initializer()) # Iterate over episodes global_steps = 0 for episode in range(max_episodes): tic = time.time() obs = u.preprocess_image(env.reset()) for i in range(3): replay_memory.add_frame( np.zeros((160 // DOWNSAMPLE, 160 // DOWNSAMPLE), dtype=bool)) replay_memory.add_frame(obs) # Iterate over frames done = False frame = 0 episode_score = [0, 0] while not done: if (global_steps >= OBSERVE_STEPS): # Feed state into DQN s = np.stack( [replay_memory.frames[i] for i in range(-4, 0)], axis=-1).reshape(1, 160 // DOWNSAMPLE, 160 // DOWNSAMPLE, 4) y = sess.run(Y, feed_dict={X: s}) # Decide on action epsilon = max( MAX_EPSILON * (1 - global_steps / EPSILON_ANNEALING_STEPS), MIN_EPSILON) if (np.random.rand() < epsilon): a = np.random.choice([1, 2, 3]) else: a = np.argmax(y) + 1 else: a = np.random.choice([1, 2, 3]) # Take action, observe environment, reward obs, r, done, _ = env.step(a) r_sum = r for i in range(STEPS_TO_SKIP): obs, r, done_temp, _ = env.step(1) r_sum += r if done_temp == True: done = True if r_sum > 0: episode_score[0] += int(r_sum) elif r_sum < 0: episode_score[1] -= int(r_sum) # Add new state/reward to replay memory replay_memory.add_frame(u.preprocess_image(obs)) experience = (np.stack(list(replay_memory.frames), axis=-1).astype(bool), a, r_sum, done) replay_memory.add_exp(experience) # Do training batch update if (global_steps >= OBSERVE_STEPS): S, A_, R, D = replay_memory.sample(BATCH_SIZE) y2 = sess.run(Y, feed_dict={X: S[:, :, :, -4:]}) q = R + (1 - D) * GAMMA * np.max(y2, axis=1) _, batch_loss = sess.run( [train_op, L], feed_dict={ X: S[:, :, :, -5:-1], Q: q, A: (A_ - 1), LR: LEARNING_RATE }) if (batch_loss == np.nan): print('nan error, exiting training') exit() elif (np.mean(np.max(y2, axis=-1)) > 1e2): print('unstable Q value, exiting training') exit() # Print updates print( 'Episode: {}/{},\tframe: {},\tscore: {},\t<max(Q)>: {:.3e},\nmax(Q): {:.3e},\taction: {},\tcurrent std(Q)/mean(Q): {:.3e}' .format(episode + 1, max_episodes, (frame + 1) * (STEPS_TO_SKIP + 1), episode_score, np.mean(np.max(y2, axis=-1)), np.max(y), action_map[a], np.std(y) / np.mean(y))) # Plot frame-by-frame metrics if avg_reward is None: avg_reward = r_sum else: avg_reward = (1 - np.exp(-1 / 500)) * r_sum + np.exp( -1 / 500) * avg_reward if (global_steps % PLOT_EVERY_N_STEPS == 0): step_list.append(global_steps) reward_list.append(10 * avg_reward) y_val = sess.run(Y, feed_dict={X: X_val}) val_Q_list.append(np.mean(np.max(y_val, axis=-1))) u.plot_metrics(step_list, 'PongMetrics', 'Pong Metrics', 'Global step', '', (val_Q_list, 'Validation <max(Q)>'), (reward_list, '10*<R>')) else: print('Observation step {}/{}'.format( global_steps, OBSERVE_STEPS)) # Update state variables global_steps += 1 frame += 1 # Save parameters at end of episode, plot episode metrics print('Saving parameters...') saver.save(sess, SAVE_PATH) episode_length_list.append(frame * (STEPS_TO_SKIP + 1) / 1000) if avg_episode_length is None: avg_episode_length = frame * (STEPS_TO_SKIP + 1) else: avg_episode_length = (1 - np.exp(-1 / 10)) * frame * ( STEPS_TO_SKIP + 1) + np.exp( -1 / 10) * avg_episode_length avg_episode_length_list.append(avg_episode_length / 1000) toc = time.time() episode_time_list.append((toc - tic) / 60) episode_score_list['player'].append(episode_score[0]) episode_score_list['computer'].append(episode_score[1]) u.plot_metrics(range(episode + 1), 'EpisodeLength', 'Episode Length', 'Episode', 'Steps/1000', (episode_length_list, 'Steps/episode'), (avg_episode_length_list, 'Average')) u.plot_metrics(range(episode + 1), 'EpisodeScore', 'Episode Score', 'Episode', 'Score', (episode_score_list['player'], 'Player'), (episode_score_list['computer'], 'Computer')) u.plot_metrics(range(episode + 1), 'EpisodeTime', 'Episode time', 'Episode', 'Time (min)', (episode_time_list, 'Episode time'))
def main(): utils.local_css("css/styles.css") st.title("Heart Disease Prediction - Manual Parameter Tuner") st.sidebar.title("Manual Parameter Tuning") st.markdown("### Machine Learning is not only about the algorithms you use but also about the different Parameters " "assigned to each of them. The final model is heavily affected by the parameters used for a specific " "algorithm. " "\nThis interactive web app will help you to explore the various parameters of different ML algorithms." "\nThe different ML models presented here are:" "\n* Logistic Regression" "\n* Support Vector Classifier" "\n* k-Nears Neighbour Classifier" "\n* Decision Tree Classifier" "\n* Random Forest Classifier" "\n* Gradient Boosting Classifier" "\n* XGBoost Classifier" "\n### The dataset used here is the **Framingham** Coronary Heart Disease dataset publicly available " "at [Kaggle](https://www.kaggle.com/amanajmera1/framingham-heart-study-dataset)." "\n## About the Dataset:" "\nThe **Framingham** dataset is from an ongoing cardiovascular study" " on residents of the town of Framingham, Massachusetts. The classification goal is " "to predict whether the patient has 10-year risk of future coronary heart disease (CHD). The dataset " "provides the patients’ information. It includes over 4,240 records and 15 attributes." "\n ### Even after optimizing parameters, the model would only work properly if accurate data is provided to it." " So, through this web app, the users will be able to get a feel of hyperparameter tuning but only on this specific dataset." "\n ## Head to the *Manual Parameter Tuning* section to get started!") st.sidebar.markdown("Manually select the model you want to view and use the interactive text boxes, sliding bars " "and buttons to tune the respective models. More than one options are provided for each model" " and you can view and gain insight on how hyper-parameter tuning works. Enjoy exploring!") data = pd.read_csv("Dataset/framingham.csv") data = utils.preprocess(data) st.sidebar.markdown("\n#### Exploratory Data Analysis:") viz_list = st.sidebar.multiselect("(Be sure to Clear off all the selected options here before moving on for faster response)", ('Categorical Visualisation', 'Numerical Visualisation', 'sysBP and diaBP Visualisation')) utils.visualize(viz_list, data) if st.sidebar.checkbox("View raw and preprocessed data", False): st.subheader("Raw-preprocessed Data") st.write(data) st.sidebar.markdown("\n#### Feature Selection:") feature = st.sidebar.radio("Feature selection using chi-squared test", ("Don't select features", "Select Features"), key='feature') if feature == "Don't select features": st.markdown("### Feature Selection is not done!") else: st.markdown("Best 10 features along with their chi-squared score") score, data = utils.feature_selection(data) st.write(score) if st.sidebar.checkbox("Plot Feature Selection", False): utils.plot_feature_selection(score) train_x, test_x, train_y, test_y = utils.split_and_scale(data) class_names = ["Has Heart Disease", "Doesn't have Heart Disease"] st.sidebar.subheader("Choose Classifier") classifier = st.sidebar.selectbox("Classifier", ("Logistic Regression", "Support Vector Classifier", "k-Nears Neighbour Classifier", "Decision Tree Classifier", "Random Forest Classifier", "Gradient Boosting Classifier", "XGBoost Classifier")) if classifier == "Logistic Regression": st.sidebar.subheader("Model Hyperparameters") C = st.sidebar.number_input("C (Regularization parameter)", 0.01, 10.0, step=0.01, key='Lr') max_iter = st.sidebar.slider("Maximum no. of Iterations", 100, 500, key='max_iter') metrics = st.sidebar.multiselect("What matrix to plot?", ("Confusion Matrix", "ROC Curve", "Precision-Recall Curve")) if st.sidebar.button("Classify", key="classify"): st.subheader("Logistic Regression Results") y_pred, accuracy, models = model.LR(train_x, test_x, train_y, test_y, C=C, max_iter=max_iter) st.write("Accuracy: ", accuracy.round(3)) st.write("Precision: ", precision_score(test_y, y_pred, labels=class_names).round(3)) st.write("Recall: ", recall_score(test_y, y_pred, labels=class_names).round(3)) utils.plot_metrics(metrics, models, test_x, test_y, class_names) if classifier == "Support Vector Classifier": st.sidebar.subheader("Model Hyperparameters") C = st.sidebar.number_input("C (Regularization parameter)", 0.01, 10.0, step=0.01, key='C') gamma = st.sidebar.radio("Gamma (for non linear hyperplanes)", ("auto", "scale"), key='gamma') kernel = st.sidebar.radio("Kernel (type of hyperplane)", ("linear", "rbf", "poly"), key='kernel') degree = 3 if kernel == 'poly': degree = st.sidebar.number_input("Degree of the polynomial used to find the hyperplane", 1, 10, step=1, key='degree') metrics = st.sidebar.multiselect("What matrix to plot?", ("Confusion Matrix", "ROC Curve", "Precision-Recall Curve")) if st.sidebar.button("Classify", key="classify"): st.subheader("Support Vector Classification Results") y_pred, accuracy, models = model.SVM(train_x, test_x, train_y, test_y, C=C, gamma=gamma, kernel=kernel, degree=degree) st.write("Accuracy: ", accuracy.round(3)) st.write("Precision: ", precision_score(test_y, y_pred, labels=class_names).round(3)) st.write("Recall: ", recall_score(test_y, y_pred, labels=class_names).round(3)) utils.plot_metrics(metrics, models, test_x, test_y, class_names) if classifier == "k-Nears Neighbour Classifier": st.sidebar.subheader("Model Hyperparameters") n = st.sidebar.number_input("n_neighbors (Number of nearest neighbors)", 1, 20, step=1, key='n') leaf_size = st.sidebar.slider("Leaf Size", 10, 200, key='leaf_size') algorithm = st.sidebar.radio("Algorithm to use", ("ball_tree", "kd_tree", "auto"), key='algorithm') metrics = st.sidebar.multiselect("What matrix to plot?", ("Confusion Matrix", "ROC Curve", "Precision-Recall Curve")) if st.sidebar.button("Classify", key="classify"): st.subheader("kNN Classification Results") y_pred, accuracy, models = model.KNN(train_x, test_x, train_y, test_y, n=n, leaf_size=leaf_size, algorithm=algorithm) st.write("Accuracy: ", accuracy.round(3)) st.write("Precision: ", precision_score(test_y, y_pred, labels=class_names).round(3)) st.write("Recall: ", recall_score(test_y, y_pred, labels=class_names).round(3)) utils.plot_metrics(metrics, models, test_x, test_y, class_names) if classifier == "Decision Tree Classifier": criterion = st.sidebar.radio("Criterion of splitting trees", ("gini", "entropy"), key='criterion') max_depth = st.sidebar.slider("Max depth of the tree", 1, 50, key='amx_depth') min_samples_leaf = st.sidebar.number_input("Minimum Leaf Samples", 1, 10, step=1, key='min_samples_leaf') max_features = st.sidebar.radio("No. of features to consider during best split", ("auto", "sqrt", "log2"), key='max_features') metrics = st.sidebar.multiselect("What matrix to plot?", ("Confusion Matrix", "ROC Curve", "Precision-Recall Curve")) if st.sidebar.button("Classify", key="classify"): st.subheader("Decision Tree Classification Results") y_pred, accuracy, models = model.DT(train_x, test_x, train_y, test_y, criterion=criterion, max_depth=max_depth, leaf=min_samples_leaf, max_features=max_features) st.write("Accuracy: ", accuracy.round(3)) st.write("Precision: ", precision_score(test_y, y_pred, labels=class_names).round(3)) st.write("Recall: ", recall_score(test_y, y_pred, labels=class_names).round(3)) utils.plot_metrics(metrics, models, test_x, test_y, class_names) if classifier == "Random Forest Classifier": st.sidebar.subheader("Model Hyperparameters") n_estimators = st.sidebar.slider("Number of Trees in the Random Forest", 100, 4000, key='n_estimators') max_depth = st.sidebar.number_input("The maximum depth of the tree", 1, 100, step=5, key='max_depth') bootstrap = st.sidebar.radio("Bootstrap samples when building trees", ("True", "False"), key='bootstrap') metrics = st.sidebar.multiselect("What matrix to plot?", ("Confusion Matrix", "ROC Curve", "Precision-Recall Curve")) if st.sidebar.button("Classify", key="classify"): st.subheader("Random Forest Classification Results") y_pred, accuracy, models = model.RF(train_x, test_x, train_y, test_y, n_estimators=n_estimators, max_depth=max_depth, bootstrap=bootstrap) st.write("Accuracy: ", accuracy.round(3)) st.write("Precision: ", precision_score(test_y, y_pred, labels=class_names).round(3)) st.write("Recall: ", recall_score(test_y, y_pred, labels=class_names).round(3)) utils.plot_metrics(metrics, models, test_x, test_y, class_names) if classifier == "Gradient Boosting Classifier": st.sidebar.subheader("Model Hyperparameters") n_estimators = st.sidebar.slider("Number of Trees in the Gradient Boost ensemble", 100, 4000, key='n_estimators') max_depth = st.sidebar.number_input("The maximum depth of the tree", 1, 100, step=5, key='max_depth') learning_rate = st.sidebar.number_input("Learning Rate", 0.01, 10.0, step=0.01, key='learning_rate') warm_start = st.sidebar.radio("Reuse previous solution for more ensemble", ("True", "False"), key='warm_start') metrics = st.sidebar.multiselect("What matrix to plot?", ("Confusion Matrix", "ROC Curve", "Precision-Recall Curve")) if st.sidebar.button("Classify", key="classify"): st.subheader("Gradient Boosting Classification Results") y_pred, accuracy, models = model.GBC(train_x, test_x, train_y, test_y, n_estimators=n_estimators, max_depth=max_depth, learning_rate=learning_rate, warm_start=warm_start) st.write("Accuracy: ", accuracy.round(3)) st.write("Precision: ", precision_score(test_y, y_pred, labels=class_names).round(3)) st.write("Recall: ", recall_score(test_y, y_pred, labels=class_names).round(3)) utils.plot_metrics(metrics, models, test_x, test_y, class_names) if classifier == "XGBoost Classifier": st.sidebar.subheader("Model Hyperparameters") n_estimators = st.sidebar.slider("Number of Trees in the XGBoost ensemble", 100, 4000, key='n_estimators') max_depth = st.sidebar.number_input("The maximum depth of the tree", 1, 100, step=5, key='max_depth') eta = st.sidebar.number_input("Learning Rate", 0.01, 10.0, step=0.01, key='eta') colsample_bytree = st.sidebar.number_input("Percentage of features used per tree", 0.01, 1.0, step=0.01, key='colsample_bytree') reg_alpha = st.sidebar.number_input("L1 regularization on leaf weights", 1, 10, step=1, key='reg_alpha') reg_lambda = st.sidebar.number_input("L2 regularization on leaf weights", 1, 10, step=1, key='reg_lambda') metrics = st.sidebar.multiselect("What matrix to plot?", ("Confusion Matrix", "ROC Curve", "Precision-Recall Curve")) if st.sidebar.button("Classify", key="classify"): st.subheader("Extreme Gradient Boosting(XGBoost) Classification Results") y_pred, accuracy, models = model.XGB(train_x, test_x, train_y, test_y, n_estimators=n_estimators, max_depth=max_depth, eta=eta, colsample_bytree=colsample_bytree, reg_alpha=reg_alpha, reg_lambda=reg_lambda) st.write("Accuracy: ", accuracy.round(3)) st.write("Precision: ", precision_score(test_y, y_pred, labels=class_names).round(3)) st.write("Recall: ", recall_score(test_y, y_pred, labels=class_names).round(3)) utils.plot_metrics(metrics, models, test_x, test_y, class_names)
def train_subj(subj, save_dir, N_epoch=20, dev_set='AVG_100', plot=1): #%% load saved data (.mat) from MATLAB #subj = 's21' # (1)train set: # filename1 = 'EEG/SNR3D_set_s1.mat' filename1 = 'DL_trainset/AVG_ram100/' + subj + '.mat' file = loadmat(filename1) data1 = file['SNR3D_arr'] # (2) dev set: # AVG_spectrum_s1 = 'EEG/SNR3D_spectrum_s1.mat' AVG_spectrum_s1 = 'DL_trainset/AVG96/' + subj + '.mat' file = loadmat(AVG_spectrum_s1) data1_dev = file['SNR3D'] print('data1_dev:', data1_dev.shape) # check shape of INPUT data r, c = data1.shape for i in range(c): print(data1[0, i].shape) #%% orginal labels -> binary labels labels_full = [ 4, 6, 27, 33, 35, 37, 39, 43, 45, 66, 72, 76, 78, 99, 105, 111, 117 ] labels_subset = [6, 33, 37, 39, 43, 66, 72, 78, 99, 117] # (1) labels_subset2 = [6, 33, 37, 39, 43, 45, 66, 72, 76, 78, 99, 117] # (2) labels_subset3 = [6, 33, 35, 37, 39, 43, 45, 66, 72, 76, 78, 99, 117] # (3) # choose one annotation from above ! labels_2use = labels_full labels_org = np.array(labels_2use) - 1 # python starts from 0 labels_bi = xloc2binaryvec(labels_org) # binary code label: 1 and 0 #%% prepare {x_train, y_train, x_test, y_test} # option B: use AVG- [50, 60, 70, 80, 90] trials for train x_train = np.concatenate( (data1[0, 0], data1[0, 1], data1[0, 2], data1[0, 3], data1[0, 4]), axis=0) if dev_set == 'AVG_100': # saved in folder named 'saved_models2' x_test_100tr = data1_dev[-1] # dev set: AVG-100 trials (1,:,:) x_test = np.reshape(x_test_100tr, (1, x_test_100tr.shape[0], x_test_100tr.shape[1])) elif dev_set == 'AVG_50_100': # saved in folder named 'mat3' # dev set: AVG 5-100 trials x_test = data1_dev[-50:, :, :] # (50-100,:,:) elif dev_set == 'AVG_5_100': # whole dev set: 'AVG_5_100' - saved in folder named 'saved_models' x_test = data1_dev # (5-100, :,:) print('dev_set: ', x_test.shape) # normalize X to [0 - 1] x_train = normalize_matrix_1(x_train) x_test = normalize_matrix_1(x_test) # repeating Y (labels_bi) the number of times given by number of samples y_train = np.tile(labels_bi, (len(x_train), 1)) # (10k,120) y_test = np.tile(labels_bi, (len(x_test), 1)) # (100,120) # shuffle [x_train, y_train] 100x along the dimenstion of frequency '1-120' x_train, y_train = shuffle_trainset(x_train, y_train) #%% reshape for CNN: not neccesary, tf.keras will take care if this # x_train = x_train.reshape(x_train.shape[0], 12, 120, 1) # x_test = x_test.reshape(x_test.shape[0], 12, 120, 1) #%% define a model tf.keras.backend.clear_session() def create_model(): # (C) CNN model (~2 conv layers): ~ 230k paras inputs = keras.Input(shape=( 60, 120, 1)) # 1 is needed here to keep the same dim with next conv2D layer x = layers.experimental.preprocessing.Rescaling(1.0 / 1)(inputs) x = layers.Conv2D(filters=8, kernel_size=(3, 3), padding='same', activation="relu")(x) x = layers.MaxPooling2D(pool_size=(3, 3), strides=(1, 1), padding='same')( x) # stride =1, not =3 be default x = layers.Dropout(.2)(x) x = layers.Conv2D(filters=4, kernel_size=(3, 3), padding='same', activation="relu")(x) x = layers.MaxPooling2D(pool_size=(2, 2), strides=(1, 1), padding='same')( x) # stride =1, not =2 be default x = layers.Dropout(.2)(x) x = layers.Flatten()(x) x = layers.Dense(1024, activation="relu")(x) # it does not further improve! outputs = layers.Dense(120, activation='sigmoid')(x) model = keras.Model(inputs, outputs) loss = tf.keras.losses.BinaryCrossentropy() # optimizer = tf.keras.optimizers.SGD(learning_rate=0.01) optimizer = tf.keras.optimizers.Adam(learning_rate=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-07) # METRICS = [ # keras.metrics.TruePositives(name='tp'), # keras.metrics.FalsePositives(name='fp'), # keras.metrics.TrueNegatives(name='tn'), # keras.metrics.FalseNegatives(name='fn'), # keras.metrics.BinaryAccuracy(name='accuracy'), # keras.metrics.Precision(name='precision'), # keras.metrics.Recall(name='recall'), # keras.metrics.AUC(name='auc'), # ] METRICS = [ keras.metrics.BinaryAccuracy(name='accuracy'), keras.metrics.Precision(name='precision'), keras.metrics.Recall(name='recall'), keras.metrics.AUC(name='auc', curve='PR'), # curve='ROC' by default ] model.compile( optimizer=optimizer, loss=loss, metrics=METRICS, ) return model #%% Build a model # Create a basic model instance model = create_model() # show model model.summary() #%% train # N_epoch = 20 # (callback 1) for using TensorBoard callback_log = [keras.callbacks.TensorBoard(log_dir='./logs')] # Launch TensorBoard from the command line (1st cd: folder of this proj) # in cmd type: tensorboard --logdir logs # (callback 2) Create a callback that saves the model's weights # only model that achieves larger 'val_auc' is saved. checkpoint_path = "checkpoints/my_ckpt" callback_cp = tf.keras.callbacks.ModelCheckpoint(filepath=checkpoint_path, save_weights_only=True, monitor='val_auc', mode='max', save_best_only=True, verbose=1) start_time = time.time() # Train the model from Numpy data input history = model.fit(x_train, y_train, validation_data=(x_test, y_test), batch_size=32, epochs=N_epoch, callbacks=[callback_log, callback_cp]) print('elapsed_time:', time.time() - start_time) # =203 s for 100 epochs #%% plot learning curves - [loss, AUC, etc.] if plot == 1: plt.figure(figsize=(12, 10)) plot_loss(history, "loss", 2) # plot metrics over epochs plt.figure(figsize=(12, 10)) plot_metrics(history) #%% Evaluate the saved 'best model weights' by callback_func # Create a basic model instance model = create_model() # Display the model's architecture model.summary() # Evaluate the initial model loss, acc, _, _, _ = model.evaluate(x_test, y_test, verbose=2) print("Untrained model, accuracy: {:5.2f}%".format(100 * acc)) # Re-load the model weights from the saved checkpoints model.load_weights(checkpoint_path) # Loads the weights # Evaluate the saved model loss, acc, _, _, _ = model.evaluate(x_test, y_test, verbose=2) print("saved model, accuracy: {:5.2f}%".format(100 * acc)) # save the entire trained model (not only weights in checkpoints) # choose the path for saving # save_dir = os.path.join(os.getcwd(), 'saved_models') # if not os.path.isdir(save_dir): # os.makedirs(save_dir) model_name = subj + '_best_trained_model.h5' model_path = os.path.join(save_dir, model_name) model.save(model_path) print('Saved trained model at %s ' % model_path) #%% test the best_trained_model on x_test (AVG-100 trials) of day1 EEG if plot == 1: predictions = model.predict(x_test) predictions_mean = np.mean(predictions, axis=0) labels2plt = labels_org plt.figure(figsize=(16, 9)) plt.imshow(predictions, cmap='gray') plot1bar(labels2plt, L=96) plt.xlabel('frequency') plt.ylabel('All test samples') plt.title('prediction on AVG 90 trials (with Ann)') plt.figure(figsize=(16, 9)) plt.plot(predictions_mean) plot1bar(labels2plt, L=2) plt.grid(True) plt.xlabel('frequency') plt.ylabel('probability of ASSR') plt.title('Mean prediction')
# In[ ]: with open('results.log', 'w') as f: lr=0.001 opt = RAdam(network.get_trainable_parameters(lr)) # opt = torch.optim.SGD(network.get_trainable_parameters(lr), lr=lr, momentum=0.9) res_metrics = network.fit( load_data, epochs=nb_epochs, optimizer=opt, dataset_size=dataset_size, result_file=f, save_checkpoints=True ) plot_metrics(res_metrics, save_plot_path='./metrics_' if SAVE_PLOTS else None) network.save('save_network.net') # network.load('save_network.net') # In[ ]: plot_one_batch(network) print_and_plot_accuracy_metrics( network, load_data('acc_train'), load_data('acc_test'), save_plot_path='./accuracy_' if SAVE_PLOTS else None )
def train(G, max_episodes, save_path): ''' Trains a DQN to play pong. ''' # Define some constants, lists, metrics, etc action_map = {1: 'x', 2: '^', 3: 'v'} # Stay, up, down replay_memory = u.ReplayMemory(max_exp_len=REPLAY_MEM_LEN) step_list = [] reward_list = [] val_Q_list = [] episode_length_list = [] avg_episode_length_list = [] episode_score_list = {'player': [], 'computer': []} X_val = u.load_validation_screens() # Initialize the Pong gym environment, set seeds env = gym.make('Pong-v0') np.random.seed(SEED) tf.set_random_seed(SEED) plt.ioff() # Gather screens # Initialize computational graph with G.as_default(): # Get input/output tensors X = G.get_tensor_by_name('X:0') Y = G.get_tensor_by_name('Y:0') # Append loss function to graph Q = tf.placeholder(dtype=tf.float32, shape=[None], name='Q') A = tf.placeholder(dtype=tf.int32, shape=[None], name='A') mask = tf.one_hot(A, depth=3, dtype=tf.float32, axis=-1) L = tf.reduce_mean(tf.square(tf.reduce_sum(mask * Y, axis=-1) - Q), name='L') # Define optimizer, training op, gradient clipping, etc. if not RELOAD_PARAMETERS: optimizer = tf.train.AdamOptimizer(LEARNING_RATE, name='Adam') else: optimizer = G.get_operation_by_name('Adam') saver = tf.train.Saver() # Initialize TF session with tf.Session() as sess: # Reload/initialize variables if RELOAD_PARAMETERS: print('Reloading from last checkpoint...') saver.restore(sess, save_path) else: print('Initializing variables...') gradients, variables = zip(*optimizer.compute_gradients(L)) train_op = optimizer.apply_gradients(zip(gradients, variables)) sess.run(tf.global_variables_initializer()) # Iterate over episodes global_steps = 0 for episode in range(max_episodes): obs = u.preprocess_image(env.reset()) for i in range(3): replay_memory.add_frame( np.zeros((160 // DOWNSAMPLE, 160 // DOWNSAMPLE))) replay_memory.add_frame(obs) # Iterate over frames done = False frame = 0 episode_score = [0, 0] while not done: if (global_steps >= OBSERVE_STEPS): # Feed state into DQN s = np.stack( [replay_memory.frames[i] for i in range(-4, 0)], axis=-1).reshape(1, 160 // DOWNSAMPLE, 160 // DOWNSAMPLE, 4) y = sess.run(Y, feed_dict={X: s}) # Decide on action epsilon = max( MAX_EPSILON * (1 - global_steps / EPSILON_ANNEALING_STEPS), MIN_EPSILON) if (np.random.rand() < epsilon): a = np.random.choice([1, 2, 3]) else: a = np.argmax(y) + 1 else: a = np.random.choice([1, 2, 3]) # Take action, observe environment, reward obs, r, done, _ = env.step(a) r_sum = r for i in range(STEPS_TO_SKIP): obs, r, done_temp, _ = env.step(1) r_sum += r if done_temp == True: done = True if r_sum > 0: episode_score[0] += r_sum elif r_sum < 0: episode_score[1] -= r_sum # Add new state/reward to replay memory replay_memory.add_frame(u.preprocess_image(obs)) experience = (np.stack(list(replay_memory.frames), axis=-1), a, r_sum, done) replay_memory.add_exp(experience) # Do training batch update if (global_steps >= OBSERVE_STEPS): S, A_, R, D = replay_memory.sample(BATCH_SIZE) y2 = sess.run(Y, feed_dict={X: S[:, :, :, -4:]}) q = R + (1 - D) * GAMMA * np.max(y2, axis=1) _, batch_loss = sess.run([train_op, L], feed_dict={ X: S[:, :, :, -5:-1], Q: q, A: (A_ - 1) }) if (batch_loss == np.nan): print('nan error, exiting training') exit() elif (np.mean(np.max(y2, axis=-1)) > 1e2): print('unstable Q value, exiting training') exit() # Print updates print( 'Episode: {}/{},\tframe: {},\treward: {},\t<max(Q)>: {:.3e},\nmax(Q): {:.3e},\taction: {},\tcurrent std(Q)/mean(Q): {:.3e}' .format(episode + 1, max_episodes, frame + 1, int(r_sum), np.mean(np.max(y2, axis=-1)), np.max(y), action_map[a], np.std(y) / np.mean(y))) # Plot frame-by-frame metrics if global_steps == 0: avg_reward = r_sum else: avg_reward = (1 - np.exp(-1 / 500)) * r_sum + np.exp( -1 / 500) * avg_reward if (global_steps % PLOT_EVERY_N_STEPS == 0): step_list.append(global_steps) reward_list.append(10 * avg_reward) y_val = sess.run(Y, feed_dict={X: X_val}) val_Q_list.append(np.mean(np.max(y_val, axis=-1))) u.plot_metrics(step_list, 'PongMetrics', 'Pong Metrics', 'Global step', '', (val_Q_list, 'Validation <max(Q)>'), (reward_list, '10*<R>')) else: print('Observation step {}/{}'.format( global_steps, OBSERVE_STEPS)) # Update state variables global_steps += 1 frame += 1 # Save parameters at end of episode, plot episode metrics saver.save(sess, SAVE_PATH) episode_length_list.append(frame * (STEPS_TO_SKIP + 1) / 1000) if episode == 0: avg_episode_length = frame * (STEPS_TO_SKIP + 1) else: avg_episode_length = (1 - np.exp(-1 / 10)) * frame * ( STEPS_TO_SKIP + 1) + np.exp( -1 / 10) * avg_episode_length avg_episode_length_list.append(avg_episode_length / 1000) episode_score_list['player'].append(episode_score[0]) episode_score_list['computer'].append(episode_score[1]) u.plot_metrics(range(episode + 1), 'EpisodeLength', 'Episode Length', 'Episode', 'Length/1000', (episode_length_list, 'Episode length'), (avg_episode_length_list, 'Average')) u.plot_metrics(range(episode + 1), 'EpisodeScore', 'Episode Score', 'Episode', 'Score', (episode_score_list['player'], 'Player'), (episode_score_list['computer'], 'Computer'))