def __init__(self, option, model_type, dataset, modules):
super(PointGroup, self).__init__(option)
backbone_options = option.get("backbone", {"architecture": "unet"})
self.Backbone = Minkowski(
backbone_options.architecture,
input_nc=dataset.feature_dimension,
num_layers=4,
config=backbone_options.config,
)
self.BackboneHead = Seq().append(FastBatchNorm1d(self.Backbone.output_nc)).append(torch.nn.ReLU())
self._scorer_is_encoder = option.scorer.architecture == "encoder"
self._activate_scorer = option.scorer.activate
self.Scorer = Minkowski(
option.scorer.architecture, input_nc=self.Backbone.output_nc, num_layers=option.scorer.depth
)
self.ScorerHead = Seq().append(torch.nn.Linear(self.Scorer.output_nc, 1)).append(torch.nn.Sigmoid())
self.Offset = Seq().append(MLP([self.Backbone.output_nc, self.Backbone.output_nc], bias=False))
self.Offset.append(torch.nn.Linear(self.Backbone.output_nc, 3))
self.Semantic = (
Seq()
.append(MLP([self.Backbone.output_nc, self.Backbone.output_nc], bias=False))
.append(torch.nn.Linear(self.Backbone.output_nc, dataset.num_classes))
.append(torch.nn.LogSoftmax())
)
self.loss_names = ["loss", "offset_norm_loss", "offset_dir_loss", "semantic_loss", "score_loss"]
stuff_classes = dataset.stuff_classes
if is_list(stuff_classes):
stuff_classes = torch.Tensor(stuff_classes).long()
self._stuff_classes = torch.cat([torch.tensor([IGNORE_LABEL]), stuff_classes])
def __init__(self, option, model_type, dataset, modules):
# Last Layer
BaseMS_SparseConv3d.__init__(self, option, model_type, dataset,
modules)
option_unet = option.option_unet
num_scales = option_unet.num_scales
self.unet = nn.ModuleList()
for i in range(num_scales):
module = UnetMSparseConv3d(
option_unet.backbone,
input_nc=option_unet.input_nc,
grid_size=option_unet.grid_size[i],
pointnet_nn=option_unet.pointnet_nn,
post_mlp_nn=option_unet.post_mlp_nn,
pre_mlp_nn=option_unet.pre_mlp_nn,
add_pos=option_unet.add_pos,
add_pre_x=option_unet.add_pre_x,
aggr=option_unet.aggr,
backend=option.backend,
)
self.unet.add_module(name=str(i), module=module)
# Last MLP layer
assert option.mlp_cls is not None
last_mlp_opt = option.mlp_cls
self.FC_layer = Seq()
for i in range(1, len(last_mlp_opt.nn)):
self.FC_layer.append(
Sequential(*[
Linear(
last_mlp_opt.nn[i -
1], last_mlp_opt.nn[i], bias=False),
FastBatchNorm1d(last_mlp_opt.nn[i],
momentum=last_mlp_opt.bn_momentum),
LeakyReLU(0.2),
]))
def __init__(self, option, model_type, dataset, modules):
UnwrappedUnetBasedModel.__init__(self, option, model_type, dataset, modules)
self.mode = option.loss_mode
self.normalize_feature = option.normalize_feature
self.loss_names = ["loss_reg", "loss"]
self.metric_loss_module, self.miner_module = BaseModel.get_metric_loss_and_miner(
getattr(option, "metric_loss", None), getattr(option, "miner", None)
)
# 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()
def __init__(self, option, model_type, dataset, modules):
# Extract parameters from the dataset
self._num_classes = dataset.num_classes
self._weight_classes = dataset.weight_classes
self._use_category = getattr(option, "use_category", False)
if self._use_category:
if not dataset.class_to_segments:
raise ValueError(
"The dataset needs to specify a class_to_segments property when using category information for segmentation"
)
self._class_to_seg = dataset.class_to_segments
self._num_categories = len(self._class_to_seg)
log.info("Using category information for the predictions with %i categories", self._num_categories)
else:
self._num_categories = 0
# Assemble encoder / decoder
UnwrappedUnetBasedModel.__init__(self, option, model_type, dataset, modules)
# Build final MLP
last_mlp_opt = option.mlp_cls
if self._use_category:
self.FC_layer = MultiHeadClassifier(
last_mlp_opt.nn[0],
self._class_to_seg,
dropout_proba=last_mlp_opt.dropout,
bn_momentum=last_mlp_opt.bn_momentum,
)
else:
in_feat = last_mlp_opt.nn[0] + self._num_categories
self.FC_layer = Sequential()
for i in range(1, len(last_mlp_opt.nn)):
self.FC_layer.add_module(
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.add_module("Dropout", Dropout(p=last_mlp_opt.dropout))
self.FC_layer.add_module("Class", Lin(in_feat, self._num_classes, bias=False))
self.FC_layer.add_module("Softmax", nn.LogSoftmax(-1))
self.loss_names = ["loss_seg"]
self.lambda_reg = self.get_from_opt(option, ["loss_weights", "lambda_reg"])
if self.lambda_reg:
self.loss_names += ["loss_reg"]
self.lambda_internal_losses = self.get_from_opt(option, ["loss_weights", "lambda_internal_losses"])
self.visual_names = ["data_visual"]
def __init__(self, option, model_type, dataset, modules):
# Extract parameters from the dataset
# Assemble encoder / decoder
UnwrappedUnetBasedModel.__init__(self, option, model_type, dataset,
modules)
# Build final MLP
last_mlp_opt = option.mlp_cls
self.out_channels = option.out_channels
in_feat = last_mlp_opt.nn[0]
self.FC_layer = Seq()
for i in range(1, len(last_mlp_opt.nn)):
self.FC_layer.add_module(
str(i),
Seq(*[
Lin(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.add_module("Dropout",
Dropout(p=last_mlp_opt.dropout))
self.FC_layer.add_module("Last",
Lin(in_feat, self.out_channels, bias=False))
self.mode = option.loss_mode
self.normalize_feature = option.normalize_feature
self.loss_names = ["loss_reg", "loss"]
self.lambda_reg = self.get_from_opt(option,
["loss_weights", "lambda_reg"])
if self.lambda_reg:
self.loss_names += ["loss_regul"]
self.lambda_internal_losses = self.get_from_opt(
option, ["loss_weights", "lambda_internal_losses"])
self.visual_names = ["data_visual"]
def __init__(self, option, model_type, dataset, modules):
BaseMS_SparseConv3d.__init__(self, option, model_type, dataset,
modules)
option_unet = option.option_unet
self.grid_size = option_unet.grid_size
self.unet = UnetMSparseConv3d(
option_unet.backbone,
input_nc=option_unet.input_nc,
pointnet_nn=option_unet.pointnet_nn,
post_mlp_nn=option_unet.post_mlp_nn,
pre_mlp_nn=option_unet.pre_mlp_nn,
add_pos=option_unet.add_pos,
add_pre_x=option_unet.add_pre_x,
aggr=option_unet.aggr,
backend=option.backend,
)
assert option.mlp_cls is not None
last_mlp_opt = option.mlp_cls
self.FC_layer = Seq()
for i in range(1, len(last_mlp_opt.nn)):
self.FC_layer.append(
Sequential(*[
Linear(
last_mlp_opt.nn[i -
1], last_mlp_opt.nn[i], bias=False),
FastBatchNorm1d(last_mlp_opt.nn[i],
momentum=last_mlp_opt.bn_momentum),
LeakyReLU(0.2),
]))
# Intermediate loss
if option.intermediate_loss is not None:
int_loss_option = option.intermediate_loss
self.int_metric_loss, _ = FragmentBaseModel.get_metric_loss_and_miner(
getattr(int_loss_option, "metric_loss", None),
getattr(int_loss_option, "miner", None))
self.int_weights = int_loss_option.weights
for i in range(len(int_loss_option.weights)):
self.loss_names += ["loss_intermediate_loss_{}".format(i)]
else:
self.int_metric_loss = None
def __init__(self, option, model_type, dataset, modules):
BaseModel.__init__(self, option)
option_unet = option.option_unet
self.normalize_feature = option.normalize_feature
self.grid_size = option_unet.grid_size
self.unet = UnetMSparseConv3d(
option_unet.backbone,
input_nc=option_unet.input_nc,
pointnet_nn=option_unet.pointnet_nn,
post_mlp_nn=option_unet.post_mlp_nn,
pre_mlp_nn=option_unet.pre_mlp_nn,
add_pos=option_unet.add_pos,
add_pre_x=option_unet.add_pre_x,
aggr=option_unet.aggr,
backend=option.backend,
)
if option.mlp_cls is not None:
last_mlp_opt = option.mlp_cls
self.FC_layer = Seq()
for i in range(1, len(last_mlp_opt.nn)):
self.FC_layer.append(
nn.Sequential(*[
nn.Linear(last_mlp_opt.nn[i - 1],
last_mlp_opt.nn[i],
bias=False),
FastBatchNorm1d(last_mlp_opt.nn[i],
momentum=last_mlp_opt.bn_momentum),
nn.LeakyReLU(0.2),
]))
if last_mlp_opt.dropout:
self.FC_layer.append(nn.Dropout(p=last_mlp_opt.dropout))
else:
self.FC_layer = torch.nn.Identity()
self.head = nn.Sequential(
nn.Linear(option.output_nc, dataset.num_classes))
self.loss_names = ["loss_seg"]
def __init__(self, in_channels, out_channels, bn=True, activation=None):
super(MLP, self).__init__()
bias = False if bn else True
self.lin = nn.Linear(in_channels, out_channels, bias=bias)
self.bn = FastBatchNorm1d(out_channels) if bn else None
self.activation = activation
