def test(images_tensor, labels_tensor, generator, parameters_path): ''' 测试模型的有效性 :param images_tensor: 图像的tensor :param labels_tensor: label的tensor :param generator: 数据的生成器,可以通过for (images_batch, labels_batch) in generator:格式来获取数据 :param parameters_path:模型保存的路径 :return: ''' logits, featuremap_tensor = inference(images_tensor, False, True) prediction_tensor = tf.argmax(logits, 1) accuracy_tensor = tf.reduce_mean(tf.cast(tf.equal(prediction_tensor, tf.argmax(labels_tensor, 1)), tf.float32)) saver = tf.train.Saver() featuremaps = [] labels = [] with tf.Session() as sess: full_path = tf.train.latest_checkpoint(parameters_path) print full_path saver.restore(sess, full_path) for (images_batch, labels_batch) in generator: print np.shape(images_batch) labels.extend(np.argmax(labels_batch, 1)) prediction, accuracy, featuremap_value = sess.run([prediction_tensor, accuracy_tensor, featuremap_tensor], feed_dict={ images_tensor: images_batch, labels_tensor: labels_batch }) featuremaps.extend(featuremap_value) print accuracy print np.shape(featuremaps), np.shape(labels) featuremaps = np.array(featuremaps) plot_scatter(featuremaps[:, 0], featuremaps[:, 1], labels, 10)
def test(images_tensor, labels_tensor, generator, parameters_path): ''' 测试模型的有效性 :param images_tensor: 图像的tensor :param labels_tensor: label的tensor :param generator: 数据的生成器,可以通过for (images_batch, labels_batch) in generator:格式来获取数据 :param parameters_path:模型保存的路径 :return: ''' center_feature, adversarial_feature = inference(images_tensor, True, True) saver = tf.train.Saver() featuremaps = [] labels = [] with tf.Session() as sess: full_path = tf.train.latest_checkpoint(parameters_path) print full_path saver.restore(sess, full_path) for (images_batch, labels_batch) in generator: print np.shape(images_batch) labels.extend(np.argmax(labels_batch, 1)) featuremap_value = sess.run(center_feature, feed_dict={ images_tensor: images_batch, labels_tensor: labels_batch }) featuremaps.extend(featuremap_value) print np.shape(featuremaps), np.shape(labels) featuremaps = np.array(featuremaps) pca_obj = PCA(n_components=2) featuremaps = pca_obj.fit_transform(featuremaps) plot_scatter(featuremaps[:, 0], featuremaps[:, 1], labels, 10)
def test(images_tensor, labels_tensor, reader, parameters_path): generator = reader.test_generator logits, featuremap_tensor = inference(images_tensor, False, True) prediction_tensor = tf.argmax(logits, 1) accuracy_tensor = tf.reduce_mean( tf.cast(tf.equal(prediction_tensor, tf.argmax(labels_tensor, 1)), tf.float32)) saver = tf.train.Saver() featuremaps = [] labels = [] with tf.Session() as sess: full_path = tf.train.latest_checkpoint(parameters_path) print full_path saver.restore(sess, full_path) for (images_batch, labels_batch) in generator: print np.shape(images_batch) labels.extend(np.argmax(labels_batch, 1)) prediction, accuracy, featuremap_value = sess.run( [prediction_tensor, accuracy_tensor, featuremap_tensor], feed_dict={ images_tensor: images_batch, labels_tensor: labels_batch }) featuremaps.extend(featuremap_value) print accuracy print np.shape(featuremaps), np.shape(labels) featuremaps = np.array(featuremaps) # featuremaps = np.array(featuremaps) / 1000.0 # print featuremaps plot_scatter(featuremaps[:, 0], featuremaps[:, 1], labels, 10)
def plot_scatter_command(args): data, to_predict, true_data, tide_height_nans = process_data(normalise_data=False) fig, ax = plt.subplots() plot_scatter( ax, data, true_data, TIDE_HEIGHT, savefig=args.save_figures, fig_name=args.fig_name, )
def analyze(self, dataset, dataset_dir): data = self.data_class.load_dataset(dataset, train_size=100) (X, Y) = (data['x_train'], data['y_train']) print_score.print_breakdown(X, Y) if self.shall_plot: plot_scatter(X, Y, "%s-orig" % dataset, filename=os.path.join(dataset_dir, "%s-orig.png" % dataset)) plot_histogram(X, Y, "%s-hist" % dataset, filename=os.path.join(dataset_dir, "%s-hist.png" % dataset)) pca = PCA() pca.fit(X) plot_PCA_variance(pca.explained_variance_ratio_ * 100, "%s-pca-#feature-vs-variance" % dataset, filename=os.path.join(dataset_dir, "%s-pca-variance-ratio" % dataset))
def plot_generator(epoch, progress): x = began.generate_x(10000, test=True) x.unchain_backward() x = began.to_numpy(x) try: plot_scatter(x, dir=args.plot_dir, filename="generator_scatter_epoch_{}_time_{}min".format( epoch, progress.get_total_time())) plot_kde(x, dir=args.plot_dir, filename="generator_kde_epoch_{}_time_{}min".format( epoch, progress.get_total_time())) except: pass
def plot_samples(epoch, progress): samples_fale = gan.generate_x(10000, from_gaussian=True) samples_fale.unchain_backward() samples_fale = gan.to_numpy(samples_fale) try: plot_scatter(samples_fale, dir=args.plot_dir, filename="scatter_epoch_{}_time_{}min".format( epoch, progress.get_total_time())) plot_kde(samples_fale, dir=args.plot_dir, filename="kde_epoch_{}_time_{}min".format( epoch, progress.get_total_time())) except: pass
def plot_reconstruction(epoch, progress, x): z = began.encode(x, test=True) x = began.decode(z, test=True) x.unchain_backward() x = began.to_numpy(x) try: plot_scatter( x, dir=args.plot_dir, filename="reconstruction_scatter_epoch_{}_time_{}min".format( epoch, progress.get_total_time())) plot_kde(x, dir=args.plot_dir, filename="reconstruction_kde_epoch_{}_time_{}min".format( epoch, progress.get_total_time())) except: pass
def east_west_run_b(f_name, east_west, net_file="None"): if east_west == 'east': obs = 'nee_day_east, nee_night_east, clma, lai_east, c_woo_east, c_roo_east' elif east_west == 'west': obs = 'nee_day_west, nee_night_west, clma, lai_west, c_woo_west, c_roo_west' if net_file != "None": d = dc.DalecData(2015, 2016, obs, nc_file=net_file) else: d = dc.DalecData(2015, 2016, obs) m = mc.DalecModel(d) assim_results, xa = m.find_min_tnc_cvt(d.edinburgh_mean, f_name + '_assim_res') # Plot 4dvar time series ax, fig = p.plot_4dvar('nee', d, xb=d.edinburgh_mean, xa=xa) fig.savefig(f_name + '_nee.png', bbox_inches='tight') ax, fig = p.plot_4dvar('nee_day', d, xb=d.edinburgh_mean, xa=xa) fig.savefig(f_name + '_need.png', bbox_inches='tight') ax, fig = p.plot_4dvar('nee_night', d, xb=d.edinburgh_mean, xa=xa) fig.savefig(f_name + '_neen.png', bbox_inches='tight') ax, fig = p.plot_4dvar('lai', d, xb=d.edinburgh_mean, xa=xa) fig.savefig(f_name + '_lai.png', bbox_inches='tight') ax, fig = p.plot_4dvar('c_woo', d, xb=d.edinburgh_mean, xa=xa) fig.savefig(f_name + '_cwoo.png', bbox_inches='tight') ax, fig = p.plot_4dvar('c_roo', d, xb=d.edinburgh_mean, xa=xa) fig.savefig(f_name + '_croo.png', bbox_inches='tight') # Plot scatter plots of obs ax, fig = p.plot_scatter('nee_day', xa, d, len(d.I), 'a') fig.savefig(f_name + '_need_scat.png', bbox_inches='tight') ax, fig = p.plot_scatter('nee_night', xa, d, len(d.I), 'a') fig.savefig(f_name + '_neen_scat.png', bbox_inches='tight') # Plot error in analysis and background ax, fig = p.plot_a_inc(d.edinburgh_mean, xa, east_west) fig.savefig(f_name + '_xa_inc.png', bbox_inches='tight') return 'all experimented'
def east_west_run(f_name, ob_list, east_west): ob_str = '' for ob in ob_list: if ob == 'clma': ob_str += ob + ',' else: ob_str += ob + '_' + east_west + ',' d = dc.DalecData(2015, 2016, ob_str) d.B = d.make_b(d.edinburgh_std) m = mc.DalecModel(d) assim_results, xa = m.find_min_tnc_cvt(d.edinburgh_mean, f_name + '_assim_res') # Plot 4dvar time series ax, fig = p.plot_4dvar('nee', d, xb=d.edinburgh_mean, xa=xa) fig.savefig(f_name + '_nee.png', bbox_inches='tight') ax, fig = p.plot_4dvar('nee_day', d, xb=d.edinburgh_mean, xa=xa) fig.savefig(f_name + '_need.png', bbox_inches='tight') ax, fig = p.plot_4dvar('nee_night', d, xb=d.edinburgh_mean, xa=xa) fig.savefig(f_name + '_neen.png', bbox_inches='tight') ax, fig = p.plot_4dvar('lai', d, xb=d.edinburgh_mean, xa=xa) fig.savefig(f_name + '_lai.png', bbox_inches='tight') ax, fig = p.plot_4dvar('c_woo', d, xb=d.edinburgh_mean, xa=xa) fig.savefig(f_name + '_cwoo.png', bbox_inches='tight') ax, fig = p.plot_4dvar('c_roo', d, xb=d.edinburgh_mean, xa=xa) fig.savefig(f_name + '_croo.png', bbox_inches='tight') # Plot scatter plots of obs ax, fig = p.plot_scatter('nee_day', xa, d, len(d.I), 'a') fig.savefig(f_name + '_need_scat.png', bbox_inches='tight') ax, fig = p.plot_scatter('nee_night', xa, d, len(d.I), 'a') fig.savefig(f_name + '_neen_scat.png', bbox_inches='tight') # Plot error in analysis and background ax, fig = p.plot_a_inc(d.edinburgh_mean, xa, east_west) fig.savefig(f_name + '_xa_inc.png', bbox_inches='tight') return 'all experimented'
def main_bert(args): # args = parse_args() if args.seed: torch.manual_seed(args.seed) np.random.seed(args.seed) args.n_vocab = args.num_labels n_train_data = args.n_train_data n_eval_data = args.n_eval_data data_path = "data/sort_train_data{}_seq{}_v{}.pt".format(n_train_data, args.seq_len, args.n_vocab) pathlib.Path(data_path).parent.mkdir(exist_ok=True, parents=True) cache_data = True if cache_data: if os.path.exists(data_path): data_set = torch.load(data_path) train_data = data_set.branch_subset(n_train_data) print("dataset len {}".format(len(train_data))) else: train_data = SortingDataset(n_train_data, args) torch.save(train_data, data_path) else: train_data = SortingDataset(n_eval_data, args) # train_data = SortingDataset(n_train_data, args) if args.train_as_eval: eval_data = train_data.branch_subset(n_eval_data) else: eval_data = SortingDataset(n_eval_data, args) if cuda: train_data.cuda() eval_data.cuda() batch_sz = args.batch_sz train_loader = torch.utils.data.DataLoader(train_data, batch_size=batch_sz, shuffle=False) # shuffle=False eval_loader = torch.utils.data.DataLoader(eval_data, batch_size=len(eval_data), shuffle=False) config = SANConfig( vocab_size=args.n_vocab, hidden_size=args.hidden_dim, num_hidden_layers=args.depth, num_attention_heads=args.width, hidden_act="gelu", intermediate_size=args.hidden_dim, do_mlp=args.do_mlp, num_labels=args.num_labels, ) model = SANForSequenceClassification(config=config) model_path = "modelsort{}d{}_{}h{}label{}.pt".format( args.width, args.depth, args.seq_len, args.hidden_dim, args.n_vocab ) pathlib.Path(model_path).parent.mkdir(exist_ok=True, parents=True) if os.path.exists(model_path) and not args.do_train: state_dict = torch.load(model_path, map_location="cpu") model.load_state_dict(state_dict) args.n_epochs = 0 if cuda: model = model.cuda() loss_fn = nn.CrossEntropyLoss() opt = torch.optim.Adam(model.parameters(), lr=1e-5) config.cur_step = 0 model.train() for epoch in tqdm(range(args.n_epochs)): for data in train_loader: X, labels = data pred = model(X) # (pooledoutput, hidden states) logits = pred[0] loss = loss_fn(logits.view(-1, args.num_labels), labels.view(-1)) opt.zero_grad() loss.backward() opt.step() config.cur_step += 1 sys.stdout.write("train loss {}".format(loss)) path_len = min(args.path_len, args.depth) # 2 n_repeat = args.n_repeat with open(args.res_file, "a") as f: f.write("~{} \n".format(args)) #''' # model_path = 'modelsort{}d{}_{}h{}'.format(args.width, args.depth, args.seq_len, args.hidden_dim) if not os.path.exists(model_path) or args.do_train: state_dict = model.state_dict() # torch.load(model_path) torch.save(state_dict, model_path) ### eval ### config.no_sub_path = args.no_sub_path config.do_rank = args.do_rank config.compute_alpha = args.compute_alpha path_len = min(args.path_len, args.depth) # 2 n_repeat = args.n_repeat #''' metric_ar = np.zeros((1, args.depth + 1 - path_len)) std_ar = np.zeros((1, args.depth + 1 - path_len)) model.eval() while path_len <= args.depth: print("path len {}".format(path_len)) for data in eval_loader: X, labels = data score_ar = np.zeros((n_repeat,)) eval_loss_ar = np.zeros((n_repeat,)) comp_match_ar = np.zeros((n_repeat,)) part_match_ar = np.zeros((n_repeat,)) for i in range(n_repeat): with torch.no_grad(): path_idx_l = [] for _ in range(args.n_paths): # path_idx_l = [path_idx_l] path_idx_l.append(create_path(path_len, args, all_heads=args.all_heads)) # must be nested idx arrays! pred = model(X, path_idx_l=path_idx_l) pred = pred[0] comp_match_ar[i], part_match_ar[i] = run_eval(pred, labels) eval_loss_ar[i] = loss_fn(pred.view(-1, args.num_labels), labels.view(-1)) pred = torch.argmax(pred, dim=-1) # score_ar[i] = evaluate_metric2(pred, X) score_ar[i] = evaluate_metric3(pred, labels) res_str = "path_len {} avg_mismatched_pairs {} eval_loss {} complete_match {} partial_match {}".format( path_len, score_ar.mean(), eval_loss_ar.mean(), comp_match_ar.mean(), part_match_ar.mean() ) # print('\npath_len {} avg_mismatched_pairs {} eval_loss {} complete_match {} partial_match {}'.format(path_len, score_ar.mean(), eval_loss_ar.mean(), comp_match_ar.mean(), \ # part_match_ar.mean())) metric_ar[0, path_len - args.path_len] = score_ar.mean() std_ar[0, path_len - args.path_len] = score_ar.std() print("\n", res_str) with open(args.res_file, "a") as f: # f.write('~{} \n'.format(args )) # f.write('path_len {} d/w {} mis_match {} eval_loss {} comp_match {} partial_match {}\n'.format(path_len, args.depth/args.width, score, eval_loss, complete_match, partial_match)) f.write(res_str + "\n") path_len += 1 # = min(path_len+1, args.depth) plot_arg = plot.PlotArg(np.arange(metric_ar.shape[-1]), metric_ar, std=std_ar) # plot_arg.legend = ['# reversed pairs (lower better)'] plot_arg.legend = ["Sorting Accuracy"] plot_arg.x_label = "Path length" # plot_arg.y_label = '# reversed pairs' plot_arg.y_label = "Average Sorting Accuracy" # plot_arg.title = 'Reversed Pairs vs Path Length for Sorting' plot.plot_scatter(plot_arg, fname="sorting{}d{}_{}".format(args.width, args.depth, args.hidden_dim)) #''' plot_res_path = "sort_res{}d{}_{}_{}.pt".format(args.width, args.depth, args.hidden_dim, args.n_paths) torch.save({"metric_ar": metric_ar, "std_ar": std_ar}, os.path.join(plot.res_dir, plot_res_path)) plot_res_ar = np.zeros((4, metric_ar.shape[-1])) plot_std_ar = np.zeros((4, metric_ar.shape[-1])) for i, pathLen in enumerate([5, 20]): try: results = torch.load("sort_res{}d{}_{}_{}.pt".format(args.width, args.depth, args.hidden_dim, pathLen)) except FileNotFoundError: print("Note: Must run script for both 5 and 20 paths combinations to produce combined plot.") break plot_res_ar[i] = results["metric_ar"][0] plot_std_ar[i] = results["std_ar"][0] # this number is obtained by running the model and using all paths plot_res_ar[2, :] = 0.98 plot_res_ar[3, :] = 0.1 x_ar = np.tile(np.arange(metric_ar.shape[-1], dtype=float), (4, 1)) x_ar[0] -= 0.05 x_ar[1] += 0.05 plot_arg = plot.PlotArg(x_ar, plot_res_ar, std=plot_std_ar) plot_arg.legend = ["5 paths", "20 paths", "Entire model", "Random predictor"] plot_arg.x_label = "Path length" # plot_arg.y_label = '# correctly predicted pairs' #'# reversed pairs' plot_arg.y_label = "Average Sorting Accuracy" plot_arg.title = "" #'# Reversed Pairs vs Path Length for Sorting' plot.plot_scatter(plot_arg, fname="sort{}d{}_{}multi".format(args.width, args.depth, args.hidden_dim))
model_f1_mi = f1_score(y_test, model_values, average="micro") model_f1_ma = f1_score(y_test, model_values, average="macro") model_corcoef = matthews_corrcoef(y_test, model_values) # calculate the error between the predicted value, and the actual value. model_errors = [] for counter, value in enumerate(model_pred): model_errors.append(abs(y_test[counter] - model_pred[counter])[0]) del counter, value # plot the accuracies on a line graph plot.plot_line_complete(np.arange(1, len(model_acc[1]) + 1, 1), accuracies) plot.plot_line_focused(np.arange(1, len(model_acc[1]) + 1, 1), accuracies, mean) # plot the errors using a scatter graph, and a histogram plot.plot_scatter(model_errors, model_mse, model_mae) bins = plot.plot_error_hist(model_errors) # save the sizes for, and the value of, each bin used in the histogram. bin_sizes = bins[0] bin_value = bins[1] # plot the confusion matrices. plot.plot_confusion_matrix(con_matrix, [0, 1], normalize=True, title="Confusion Matrix of Predictions Normalized", save_name="confusion_matrix_norm") plot.plot_confusion_matrix(con_matrix, [0, 1], title="Confusion Matrix of Predictions", save_name="confusion_matrix")
z = Variable(Tensor(np.random.normal(0, 1, (opt.batchSize, opt.nz)).astype(np.float32))).to(device) optimizer_G.zero_grad() # Generate a batch of images samples_fake = generator(z) # Adversarial loss lossG = - torch.sum(discriminator(samples_fake / opt.scale) / opt.batchSize) lossG.backward() optimizer_G.step() # ==================== # Save to tensorborad # ==================== if(i == 0 or (i % opt.n_display_step == 0)): board_train.add_scalar('Generater/loss_G', lossG.item(), iterations) board_train.add_scalar('Discriminator/loss_D', lossD.item(), iterations) # Monitor trainnig progresses print("epoch={}, iters={}, loss_G={:.5f}, loss_C={:.5f}".format(epoch, iterations, lossG, lossD)) # ============ # Save images # ============ generator.eval() z_fixed = Variable(Tensor(np.random.normal(0, 1, (10000, opt.nz)).astype(np.float32))).to(device) with torch.no_grad(): samples_fake = generator(z_fixed) plot_scatter(samples_fake.cpu().numpy(), dir=os.path.join(opt.dir_out, opt.exper_name), filename="scatter_epoches{}".format(epoch)) plot_kde(samples_fake.cpu().numpy(), dir=os.path.join(opt.dir_out, opt.exper_name), filename="kde_epoches{}".format(epoch))
prog.add_loss_dis() z = sampler.sample_z(config['dim_z'], batchsize, gaussian=config['gaussian']) z = Variable(torch.from_numpy(z)) samples_fake = gen_net(z) samples_fake /= config['scale'] f_fake = dis_net(samples_fake) loss_gen = -f_fake.mean() prog.add_loss_gen(loss_gen) gen_optim.zero_grad() loss_gen.backward() gen_optim.step() if (i + 1) % config['num_plot'] == 0: print(i + 1) z = sampler.sample_z(config['dim_z'], 10000, gaussian=config['gaussian']) z = Variable(torch.from_numpy(z)) samples_fake = gen_net(z).data.numpy() plot.plot_scatter(samples_fake, dir='plot', filename='{}_scatter'.format(i + 1)) plot.plot_kde(samples_fake, dir='plot', filename='{}_kde'.format(i + 1)) prog.plot()
data['604800-1799999'] = 0 for item in raw: if item[0] >= 604800 and item[0] < 1799999: data['604800-1799999'] += item[1] data['1800000-3599999'] = 0 for item in raw: if item[0] >= 1800000 and item[0] < 3599999: data['1800000-3599999'] += item[1] data['3600000-10000000'] = 0 for item in raw: if item[0] >= 3600000 and item[0] < 10000000: data['3600000-10000000'] += item[1] data['10000000-'] = 0 for item in raw: if item[0] >= 10000000: data['10000000-'] += item[1] return data if __name__ == '__main__': read_raw('dns_ttl.csv') data = read_csv('ttl_distribution.csv') sp = separate(data) write_csv(data, 'ttl_distribution.csv') plt.plot(data) plt.plot_scatter(data) plt.plot_bar(sp)
loss_critic.backward() dis_optim.step() prog.add_loss_dis() z = sampler.sample_z(config['dim_z'], batchsize, gaussian=config['gaussian']) z = Variable(torch.from_numpy(z).cuda()) samples_fake = gen_net(z) samples_fake /= config['scale'] f_fake = dis_net(samples_fake) loss_gen = -f_fake.mean() prog.add_loss_gen(loss_gen.data.cpu().numpy()[0]) gen_optim.zero_grad() loss_gen.backward() gen_optim.step() if (i + 1) % config['num_plot'] == 0: print(i + 1) z = sampler.sample_z(config['dim_z'], 10000, gaussian=config['gaussian']) z = Variable(torch.from_numpy(z).cuda()) samples_fake = gen_net(z).data.cpu().numpy() plot.plot_scatter(samples_fake, filename='{}_scatter'.format(i + 1), show=True) plot.plot_kde(samples_fake, filename='{}_kde'.format(i + 1), show=True) prog.plot()
def test_bitarray_size(fib, traffic, pref_stats): ''' vary bitarray size (or equivalently by % bits set) ''' print('\n\ntest_bitarray_size()\n\n') multiples = (-2, 3, 1) test_matrix = { 'linear': [round(BITARR_SIZE * 10**factor) for factor in range(*multiples)], 'guided': [round(BITARR_SIZE * 10**factor) for factor in range(*multiples)] } protocol = 'v4' res = {} for typ in test_matrix: print('\nStarting on %s\n' % typ) res[typ] = { 'percent_full': [], 'ncalls': [], 'bf': [] } # list of tuples for bitarray_size in test_matrix[typ]: if typ == 'linear': ## LINEAR bf_linear, _ = ipfilter.build_bloom_filter( protocol=protocol, lamda=None, fpp=None, k=K, num_bits=bitarray_size, fib=fib) res[typ]['percent_full'].append(100 * bf_linear.ba.count() / bf_linear.ba.length()) res[typ]['bf'].append(str(bf_linear)) print(bf_linear) # record starting ncalls for each function of interest ncontains = bf_linear._register.ncalls nfnv = hash_fnv.ncalls nfib = fib.__contains__.ncalls ndefault = ipfilter._default_to_linear_search.ncalls # perform the lookup _lookup_wrapper(bf_linear, traffic, fib, pref_stats, protocol, bst=None, typ='linear') # record the ending ncalls for each function of interest ncontains = (bf_linear._register.ncalls - ncontains) / THROTTLE nfnv = (hash_fnv.ncalls - nfnv) / THROTTLE nfib = (fib.__contains__.ncalls - nfib) / THROTTLE ndefault = (ipfilter._default_to_linear_search.ncalls - ndefault) / THROTTLE res[typ]['ncalls'].append((ncontains, nfnv, nfib, ndefault)) else: ## GUIDED # use hand tuned params bf_guided, bst = ipfilter.build_bloom_filter( protocol=protocol, lamda=weigh_equally, fpp=None, k=K, num_bits=bitarray_size, fib=fib) res[typ]['percent_full'].append(100 * bf_guided.ba.count() / bf_guided.ba.length()) res[typ]['bf'].append(str(bf_guided)) print(bf_guided) # record starting ncalls for each function of interest ncontains = bf_guided._register.ncalls nfnv = hash_fnv.ncalls nfib = fib.__contains__.ncalls ndefault = ipfilter._default_to_linear_search.ncalls # perform the lookup _lookup_wrapper(bf_guided, traffic, fib, pref_stats, protocol, bst=bst, typ='guided') # record the ending ncalls for each function of interest ncontains = (bf_guided._register.ncalls - ncontains) / THROTTLE nfnv = (hash_fnv.ncalls - nfnv) / THROTTLE nfib = (fib.__contains__.ncalls - nfib) / THROTTLE ndefault = (ipfilter._default_to_linear_search.ncalls - ndefault) / THROTTLE res[typ]['ncalls'].append((ncontains, nfnv, nfib, ndefault)) # record experiment to file in EXPERIMENTS: header, plot title, xaxis, yaxis, xs, ys, misc info with open(os.path.join(EXPERIMENTS, 'linear_bitarraySize_v4_random.txt'), 'w') as out: lines = [ "test_bitarray_size(): vary bitarray size, keeping k constant, for linear, invocations of funcs,xs=[bf._register(), hash_fnv(), fib.__contains__(), ipfilter._default_to_linear_search], yaxis=ncalls" ] # header lines.append('Linear search: lookup/hashing stats') # plot title lines.append('Percent full') # xaxis title lines.append('Count of invocations') # yaxis title lines.append(';'.join( [str(val) for val in res['linear']['percent_full']])) # xs lines.append(';'.join([ '(%.2f, %.2f, %.2f, %.2f)' % quad for quad in res['linear']['ncalls'] ])) # ys lines.append(';'.join(res['linear']['bf'])) # any extra info out.write('\n'.join(lines)) # record experiment to file in EXPERIMENTS: header, plot title, xaxis, yaxis, xs, ys, misc info with open(os.path.join(EXPERIMENTS, 'guided_bitarraySize_v4_random.txt'), 'w') as out: lines = [ "test_bitarray_size(): vary bitarray size, keeping k constant, for guided, invocations of funcs,xs=[bf._register(), hash_fnv(), fib.__contains__(), ipfilter._default_to_linear_search], yaxis=ncalls" ] # header lines.append('Guided search: lookup/hashing stats') # plot title lines.append('Percent full') # xaxis title lines.append('Count of invocations') # yaxis title lines.append(';'.join( [str(val) for val in res['guided']['percent_full']])) # xs lines.append(';'.join([ '(%.2f, %.2f, %.2f, %.2f)' % quad for quad in res['guided']['ncalls'] ])) # ys lines.append(';'.join(res['guided']['bf'])) # any extra info out.write('\n'.join(lines)) # plot seqs = ['bit lookups', 'hashing', 'FIB lookups', 'defaults'] ofile = 'bitarraySize_' + protocol + '_random.svg' title = 'Count by metric: bitarray size' xlabel = '% bitarray full' ylabel = 'count' plot_scatter(seqs, res, ofile, title, xlabel, ylabel, key='percent_full') print('\n\nAll done!')
def main_bert(args): # args = parse_args() if args.seed: torch.manual_seed(args.seed) np.random.seed(args.seed) args.n_vocab = args.num_labels # args.n_data = 10 n_train_data = args.n_train_data # 10 n_eval_data = args.n_eval_data # 10 #30 model_path = "model{}d{}_{}h{}_{}.pt".format(args.width, args.depth, args.seq_len, args.hidden_dim, args.n_epochs) print("model_path {}".format(model_path)) data_path = "data/train_data_convexhull{}.pt".format(n_train_data) cache_data = True if cache_data or not os.path.exists(model_path): if os.path.exists(data_path): data_set = torch.load(data_path) train_data = data_set.branch_subset(n_train_data) print("dataset len {}".format(len(train_data))) else: train_data = ConvexHullDataset(n_train_data, args) torch.save(train_data, data_path) else: train_data = ConvexHullDataset(n_eval_data, args) if args.train_as_eval: eval_data = train_data.branch_subset(n_eval_data) else: eval_data = ConvexHullDataset(n_eval_data, args) if cuda: train_data.cuda() eval_data.cuda() batch_sz = args.batch_sz train_loader = torch.utils.data.DataLoader(train_data, batch_size=batch_sz, shuffle=False) eval_loader = torch.utils.data.DataLoader(eval_data, batch_size=len(eval_data), shuffle=False) config = SANConfig( vocab_size=2, # no embeddings for convex hull. no_embed=True, hidden_size=args.hidden_dim, num_hidden_layers=args.depth, num_attention_heads=args.width, hidden_act="gelu", intermediate_size=args.hidden_dim, do_mlp=args.do_mlp, do_ffn2_embed=args.ffn2, max_position_embeddings=-1, num_labels=args.num_labels, ) # This has been fitted for *token*-wise prediction # No embeddings layer, feedforward layer that projects coordinates into hidden_dim space instead model = SANForSequenceClassification(config=config) if os.path.exists(model_path) and not args.do_train: state_dict = torch.load(model_path, map_location="cpu") model.load_state_dict(state_dict) args.n_epochs = 0 if cuda: model = model.cuda() loss_fn = nn.CrossEntropyLoss() do_regularization = True if do_regularization: opt = torch.optim.Adam(model.parameters(), lr=1e-5, weight_decay=1e-3) milestones = [15, 30, 40, 50, 60] scheduler = torch.optim.lr_scheduler.MultiStepLR(opt, milestones=milestones, gamma=0.91) else: opt = torch.optim.Adam(model.parameters(), lr=1e-5) # , weight_decay=1e-3) config.cur_step = 0 model.train() for epoch in tqdm(range(args.n_epochs)): for data in train_loader: X, labels = data pred = model(X) # (pooledoutput, hidden states) logits = pred[0] loss = loss_fn(logits.view(-1, args.num_labels), labels.view(-1)) opt.zero_grad() loss.backward() opt.step() config.cur_step += 1 sys.stdout.write("train loss {}".format(loss)) if do_regularization: scheduler.step() # model_path = 'model{}d{}_{}h{}'.format(args.width, args.depth, args.seq_len, args.hidden_dim) if not os.path.exists(model_path) or args.do_train: state_dict = model.state_dict() # torch.load(model_path) torch.save(state_dict, model_path) ### eval ### config.no_sub_path = args.no_sub_path config.do_rank = args.do_rank config.compute_alpha = args.compute_alpha path_len = min(args.path_len, args.depth) # 2 n_repeat = args.n_repeat with open(args.res_file, "a") as f: f.write("~{} \n".format(args)) model.eval() metric_ar = np.zeros((2, args.depth + 1 - path_len)) std_ar = np.zeros((2, args.depth + 1 - path_len)) while path_len <= args.depth: print("path len {}".format(path_len)) for data in eval_loader: X, labels = data eval_loss_ar = np.zeros((n_repeat, )) soft_match_ar = np.zeros((n_repeat, )) for i in range(n_repeat): with torch.no_grad(): path_idx_l = [] for _ in range(args.n_paths): # path_idx_l = [path_idx_l] path_idx_l.append( create_path(path_len, args, all_heads=args.all_heads)) # path_idx_l.append(create_path(np.random.randint(1, high=path_len+1), args, all_heads=args.all_heads )) # must be nested idx arrays! pred = model(X, path_idx_l=path_idx_l) pred = pred[0] eval_loss_ar[i] = loss_fn(pred.view(-1, args.num_labels), labels.view(-1)) # pred = torch.argmax(pred, dim=-1) soft_match_ar[i] = evaluate_metric_softmax_match( pred.view(-1, args.num_labels), labels.view(-1), args) res_str = "path_len {} eval_loss {} token_acc {}".format( path_len, eval_loss_ar.mean(), soft_match_ar.mean()) # , comp_match_ar.mean(), metric_ar[0, path_len - args.path_len] = soft_match_ar.mean() metric_ar[1, path_len - args.path_len] = soft_match_ar.mean() std_ar[0, path_len - args.path_len] = soft_match_ar.std() std_ar[1, path_len - args.path_len] = soft_match_ar.std() print("\n", res_str) # print('Enter desired path len between 1 and {}: '.format(args.depth )) # path_len = input('Enter desired path len between 1 ' ) # path_len = input() # path_len = int(path_len) with open(args.res_file, "a") as f: # f.write('~{} \n'.format(args )) # f.write('path_len {} d/w {} mis_match {} eval_loss {} comp_match {} partial_match {}\n'.format(path_len, args.depth/args.width, score, eval_loss, complete_match, partial_match)) f.write(res_str + "\n") path_len += 1 # = min(path_len+1, args.depth) plot_arg = plot.PlotArg(np.arange(metric_ar.shape[-1]), metric_ar, std=std_ar) # plot_arg.legend = ['AUC', 'Exact Match'] plot_arg.legend = ["Accuracy", "Token Acc"] plot_arg.x_label = "Path length" # plot_arg.y_label = 'AUC' plot_arg.y_label = "Token Prediction Accuracy" # plot_arg.title = 'AUC vs Path Length for Convex Hull' plot.plot_scatter(plot_arg, fname="convex_hull{}d{}_{}".format( args.width, args.depth, args.hidden_dim)) plot_res_path = os.path.join( plot.res_dir, "convex_hull_res{}d{}_{}_{}.pt".format( args.width, args.depth, args.hidden_dim, args.n_paths)) #'convex_hull_res{}.pt'.format(args.n_paths) torch.save({"metric_ar": metric_ar, "std_ar": std_ar}, plot_res_path) plot_res_ar = np.zeros((4, metric_ar.shape[-1])) plot_std_ar = np.zeros((4, metric_ar.shape[-1])) for i, pathLen in enumerate([5, 20]): # torch.load('sort_res{}d{}_{}_{}.pt'.format(args.width, args.depth, args.hidden_dim, pathLen) ) try: results = torch.load("convex_hull_res{}d{}_{}_{}.pt".format( args.width, args.depth, args.hidden_dim, pathLen)) except FileNotFoundError: print( "Note: Must run script for both 5 and 20 paths combinations to produce combined plot." ) break plot_res_ar[i] = results["metric_ar"][0] plot_std_ar[i] = results["std_ar"][0] # this number is obtained by running the model and using all paths plot_res_ar[2, :] = 0.9 plot_res_ar[3, :] = 0.54 x_ar = np.tile(np.arange(metric_ar.shape[-1], dtype=float), (4, 1)) x_ar[0] -= 0.05 # np.arange(metric_ar.shape[-1])-0.05 x_ar[1] += 0.05 # np.arange(metric_ar.shape[-1])+0.05 plot_arg = plot.PlotArg(x_ar, plot_res_ar, std=plot_std_ar) plot_arg.legend = [ "5 paths", "20 paths", "Entire model", "Majority predictor" ] plot_arg.x_label = "Path length" # plot_arg.y_label = 'AUC' plot_arg.y_label = "Token Prediction Accuracy" # plot_arg.title = 'AUC vs Path Length for Convex Hull' plot.plot_scatter( plot_arg, fname="convex_hull{}d{}_{}l{}multi".format(args.width, args.depth, args.hidden_dim, args.seq_len), loc="best", bbox=(0.5, 0.4, 0.5, 0.5), ) # plt.legend(loc='best', bbox_to_anchor=(0.5, 0.4, 0.5, 0.5))
def main(_): roi_images = tf.placeholder(shape=[ None, net_config.ROI_SIZE_W, net_config.ROI_SIZE_H, net_config.IMAGE_CHANNEL ], dtype=np.float32, name='roi_input') expand_roi_images = tf.placeholder(shape=[ None, net_config.EXPAND_SIZE_W, net_config.EXPAND_SIZE_H, net_config.IMAGE_CHANNEL ], dtype=np.float32, name='expand_roi_input') batch_size_tensor = tf.placeholder(dtype=tf.int32, shape=[]) is_training_tensor = tf.placeholder(dtype=tf.bool, shape=[]) logits, _, _, representor_tensor = inference_small( roi_images, expand_roi_images, phase_names=['NC', 'ART', 'PV'], num_classes=4, is_training=is_training_tensor, batch_size=batch_size_tensor) model_path = '/home/give/PycharmProjects/MICCAI2018/deeplearning/LSTM/parameters/0/0.0001' # model_path = '/home/give/PycharmProjects/MedicalImage/Net/forpatch/cross_validation/model/multiscale/parallel/0/2200.0' predictions = tf.nn.softmax(logits) saver = tf.train.Saver(tf.all_variables()) print predictions predicted_label_tensor = tf.argmax(predictions, axis=1) print predicted_label_tensor init = tf.initialize_all_variables() sess = tf.Session(config=tf.ConfigProto(log_device_placement=False)) sess.run(init) tf.train.start_queue_runners(sess=sess) latest = tf.train.latest_checkpoint(model_path) if not latest: print "No checkpoint to continue from in", model_path sys.exit(1) print "resume", latest saver.restore(sess, latest) data_dir = '/home/give/Documents/dataset/MICCAI2018/Patches/crossvalidation/0/test' slice_dir = '/home/give/Documents/dataset/MICCAI2018/Slices/crossvalidation/0/test' labels = [] paths = [] for typeid in [0, 1, 2, 3]: cur_path = os.path.join(data_dir, str(typeid)) names = os.listdir(cur_path) labels.extend([typeid] * len(names)) paths.extend([os.path.join(cur_path, name) for name in names]) paths, labels = shuffle_image_label(paths, labels) start_index = 0 predicted_labels = [] liver_density = load_raw_liver_density() while True: if start_index >= len(paths): break print start_index, len(paths) end_index = start_index + net_config.BATCH_SIZE cur_paths = paths[start_index:end_index] cur_roi_images = [np.asarray(load_patch(path)) for path in cur_paths] cur_expand_roi_images = [ np.asarray(load_patch(path, return_roi=True, parent_dir=slice_dir)) for path in cur_paths ] cur_roi_images = resize_images(cur_roi_images, net_config.ROI_SIZE_W, True) cur_expand_roi_images = resize_images(cur_expand_roi_images, net_config.EXPAND_SIZE_W, True) # cur_liver_densitys = [liver_density[os.path.basename(path)[:os.path.basename(path).rfind('_')]] for # path in cur_paths] # for i in range(len(cur_roi_images)): # for j in range(3): # cur_roi_images[i, :, :, j] = (1.0 * cur_roi_images[i, :, :, j]) / (1.0 * cur_liver_densitys[i][j]) # cur_expand_roi_images[i, :, :, j] = (1.0 * cur_expand_roi_images[i, :, :, j]) / ( # 1.0 * cur_liver_densitys[i][j]) predicted_batch_labels, representor_value, logits_value = sess.run( [predicted_label_tensor, representor_tensor, logits], feed_dict={ roi_images: cur_roi_images, expand_roi_images: cur_expand_roi_images, is_training_tensor: False, batch_size_tensor: len(cur_roi_images) }) features.extend(representor_value) batch_labels = labels[start_index:end_index] predicted_labels.extend(predicted_batch_labels) start_index = end_index calculate_acc_error(predicted_batch_labels, batch_labels) calculate_acc_error(predicted_labels, labels) # get the feature, visualize it # first dimension reduction from sklearn.decomposition import PCA dim = 2 from plot import plot_scatter, plot_scatter3D pca_obj = PCA(n_components=dim) visualized_data = pca_obj.fit_transform(features) if dim == 3: plot_scatter3D(visualized_data[:, 0], visualized_data[:, 1], visualized_data[:, 2], labels=labels, category_num=4) else: plot_scatter(visualized_data[:, 0], visualized_data[:, 1], labels=labels, category_num=4) dim = 3 pca_obj = PCA(n_components=dim) visualized_data = pca_obj.fit_transform(features) if dim == 3: plot_scatter3D(visualized_data[:, 0], visualized_data[:, 1], visualized_data[:, 2], labels=labels, category_num=4) else: plot_scatter(visualized_data[:, 0], visualized_data[:, 1], labels=labels, category_num=4)
from package_simulation import simulate_packages from scheduling import round_robin, fair_queuing print('# =============== #') print('# Scheduling Plot #') print('# =============== #') print('© Dominic Plein 11/2020') # Plot fig, (ax1, ax2, ax3, ax4, ax5) = plot.init_plot() # Packages sources, max_end_time = simulate_packages(15, 40, 10) plot.plot_broken_barh(ax1, 'Eintreffende Pakete', sources, max_end_time) # Round Robin (abbreviated as rr) sources_rr, diff_rr, max_end_time_rr, data_rr = round_robin(deepcopy(sources)) plot.plot_broken_barh(ax2, 'Round-Robin', sources_rr, max_end_time_rr, diff_rr) plot.plot_scatter(ax4, 'Round-Robin (Auswertung)', data_rr) # Fair Queuing (abbreviated as fq) sources_fq, diff_fq, max_end_time_fq, data_fq = fair_queuing(deepcopy(sources)) plot.plot_broken_barh(ax3, 'Fair Queuing', sources_fq, max_end_time_fq, diff_fq) plot.plot_scatter(ax5, 'Fair Queuing (Auswertung)', data_fq) # Plot ax1.set_xlim(0, max(max_end_time_rr, max_end_time_fq)) plot.save(fig) plot.show_plot()
def fexc_finh_sweep(neuronp, filt_tau=.01, k_trans=5, max_u=6., max_f=1000., npts=10, fname_pre='', max_proc=None, close=False): alpha = max_u/max_f fexc = np.linspace(0, max_f, npts) finh = np.linspace(0, max_f, npts) fexc_g, finh_g = np.meshgrid(fexc, finh) lam_g = fexc_g+finh_g u_g = alpha*(fexc_g-finh_g) s_g = np.sqrt(lam_g/(2.*neuronp['tau_syn'])) tuning_th = th_lif_fi(u_g, neuronp['tau_m'], neuronp['tref'], neuronp['xt']) T = 2. dt = .0001 io_collector = LIF_IO_Collector( dt=dt, T=T, alpha=alpha, neuronp=neuronp, filt_tau=filt_tau, k_trans=k_trans) tuning, dev1s_l, dev1s_u = io_collector.collect_io_stats( fexc=fexc_g, finh=finh_g, ret_devs=True, max_proc=max_proc) # E[u] fig, ax = plot_contour( fexc_g, finh_g, u_g, contourfp={'cmap': plt.cm.BrBG}, contourp={'colors': 'r'}, figp={'figsize': (8, 6)}, xlabel=r'$f_{exc}$', xlabelp={'fontsize': 20}, ylabel=r'$f_{inh}$', ylabelp={'fontsize': 20}, title=r'$E[u]$', titlep={'fontsize': 20}) plot_scatter( fexc_g, finh_g, scatterp={'c': 'm', 'marker': '+', 'alpha': .5}, ax=ax, xlim=(fexc[0], fexc[-1]), ylim=(finh[0], finh[-1]), close=close, fname=FIGDIR+fname_pre+'fe_fi_u.png', savep={'dpi': 200}) # a(E[u])) fig, ax = plot_contour( fexc_g, finh_g, tuning_th, contourfp={'cmap': plt.cm.copper}, contourp={'colors': 'r'}, figp={'figsize': (8, 6)}, xlabel=r'$f_{exc}$', xlabelp={'fontsize': 20}, ylabel=r'$f_{inh}$', ylabelp={'fontsize': 20}, title=r'$a(E[u])$', titlep={'fontsize': 20}) plot_scatter( fexc_g, finh_g, scatterp={'c': 'm', 'marker': '+', 'alpha': .5}, ax=ax, xlim=(fexc[0], fexc[-1]), ylim=(finh[0], finh[-1]), close=close, fname=FIGDIR+fname_pre+'fe_fi_tuning_th.png', savep={'dpi': 200}) # sqrt(Var(u)) fig, ax = plot_contour( fexc_g, finh_g, s_g, contourfp={'cmap': plt.cm.PuOr}, contourp={'colors': 'r'}, figp={'figsize': (8, 6)}, xlabel=r'$f_{exc}$', xlabelp={'fontsize': 20}, ylabel=r'$f_{inh}$', ylabelp={'fontsize': 20}, title=r'$\sigma(f_{exc}+f_{inh})$', titlep={'fontsize': 20}) plot_scatter(fexc_g, finh_g, scatterp={'c': 'm', 'marker': '+', 'alpha': .5}, ax=ax, xlim=(fexc[0], fexc[-1]), ylim=(finh[0], finh[-1]), close=close, fname=FIGDIR+fname_pre+'fe_fi_noise.png', savep={'dpi': 200}) # E[a(u)] fig, ax = plot_contour( fexc_g, finh_g, tuning, contourfp={'cmap': plt.cm.copper}, contourp={'colors': 'r'}, figp={'figsize': (8, 6)}, xlabel=r'$f_{exc}$', xlabelp={'fontsize': 20}, ylabel=r'$f_{inh}$', ylabelp={'fontsize': 20}, title=r'$E[a(u)]$', titlep={'fontsize': 20}) plot_scatter( fexc_g, finh_g, scatterp={'c': 'm', 'marker': '+', 'alpha': .5}, ax=ax, xlim=(fexc[0], fexc[-1]), ylim=(finh[0], finh[-1]), close=close, fname=FIGDIR+fname_pre+'fe_fi_noisy_tuning.png', savep={'dpi': 200}) # Var(a(u)) fig, ax = plot_contour( fexc_g, finh_g, dev1s_l, contourfp={'cmap': plt.cm.winter}, contourp={'colors': 'r'}, subplotp=(1, 2, 1), figp={'figsize': (16, 6)}, xlabel=r'$f_{exc}$', xlabelp={'fontsize': 20}, ylabel=r'$f_{inh}$', ylabelp={'fontsize': 20}, title=r'$-\sigma\%(a(u))$', titlep={'fontsize': 20}) plot_scatter( fexc_g, finh_g, scatterp={'c': 'm', 'marker': '+', 'alpha': .5}, ax=ax, xlim=(fexc[0], fexc[-1]), ylim=(finh[0], finh[-1])) fig, ax = plot_contour( fexc_g, finh_g, dev1s_u, contourfp={'cmap': plt.cm.winter}, contourp={'colors': 'r'}, fig=fig, subplotp=(1, 2, 2), xlabel=r'$f_{exc}$', xlabelp={'fontsize': 20}, ylabel=r'$f_{inh}$', ylabelp={'fontsize': 20}, title=r'$+\sigma\%(a(u))$', titlep={'fontsize': 20}) plot_scatter( fexc_g, finh_g, scatterp={'c': 'm', 'marker': '+', 'alpha': .5}, ax=ax, xlim=(fexc[0], fexc[-1]), ylim=(finh[0], finh[-1]), close=close, fname=FIGDIR+fname_pre+'fe_fi_noisy_tuning.png', savep={'dpi': 200})
def test_num_hash_funcs(fib, traffic, pref_stats): '''Vary hash function count ''' print('\n\ntest_num_hash_funcs()\n\n') test_matrix = { 'linear': list(range(7, 21, 1)), 'guided': list(range(7, 21, 1)) } protocol = 'v4' res = {} for typ in test_matrix: print('\nStarting on %s\n' % typ) res[typ] = {'k': [], 'ncalls': [], 'bf': []} # list of tuples for k_size in test_matrix[typ]: if typ == 'linear': ## LINEAR bf_linear, _ = ipfilter.build_bloom_filter( protocol=protocol, lamda=None, fpp=None, k=k_size, num_bits=BITARR_SIZE, fib=fib) res[typ]['k'].append(k_size) res[typ]['bf'].append(str(bf_linear)) print(bf_linear) # record starting ncalls for each function of interest ncontains = bf_linear._register.ncalls nfnv = hash_fnv.ncalls nfib = fib.__contains__.ncalls ndefault = ipfilter._default_to_linear_search.ncalls # perform the lookup _lookup_wrapper(bf_linear, traffic, fib, pref_stats, protocol, bst=None, typ='linear') # record the ending ncalls for each function of interest ncontains = (bf_linear._register.ncalls - ncontains) / THROTTLE nfnv = (hash_fnv.ncalls - nfnv) / THROTTLE nfib = (fib.__contains__.ncalls - nfib) / THROTTLE ndefault = (ipfilter._default_to_linear_search.ncalls - ndefault) / THROTTLE res[typ]['ncalls'].append((ncontains, nfnv, nfib, ndefault)) else: ## GUIDED # use hand tuned params bf_guided, bst = ipfilter.build_bloom_filter( protocol=protocol, lamda=weigh_equally, fpp=None, k=k_size, num_bits=BITARR_SIZE, fib=fib) res[typ]['k'].append(k_size) res[typ]['bf'].append(str(bf_guided)) print(bf_guided) # record starting ncalls for each function of interest ncontains = bf_guided._register.ncalls nfnv = hash_fnv.ncalls nfib = fib.__contains__.ncalls ndefault = ipfilter._default_to_linear_search.ncalls # perform the lookup _lookup_wrapper(bf_guided, traffic, fib, pref_stats, protocol, bst=bst, typ='guided') # record the ending ncalls for each function of interest ncontains = (bf_guided._register.ncalls - ncontains) / THROTTLE nfnv = (hash_fnv.ncalls - nfnv) / THROTTLE nfib = (fib.__contains__.ncalls - nfib) / THROTTLE ndefault = (ipfilter._default_to_linear_search.ncalls - ndefault) / THROTTLE res[typ]['ncalls'].append((ncontains, nfnv, nfib, ndefault)) # record experiment to file in EXPERIMENTS: header, plot title, xaxis, yaxis, xs, ys, misc info with open(os.path.join(EXPERIMENTS, 'linear_numHashFuncs_v4_random.txt'), 'w') as out: lines = [ "test_num_hash_funcs(): vary num hash funcs, keeping bitarray size constant, for linear, invocations of funcs,xs=[bf._register(), hash_fnv(), fib.__contains__(), ipfilter._default_to_linear_search], yaxis=ncalls" ] # header lines.append('Linear search: lookup/hashing stats') # plot title lines.append('Num hash funcs') # xaxis title lines.append('Count of invocations') # yaxis title lines.append(';'.join([str(val) for val in res['linear']['k']])) # xs lines.append(';'.join([ '(%.2f, %.2f, %.2f, %.2f)' % quad for quad in res['linear']['ncalls'] ])) # ys lines.append(';'.join(res['linear']['bf'])) # any extra info out.write('\n'.join(lines)) with open(os.path.join(EXPERIMENTS, 'guided_numHashFuncs_v4_random.txt'), 'w') as out: lines = [ "test_num_hash_funcs(): vary num hash funcs, keeping bitarray size constant, for guided, invocations of funcs,xs=[bf._register(), hash_fnv(), fib.__contains__(), ipfilter._default_to_linear_search], yaxis=ncalls" ] # header lines.append('Linear search: lookup/hashing stats') # plot title lines.append('Num hash funcs') # xaxis title lines.append('Count of invocations') # yaxis title lines.append(';'.join([str(val) for val in res['guided']['k']])) # xs lines.append(';'.join([ '(%.2f, %.2f, %.2f, %.2f)' % quad for quad in res['guided']['ncalls'] ])) # ys lines.append(';'.join(res['guided']['bf'])) # any extra info out.write('\n'.join(lines)) # plot seqs = ['bit lookups', 'hashing', 'FIB lookups', 'defaults'] ofile = 'numHashFuncs_' + protocol + '_random.svg' title = 'Count by metric: number of hash funcs' xlabel = 'count of hash funcs' ylabel = 'count' plot_scatter(seqs, res, ofile, title, xlabel, ylabel, key='k', x_logscale=False) print('\n\nAll done!')
(config['lda']*diff).mean() prog.add_loss_critic(cpu(loss_critic.data).numpy()[0]) dis_optim.zero_grad() loss_critic.backward() dis_optim.step() prog.add_loss_dis() z = sampler.sample_z(batchsize,config['dim_z']) z = Variable(cuda(torch.from_numpy(z))) samples_fake = gen_net(z) f_fake = dis_net(samples_fake) loss_gen = -f_fake.mean() prog.add_loss_gen(cpu(loss_gen.data).numpy()[0]) gen_optim.zero_grad() loss_gen.backward() gen_optim.step() if (i+1)%config['num_plot'] == 0: print(i+1,prog.duration()) z = sampler.sample_z(500,config['dim_z']) z = Variable(cuda(torch.from_numpy(z))) samples_fake = cpu(gen_net(z).data).numpy() plot.plot_corr(samples_fake,dir='plot', filename='{}_corr'.format(i+1),show=False) plot.plot_scatter(sampler.mat[:,:200].T,samples_fake[:200,:], dir='plot',filename='{}_scatter'.format(i+1),show=False) prog.start() prog.plot()