def calc_jsd(args, X, G, dist):
print("evaluating JSD")
G.eval()
bins = [np.arange(-1, 1, 0.02), np.arange(-1, 1, 0.02), np.arange(-1, 1, 0.01)]
N = len(X)
jsds = []
for j in tqdm(range(10)):
gen_out = utils.gen(args, G, dist=dist, num_samples=args.batch_size).cpu().detach().numpy()
for i in range(int(args.num_samples / args.batch_size)):
gen_out = np.concatenate((gen_out, utils.gen(args, G, dist=dist, num_samples=args.batch_size).cpu().detach().numpy()), 0)
gen_out = gen_out[:args.num_samples]
sample = X[rng.choice(N, size=args.num_samples, replace=False)].cpu().detach().numpy()
jsd = []
for i in range(3):
hist1 = np.histogram(gen_out[:, :, i].reshape(-1), bins=bins[i], density=True)[0]
hist2 = np.histogram(sample[:, :, i].reshape(-1), bins=bins[i], density=True)[0]
jsd.append(jensenshannon(hist1, hist2))
jsds.append(jsd)
return np.mean(np.array(jsds), axis=0), np.std(np.array(jsds), axis=0)
def train_model(train_files, model_save_path):
""" Main function to train model.
Inputs:
- train_files: files we will use to train our model.
- model_save_path: path to save the model.
"""
#Split the data between training and validation. The variable "test_size" is 0.1 (10%) the percentage for validation.
# ---> train_test_split is a function that randomly splits the data. For now we won't cherry pick our random state.
train, val = train_test_split(train_files,
test_size=0.1) #, random_state=1337)
# Load all our train data
train_dict = {k: np.load(k) for k in train}
# Load all our validation data
val_dict = {k: np.load(k) for k in val}
print("Validating: " + str(val_dict))
#The model architecture has 3 repeated sets of two 1-D convolutional (Conv1D) layers, 1-D max-pooling and spatial dropout layers.
# This is followed by two Conv1D, 1-D global max-pooling, dropout and dense layers. We finally have a dropout layer as the output of "Base-CNN".
# This is fed to the Time-Distributed Base-CNN model, and then a 1-D convolutional layer, spatial dropout, another 1-D convolutional layer, dropout, 1D conv and finally the multiclass sleep labels.
model = get_model_cnn()
# Training
#This is useful to avoid overfitting. Saves what is the best so far for validation accuracy (for every epoch).
checkpoint = ModelCheckpoint(model_save_path,
monitor='val_acc',
verbose=1,
save_best_only=True,
mode='max')
early = EarlyStopping(monitor="val_acc",
mode="max",
patience=20,
verbose=1)
#Learning rate is reduced each time the validation accuracy plateaus using ReduceLROnPlateau Keras Callbacks.
redonplat = ReduceLROnPlateau(monitor="val_acc",
mode="max",
patience=5,
verbose=2)
callbacks_list = [checkpoint, redonplat]
model.fit_generator(gen(train_dict, aug=False),
validation_data=gen(val_dict),
epochs=25,
verbose=2,
steps_per_epoch=1000,
validation_steps=300,
callbacks=callbacks_list)
#And finally we save our model!
model.save(model_save_path)
def train_D(data, labels=None, gen_data=None):
if args.debug: print("dtrain")
D.train()
D_optimizer.zero_grad()
run_batch_size = data.shape[0]
deb = run_batch_size != args.batch_size
if gen_data is None:
gen_data = utils.gen(args, G, normal_dist, run_batch_size, labels=labels)
if args.augment:
p = args.aug_prob if not args.adaptive_prob else losses['p'][-1]
data = augment.augment(args, data, p)
gen_data = augment.augment(args, gen_data, p)
D_real_output = D(data.clone(), labels, deb)
if args.debug or run_batch_size != args.batch_size:
print("D real output: ")
print(D_real_output[:10])
D_fake_output = D(gen_data, labels, deb)
if args.debug or run_batch_size != args.batch_size:
print("D fake output: ")
print(D_fake_output[:10])
D_loss, D_loss_items = utils.calc_D_loss(args, D, data, gen_data, D_real_output, D_fake_output, run_batch_size, Y_real, Y_fake)
D_loss.backward()
D_optimizer.step()
return D_loss_items
def train_acgd(data):
if args.debug: print("acgd train")
D.train()
G.train()
optimizer.zero_grad()
run_batch_size = data.shape[0] if not args.gcnn else data.y.shape[0]
gen_data = utils.gen(args, G, normal_dist, run_batch_size)
if (args.gcnn):
gen_data = utils.convert_to_batch(args, gen_data, run_batch_size)
if args.augment:
p = args.aug_prob if not args.adaptive_prob else losses['p'][-1]
data = utils.rand_translate(args, data, p)
gen_data = utils.rand_translate(args, gen_data, p)
D_real_output = D(data.clone())
D_fake_output = D(gen_data)
D_loss, D_loss_items = utils.calc_D_loss(args, D, data, gen_data,
D_real_output, D_fake_output,
run_batch_size)
optimizer.step(loss=D_loss)
G.eval()
with torch.no_grad():
G_loss = utils.calc_G_loss(args, D_fake_output)
return D_loss_items, G_loss.item()
def train_G(data):
if args.debug: print("gtrain")
G.train()
G_optimizer.zero_grad()
gen_data = utils.gen(args, G, normal_dist, args.batch_size)
if (args.gcnn):
gen_data = utils.convert_to_batch(args, gen_data, args.batch_size)
if args.augment:
p = args.aug_prob if not args.adaptive_prob else losses['p'][-1]
gen_data = augment.augment(args, gen_data, p)
if (args.unrolled_steps > 0):
D_backup = deepcopy(D)
for i in range(args.unrolled_steps - 1):
train_D(data, gen_data=gen_data, unrolled=True)
D_fake_output = D(gen_data)
G_loss = utils.calc_G_loss(args, D_fake_output, Y_real)
G_loss.backward()
G_optimizer.step()
if (args.unrolled_steps > 0):
D.load(D_backup)
return G_loss.item()
def train_G(data, labels=None, epoch=0):
logging.debug("gtrain")
G.train()
G_optimizer.zero_grad()
run_batch_size = labels.shape[
0] if labels is not None else args.batch_size
gen_data = utils.gen(args, G, run_batch_size, labels=labels)
if args.augment:
p = args.aug_prob if not args.adaptive_prob else losses['p'][-1]
gen_data = augment.augment(args, gen_data, p)
D_fake_output = D(gen_data, labels, epoch=epoch)
logging.debug("D fake output:")
logging.debug(D_fake_output[:10])
G_loss = utils.calc_G_loss(args, D_fake_output, Y_real, run_batch_size,
mse)
G_loss.backward()
G_optimizer.step()
return G_loss.item()
def sign():
tac = request.form.get("tac")
user_id = request.form.get("user_id")
if not all([tac, user_id]):
return 'argements error', 401
sign = gen(ws, tac, user_id)
return jsonify({'signature': sign, 'user-agent': ua})
def train_D(data, gen_data=None, unrolled=False):
if args.debug: print("dtrain")
D.train()
D_optimizer.zero_grad()
run_batch_size = data.shape[0] if not args.gcnn else data.y.shape[0]
if gen_data is None:
gen_data = utils.gen(args, G, normal_dist, run_batch_size)
if (args.gcnn):
gen_data = utils.convert_to_batch(args, gen_data,
run_batch_size)
if args.augment:
p = args.aug_prob if not args.adaptive_prob else losses['p'][-1]
data = augment.augment(args, data, p)
gen_data = augment.augment(args, gen_data, p)
D_real_output = D(data.clone())
D_fake_output = D(gen_data)
D_loss, D_loss_items = utils.calc_D_loss(args, D, data, gen_data,
D_real_output, D_fake_output,
run_batch_size, Y_real,
Y_fake)
D_loss.backward(create_graph=unrolled)
D_optimizer.step()
return D_loss_items
def get_sign():
global ws, tac_queue
user_id = request.form.get("user_id")
if len(tac_queue) == 0:
return jsonify({
'error': '1',
})
tac_queue = tac_queue[-10:]
tac = random.choice(tac_queue)
# 异步程序一直获取sign
sign = gen(ws, tac, user_id)
return jsonify({'signature': sign, 'user-agent': ua})
def sign_userid(user_id):
global ws, tac_queue
if len(tac_queue) == 0:
return jsonify({
'error': '1',
})
tac_queue = tac_queue[-5:]
tac = random.choice(tac_queue)
# 异步程序一直获取sign
sign = gen(ws, tac, user_id)
return jsonify({'signature': sign, 'user-agent': ua})
def main():
csv = 'data/train.csv'
train_idx, mask_count_df, train_df, val_idx = gen(csv, False)
data = (train_idx, mask_count_df, train_df, val_idx)
showpred = 0
st.sidebar.title("Content")
st.sidebar.info("Cloud image segmentation!")
st.sidebar.title("Train Neural Network")
if st.sidebar.button("Train CNN"):
train((img_h, img_w, 3), data)
st.sidebar.title("Predict New Images")
onlyfiles = [
f for f in listdir('/home/zsh/underStandingCloud/testImages/')
if isfile(join('/home/zsh/underStandingCloud/testImages/', f))
]
imageselect = st.sidebar.selectbox("Pick an image.", onlyfiles)
if st.sidebar.button("Predict "):
showpred = 1
prediction, img = pre("/home/zsh/underStandingCloud/testImages/" +
imageselect)
st.title("Origin image")
st.write(
"Pick an image from the left. You will be able to view the image.")
st.write("When you're ready, submit a prediction on the left.")
st.write("")
image = Image.open("/home/zsh/underStandingCloud/testImages/" +
imageselect)
st.image(image, caption="Let's predict the image!", use_column_width=True)
if showpred == 1:
st.title("Segment image")
st.write(
"Pick an image from the left. You will be able to view the image.")
st.write("When you're ready, submit a prediction on the left.")
st.write("")
temp = img
masks, class_names, boxes, class_ids = gen_instances(prediction)
masks = np.array(masks)
masked_image = display_instances(temp, boxes, masks, class_ids,
class_names)
image = Image.fromarray(
cv2.cvtColor(masked_image.astype(np.uint8), cv2.COLOR_BGR2RGB))
st.image(image, caption="final result", use_column_width=True)
def get_fid(args, C, G, dist, mu2, sigma2):
print("evaluating fid")
G.eval()
C.eval()
num_iters = np.ceil(float(args.fid_eval_size) / float(args.fid_batch_size))
with torch.no_grad():
for i in tqdm(range(int(num_iters))):
gen_data = utils.tg_transform(args, utils.gen(args, G, dist, args.fid_batch_size))
if(i == 0):
activations = C(gen_data)
else:
activations = torch.cat((C(gen_data), activations), axis=0)
activations = activations.cpu().detach().numpy()
mu1 = np.mean(activations, axis=0)
sigma1 = np.cov(activations, rowvar=False)
fid = utils.calculate_frechet_distance(mu1, sigma1, mu2, sigma2)
print("fid:" + str(fid))
return fid
def train_D(data, labels=None, gen_data=None, epoch=0, print_output=False):
logging.debug("dtrain")
log = logging.info if print_output else logging.debug
D.train()
D_optimizer.zero_grad()
G.eval()
run_batch_size = data.shape[0]
D_real_output = D(data.clone(), labels, epoch=epoch)
log("D real output: ")
log(D_real_output[:10])
if gen_data is None:
gen_data = utils.gen(args, G, run_batch_size, labels=labels)
if args.augment:
p = args.aug_prob if not args.adaptive_prob else losses['p'][-1]
data = augment.augment(args, data, p)
gen_data = augment.augment(args, gen_data, p)
log("G output: ")
log(gen_data[:2, :10, :])
D_fake_output = D(gen_data, labels, epoch=epoch)
log("D fake output: ")
log(D_fake_output[:10])
D_loss, D_loss_items = utils.calc_D_loss(args, D, data, gen_data,
D_real_output, D_fake_output,
run_batch_size, Y_real,
Y_fake, mse)
D_loss.backward()
D_optimizer.step()
return D_loss_items
})
X = JetsDataset(args)
labels = X[:][1]
# X_loaded = DataLoader(X, shuffle=True, batch_size=32, pin_memory=True)
X = X[:][0]
N = len(X)
rng = np.random.default_rng()
num_samples = 100000
if args.clabels:
gen_out = utils.gen(args,
G,
dist=normal_dist,
num_samples=batch_size,
labels=labels[:128]).cpu().detach().numpy()
for i in tqdm(range(int(num_samples / batch_size))):
gen_out = np.concatenate(
(gen_out,
utils.gen(args,
G,
dist=normal_dist,
num_samples=batch_size,
labels=labels[128 * (i + 1):128 *
(i + 2)]).cpu().detach().numpy()), 0)
gen_out = gen_out[:num_samples]
else:
gen_out = utils.gen(args, G, dist=normal_dist,
num_samples=batch_size).cpu().detach().numpy()
return new_d
expanded_train_dict = expand_dict(train_dict)
expanded_test_dict = expand_dict(test_dict)
expanded_val_dict = expand_dict(val_dict)
#train_only_x = [i['x'] for i in expanded_train_dict.values()]
#predict(model, np.array(train_only_x))
counter = 0
background = []
for i in gen(train_dict, aug=False):
#print("Y SHAPE")
#print(i[1].shape)
only_x = i[0]
background.append(only_x)
counter += 1
if counter > 100:
break
background = np.array(background)
#background = np.array(train_only_x)
def calc_w1(args, X, G, dist, losses, X_loaded=None):
print("evaluating 1-WD")
num_batches = np.array(100000 / np.array(args.w1_num_samples), dtype=int)
# num_batches = [5, 5, 5]
G.eval()
N = len(X)
for k in range(len(args.w1_num_samples)):
print("Num Samples: " + str(args.w1_num_samples[k]))
w1s = []
if args.jf: w1js = []
for j in tqdm(range(num_batches[k])):
gen_out = utils.gen(args, G, dist=dist, num_samples=args.batch_size, X_loaded=X_loaded).cpu().detach().numpy()
for i in range(int(args.w1_num_samples[k] / args.batch_size)):
gen_out = np.concatenate((gen_out, utils.gen(args, G, dist=dist, num_samples=args.batch_size, X_loaded=X_loaded).cpu().detach().numpy()), 0)
gen_out = gen_out[:args.w1_num_samples[k]]
sample = X[rng.choice(N, size=args.w1_num_samples[k])].cpu().detach().numpy()
w1 = []
for i in range(3):
w1.append(wasserstein_distance(sample[:, :, i].reshape(-1), gen_out[:, :, i].reshape(-1)))
w1s.append(w1)
if args.jf:
realj = []
genj = []
for i in range(args.w1_num_samples[k]):
jetv = LorentzVector()
for part in sample[i]:
vec = LorentzVector()
vec.setptetaphim(part[2], part[0], part[1], 0)
jetv += vec
realj.append([jetv.mass, jetv.pt])
for i in range(args.w1_num_samples[k]):
jetv = LorentzVector()
for part in gen_out[i]:
vec = LorentzVector()
vec.setptetaphim(part[2], part[0], part[1], 0)
jetv += vec
genj.append([jetv.mass, jetv.pt])
w1j = []
for i in range(len(args.jet_features)):
w1j.append(wasserstein_distance(np.array(realj)[:, i], np.array(genj)[:, i]))
w1js.append(w1j)
losses['w1_' + str(args.w1_num_samples[k]) + 'm'].append(np.mean(np.array(w1s), axis=0))
losses['w1_' + str(args.w1_num_samples[k]) + 'std'].append(np.std(np.array(w1s), axis=0))
if args.jf:
losses['w1j_' + str(args.w1_num_samples[k]) + 'm'].append(np.mean(np.array(w1js), axis=0))
losses['w1j_' + str(args.w1_num_samples[k]) + 'std'].append(np.std(np.array(w1js), axis=0))
losses['w1_1000m'] = []
losses['w1_100m'] = []
losses['w1_10000std'] = []
losses['w1_1000std'] = []
losses['w1_100std'] = []
for i in range(0, epochs + 1, 5):
print(i)
# if i != 535: continue # COMMENT OUT
G = torch.load(full_path + 'G_' + str(i) + '.pt', map_location=device)
for k in range(len(num_samples)):
print("Num Samples: " + str(num_samples[k]))
w1s = []
for j in tqdm(range(num_batches[k])):
gen_out = utils.gen(utils.objectview(args),
G,
dist=normal_dist,
num_samples=batch_size).cpu().detach().numpy()
for i in range(int(num_samples[k] / batch_size)):
gen_out = np.concatenate(
(gen_out,
utils.gen(utils.objectview(args),
G,
dist=normal_dist,
num_samples=batch_size).cpu().detach().numpy()),
0)
gen_out = gen_out[:num_samples[k]]
sample = X[rng.choice(N,
size=num_samples[k])].cpu().detach().numpy()
w1 = []
def save_sample_outputs(args, D, G, dist, name, epoch, losses, k=-1, j=-1):
print("drawing figs")
fig = plt.figure(figsize=(10, 10))
if (args.fid): plt.suptitle("FID: " + str(losses['fid'][-1]))
num_ims = args.num_samples
noise = torch.load(args.noise_path + args.noise_file_name).to(args.device)
gen_out = utils.gen(args, G, noise=noise[:args.batch_size],
disp=True).cpu().detach().numpy()
for i in range(int(num_ims / args.batch_size)):
gen_out = np.concatenate(
(gen_out,
utils.gen(args,
G,
noise=noise[args.batch_size * (i + 1):args.batch_size *
(i + 2)],
disp=True).cpu().detach().numpy()), 0)
gen_out = gen_out[:num_ims]
# print(gen_out)
# if(args.sparse_mnist):
# gen_out = gen_out * [28, 28, 1] + [14, 14, 1]
#
# for i in range(1, num_ims + 1):
# fig.add_subplot(10, 10, i)
# im_disp = np.zeros((28, 28)) - 0.5
#
# im_disp += np.min(gen_out[i - 1])
#
# for x in gen_out[i - 1]:
# x0 = int(round(x[0])) if x[0] < 27 else 27
# x0 = x0 if x0 > 0 else 0
#
# x1 = int(round(x[1])) if x[1] < 27 else 27
# x1 = x1 if x1 > 0 else 0
#
# im_disp[x1, x0] = x[2]
#
# plt.imshow(im_disp, cmap=cm.gray_r, interpolation='nearest')
# plt.axis('off')
# else:
node_r = 30
im_px = 1000
gen_out[gen_out > 0.47] = 0.47
gen_out[gen_out < -0.5] = -0.5
gen_out = gen_out * [im_px, im_px, 1] + [(im_px + node_r) / 2,
(im_px + node_r) / 2, 0.55]
for i in range(1, num_ims + 1):
fig.add_subplot(10, 10, i)
im_disp = draw_graph(gen_out[i - 1], node_r, im_px)
plt.imshow(im_disp, cmap=cm.gray_r, interpolation='nearest')
plt.axis('off')
g_only = "_g_only_" + str(k) + "_" + str(j) if j > -1 else ""
name = args.name + "/" + str(epoch) + g_only
plt.savefig(args.figs_path + name + ".pdf", bbox_inches='tight')
plt.close()
plt.figure()
if (args.loss == "og" or args.loss == "ls"):
plt.plot(losses['Dr'], label='Discriminitive real loss')
plt.plot(losses['Df'], label='Discriminitive fake loss')
plt.plot(losses['G'], label='Generative loss')
elif (args.loss == 'w'):
plt.plot(losses['D'], label='Critic loss')
elif (args.loss == 'hinge'):
plt.plot(losses['Dr'], label='Discriminitive real loss')
plt.plot(losses['Df'], label='Discriminitive fake loss')
plt.plot(losses['G'], label='Generative loss')
# plt.plot(losses['D'], label='Disciriminative total loss')
if (args.gp): plt.plot(losses['gp'], label='Gradient penalty')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()
plt.savefig(args.losses_path + name + ".pdf", bbox_inches='tight')
plt.close()
if args.fid:
fid_5 = losses['fid'][::5]
x = np.arange(len(losses['fid']), step=5)
plt.figure()
plt.plot(x, np.log10(fid_5))
# plt.ylim((0, 5))
plt.xlabel('Epoch')
plt.ylabel('Log10FID')
# plt.legend()
plt.savefig(args.losses_path + name + "_fid.pdf", bbox_inches='tight')
plt.close()
if (args.gp):
np.savetxt(args.losses_path + args.name + "/" + "gp.txt", losses['gp'])
np.savetxt(args.losses_path + args.name + "/" + "D.txt", losses['D'])
np.savetxt(args.losses_path + args.name + "/" + "G.txt", losses['G'])
np.savetxt(args.losses_path + args.name + "/" + "Dr.txt", losses['Dr'])
np.savetxt(args.losses_path + args.name + "/" + "Df.txt", losses['Df'])
if args.fid:
np.savetxt(args.losses_path + args.name + "/" + "fid.txt",
losses['fid'])
try:
if (j == -1):
remove(args.losses_path + args.name + "/" + str(epoch - 5) +
".pdf")
remove(args.losses_path + args.name + "/" + str(epoch - 5) +
"_fid.pdf")
else:
remove(args.losses_path + args.name + "/" + str(epoch) +
"_g_only_" + str(k) + "_" + str(j - 5) + ".pdf")
except:
print("couldn't remove loss file")
print("saved figs")
n_channels=config.channels,
n_classes=config.n_classes)
earlystopping = EarlyStopping(monitor='loss', patience=config.es_patience)
reduce_lr = ReduceLROnPlateau(monitor='loss',
patience=config.rlrop_patience,
factor=config.decay_drop,
min_lr=1e-6)
checkpoint = ModelCheckpoint(filepath='weights-{epoch:03d}-{loss:.2f}.h5',
monitor='loss',
save_best_only=False,
save_weights_only=True)
metric_list = [dice_coef]
callback_list = [earlystopping, reduce_lr, checkpoint]
optimizer = Adam(lr=config.learning_rate)
model.compile(optimizer=optimizer, loss=bce_dice_loss, metrics=metric_list)
checkpoint.set_model(model)
model.fit_generator(train_generator,
validation_data=val_generator,
callbacks=callback_list,
epochs=100,
initial_epoch=0)
if __name__ == '__main__':
csv = 'data/train.csv'
train_idx, mask_count_df, train_df, val_idx = gen(csv, False)
data = (train_idx, mask_count_df, train_df, val_idx)
model = unet((320, 480, 3))
train((320, 480, 3), data)
def save_sample_outputs(args,
D,
G,
X,
dist,
name,
epoch,
losses,
X_loaded=None):
print("drawing figs")
plt.rcParams.update({'font.size': 16})
plt.style.use(hep.style.CMS)
# if(args.fid): plt.suptitle("FID: " + str(losses['fid'][-1]))
# noise = torch.load(args.noise_path + args.noise_file_name).to(args.device)
G.eval()
gen_out = utils.gen(args,
G,
dist=dist,
num_samples=args.batch_size,
X_loaded=X_loaded).cpu().detach().numpy()
for i in range(int(args.num_samples / args.batch_size)):
gen_out = np.concatenate(
(gen_out,
utils.gen(args,
G,
dist=dist,
num_samples=args.batch_size,
X_loaded=X_loaded).cpu().detach().numpy()), 0)
gen_out = gen_out[:args.num_samples]
if args.coords == 'cartesian':
labels = ['$p_x$ (GeV)', '$p_y$ (GeV)', '$p_z$ (GeV)']
bin = np.arange(-500, 500, 10)
bins = [bin, bin, bin]
elif args.coords == 'polarrel':
labels = ['$\eta^{rel}$', '$\phi^{rel}$', '$p_T^{rel}$']
if args.jets == 'g':
bins = [
np.arange(-0.3, 0.3, 0.005),
np.arange(-0.3, 0.3, 0.005),
np.arange(0, 0.2, 0.002)
]
elif args.jets == 't':
bins = [
np.arange(-0.5, 0.5, 0.005),
np.arange(-0.5, 0.5, 0.005),
np.arange(0, 0.2, 0.002)
]
elif args.coords == 'polarrelabspt':
labels = ['$\eta^{rel}$', '$\phi^{rel}$', '$p_T (GeV)$']
bins = [
np.arange(-0.5, 0.5, 0.01),
np.arange(-0.5, 0.5, 0.01),
np.arange(0, 400, 4)
]
labelsj = ['mass (GeV)', '$p_T (GeV)']
# print(X)
# print(X.shape)
if args.coords == 'cartesian':
Xplot = X.cpu().detach().numpy() * args.maxp / args.norm
gen_out = gen_out * args.maxp / args.norm
else:
Xplot = X.cpu().detach().numpy()
Xplot = Xplot / args.norm
Xplot[:, :, 2] += 0.5
Xplot *= args.maxepp
gen_out = gen_out / args.norm
gen_out[:, :, 2] += 0.5
gen_out *= args.maxepp
for i in range(args.num_samples):
for j in range(args.num_hits):
if gen_out[i][j][2] < 0:
gen_out[i][j][2] = 0
print(Xplot.shape)
print(gen_out.shape)
print(Xplot[0][:10])
print(gen_out[0][:10])
real_masses = []
gen_masses = []
for i in range(args.num_samples):
jetv = LorentzVector()
for part in Xplot[i]:
vec = LorentzVector()
vec.setptetaphim(part[2], part[0], part[1], 0)
jetv += vec
real_masses.append(jetv.mass)
for i in range(args.num_samples):
jetv = LorentzVector()
for part in gen_out[i]:
vec = LorentzVector()
vec.setptetaphim(part[2], part[0], part[1], 0)
jetv += vec
gen_masses.append(jetv.mass)
fig = plt.figure(figsize=(30, 8))
for i in range(3):
fig.add_subplot(1, 4, i + 1)
plt.ticklabel_format(axis='y', scilimits=(0, 0), useMathText=True)
_ = plt.hist(Xplot[:, :, i].reshape(-1),
bins[i],
histtype='step',
label='Real',
color='red')
_ = plt.hist(gen_out[:, :, i].reshape(-1),
bins[i],
histtype='step',
label='Generated',
color='blue')
plt.xlabel('Particle ' + labels[i])
plt.ylabel('Number of Particles')
# plt.title('JSD = ' + str(round(losses['jsdm'][-1][i], 3)) + ' ± ' + str(round(losses['jsdstd'][-1][i], 3)))
plt.legend(loc=1, prop={'size': 18})
binsm = np.arange(0, 0.225, 0.0045)
fig.add_subplot(1, 4, 4)
plt.ticklabel_format(axis='y', scilimits=(0, 0), useMathText=True)
# plt.ticklabel_format(axis='x', scilimits=(0, 0), useMathText=True)
_ = plt.hist(real_masses,
bins=binsm,
histtype='step',
label='Real',
color='red')
_ = plt.hist(gen_masses,
bins=binsm,
histtype='step',
label='Generated',
color='blue')
plt.xlabel('Jet $m/p_{T}$')
plt.ylabel('Jets')
plt.legend(loc=1, prop={'size': 18})
name = args.name + "/" + str(epoch)
plt.tight_layout(2.0)
plt.savefig(args.figs_path + name + ".pdf", bbox_inches='tight')
plt.close()
plt.figure()
if (args.loss == "og" or args.loss == "ls"):
plt.plot(losses['Dr'], label='Discriminitive real loss')
plt.plot(losses['Df'], label='Discriminitive fake loss')
plt.plot(losses['G'], label='Generative loss')
elif (args.loss == 'w'):
plt.plot(losses['D'], label='Critic loss')
elif (args.loss == 'hinge'):
plt.plot(losses['Dr'], label='Discriminitive real loss')
plt.plot(losses['Df'], label='Discriminitive fake loss')
plt.plot(losses['G'], label='Generative loss')
# plt.plot(losses['D'], label='Disciriminative total loss')
if (args.gp): plt.plot(losses['gp'], label='Gradient penalty')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()
plt.savefig(args.losses_path + name + ".pdf", bbox_inches='tight')
plt.close()
if args.jf:
real_masses = []
real_pts = []
gen_masses = []
gen_pts = []
for i in range(args.num_samples):
jetv = LorentzVector()
for part in Xplot[i]:
vec = LorentzVector()
vec.setptetaphim(part[2], part[0], part[1], 0)
jetv += vec
real_masses.append(jetv.mass)
real_pts.append(jetv.pt)
for i in range(args.num_samples):
jetv = LorentzVector()
for part in gen_out[i]:
vec = LorentzVector()
vec.setptetaphim(part[2], part[0], part[1], 0)
jetv += vec
gen_masses.append(jetv.mass)
gen_pts.append(jetv.pt)
mass_bins = np.arange(0, 400, 4)
pt_bins = np.arange(0, 3000, 30)
fig = plt.figure(figsize=(16, 8))
fig.add_subplot(1, 2, 1)
plt.ticklabel_format(axis='y', scilimits=(0, 0), useMathText=True)
_ = plt.hist(real_masses,
bins=mass_bins,
histtype='step',
label='real',
color='red')
_ = plt.hist(gen_masses,
bins=mass_bins,
histtype='step',
label='real',
color='blue')
plt.xlabel('Jet Mass (GeV)')
plt.ylabel('Jets')
plt.legend(loc=1, prop={'size': 18})
fig.add_subplot(1, 2, 2)
plt.ticklabel_format(axis='y', scilimits=(0, 0), useMathText=True)
_ = plt.hist(real_pts,
bins=pt_bins,
histtype='step',
label='real',
color='red')
_ = plt.hist(gen_pts,
bins=pt_bins,
histtype='step',
label='real',
color='blue')
plt.xlabel('Jet $p_T$ (GeV)')
plt.ylabel('Jets')
plt.legend(loc=1, prop={'size': 18})
plt.savefig(args.figs_path + name + "_mass_pt.pdf",
bbox_inches='tight')
plt.close()
if args.fid:
fid_5 = losses['fid'][::5]
x = np.arange(len(losses['fid']), step=5)
plt.figure()
plt.plot(x, np.log10(fid_5))
# plt.ylim((0, 5))
plt.xlabel('Epoch')
plt.ylabel('Log10FID')
# plt.legend()
plt.savefig(args.losses_path + name + "_fid.pdf", bbox_inches='tight')
plt.close()
x = np.arange(epoch + 1, step=args.save_epochs)
# plt.rcParams.update({'font.size': 12})
# fig = plt.figure(figsize=(22, 5))
# for i in range(3):
# fig.add_subplot(1, 3, i + 1)
# plt.plot(x, np.log10(np.array(losses['jsdm'])[:, i]))
# # plt.ylim((0, 5))
# plt.xlabel('Epoch')
# plt.ylabel('Particle ' + labels[i] + ' LogJSD')
# # plt.legend()
# plt.savefig(args.losses_path + name + "_jsd.pdf", bbox_inches='tight')
# plt.close()
# if(args.gp): np.savetxt(args.losses_path + args.name + "/" + "gp.txt", losses['gp'])
# np.savetxt(args.losses_path + args.name + "/" + "D.txt", losses['D'])
# np.savetxt(args.losses_path + args.name + "/" + "G.txt", losses['G'])
# np.savetxt(args.losses_path + args.name + "/" + "Dr.txt", losses['Dr'])
# np.savetxt(args.losses_path + args.name + "/" + "Df.txt", losses['Df'])
# np.savetxt(args.losses_path + args.name + "/" + "jsdm.txt", np.array(losses['jsdm']))
# np.savetxt(args.losses_path + args.name + "/" + "jsdstd.txt", np.array(losses['jsdstd']))
# if args.fid: np.savetxt(args.losses_path + args.name + "/" + "fid.txt", losses['fid'])
if args.w1 and epoch >= 5:
x = np.arange(5, epoch + 1, 5)
plt.rcParams.update({'font.size': 12})
colors = ['blue', 'green', 'orange']
fig = plt.figure(figsize=(30, 7))
for i in range(3):
fig.add_subplot(1, 3, i + 1)
for k in range(len(args.w1_num_samples)):
plt.plot(x,
np.log10(
np.array(
losses['w1_' + str(args.w1_num_samples[k]) +
'm'])[:, i]),
label=str(args.w1_num_samples[k]) + ' Jet Samples',
color=colors[k])
# plt.fill_between(x, np.log10(np.array(losses['w1_' + str(args.num_samples[k]) + 'm'])[:, i] - np.array(losses['w1_' + str(args.num_samples[k]) + 'std'])[:, i]), np.log10(np.array(losses['w1_' + str(args.num_samples[k]) + 'm'])[:, i] + np.array(losses['w1_' + str(args.num_samples[k]) + 'std'])[:, i]), color=colors[k], alpha=0.2)
# plt.plot(x, np.ones(len(x)) * np.log10(realw1m[k][i]), '--', label=str(args.num_samples[k]) + ' Real W1', color=colors[k])
# plt.fill_between(x, np.log10(np.ones(len(x)) * (realw1m[k][i] - realw1std[k][i])), np.log10(np.ones(len(x)) * (realw1m[k][i] + realw1std[k][i])), color=colors[k], alpha=0.2)
plt.legend(loc=2, prop={'size': 11})
plt.xlabel('Epoch')
plt.ylabel('Particle ' + labels[i] + ' LogW1')
plt.savefig(args.losses_path + name + "_w1.pdf", bbox_inches='tight')
plt.close()
if args.jf:
fig = plt.figure(figsize=(20, 7))
for i in range(len(args.jet_features)):
fig.add_subplot(1, len(args.jet_features), i + 1)
for k in range(len(args.w1_num_samples)):
plt.plot(
x,
np.log10(
np.array(
losses['w1j_' + str(args.w1_num_samples[k]) +
'm'])[:, i]),
label=str(args.w1_num_samples[k]) + ' Jet Samples',
color=colors[k])
plt.legend(loc=2, prop={'size': 11})
plt.xlabel('Epoch')
plt.ylabel('Particle ' + labelsj[i] + ' LogW1')
plt.savefig(args.losses_path + name + "_w1j.pdf",
bbox_inches='tight')
plt.close()
for key in losses:
np.savetxt(args.losses_path + args.name + "/" + key + '.txt',
losses[key])
try:
remove(args.losses_path + args.name + "/" +
str(epoch - args.save_epochs) + ".pdf")
remove(args.losses_path + args.name + "/" +
str(epoch - args.save_epochs) + "_w1.pdf")
# remove(args.losses_path + args.name + "/" + str(epoch - args.save_epochs) + "_fid.pdf")
except:
print("couldn't remove loss file")
print("saved figs")
checkpoint = ModelCheckpoint(file_path,
monitor='val_acc',
verbose=1,
save_best_only=True,
mode='max')
early = EarlyStopping(monitor="val_acc",
mode="max",
patience=20,
verbose=1)
redonplat = ReduceLROnPlateau(monitor="val_acc",
mode="max",
patience=5,
verbose=2)
callbacks_list = [checkpoint, redonplat] # early
model.fit_generator(gen(train_dict, aug=False),
validation_data=gen(val_dict),
epochs=40,
verbose=2,
steps_per_epoch=1000,
validation_steps=300,
callbacks=callbacks_list)
model.load_weights(file_path)
for record in tqdm(test_dict):
all_rows = test_dict[record]['x']
record_y_gt = []
record_y_pred = []
for batch_hyp in chunker(range(all_rows.shape[0])):
X = all_rows[min(batch_hyp):max(batch_hyp) + 1, ...]
checkpoint = ModelCheckpoint(file_path,
monitor='val_crf_viterbi_accuracy',
verbose=1,
save_best_only=True,
mode='max')
early = EarlyStopping(monitor="val_crf_viterbi_accuracy",
mode="max",
patience=20,
verbose=1)
redonplat = ReduceLROnPlateau(monitor="val_crf_viterbi_accuracy",
mode="max",
patience=5,
verbose=2)
callbacks_list = [checkpoint, redonplat] # early
model.fit_generator(gen(train_files, 'train', aug=False),
validation_data=gen(val_files, 'val'),
epochs=45,
verbose=2,
steps_per_epoch=1000,
validation_steps=300,
callbacks=callbacks_list)
print('DONE')
# model.load_weights(file_path)
#
# for record in tqdm(test):
# all_rows = test_dict[record]['x']
# record_y_gt = []
# record_y_pred = []
# for batch_hyp in chunker(range(all_rows.shape[0])):
