Ejemplo n.º 1
0
    def __init__(self,
                 inplanes,
                 planes,
                 stride=1,
                 dilation=1,
                 downsample=None,
                 bn_momentum=0.1,
                 D=3):
        super(BasicBlockBase, self).__init__()

        self.conv1 = ME.MinkowskiConvolution(
            inplanes, planes, kernel_size=3, stride=stride, dimension=D)
        self.norm1 = get_norm(self.NORM_TYPE, planes, bn_momentum=bn_momentum, D=D)
        self.conv2 = ME.MinkowskiConvolution(
            planes,
            planes,
            kernel_size=3,
            stride=1,
            dilation=dilation,
            bias=False,
            dimension=D)
        self.norm2 = get_norm(self.NORM_TYPE, planes, bn_momentum=bn_momentum, D=D)
        self.downsample = downsample
Ejemplo n.º 2
0
    def __init__(self,
                 in_channels=3,
                 out_channels=32,
                 bn_momentum=0.1,
                 normalize_feature=None,
                 conv1_kernel_size=None,
                 D=3):
        ME.MinkowskiNetwork.__init__(self, D)
        NORM_TYPE = self.NORM_TYPE
        BLOCK_NORM_TYPE = self.BLOCK_NORM_TYPE
        CHANNELS = self.CHANNELS
        TR_CHANNELS = self.TR_CHANNELS
        self.normalize_feature = normalize_feature
        self.conv1 = ME.MinkowskiConvolution(in_channels=in_channels,
                                             out_channels=CHANNELS[1],
                                             kernel_size=conv1_kernel_size,
                                             stride=1,
                                             dilation=1,
                                             bias=False,
                                             dimension=D)
        self.norm1 = get_norm(NORM_TYPE,
                              CHANNELS[1],
                              bn_momentum=bn_momentum,
                              D=D)

        self.block1 = get_block(BLOCK_NORM_TYPE,
                                CHANNELS[1],
                                CHANNELS[1],
                                bn_momentum=bn_momentum,
                                D=D)

        self.conv2 = ME.MinkowskiConvolution(in_channels=CHANNELS[1],
                                             out_channels=CHANNELS[2],
                                             kernel_size=3,
                                             stride=2,
                                             dilation=1,
                                             bias=False,
                                             dimension=D)
        self.norm2 = get_norm(NORM_TYPE,
                              CHANNELS[2],
                              bn_momentum=bn_momentum,
                              D=D)

        self.block2 = get_block(BLOCK_NORM_TYPE,
                                CHANNELS[2],
                                CHANNELS[2],
                                bn_momentum=bn_momentum,
                                D=D)

        self.conv3 = ME.MinkowskiConvolution(in_channels=CHANNELS[2],
                                             out_channels=CHANNELS[3],
                                             kernel_size=3,
                                             stride=2,
                                             dilation=1,
                                             bias=False,
                                             dimension=D)
        self.norm3 = get_norm(NORM_TYPE,
                              CHANNELS[3],
                              bn_momentum=bn_momentum,
                              D=D)

        self.block3 = get_block(BLOCK_NORM_TYPE,
                                CHANNELS[3],
                                CHANNELS[3],
                                bn_momentum=bn_momentum,
                                D=D)

        self.conv4 = ME.MinkowskiConvolution(in_channels=CHANNELS[3],
                                             out_channels=CHANNELS[4],
                                             kernel_size=3,
                                             stride=2,
                                             dilation=1,
                                             bias=False,
                                             dimension=D)
        self.norm4 = get_norm(NORM_TYPE,
                              CHANNELS[4],
                              bn_momentum=bn_momentum,
                              D=D)

        self.block4 = get_block(BLOCK_NORM_TYPE,
                                CHANNELS[4],
                                CHANNELS[4],
                                bn_momentum=bn_momentum,
                                D=D)

        self.conv4_tr = ME.MinkowskiConvolutionTranspose(
            in_channels=CHANNELS[4],
            out_channels=TR_CHANNELS[4],
            kernel_size=3,
            stride=2,
            dilation=1,
            bias=False,
            dimension=D)
        self.norm4_tr = get_norm(NORM_TYPE,
                                 TR_CHANNELS[4],
                                 bn_momentum=bn_momentum,
                                 D=D)

        self.block4_tr = get_block(BLOCK_NORM_TYPE,
                                   TR_CHANNELS[4],
                                   TR_CHANNELS[4],
                                   bn_momentum=bn_momentum,
                                   D=D)

        self.conv3_tr = ME.MinkowskiConvolutionTranspose(
            in_channels=CHANNELS[3] + TR_CHANNELS[4],
            out_channels=TR_CHANNELS[3],
            kernel_size=3,
            stride=2,
            dilation=1,
            bias=False,
            dimension=D)
        self.norm3_tr = get_norm(NORM_TYPE,
                                 TR_CHANNELS[3],
                                 bn_momentum=bn_momentum,
                                 D=D)

        self.block3_tr = get_block(BLOCK_NORM_TYPE,
                                   TR_CHANNELS[3],
                                   TR_CHANNELS[3],
                                   bn_momentum=bn_momentum,
                                   D=D)

        self.conv2_tr = ME.MinkowskiConvolutionTranspose(
            in_channels=CHANNELS[2] + TR_CHANNELS[3],
            out_channels=TR_CHANNELS[2],
            kernel_size=3,
            stride=2,
            dilation=1,
            bias=False,
            dimension=D)
        self.norm2_tr = get_norm(NORM_TYPE,
                                 TR_CHANNELS[2],
                                 bn_momentum=bn_momentum,
                                 D=D)

        self.block2_tr = get_block(BLOCK_NORM_TYPE,
                                   TR_CHANNELS[2],
                                   TR_CHANNELS[2],
                                   bn_momentum=bn_momentum,
                                   D=D)

        self.conv1_tr = ME.MinkowskiConvolution(in_channels=CHANNELS[1] +
                                                TR_CHANNELS[2],
                                                out_channels=TR_CHANNELS[1],
                                                kernel_size=1,
                                                stride=1,
                                                dilation=1,
                                                bias=False,
                                                dimension=D)

        # self.block1_tr = BasicBlockBN(TR_CHANNELS[1], TR_CHANNELS[1], bn_momentum=bn_momentum, D=D)

        self.final = ME.MinkowskiConvolution(in_channels=TR_CHANNELS[1],
                                             out_channels=out_channels,
                                             kernel_size=1,
                                             stride=1,
                                             dilation=1,
                                             bias=True,
                                             dimension=D)
Ejemplo n.º 3
0
    def __init__(self,
                 in_channels=3,
                 out_channels=32,
                 bn_momentum=0.1,
                 D=3,
                 config=None):
        ME.MinkowskiNetwork.__init__(self, D)
        NORM_TYPE = self.NORM_TYPE
        bn_momentum = config.bn_momentum
        CHANNELS = self.CHANNELS
        TR_CHANNELS = self.TR_CHANNELS
        self.normalize_feature = config.normalize_feature
        self.conv1 = ME.MinkowskiConvolution(
            in_channels=in_channels,
            out_channels=CHANNELS[1],
            kernel_size=config.conv1_kernel_size,
            stride=1,
            dilation=1,
            bias=False,
            dimension=D)
        self.norm1 = get_norm(NORM_TYPE,
                              CHANNELS[1],
                              bn_momentum=bn_momentum,
                              D=D)

        self.conv2 = ME.MinkowskiConvolution(in_channels=CHANNELS[1],
                                             out_channels=CHANNELS[2],
                                             kernel_size=3,
                                             stride=2,
                                             dilation=1,
                                             bias=False,
                                             dimension=D)
        self.norm2 = get_norm(NORM_TYPE,
                              CHANNELS[2],
                              bn_momentum=bn_momentum,
                              D=D)

        self.conv3 = ME.MinkowskiConvolution(in_channels=CHANNELS[2],
                                             out_channels=CHANNELS[3],
                                             kernel_size=3,
                                             stride=2,
                                             dilation=1,
                                             bias=False,
                                             dimension=D)
        self.norm3 = get_norm(NORM_TYPE,
                              CHANNELS[3],
                              bn_momentum=bn_momentum,
                              D=D)

        self.conv4 = ME.MinkowskiConvolution(in_channels=CHANNELS[3],
                                             out_channels=CHANNELS[4],
                                             kernel_size=3,
                                             stride=2,
                                             dilation=1,
                                             bias=False,
                                             dimension=D)
        self.norm4 = get_norm(NORM_TYPE,
                              CHANNELS[4],
                              bn_momentum=bn_momentum,
                              D=D)

        self.conv5 = ME.MinkowskiConvolution(in_channels=CHANNELS[4],
                                             out_channels=CHANNELS[5],
                                             kernel_size=3,
                                             stride=2,
                                             dilation=1,
                                             bias=False,
                                             dimension=D)
        self.norm5 = get_norm(NORM_TYPE,
                              CHANNELS[5],
                              bn_momentum=bn_momentum,
                              D=D)

        self.conv5_tr = ME.MinkowskiConvolutionTranspose(
            in_channels=CHANNELS[5],
            out_channels=TR_CHANNELS[5],
            kernel_size=3,
            stride=2,
            dilation=1,
            bias=False,
            dimension=D)
        self.norm5_tr = get_norm(NORM_TYPE,
                                 TR_CHANNELS[5],
                                 bn_momentum=bn_momentum,
                                 D=D)

        self.conv4_tr = ME.MinkowskiConvolutionTranspose(
            in_channels=CHANNELS[4] + TR_CHANNELS[5],
            out_channels=TR_CHANNELS[4],
            kernel_size=3,
            stride=2,
            dilation=1,
            bias=False,
            dimension=D)
        self.norm4_tr = get_norm(NORM_TYPE,
                                 TR_CHANNELS[4],
                                 bn_momentum=bn_momentum,
                                 D=D)

        self.conv3_tr = ME.MinkowskiConvolutionTranspose(
            in_channels=CHANNELS[3] + TR_CHANNELS[4],
            out_channels=TR_CHANNELS[3],
            kernel_size=3,
            stride=2,
            dilation=1,
            bias=False,
            dimension=D)
        self.norm3_tr = get_norm(NORM_TYPE,
                                 TR_CHANNELS[3],
                                 bn_momentum=bn_momentum,
                                 D=D)

        self.conv2_tr = ME.MinkowskiConvolutionTranspose(
            in_channels=CHANNELS[2] + TR_CHANNELS[3],
            out_channels=TR_CHANNELS[2],
            kernel_size=3,
            stride=2,
            dilation=1,
            bias=False,
            dimension=D)
        self.norm2_tr = get_norm(NORM_TYPE,
                                 TR_CHANNELS[2],
                                 bn_momentum=bn_momentum,
                                 D=D)

        self.conv1_tr = ME.MinkowskiConvolution(in_channels=CHANNELS[1] +
                                                TR_CHANNELS[2],
                                                out_channels=TR_CHANNELS[1],
                                                kernel_size=1,
                                                stride=1,
                                                dilation=1,
                                                bias=True,
                                                dimension=D)
Ejemplo n.º 4
0
    def __init__(self,
                 in_channels=3,
                 out_channels=32,
                 bn_momentum=0.1,
                 normalize_feature=None,
                 conv1_kernel_size=None,
                 D=3):
        super(SimpleNet, self).__init__(D)
        NORM_TYPE = self.NORM_TYPE
        CHANNELS = self.CHANNELS
        TR_CHANNELS = self.TR_CHANNELS
        self.normalize_feature = normalize_feature
        self.conv1 = ME.MinkowskiConvolution(in_channels=in_channels,
                                             out_channels=CHANNELS[1],
                                             kernel_size=conv1_kernel_size,
                                             stride=1,
                                             dilation=1,
                                             bias=False,
                                             dimension=D)
        self.norm1 = get_norm(NORM_TYPE,
                              CHANNELS[1],
                              bn_momentum=bn_momentum,
                              D=D)

        self.conv2 = ME.MinkowskiConvolution(in_channels=CHANNELS[1],
                                             out_channels=CHANNELS[2],
                                             kernel_size=3,
                                             stride=2,
                                             dilation=1,
                                             bias=False,
                                             dimension=D)
        self.norm2 = get_norm(NORM_TYPE,
                              CHANNELS[2],
                              bn_momentum=bn_momentum,
                              D=D)

        self.conv3 = ME.MinkowskiConvolution(in_channels=CHANNELS[2],
                                             out_channels=CHANNELS[3],
                                             kernel_size=3,
                                             stride=2,
                                             dilation=1,
                                             bias=False,
                                             dimension=D)
        self.norm3 = get_norm(NORM_TYPE,
                              CHANNELS[3],
                              bn_momentum=bn_momentum,
                              D=D)

        self.conv3_tr = ME.MinkowskiConvolutionTranspose(
            in_channels=CHANNELS[3],
            out_channels=TR_CHANNELS[3],
            kernel_size=3,
            stride=2,
            dilation=1,
            bias=False,
            dimension=D)
        self.norm3_tr = get_norm(NORM_TYPE,
                                 TR_CHANNELS[3],
                                 bn_momentum=bn_momentum,
                                 D=D)

        self.conv2_tr = ME.MinkowskiConvolutionTranspose(
            in_channels=CHANNELS[2] + TR_CHANNELS[3],
            out_channels=TR_CHANNELS[2],
            kernel_size=3,
            stride=2,
            dilation=1,
            bias=False,
            dimension=D)
        self.norm2_tr = get_norm(NORM_TYPE,
                                 TR_CHANNELS[2],
                                 bn_momentum=bn_momentum,
                                 D=D)

        self.conv1_tr = ME.MinkowskiConvolution(in_channels=CHANNELS[1] +
                                                TR_CHANNELS[2],
                                                out_channels=TR_CHANNELS[1],
                                                kernel_size=3,
                                                stride=1,
                                                dilation=1,
                                                bias=False,
                                                dimension=D)
        self.norm1_tr = get_norm(NORM_TYPE,
                                 TR_CHANNELS[1],
                                 bn_momentum=bn_momentum,
                                 D=D)

        self.final = ME.MinkowskiConvolution(in_channels=TR_CHANNELS[1],
                                             out_channels=out_channels,
                                             kernel_size=1,
                                             stride=1,
                                             dilation=1,
                                             bias=True,
                                             dimension=D)