def main():
X_train, y_train, inpz_train = load('data/train/merged.npz')
X_test, y_test, inpz_test = load('data/test/merged.npz')
# One-hot encoded
Y_train = to_categorical(y_train, 2)
Y_test = to_categorical(y_test, 2)
Phi_sizes, F_sizes = (100, 100, 128), (100, 100, 100)
efn = EFN(input_dim=2, Phi_sizes=Phi_sizes, F_sizes=F_sizes)
efn.load_weights('ckpts_Apr06_134930/ckpt-40-val_acc-0.73.hdf5')
ckpt_dir = strftime('ckpts_%b%d_%H%M%S')
if not osp.isdir(ckpt_dir): os.makedirs(ckpt_dir)
checkpoint_callback = ModelCheckpoint(
ckpt_dir + '/ckpt-{epoch:02d}-val_acc-{val_acc:.3f}.hdf5',
monitor='val_acc',
verbose=1,
save_best_only=False,
mode='max')
best_checkpoint_callback = ModelCheckpoint(ckpt_dir + '/ckpt-best.hdf5',
monitor='val_acc',
verbose=1,
save_best_only=True,
mode='max')
efn.fit([X_train[:, :, 0], X_train[:, :, 1:]],
Y_train,
epochs=40,
batch_size=64,
validation_data=([X_test[:, :, 0], X_test[:, :, 1:]], Y_test),
verbose=1,
callbacks=[checkpoint_callback, best_checkpoint_callback])
def PFN_AUC_calculation(jet_array_1, jet_array_2, train_size, test_size):
X = np.concatenate([jet_array_1, jet_array_2])[:,:,:4]
y = np.concatenate([np.ones(len(jet_array_1)), np.zeros(len(jet_array_2))])
################################### SETTINGS ###################################
# data controls
train, val, test = train_size, X.shape[0]-train_size-test_size, test_size
use_pids = True
# network architecture parameters
Phi_sizes, F_sizes = (100, 100, 128), (100, 100, 100)
# network training parameters
num_epoch = 10
batch_size = 500
################################################################################
# convert labels to categorical
Y = to_categorical(y, num_classes=2)
# preprocess by centering jets and normalizing pts
for x in X:
mask = x[:,0] > 0
yphi_avg = np.average(x[mask,1:3], weights=x[mask,0], axis=0)
x[mask,1:3] -= yphi_avg
x[mask,0] /= x[:,0].sum()
# handle particle id channel
if use_pids:
remap_pids(X, pid_i=3)
else:
X = X[:,:,:3]
# do train/val/test split
(X_train, X_val, X_test,
Y_train, Y_val, Y_test) = data_split(X, Y, val=val, test=test)
# build architecture
pfn = 0
with suppress_stdout():
pfn = PFN(input_dim=X.shape[-1], Phi_sizes=Phi_sizes, F_sizes=F_sizes)
# train model
pfn.fit(X_train, Y_train,
epochs=num_epoch,
batch_size=batch_size,
validation_data=(X_val, Y_val),
verbose=0)
# get predictions on test data
preds = pfn.predict(X_test, batch_size=1000)
# get area under the ROC curve
auc = roc_auc_score(Y_test[:,1], preds[:,1])
return auc
# Phi_sizes, F_sizes = (100, 100, 256), (100, 100, 100)
# network training parameters
num_epoch = 5
batch_size = 500
###############################################################################
# load data
X, y = qg_jets.load(train + val + test)
# ignore pid information
X = X[:, :, :3]
# convert labels to categorical
Y = to_categorical(y, num_classes=2)
print('Loaded quark and gluon jets')
# preprocess by centering jets and normalizing pts
for x in X:
mask = x[:, 0] > 0
yphi_avg = np.average(x[mask, 1:3], weights=x[mask, 0], axis=0)
x[mask, 1:3] -= yphi_avg
x[mask, 0] /= x[:, 0].sum()
print('Finished preprocessing')
# do train/val/test split
(z_train, z_val, z_test, p_train, p_val, p_test, Y_train, Y_val,
Y_test) = data_split(X[:, :, 0], X[:, :, 1:], Y, val=val, test=test)
