def test_minkowski(self):
from torch_points3d.applications.minkowski import Minkowski
input_nc = 3
num_layers = 4
in_feat = 16
model = Minkowski(
architecture="encoder",
input_nc=input_nc,
in_feat=in_feat,
num_layers=num_layers,
config=None,
)
dataset = MockDatasetGeometric(input_nc,
transform=GridSampling3D(
0.01, quantize_coords=True),
num_points=128)
self.assertEqual(len(model._modules["down_modules"]), num_layers)
self.assertEqual(len(model._modules["inner_modules"]), 1)
self.assertFalse(model.has_mlp_head)
self.assertEqual(model.output_nc, 8 * in_feat)
try:
data_out = model.forward(dataset[0])
# self.assertEqual(data_out.x.shape[1], 8 * in_feat)
except Exception as e:
print("Model failing:")
print(model)
raise e
input_nc = 3
num_layers = 4
grid_sampling = 0.02
in_feat = 32
output_nc = 5
model = Minkowski(
architecture="encoder",
input_nc=input_nc,
output_nc=output_nc,
in_feat=in_feat,
in_grid_size=grid_sampling,
num_layers=num_layers,
config=None,
)
dataset = MockDatasetGeometric(input_nc,
transform=GridSampling3D(
0.01, quantize_coords=True),
num_points=128)
self.assertEqual(len(model._modules["down_modules"]), num_layers)
self.assertEqual(len(model._modules["inner_modules"]), 1)
self.assertTrue(model.has_mlp_head)
self.assertEqual(model.output_nc, output_nc)
try:
data_out = model.forward(dataset[0])
self.assertEqual(data_out.x.shape[1], output_nc)
except Exception as e:
print("Model failing:")
print(model)
raise e
def get_dataset(conv_type, task):
features = 2
if task == "registration":
if conv_type.lower() == "dense":
return PairMockDataset(features, num_points=2048)
if conv_type.lower() == "sparse":
tr = Compose([
XYZFeature(True, True, True),
GridSampling(size=0.01,
quantize_coords=True,
mode="last")
])
return PairMockDatasetGeometric(features,
transform=tr,
num_points=1024)
return PairMockDatasetGeometric(features)
else:
if conv_type.lower() == "dense":
return MockDataset(features, num_points=2048)
if conv_type.lower() == "sparse":
return MockDatasetGeometric(features,
transform=GridSampling(
size=0.01,
quantize_coords=True,
mode="last"),
num_points=1024)
return MockDatasetGeometric(features)
def get_dataset(conv_type, task):
num_points = 1024
features = 2
batch_size = 2
if task == "object_detection":
include_box = True
else:
include_box = False
if conv_type.lower() == "dense":
num_points = 2048
batch_size = 1
if task == "registration":
if conv_type.lower() == "dense":
return PairMockDataset(features, num_points=num_points, batch_size=batch_size)
if conv_type.lower() == "sparse":
tr = Compose([XYZFeature(True, True, True), GridSampling3D(size=0.01, quantize_coords=True, mode="last")])
return PairMockDatasetGeometric(features, transform=tr, num_points=num_points, batch_size=batch_size)
return PairMockDatasetGeometric(features, batch_size=batch_size)
else:
if conv_type.lower() == "dense":
num_points = 2048
return MockDataset(features, num_points=num_points, include_box=include_box, batch_size=batch_size)
if conv_type.lower() == "sparse":
return MockDatasetGeometric(
features,
include_box=include_box,
transform=GridSampling3D(size=0.01, quantize_coords=True, mode="last"),
num_points=num_points,
batch_size=batch_size,
)
return MockDatasetGeometric(features, batch_size=batch_size)
def test_kpconv(self):
from torch_points3d.applications.kpconv import KPConv
input_nc = 3
num_layers = 4
grid_sampling = 0.02
in_feat = 32
model = KPConv(
architecture="unet",
input_nc=input_nc,
in_feat=in_feat,
in_grid_size=grid_sampling,
num_layers=num_layers,
config=None,
)
dataset = MockDatasetGeometric(input_nc + 1, transform=GridSampling3D(0.01), num_points=128)
self.assertEqual(len(model._modules["down_modules"]), num_layers + 1)
self.assertEqual(len(model._modules["inner_modules"]), 1)
self.assertEqual(len(model._modules["up_modules"]), 4)
self.assertFalse(model.has_mlp_head)
self.assertEqual(model.output_nc, in_feat)
try:
data_out = model.forward(dataset[0])
self.assertEqual(data_out.x.shape[1], in_feat)
except Exception as e:
print("Model failing:")
print(model)
raise e
input_nc = 3
num_layers = 4
grid_sampling = 0.02
in_feat = 32
output_nc = 5
model = KPConv(
architecture="unet",
input_nc=input_nc,
output_nc=output_nc,
in_feat=in_feat,
in_grid_size=grid_sampling,
num_layers=num_layers,
config=None,
)
dataset = MockDatasetGeometric(input_nc + 1, transform=GridSampling3D(0.01), num_points=128)
self.assertEqual(len(model._modules["down_modules"]), num_layers + 1)
self.assertEqual(len(model._modules["inner_modules"]), 1)
self.assertEqual(len(model._modules["up_modules"]), 4)
self.assertTrue(model.has_mlp_head)
self.assertEqual(model.output_nc, output_nc)
try:
data_out = model.forward(dataset[0])
self.assertEqual(data_out.x.shape[1], output_nc)
except Exception as e:
print("Model failing:")
print(model)
raise e
def get_dataset(conv_type):
features = 2
if conv_type.lower() == "dense":
return MockDataset(features, num_points=2048)
if conv_type.lower() == "sparse":
return MockDatasetGeometric(features,
transform=ToSparseInput(0.01),
num_points=1024)
return MockDatasetGeometric(features)
def test_kpconvpretransform(self):
params = load_model_config("segmentation", "kpconv", "SimpleKPConv")
dataset = MockDatasetGeometric(5)
model = instantiate_model(params, dataset)
model.eval()
dataset_transform = MockDatasetGeometric(5)
dataset_transform.set_strategies(model)
model.set_input(dataset[0])
model.forward()
model.get_output()
torch.testing.assert_allclose(dataset_transform[0].pos, dataset[0].pos)
def test_kpconvpretransform(self):
params = load_model_config("segmentation", "kpconv")["PDSimpleKPConv"]
model_config = OmegaConf.merge(params, self.data_config)
dataset = MockDatasetGeometric(5)
model_class = getattr(params, "class")
model = _find_model_using_name(model_class, "segmentation",
model_config, dataset)
model.eval()
dataset_transform = MockDatasetGeometric(5)
dataset_transform.set_strategies(model)
model.set_input(dataset[0])
model.forward()
model.get_output()
torch.testing.assert_allclose(dataset_transform[0].pos, dataset[0].pos)
def test_kpconv(self):
params = load_model_config("segmentation", "kpconv", "SimpleKPConv")
dataset = MockDatasetGeometric(5)
model = instantiate_model(params, dataset)
model.set_input(dataset[0])
model.forward()
model.backward()
def test_accumulated_gradient(self):
params = load_model_config("segmentation", "pointnet2", "pointnet2ms")
config_training = OmegaConf.load(
os.path.join(DIR, "test_config/training_config.yaml"))
dataset = MockDatasetGeometric(5)
model = instantiate_model(params, dataset)
model.instantiate_optimizers(config_training)
model.set_input(dataset[0], "cpu")
expected_make_optimizer_step = [
False, False, True, False, False, True, False, False, True, False
]
expected_contains_grads = [
False, True, True, False, True, True, False, True, True, False
]
make_optimizer_steps = []
contains_grads = []
for epoch in range(10):
model.forward()
make_optimizer_step = model._manage_optimizer_zero_grad(
) # Accumulate gradient if option is up
make_optimizer_steps.append(make_optimizer_step)
grad_ = model._modules["lin1"].weight.grad
if grad_ is not None:
contains_grads.append((grad_.sum() != 0).item())
else:
contains_grads.append(False)
model.backward() # calculate gradients
if make_optimizer_step:
model._optimizer.step() # update parameters
self.assertEqual(contains_grads, expected_contains_grads)
self.assertEqual(make_optimizer_steps, expected_make_optimizer_step)
def test_kpconv(self):
from torch_points3d.applications.kpconv import KPConv
input_nc = 3
num_layers = 4
grid_sampling = 0.02
model = KPConv(
architecture="unet",
input_nc=input_nc,
output_nc=5,
in_feat=32,
in_grid_size=grid_sampling,
num_layers=num_layers,
config=None,
)
dataset = MockDatasetGeometric(input_nc + 1, transform=GridSampling(0.01), num_points=128)
self.assertEqual(len(model._modules["down_modules"]), num_layers + 1)
self.assertEqual(len(model._modules["inner_modules"]), 1)
self.assertEqual(len(model._modules["up_modules"]), 4)
try:
model.forward(dataset[0])
except Exception as e:
print("Model failing:")
print(model)
raise e
def test_model_ckpt_using_pointnet2ms(self,):
# Create a checkpt
name = "model"
self.run_path = os.path.join(DIR, "checkpt")
print(self.run_path)
if not os.path.exists(self.run_path):
os.makedirs(self.run_path)
model_checkpoint = ModelCheckpoint(self.run_path, name, "test", run_config=self.config, resume=False)
dataset = MockDatasetGeometric(5)
model = instantiate_model(self.config, dataset)
model.set_input(dataset[0], "cpu")
model.instantiate_optimizers(self.config)
mock_metrics = {"current_metrics": {"acc": 12}, "stage": "test", "epoch": 10}
model_checkpoint.save_best_models_under_current_metrics(model, mock_metrics)
# Load checkpoint and initialize model
model_checkpoint = ModelCheckpoint(self.run_path, name, "test", self.config, resume=True)
model2 = model_checkpoint.create_model(dataset, weight_name="acc")
self.assertEqual(str(model.optimizer.__class__.__name__), str(model2.optimizer.__class__.__name__))
self.assertEqual(model.optimizer.defaults, model2.optimizer.defaults)
self.assertEqual(model.schedulers["lr_scheduler"].state_dict(), model2.schedulers["lr_scheduler"].state_dict())
self.assertEqual(model.schedulers["bn_scheduler"].state_dict(), model2.schedulers["bn_scheduler"].state_dict())
shutil.rmtree(self.run_path)
remove(os.path.join(ROOT, "{}.pt".format(name)))
remove(os.path.join(DIR, "{}.pt".format(name)))
def test_pointnet2ms(self):
model_type = "pointnet2"
params = self.config["models"]["pointnet2ms"]
dataset = MockDatasetGeometric(5)
model = _find_model_using_name(model_type, "segmentation", params, dataset)
model.set_input(dataset[0])
model.forward()
def test_kpconv(self):
model_type = "KPConv"
params = self.config["models"]["SimpleKPConv"]
dataset = MockDatasetGeometric(5)
model = _find_model_using_name(model_type, "segmentation", params, dataset)
model.set_input(dataset[0])
model.forward()
def test_pointnet2ms(self):
params = load_model_config("segmentation", "pointnet2", "pointnet2ms")
dataset = MockDatasetGeometric(5)
model = instantiate_model(params, dataset)
model.set_input(dataset[0])
model.forward()
model.backward()
def test_sparseconv3d(self):
from torch_points3d.applications.sparseconv3d import SparseConv3d
input_nc = 3
num_layers = 4
in_feat = 32
out_feat = in_feat * 3
model = SparseConv3d(
architecture="unet", input_nc=input_nc, in_feat=in_feat, num_layers=num_layers, config=None,
)
dataset = MockDatasetGeometric(input_nc, transform=GridSampling3D(0.01, quantize_coords=True), num_points=128)
self.assertEqual(len(model._modules["down_modules"]), num_layers + 1)
self.assertEqual(len(model._modules["inner_modules"]), 1)
self.assertEqual(len(model._modules["up_modules"]), 4 + 1)
self.assertFalse(model.has_mlp_head)
self.assertEqual(model.output_nc, out_feat)
try:
data_out = model.forward(dataset[0])
self.assertEqual(data_out.x.shape[1], out_feat)
except Exception as e:
print("Model failing:")
print(model)
print(e)
input_nc = 3
num_layers = 4
output_nc = 5
model = SparseConv3d(
architecture="unet", input_nc=input_nc, output_nc=output_nc, num_layers=num_layers, config=None,
)
dataset = MockDatasetGeometric(input_nc, transform=GridSampling3D(0.01, quantize_coords=True), num_points=128)
self.assertEqual(len(model._modules["down_modules"]), num_layers + 1)
self.assertEqual(len(model._modules["inner_modules"]), 1)
self.assertEqual(len(model._modules["up_modules"]), 4 + 1)
self.assertTrue(model.has_mlp_head)
self.assertEqual(model.output_nc, output_nc)
try:
data_out = model.forward(dataset[0])
self.assertEqual(data_out.x.shape[1], output_nc)
except Exception as e:
print("Model failing:")
print(model)
raise e
def test_pointnet2ms(self):
params = load_model_config("segmentation", "pointnet2")["pointnet2ms"]
dataset = MockDatasetGeometric(5)
model = _find_model_using_name(params.architecture, "segmentation",
params, dataset)
model.set_input(dataset[0])
model.forward()
model.backward()
def test_kpconv(self):
params = load_model_config("segmentation", "kpconv")["PDSimpleKPConv"]
dataset = MockDatasetGeometric(5)
model = _find_model_using_name(params.architecture, "segmentation",
params, dataset)
model.set_input(dataset[0])
model.forward()
model.backward()
def test_largekpconv(self):
params = load_model_config("segmentation", "kpconv")["KPConvPaper"]
model_config = OmegaConf.merge(params, self.data_config)
dataset = MockDatasetGeometric(5)
model = _find_model_using_name(params.architecture, "segmentation",
model_config, dataset)
model.set_input(dataset[0])
model.forward()
model.backward()
def test_largekpconv(self):
params = load_model_config("segmentation", "kpconv", "KPConvPaper")
params.update("data.use_category", True)
params.update("data.first_subsampling", 0.02)
dataset = MockDatasetGeometric(5)
model = instantiate_model(params, dataset)
model.set_input(dataset[0])
model.forward()
model.backward()
def test_registration_from_pretrained(self):
model = PretainedRegistry.from_pretrained(
"minkowski-registration-3dmatch", download=True)
input_nc = 1
dataset = MockDatasetGeometric(input_nc,
transform=GridSampling3D(
0.01, quantize_coords=True),
num_points=128)
model.set_input(dataset[0], device="cpu")
model.forward(dataset[0])
def test_kpconv(self):
params = load_model_config("segmentation", "kpconv")["PDSimpleKPConv"]
model_class = getattr(params, "class")
model_config = OmegaConf.merge(params, self.data_config)
dataset = MockDatasetGeometric(5)
model = _find_model_using_name(model_class, "segmentation",
model_config, dataset)
model.set_input(dataset[0])
model.forward()
model.backward()
def test_createall(self):
for type_file in self.model_type_files:
associated_task = type_file.split("/")[-2]
models_config = OmegaConf.load(type_file)
models_config = OmegaConf.merge(models_config, self.data_config)
models_config.update("data.task", associated_task)
for model_name in models_config.models.keys():
with self.subTest(model_name):
if model_name not in ["MinkUNet_WIP"]:
models_config.update("model_name", model_name)
instantiate_model(models_config, MockDatasetGeometric(6))
def test_createall(self):
for type_file in self.model_type_files:
associated_task = type_file.split("/")[-2]
models_config = OmegaConf.load(type_file).models
for model_name in models_config.keys():
print(model_name)
if model_name not in ["MyTemplateModel"]:
model_config = models_config[model_name]
_find_model_using_name(model_config.architecture,
associated_task, model_config,
MockDatasetGeometric(6))
def test_largekpconv(self):
params = load_model_config("segmentation", "kpconv", "KPConvPaper")
params.update("data.use_category", True)
params.update("data.first_subsampling", 0.02)
dataset = MockDatasetGeometric(5)
model = instantiate_model(params, dataset)
model.set_input(dataset[0], device)
model.forward()
model.backward()
ratio = test_hasgrad(model)
if ratio < 1:
print("Model segmentation.kpconv.KPConvPaper has %i%% of parameters with 0 gradient" % (100 * ratio))
def test_createall(self):
for model_name in self.config["models"].keys():
print(model_name)
if model_name not in ["MyTemplateModel"]:
model_config = self.config["models"][model_name]
cfg_training = set_format(model_config, self.config_file.training)
model_config = merges_in_sub(model_config, [cfg_training, _find_random_dataset(self.config_file.data)])
_find_model_using_name(model_config.type, "segmentation", model_config, MockDatasetGeometric(6))
