def run_train_split_test(method, moea, target): moea_name = dictionaries.get_moea_name(moea) target_name = dictionaries.get_target_composition(target) method_name = dictionaries.get_model_method_name(method) folder_name = 'split-train/' + method_name +'/'+ moea_name + '/' + target_name type = 2 helpers.test_model(folder_name=folder_name, type = type, predict_model=method)
def run_msdp_test(method, moea, target): moea_name = dictionaries.get_moea_name(moea) target_name = dictionaries.get_target_composition(target) method_name = dictionaries.get_model_method_name(method) folder_name = 'multi-objective/' + method_name +'/'+ moea_name + '/' + target_name type = 2 helpers.test_model(folder_name=folder_name, type = type, predict_model=method)
buffer_size = 5000 c = 750 c_step = 0 e = 0.01 a = 0.6 b = 0.4 input_depth = 37 hidden0 = 128 hidden1 = 128 hidden2 = 128 output_depth = 4 replay = [] model, loss_fn, optimizer = get_model(input_depth, hidden0, hidden1, hidden2, output_depth, lr) filename = 'checkpoint-2000.pt' model, optimizer, replay = load_model(model, optimizer, filename) env = UnityEnvironment(file_name="Banana.app") brain_name = env.brain_names[0] brain = env.brains[brain_name] test_actor_env = (model, brain_name, env) attemps = 100 filename = 'test_scores-{}.png'.format(attemps) test_model(test_actor_env, attemps, filename, viewableSpeed=False)
m.Linear(Hidden_Units, Hidden_Units), m.ReLU(), m.Linear(Hidden_Units, Hidden_Units), m.Tanh(), m.Linear(Hidden_Units, Output_Units), m.Tanh()) #Instantiate the optimizer lr = 0.00095 sgd = m.SGD(params=model.param(), lr=lr) #Train the model EPOCHS = 150 model, train_error, validation_error = h.train_model(train_data, train_targets,\ validation_data, validation_targets, model, sgd, nb_epochs = EPOCHS) ''' #Plot both train and validation errors wrt the number of epochs fig = plt.figure(figsize=(9, 5)) ax = fig.add_subplot(111) ax.set_title('Evolution of the training and validation errors w.r.t the epoch number.') plt.plot(validation_error,color='red') plt.plot(train_error,color='blue') plt.legend(['Training Error', 'Validation Error']) ax.set_xlabel('Epochs') ax.set_ylabel(' % of Error') #plt.savefig('Error_results.png') plt.grid() plt.show() ''' h.test_model(model, test_data, test_targets)
def run_msdp_fpa_l1_linear_nsga2_toZero_test(): folder_name = 'linear/多目标优化_FPA+L1_nsga2_toZero' type = 2 helpers.test_model(folder_name=folder_name, type=type)
def run_msdp_fpa_aae_nonz_linear_nsga2_DE_toZero_test(): folder_name = 'linear/多目标优化_FPA+AAE+numofnonzero_nsga2_DE_toZero' type = 2 helpers.test_model(folder_name=folder_name, type=type)
def run_ssdp_linear_CoDE_test(): folder_name = 'linear/CoDE' type = 1 helpers.test_model(folder_name=folder_name, type=type)
def run_ssdpM_test(method,soea): type = 2 soea_name = dictionaries.get_soea_name(soea) method_name = dictionaries.get_model_method_name(method) folder_name = 'multi-objective/' + method_name + '/' + soea_name helpers.test_model(folder_name=folder_name, type = type, predict_model=method)
final_test_acc = 0. for epoch in range(num_epochs): # Decay learning rate according to decay schedule helpers.adjust_learning_rate(optimizer, epoch, learning_rate_table) print("Starting Epoch {}/{}. lr = {}".format( epoch, num_epochs, learning_rate_table[epoch])) # Train train_acc, train_loss, percent_real = training_helpers.train_model( net, optimizer, ID_trainloader, 10 - NUM_HOLDOUT_CLASSES) print( "[{}] Epoch [ {} / {} ]; lr: {} TrainAccuracy: {:.5f} TrainLoss: {:.5f} %-Real: {}" .format(ITER, epoch, num_epochs, learning_rate_table[epoch], train_acc, train_loss, percent_real)) # Test test_acc, test_loss = helpers.test_model(net, device, ID_testloader, MEAN, STD) print( "\t[{}] Epoch [ {} / {} ]; TestAccuracy: {:.5f} TestLoss: {:.5f}". format(ITER, epoch, num_epochs, test_acc, test_loss)) final_test_acc = test_acc STAT_accuracy.append(final_test_acc) net.eval() # Optional: Save model checkpoint and move to next iter #helpers.save_checkpoint({'test_acc': final_test_acc,'state_dict': net.state_dict()}, False, "{}_K{}_J{}_SEED{}_ITER{}".format(SAVE_CKPT,int(100*K), int(NUM_HOLDOUT_CLASSES),SEED,ITER)) ################################################################################################################# # Test ID and OOD data ### Hook into Net for Mahalanobis layer
model.word_embeddings.weight.data.numpy(), 'pos_embeddings': model.cpu().pos_embeddings.weight.data.numpy(), 'optimizer': optimizer.state_dict(), }, LATEST_CHECKPOINT_RELATIVE_PATH, BEST_CHECKPOINT_RELATIVE_PATH, is_best_model) break print('Finished testing at {}.'.format( time.strftime('%d-%m-%Y, %H:%M:%S'))) logging.info('Finished testing at {}.'.format( time.strftime('%d-%m-%Y, %H:%M:%S'))) elif args.mode == 'test': test_loss, test_arc_scores, test_label_scores = test_model( model, loss_function, conllu_sentences[args.language]['test'], args.language) print(test_loss) elif args.mode == 'predict': prediction_file = open(RESULTS_RELATIVE_PATH, mode='a', encoding='UTF-8') formatted_test_file = open(FORMATTED_TEST_RELATIVE_PATH, mode='a', encoding='UTF-8') for conllu_sentence in conllu_sentences[args.language]['test']: # save formatted version fo test file formatted_test_file.write(str(conllu_sentence)) formatted_test_file.flush() # predict arc scores and labels predicted_arcs, predicted_labels = predict(model, conllu_sentence,
parser = argparse.ArgumentParser() parser.add_argument('file', help='model file') parser.add_argument('dataset', help='dataset we want to test it on') parser.add_argument('--mode', default='offsets', choices=['offsets', 'times', 'intervals']) parser.add_argument('--n_samples', default=500, type=int) args = parser.parse_args() with open(args.file, 'rb') as f: model = torch.load(f) dset = load_dataset(args.dataset) data = test_model(model, dset, args.n_samples) distr = {} for i in range(len(data)): dset_idx, x, y, z, _ = data[i] r, s, g = dset[dset_idx][2] peak = np.argmax(z) if args.mode == 'offsets': val = peak - g elif args.mode == 'times': val = peak elif args.mode == 'intervals': val = peak - s
### Create model input_dim = 2 hidden_width = 25 output_dim = 2 model = HL.Sequential([ HL.Linear(input_dim, hidden_width), HL.ReLu(), HL.Linear(hidden_width, hidden_width), HL.ReLu(), HL.Linear(hidden_width, hidden_width), HL.Tanh(), HL.Linear(hidden_width, output_dim), HL.Tanh() ]) ### Train model and log training and validation error model, train_error_list, test_error_list = HL.train_model(train_inputs, train_targets, validation_inputs, validation_targets, model, learning_rate=0.0001, epochs=300) ### Print final training error print('train_error {:.02f}%'.format(train_error_list[-1])) ### Test error HL.test_model(model, test_inputs, test_targets)