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])):