def test(train_data,
test_data=None,
n_hidden=None,
learn_rate=0.1,
n_epochs=500,
verbose=True):
"""
Uses <test_data> to evaluate classification accuracy of network trained on
<train_data>.
INPUTS:
- train_data (list): list of train data, stored as tuples of input/target
feature vectors
- test_data (list): list of test data, in same format as train data
- n_hidden (int): size of hidden layer
- learn_rate (float): learning rate for grad. descent
- n_epochs (int): total iterations over all train data
- verbose (bool): prints test accuracy if True
OUTPUTS:
- returns test accuracy and trained weights/biases
"""
if test_data is None:
test_data = train_data # use same dataset for train/test
# classify test data using trained weights/biases
w_out, b_out, w_h, b_h = train(train_data, n_hidden, learn_rate, n_epochs)
n_correct, n_data = 0, len(test_data)
for x, target in test_data:
_, sigma_out = forward(x, w_out, b_out, w_h, b_h)
pred = np.argmax(sigma_out)
n_correct += target[pred][0]
if verbose:
print("Percent classified correctly: {:.2f}% ({}:{})".format(
100 * n_correct / n_data, n_correct, n_data - n_correct))
return n_correct, n_data, (w_out, b_out, w_h, b_h)
def classify(net, impath, regions_list, image_mean):
im = imread(impath)
batch_size = len(regions_list) / 4
image_batch = np.zeros((batch_size, 3, 227, 227))
for i in range(batch_size):
x0 = int(regions_list[i * 4 + 0])
y0 = int(regions_list[i * 4 + 1])
x1 = int(regions_list[i * 4 + 2])
y1 = int(regions_list[i * 4 + 3])
sub_image = im[x0:x1, y0:y1, :]
jit_image = cv2.resize(sub_image, (256, 256))
image = image_to_h5(jit_image,
image_mean,
crop_size=227,
image_scaling=1.0)
image_batch[i, :, :, :] = image
input_en = {"image": image_batch}
probs = forward(net, input_en, deploy=True)
res = ''
for i in range(probs.shape[0]):
index, value = get_max_index(probs[i, :])
res += "%d %.03f" % (index, value)
return res
def main():
torch.manual_seed(opt.random_seed)
torch.cuda.manual_seed(opt.random_seed)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# device = torch.device('cpu')
cur_dir = os.getcwd()
train_dataset = MultiSessionsGraph(cur_dir + '/datasets/' + opt.dataset, phrase='train', knn_phrase='neigh_data_'+str(opt.id))
train_loader = DataLoader(train_dataset, batch_size=opt.batch_size, shuffle=True)
test_dataset = MultiSessionsGraph(cur_dir + '/datasets/' + opt.dataset, phrase='test', knn_phrase='neigh_data_'+str(opt.id))
test_loader = DataLoader(test_dataset, batch_size=opt.batch_size, shuffle=False)
log_dir = cur_dir + '/log/' + str(opt.dataset) + '/' + time.strftime(
"%Y-%m-%d %H:%M:%S", time.localtime())
if not os.path.exists(log_dir):
os.makedirs(log_dir)
logging.warning('logging to {}'.format(log_dir))
writer = SummaryWriter(log_dir)
if opt.dataset == 'cikm16':
n_node = 43097
elif opt.dataset == 'yoochoose1_64':
n_node = 17400
else:
n_node = 309
model = GraphModel(opt, n_node=n_node).to(device)
multigraph_parameters = list(map(id, model.group_graph.parameters()))
srgnn_parameters = (p for p in model.parameters() if id(p) not in multigraph_parameters)
parameters = [{"params": model.group_graph.parameters(), "lr": 0.001}, {"params": srgnn_parameters}]
# best 0.1
lambda1 = lambda epoch: 0.1 ** (epoch // 3)
lambda2 = lambda epoch: 0.1 ** (epoch // 3)
optimizer = torch.optim.Adam(parameters, lr=opt.lr, weight_decay=opt.l2)
#scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=opt.lr_dc_step, gamma=opt.lr_dc)
scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=[lambda1, lambda2])
logging.warning(model)
if not opt.predict:
best_result20 = [0, 0]
best_epoch20 = [0, 0]
best_result10 = [0, 0]
best_epoch10 = [0, 0]
best_result5 = [0, 0]
best_epoch5 = [0, 0]
for epoch in range(opt.epoch):
scheduler.step(epoch)
print("Epoch ", epoch)
forward(model, train_loader, device, writer, epoch, top_k=opt.top_k, optimizer=optimizer, train_flag=True)
with torch.no_grad():
mrr20, hit20, mrr10, hit10, mrr5, hit5 = forward(model, test_loader, device, writer, epoch, top_k=opt.top_k, train_flag=False)
if hit20 >= best_result20[0]:
best_result20[0] = hit20
best_epoch20[0] = epoch
# torch.save(model.state_dict(), log_dir+'/best_recall_params.pkl')
if mrr20 >= best_result20[1]:
best_result20[1] = mrr20
best_epoch20[1] = epoch
if hit10 >= best_result10[0]:
best_result10[0] = hit10
best_epoch10[0] = epoch
# torch.save(model.state_dict(), log_dir+'/best_recall_params.pkl')
if mrr10 >= best_result10[1]:
best_result10[1] = mrr10
best_epoch10[1] = epoch
# torch.save(model.state_dict(), log_dir+'/best_mrr_params.pkl')
if hit5 >= best_result5[0]:
best_result5[0] = hit5
best_epoch5[0] = epoch
# torch.save(model.state_dict(), log_dir+'/best_recall_params.pkl')
if mrr5 >= best_result5[1]:
best_result5[1] = mrr5
best_epoch5[1] = epoch
print('Best Result:')
print('\tMrr@%d:\t%.4f\tEpoch:\t%d' % (20, best_result20[1], best_epoch20[1]))
print('\tRecall@%d:\t%.4f\tEpoch:\t%d\n' % (20, best_result20[0], best_epoch20[0]))
print('\tMrr@%d:\t%.4f\tEpoch:\t%d' % (opt.top_k, best_result10[1], best_epoch10[1]))
print('\tRecall@%d:\t%.4f\tEpoch:\t%d\n' % (opt.top_k, best_result10[0], best_epoch10[0]))
print('\tMrr@%d:\t%.4f\tEpoch:\t%d' % (5, best_result5[1], best_epoch5[1]))
print('\tRecall@%d:\t%.4f\tEpoch:\t%d' % (5, best_result5[0], best_epoch5[0]))
print("-"*20)
# print_txt(log_dir, opt, best_result, best_epoch, opt.top_k, note, save_config=True)
else:
log_dir = 'log/cikm16/2019-08-19 14:27:33'
model.load_state_dict(torch.load(log_dir+'/best_mrr_params.pkl'))
mrr, hit = forward(model, test_loader, device, writer, 0, top_k=opt.top_k, train_flag=False)
best_result = [hit, mrr]
best_epoch = [0, 0]
def main():
assert opt.dataset in ['gowalla', 'lastfm']
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
cur_dir = os.getcwd()
train_dataset = MultiSessionsGraph(cur_dir + '/../datasets/' + opt.dataset,
phrase='train')
train_loader = DataLoader(train_dataset,
batch_size=opt.batch_size,
shuffle=True)
train_for_res, _ = load_data_valid(
os.path.expanduser(
os.path.normpath(cur_dir + '/../datasets/' + opt.dataset +
'/raw/train.txt.csv')), 0)
max_train_item = max(max(max(train_for_res[0])), max(train_for_res[1]))
max_train_user = max(train_for_res[2])
test_dataset = MultiSessionsGraph(cur_dir + '/../datasets/' + opt.dataset,
phrase='test1')
test_loader = DataLoader(test_dataset,
batch_size=opt.batch_size,
shuffle=False)
test_for_res = load_testdata(
os.path.expanduser(
os.path.normpath(cur_dir + '/../datasets/' + opt.dataset +
'/raw/test1.txt.csv')))
max_item = max(max(max(test_for_res[0])), max(test_for_res[1]))
max_user = max(test_for_res[2])
pre_max_item = max_train_item
pre_max_user = max_train_user
log_dir = cur_dir + '/../log/' + str(opt.dataset) + '/paper200/' + str(
opt) + '_fix_new_entropy(rank)_on_union+' + str(opt.u) + 'tanh*u_AGCN***GAG-win' + str(opt.win_size) \
+ '***concat3_linear_tanh_in_e2s_' + time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
if not os.path.exists(log_dir):
os.makedirs(log_dir)
logging.warning('logging to {}'.format(log_dir))
writer = SummaryWriter(log_dir)
if opt.dataset == 'gowalla':
n_item = 30000
n_user = 33005
else:
n_item = 10000
n_user = 984
model = GNNModel(hidden_size=opt.hidden_size,
n_item=n_item,
n_user=n_user,
u=opt.u).to(device)
optimizer = torch.optim.Adam(model.parameters(),
lr=opt.lr,
weight_decay=opt.l2)
scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer,
milestones=[2, 3],
gamma=opt.lr_dc)
logging.warning(model)
# offline training on 'train' and test on 'test1'
logging.warning('*********Begin offline training*********')
updates_per_epoch = len(train_loader)
updates_count = 0
for train_epoch in tqdm(range(opt.epoch)):
forward(model,
train_loader,
device,
writer,
train_epoch,
optimizer=optimizer,
train_flag=True,
max_item_id=max_train_item,
last_update=updates_count)
scheduler.step()
updates_count += updates_per_epoch
with torch.no_grad():
forward(model,
test_loader,
device,
writer,
train_epoch,
train_flag=False,
max_item_id=max_item)
# reservoir construction with 'train'
logging.warning(
'*********Constructing the reservoir with offline training data*********'
)
res = Reservoir(train_for_res, opt.res_size)
res.update(train_for_res)
# test and online training on 'test2~5'
logging.warning('*********Begin online training*********')
now = time.asctime()
for test_epoch in tqdm(range(1, 6)):
if test_epoch != 1:
test_dataset = MultiSessionsGraph(cur_dir + '/../datasets/' +
opt.dataset,
phrase='test' + str(test_epoch))
test_loader = DataLoader(test_dataset,
batch_size=opt.batch_size,
shuffle=False)
test_for_res = load_testdata(
os.path.expanduser(
os.path.normpath(cur_dir + '/../datasets/' + opt.dataset +
'/raw/test' + str(test_epoch) +
'.txt.csv')))
pre_max_item = max_item
pre_max_user = max_user
max_item = max(max(max(test_for_res[0])), max(test_for_res[1]))
max_user = max(test_for_res[2])
# test on the current test set
# no need to test on test1 because it's done in the online training part
# epoch + 10 is a number only for the visualization convenience
with torch.no_grad():
forward(model,
test_loader,
device,
writer,
test_epoch + 10,
train_flag=False,
max_item_id=max_item)
# reservoir sampling
sampled_data = fix_new_entropy_on_union(cur_dir,
now,
opt,
model,
device,
res.data,
test_for_res,
len(test_for_res[0]) //
opt.win_size,
pre_max_item,
pre_max_user,
ent='wass')
# cast the sampled set to dataset
sampled_dataset = MultiSessionsGraph(cur_dir + '/../datasets/' +
opt.dataset,
phrase='sampled' + now,
sampled_data=sampled_data)
sampled_loader = DataLoader(sampled_dataset,
batch_size=opt.batch_size,
shuffle=True)
# update with the sampled set
forward(model,
sampled_loader,
device,
writer,
test_epoch + opt.epoch,
optimizer=optimizer,
train_flag=True,
max_item_id=max_item,
last_update=updates_count)
updates_count += len(test_loader)
scheduler.step()
res.update(test_for_res)
os.remove('../datasets/' + opt.dataset + '/processed/sampled' + now +
'.pt')
def main():
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
cur_dir = os.getcwd()
# custom dataset
train_dataset = MultiSessionsGraph(cur_dir + '/datasets/' + opt.dataset,
phrase='train')
train_loader = DataLoader(train_dataset,
batch_size=opt.batch_size,
shuffle=True)
test_dataset = MultiSessionsGraph(cur_dir + '/datasets/' + opt.dataset,
phrase='test')
test_loader = DataLoader(test_dataset,
batch_size=opt.batch_size,
shuffle=False)
# log_dir = cur_dir + '/log/' + str(opt.dataset) + '/' + str(opt) + '_s2s3_linear_gat8-1_noleaky_' + time.strftime(
# "%Y-%m-%d %H:%M:%S", time.localtime())
log_dir = cur_dir + '/log/' + str(opt.dataset) + '/' + 'model_log'
if not os.path.exists(log_dir):
os.makedirs(log_dir)
logging.warning('logging to {}'.format(log_dir))
writer = SummaryWriter(log_dir)
if opt.dataset == 'diginetica':
n_node = 43097
elif opt.dataset == 'yoochoose1_64' or opt.dataset == 'yoochoose1_4':
n_node = 37483
else:
n_node = 309
model = GNNModel(hidden_size=opt.hidden_size, n_node=n_node).to(device)
# model = SortPoolModel(hidden_size=opt.hidden_size, n_node=n_node).to(device)
# model = Set2SetModel(hidden_size=opt.hidden_size, n_node=n_node).to(device)
# model = GINSet2SetModel(hidden_size=opt.hidden_size, n_node=n_node).to(device)
# model = VirtualNodeModel(hidden_size=opt.hidden_size, n_node=n_node).to(device)
# model = Set2SetATTModel(hidden_size=opt.hidden_size, n_node=n_node).to(device)
# model = VirtualNodeRNNModel(hidden_size=opt.hidden_size, n_node=n_node).to(device)
optimizer = torch.optim.Adam(model.parameters(),
lr=opt.lr,
weight_decay=opt.l2)
# optimizer = torch.optim.SGD(model.parameters(), lr=opt.lr, weight_decay=opt.l2, momentum=opt.momentum)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer,
step_size=opt.lr_dc_step,
gamma=opt.lr_dc)
logging.warning(model)
for epoch in tqdm(range(opt.epoch)):
scheduler.step()
_, _ = forward(model,
train_loader,
device,
writer,
epoch,
top_k=opt.top_k,
optimizer=optimizer,
train_flag=True)
with torch.no_grad():
h, m = forward(model,
test_loader,
device,
writer,
epoch,
top_k=opt.top_k,
train_flag=False)
print(h, m)
def main():
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
cur_dir = os.getcwd()
train_dataset = MultiSessionsGraph(cur_dir + '/../datasets/' + opt.dataset,
phrase='train')
train_loader = DataLoader(train_dataset,
batch_size=opt.batch_size,
shuffle=True)
test_dataset = MultiSessionsGraph(cur_dir + '/../datasets/' + opt.dataset,
phrase='test')
test_loader = DataLoader(test_dataset,
batch_size=opt.batch_size,
shuffle=False)
log_dir = cur_dir + '/../log/' + str(
opt.dataset) + '/' + str(opt) + time.strftime("%Y-%m-%d %H:%M:%S",
time.localtime())
if not os.path.exists(log_dir):
os.makedirs(log_dir)
logging.warning('logging to {}'.format(log_dir))
writer = SummaryWriter(log_dir)
if opt.dataset == 'diginetica':
n_node = 43097
elif opt.dataset == 'yoochoose1_64' or opt.dataset == 'yoochoose1_4':
n_node = 37483
else:
n_node = 309
model = GNNModel(hidden_size=opt.hidden_size,
n_node=n_node,
use_san=opt.use_san,
use_gat=opt.use_gat).to(device)
optimizer = torch.optim.Adam(model.parameters(),
lr=opt.lr,
weight_decay=opt.l2)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer,
step_size=opt.lr_dc_step,
gamma=opt.lr_dc)
logging.warning(model)
for epoch in tqdm(range(opt.epoch)):
scheduler.step()
forward(model,
train_loader,
device,
writer,
epoch,
top_k=opt.top_k,
optimizer=optimizer,
train_flag=True)
with torch.no_grad():
forward(model,
test_loader,
device,
writer,
epoch,
top_k=opt.top_k,
train_flag=False)
def eval_ai_generate(dataloader, params, eval_batch_size, split='test'):
ranks_json = []
dialog_encoder.eval()
batch_idx = 0
with torch.no_grad():
batch_size = 500 * (params['n_gpus'] / 8)
batch_size = min([1, 2, 4, 5, 100, 1000, 200, 8, 10, 40, 50, 500, 20, 25, 250, 125], \
key=lambda x: abs(x-batch_size) if x <= batch_size else float("inf"))
print("batch size for evaluation", batch_size)
for epochId, _, batch in batch_iter(dataloader, params):
if epochId == 1:
break
tokens = batch['tokens']
num_rounds = tokens.shape[1]
num_options = tokens.shape[2]
tokens = tokens.view(-1, tokens.shape[-1])
segments = batch['segments']
segments = segments.view(-1, segments.shape[-1])
sep_indices = batch['sep_indices']
sep_indices = sep_indices.view(-1, sep_indices.shape[-1])
mask = batch['mask']
mask = mask.view(-1, mask.shape[-1])
hist_len = batch['hist_len']
hist_len = hist_len.view(-1)
# get image features
features = batch['image_feat']
spatials = batch['image_loc']
image_mask = batch['image_mask']
# expand the image features to match those of tokens etc.
max_num_regions = features.shape[-2]
features = features.unsqueeze(1).unsqueeze(1).expand(
eval_batch_size, num_rounds, num_options, max_num_regions,
2048).contiguous()
spatials = spatials.unsqueeze(1).unsqueeze(1).expand(
eval_batch_size, num_rounds, num_options, max_num_regions,
5).contiguous()
image_mask = image_mask.unsqueeze(1).unsqueeze(1).expand(
eval_batch_size, num_rounds, num_options,
max_num_regions).contiguous()
features = features.view(-1, max_num_regions, 2048)
spatials = spatials.view(-1, max_num_regions, 5)
image_mask = image_mask.view(-1, max_num_regions)
assert tokens.shape[0] == segments.shape[0] == sep_indices.shape[0] == mask.shape[0] == \
hist_len.shape[0] == features.shape[0] == spatials.shape[0] == \
image_mask.shape[0] == num_rounds * num_options * eval_batch_size
output = []
assert (eval_batch_size * num_rounds *
num_options) // batch_size == (eval_batch_size * num_rounds
* num_options) / batch_size
for j in range(
(eval_batch_size * num_rounds * num_options) // batch_size):
# create chunks of the original batch
item = {}
item['tokens'] = tokens[j * batch_size:(j + 1) * batch_size, :]
item['segments'] = segments[j * batch_size:(j + 1) *
batch_size, :]
item['sep_indices'] = sep_indices[j * batch_size:(j + 1) *
batch_size, :]
item['mask'] = mask[j * batch_size:(j + 1) * batch_size, :]
item['hist_len'] = hist_len[j * batch_size:(j + 1) *
batch_size]
item['image_feat'] = features[j * batch_size:(j + 1) *
batch_size, :, :]
item['image_loc'] = spatials[j * batch_size:(j + 1) *
batch_size, :, :]
item['image_mask'] = image_mask[j * batch_size:(j + 1) *
batch_size, :]
_, _, _, _, nsp_scores = forward(dialog_encoder,
item,
params,
output_nsp_scores=True,
evaluation=True)
# normalize nsp scores
nsp_probs = F.softmax(nsp_scores, dim=1)
assert nsp_probs.shape[-1] == 2
output.append(nsp_probs[:, 0])
# print("output shape",torch.cat(output,0).shape)
output = torch.cat(output, 0).view(eval_batch_size, num_rounds,
num_options)
ranks = scores_to_ranks(output)
ranks = ranks.squeeze(1)
for i in range(eval_batch_size):
ranks_json.append({
"image_id":
batch["image_id"][i].item(),
"round_id":
int(batch["round_id"][i].item()),
"ranks": [rank.item() for rank in ranks[i][:]],
})
batch_idx += 1
return ranks_json
def test(config):
""" Takes the config, run test program
"""
data_mean = load_data_mean(config["data"]["idl_mean"],
config["net"]["img_width"],
config["net"]["img_height"], image_scaling=1.0)
num_test_images = 599
# Warning: load_idl returns an infinite generator. Calling list() before islice() will hang.
test_list = list(itertools.islice(
load_idl(config["data"]["test_idl"], data_mean, config["net"], False),
0,
num_test_images))
img = np.copy(test_list[-1]["raw"])
# plt.imshow(img)
net = apollocaffe.ApolloNet()
net.phase = 'test'
forward(net, test_list[0], config["net"], True)
net.load("data/snapshot/reinspect_hcs_800000.h5")
annolist = al.AnnoList()
net_config = config["net"]
pix_per_w = net_config["img_width"]/net_config["grid_width"]
pix_per_h = net_config["img_height"]/net_config["grid_height"]
if config.has_key("conf_th"):
conf_th = config["conf_th"]
else:
conf_th = 0.6
mae = 0.
for i in range(num_test_images):
inputs = test_list[i]
bbox_list, conf_list = forward(net, inputs, net_config, True)
img = np.copy(inputs["raw"])
all_rects = [[[] for x in range(net_config["grid_width"])] for y in range(net_config["grid_height"])]
for n in range(len(bbox_list)):
for k in range(net_config["grid_height"] * net_config["grid_width"]):
y = int(k / net_config["grid_width"])
x = int(k % net_config["grid_width"])
bbox = bbox_list[n][k]
conf = conf_list[n][k,1].flatten()[0]
# notice the output rect [cx, cy, w, h]
# cx means center x-cord
abs_cx = pix_per_w/2 + pix_per_w*x + int(bbox[0,0,0])
abs_cy = pix_per_h/2 + pix_per_h*y + int(bbox[1,0,0])
w = bbox[2,0,0]
h = bbox[3,0,0]
all_rects[y][x].append(Rect(abs_cx,abs_cy,w,h,conf))
acc_rects = stitch_rects(all_rects)
display = True
if display:
for rect in acc_rects:
if rect.true_confidence < conf_th:
continue
cv2.rectangle(img,
(rect.cx-int(rect.width/2), rect.cy-int(rect.height/2)),
(rect.cx+int(rect.width/2), rect.cy+int(rect.height/2)),
(255,0,0),
2)
# cv2.circle(img,
# (rect.cx, rect.cy),
# ((rect.width + rect.height)/4),
# (255,0,0),
# 2)
img_name = './data/tmp/%05d.jpg' % i
plt.imsave(img_name, img)
plt.figure(figsize=(15,10))
plt.imshow(img)
anno = al.Annotation()
anno.imageName = inputs["imname"]
# count
number = 0;
for rect in acc_rects:
r = al.AnnoRect()
r.x1 = rect.cx - rect.width/2.
r.x2 = rect.cx + rect.width/2.
r.y1 = rect.cy - rect.height/2.
r.y2 = rect.cy + rect.height/2.
r.score = rect.true_confidence
anno.rects.append(r)
if r.score > conf_th:
number += 1;
annolist.append(anno)
mae += abs(number - len(inputs["rects"]))
print anno.imageName, number, len(inputs["rects"]), abs(number - len(inputs["rects"]))
print mae / num_test_images
def test(config):
""" Takes the config, run test program
"""
data_mean = load_data_mean(config["data"]["idl_mean"],
config["net"]["img_width"],
config["net"]["img_height"],
image_scaling=1.0)
num_test_images = 599
# Warning: load_idl returns an infinite generator. Calling list() before islice() will hang.
test_list = list(
itertools.islice(
load_idl(config["data"]["test_idl"], data_mean, config["net"],
False), 0, num_test_images))
img = np.copy(test_list[-1]["raw"])
# plt.imshow(img)
net = apollocaffe.ApolloNet()
net.phase = 'test'
forward(net, test_list[0], config["net"], True)
net.load("data/snapshot/reinspect_hcs_800000.h5")
annolist = al.AnnoList()
net_config = config["net"]
pix_per_w = net_config["img_width"] / net_config["grid_width"]
pix_per_h = net_config["img_height"] / net_config["grid_height"]
if config.has_key("conf_th"):
conf_th = config["conf_th"]
else:
conf_th = 0.6
mae = 0.
for i in range(num_test_images):
inputs = test_list[i]
bbox_list, conf_list = forward(net, inputs, net_config, True)
img = np.copy(inputs["raw"])
all_rects = [[[] for x in range(net_config["grid_width"])]
for y in range(net_config["grid_height"])]
for n in range(len(bbox_list)):
for k in range(net_config["grid_height"] *
net_config["grid_width"]):
y = int(k / net_config["grid_width"])
x = int(k % net_config["grid_width"])
bbox = bbox_list[n][k]
conf = conf_list[n][k, 1].flatten()[0]
# notice the output rect [cx, cy, w, h]
# cx means center x-cord
abs_cx = pix_per_w / 2 + pix_per_w * x + int(bbox[0, 0, 0])
abs_cy = pix_per_h / 2 + pix_per_h * y + int(bbox[1, 0, 0])
w = bbox[2, 0, 0]
h = bbox[3, 0, 0]
all_rects[y][x].append(Rect(abs_cx, abs_cy, w, h, conf))
acc_rects = stitch_rects(all_rects)
display = True
if display:
for rect in acc_rects:
if rect.true_confidence < conf_th:
continue
cv2.rectangle(img, (rect.cx - int(rect.width / 2),
rect.cy - int(rect.height / 2)),
(rect.cx + int(rect.width / 2),
rect.cy + int(rect.height / 2)), (255, 0, 0), 2)
# cv2.circle(img,
# (rect.cx, rect.cy),
# ((rect.width + rect.height)/4),
# (255,0,0),
# 2)
img_name = './data/tmp/%05d.jpg' % i
plt.imsave(img_name, img)
plt.figure(figsize=(15, 10))
plt.imshow(img)
anno = al.Annotation()
anno.imageName = inputs["imname"]
# count
number = 0
for rect in acc_rects:
r = al.AnnoRect()
r.x1 = rect.cx - rect.width / 2.
r.x2 = rect.cx + rect.width / 2.
r.y1 = rect.cy - rect.height / 2.
r.y2 = rect.cy + rect.height / 2.
r.score = rect.true_confidence
anno.rects.append(r)
if r.score > conf_th:
number += 1
annolist.append(anno)
mae += abs(number - len(inputs["rects"]))
print anno.imageName, number, len(
inputs["rects"]), abs(number - len(inputs["rects"]))
print mae / num_test_images
batch['segments'] = segments
batch['sep_indices'] = sep_indices
batch['mask'] = mask
batch['hist_len'] = hist_len
batch['next_sentence_labels'] = nsp_labels
batch['image_feat'] = features.contiguous()
batch['image_loc'] = spatials.contiguous()
batch['image_mask'] = image_mask.contiguous()
batch['image_target'] = image_target.contiguous()
batch['image_label'] = image_label.contiguous()
print("token shape", tokens.shape)
loss = 0
nsp_loss = 0
_, _, _, _, nsp_scores = forward(dialog_encoder, batch, \
params, sample_size=None, output_nsp_scores=True, evaluation=True)
logging.info("nsp scores: {}".format(nsp_scores))
# calculate dense annotation ce loss
nsp_scores = nsp_scores.view(-1, 80, 2)
nsp_loss = F.cross_entropy(nsp_scores.view(-1, 2), nsp_labels.view(-1))
nsp_scores = nsp_scores[:, :, 0]
gt_relevance = batch['gt_relevance'].to(device)
# shuffle the gt relevance scores as well
gt_relevance = gt_relevance[:, option_indices]
ce_loss = ce_loss_fct(F.log_softmax(nsp_scores, dim=1),
F.softmax(gt_relevance, dim=1))
loss = ce_loss + params['nsp_loss_coeff'] * nsp_loss
loss /= params['batch_multiply']
loss.backward()
scheduler.step()
def get_sentiment(word):
x = get_encoded_data(word, enc)
sentiment = forward(x, W, bias)
print(sentiment)
return sentiment[0][0]
def main():
config = json.load(open("config.json", 'r'))
config["data"]["test_idl"] = "./data/brainwash/brainwash_test.idl"
apollocaffe.set_random_seed(config["solver"]["random_seed"])
apollocaffe.set_device(0)
# Now lets load the data mean and the data.
data_mean = load_data_mean(config["data"]["idl_mean"],
config["net"]["img_width"],
config["net"]["img_height"], image_scaling=1.0)
num_test_images = 500
display = True
## Warning: load_idl returns an infinite generator. Calling list() before islice() will hang.
test_list = list(itertools.islice(
load_idl(config["data"]["test_idl"], data_mean, config["net"], False),
0,
num_test_images))
# We can now load the snapshot weights.
net = apollocaffe.ApolloNet()
net.phase = 'test'
import time; s = time.time()
forward(net, test_list[0], config["net"], True) # define structure
print time.time() - s
net.load("./data/brainwash_800000.h5") # load pre-trained weights
# We can now begin to run the model and visualize the results.
annolist = al.AnnoList()
net_config = config["net"]
pix_per_w = net_config["img_width"]/net_config["grid_width"]
pix_per_h = net_config["img_height"]/net_config["grid_height"]
for i in range(10):
inputs = test_list[i]
timer = Timer()
timer.tic()
bbox_list, conf_list = forward(net, inputs, net_config, True)
timer.toc()
print ('Detection took {:.3f}s').format(timer.total_time)
img = np.copy(inputs["raw"])
png = np.copy(inputs["imname"])
all_rects = [[[] for x in range(net_config["grid_width"])] for y in range(net_config["grid_height"])]
for n in range(len(bbox_list)):
for k in range(net_config["grid_height"] * net_config["grid_width"]):
y = int(k / net_config["grid_width"])
x = int(k % net_config["grid_width"])
bbox = bbox_list[n][k]
conf = conf_list[n][k,1].flatten()[0]
abs_cx = pix_per_w/2 + pix_per_w*x + int(bbox[0,0,0])
abs_cy = pix_per_h/2 + pix_per_h*y+int(bbox[1,0,0])
w = bbox[2,0,0]
h = bbox[3,0,0]
all_rects[y][x].append(Rect(abs_cx,abs_cy,w,h,conf))
timer.tic()
acc_rects = stitch_rects(all_rects)
timer.toc()
print ('Stitching detected bboxes took {:.3f}s').format(timer.total_time)
if display:
visualize_detection(img, acc_rects)
anno = al.Annotation()
anno.imageName = inputs["imname"]
for rect in acc_rects:
r = al.AnnoRect()
r.x1 = rect.cx - rect.width/2.
r.x2 = rect.cx + rect.width/2.
r.y1 = rect.cy - rect.height/2.
r.y2 = rect.cy + rect.height/2.
r.score = rect.true_confidence
anno.rects.append(r)
annolist.append(anno)
def main():
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
cur_dir = os.getcwd()
train_filename, test_filename = 'train.txt', 'test.txt'
dataset_name = opt.dataset
if 'yoochoose' in opt.dataset:
dataset_name = 'yoochoose'
train_filename = opt.dataset + '-' + train_filename
test_filename = opt.dataset + '-' + test_filename
train_dataset = MultiSessionsGraph(
name=train_filename,
raw_dir=cur_dir + '/../../../_data/' + dataset_name + '/processed/',
save_dir=cur_dir + '/../../../_data/' + dataset_name + '/saved/',
force_reload=True)
num_train = len(train_dataset)
train_sampler = SubsetRandomSampler(torch.arange(num_train))
train_loader = GraphDataLoader(
train_dataset,
batch_size=opt.batch_size,
# sampler=train_sampler,
shuffle=True,
drop_last=False)
test_dataset = MultiSessionsGraph(
name=test_filename,
raw_dir=cur_dir + '/../../../_data/' + dataset_name + '/processed/',
save_dir=cur_dir + '/../../../_data/' + dataset_name + '/saved/',
force_reload=True)
num_test = len(test_dataset)
test_sampler = SubsetRandomSampler(torch.arange(num_test))
test_loader = GraphDataLoader(
test_dataset,
batch_size=opt.batch_size,
# sampler=test_sampler,
shuffle=False,
drop_last=False)
log_dir = os.path.join(cur_dir, 'log', str(opt.dataset), str(opt))
if not os.path.exists(log_dir):
os.makedirs(log_dir)
logging.warning('logging to {}'.format(log_dir))
writer = SummaryWriter(log_dir)
if 'diginetica' in opt.dataset:
n_node = 43097
elif 'yoochoose' in opt.dataset:
n_node = 37483
else:
n_node = 309
model = GNNModel(hidden_size=opt.hidden_size, n_node=n_node).to(device)
optimizer = torch.optim.Adam(model.parameters(),
lr=opt.lr,
weight_decay=opt.l2)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer,
step_size=opt.lr_dc_step,
gamma=opt.lr_dc)
logging.warning(model)
for epoch in tqdm(range(opt.epoch)):
forward(model,
train_loader,
device,
writer,
epoch,
top_k=opt.top_k,
optimizer=optimizer,
train_flag=True)
with torch.no_grad():
forward(model,
test_loader,
device,
writer,
epoch,
top_k=opt.top_k,
train_flag=False)
scheduler.step()
