def __init__(
self,
backbone,
input_nc=1,
grid_size=0.05,
pointnet_nn=None,
pre_mlp_nn=None,
post_mlp_nn=[64, 64, 32],
add_pos=False,
add_pre_x=False,
backend="minkowski",
aggr=None,
):
if input_nc is None:
input_nc = 1
nn.Module.__init__(self)
self.unet = SparseConv3d(architecture="unet",
input_nc=input_nc,
config=backbone,
backend=backend)
if pre_mlp_nn is not None:
self.pre_mlp = MLP(pre_mlp_nn)
else:
self.pre_mlp = torch.nn.Identity()
if pointnet_nn is not None:
self.pointnet = MLP(pointnet_nn)
else:
self.pointnet = torch.nn.Identity()
self.post_mlp = MLP(post_mlp_nn)
self._grid_size = grid_size
self.add_pos = add_pos
self.add_pre_x = add_pre_x
self.aggr = aggr
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 __init__(self, option, model_type, dataset, modules):
# call the initialization method of UnetBasedModel
super().__init__(option)
self.backbone = SparseConv3d(
"unet", dataset.feature_dimension, config=option.backbone, backend=option.get("backend", "minkowski")
)
self.head = nn.Sequential(nn.Linear(self.backbone.output_nc, dataset.num_classes))
self.loss_names = ["loss_seg"]
def __init__(self, option, model_type, dataset, modules):
# call the initialization method of UnetBasedModel
super().__init__(option)
self._weight_classes = dataset.weight_classes
self.backbone = SparseConv3d("unet",
dataset.feature_dimension,
config=option.backbone,
backend=option.get(
"backend", "minkowski"))
self._supports_mixed = sp3d.nn.get_backend() == "torchsparse"
self.head = nn.Sequential(
nn.Linear(self.backbone.output_nc, dataset.num_classes))
self.loss_names = ["loss_seg"]
self.visual_names = ["data_visual"]
def __init__(self, option, model_type, dataset, modules):
FragmentBaseModel.__init__(self, option)
self.mode = option.loss_mode
self.normalize_feature = option.normalize_feature
self.loss_names = ["loss_reg", "loss"]
self.metric_loss_module, self.miner_module = FragmentBaseModel.get_metric_loss_and_miner(
getattr(option, "metric_loss", None),
getattr(option, "miner", None))
# Unet
self.backbone = SparseConv3d("unet",
dataset.feature_dimension,
config=option.backbone,
backend=option.get(
"backend", "minkowski"))
# Last Layer
if option.mlp_cls is not None:
last_mlp_opt = option.mlp_cls
in_feat = last_mlp_opt.nn[0]
self.FC_layer = Seq()
for i in range(1, len(last_mlp_opt.nn)):
self.FC_layer.append(
str(i),
Sequential(*[
Linear(in_feat, last_mlp_opt.nn[i], bias=False),
FastBatchNorm1d(last_mlp_opt.nn[i],
momentum=last_mlp_opt.bn_momentum),
LeakyReLU(0.2),
]),
)
in_feat = last_mlp_opt.nn[i]
if last_mlp_opt.dropout:
self.FC_layer.append(Dropout(p=last_mlp_opt.dropout))
self.FC_layer.append(Linear(in_feat, in_feat, bias=False))
else:
self.FC_layer = torch.nn.Identity()