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))