예제 #1
0
파일: resnet.py 프로젝트: ecr23xx/eve
    def network_initialization(self, in_channels, out_channels, D):

        self.inplanes = self.INIT_DIM
        self.conv1 = ME.MinkowskiConvolution(
            in_channels, self.inplanes, kernel_size=5, stride=2, dimension=D)

        self.bn1 = ME.MinkowskiBatchNorm(self.inplanes)
        self.relu = ME.MinkowskiReLU(inplace=True)

        self.pool = ME.MinkowskiAvgPooling(
            kernel_size=2, stride=2, dimension=D)

        self.layer1 = self._make_layer(
            self.BLOCK, self.PLANES[0], self.LAYERS[0], stride=2)
        self.layer2 = self._make_layer(
            self.BLOCK, self.PLANES[1], self.LAYERS[1], stride=2)
        self.layer3 = self._make_layer(
            self.BLOCK, self.PLANES[2], self.LAYERS[2], stride=2)
        self.layer4 = self._make_layer(
            self.BLOCK, self.PLANES[3], self.LAYERS[3], stride=2)

        self.conv5 = ME.MinkowskiConvolution(
            self.inplanes, self.inplanes, kernel_size=3, stride=3, dimension=D)
        self.bn5 = ME.MinkowskiBatchNorm(self.inplanes)

        self.glob_avg = ME.MinkowskiGlobalPooling(dimension=D)

        self.final = ME.MinkowskiLinear(self.inplanes, out_channels, bias=True)
예제 #2
0
    def __init__(self):
        super(PointNetFeature, self).__init__()

        k = self.KERNEL_SIZES
        s = self.STRIDES
        c = self.CONV_CHANNELS

        self.stn = STN3d(D=3)
        self.block1 = nn.Sequential(
            ME.MinkowskiConvolution(6,
                                    c[0],
                                    kernel_size=k[0],
                                    stride=s[0],
                                    has_bias=False,
                                    dimension=3),
            ME.MinkowskiInstanceNorm(c[0]), ME.MinkowskiReLU())
        self.block2 = nn.Sequential(
            ME.MinkowskiConvolution(c[0],
                                    c[1],
                                    kernel_size=k[1],
                                    stride=s[1],
                                    has_bias=False,
                                    dimension=3),
            ME.MinkowskiInstanceNorm(c[1]), ME.MinkowskiReLU())
        self.block3 = nn.Sequential(
            ME.MinkowskiConvolution(c[1],
                                    c[2],
                                    kernel_size=k[2],
                                    stride=s[2],
                                    has_bias=False,
                                    dimension=3),
            ME.MinkowskiInstanceNorm(c[2]), ME.MinkowskiReLU())

        self.avgpool = ME.MinkowskiGlobalPooling()
        self.concat = ME.MinkowskiBroadcastConcatenation()
예제 #3
0
    def __init__(self):
        super(PointNetFeature, self).__init__()

        k = self.KERNEL_SIZES
        s = self.STRIDES
        c = self.CONV_CHANNELS

        self.stn = STN3d(D=3)
        self.conv1 = ME.MinkowskiConvolution(6,
                                             c[0],
                                             kernel_size=k[0],
                                             stride=s[0],
                                             has_bias=False,
                                             dimension=3)
        self.conv2 = ME.MinkowskiConvolution(c[0],
                                             c[1],
                                             kernel_size=k[1],
                                             stride=s[1],
                                             has_bias=False,
                                             dimension=3)
        self.conv3 = ME.MinkowskiConvolution(c[1],
                                             c[2],
                                             kernel_size=k[2],
                                             stride=s[2],
                                             has_bias=False,
                                             dimension=3)
        self.bn1 = ME.MinkowskiInstanceNorm(c[0], dimension=3)
        self.bn2 = ME.MinkowskiInstanceNorm(c[1], dimension=3)
        self.bn3 = ME.MinkowskiInstanceNorm(c[2], dimension=3)

        self.relu = ME.MinkowskiReLU(inplace=True)
        self.avgpool = ME.MinkowskiGlobalPooling()
        self.concat = ME.MinkowskiBroadcastConcatenation()
    def network_initialization(
        self, in_channel, out_channel, channels, embedding_channel, kernel_size, D=2,
    ):
        self.conv1_1 = self.get_conv_block(in_channel, channels[0], kernel_size=kernel_size, stride=1)
        self.conv1_2 = self.get_conv_block(channels[0], channels[1], kernel_size=kernel_size, stride=1)
        self.pool1 = ME.MinkowskiMaxPooling(kernel_size=3, stride=2, dimension=D)

        self.conv2_1 = self.get_conv_block(channels[1], channels[2], kernel_size=kernel_size, stride=1)
        self.conv2_2 = self.get_conv_block(channels[2], channels[3], kernel_size=kernel_size, stride=1)
        self.pool2 = ME.MinkowskiMaxPooling(kernel_size=3, stride=2, dimension=D)

        self.conv3_1 = self.get_conv_block(channels[3], channels[4], kernel_size=kernel_size, stride=1)
        self.conv3_2 = self.get_conv_block(channels[4], channels[5], kernel_size=kernel_size, stride=1)
        self.conv3_3 = self.get_conv_block(channels[5], channels[6], kernel_size=kernel_size, stride=1)
        self.pool3 = ME.MinkowskiMaxPooling(kernel_size=3, stride=2, dimension=D)

        self.conv4_1 = self.get_conv_block(channels[6], channels[7], kernel_size=kernel_size, stride=1)
        self.conv4_2 = self.get_conv_block(channels[7], channels[8], kernel_size=kernel_size, stride=1)
        self.conv4_3 = self.get_conv_block(channels[8], channels[9], kernel_size=kernel_size, stride=1)
        self.pool4 = ME.MinkowskiMaxPooling(kernel_size=3, stride=2, dimension=D)

        self.conv5_1 = self.get_conv_block(channels[9], channels[10], kernel_size=kernel_size, stride=1)
        self.conv5_2 = self.get_conv_block(channels[10], channels[11], kernel_size=kernel_size, stride=1)
        self.conv5_3 = self.get_conv_block(channels[11], channels[12], kernel_size=kernel_size, stride=1)
        self.pool5 = ME.MinkowskiMaxPooling(kernel_size=3, stride=2, dimension=D)

        self.global_pool = ME.MinkowskiGlobalPooling()

        self.final = nn.Sequential(
            self.get_mlp_block(512, 512),
            ME.MinkowskiDropout(),
            self.get_mlp_block(512, 512),
            self.get_mlp_block(512, 2),
            #ME.MinkowskiFunctional.softmax(),
        )
예제 #5
0
  def network_initialization(self, in_channels, out_channels, config, D):

    def space_n_time_m(n, m):
      return n if D == 3 else [n, n, n, m]

    if D == 4:
      self.OUT_PIXEL_DIST = space_n_time_m(self.OUT_PIXEL_DIST, 1)

    dilations = config.dilations
    bn_momentum = config.bn_momentum
    self.inplanes = self.INIT_DIM
    self.conv1 = conv(
        in_channels,
        self.inplanes,
        kernel_size=space_n_time_m(config.conv1_kernel_size, 1),
        stride=1,
        D=D)

    self.bn1 = get_norm(NormType.BATCH_NORM, self.inplanes, D=self.D, bn_momentum=bn_momentum)
    self.relu = ME.MinkowskiReLU(inplace=True)
    self.pool = sum_pool(kernel_size=space_n_time_m(2, 1), stride=space_n_time_m(2, 1), D=D)

    self.layer1 = self._make_layer(
        self.BLOCK,
        self.PLANES[0],
        self.LAYERS[0],
        stride=space_n_time_m(2, 1),
        dilation=space_n_time_m(dilations[0], 1))
    self.layer2 = self._make_layer(
        self.BLOCK,
        self.PLANES[1],
        self.LAYERS[1],
        stride=space_n_time_m(2, 1),
        dilation=space_n_time_m(dilations[1], 1))
    self.layer3 = self._make_layer(
        self.BLOCK,
        self.PLANES[2],
        self.LAYERS[2],
        stride=space_n_time_m(2, 1),
        dilation=space_n_time_m(dilations[2], 1))
    self.layer4 = self._make_layer(
        self.BLOCK,
        self.PLANES[3],
        self.LAYERS[3],
        stride=space_n_time_m(2, 1),
        dilation=space_n_time_m(dilations[3], 1))

    if self.NETWORK_TYPE == NetworkType.CLASSIFICATION:
      self.glob_avg = ME.MinkowskiGlobalPooling(dimension=D)
      if self.HAS_LAST_BLOCK:
        self.final1 = nn.Linear(self.inplanes, self.inplanes, bias=False)
        self.bnfinal1 = nn.BatchNorm1d(self.inplanes)

        self.final2 = nn.Linear(self.inplanes, self.inplanes, bias=False)
        self.bnfinal2 = nn.BatchNorm1d(self.inplanes)

      self.final = nn.Linear(self.inplanes, out_channels, bias=True)
    else:
      self.final = conv(
          self.PLANES[3] * self.BLOCK.expansion, out_channels, kernel_size=1, bias=True, D=D)
예제 #6
0
 def __init__(self, channel, reduction=16, D=-1):
   # Global coords does not require coords_key
   super(SELayer, self).__init__()
   self.fc = nn.Sequential(
       ME.MinkowskiLinear(channel, channel // reduction), ME.MinkowskiReLU(inplace=True),
       ME.MinkowskiLinear(channel // reduction, channel), ME.MinkowskiSigmoid())
   self.pooling = ME.MinkowskiGlobalPooling(dimension=D)
   self.broadcast_mul = ME.MinkowskiBroadcastMultiplication(dimension=D)
예제 #7
0
    def __init__(self, D=3):
        super(STN3d, self).__init__()

        k = self.KERNEL_SIZES
        s = self.STRIDES
        c = self.CONV_CHANNELS

        self.block1 = nn.Sequential(
            ME.MinkowskiConvolution(3,
                                    c[0],
                                    kernel_size=k[0],
                                    stride=s[0],
                                    has_bias=False,
                                    dimension=3),
            ME.MinkowskiInstanceNorm(c[0]), ME.MinkowskiReLU())
        self.block2 = nn.Sequential(
            ME.MinkowskiConvolution(c[0],
                                    c[1],
                                    kernel_size=k[1],
                                    stride=s[1],
                                    has_bias=False,
                                    dimension=3),
            ME.MinkowskiInstanceNorm(c[1]), ME.MinkowskiReLU())
        self.block3 = nn.Sequential(
            ME.MinkowskiConvolution(c[1],
                                    c[2],
                                    kernel_size=k[2],
                                    stride=s[2],
                                    has_bias=False,
                                    dimension=3),
            ME.MinkowskiInstanceNorm(c[2]), ME.MinkowskiReLU())

        # Use the kernelsize 1 convolution for linear layers. If kernel size ==
        # 1, minkowski engine internally uses a linear function.
        self.block4 = nn.Sequential(
            ME.MinkowskiConvolution(c[2],
                                    c[3],
                                    kernel_size=1,
                                    has_bias=False,
                                    dimension=3),
            ME.MinkowskiInstanceNorm(c[3]), ME.MinkowskiReLU())
        self.block5 = nn.Sequential(
            ME.MinkowskiConvolution(c[3],
                                    c[4],
                                    kernel_size=1,
                                    has_bias=False,
                                    dimension=3),
            ME.MinkowskiInstanceNorm(c[4]), ME.MinkowskiReLU())
        self.fc6 = ME.MinkowskiConvolution(c[4],
                                           9,
                                           kernel_size=1,
                                           has_bias=True,
                                           dimension=3)

        self.avgpool = ME.MinkowskiGlobalPooling()
        self.broadcast = ME.MinkowskiBroadcast()
예제 #8
0
파일: pointnet.py 프로젝트: jgwak/GSDN
 def __init__(self, in_channels):
     super(PointNetfeat, self).__init__()
     self.pool = ME.MinkowskiGlobalPooling()
     self.broadcast = ME.MinkowskiBroadcast()
     self.stn = STN3d(D=3)
     self.conv1 = nn.Conv1d(in_channels + 3, 128, 1, bias=False)
     self.conv2 = nn.Conv1d(128, 256, 1, bias=False)
     self.bn1 = nn.BatchNorm1d(128)
     self.bn2 = nn.BatchNorm1d(256)
     self.relu = nn.ReLU()
예제 #9
0
    def __init__(self, D=3):
        super(STN3d, self).__init__()

        k = self.KERNEL_SIZES
        s = self.STRIDES
        c = self.CONV_CHANNELS

        self.conv1 = ME.MinkowskiConvolution(3,
                                             c[0],
                                             kernel_size=k[0],
                                             stride=s[0],
                                             has_bias=False,
                                             dimension=3)
        self.conv2 = ME.MinkowskiConvolution(c[0],
                                             c[1],
                                             kernel_size=k[1],
                                             stride=s[1],
                                             has_bias=False,
                                             dimension=3)
        self.conv3 = ME.MinkowskiConvolution(c[1],
                                             c[2],
                                             kernel_size=k[2],
                                             stride=s[2],
                                             has_bias=False,
                                             dimension=3)

        # Use the kernelsize 1 convolution for linear layers. If kernel size ==
        # 1, minkowski engine internally uses a linear function.
        self.fc4 = ME.MinkowskiConvolution(c[2],
                                           c[3],
                                           kernel_size=1,
                                           has_bias=False,
                                           dimension=3)
        self.fc5 = ME.MinkowskiConvolution(c[3],
                                           c[4],
                                           kernel_size=1,
                                           has_bias=False,
                                           dimension=3)
        self.fc6 = ME.MinkowskiConvolution(c[4],
                                           9,
                                           kernel_size=1,
                                           has_bias=True,
                                           dimension=3)

        self.relu = ME.MinkowskiReLU(inplace=True)
        self.avgpool = ME.MinkowskiGlobalPooling()
        self.broadcast = ME.MinkowskiBroadcast()

        self.bn1 = ME.MinkowskiInstanceNorm(c[0], dimension=3)
        self.bn2 = ME.MinkowskiInstanceNorm(c[1], dimension=3)
        self.bn3 = ME.MinkowskiInstanceNorm(c[2], dimension=3)
        self.bn4 = ME.MinkowskiInstanceNorm(c[3], dimension=3)
        self.bn5 = ME.MinkowskiInstanceNorm(c[4], dimension=3)
예제 #10
0
 def __init__(self, channels, gamma=2, b=1):
     super().__init__()
     t = int(abs((np.log2(channels) + b) / gamma))
     k_size = t if t % 2 else t + 1
     self.avg_pool = ME.MinkowskiGlobalPooling()
     self.conv = nn.Conv1d(1,
                           1,
                           kernel_size=k_size,
                           padding=(k_size - 1) // 2,
                           bias=False)
     self.sigmoid = nn.Sigmoid()
     self.broadcast_mul = ME.MinkowskiBroadcastMultiplication()
예제 #11
0
    def __init__(self,
                 in_features,
                 out_features,
                 kernel_sizes=None,
                 dilations=None,
                 mode='avg',
                 D=3):
        super(SPP, self).__init__()
        if mode == 'avg':
            self.pool_fn = ME.MinkowskiAvgPooling
        elif mode == 'max':
            self.pool_fn = ME.MinkowskiMaxPooling
        elif mode == 'sum':
            self.pool_fn = ME.MinkowskiSumPooling
        else:
            raise ValueError("Invalid pooling mode, must be one of \
                'sum', 'max' or 'average'")
        self.unpool_fn = ME.MinkowskiPoolingTranspose

        # Include global pooling as first modules.
        self.pool = [ME.MinkowskiGlobalPooling(dimension=D)]
        self.unpool = [ME.MinkowskiBroadcast(dimension=D)]
        multiplier = 1
        # Define subregion poolings
        self.spp = []
        if kernel_sizes is not None:
            if isinstance(dilations, int):
                dilations = [dilations for _ in range(len(kernel_sizes))]
            elif isinstance(dilations, list):
                assert len(kernel_sizes) == len(dilations)
            else:
                raise ValueError("Invalid input to dilations, must be either \
                    int or list of ints")
            multiplier = len(kernel_sizes) + 1  # Additional 1 for globalPool
            for k, d in zip(kernel_sizes, dilations):
                pooling_layer = self.pool_fn(kernel_size=k,
                                             dilation=d,
                                             stride=k,
                                             dimension=D)
                unpooling_layer = self.unpool_fn(kernel_size=k,
                                                 dilation=d,
                                                 stride=k,
                                                 dimension=D)
                self.pool.append(pooling_layer)
                self.unpool.append(unpooling_layer)
        self.pool = nn.Sequential(*self.pool)
        self.unpool = nn.Sequential(*self.unpool)
        self.linear = ME.MinkowskiLinear(in_features * multiplier,
                                         out_features)
예제 #12
0
파일: pointnet.py 프로젝트: jgwak/GSDN
    def __init__(self, D=3):
        super(STN3d, self).__init__()
        self.conv1 = nn.Conv1d(3, 64, 1, bias=False)
        self.conv2 = nn.Conv1d(64, 128, 1, bias=False)
        self.conv3 = nn.Conv1d(128, 256, 1, bias=False)
        self.fc1 = nn.Linear(256, 128, bias=False)
        self.fc2 = nn.Linear(128, 64, bias=False)
        self.fc3 = nn.Linear(64, 9)
        self.relu = nn.ReLU()
        self.pool = ME.MinkowskiGlobalPooling()

        self.bn1 = nn.BatchNorm1d(64)
        self.bn2 = nn.BatchNorm1d(128)
        self.bn3 = nn.BatchNorm1d(256)
        self.bn4 = nn.BatchNorm1d(128)
        self.bn5 = nn.BatchNorm1d(64)
        self.broadcast = ME.MinkowskiBroadcast()
예제 #13
0
 def __init__(self, in_feat, out_feat, D):
     super(ExampleNetwork, self).__init__(D)
     self.conv1 = ME.MinkowskiConvolution(in_channels=in_feat,
                                          out_channels=64,
                                          kernel_size=3,
                                          stride=2,
                                          dilation=1,
                                          has_bias=False,
                                          dimension=D)
     self.bn1 = ME.MinkowskiBatchNorm(64)
     self.conv2 = ME.MinkowskiConvolution(in_channels=64,
                                          out_channels=128,
                                          kernel_size=3,
                                          stride=2,
                                          dimension=D)
     self.bn2 = ME.MinkowskiBatchNorm(128)
     self.pooling = ME.MinkowskiGlobalPooling(dimension=D)
     self.linear = ME.MinkowskiLinear(128, out_feat)
예제 #14
0
 def __init__(self, in_feat, out_feat, D):
     super(ExampleNetwork, self).__init__(D)
     self.net = nn.Sequential(
         ME.MinkowskiConvolution(in_channels=in_feat,
                                 out_channels=64,
                                 kernel_size=3,
                                 stride=2,
                                 dilation=1,
                                 has_bias=False,
                                 dimension=D), ME.MinkowskiBatchNorm(64),
         ME.MinkowskiReLU(),
         ME.MinkowskiConvolution(in_channels=64,
                                 out_channels=128,
                                 kernel_size=3,
                                 stride=2,
                                 dimension=D), ME.MinkowskiBatchNorm(128),
         ME.MinkowskiReLU(), ME.MinkowskiGlobalPooling(dimension=D),
         ME.MinkowskiLinear(128, out_feat))
예제 #15
0
    def __init__(self, config={}, **kwargs):
        MEEncoder.__init__(self, config=config, **kwargs)

        # need square and power of 2 image size input
        power = math.log(self.config.input_size[0], 2)
        assert (power % 1 == 0.0) and (
            power > 3
        ), "Dumoulin Encoder needs a power of 2 as image input size (>=16)"
        # need square image input
        assert torch.all(
            torch.tensor([
                self.config.input_size[i] == self.config.input_size[0]
                for i in range(1, len(self.config.input_size))
            ])), "Dumoulin Encoder needs a square image input size"

        assert self.config.n_conv_layers == power, "The number of convolutional layers in DumoulinEncoder must be log2(input_size) "

        # network architecture
        if self.config.hidden_channels is None:
            self.config.hidden_channels = 8

        hidden_channels = self.config.hidden_channels
        kernels_size = [4, 4] * self.config.n_conv_layers
        strides = [1, 2] * self.config.n_conv_layers
        pads = [0, 1] * self.config.n_conv_layers
        dils = [1, 1] * self.config.n_conv_layers

        # feature map size
        feature_map_sizes = conv_output_sizes(self.config.input_size,
                                              2 * self.config.n_conv_layers,
                                              kernels_size, strides, pads,
                                              dils)

        # local feature
        ## convolutional layers
        self.local_feature_shape = (
            int(hidden_channels * math.pow(2, self.config.feature_layer + 1)),
            feature_map_sizes[2 * self.config.feature_layer + 1][0],
            feature_map_sizes[2 * self.config.feature_layer + 1][1])
        self.lf = nn.Sequential()

        for conv_layer_id in range(self.config.feature_layer + 1):
            if conv_layer_id == 0:
                self.lf.add_module(
                    "conv_{}".format(conv_layer_id),
                    nn.Sequential(
                        ME.MinkowskiConvolution(
                            self.config.n_channels,
                            hidden_channels,
                            kernel_size=kernels_size[2 * conv_layer_id],
                            stride=strides[2 * conv_layer_id],
                            dilation=dils[2 * conv_layer_id],
                            dimension=self.spatial_dims,
                            bias=True),
                        ME.MinkowskiBatchNorm(hidden_channels),
                        ME.MinkowskiELU(inplace=True),
                        ME.MinkowskiConvolution(
                            hidden_channels,
                            2 * hidden_channels,
                            kernel_size=kernels_size[2 * conv_layer_id + 1],
                            stride=strides[2 * conv_layer_id + 1],
                            dilation=dils[2 * conv_layer_id + 1],
                            dimension=self.spatial_dims,
                            bias=True),
                        ME.MinkowskiBatchNorm(2 * hidden_channels),
                        ME.MinkowskiELU(inplace=True),
                    ))
            else:
                self.lf.add_module(
                    "conv_{}".format(conv_layer_id),
                    nn.Sequential(
                        ME.MinkowskiConvolution(
                            hidden_channels,
                            hidden_channels,
                            kernel_size=kernels_size[2 * conv_layer_id],
                            stride=strides[2 * conv_layer_id],
                            dilation=dils[2 * conv_layer_id],
                            dimension=self.spatial_dims,
                            bias=True),
                        ME.MinkowskiBatchNorm(hidden_channels),
                        ME.MinkowskiELU(inplace=True),
                        ME.MinkowskiConvolution(
                            hidden_channels,
                            2 * hidden_channels,
                            kernel_size=kernels_size[2 * conv_layer_id + 1],
                            stride=strides[2 * conv_layer_id + 1],
                            dilation=dils[2 * conv_layer_id + 1],
                            dimension=self.spatial_dims,
                            bias=True),
                        ME.MinkowskiBatchNorm(2 * hidden_channels),
                        ME.MinkowskiELU(inplace=True),
                    ))
            hidden_channels *= 2
        self.lf.out_connection_type = ("conv", hidden_channels)

        # global feature
        self.gf = nn.Sequential()
        ## convolutional layers
        for conv_layer_id in range(self.config.feature_layer + 1,
                                   self.config.n_conv_layers):
            self.gf.add_module(
                "conv_{}".format(conv_layer_id),
                nn.Sequential(
                    ME.MinkowskiConvolution(
                        hidden_channels,
                        hidden_channels,
                        kernel_size=kernels_size[2 * conv_layer_id],
                        stride=strides[2 * conv_layer_id],
                        dilation=dils[2 * conv_layer_id],
                        dimension=self.spatial_dims,
                        bias=True),
                    ME.MinkowskiBatchNorm(hidden_channels),
                    ME.MinkowskiELU(inplace=True),
                    ME.MinkowskiConvolution(
                        hidden_channels,
                        2 * hidden_channels,
                        kernel_size=kernels_size[2 * conv_layer_id + 1],
                        stride=strides[2 * conv_layer_id + 1],
                        dilation=dils[2 * conv_layer_id + 1],
                        dimension=self.spatial_dims,
                        bias=True),
                    ME.MinkowskiBatchNorm(2 * hidden_channels),
                    ME.MinkowskiELU(inplace=True),
                ))
            hidden_channels *= 2
        self.gf.out_connection_type = ("conv", hidden_channels)

        # encoding feature
        if self.config.encoder_conditional_type == "gaussian":
            self.add_module(
                "ef",
                nn.Sequential(
                    ME.MinkowskiConvolution(hidden_channels,
                                            hidden_channels,
                                            kernel_size=1,
                                            stride=1,
                                            dilation=1,
                                            dimension=self.spatial_dims,
                                            bias=True),
                    ME.MinkowskiBatchNorm(hidden_channels),
                    ME.MinkowskiELU(inplace=True),
                    ME.MinkowskiConvolution(hidden_channels,
                                            2 * self.config.n_latents,
                                            kernel_size=1,
                                            stride=1,
                                            dilation=1,
                                            dimension=self.spatial_dims,
                                            bias=True),
                ))
        elif self.config.encoder_conditional_type == "deterministic":
            self.add_module(
                "ef",
                nn.Sequential(
                    ME.MinkowskiConvolution(hidden_channels,
                                            hidden_channels,
                                            kernel_size=1,
                                            stride=1,
                                            dilation=1,
                                            dimension=self.spatial_dims,
                                            bias=True),
                    ME.MinkowskiBatchNorm(hidden_channels),
                    ME.MinkowskiELU(inplace=True),
                    ME.MinkowskiConvolution(hidden_channels,
                                            self.config.n_latents,
                                            kernel_size=1,
                                            stride=1,
                                            dilation=1,
                                            dimension=self.spatial_dims,
                                            bias=True),
                ))

        # global pool
        self.global_pool = ME.MinkowskiGlobalPooling()

        # attention feature
        if self.config.use_attention:
            self.add_module(
                "af",
                ME.MinkowskiConvolution(hidden_channels,
                                        4 * self.config.n_latents,
                                        kernel_size=1,
                                        stride=1,
                                        dilation=1,
                                        dimension=self.spatial_dims,
                                        bias=True))
예제 #16
0
    def __init__(self):
        nn.Module.__init__(self)

        # Input sparse tensor must have tensor stride 128.
        ch = self.CHANNELS

        # Block 1
        self.block1 = nn.Sequential(
            ME.MinkowskiConvolution(1, ch[0], kernel_size=3, stride=2, dimension=3),
            ME.MinkowskiBatchNorm(ch[0]),
            ME.MinkowskiELU(),
            ME.MinkowskiConvolution(ch[0], ch[0], kernel_size=3, dimension=3),
            ME.MinkowskiBatchNorm(ch[0]),
            ME.MinkowskiELU(),
        )

        self.block2 = nn.Sequential(
            ME.MinkowskiConvolution(ch[0], ch[1], kernel_size=3, stride=2, dimension=3),
            ME.MinkowskiBatchNorm(ch[1]),
            ME.MinkowskiELU(),
            ME.MinkowskiConvolution(ch[1], ch[1], kernel_size=3, dimension=3),
            ME.MinkowskiBatchNorm(ch[1]),
            ME.MinkowskiELU(),
        )

        self.block3 = nn.Sequential(
            ME.MinkowskiConvolution(ch[1], ch[2], kernel_size=3, stride=2, dimension=3),
            ME.MinkowskiBatchNorm(ch[2]),
            ME.MinkowskiELU(),
            ME.MinkowskiConvolution(ch[2], ch[2], kernel_size=3, dimension=3),
            ME.MinkowskiBatchNorm(ch[2]),
            ME.MinkowskiELU(),
        )

        self.block4 = nn.Sequential(
            ME.MinkowskiConvolution(ch[2], ch[3], kernel_size=3, stride=2, dimension=3),
            ME.MinkowskiBatchNorm(ch[3]),
            ME.MinkowskiELU(),
            ME.MinkowskiConvolution(ch[3], ch[3], kernel_size=3, dimension=3),
            ME.MinkowskiBatchNorm(ch[3]),
            ME.MinkowskiELU(),
        )

        self.block5 = nn.Sequential(
            ME.MinkowskiConvolution(ch[3], ch[4], kernel_size=3, stride=2, dimension=3),
            ME.MinkowskiBatchNorm(ch[4]),
            ME.MinkowskiELU(),
            ME.MinkowskiConvolution(ch[4], ch[4], kernel_size=3, dimension=3),
            ME.MinkowskiBatchNorm(ch[4]),
            ME.MinkowskiELU(),
        )

        self.block6 = nn.Sequential(
            ME.MinkowskiConvolution(ch[4], ch[5], kernel_size=3, stride=2, dimension=3),
            ME.MinkowskiBatchNorm(ch[5]),
            ME.MinkowskiELU(),
            ME.MinkowskiConvolution(ch[5], ch[5], kernel_size=3, dimension=3),
            ME.MinkowskiBatchNorm(ch[5]),
            ME.MinkowskiELU(),
        )

        self.block7 = nn.Sequential(
            ME.MinkowskiConvolution(ch[5], ch[6], kernel_size=3, stride=2, dimension=3),
            ME.MinkowskiBatchNorm(ch[6]),
            ME.MinkowskiELU(),
            ME.MinkowskiConvolution(ch[6], ch[6], kernel_size=3, dimension=3),
            ME.MinkowskiBatchNorm(ch[6]),
            ME.MinkowskiELU(),
        )

        self.global_pool = ME.MinkowskiGlobalPooling()

        self.linear_mean = ME.MinkowskiLinear(ch[6], ch[6], bias=True)
        self.linear_log_var = ME.MinkowskiLinear(ch[6], ch[6], bias=True)
        self.weight_initialization()
예제 #17
0
    # Normalize features and create a sparse tensor
    return features, coordinates


if __name__ == '__main__':
    config = parser.parse_args()
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

    # Define a model and load the weights
    feats = [3, 8, 16, 32, 64, 128]
    features, coordinates = generate_input_sparse_tensor(
        config.file_name,
        voxel_size=config.voxel_size,
        batch_size=config.batch_size)

    pool = ME.MinkowskiGlobalPooling(mode=ME.GlobalPoolingMode.AUTO,
                                     dimension=3)

    # Measure time
    print('Forward')
    for feat in feats:
        timer = Timer()
        features = torch.rand(len(coordinates), feat).to(device)

        # Feed-forward pass and get the prediction
        for i in range(20):
            sinput = ME.SparseTensor(features, coords=coordinates).to(device)

            timer.tic()
            soutput = pool(sinput)
            timer.toc()
        print(
예제 #18
0
    # Normalize features and create a sparse tensor
    return features, coordinates


if __name__ == '__main__':
    config = parser.parse_args()
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

    # Define a model and load the weights
    feats = [3, 8, 16, 32, 64, 128]
    features, coordinates = generate_input_sparse_tensor(
        config.file_name,
        voxel_size=config.voxel_size,
        batch_size=config.batch_size)

    pool = ME.MinkowskiGlobalPooling(mode=ME.GlobalPoolingMode.AUTO)

    # Measure time
    print('Forward')
    for feat in feats:
        timer = Timer()
        features = torch.rand(len(coordinates), feat).to(device)

        # Feed-forward pass and get the prediction
        for i in range(20):
            sinput = ME.SparseTensor(features, coords=coordinates).to(device)

            timer.tic()
            soutput = pool(sinput)
            timer.toc()
        print(
예제 #19
0
  def network_initialization(self, in_channels, out_channels, config, D):
    # Setup net_metadata
    dilations = self.DILATIONS
    bn_momentum = config['bn_momentum']

    def space_n_time_m(n, m):
      return n if D == 3 else [n, n, n, m]

    if D == 4:
      self.OUT_PIXEL_DIST = space_n_time_m(self.OUT_PIXEL_DIST, 1)

    # Output of the first conv concated to conv6
    self.inplanes = self.INIT_DIM
    self.conv0p1s1 = conv(
        in_channels,
        self.inplanes,
        kernel_size=space_n_time_m(config['conv1_kernel_size'], 1),
        stride=1,
        dilation=1,
        conv_type=self.NON_BLOCK_CONV_TYPE,
        D=D)

    self.bn0 = get_norm(self.NORM_TYPE, self.inplanes, D, bn_momentum=bn_momentum)

    self.conv1p1s2 = conv(
        self.inplanes,
        self.inplanes,
        kernel_size=space_n_time_m(2, 1),
        stride=space_n_time_m(2, 1),
        dilation=1,
        conv_type=self.NON_BLOCK_CONV_TYPE,
        D=D)
    self.bn1 = get_norm(self.NORM_TYPE, self.inplanes, D, bn_momentum=bn_momentum)
    self.block1 = self._make_layer(
        self.BLOCK,
        self.PLANES[0],
        self.LAYERS[0],
        dilation=dilations[0],
        norm_type=self.NORM_TYPE,
        bn_momentum=bn_momentum)

    self.conv2p2s2 = conv(
        self.inplanes,
        self.inplanes,
        kernel_size=space_n_time_m(2, 1),
        stride=space_n_time_m(2, 1),
        dilation=1,
        conv_type=self.NON_BLOCK_CONV_TYPE,
        D=D)
    self.bn2 = get_norm(self.NORM_TYPE, self.inplanes, D, bn_momentum=bn_momentum)
    self.block2 = self._make_layer(
        self.BLOCK,
        self.PLANES[1],
        self.LAYERS[1],
        dilation=dilations[1],
        norm_type=self.NORM_TYPE,
        bn_momentum=bn_momentum)

    self.conv3p4s2 = conv(
        self.inplanes,
        self.inplanes,
        kernel_size=space_n_time_m(2, 1),
        stride=space_n_time_m(2, 1),
        dilation=1,
        conv_type=self.NON_BLOCK_CONV_TYPE,
        D=D)
    self.bn3 = get_norm(self.NORM_TYPE, self.inplanes, D, bn_momentum=bn_momentum)
    self.block3 = self._make_layer(
        self.BLOCK,
        self.PLANES[2],
        self.LAYERS[2],
        dilation=dilations[2],
        norm_type=self.NORM_TYPE,
        bn_momentum=bn_momentum)

    self.conv4p8s2 = conv(
        self.inplanes,
        self.inplanes,
        kernel_size=space_n_time_m(2, 1),
        stride=space_n_time_m(2, 1),
        dilation=1,
        conv_type=self.NON_BLOCK_CONV_TYPE,
        D=D)
    self.bn4 = get_norm(self.NORM_TYPE, self.inplanes, D, bn_momentum=bn_momentum)
    self.block4 = self._make_layer(
        self.BLOCK,
        self.PLANES[3],
        self.LAYERS[3],
        dilation=dilations[3],
        norm_type=self.NORM_TYPE,
        bn_momentum=bn_momentum)
        
    self.relu = MinkowskiReLU(inplace=True)
    # add a classification head here
    self.clf_glob_avg = ME.MinkowskiGlobalPooling(dimension=D)
    self.clf_glob_max=ME.MinkowskiGlobalMaxPooling(dimension=D)
    self.clf_conv0 = conv(
        256,
        512,
        kernel_size=3,
        stride=2,
        dilation=1,
        conv_type=self.NON_BLOCK_CONV_TYPE,
        D=D)
    self.clf_bn0 = get_norm(self.NORM_TYPE, 512, D, bn_momentum=bn_momentum)
    self.clf_conv1 = conv(
        512,
        512,
        kernel_size=3,
        stride=2,
        dilation=1,
        conv_type=self.NON_BLOCK_CONV_TYPE,
        D=D)
    self.clf_bn1 = get_norm(self.NORM_TYPE, 512, D, bn_momentum=bn_momentum)
    self.clf_conv2 = conv(
        512,
        config['clf_num_labels'],
        kernel_size=1,
        stride=1,
        dilation=1,
        conv_type=self.NON_BLOCK_CONV_TYPE,
        D=D)