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