def predict_original_samples(self, batch, conv_type, output):
""" Takes the output generated by the NN and upsamples it to the original data
Arguments:
batch -- processed batch
conv_type -- Type of convolutio (DENSE, PARTIAL_DENSE, etc...)
output -- output predicted by the model
"""
full_res_results = {}
num_sample = BaseDataset.get_num_samples(batch, conv_type)
if conv_type == "DENSE":
output = output.reshape(num_sample, -1,
output.shape[-1]) # [B,N,L]
setattr(batch, "_pred", output)
for b in range(num_sample):
sampleid = batch.sampleid[b]
sample_raw_pos = self.test_dataset[0].get_raw(sampleid).pos.to(
output.device)
predicted = BaseDataset.get_sample(batch, "_pred", b, conv_type)
origindid = BaseDataset.get_sample(batch, SaveOriginalPosId.KEY, b,
conv_type)
full_prediction = knn_interpolate(predicted,
sample_raw_pos[origindid],
sample_raw_pos,
k=3)
labels = full_prediction.max(1)[1].unsqueeze(-1)
full_res_results[self.test_dataset[0].get_filename(
sampleid)] = np.hstack((
sample_raw_pos.cpu().numpy(),
labels.cpu().numpy(),
))
return full_res_results
def run(cfg, model: BaseModel, dataset: BaseDataset, device,
measurement_name: str):
measurements = {}
num_batches = getattr(cfg.debugging, "num_batches", np.inf)
run_epoch(model, dataset.train_dataloader(), device, num_batches)
measurements["train"] = extract_histogram(model.get_spatial_ops(),
normalize=False)
if dataset.has_val_loader:
run_epoch(model, dataset.val_dataloader(), device, num_batches)
measurements["val"] = extract_histogram(model.get_spatial_ops(),
normalize=False)
for loader_idx, loader in enumerate(dataset.test_dataloaders()):
run_epoch(model, dataset.test_dataloaders(), device, num_batches)
measurements[dataset.get_test_dataset_name(
loader_idx)] = extract_histogram(model.get_spatial_ops(),
normalize=False)
with open(
os.path.join(DIR,
"measurements/{}.pickle".format(measurement_name)),
"wb") as f:
pickle.dump(measurements, f)
def __init__(self, checkpoint_dir, model_name, weight_name, feat_name, num_classes=None, mock_dataset=True):
# Checkpoint
from src.datasets.base_dataset import BaseDataset
from src.datasets.dataset_factory import instantiate_dataset
checkpoint = model_checkpoint.ModelCheckpoint(checkpoint_dir, model_name, weight_name, strict=True)
if mock_dataset:
dataset = MockDataset(num_classes)
dataset.num_classes = num_classes
else:
dataset = instantiate_dataset(checkpoint.data_config)
BaseDataset.set_transform(self, checkpoint.data_config)
self.model = checkpoint.create_model(dataset, weight_name=weight_name)
self.model.eval()
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)
def __init__(self, checkpoint_dir, model_name, weight_name, feat_name, num_classes, mock_dataset=True):
super(PointNetForward, self).__init__(
checkpoint_dir, model_name, weight_name, feat_name, num_classes=num_classes, mock_dataset=mock_dataset
)
self.feat_name = feat_name
from src.datasets.base_dataset import BaseDataset
from torch_geometric.transforms import FixedPoints
self.inference_transform = BaseDataset.remove_transform(self.inference_transform, [GridSampling, FixedPoints])
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 test_multiple_test_datasets(self):
opt = Options()
opt.dataset_name = os.path.join(os.getcwd(), "test")
opt.dataroot = os.path.join(os.getcwd(), "test")
class MultiTestDataset(BaseDataset):
def __init__(self, dataset_opt):
super(MultiTestDataset, self).__init__(dataset_opt)
self.train_dataset = CustomMockDataset(10, 1, 3, 10)
self.val_dataset = CustomMockDataset(10, 1, 3, 10)
self.test_dataset = [CustomMockDataset(10, 1, 3, 10), CustomMockDataset(10, 1, 3, 20)]
dataset = MultiTestDataset(opt)
model_config = MockModelConfig()
model_config.conv_type = "dense"
model = MockModel(model_config)
dataset.create_dataloaders(model, 5, True, 0, False)
loaders = dataset.test_dataloaders
self.assertEqual(len(loaders), 2)
self.assertEqual(len(loaders[0].dataset), 10)
self.assertEqual(len(loaders[1].dataset), 20)
self.assertEqual(dataset.num_classes, 3)
self.assertEqual(dataset.is_hierarchical, False)
self.assertEqual(dataset.has_fixed_points_transform, False)
self.assertEqual(dataset.has_val_loader, True)
self.assertEqual(dataset.class_to_segments, None)
self.assertEqual(dataset.feature_dimension, 1)
batch = next(iter(loaders[0]))
num_samples = BaseDataset.get_num_samples(batch, "dense")
self.assertEqual(num_samples, 5)
sample = BaseDataset.get_sample(batch, "pos", 1, "dense")
self.assertEqual(sample.shape, (10, 3))
sample = BaseDataset.get_sample(batch, "x", 1, "dense")
self.assertEqual(sample.shape, (10, 1))
self.assertEqual(dataset.num_batches, {"train": 2, "val": 2, "test_0": 2, "test_1": 4})
repr = "Dataset: MultiTestDataset \n\x1b[0;95mpre_transform \x1b[0m= None\n\x1b[0;95mtest_transform \x1b[0m= None\n\x1b[0;95mtrain_transform \x1b[0m= None\n\x1b[0;95mval_transform \x1b[0m= None\n\x1b[0;95minference_transform \x1b[0m= None\nSize of \x1b[0;95mtrain_dataset \x1b[0m= 10\nSize of \x1b[0;95mtest_dataset \x1b[0m= 10, 20\nSize of \x1b[0;95mval_dataset \x1b[0m= 10\n\x1b[0;95mBatch size =\x1b[0m 5"
self.assertEqual(dataset.__repr__(), repr)
def test_empty_dataset(self):
opt = Options()
opt.dataset_name = os.path.join(os.getcwd(), "test")
opt.dataroot = os.path.join(os.getcwd(), "test")
dataset = BaseDataset(opt)
self.assertEqual(dataset.pre_transform, None)
self.assertEqual(dataset.test_transform, None)
self.assertEqual(dataset.train_transform, None)
self.assertEqual(dataset.val_transform, None)
self.assertEqual(dataset.train_dataset, None)
self.assertEqual(dataset.test_dataset, None)
self.assertEqual(dataset.val_dataset, None)
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)