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