Ejemplo n.º 1
0
    def __init__(self, nclasses):
        super().__init__()

        self.features = [hyper.R_IN, 40, 40, nclasses]
        self.bandwidths = [hyper.BANDWIDTH_IN, 32, 32, hyper.BANDWIDTH_OUT]
        self.linear1 = nn.Linear(nclasses + hyper.N_CATS, 50)
        self.linear2 = nn.Linear(50, 50)

        sequence = []

        # S2 layer
        grid = s2_equatorial_grid(max_beta=0, n_alpha=2 * self.bandwidths[0], n_beta=1)
        sequence.append(S2Convolution(self.features[0], self.features[1], self.bandwidths[0], self.bandwidths[1], grid))

        # SO3 layers
        for l in range(1, len(self.features) - 1):
            nfeature_in = self.features[l]
            nfeature_out = self.features[l + 1]
            b_in = self.bandwidths[l]
            b_out = self.bandwidths[l + 1]

            sequence.append(nn.BatchNorm3d(nfeature_in, affine=True))
            sequence.append(nn.ReLU())
            grid = so3_equatorial_grid(max_beta=0, max_gamma=0, n_alpha=2 * b_in, n_beta=1, n_gamma=1)
            sequence.append(SO3Convolution(nfeature_in, nfeature_out, b_in, b_out, grid))

        sequence.append(nn.BatchNorm3d(self.features[-1], affine=True))
        sequence.append(nn.ReLU())

        self.sequential = nn.Sequential(*sequence)
Ejemplo n.º 2
0
    def __init__(self, features=None, bandwidths=None):
        super().__init__()

        if bandwidths is None:
            bandwidths = [24, 24]
        if features is None:
            features = [3, 100]
        self.features = features
        self.bandwidths = bandwidths

        # define the number of layers.
        self.num_layers = 1

        assert len(self.bandwidths) == len(self.features)

        sequence = []

        # S2 layer
        # =====================If we could chose another gridding method=====================
        grid = s2_equatorial_grid(max_beta=0,
                                  n_alpha=2 * self.bandwidths[0],
                                  n_beta=1)
        sequence.append(
            S2Convolution(self.features[0],
                          int(self.features[1] / self.num_layers),
                          self.bandwidths[0], self.bandwidths[1], grid))
        sequence.append(nn.BatchNorm3d(self.features[-1], affine=True))
        sequence.append(nn.ReLU())

        self.sequential = nn.Sequential(*sequence)

        self.bn1 = nn.BatchNorm1d(self.features[-1])
Ejemplo n.º 3
0
    def __init__(self, nclasses, bw_in):
        super().__init__()

        self.features = [1,  100, 100, nclasses]
        self.bandwidths = [bw_in, 16, 10]

        assert len(self.bandwidths) == len(self.features) - 1

        sequence = []

        # S2 layer
        grid = s2_equatorial_grid(max_beta=0, n_alpha=2 * self.bandwidths[0], n_beta=1)
        sequence.append(S2Convolution(self.features[0], self.features[1], self.bandwidths[0], self.bandwidths[1], grid))

        # SO3 layers
        for l in range(1, len(self.features) - 2):
            nfeature_in = self.features[l]
            nfeature_out = self.features[l + 1]
            b_in = self.bandwidths[l]
            b_out = self.bandwidths[l + 1]

            sequence.append(nn.BatchNorm3d(nfeature_in, affine=True))
            sequence.append(nn.ReLU())
            grid = so3_equatorial_grid(max_beta=0, max_gamma=0, n_alpha=2 * b_in, n_beta=1, n_gamma=1)
            sequence.append(SO3Convolution(nfeature_in, nfeature_out, b_in, b_out, grid))

        sequence.append(nn.BatchNorm3d(self.features[-2], affine=True))
        sequence.append(nn.ReLU())

        self.sequential = nn.Sequential(*sequence)

        # Output layer
        output_features = self.features[-2]
        self.out_layer = nn.Linear(output_features, self.features[-1])
Ejemplo n.º 4
0
    def __init__(self, nclasses):
        super().__init__()

        self.features = [3, 128, nclasses]
        self.bandwidths = [24, 24]

        # define the number of layers.
        self.num_layers = 1

        assert len(self.bandwidths) == len(self.features) - 1

        sequence = []

        # S2 layer
        # =====================If we could chose another gridding method=====================
        grid = s2_equatorial_grid(max_beta=0,
                                  n_alpha=2 * self.bandwidths[0],
                                  n_beta=1)
        sequence.append(
            S2Convolution(self.features[0],
                          int(self.features[1] / self.num_layers),
                          self.bandwidths[0], self.bandwidths[1], grid))
        # sequence.append(S2Convolution(self.features[0], int(self.features[2] / self.num_layers), self.bandwidths[1],
        #                               self.bandwidths[2], grid))

        # SO3 layers
        # for l in range(1, len(self.features) - 2):
        #     nfeature_in = self.features[l]
        #     nfeature_out = self.features[l + 1]
        #     b_in = self.bandwidths[l]
        #     b_out = self.bandwidths[l + 1]
        #
        #     sequence.append(nn.BatchNorm3d(nfeature_in, affine=True))
        #     sequence.append(nn.ReLU())+
        #     grid = so3_equatorial_grid(max_beta=0, max_gamma=0, n_alpha=2 * b_in, n_beta=1, n_gamma=1)
        #     sequence.append(SO3Convolution(nfeature_in, nfeature_out, b_in, b_out, grid))

        sequence.append(nn.BatchNorm3d(self.features[-2], affine=True))
        sequence.append(nn.ReLU())

        self.sequential = nn.Sequential(*sequence)

        # Output layer
        output_features = self.features[-2]
        # self.out_layer = nn.Linear(2*output_features, self.features[-1]) #For ensemble learning
        self.out_layer_1 = nn.Linear(self.features[-2], self.features[-2])
        self.out_layer = nn.Linear(self.features[-2], self.features[-1])
        self.bn1 = nn.BatchNorm1d(self.features[-2])
        self.bn2 = nn.BatchNorm1d(self.features[-2])
        self.relu = nn.LeakyReLU()

        # self.point_net = PointNetEncoder(global_feat = False)
        self.point_net = get_model(combine_with_spherical_features=True)
        print("f**k")
Ejemplo n.º 5
0
    def __init__(self, nclasses, cfg):
        super().__init__()

        self.features = [1, 50, 50, 50, 256, 128, nclasses]
        self.bandwidths = [cfg.bw, cfg.bw, cfg.bw, cfg.bw]

        sequence = []

        # S2 layer
        grid = s2_equatorial_grid(max_beta=0,
                                  n_alpha=2 * self.bandwidths[0],
                                  n_beta=1)
        sequence.append(
            S2HConvolution(self.features[0], self.features[1],
                           self.bandwidths[0], self.bandwidths[1], grid))

        # SO3 layers
        for l in range(1, len(self.features) - 4):
            nfeature_in = self.features[l]
            nfeature_out = self.features[l + 1]
            b_in = self.bandwidths[l]
            b_out = self.bandwidths[l + 1]

            sequence.append(nn.BatchNorm3d(nfeature_in, affine=True))
            sequence.append(nn.ReLU())

            grid = so3_equatorial_grid(max_beta=0,
                                       max_gamma=0,
                                       n_alpha=2 * b_in,
                                       n_beta=1,
                                       n_gamma=1)
            sequence.append(
                SO3Convolution(nfeature_in, nfeature_out, b_in, b_out, grid))

        sequence.append(nn.BatchNorm3d(self.features[3], affine=True))
        sequence.append(nn.ReLU())

        self.sequential = nn.Sequential(*sequence)

        fcs = []
        # Output layer
        for i in range(3, len(self.features) - 1):
            ch_in = self.features[i]
            ch_out = self.features[i + 1]
            fcs.append(nn.Linear(ch_in, ch_out))
            if i < len(self.features) - 2:
                fcs.append(nn.BatchNorm1d(ch_out))
                fcs.append(nn.ReLU())
        self.out_layer = nn.Sequential(*fcs)
Ejemplo n.º 6
0
    def build_conv_block(self, b_dim, f_dim, norm_layer, activation, use_dropout, use_activation):
        conv_block = []

        grid = s2_equatorial_grid(max_beta=0, n_alpha=3, n_beta=3)
        conv_block.append(S2Convolution(f_dim, f_dim, b_dim, b_dim, grid))

        #grid = so3_equatorial_grid(max_beta=0, max_gamma=0, n_alpha=1, n_beta=1, n_gamma=1)
        #conv_block.append(SO3Convolution(f_dim, f_dim, b_dim, b_dim, grid))
        conv_block += [norm_layer(f_dim)]

        if use_activation:
            conv_block += [activation]

        if use_dropout:
            conv_block += [nn.Dropout(0.5)]

        return nn.Sequential(*conv_block)
Ejemplo n.º 7
0
    def __init__(self, out_channels=64, dropout_ratio=None):
        super().__init__()

        self.features = [3, 100, 100, out_channels]
        self.bandwidths = [init_bandwidth, 16, 10]

        assert len(self.bandwidths) == len(self.features) - 1

        sequence = []

        # S2 layer
        # =====================If we could chose another gridding method=====================
        grid = s2_equatorial_grid(max_beta=0, n_alpha=2 * self.bandwidths[0], n_beta=1)
        sequence.append(S2Convolution(self.features[0], self.features[1], self.bandwidths[0], self.bandwidths[1], grid))

        # SO3 layers
        for l in range(1, len(self.features) - 2):
            nfeature_in = self.features[l]
            nfeature_out = self.features[l + 1]
            b_in = self.bandwidths[l]
            b_out = self.bandwidths[l + 1]

            sequence.append(nn.BatchNorm3d(nfeature_in, affine=True))
            sequence.append(nn.ReLU())
            grid = so3_equatorial_grid(max_beta=0, max_gamma=0, n_alpha=2 * b_in, n_beta=1, n_gamma=1)
            sequence.append(SO3Convolution(nfeature_in, nfeature_out, b_in, b_out, grid))

        sequence.append(nn.BatchNorm3d(self.features[-2], affine=True))
        sequence.append(nn.ReLU())

        self.sequential = nn.Sequential(*sequence)

        # Output layer
        output_features = self.features[-2]
        self.out_layer = nn.Linear(output_features, self.features[-1])
        self.bn = nn.BatchNorm1d(self.features[-1])
        if dropout_ratio != 0:
            self.dropout = nn.Dropout(p=dropout_ratio)
            print("Spherical models use dropout.")
        else:
            self.dropout = None
Ejemplo n.º 8
0
    def __init__(self, nclasses, cfg):
        super().__init__()
        self.features = [1, 40, 40, nclasses]
        self.bandwidths = [
            cfg.bw,
        ] * len(self.features)
        self.linear1 = nn.Linear(nclasses + 16, 50)
        self.linear2 = nn.Linear(50, 50)

        sequence = []
        # S2 layer
        grid = s2_equatorial_grid(max_beta=0,
                                  n_alpha=2 * self.bandwidths[0],
                                  n_beta=1)
        sequence.append(
            S2HConvolution(self.features[0], self.features[1],
                           self.bandwidths[0], self.bandwidths[1], grid))

        # SO3 layers
        for l in range(1, len(self.features) - 1):
            nfeature_in = self.features[l]
            nfeature_out = self.features[l + 1]
            b_in = self.bandwidths[l]
            b_out = self.bandwidths[l + 1]

            sequence.append(nn.BatchNorm3d(nfeature_in, affine=True))
            sequence.append(nn.ReLU())

            grid = so3_equatorial_grid(max_beta=0,
                                       max_gamma=0,
                                       n_alpha=2 * b_in,
                                       n_beta=1,
                                       n_gamma=1)
            sequence.append(
                SO3Convolution(nfeature_in, nfeature_out, b_in, b_out, grid))

        sequence.append(nn.BatchNorm3d(self.features[-1], affine=True))
        sequence.append(nn.ReLU())
        sequence.append(GammaMean(2 * self.bandwidths[-1]))

        self.sequential = nn.Sequential(*sequence)
Ejemplo n.º 9
0
    def __init__(self):
        super().__init__()

        self.features = [3, 25, 25, 25, 36]
        self.bandwidths = [32, 32, 32, 32, 32]

        # S2 layer
        grid = s2_equatorial_grid(max_beta=0,
                                  n_alpha=2 * self.bandwidths[0],
                                  n_beta=1)
        self.s2_conv = S2Convolution(self.features[0], self.features[1],
                                     self.bandwidths[0], self.bandwidths[1],
                                     grid)
        self.bn1 = nn.BatchNorm3d(self.features[1], affine=True)
        self.relu1 = nn.ReLU()

        # SO3 layers
        b_in = 32
        b_out = 32
        grid3 = so3_equatorial_grid(max_beta=0,
                                    max_gamma=0,
                                    n_alpha=2 * 32,
                                    n_beta=1,
                                    n_gamma=1)
        self.so3_layer1 = SO3Convolution(self.features[1], self.features[2],
                                         b_in, b_out, grid3)
        self.bn2 = nn.BatchNorm3d(self.features[1] + self.features[2],
                                  affine=True)
        self.relu2 = nn.ReLU()
        self.so3_layer2 = SO3Convolution(self.features[1] + self.features[2],
                                         self.features[3], b_in, b_out, grid3)
        self.bn3 = nn.BatchNorm3d(self.features[1] + self.features[2] +
                                  self.features[3],
                                  affine=True)
        self.relu3 = nn.ReLU()
        self.so3_layer3 = SO3Convolution(
            self.features[1] + self.features[2] + self.features[3],
            self.features[4], b_in, b_out, grid3)
        self.bn4 = nn.BatchNorm3d(self.features[4], affine=True)
        self.relu4 = nn.ReLU()
Ejemplo n.º 10
0
    def __init__(self, bandwidths, features, use_equatorial_grid):
        super().__init__()

        self.bandwidths = bandwidths
        self.features = features

        assert len(self.bandwidths) == len(self.features)

        sequence = []

        # S2 layer
        grid_s2 = s2_equatorial_grid(
            max_beta=0, n_alpha=2 * self.bandwidths[0],
            n_beta=1) if use_equatorial_grid else s2_near_identity_grid(
                max_beta=np.pi / 8, n_alpha=8, n_beta=3)
        sequence.append(
            S2Convolution(self.features[0], self.features[1],
                          self.bandwidths[0], self.bandwidths[1], grid_s2))

        sequence.append(nn.BatchNorm3d(self.features[-1], affine=True))
        sequence.append(nn.ReLU())

        self.sequential = nn.Sequential(*sequence)
Ejemplo n.º 11
0
Where Phi is a composition of a S^2 convolution and a SO(3) convolution

For simplicity, R is a rotation around the Z axis.
'''

#pylint: disable=C,R,E1101,W0621
import torch

from s2cnn import s2_equatorial_grid, S2Convolution
from s2cnn import so3_equatorial_grid, SO3Convolution

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

# Define the two convolutions
s2_grid = s2_equatorial_grid(max_beta=0, n_alpha=64, n_beta=1)
s2_conv = S2Convolution(nfeature_in=12,
                        nfeature_out=15,
                        b_in=64,
                        b_out=32,
                        grid=s2_grid)
s2_conv.to(device)

so3_grid = so3_equatorial_grid(max_beta=0,
                               max_gamma=0,
                               n_alpha=64,
                               n_beta=1,
                               n_gamma=1)
so3_conv = SO3Convolution(nfeature_in=15,
                          nfeature_out=21,
                          b_in=32,
Ejemplo n.º 12
0
    def __init__(self, params):
        super(S2ConvNet, self).__init__()

        grid_s2 = s2_equatorial_grid()
        if (params.so3grid):
            grid_so3 = so3_equatorial_grid()
        else:
            grid_so3 = so3_near_identity_grid()

        self.conv1 = S2Convolution(nfeature_in=34,
                                   nfeature_out=params.s2_1,
                                   b_in=13,
                                   b_out=10,
                                   grid=grid_s2)

        self.conv2 = SO3Convolution(nfeature_in=params.s2_1,
                                    nfeature_out=params.so3_2,
                                    b_in=10,
                                    b_out=8,
                                    grid=grid_so3)

        self.conv3 = SO3Convolution(nfeature_in=params.so3_2,
                                    nfeature_out=params.so3_3,
                                    b_in=8,
                                    b_out=5,
                                    grid=grid_so3)

        self.conv4 = SO3Convolution(nfeature_in=params.so3_3,
                                    nfeature_out=params.so3_4,
                                    b_in=5,
                                    b_out=3,
                                    grid=grid_so3)

        self.conv5 = SO3Convolution(nfeature_in=params.so3_4,
                                    nfeature_out=params.so3_5,
                                    b_in=3,
                                    b_out=2,
                                    grid=grid_so3)

        last_entry = params.so3_3
        if (params.if_so3_4) and (params.if_so3_5):
            last_entry = params.so3_5
        elif (params.if_so3_4):
            last_entry = params.so3_4

        self.fc_layer = nn.Linear(last_entry, params.fc1)
        self.fc_layer_2 = nn.Linear(params.fc1, params.fc2)
        self.fc_layer_3 = nn.Linear(params.fc2, params.fc3)
        self.fc_layer_4 = nn.Linear(params.fc3, params.fc4)
        self.fc_layer_5 = nn.Linear(params.fc4, params.fc5)

        self.norm_layer_2d_1 = nn.BatchNorm2d(34)
        self.norm_1d_1 = nn.BatchNorm1d(params.fc1)
        self.norm_1d_2 = nn.BatchNorm1d(params.fc2)
        self.norm_1d_3 = nn.BatchNorm1d(params.fc3)
        self.norm_1d_4 = nn.BatchNorm1d(params.fc4)
        self.norm_1d_5 = nn.BatchNorm1d(params.fc5)
        self.norm_1d_6 = nn.BatchNorm1d(1)

        last_fc_entry = params.fc3
        if params.if_fc_4 and params.if_fc_5:
            last_fc_entry = params.fc5
        elif params.if_fc_4:
            last_fc_entry = params.fc4

        #print(last_fc_entry, params.if_fc_4, params.if_fc_5, params.fc3,params.fc4,params.fc5, "Aoba=================")

        self.fc_layer_6 = nn.Linear(last_fc_entry, 1)

        self.do1 = nn.Dropout(params.do1r)
        self.do2 = nn.Dropout(params.do2r)
        self.do3 = nn.Dropout(params.do3r)
        self.do4 = nn.Dropout(params.do4r)
        self.do5 = nn.Dropout(params.do5r)

        self.if_so3_4 = params.if_so3_4
        self.if_so3_5 = params.if_so3_5
        self.if_fc_4 = params.if_fc_4
        self.if_fc_5 = params.if_fc_5
Ejemplo n.º 13
0
    def __init__(self, final_output_dim, sconv_dims, bandwidths
                 #BANDWIDTH_IN,
                 #BANDWIDTH_OUT,
                 #R_IN=64,
                 #sconv_intermed_dims
                 ):
        super().__init__()

        self.per_point_dims = [32, 32]
        #self.features = [R_IN, 40, 40, dim_output]
        self.features = list(sconv_dims)
        self.bandwidths = bandwidths  #[BANDWIDTH_IN, 32, 32, BANDWIDTH_OUT]
        #self.linear1 = nn.Linear(dim_output, 50)
        #self.linear2 = nn.Linear(50, 50)

        print('Building PRIN-based AE Encoder')
        print('\tFeatures:', self.features)
        print('\tInput Dim:', final_output_dim)
        print('\tBandwidths:', self.bandwidths)

        ### SConv module ###
        sequence = []
        # S2 layer
        grid = s2_equatorial_grid(max_beta=0,
                                  n_alpha=2 * self.bandwidths[0],
                                  n_beta=1)
        sequence.append(
            S2Convolution(self.features[0], self.features[1],
                          self.bandwidths[0], self.bandwidths[1], grid))
        # SO3 layers
        for l in range(1, len(self.features) - 1):
            nfeature_in = self.features[l]
            nfeature_out = self.features[l + 1]
            b_in = self.bandwidths[l]
            b_out = self.bandwidths[l + 1]
            sequence.append(nn.BatchNorm3d(nfeature_in, affine=True))
            sequence.append(nn.ReLU())
            grid = so3_equatorial_grid(max_beta=0,
                                       max_gamma=0,
                                       n_alpha=2 * b_in,
                                       n_beta=1,
                                       n_gamma=1)
            sequence.append(
                SO3Convolution(nfeature_in, nfeature_out, b_in, b_out, grid))
        # Final BN and non-linearity
        sequence.append(nn.BatchNorm3d(self.features[-1], affine=True))
        sequence.append(nn.ReLU())
        self.sequential = nn.Sequential(*sequence)

        # TODO maybe just operate on the voxel and pool that directly, without converting to a PC first?

        # Per-point processor
        self.per_point_processor = nn.Sequential(
            nn.Conv1d(self.features[-1], self.per_point_dims[0], 1,
                      bias=False), nn.BatchNorm1d(self.per_point_dims[0]),
            nn.ReLU(False),
            nn.Conv1d(self.per_point_dims[0],
                      self.per_point_dims[1],
                      1,
                      bias=False), nn.BatchNorm1d(self.per_point_dims[1]),
            nn.ReLU(False))
        # Final pooled processor
        self.pooled_processor_dims = [
            2 * self.per_point_dims[-1], final_output_dim, final_output_dim
        ]
        self.pooled_processor = nn.Sequential(
            nn.Linear(self.pooled_processor_dims[0],
                      self.pooled_processor_dims[1]),
            nn.BatchNorm1d(self.pooled_processor_dims[1]),
            nn.ReLU(),
            nn.Linear(self.pooled_processor_dims[1],
                      self.pooled_processor_dims[2]),
        )

        #self.protlin = nn.Linear(2*self.features[-1], final_output_dim)
        self.protlin = nn.Sequential(
            nn.Linear(2 * self.features[-1], 2 * final_output_dim),
            nn.BatchNorm1d(2 * final_output_dim), nn.ReLU(),
            nn.Linear(final_output_dim * 2, final_output_dim))