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')
