def demo():
net = Resnet18_8s(ver_dim=vote_num * 2, seg_dim=2)
net = NetWrapper(net).cuda()
net = DataParallel(net)
optimizer = optim.Adam(net.parameters(), lr=train_cfg['lr'])
model_dir = os.path.join(cfg.MODEL_DIR, "switch_linemod_train")
load_model(net.module.net, optimizer, model_dir, -1)
image, points_3d, bb8_3d = read_data()
image = image[None, ...]
seg_pred, vertex_pred = net(image)
# visualize_mask(mask)
# visualize_vertex(vertex, vertex_weights)
# visualize_hypothesis(image, seg_pred, vertex_pred, corner_target)
# visualize_voting_ellipse(image, seg_pred, vertex_pred, corner_target)
eval_net = DataParallel(EvalWrapper().cuda())
corner_pred = eval_net(seg_pred, vertex_pred).cpu().detach().numpy()[0]
camera_matrix = np.array([[572.4114, 0., 325.2611],
[0., 573.57043, 242.04899], [0., 0., 1.]])
pose_pred = pnp(points_3d, corner_pred, camera_matrix)
projector = Projector()
bb8_2d_pred = projector.project(bb8_3d, pose_pred, 'linemod')
print(bb8_2d_pred)
image = imagenet_to_uint8(image.detach().cpu().numpy())[0]
visualize_bounding_box(image[None, ...], bb8_2d_pred[None, None, ...])
def demo():
net = Resnet18_8s(ver_dim=vote_num * 2, seg_dim=2)
net = NetWrapper(net).cuda()
net = DataParallel(net)
optimizer = optim.Adam(net.parameters(), lr=train_cfg['lr'])
model_dir = os.path.join(cfg.MODEL_DIR, "cat_demo")
load_model(net.module.net, optimizer, model_dir, args.load_epoch)
data, points_3d, bb8_3d = read_data()
image, mask, vertex, vertex_weights, pose, corner_target = [
d.unsqueeze(0).cuda() for d in data
]
seg_pred, vertex_pred, loss_seg, loss_vertex, precision, recall = net(
image, mask, vertex, vertex_weights)
eval_net = DataParallel(EvalWrapper().cuda())
corner_pred = eval_net(seg_pred, vertex_pred).cpu().detach().numpy()[0]
camera_matrix = np.array([[572.4114, 0., 325.2611],
[0., 573.57043, 242.04899], [0., 0., 1.]])
pose_pred = pnp(points_3d, corner_pred, camera_matrix)
projector = Projector()
bb8_2d_pred = projector.project(bb8_3d, pose_pred, 'linemod')
bb8_2d_gt = projector.project(bb8_3d, pose[0].detach().cpu().numpy(),
'linemod')
image = imagenet_to_uint8(image.detach().cpu().numpy())[0]
visualize_bounding_box(image[None, ...], bb8_2d_pred[None, None, ...],
bb8_2d_gt[None, None, ...])
def demo():
net = Resnet18_8s(ver_dim=vote_num * 2, seg_dim=2)
net = NetWrapper(net).cuda()
net = DataParallel(net)
optimizer = optim.Adam(net.parameters(), lr=train_cfg['lr'])
model_dir = os.path.join(cfg.MODEL_DIR, "cat_linemod_train") #cat_demo
load_model(net.module.net, optimizer, model_dir, args.load_epoch)
data, points_3d, bb8_3d = read_data()
image, mask, vertex, vertex_weights, pose, corner_target = [
d.unsqueeze(0).cuda() for d in data
]
seg_pred, vertex_pred, loss_seg, loss_vertex, precision, recall = net(
image, mask, vertex, vertex_weights)
eval_net = DataParallel(EvalWrapper().cuda())
#向量方形图，语义分割图，然后 ransac 计算 kp，，向量方向图一旦准了，kp也就准了
corner_pred = eval_net(seg_pred, vertex_pred).cpu().detach().numpy()[0]
camera_matrix = np.array([[572.4114, 0., 325.2611],
[0., 573.57043, 242.04899], [0., 0., 1.]])
pose_pred = pnp(points_3d, corner_pred, camera_matrix)
projector = Projector()
#
bb8_2d_pred = projector.project(bb8_3d, pose_pred, 'linemod')
bb8_2d_gt = projector.project(bb8_3d, pose[0].detach().cpu().numpy(),
'linemod')
image = imagenet_to_uint8(image.detach().cpu().numpy())[0]
print("loss_seg:{} , loss_vertex:{} , precision:{},recall:{}, ".format(
loss_seg, loss_vertex, precision, recall))
#399.pth
#loss_seg:tensor([0.0015], device='cuda:0', grad_fn=<MeanBackward0>) , loss_vertex:tensor([0.0016], device='cuda:0', grad_fn=<DivBackward1>) ,
#precision:tensor([0.9434], device='cuda:0'),recall:tensor([0.9677], device='cuda:0'),
#199.pth
# loss_seg:tensor([0.0015], device='cuda:0', grad_fn=<MeanBackward0>) , loss_vertex:tensor([0.0016], device='cuda:0', grad_fn=<DivBackward1>) ,
# precision:tensor([0.9583], device='cuda:0'),recall:tensor([0.9524], device='cuda:0'),
erro = bb8_2d_pred - bb8_2d_gt
erro = np.abs(erro)
err = np.reshape(erro, (erro.size, ))
#abserr = map(abs,err)
print("reproject sum_error:{} ".format(np.sum(err)))
## 199 reproject sum_error:13.385891544820552
## 399 reproject sum_error:12.718721049803733
##看了是有提高 准召定义 准确下降，召回上升
visualize_bounding_box(image[None, ...], bb8_2d_pred[None, None, ...],
bb8_2d_gt[None, None, ...])
def demo(idx):
data, bb8_3d = read_data(idx)
print("BB8_3D: ",bb8_3d)
image, mask, pose = [d.unsqueeze(0).cuda() for d in data]
projector = Projector()
bb8_2d_gt = projector.project(bb8_3d, pose[0].detach().cpu().numpy(), 'blender')
print(bb8_2d_gt)
image = imagenet_to_uint8(image.detach().cpu().numpy())[0]
visualize_bounding_box(image[None, ...], bb8_2d_gt[None, None, ...])
def inference(input_image, count=0):
c_timer = time.time()
rgb = input_image
if args.input != 'image':
color = cv2.cvtColor(input_image, cv2.COLOR_BGR2RGB)
rgb = color
pre_start = time.time()
print(pre_start - c_timer, "s BGR2RGB")
#rgb = Image.open(input_image)
#print(rgb.shape)
start = time.time()
transformer = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
rgb = transformer(rgb)
rgb = rgb.unsqueeze(0).cuda()
seg_pred, vertex_pred = net(rgb)
eval_net = DataParallel(EvalWrapper().cuda())
corner_pred = eval_net(seg_pred, vertex_pred).cpu().detach().numpy()[0]
end = time.time()
print(end - start, "s - to go from image to corner prediction")
image = imagenet_to_uint8(rgb.detach().cpu().numpy())[0]
pose_pred = pnp(points_3d, corner_pred, camera_matrix)
projector = Projector()
bb8_2d_pred = projector.project(bb8_3d, pose_pred, 'logitech')
end_ = time.time()
print(end_ - end, "s - to project the corners and show the result")
seg_mask = torch.argmax(seg_pred, 1)
if args.debug:
visualize_mask(seg_mask, count)
pose_test = np.array([[1, 0, 0, 0], [0, 1, 0, 0.3], [0, 0, 1, 1.2]])
print(pose_pred)
#print(pose_test)
bb8_2d_gt = projector.project(bb8_3d, pose_test, 'logitech')
if pose_pred[2][3] < 0.4:
if pose_pred[2][3] > -0.4:
if isinstance(rgb, torch.Tensor):
rgb = rgb.permute(0, 2, 3, 1).detach().cpu().numpy()
rgb = rgb.astype(np.uint8)
_, ax = plt.subplots(1)
ax.imshow(cv2.cvtColor(input_image, cv2.COLOR_BGR2RGB))
#plt.show()
plt.savefig('temp{}.png'.format(count))
plt.close()
print("image was culled due to pose being unreasonable")
else:
visualize_bounding_box(image[None, ...],
bb8_2d_pred[None, None, ...],
save=True,
count=count) #,bb8_2d_gt[None, None, ...])
def demo():
net = Resnet18_8s(ver_dim=vote_num * 2, seg_dim=2)
net = NetWrapper(net).cuda()
net = DataParallel(net)
optimizer = optim.Adam(net.parameters(), lr=train_cfg['lr'])
model_dir = os.path.join(cfg.MODEL_DIR, "cat_demo")
load_model(net.module.net, optimizer, model_dir, -1)
data, points_3d, bb8_3d = read_data()
#print("BB8_3D: ",bb8_3d)
image, mask, vertex, vertex_weights, pose, corner_target = [
d.unsqueeze(0).cuda() for d in data
]
seg_pred, vertex_pred, loss_seg, loss_vertex, precision, recall = net(
image, mask, vertex, vertex_weights)
seg_mask = torch.argmax(seg_pred, 1)
print("seg_mask", seg_mask, type(seg_mask), seg_mask.shape, seg_mask[0])
visualize_mask(seg_mask)
visualize_mask(mask)
#visualize_vertex(vertex, vertex_weights)
#visualize_hypothesis(image, seg_pred, vertex_pred, corner_target)
visualize_voting_ellipse(image, seg_pred, vertex_pred, corner_target)
eval_net = DataParallel(EvalWrapper().cuda())
corner_pred = eval_net(seg_pred, vertex_pred).cpu().detach().numpy()[0]
print("Corner Predictions: ", corner_pred)
camera_matrix = np.array([[572.4114, 0., 325.2611],
[0., 573.57043, 242.04899], [0., 0., 1.]])
pose_pred = pnp(points_3d, corner_pred, camera_matrix)
projector = Projector()
bb8_2d_pred = projector.project(bb8_3d, pose_pred, 'linemod')
print("Pose prediction :\n", pose_pred)
print("GT pose: \n", pose[0].detach().cpu().numpy())
bb8_2d_gt = projector.project(bb8_3d, pose[0].detach().cpu().numpy(),
'linemod')
print(bb8_2d_gt)
image = imagenet_to_uint8(image.detach().cpu().numpy())[0]
visualize_bounding_box(image[None, ...], bb8_2d_pred[None, None, ...],
bb8_2d_gt[None, None, ...])
def visualize_bounding_box(corners_pred, corners_targets, rgb):
visualize_bounding_box(corners_pred, corners_targets, rgb)
# camera_matrix = np.array([[572.4114, 0., 325.2611],
# [0., 573.57043, 242.04899],
# [0., 0., 1.]])
# pose_pred = pnp(points_3d, corner_pred, camera_matrix)
# projector = Projector()
# bb8_2d_pred = projector.project(bb8_3d, pose_pred, 'linemod')
# bb8_2d_gt = projector.project(bb8_3d, pose[0].detach().cpu().numpy(), 'linemod')
# image = imagenet_to_uint8(image.detach().cpu().numpy())[0]
# visualize_bounding_box(image[None, ...], bb8_2d_pred[None, None, ...], bb8_2d_gt[None, None, ...])
=======
seg_pred, vertex_pred, loss_seg, loss_vertex, precision, recall = net(image, mask, vertex, vertex_weights)
raise TypeError
eval_net = DataParallel(EvalWrapper().cuda())
corner_pred = eval_net(seg_pred, vertex_pred).cpu().detach().numpy()[0]
camera_matrix = np.array([[572.4114, 0., 325.2611],
[0., 573.57043, 242.04899],
[0., 0., 1.]])
pose_pred = pnp(points_3d, corner_pred, camera_matrix)
projector = Projector()
bb8_2d_pred = projector.project(bb8_3d, pose_pred, 'linemod')
bb8_2d_gt = projector.project(bb8_3d, pose[0].detach().cpu().numpy(), 'linemod')
image = imagenet_to_uint8(image.detach().cpu().numpy())[0]
visualize_bounding_box(image[None, ...], bb8_2d_pred[None, None, ...], bb8_2d_gt[None, None, ...])
>>>>>>> 2c722555563b8a77e36b246d82747754cf8dfae7
if __name__ == "__main__":
demo()
def demo():
net = Resnet18_8s(ver_dim=vote_num * 2, seg_dim=2)
net = NetWrapper(net).cuda()
net = DataParallel(net)
optimizer = optim.Adam(net.parameters(), lr=train_cfg['lr'])
model_dir = os.path.join(cfg.MODEL_DIR, 'cat_demo')
load_model(net.module.net, optimizer, model_dir, args.load_epoch)
data, points_3d, bb8_3d = read_data()
image, mask, vertex, vertex_weights, pose, corner_target = [
d.unsqueeze(0).cuda() for d in data
]
# Run the net
seg_pred, vertex_pred, loss_seg, loss_vertex, precision, recall = net(
image, mask, vertex, vertex_weights)
print('vertex_pred.shape')
print(vertex_pred.shape)
print(' ')
print('vertex_pred[0]')
print(vertex_pred)
print(' ')
# Various visualizations
#visualize_vertex_field(vertex_pred,vertex_weights, keypointIdx=3)
print('asdasdsadas')
print(seg_pred.shape, mask.shape)
visualize_mask(np.squeeze(seg_pred.cpu().detach().numpy()),
mask.cpu().detach().numpy())
rgb = Image.open('data/demo/cat.jpg')
img = np.array(rgb)
#visualize_overlap_mask(img, np.squeeze(seg_pred.cpu().detach().numpy()), None)
# Run the ransac voting
eval_net = DataParallel(EvalWrapper2().cuda())
#corner_pred = eval_net(seg_pred, vertex_pred).cpu().detach().numpy()[0]
corner_pred, covar = [
x.cpu().detach().numpy()[0] for x in eval_net(seg_pred, vertex_pred)
]
print('Keypoint predictions:')
print(corner_pred)
print(' ')
print('covar: ', covar)
print(' ')
camera_matrix = np.array([[572.4114, 0., 325.2611],
[0., 573.57043, 242.04899], [0., 0., 1.]])
# Fit pose to points
#pose_pred = pnp(points_3d, corner_pred, camera_matrix)
#evaluator = Evaluator()
#pose_pred = evaluator.evaluate_uncertainty(corner_pred,covar,pose,'cat',intri_matrix=camera_matrix)
def getWeights(covar):
cov_invs = []
for vi in range(covar.shape[0]): # For every keypoint
if covar[vi, 0, 0] < 1e-6 or np.sum(np.isnan(covar)[vi]) > 0:
cov_invs.append(np.zeros([2, 2]).astype(np.float32))
continue
cov_inv = np.linalg.inv(scipy.linalg.sqrtm(covar[vi]))
cov_invs.append(cov_inv)
cov_invs = np.asarray(cov_invs) # pn,2,2
weights = cov_invs.reshape([-1, 4])
weights = weights[:, (0, 1, 3)]
return weights
weights = getWeights(covar)
pose_pred = uncertainty_pnp(corner_pred, weights, points_3d, camera_matrix)
print('Predicted pose: \n', pose_pred)
print('Ground truth pose: \n', pose[0].detach().cpu().numpy())
print(' ')
projector = Projector()
bb8_2d_pred = projector.project(bb8_3d, pose_pred, 'linemod')
bb8_2d_gt = projector.project(bb8_3d, pose[0].detach().cpu().numpy(),
'linemod')
image = imagenet_to_uint8(image.detach().cpu().numpy())[0]
visualize_points(image[None, ...],
corner_target.detach().cpu().numpy(),
pts_pred=corner_pred[None, :, :])
visualize_bounding_box(image[None, ...], bb8_2d_pred[None, None, ...],
bb8_2d_gt[None, None, ...])
def demo(idx):
net = Resnet18_8s(ver_dim=vote_num * 2, seg_dim=2)
net = NetWrapper(net).cuda()
net = DataParallel(net)
optimizer = optim.Adam(net.parameters(), lr=train_cfg['lr'])
model_dir = os.path.join(cfg.MODEL_DIR, "intake_demo")
load_model(net.module.net, optimizer, model_dir, -1)
data, points_3d, bb8_3d = read_data(idx)
#print("BB8_3D: ",bb8_3d)
image, mask, vertex, vertex_weights, pose, corner_target = [
d.unsqueeze(0).cuda() for d in data
]
seg_pred, vertex_pred, loss_seg, loss_vertex, precision, recall = net(
image, mask, vertex, vertex_weights)
seg_mask = torch.argmax(seg_pred, 1)
visualize_mask(seg_mask)
visualize_mask(mask)
#visualize_vertex(vertex, vertex_weights)
#visualize_hypothesis(image, seg_pred, vertex_pred, corner_target)
#visualize_voting_ellipse(image, seg_pred, vertex_pred, corner_target)
#############
eval_net = DataParallel(EvalWrapper().cuda())
uncertain_eval_net = DataParallel(UncertaintyEvalWrapper().cuda())
corner_pred = eval_net(seg_pred, vertex_pred).cpu().detach().numpy()[0]
net.eval()
loss_seg, loss_vertex, precision, recall = [
torch.mean(val) for val in (loss_seg, loss_vertex, precision, recall)
]
print("LOSS SEG :", loss_seg, "\nLOSS VERTEX : ", loss_vertex,
"\nPRECISION :", precision, '\nRECALL :', recall)
###############
#print("Corner Predictions: ",corner_pred)
camera_matrix = np.array([[700, 0., 320.], [0., 700, 240.], [0., 0., 1.]])
pose_pred = pnp(points_3d, corner_pred, camera_matrix)
projector = Projector()
print("Pose prediction :\n", pose_pred)
pose_gt = pose[0].detach().cpu().numpy()
print("GT Pose :\n", pose[0].detach().cpu().numpy())
s = 0
import math as m
for i in range(3):
if pose_pred[2][3] < 0:
print('NB!')
s += (pose_pred[i][3] - pose_gt[i][3])**2
s = m.sqrt(s)
print("--->",
loss_seg.detach().cpu().numpy(),
loss_vertex.detach().cpu().numpy(),
precision.detach().cpu().numpy(),
recall.detach().cpu().numpy(), s)
bb8_2d_pred = projector.project(bb8_3d, pose_pred, 'blender')
bb8_2d_gt = projector.project(bb8_3d, pose[0].detach().cpu().numpy(),
'blender')
#print(bb8_2d_gt)
image = imagenet_to_uint8(image.detach().cpu().numpy())[0]
visualize_bounding_box(image[None, ...], bb8_2d_pred[None, None, ...],
bb8_2d_gt[None, None, ...])
def val(net,
PVNet,
dataloader,
epoch,
lr,
writer,
val_prefix='val',
use_camera_intrinsic=False,
use_motion=False):
for rec in recs:
rec.reset()
test_begin = time.time()
eval_net = DataParallel(EvalWrapper().cuda(
)) # if not use_motion else DataParallel(MotionEvalWrapper().cuda())
# uncertain_eval_net=DataParallel(UncertaintyEvalWrapper().cuda())
net.eval()
if val_prefix == 'val':
if (train_cfg['eval_epoch'] and epoch % train_cfg['eval_inter'] == 0
and epoch >= train_cfg['eval_epoch_begin']) or args.test_model:
iterations = train_cfg["eval_iterations"] + 1
else:
iterations = train_cfg["train_iterations"] + 2
else:
iterations = 2
evaluatorList = []
losses_vertex = np.zeros(int(
(iterations))) # /train_cfg["skips"])+(train_cfg["skips"]-1)))
losses_q = np.zeros(int(
(iterations))) # /train_cfg["skips"])+(train_cfg["skips"]-1)))
norm_q = np.zeros(int(
(iterations))) # /train_cfg["skips"])+(train_cfg["skips"]-1)))
norm_v = np.zeros(int(
(iterations))) # /train_cfg["skips"])+(train_cfg["skips"]-1)))
deltas = np.zeros(int(
(iterations))) # /train_cfg["skips"])+(train_cfg["skips"]-1)))
for i in range(iterations):
# if (i % train_cfg["skips"]==0) or (i==0):
evaluatorList.append(Evaluator())
data_counter = 0
PVNet.eval()
for idx, data in tqdm(enumerate(dataloader)):
if use_camera_intrinsic:
image, mask, vertex, vertex_weights, pose, corner_target, Ks = [
d for d in data
]
else:
image, mask, vertex, vertex_weights, pose, corner_target = [
d for d in data
]
# image = image
# mask = mask
# vertex = vertex
# vertex_weights = vertex_weights
# pose = pose
im = image.half()
with torch.no_grad():
pose = pose.cpu().numpy()
delta = train_cfg["delta"]
id = 0
for t in range(iterations):
if t == 0:
seg_pred, vertex_init = PVNet(im)
mask_init = torch.argmax(seg_pred, 1)
vertex_init = vertex_init.cpu().float()
else:
vertex_init_pert = vertex_init
_, _, q_pred, loss, precision, recall = net(
image, mask, vertex, vertex_weights,
vertex_init_pert.detach(), vertex_init.detach())
loss, precision, recall = [
torch.mean(val) for val in (loss, precision, recall)
]
# losses_seg[t] = losses_seg[t] + loss_seg
# losses_vertex[id] = losses_vertex[id] + loss_vertex
# losses_q[id] = losses_q[id] + loss_q
# q_gt = vertex_init - vertex
norm_q[id] = norm_q[id] + ((1/torch.sum(vertex_weights).cpu().numpy()) * \
(np.linalg.norm((vertex_weights.cpu().numpy() * (q_pred.cpu().numpy() - (vertex_init.cpu().numpy() - vertex.cpu().numpy())))**2)))
if t > 0:
# 0.01 * (0.99)**t
# mask_init = mask
# delta = compute_step_size(delta, vertex.detach(), vertex_init.detach(), vertex_weights.detach(), -q_pred.detach(), train_cfg,t)
deltas[id] = deltas[id] + delta
vertex_init = vertex_init - (delta * q_pred.cpu())
# vertex_init = normalise_vector_field(vertex_init,vertex_init0)
# if data_counter==1000:
# plot_mask_vfield(image, rgb_pth, mask_init, mask_pth, vertex_init, t)
norm_v[id] = norm_v[id] + ((1/torch.sum(vertex_weights).cpu().numpy()) * \
(np.linalg.norm((vertex_weights.cpu().numpy() * (vertex_init.cpu().numpy()- vertex.cpu().numpy())))**2))
# if args.use_uncertainty_pnp:
# mean,cov_inv=uncertain_eval_net(mask_init,vertex_init)
# mean=mean.cpu().numpy()
# cov_inv=cov_inv.cpu().numpy()
# else:
# corner_pred=eval_net(mask_init,vertex_init).cpu().detach().numpy()
# b=pose.shape[0]
# pose_preds=[]
# for bi in range(b):
# intri_type='use_intrinsic' if use_camera_intrinsic else 'linemod'
# K=Ks[bi].cpu().numpy() if use_camera_intrinsic else None
# if args.use_uncertainty_pnp:
# pose_preds.append(evaluatorList[id].evaluate_uncertainty(mean[bi],cov_inv[bi],pose[bi],args.linemod_cls,
# intri_type,vote_type,intri_matrix=K))
# else:
# pose_preds.append(evaluatorList[id].evaluate(corner_pred[bi],pose[bi],args.linemod_cls,intri_type,
# vote_type,intri_matrix=K))
# if args.save_inter_result:
# mask_pr = torch.argmax(seg_pred, 1).cpu().detach().numpy()
# mask_gt = mask.cpu().detach().numpy()
# # assume b3th.join(args.save_inter_dir, '{}_mask_gt.png'.format(idx)), mask_gt[0])
# imsave(os.path.join(args.save_inter_dir, '{}_rgb.png'.format(idx)),
# imagenet_to_uint8(image.cpu().detach().numpy()[0]))
# save_pickle([pose_preds[0],pose[0]],os.path.join(args.save_inter_dir, '{}_pose.pkl'.format(idx)))
if t > 0:
vals = [loss, precision, recall]
for rec, val in zip(recs, vals):
rec.update(val)
if t == 0:
corners_init = corner_pred[np.newaxis, ...]
if t == iterations - 1:
corners_end = corner_pred[np.newaxis, ...]
visualize_bounding_box(image,
corners_init,
t,
corners_targets=corners_end)
id += 1
data_counter += 1
proj_err_list = []
add_list = []
p_increase_add = 0
p_decrease_v = 0
p_decrease_q = 0
first_a = []
first_v = []
largest_a = 0
smallest_v = 0
smallest_q = 0
# if val_prefix == 'val':
id = 0
for i in range(iterations):
# if (i % train_cfg["skips"]==0) or (i==0):
# proj_err,add,cm=evaluatorList[id].average_precision(False)
# losses_q[id] = losses_q[id] / len(dataloader)
norm_q[id] = norm_q[id] / len(dataloader)
norm_v[id] = norm_v[id] / len(dataloader)
if i == 0:
# first_a = add
# largest_a = add
first_v = norm_v[id]
smallest_v = norm_v[id]
if i == 1:
first_q = norm_q[id]
smallest_q = norm_q[id]
# proj_err_list.append(proj_err)
# add_list.append(add)
# losses_vertex[id] = losses_vertex[id] / len(dataloader)
deltas[id] = deltas[id] / len(dataloader)
if i > 0:
deltas[id] = deltas[id] + deltas[id - 1]
if norm_v[id] < smallest_v:
smallest_v = norm_v[id]
if i > 1:
smallest_q = norm_q[id]
# if add > largest_a:
# largest_a = add
id += 1
# if (largest_a == first_a):
# largest_a = max(add_list.remove(largest_a))
# print("after loop")
# print("smallest_v after: ", smallest_v)
# print("first_v after: ",first_v)
# print("largest_a after: ", largest_a)
# print("add list: ",add_list)
print('X-X^: ', norm_v)
# print('smallest_q after', smallest_q)
# print('first_q after', first_q)
# p_increase_add = ((largest_a - first_a)/first_a)*100
p_decrease_v = ((first_v - smallest_v) / first_v) * 100
p_decrease_q = ((first_q - smallest_q) / first_q) * 100
print(train_cfg['exp_name'])
# print('add percentage increase ', p_increase_add)
print('X-X^ percentage decrease: ', p_decrease_v)
print('q-q^ percentage decrease: ', p_decrease_q)
# distance = np.array(list(range(len(add_list)))) * (train_cfg["delta"]*train_cfg["skips"])
# # distance = deltas
# print(add_list)
# print(norm_v)
# print(norm_q)
# # distance = np.array(list(range(iterations)))
# # print((np.array(list(range(len(add_list)))) * train_cfg["delta"]).shape)
# # print(deltas.shape)
# fig = plt.figure(figsize=[24,12])
# ax1 = plt.subplot(241)
# ax1.plot(distance,add_list)
# ax1.axvline(x=(train_cfg["train_iterations"]) * train_cfg["sigma"],color='gray',linestyle='--')
# ax1.set_title('ADD')
# ax1.set_xlabel(r"$\rho_E$")
# ax1.grid()
# ax2 = plt.subplot(242)
# ax2.plot(distance,proj_err_list)
# ax2.set_title('2D proj')
# ax2.axvline(x=(train_cfg["train_iterations"]) * train_cfg["sigma"],color='gray',linestyle='--')
# ax2.set_xlabel(r"$\rho_E$")
# ax2.grid()
# ax3 = plt.subplot(243)
# ax3.plot(distance[1:],norm_q[1:]/norm_q[1])
# ax3.set_title(r'$||q - \hat{q}||$')
# ax3.axvline(x=(train_cfg["train_iterations"]) * train_cfg["sigma"],color='gray',linestyle='--')
# ax3.set_xlabel(r"$\rho_E$")
# ax3.grid()
# ax4 = plt.subplot(244)
# ax4.plot(distance[1:],norm_v[1:]/norm_v[1])
# ax4.set_title(r'$||x-\hat{x}||$')
# ax4.axvline(x=(train_cfg["train_iterations"]) * train_cfg["sigma"],color='gray',linestyle='--')
# ax4.set_xlabel(r"$\rho_E$")
# ax4.grid()
# ax5 = plt.subplot(246)
# ax5.plot(distance[1:],losses_vertex[1:]/losses_vertex[1])
# ax5.set_title(r'$\mathcal{L}_X$')
# ax5.axvline(x=(train_cfg["train_iterations"]) * train_cfg["sigma"],color='gray',linestyle='--')
# ax5.set_xlabel(r"$\rho_E$")
# ax5.grid()
# ax6 = plt.subplot(247)
# ax6.plot(distance[1:],losses_q[1:]/losses_q[1])
# ax6.set_title(r'$\mathcal{L}_q$')
# ax6.axvline(x=(train_cfg["train_iterations"]) * train_cfg["sigma"],color='gray',linestyle='--')
# ax6.set_xlabel(r"$\rho_E$")
# ax6.grid()
# fig.suptitle(r"""Date: {}, Epoch: {}
# $T_T$ = {}, $\sigma$ = {}: $\rho_T$ = {}.
# $T_E$ = {}, $\delta$ = {}: $\rho_E$ = {}.""".format( \
# date.today(),epoch,(train_cfg["train_iterations"]),train_cfg["sigma"],(train_cfg["train_iterations"])*train_cfg["sigma"],\
# (train_cfg["eval_iterations"]),train_cfg["delta"],(train_cfg["eval_iterations"])*train_cfg["delta"]))
# plt.savefig('{}/{}_{}_{}.png'.format(train_cfg["exp_name"],date.today(),epoch,train_cfg["delta"]))
with torch.no_grad():
batch_size = image.shape[0]
nrow = 5 if batch_size > 5 else batch_size
recorder.rec_segmentation(F.softmax(seg_pred, dim=1),
num_classes=2,
nrow=nrow,
step=epoch,
name='{}/image/seg'.format(val_prefix))
recorder.rec_vertex(vertex_init,
vertex_weights,
nrow=4,
step=epoch,
name='{}/image/ver'.format(val_prefix))
losses_batch = OrderedDict()
for name, rec in zip(recs_names, recs):
losses_batch['{}/'.format(val_prefix) + name] = rec.avg
if (train_cfg['eval_epoch'] and epoch % train_cfg['eval_inter'] == 0
and epoch >= train_cfg['eval_epoch_begin']
and val_prefix == 'val'): # or args.test_model:
print(val_prefix)
# proj_err,add,cm=evaluatorList[-1].average_precision(False)
# losses_batch['{}/scalar/projection_error'.format(val_prefix)]=proj_err
# losses_batch['{}/scalar/add'.format(val_prefix)]=add
# losses_batch['{}/scalar/cm'.format(val_prefix)]=cm
recorder.rec_loss_batch(losses_batch, epoch, epoch, val_prefix)
# writer.add_scalar('projection error', proj_err, epoch)
# writer.add_scalar('add',add,epoch)
# writer.add_scalar('vertex loss',loss_vertex, epoch)
# writer.add_scalar('q loss',loss_q, epoch)
# writer.add_scalar('seg loss', loss_seg, epoch)
writer.add_scalar('learning rate', lr, epoch)
for rec in recs:
rec.reset()
print('epoch {} {} cost {} s'.format(epoch, val_prefix,
time.time() - test_begin))
return add_list, first_a, first_v, largest_a, smallest_v, smallest_q, p_increase_add, p_decrease_v, p_decrease_q
