def track(self, model: model_interface.TrackerInterface, **kwargs):
super().track(model)
if self._stage != "train":
batch_idx, batch_idx_target = model.get_batch()
batch_xyz, batch_xyz_target = model.get_xyz() # type: ignore
batch_ind, batch_ind_target, batch_size_ind = model.get_ind(
) # type: ignore
batch_feat, batch_feat_target = model.get_output()
nb_batches = batch_idx.max() + 1
cum_sum = 0
cum_sum_target = 0
begin = 0
end = batch_size_ind[0].item()
for b in range(nb_batches):
xyz = batch_xyz[batch_idx == b]
xyz_target = batch_xyz_target[batch_idx_target == b]
feat = batch_feat[batch_idx == b]
feat_target = batch_feat_target[batch_idx_target == b]
# as we have concatenated ind,
# we need to substract the cum_sum because we deal
# with each batch independently
# ind = batch_ind[b * len(batch_ind) / nb_batches : (b + 1) * len(batch_ind) / nb_batches] - cum_sum
# ind_target = (batch_ind_target[b * len(batch_ind_target) / nb_batches : (b + 1) * len(batch_ind_target) / nb_batches]- cum_sum_target)
ind = batch_ind[begin:end] - cum_sum
ind_target = batch_ind_target[begin:end] - cum_sum_target
# print(begin, end)
if b < nb_batches - 1:
begin = end
end = begin + batch_size_ind[b + 1].item()
cum_sum += len(xyz)
cum_sum_target += len(xyz_target)
rand = torch.randperm(len(feat))[:self.num_points]
rand_target = torch.randperm(
len(feat_target))[:self.num_points]
matches_gt = torch.stack([ind, ind_target]).transpose(0, 1)
# print(matches_gt.max(0), len(xyz), len(xyz_target), len(matches_gt))
# print(batch_ind.shape, nb_batches)
T_gt = estimate_transfo(xyz[matches_gt[:, 0]],
xyz_target[matches_gt[:, 1]])
matches_pred = get_matches(feat[rand],
feat_target[rand_target])
T_pred = fast_global_registration(
xyz[rand][matches_pred[:, 0]],
xyz_target[rand_target][matches_pred[:, 1]])
hit_ratio = compute_hit_ratio(
xyz[rand][matches_pred[:, 0]],
xyz_target[rand_target][matches_pred[:,
1]], T_gt, self.tau_1)
trans_error, rot_error = compute_transfo_error(T_pred, T_gt)
self._hit_ratio.add(hit_ratio.item())
self._feat_match_ratio.add(
float(hit_ratio.item() > self.tau_2))
self._trans_error.add(trans_error.item())
self._rot_error.add(rot_error.item())
def track(self, model: model_interface.TrackerInterface, **kwargs):
""" Add current model predictions (usually the result of a batch) to the tracking
"""
super().track(model)
outputs = self._convert(model.get_output())
targets = self._convert(model.get_labels())
batch_idx = self._convert(model.get_batch())
if batch_idx is None:
raise ValueError(
"Your model need to set the batch_idx variable in its set_input function."
)
nb_batches = batch_idx.max() + 1
# pred to the groundtruth classes (selected by seg_classes[cat])
for b in range(nb_batches):
segl = targets[batch_idx == b]
cat = self._seg_to_class[segl[0]]
logits = outputs[batch_idx == b, :] # (num_points, num_classes)
segp = logits[:, self._class_seg_map[cat]].argmax(
1) + self._class_seg_map[cat][0]
part_ious = np.zeros(len(self._class_seg_map[cat]))
for l in self._class_seg_map[cat]:
if np.sum((segl == l) | (segp == l)) == 0:
# part is not present in this shape
part_ious[l - self._class_seg_map[cat][0]] = 1
else:
part_ious[l - self._class_seg_map[cat][0]] = float(
np.sum((segl == l) & (segp == l))) / float(
np.sum((segl == l) | (segp == l)))
self._shape_ious[cat].append(np.mean(part_ious))
self._miou_per_class, self._Cmiou, self._Imiou = self._get_metrics_per_class(
)
def track(self,
model: model_interface.TrackerInterface,
full_res: bool = False,
data: Data = None,
**kwargs):
""" Add current model predictions (usually the result of a batch) to the tracking
"""
super().track(model)
self._conv_type = model.conv_type
outputs = self._convert(model.get_output())
targets = self._convert(model.get_labels())
batch_idx = self._convert(model.get_batch())
if batch_idx is None:
raise ValueError(
"Your model need to set the batch_idx variable in its set_input function."
)
nb_batches = batch_idx.max() + 1
if self._stage != "train" and full_res:
self._add_votes(data, outputs, batch_idx)
# pred to the groundtruth classes (selected by seg_classes[cat])
for b in range(nb_batches):
segl = targets[batch_idx == b]
cat = self._seg_to_class[segl[0]]
logits = outputs[batch_idx == b, :] # (num_points, num_classes)
segp = logits[:, self._class_seg_map[cat]].argmax(
1) + self._class_seg_map[cat][0]
part_ious = self._compute_part_ious(segl, segp, cat)
self._shape_ious[cat].append(np.mean(part_ious))
self._miou_per_class, self._Cmiou, self._Imiou = ShapenetPartTracker._get_metrics_per_class(
self._shape_ious)
