def train_copy_task(): num_words = 11 criterion = nn.NLLLoss(ignore_index=0, reduction='sum') model = full_model.make_model(num_words, num_words, emb_size=32, hidden_size=64) optim = torch.optim.Adam(model.parameters(), lr=0.0003) eval_data = list(data_gen(num_words=num_words, batch_size=1, num_batches=100)) dev_perplexities = [] if init.USE_CUDA: model.cuda() for epoch in range(10): print("Epoch %d" % epoch) model.train() data = data_gen(num_words=num_words, batch_size=32, num_batches=100) train.run_epoch(data, model, train.SimpleLossCompute(model.generator, criterion, optim)) model.eval() with torch.no_grad(): perplexity = train.run_epoch(eval_data, model, train.SimpleLossCompute(model.generator, criterion, None)) print("Evaluation perplexity: %f" % perplexity) dev_perplexities.append(perplexity) return dev_perplexities
def main(_): # if not FLAGS.data_path: # raise ValueError("Must set --data_path to data directory") config = Config() eval_config = Config() if FLAGS.data_path: config.data_path = FLAGS.data_path eval_config.data_path = FLAGS.data_path raw_data = proc_raw_data(config) train_data, test_data = raw_data valid_data = train_data[:160, :] with tf.Graph().as_default(): initializer = tf.random_uniform_initializer(-config.init_scale, config.init_scale) with tf.name_scope("Train"): train_input = ProcInput(data=train_data, config=config, name="TrainInput") with tf.variable_scope("Model", reuse=None, initializer=initializer): m = ProcModel(is_training=True, config=config, input_=train_input) tf.summary.scalar("Training Loss", m.cost) tf.summary.scalar("Learning Rate", m.lr) with tf.name_scope("Valid"): valid_input = ProcInput(data=valid_data, config=config, name="ValidInput") with tf.variable_scope("Model", reuse=True, initializer=initializer): mvalid = ProcModel(is_training=False, config=config, input_=valid_input) # tf.summary.scalar("Validation Loss", mvalid.cost) with tf.name_scope("Test"): test_input = ProcInput(config=eval_config, data=test_data, name="TestInput") with tf.variable_scope("Model", reuse=True, initializer=initializer): mtest = ProcModel(is_training=False, config=eval_config, input_=test_input) sv = tf.train.Supervisor(logdir=FLAGS.save_path) with sv.managed_session() as session: for i in range(config.max_max_epoch): lr_decay = config.lr_decay ** max(i + 1 - config.max_epoch, 0.0) m.assign_lr(session, config.learning_rate * lr_decay) print("Epoch: %d Learning rate: %.3f" % (i + 1, session.run(m.lr))) train_entrophy = run_epoch(session, m, eval_op=m.train_op, verbose=True) # train_perplexity = run_epoch(session, m, eval_op=m.train_op, # verbose=True) print("Epoch: %d Train Entrophy: %.3f" % (i + 1, train_entrophy)) valid_accuracy = run_epoch(session, mvalid, get_acc=True) print("Epoch: %d Valid Accuracy: %.3f" % (i + 1, valid_accuracy)) test_accuracy = run_epoch(session, mtest, get_acc=True) print("Test Accuracy: %.3f" % test_accuracy) if FLAGS.save_path: print("Saving model to %s." % FLAGS.save_path) sv.saver.save(session, FLAGS.save_path, global_step=sv.global_step)
def evaluate(net, video_ids, anns_path, batch_size=64, experiment_dir=None, use_anns=False, balance=False): segments_df = dataframe_from_video_ids(video_ids, anns_path, use_anns=use_anns) test_data_loader = get_test_data_loaders(segments_df, batch_size, balance=balance) criterion = nn.BCELoss() optimizer = None net.eval() val_accuracy, y_true, y_score, results = run_epoch(test_data_loader, net, optimizer, criterion, 0) df = pd.DataFrame(results) df = df.drop_duplicates(subset=['video_id', 'start_seconds'], keep=False) print(df) save_results(results, experiment_dir, 0, mode='inference')
def main(cfg): net = SPRINSeg(6, cfg.fps_n).to("cuda") net.load_state_dict( torch.load(hydra.utils.to_absolute_path('sprin/epoch250.pt'))) pcs_test, segs_centered_test, segs_test = read_data( hydra.utils.to_absolute_path( "shapenet_part_seg_hdf5_data/ply_data_test*")) print(len(pcs_test)) run_epoch(net, pcs_test, segs_centered_test, segs_test, None, 1, train=False, ds=cfg.npoints, batchsize=1)
def _get_delta(self, indices, label_manager): """Try adding indices to the labeled set, train on labeled set, and return change in val metric after M epochs""" if type(indices) != list: indices = [indices] label_manager.reveal_labels(indices) labeled_dict = configure_split_dict( data=label_manager.get_labeled_subset(), split="labeled_test", split_name="labeled_test", get_train=True, verbose=False, grouper=self.grouper, batch_size=self.config.batch_size, config=self.config) unlabeled_dict = configure_split_dict( data=label_manager.get_unlabeled_subset(), split="unlabeled_test", split_name="unlabeled_test", get_eval=True, grouper=None, verbose=False, batch_size=self.config.unlabeled_batch_size, config=self.config) temp_model = copy.deepcopy(self.uncertainty_model) temp_model.train() for epoch in range(self.M): run_epoch(temp_model, labeled_dict, None, epoch, self.config, train=True) res, _ = run_epoch(temp_model, unlabeled_dict, None, 0, self.config, train=False) del temp_model label_manager.hide_labels(indices) return res[self.config.val_metric]
def train_phoneme(num_layers, lr, batch_size, hidden, numepoch, dropout, inputfeeding, cuda, maxlen, soft=True): dataset = Dataload(maxlen=maxlen) criterion = nn.NLLLoss(ignore_index=0, reduction='sum') model = full_model.make_model(dataset.src_num, dataset.trg_num, emb_size=32, hidden_size=hidden, num_layers=num_layers, dropout=dropout, inputfeeding=inputfeeding, soft=soft) optim = torch.optim.Adam(model.parameters(), lr=lr) eval_data = list(dataset.data_gen(batch_size=1, num_batches=100, eval=True)) dev_perplexities = [] if init.USE_CUDA and cuda: model.cuda() min_perplexity = 100 minp_iter = 0 max_accuracy = 0 maxa_iter = 0 for epoch in range(numepoch): print("Epoch %d" % epoch) model.train() data = dataset.data_gen(batch_size=batch_size, num_batches=100, eval=True) train.run_epoch(data, model, train.SimpleLossCompute(model.generator, criterion, optim)) model.eval() with torch.no_grad(): perplexity, accuracy = train.run_epoch(eval_data, model, train.SimpleLossCompute(model.generator, criterion, None)) if perplexity < min_perplexity: min_perplexity = perplexity minp_iter = epoch if accuracy > max_accuracy: max_accuracy = accuracy maxa_iter = epoch print("Evaluation perplexity: %f" % perplexity) print("Evaluation accuracy: %f" % accuracy) dev_perplexities.append(perplexity) print_e.print_examples(eval_data, dataset, model, n=2, max_len=maxlen) print("min perplexity: %f at %d iterations" % (min_perplexity, minp_iter)) print("max accuracy: %f at %d iterations" % (max_accuracy, maxa_iter)) return dev_perplexities
def run_test(model, basename, batch_size, criterion, subset, outname, device, inputdir_type0, inputdir_type1, num_examples_to_plot=100, num_workers=32): # For either multi or binary classifier use: testset = ActionOrNot(type0_pathname=inputdir_type0, type1_pathname=inputdir_type1) loader = torch.utils.data.DataLoader(testset, batch_size=batch_size, shuffle=False, pin_memory=True, num_workers=num_workers) print('Testing %d image examples..' % len(testset)) if subset is not None: type1 = np.asarray(testset.inds_type1_examples) # all pos type0 = np.random.choice(testset.inds_type0_examples, subset) # subset neg loader = torch.utils.data.DataLoader( testset, batch_size=batch_size, sampler=torch.utils.data.sampler.SubsetRandomSampler( np.concatenate((type1, type0))), shuffle=False, pin_memory=True, num_workers=num_workers) test_loss, test_acc, test_auc, misc = run_epoch(epoch=1, loader=loader, optimizer=None, model=model, criterion=criterion, device=device, prefix='Testing') test_total_outputs_class, test_total_gt_labels, test_total_filenames = misc[ 0], misc[1], misc[2] filename = os.path.join(outname, 'misclassifications_{}'.format(basename)) eval_model(test_total_outputs_class, test_total_gt_labels, test_total_filenames, outname=filename, num_examples_to_plot=num_examples_to_plot)
def evaluate(net, batch_size=64, experiment_dir=None, num_videos=10): writer = SummaryWriter(experiment_dir) anns_path = "data/v0.3.1-anns-5sec.csv" train_data_loader, val_data_loader = get_train_val_data_loaders(anns_path, batch_size) criterion = nn.BCELoss() optimizer = None print(set(list(train_data_loader.dataset.df['video_name']))) print(set(list(val_data_loader.dataset.df['video_name']))) net.eval() val_accuracy, y_true, y_score, results = run_epoch(val_data_loader, net, optimizer, criterion, 0) df = pd.DataFrame(results) print(df) save_results(results, '', 0)
def main(): # Carregar os dados de treinamento e teste # X: SOC SPKF, KPI BA, KPI BR, KPI TA, KPI TR # Y: SOC REAL num_classes = 10 X_train = np.loadtxt('../Datasets/x45.txt') y_train = np.loadtxt('../Datasets/y45.txt') X_test = np.loadtxt('../Datasets/x45.txt') y_test = np.loadtxt('../Datasets/y45.txt') ############################################################################## # Vetores do eixo x para plotar os gráficos time_train = len(y_train) + 1 train = np.arange(1, time_train, 1) time_test = len(y_test) + 1 test = np.arange(1, time_test, 1) # Plotando os dados y de treinamento e teste de entrada da Rede Neural plt.plot(train, y_train, 'r', label='train') plt.plot(test, y_test, 'b', label='test') plt.title('Neural Networks Output') plt.ylabel('SOC') plt.xlabel('time') plt.legend(framealpha=1, frameon=True); plt.show() # Plotando os dados X de treinamento de entrada da Rede Neural plt.plot(train, X_train[:,0], 'b', label='train') plt.plot(train, X_train, 'b', label='train') plt.title('Neural Networks Input') plt.ylabel('SOC') plt.xlabel('time') plt.legend(framealpha=1, frameon=True); plt.show() plt.plot(train, X_train[:,1], 'r', label='Aggression train') plt.plot(train, X_train[:,2], 'b', label='Release train') plt.title('Neural Networks Input') plt.ylabel('Brake KPI') plt.xlabel('time') plt.legend(framealpha=1, frameon=True); plt.show() plt.plot(train, X_train[:,3], 'r', label='Aggression train') plt.plot(train, X_train[:,4], 'b', label='Release train') plt.title('Neural Networks Input') plt.ylabel('Throttle KPI') plt.xlabel('time') plt.legend(framealpha=1, frameon=True); plt.show() # Plotando os dados X de teste de entrada da Rede Neural plt.plot(test, X_test[:,0], 'b', label='test') plt.title('Neural Networks Input') plt.ylabel('SOC') plt.xlabel('time') plt.legend(framealpha=1, frameon=True); plt.show() plt.plot(test, X_test[:,1], 'r', label='Aggression test') plt.plot(test, X_test[:,2], 'b', label='Release test') plt.title('Neural Networks Input') plt.ylabel('Brake KPI') plt.xlabel('time') plt.legend(framealpha=1, frameon=True); plt.show() plt.plot(test, X_test[:,3], 'r', label='Aggression test') plt.plot(test, X_test[:,4], 'b', label='Release test') plt.title('Neural Networks Input') plt.ylabel('Throttle KPI') plt.xlabel('time') plt.legend(framealpha=1, frameon=True); plt.show() ############################################################################## # Dividir os dados de treinamento em validação (10%) e treinamento (90%) dev_split_index = int(9 * len(X_train) / 10) X_val = X_train[dev_split_index:] y_val = y_train[dev_split_index:] X_train = X_train[:dev_split_index] y_train = y_train[:dev_split_index] # Randomizar os dados de treinamento para inserir na rede # permutation = np.array([i for i in range(len(X_train))]) # np.random.shuffle(permutation) #MODIFICAR # X_train = [X_train[i] for i in permutation] # y_train = [y_train[i] for i in permutation] # Dividindo os dados em batches para o treinamento batch_size_train = 8 batch_size_test = 1 train_batches = batchify_data(X_train, y_train, batch_size_train) val_batches = batchify_data(X_val, y_val, batch_size_train) test_batches = batchify_data(X_test, y_test, batch_size_test) ############################################################################## # Definindo modelo sequencial da Rede Neural Artifical Profunda model = nn.Sequential( nn.Linear(5, 10), nn.Hardtanh(), nn.Linear(10, 10), #hidden layer 1 nn.Hardtanh(), nn.Linear(10, 1), ) lr=0.05 momentum=0 ############################################################################## # Treinando o modelo com os batches de validação e treinamento no modelo train_model(train_batches, val_batches, model, lr=lr, momentum=momentum) # Validando o modelo com os dados de teste UDDS A123 a 25°C # Calculando loss, error, accuracy e SOC estimado do modelo loss, accuracy, error, sochat = run_epoch(test_batches, model.eval(), None) print ("Loss on test set:" + str(loss) + " Accuracy on test set: " + str(accuracy)) loss_spkf, accuracy_spkf, error_spkf = spkf_parameters(X_test[:,0], y_test) print ("Loss on SPKF set:" + str(loss_spkf) + " Accuracy on SPKF set: " + str(accuracy_spkf)) sochat = np.concatenate( sochat, axis=0 ) ############################################################################## # Plotando os resultados da Rede Neural Artificial Profunda plt.plot(range(len(error)), error) plt.ylabel('Lost Function') plt.xlabel('Iteration number') plt.show() plt.plot(range(len(error)), sochat) plt.ylabel('SOC Function') plt.xlabel('Iteration number') plt.show() #plt.plot(range(len(test)), y_test, 'r', label='Real SOC') plt.plot(range(len(y_test)), y_test, 'r', label='Real SOC') #plt.plot(range(len(test)), sochat, 'b', label='ANN SOC Estimator') plt.plot(range(len(sochat)), sochat, 'b', label='ANN SOC Estimator') #plt.plot(range(len(test)), X_test[:,0], 'g', label='SPKF SOC Estimator') plt.plot(range(len(y_test)), X_test[:,0], 'g', label='SPKF SOC Estimator') plt.title('Neural Networks Output') plt.ylabel('SOC') plt.xlabel('time') plt.legend(framealpha=1, frameon=True); plt.show() plt.plot(range(len(error)), sochat) plt.ylabel('SOC Function') plt.xlabel('Iteration number') plt.show()
sort_key=lambda x: (len(x.src), len(x.trg)), batch_size_fn=batch_size_fn, train=True) valid_iter = MyIterator(val, batch_size=BATCH_SIZE, device=0, repeat=False, sort_key=lambda x: (len(x.src), len(x.trg)), batch_size_fn=batch_size_fn, train=False) model_par = nn.DataParallel(model, device_ids=devices) model_opt = NoamOpt( model.src_emb[0].d_model, 1, 2000, torch.optim.Adam(model.parameters(), lr=0, betas=(0.9, 0.98), eps=1e-9)) for epoch in range(10): model_par.train() run_epoch((rebatch(pad_idx, b) for b in train_iter), model_par, MultiGPULossCompute(model.generator, criterion, devices=devices, opt=None)) model_par.eval() loss = run_epoch((rebatch(pad_idx, b) for b in valid_iter), model_par, MultiGPULossCompute(model.generator, criterion, devices=devices, opt=None)) print(loss)
torch.optim.Adam( model.parameters(), lr = 0, betas = (0.9, 0.98), eps = 1e-9 ) ) for epoch in range(10): model.train() run_epoch( data_gen( V, 30, 20 ), model, SimpleLossCompute( model.generator, criterion, model_opt ) ) model.eval() print( run_epoch( data_gen( V, 30, 5 ), model, SimpleLossCompute(
train.source_w2i, train.source_i2w = train.load_vocabs(config.source_vocab_path) train.target_w2i, train.target_i2w = train.load_vocabs(config.target_vocab_path) config.source_vocab_size = len(train.source_w2i) config.target_vocab_size = len(train.target_w2i) source_test = train.read_docs_to_seqs(config.source_test_path, train.source_w2i) target_test = train.read_docs_to_seqs(config.target_test_path, train.target_w2i) test_pairs = [(s_seq, t_seq) for s_seq, t_seq in zip(source_test, target_test)] source_batch, source_lengths, target_batch, target_lengths = train.get_batch(test_pairs, None) encoder = torch.load(checkpoint_path+"/encoder.model.iter"+str(iter_num)+".pth") decoder = torch.load(checkpoint_path+"/decoder.model.iter"+str(iter_num)+".pth") precision, preds = train.run_epoch(source_batch, source_lengths, target_batch, target_lengths, encoder, decoder, TRAIN=False) print precision fout = open("predict.result","w") for i in range(len(preds)): fout.write(" ".join([train.source_i2w[j] for j in source_test[i]])+"\n") fout.write(" ".join([train.target_i2w[j] for j in target_test[i]])+"\n") fout.write(" ".join([train.target_i2w[j] for j in preds[i]])+"\n") fout.write(str(preds[i] == target_test[i])+"\n") fout.write("\n") fout.close()
def train_model(config, verbose=True): print("\nLoading training data ...") train_data, valid_data = load_train_valid_data(config, verbose) if config.start_date is not None: print("Training start date: ", config.start_date) if config.start_date is not None: print("Training end date: ", config.end_date) tf_config = tf.ConfigProto(allow_soft_placement=True, log_device_placement=False, device_count={'GPU': 0}) with tf.Graph().as_default(), tf.Session(config=tf_config) as session: if config.seed is not None: tf.set_random_seed(config.seed) print("\nConstructing model ...") model = model_utils.get_model(session, config, verbose=verbose) if config.data_scaler is not None: start_time = time.time() print("Calculating scaling parameters ...", end=' ') sys.stdout.flush() scaling_params = train_data.get_scaling_params(config.data_scaler) model.set_scaling_params(session, **scaling_params) print("done in %.2f seconds." % (time.time() - start_time)) if config.early_stop is not None: print("Training will early stop without " "improvement after %d epochs." % config.early_stop) train_history = list() valid_history = list() lr = model.set_learning_rate(session, config.learning_rate) train_data.cache(verbose=verbose) valid_data.cache(verbose=verbose) for i in range(config.max_epoch): (train_mse, valid_mse) = run_epoch(session, model, train_data, valid_data, keep_prob=config.keep_prob, passes=config.passes, verbose=verbose) if verbose: print(('Epoch: %d Train MSE: %.6f Valid MSE: %.6f Learning' 'rate: %.4f') % (i + 1, train_mse, valid_mse, lr)) sys.stdout.flush() train_history.append(train_mse) valid_history.append(valid_mse) if re.match("Gradient|Momentum", config.optimizer): lr = model_utils.adjust_learning_rate(session, model, lr, config.lr_decay, train_history) return train_history, valid_history
raise ValueError("Requested optimizer not recognized:", params.optimizer) scheduler = lr_scheduler.StepLR( optimizer, step_size=20, gamma=0.5) time_train_start = time.time() for epoch in range(params.num_epochs): for phase in ['train', 'val']: epoch_loss = run_epoch( params=params, phase=phase, num_batches=params.steps_per_epoch, model=model, optimizer=optimizer, scheduler=scheduler, dataloader=dataloader[phase], device=device) dates = time.localtime() datestring = "-".join([str(dates.tm_year), str(dates.tm_mon), str(dates.tm_mday)]) timestring = ":".join([str(dates.tm_hour), str(dates.tm_min), str(dates.tm_min)]) plotter.plot(var_name='loss over epoch', split_name=phase, title_name='loss over epoch', x=epoch, y=epoch_loss)
if __name__ == '__main__': window_size = 40 batch_size = 512 text = load_file('../data/horoscope_2011.csv') text_idx, itos, stoi = preprocess_data(text) vocab_size = len(itos) src, tgt = make_arrays(text_idx, window_size) criterion = LabelSmoothing(size=vocab_size, padding_idx=0, smoothing=0.1) model = make_model(vocab_size, vocab_size, N=2) model_opt = NoamOpt( model.src_embed[0].d_model, 1, 400, torch.optim.Adam(model.parameters(), lr=0, betas=(0.9, 0.98), eps=1e-9)) for epoch in range(10): model.train() run_epoch(batch_generator(src, tgt, batch_size), model, SimpleLossCompute(model.generator, criterion, model_opt)) # BOS_WORD = '<s>' # EOS_WORD = '</s>' # BLANK_WORD = '<blank>' # SRC = data.Field( # sequential = True, # tokenize = tokenize_en, # lower = True, # pad_token = BLANK_WORD # ) # TGT = data.Field( # sequential = True, # tokenize = tokenize_en, # lower = True, # init_token = BOS_WORD,