def main(): trainer = Trainer() trainer.prepare_for_train(random_id = True, hist = "hist", ifDense_GCN = True, feedback = True, batch_size = 128, epoch_num = 40, val = 0.2) trainer.fit() #trainer.save_model("model.pkl") #trainer.load_model("model.pkl") trainer.score()
def train_test(config, logger): tot_acc = 0 tot_prec = 0 tot_rec = 0 tot_f1 = 0 tot_auc = 0 total_start_time = time.time() # Training for each fold for i in range(0, config.kfold): # To match the output filenames k = str(i + 1) # Load data iterator dataloader = Dataloader(config, k) # Load model arch = LSTM(config, dataloader).to(config.device) if config.model == 'cnn': arch = CNN(config, dataloader).to(config.device) # Print network configuration logger.info(arch) # Trainer model = Trainer(config, logger, dataloader, arch, k) # Train if not config.eval: logger.info("**************Training started !!!**************\n") logger.info("Starting training on {0}th-fold".format(k)) model.fit() # Test logger.info("**************Testing Started !!!**************\n") model.load_checkpoint() acc, prec, rec, f1, auc = model.predict() logger.info( "Accuracy: %6.3f Precision: %6.3f Recall: %6.3f FB1: %6.3f AUC: %6.3f" % (acc, prec, rec, f1, auc)) logger.info("***********************************************\n") # Calculate the metrics tot_acc += acc tot_prec += prec tot_rec += rec tot_f1 += f1 tot_auc += auc total_end_time = time.time() # Display final results epoch_mins, epoch_secs = utilities.epoch_time(total_start_time, total_end_time) logger.info("Epoch Time: %dm %ds" % (epoch_mins, epoch_secs)) logger.info( "Final_Accuracy;%6.3f;Final_Precision;%6.3f;Final_Recall;%6.3f;Final_FB1;%6.3f;Final_AUC;%6.3f " % (tot_acc / config.kfold, tot_prec / config.kfold, tot_rec / config.kfold, tot_f1 / config.kfold, tot_auc / config.kfold))
def main(config_fn, data_verbose=False): """""" # load config file config_fn = os.path.abspath(config_fn) config = load_config(config_fn) # launch data servers with data_context(config_fn, which_set=['train', 'valid'], verbose=data_verbose) as data_streams: # initialize trainer trainer = Trainer(config, data_streams) # train trainer.fit()
def process(self): """ Trains different model based on a csv-data containing the hyper_params. If a model is trained, results, parameters of model, coefficient mask and the hyperparaemters are saved in analysis_folder. Models are numbered in the same ordered as they are in the hyper_params.csv. """ rng = jax.random.PRNGKey(-1) rng_batch = npr.RandomState(5) for j, hyper_params in self.hyper_params_df.iterrows(): hyper_params = hyper_params.to_dict() path_save = self.analysis_folder + '/' + str(j) if os.path.isfile(path_save): continue else: loader = Loader(hyper_params) train_set = hyper_params['training_set'] X, dX, X_eval, dX_eval, t = self.data[train_set] loader.hyper_params['num_batches'], _ = divmod( X.shape[0], loader.hyper_params['batch_size']) loader.hyper_params['x_dim'] = X.shape[1] model, hyper_params = loader.create_model(rng) trainer = Trainer(X, dX, X_eval, dX_eval, t, model, hyper_params) results, params, coeff_mask = trainer.fit(rng_batch) with open(path_save, 'wb') as fp: pickle.dump([results, params, coeff_mask, hyper_params], fp)
def experiment(trial: optuna.Trial, train_dl, valid_dl, *, device='cpu', n_classes, n_epochs, input_shape): net = Net(input_shape, n_classes, trial).to(device) trainer = Trainer(trial, n_epochs=n_epochs, device=device) def epoch_end_callback(epoch, _, acc): trial.report(acc, epoch) if trial.should_prune(epoch): raise optuna.exceptions.TrialPruned() if acc < 0.05: # Prune really bad runs raise optuna.exceptions.TrialPruned() losses, accuracies = trainer.fit(net, train_dl, valid_dl, epoch_end_callback=epoch_end_callback) return accuracies[-1]
def main(): """ Main File """ # Parse argument config, logger = parse_args() if config.kfold > 0 and not config.eval: logger.info("Splitting dataset into {0}-fold".format(config.kfold)) splitter.main(input_file=config.data_file, output_dir=config.root_path, verbose=config.verbose, kfold=config.kfold, pos=config.use_pos, log_file=config.data_log) tot_acc = 0 tot_prec = 0 tot_rec = 0 tot_f1 = 0 for i in range(0, config.kfold): # To match the output filenames k = str(i + 1) if not config.eval: logger.info("Starting training on {0}th-fold".format(k)) # Load data iterator dataloader = Dataloader(config, k) # Debugging purpose. Don't delete # sample = next(iter(train_iter)) # print(sample.TEXT) # Load model if config.use_char or config.use_graph: assert config.use_char ^ config.use_graph, "Either use Character-Level or Grapheme-Level. Not both!!!" lstm = CharLSTMTagger(config, dataloader).to(config.device) else: lstm = LSTMTagger(config, dataloader).to(config.device) # Print network configuration logger.info(lstm) model = Trainer(config, logger, dataloader, lstm, k) if not config.eval: # Train logger.info("Training started !!!") model.fit() # Test model.load_checkpoint() logger.info("Testing Started !!!") acc, prec, rec, f1 = model.predict() logger.info( "Accuracy: %6.2f%%; Precision: %6.2f%%; Recall: %6.2f%%; FB1: %6.2f " % (acc, prec, rec, f1)) tot_acc += acc tot_prec += prec tot_rec += rec tot_f1 += f1 logger.info( "Final Accuracy: %6.2f%%; Final Precision: %6.2f%%; Final Recall: %6.2f%%; Final FB1: %6.2f " % (tot_acc / config.kfold, tot_prec / config.kfold, tot_rec / config.kfold, tot_f1 / config.kfold))
if config.dataset == 'mnist': model = SimpleLinear(in_size=28 * 28, out_size=10) else: num_langs = len(loaders[0].dataset.langs) vocab_size = len(loaders[0].dataset.char2index) model = SimpleRNN(in_size=vocab_size, hidden_size=config.hidden_size, out_size=num_langs) return model if __name__ == '__main__': data_dir = Path(__file__).parent / 'data/' data_dir.mkdir(parents=True, exist_ok=True) loaders = configure_dataloaders(data_dir) model = configure_model() trainer = Trainer( model=model, train_loader=loaders[0], valid_loader=loaders[1], ) try: trainer.fit() except KeyboardInterrupt: exit(0)
NewPad(), transforms.ToTensor(), transforms.Normalize([0.3967, 0.4193, 0.4018], [0.1837, 0.1673, 0.1833]) ]) return image_transformer(image).float(), mask train_image_path = './data/UDD5/train/splitted/src/' train_label_path = './fast_scnn/data/UDD5/train/splitted/gt/' test_image_path = './fast_scnn/data/UDD5/val/splitted/src/' test_label_path = './fast_scnn/data/UDD5/val/splitted/gt/' ds_train = UDD(train_image_path, train_label_path, transform=UDD_preprocessing) ds_test = UDD(test_image_path, test_label_path, transform=UDD_preprocessing) dl_train = DataLoader(ds_train, batch_size, shuffle=True) dl_test = DataLoader(ds_test, batch_size, shuffle=False) model = FastSCNN(num_classes=5) optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate) criterion = CrossEntropyLoss() success_metric = pixel_accuracy trainer = Trainer(model, criterion, optimizer, success_metric, device, None) fit_res = trainer.fit(dl_train, dl_test, num_epochs=num_epochs, checkpoints='checkpoints/' + model.__class__.__name__ + datetime.datetime.today().strftime("%m_%d")) print(fit_res)
trainer = Trainer( model=model, optimizer=optimizer, criterion=FocalDiceCoefLoss(d_weight=[1, 10, 20]), metrics={ 'Kd Dsc': DiceCoef(weight=[0, 1, 0]), 'Ca Dsc': DiceCoef(weight=[0, 0, 1]) }, scheduler=scheduler, tr_transform=tr_transform, vd_transform=vd_transform, ) trainer.save('init.pt') log_dir = "logs/Task00_Kidney/att-res-{}".format( datetime.now().strftime("%H%M%S")) trainer.load('logs/Task00_Kidney/att-res-065552-last.pt') trainer.fit( case_set, batch_size=1, epochs=500, # valid_split=0.2, num_samples=250, log_dir=log_dir, save_dir=log_dir, save_last=True, save_best=True, num_workers=2, pin_memory=True)
#gpu_device=0 #cuda.get_device(gpu_device).use() #model.to_gpu(gpu_device) tr_im = loadim(a=-1, j="trainimages") tr_ma = loadim(a=-1, j="trainmasks") #teimage=loadim(a=-1,j="test") #trdepth,tedepth=loadcsv() #trdepth=sorted(trdepth,key=lambda t:t[0]) #tedepth=sorted(tedepth,key=lambda t:t[0]) #tr_dep=[int(t[1]) for t in trdepth] #te_dep=[int(t[1]) for t in tedepth] #tr_im_ma_dep=[[tr_im[i],tr_ma[i],tr_dep[i]] for i in range(4000)] #tr_im_ma_dep=sorted(tr_im_ma_dep,key=lambda t:t[2]) gpu_device = 0 X = cuda.to_gpu(tr_im, device=0) Y = cuda.to_gpu(tr_ma, device=0) model = ResNet() cuda.get_device(gpu_device).use() model.to_gpu(gpu_device) trainer = Trainer(model) trainer.fit(X) df_loss = pd.DataFrame(trainer.loss) df_loss.to_csv('loss_csv')