def train_network(folder, N, lx, ly): train_data_shape = (N, lx) test_data_shape = (N, ly) item_list = MemMapItemList.from_memfile(folder / "x.npy", data_shape=train_data_shape) splitted = item_list.random_split_by_pct(valid_pct=0.1) labeled = splitted.labels_from_memmap(folder / "y.npy", data_shape=test_data_shape) data_bunch = labeled.databunch( bs=512, num_workers=4 ) # Test few values to see what's best for your hw+data stack model = Validation_Net() learner = basic_train.Learner(data=data_bunch, model=model, true_wd=True, wd=0.0001, loss_func=Validation_Loss(), path=folder) learner.fit(3, lr=0.001) t0 = time.time() learner.fit(3, lr=0.001) t1 = time.time() print("Time {}".format(t1 - t0))
def train_model(model, epochs, lr, wd, module_string, ct, path): plt.close('all') learn = basic_train.Learner(data=db, model=model, loss_func=loss_func, wd=wd, callback_fns=ActivationStats, bn_wd=bn_wd, true_wd=true_wd) start = time.perf_counter() if ct: learn.load(path) print('Model loaded: ', path) learn.fit_one_cycle( epochs, max_lr=lr, wd=wd, callbacks=[ SaveModelCallback(learn, every='improvement', monitor='valid_loss', name='best_%s_bs%s_lr%.0e_wd%.0e' % (module_string, bs, lr, wd)) ]) end = time.perf_counter() delta_t = end - start return learn, delta_t
def train_ae(X, bs=1024, lr=1e-03, wd=1e-04, epochs=100): model = autoencoder() db = prepare_data(X, bs) learn = basic_train.Learner(data=db, model=model, loss_func=nn.MSELoss(), wd=wd, callback_fns=ActivationStats, bn_wd=False, true_wd=True) learn.fit(epochs, lr=lr, wd=wd) return model
def train_model(model, epochs, lr, wd): plt.close('all') learn = basic_train.Learner(data=db, model=model, loss_func=loss_func, wd=wd, callback_fns=ActivationStats, bn_wd=bn_wd, true_wd=true_wd) start = time.perf_counter() learn.fit_one_cycle(epochs, max_lr=lr, wd=wd) end = time.perf_counter() delta_t = end - start return learn, delta_t
def train_evaluate_model(model_class, num_epochs): model = model_class() train_dl, valid_dl, train_x, train_y, test_x, test_y = load_data(batch_size = 256) db = basic_data.DataBunch(train_dl, valid_dl) loss_func = nn.MSELoss() bn_wd = False # Don't use weight decay fpr batchnorm layers true_wd = True # wd will be used for all optimizers wd = 1e-6 plots_path, model_name = make_plots_dir(model_class) learn = basic_train.Learner(data=db, model=model, loss_func=loss_func, wd=wd, callback_fns=ActivationStats, bn_wd=bn_wd, true_wd=true_wd) #tr.lr_find(learn, start_lr=1e-8) #losses = [loss.item() for loss in learn.recorder.losses] #lr = round(learn.recorder.lrs[np.argmin(np.array(losses))], 4) #lr_plot = learn.recorder.plot(return_fig=True) #lr_plot.savefig('lr_plot.png') lr = 3e-4 learn.fit(num_epochs, lr=lr, wd=wd) learn.save(model_name) loss_plot = learn.recorder.plot_losses(return_fig=True) loss_plot.savefig(plots_path + 'loss_plot.png') plt.plot(learn.recorder.val_losses, marker='>') plt.savefig(plots_path + 'val_losses.png') plot_activations(learn, save = plots_path) loss = learn.validate()[0] plt.close('all') current_save_folder = plots_path make_plots(model, train_x, train_y, test_x, test_y, current_save_folder, model_name) return loss
tmp = train_folder.split('bs')[1] param_string = 'bs' + tmp save_dict_fname = 'save_dict' + param_string + '.pkl' path_to_save_dict = grid_search_folder + model_folder + '/' + train_folder + '/' + save_dict_fname saved_model_fname = 'best_' + module_name + '_' + param_string.split( '_pp')[0] path_to_saved_model = grid_search_folder + model_folder + '/' + 'models/' + saved_model_fname curr_save_folder = grid_search_folder + model_folder + '/' + train_folder + '/' nodes = model_folder.split('AE_')[1].split('_') nodes = [int(x) for x in nodes] model = module(nodes) learn = basic_train.Learner( data=db, model=model, loss_func=loss_func, true_wd=True, bn_wd=False, ) learn.model_dir = grid_search_folder + model_folder + '/' + 'models/' learn.load(saved_model_fname) learn.model.eval() idxs = (0, -1) # Pick events to compare data = torch.tensor(test[idxs[0]:idxs[1]].values, dtype=torch.float) pred = model(data).detach().numpy() data = data.detach().numpy() data_df = pd.DataFrame(data, columns=test.columns) pred_df = pd.DataFrame(pred, columns=test.columns)
for key in rootFile.keys(): df[key] = rootFile.array(key) df = df.rename(columns=lambda x: str(x).split("'")[1]) # Decide which features to use input_features = [ 'jetPt', 'jetEta', 'jetPhi', 'jetMass', 'jetGirth', 'jetArea', 'jetQGl', 'QG_mult', 'QG_ptD', 'QG_axis2' ] n_features = len(input_features) df = df[input_features] il = data_block.ItemList(df.values) # basic ItemList class in fastai seed = 37 ils = il.split_by_rand_pct(valid_pct=0.2, seed=seed) lls = ils.label_from_lists(ils.train, ils.valid) db = lls.databunch(bs=4, num_workers=1) model = myAE().double() def my_loss_func(input, target): np.power(target - input, 2).mean() #loss_func = nn.MSELoss() loss_func = my_loss_func learn = basic_train.Learner(data=db, model=model, loss_func=loss_func)
test_y = test_x # Create datasets train_ds = TensorDataset(torch.tensor(train_x.values), torch.tensor(train_y.values)) valid_ds = TensorDataset(torch.tensor(test_x.values), torch.tensor(test_y.values)) # Create DataLoaders train_dl, valid_dl = utils.get_data(train_ds, valid_ds, bs=256) # Create DataBunch db = basic_data.DataBunch(train_dl, valid_dl) # Create model and Learner model = AE_3D_200() bn_wd = False # Don't use weight decay fpr batchnorm layers true_wd = True # wd will be used for all optimizers wd = 1e-6 learn = basic_train.Learner(data=db, model=model, loss_func=loss_func, wd=wd, bn_wd=bn_wd, true_wd=true_wd) # Load trained model learn.load('AE_3D_200_no1cycle_trainforever') # Test the model and make plots plt.close('all') unit_list = ['[GeV]', '[rad]', '[rad]', '[GeV]'] variable_list = [r'$p_T$', r'$\eta$', r'$\phi$', r'$E$'] line_style = ['--', '-'] colors = ['orange', 'c'] markers = ['*', 's'] model.to('cpu')