def run(model: BaseModel, dataset: BaseDataset, device, output_path, cfg):
# Set dataloaders
num_fragment = dataset.num_fragment
if cfg.data.is_patch:
for i in range(num_fragment):
dataset.set_patches(i)
dataset.create_dataloaders(
model,
cfg.batch_size,
False,
cfg.num_workers,
False,
)
loader = dataset.test_dataloaders()[0]
features = []
scene_name, pc_name = dataset.get_name(i)
with Ctq(loader) as tq_test_loader:
for data in tq_test_loader:
# pcd = open3d.geometry.PointCloud()
# pcd.points = open3d.utility.Vector3dVector(data.pos[0].numpy())
# open3d.visualization.draw_geometries([pcd])
with torch.no_grad():
model.set_input(data, device)
model.forward()
features.append(model.get_output().cpu())
features = torch.cat(features, 0).numpy()
log.info("save {} from {} in {}".format(pc_name, scene_name,
output_path))
save(output_path, scene_name, pc_name,
dataset.base_dataset[i].to("cpu"), features)
else:
dataset.create_dataloaders(
model,
1,
False,
cfg.num_workers,
False,
)
loader = dataset.test_dataloaders()[0]
with Ctq(loader) as tq_test_loader:
for i, data in enumerate(tq_test_loader):
with torch.no_grad():
model.set_input(data, device)
model.forward()
features = model.get_output()[0] # batch of 1
save(output_path, scene_name, pc_name, data.to("cpu"),
features)
def track(self, model: BaseModel):
""" Add model predictions (accuracy)
"""
super().track(model)
outputs = self._convert(model.get_output())
self._acc = compute_accuracy(outputs[::2], outputs[1::2])
def track(self, model: BaseModel):
""" Add model predictions (accuracy)
"""
super().track(model)
outputs = self._convert(model.get_output())
N = len(outputs) // 2
self._acc = compute_accuracy(outputs[:N], outputs[N:])
def track(self, model: BaseModel):
""" 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())
erp = torch.sqrt(((outputs - targets) / (targets + self._eps)) ** 2)
self._merp = torch.mean(erp).item()
self._mer = (
torch.mean(F.normalize(outputs - targets, p=2, dim=-1))
/ torch.mean((F.normalize(targets, p=2, dim=-1) + self._eps))
).item()
def track(self, model: BaseModel):
""" 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())
assert outputs.shape[0] == len(targets)
self._confusion_matrix.count_predicted_batch(targets,
np.argmax(outputs, 1))
self._acc = 100 * self._confusion_matrix.get_overall_accuracy()
self._macc = 100 * self._confusion_matrix.get_mean_class_accuracy()
self._miou = 100 * self._confusion_matrix.get_average_intersection_union(
)
def run(model: BaseModel, dataset: BaseDataset, device, output_path):
loaders = dataset.test_dataloaders
predicted = {}
for loader in loaders:
loader.dataset.name
with Ctq(loader) as tq_test_loader:
for data in tq_test_loader:
with torch.no_grad():
model.set_input(data, device)
model.forward()
predicted = {
**predicted,
**dataset.predict_original_samples(data, model.conv_type,
model.get_output())
}
save(output_path, predicted)
def run(model: BaseModel, dataset: BaseDataset, device, output_path):
loaders = dataset.test_dataloaders()
predicted = {}
for idx, loader in enumerate(loaders):
dataset.get_test_dataset_name(idx)
with Ctq(loader) as tq_test_loader:
for data in tq_test_loader:
data = data.to(device)
with torch.no_grad():
model.set_input(data)
model.forward()
predicted = {
**predicted,
**dataset.predict_original_samples(data, model.conv_type,
model.get_output())
}
save(output_path, predicted)
