def __init__(self): super(Net, self).__init__() self.szp = SparseZeroPad2d(1) self.bn = nn.BatchNorm1d(3) self.cv1 = spconv.SparseConv2d(3, 3, 5, 5) self.ss1 = SparseScale2d(5) self.cv2 = spconv.SparseConv2d(3, 3, 5, 5) self.ss2 = SparseScale2d(5) self.mp = spconv.SparseMaxPool2d(2, 2) self.td = spconv.ToDense() self.net = spconv.SparseSequential( SparseZeroPad2d(1), nn.BatchNorm1d(3), spconv.SparseConv2d(3, 32, 3, 1), nn.ReLU(), spconv.SparseConv2d(32, 64, 3, 1), nn.ReLU(), spconv.SparseMaxPool2d(2, 2), spconv.ToDense(), ) self.fc1 = nn.Linear(10816, 128) self.fc2 = nn.Linear(128, 10) self.dropout1 = nn.Dropout2d(0.25) self.dropout2 = nn.Dropout2d(0.5)
def __init__(self, in_planes, pointwise_layers=2): super(Pointwise2DForZ, self).__init__() self.log = logging.getLogger(__name__) layers = [] n_layers = pointwise_layers if not isinstance(n_layers, int) or n_layers < 2: raise ValueError("n_layers must be integer >= 2") increment = int(round(float(in_planes) / float(n_layers - 1))) out = in_planes for i in range(n_layers): if i == (n_layers - 1): out = 1 elif i == 0: out = in_planes else: out -= increment self.log.debug( "appending layer {0} -> {1} planes, kernel size of {2}, padding of {3}" .format(in_planes, out, 1, 0)) layers.append(spconv.SparseConv2d(in_planes, out, 1, 1, 0)) layers.append(nn.BatchNorm1d(out)) layers.append(nn.ReLU()) in_planes = out layers.append(spconv.ToDense()) self.network = spconv.SparseSequential(*layers)
def __init__(self, shape): super().__init__() self.net = spconv.SparseSequential( spconv.SparseConv3d(1, 32, 4), nn.LeakyReLU(), spconv.SparseConv3d(32, 32, 4), nn.LeakyReLU(), spconvpool.SparseMaxPool(3, 5), spconv.SparseConv3d(32, 32, 4), nn.LeakyReLU(), spconv.SparseConv3d(32, 32, 4), nn.LeakyReLU(), spconvpool.SparseMaxPool(3, 5), spconv.SparseConv3d(32, 32, 4), nn.LeakyReLU(), spconv.SparseConv3d(32, 32, 4), nn.LeakyReLU(), spconv.SparseConv3d(32, 1, 4), nn.LeakyReLU(), spconvpool.SparseMaxPool(3, 5), spconv.ToDense(), nn.Flatten(), nn.Linear(14688, 1000), nn.LeakyReLU(), nn.Linear(1000, 1000), nn.LeakyReLU(), nn.Linear(1000, 1), nn.LeakyReLU(), # nn.Sigmoid() ) self.shape = shape
def __init__(self): super().__init__() self.net = spconv.SparseSequential( spconv.SubMConv3d(3, 8, 3, indice_key="subm1", padding=1, use_hash=False), nn.BatchNorm1d(8), nn.ReLU(), spconv.SparseConv3d(8, 16, 3, stride=2, padding=1, use_hash=False), nn.BatchNorm1d(16), nn.ReLU(), spconv.SubMConv3d(16, 16, 3, indice_key="subm2", padding=1, use_hash=False), nn.BatchNorm1d(16), nn.ReLU(), spconv.SparseConv3d(16, 32, 3, stride=2, padding=1, use_hash=False), nn.BatchNorm1d(32), nn.ReLU(), spconv.SubMConv3d(32, 32, 3, indice_key="subm3", padding=1, use_hash=False), nn.BatchNorm1d(32), nn.ReLU(), spconv.SparseConv3d(32, 64, 3, stride=2, padding=1, use_hash=False), nn.BatchNorm1d(64), nn.ReLU(), spconv.SubMConv3d(64, 64, 3, indice_key="subm4", padding=1, use_hash=False), nn.BatchNorm1d(64), nn.ReLU(), spconv.ToDense() # [64, 2, 8, 8] ) self.linear = nn.Linear(64 * 2 * 8 * 8, 4)
def __init__(self, in_planes, kernel_size=3, n_layers=2, pointwise_layers=0, pointwise_factor=0.8, todense=True): super(SparseConv2DForZ, self).__init__() self.log = logging.getLogger(__name__) layers = [] if pointwise_layers > 0: if n_layers == 1: raise ValueError( "n_layers must be > 1 if using pointwise convolution") increment = int( round( int(round(in_planes * pointwise_factor)) / float(n_layers - 1))) else: increment = int(round(float(in_planes) / float(n_layers))) if kernel_size % 2 != 1: raise ValueError("Kernel size must be an odd integer") if not isinstance(n_layers, int) or n_layers < 1: raise ValueError("n_layers must be integer >= 1") out = in_planes reset_kernel = False orig_kernel = kernel_size for i in range(n_layers): if i == (n_layers - 1): out = 1 else: out -= increment if i == 0 and pointwise_layers > 0: if pointwise_factor > 0: out = int(round(pointwise_factor * in_planes)) pd = int((kernel_size - 1) / 2) if pointwise_layers > 0: pd = 0 kernel_size = 1 pointwise_layers -= 1 if pointwise_layers == 0: reset_kernel = True self.log.debug( "appending layer {0} -> {1} planes, kernel size of {2}, padding of {3}" .format(in_planes, out, kernel_size, pd)) layers.append( spconv.SparseConv2d(in_planes, out, kernel_size, 1, pd)) if reset_kernel: kernel_size = orig_kernel reset_kernel = False if i != (n_layers - 1): layers.append(nn.BatchNorm1d(out)) layers.append(nn.ReLU()) in_planes = out if kernel_size > 1: kernel_size -= 2 if todense: layers.append(spconv.ToDense()) self.network = spconv.SparseSequential(*layers)
def _make_deblock(self, num_out_filters, idx): print("CUSTOM MAKE DEBLOCK") stride = self._upsample_strides[idx - self._upsample_start_idx] if self._use_norm: if self._use_groupnorm: SparseBatchNorm2d = change_default_args( num_groups=self._num_groups, eps=1e-3)(GroupNorm) DenseBatchNorm2d = change_default_args( num_groups=self._num_groups, eps=1e-3)(GroupNorm) else: SparseBatchNorm2d = change_default_args(eps=1e-3, momentum=0.01)( nn.BatchNorm1d) DenseBatchNorm2d = change_default_args( eps=1e-3, momentum=0.01)(nn.BatchNorm2d) SparseConvTranspose2d = change_default_args(bias=False)( spconv.SparseConvTranspose2d) DenseConvTranspose2d = change_default_args(bias=False)( nn.ConvTranspose2d) else: SparseBatchNorm2d = Empty DenseBatchNorm2d = Empty SparseConvTranspose2d = change_default_args(bias=True)( spconv.SparseConvTranspose2d) DenseConvTranspose2d = change_default_args(bias=True)( nn.ConvTranspose2d) stride = np.round(stride).astype(np.int64) if (idx <= LAST_SPARSE_IDX): deblock = spconv.SparseSequential( SparseConvTranspose2d( num_out_filters, self._num_upsample_filters[idx - self._upsample_start_idx], stride, stride=stride), SparseBatchNorm2d( self._num_upsample_filters[idx - self._upsample_start_idx]), nn.ReLU(), spconv.ToDense()) else: stride = np.round(stride).astype(np.int64) deblock = Sequential( DenseConvTranspose2d( num_out_filters, self._num_upsample_filters[idx - self._upsample_start_idx], stride, stride=stride), DenseBatchNorm2d( self._num_upsample_filters[idx - self._upsample_start_idx]), nn.ReLU(), ) return deblock
def _make_deblock(self, num_out_filters, idx): stride = self._upsample_strides[idx - self._upsample_start_idx] if self._use_norm: if self._use_groupnorm: BatchNorm2d = change_default_args(num_groups=self._num_groups, eps=1e-3)(GroupNorm) else: BatchNorm2d = change_default_args(eps=1e-3, momentum=0.01)( nn.BatchNorm1d) Conv2d = change_default_args(bias=False)(spconv.SparseConv2d) ConvTranspose2d = change_default_args(bias=False)( spconv.SparseConvTranspose2d) else: BatchNorm2d = Empty Conv2d = change_default_args(bias=True)(spconv.SparseConv2d) ConvTranspose2d = change_default_args(bias=True)( spconv.SparseConvTranspose2d) if stride >= 1: stride = np.round(stride).astype(np.int64) print("DEBLOCK CONV_TRANSPOSE STRIDE:", stride) deblock = spconv.SparseSequential( # PrintLayer(stride), ConvTranspose2d( num_out_filters, self._num_upsample_filters[idx - self._upsample_start_idx], stride, stride=stride), # PrintLayer(stride), BatchNorm2d( self._num_upsample_filters[idx - self._upsample_start_idx] ), nn.ReLU(), ) else: stride = np.round(1 / stride).astype(np.int64) print("DEBLOCK CONV STRIDE:", stride) deblock = spconv.SparseSequential( # PrintLayer(stride), Conv2d(num_out_filters, self._num_upsample_filters[idx - self._upsample_start_idx], stride, stride=stride), # PrintLayer(stride), BatchNorm2d( self._num_upsample_filters[idx - self._upsample_start_idx] ), nn.ReLU(), ) deblock.add(spconv.ToDense()) return deblock
def __init__(self): super(Net, self).__init__() self.net = spconv.SparseSequential( nn.BatchNorm1d(1), spconv.SparseConv2d(1, 32, 3, 1), nn.ReLU(), spconv.SparseConv2d(32, 64, 3, 1), nn.ReLU(), spconv.SparseMaxPool2d(2, 2), spconv.ToDense(), ) self.fc1 = nn.Linear(9216, 128) self.fc2 = nn.Linear(128, 10) self.dropout1 = nn.Dropout2d(0.25) self.dropout2 = nn.Dropout2d(0.5)
def __init__(self, num_layers, ndim, shape, in_channels, out_channels, kernel_size, stride): super().__init__() self.net = spconv.SparseSequential( spconv.SparseConv3d(in_channels, out_channels, kernel_size, stride, indice_key="cp0", bias=False), spconv.SparseInverseConv3d(out_channels, in_channels, kernel_size, indice_key="cp0", bias=False), ) self.todense = spconv.ToDense() self.shape = shape
def __init__(self, shape): super().__init__() # For some reason the batch normalization is screwing things up idk why. # I heard it fixes itself when you do model.eval rather than just getting a single output self.net = spconv.SparseSequential( spconv.SparseConv3d(1, 32, 4), nn.LeakyReLU(), spconv.SparseConv3d(32, 32, 4), nn.LeakyReLU(), spconvpool.SparseMaxPool(3, 5), spconv.SparseConv3d(32, 32, 4), nn.LeakyReLU(), spconv.SparseConv3d(32, 32, 4), nn.LeakyReLU(), spconvpool.SparseMaxPool(3, 5), spconv.SparseConv3d(32, 32, 4), nn.LeakyReLU(), spconv.SparseConv3d(32, 32, 4), nn.LeakyReLU(), spconv.SparseConv3d(32, 1, 4), nn.LeakyReLU(), spconvpool.SparseMaxPool(3, 5), spconv.ToDense(), nn.Flatten(), nn.Linear(14688, 1000), nn.LeakyReLU(), nn.Linear(1000, 1000), nn.LeakyReLU(), nn.Linear(1000, 1), nn.LeakyReLU(), # nn.Sigmoid() ) self.shape = shape
def generate_block(self, in_dim, out_dim, ksize, stride, padding, do_subm=True): block = spconv.SparseSequential( spconv.SubMConv3d(in_channels=in_dim, out_channels=out_dim, kernel_size=1, stride=1, indice_key="subm0"), nn.BatchNorm1d(num_features=out_dim), nn.LeakyReLU(), spconv.SubMConv3d(in_channels=in_dim, out_channels=out_dim, kernel_size=3, stride=1, padding=1, indice_key='subm0') if do_subm else spconv.SparseConv3d(in_channels=in_dim, out_channels=out_dim, kernel_size=3, stride=1, padding=1), nn.BatchNorm1d(num_features=out_dim), nn.LeakyReLU(), spconv.SubMConv3d(in_channels=in_dim, out_channels=out_dim, kernel_size=1, stride=1, indice_key="subm0"), nn.BatchNorm1d(num_features=out_dim), spconv.ToDense(), ) return block
def __init__(self, in_planes, out_planes=2, kernel_size=3, n_conv=1, n_point=3, conv_position=3, pointwise_factor=0.8, batchnorm=True): """ @type out_planes: int """ super(SparseConv2DForEZ, self).__init__() self.log = logging.getLogger(__name__) layers = [] n_layers = n_conv + n_point if n_conv > 0: if conv_position < 1: raise ValueError("conv position must be >= 1 if n_conv > 0") if n_point > 0: if n_layers == 1: raise ValueError( "n_layers must be > 1 if using pointwise convolution") increment = int( round( int(round(in_planes * pointwise_factor - out_planes)) / float(n_layers - 1))) else: increment = int( round(float(in_planes - out_planes) / float(n_layers))) if kernel_size % 2 != 1: raise ValueError("Kernel size must be an odd integer") if not isinstance(n_layers, int) or n_layers < 1: raise ValueError("n_layers must be integer >= 1") out = copy(in_planes) inp = copy(in_planes) curr_kernel = copy(kernel_size) if n_conv > 0: conv_positions = [ i for i in range(conv_position - 1, conv_position - 1 + n_conv) ] else: conv_positions = [] for i in range(n_layers): if i == (n_layers - 1): out = copy(out_planes) else: out -= increment if i == 0 and n_point > 0: if pointwise_factor > 0: out = int(round(pointwise_factor * in_planes)) if not i in conv_positions: curr_kernel = 1 else: curr_kernel = kernel_size - int((i + 1 - conv_position) * 2) if curr_kernel < 3: curr_kernel = 3 if curr_kernel % 2 == 0: raise ValueError("error: kernel size is even") pd = int((curr_kernel - 1) / 2) self.log.debug( "appending layer {0} -> {1} planes, kernel size of {2}, padding of {3}" .format(inp, out, curr_kernel, pd)) layers.append(spconv.SparseConv2d(inp, out, curr_kernel, 1, pd)) if i != (n_layers - 1): if batchnorm: layers.append(nn.BatchNorm1d(out)) layers.append(nn.ReLU()) inp = out layers.append(spconv.ToDense()) self.network = spconv.SparseSequential(*layers)
def __init__(self, output_shape, num_input_features=128, num_filters_down1=[64], num_filters_down2=[64, 64], use_norm=True, num_class=2, layer_nums=[3, 5, 5], layer_strides=[2, 2, 2], num_filters=[128, 128, 256], upsample_strides=[1, 2, 4], num_upsample_filters=[256, 256, 256], num_anchor_per_loc=2, encode_background_as_zeros=True, use_direction_classifier=True, use_groupnorm=False, num_groups=32, use_bev=False, box_code_size=7, use_rc_net=False, name='sparse_rpn'): super(SparseRPN, self).__init__() self._num_anchor_per_loc = num_anchor_per_loc self._use_direction_classifier = use_direction_classifier self.name = name if use_norm: BatchNorm2d = change_default_args(eps=1e-3, momentum=0.01)(nn.BatchNorm2d) BatchNorm1d = change_default_args(eps=1e-3, momentum=0.01)(nn.BatchNorm1d) Conv2d = change_default_args(bias=False)(nn.Conv2d) SpConv3d = change_default_args(bias=False)(spconv.SparseConv3d) SubMConv3d = change_default_args(bias=False)(spconv.SubMConv3d) ConvTranspose2d = change_default_args(bias=False)( nn.ConvTranspose2d) else: BatchNorm2d = Empty BatchNorm1d = Empty Conv2d = change_default_args(bias=True)(nn.Conv2d) SpConv3d = change_default_args(bias=True)(spconv.SparseConv3d) SubMConv3d = change_default_args(bias=True)(spconv.SubMConv3d) ConvTranspose2d = change_default_args(bias=True)( nn.ConvTranspose2d) sparse_shape = np.array(output_shape[1:4]) + [1, 0, 0] # sparse_shape[0] = 11 print(sparse_shape) self.sparse_shape = sparse_shape self.voxel_output_shape = output_shape # [11, 400, 352] self.block1 = spconv.SparseSequential( SpConv3d(num_input_features, num_filters[0], 3, stride=[2, layer_strides[0], layer_strides[0]], padding=[0, 1, 1]), BatchNorm1d(num_filters[0]), nn.ReLU()) # [5, 200, 176] for i in range(layer_nums[0]): self.block1.add( SubMConv3d(num_filters[0], num_filters[0], 3, padding=1, indice_key="subm0")) self.block1.add(BatchNorm1d(num_filters[0])) self.block1.add(nn.ReLU()) self.deconv1 = spconv.SparseSequential( SpConv3d(num_filters[0], num_filters[0], (3, 1, 1), stride=(2, 1, 1)), BatchNorm1d(num_filters[0]), nn.ReLU(), SpConv3d(num_filters[0], num_upsample_filters[0], (2, 1, 1), stride=1), BatchNorm1d(num_upsample_filters[0]), nn.ReLU(), spconv.ToDense(), Squeeze()) # [1, 200, 176] # [5, 200, 176] self.block2 = spconv.SparseSequential( SpConv3d(num_filters[0], num_filters[1], 3, stride=[2, layer_strides[1], layer_strides[1]], padding=[0, 1, 1]), BatchNorm1d(num_filters[1]), nn.ReLU()) for i in range(layer_nums[1]): self.block2.add( SubMConv3d(num_filters[1], num_filters[1], 3, padding=1, indice_key="subm1")) self.block2.add(BatchNorm1d(num_filters[1])) self.block2.add(nn.ReLU()) # [2, 100, 88] self.deconv2 = spconv.SparseSequential( SpConv3d(num_filters[1], num_filters[1], (2, 1, 1), stride=1), BatchNorm1d(num_filters[1]), nn.ReLU(), spconv.ToDense(), Squeeze(), ConvTranspose2d(num_filters[1], num_upsample_filters[1], upsample_strides[1], stride=upsample_strides[1]), BatchNorm2d(num_upsample_filters[1]), nn.ReLU()) # [1, 200, 176] self.block3 = spconv.SparseSequential( SpConv3d(num_filters[1], num_filters[2], [2, 3, 3], stride=[1, layer_strides[2], layer_strides[2]], padding=[0, 1, 1]), BatchNorm1d(num_filters[2]), nn.ReLU()) for i in range(layer_nums[2]): self.block3.add( SubMConv3d(num_filters[2], num_filters[2], 3, padding=1, indice_key="subm2")) self.block3.add(BatchNorm1d(num_filters[2])) self.block3.add(nn.ReLU()) self.deconv3 = Sequential( spconv.ToDense(), Squeeze(), ConvTranspose2d(num_filters[2], num_upsample_filters[2], upsample_strides[2], stride=upsample_strides[2]), BatchNorm2d(num_upsample_filters[2]), nn.ReLU(), ) # [1, 200, 176] self.post = Sequential( Conv2d(sum(num_upsample_filters), 128, 3, stride=1, padding=1), BatchNorm2d(128), nn.ReLU(), Conv2d(128, 64, 3, stride=1, padding=1), BatchNorm2d(64), nn.ReLU(), ) # [1, 200, 176] if encode_background_as_zeros: num_cls = num_anchor_per_loc * num_class else: num_cls = num_anchor_per_loc * (num_class + 1) '''self.conv_cls = nn.Conv2d(sum(num_upsample_filters), num_cls, 1) self.conv_box = nn.Conv2d( sum(num_upsample_filters), num_anchor_per_loc * box_code_size, 1) if use_direction_classifier: self.conv_dir_cls = nn.Conv2d( sum(num_upsample_filters), num_anchor_per_loc * 2, 1) ''' self.conv_cls = nn.Conv2d(64, num_cls, 1) self.conv_box = nn.Conv2d(64, num_anchor_per_loc * box_code_size, 1) if use_direction_classifier: self.conv_dir_cls = nn.Conv2d(64, num_anchor_per_loc * 2, 1)
def __init__(self, nin, nout, n, size, expansion_factor=10., size_factor=3, pad_factor=0.0, stride_factor=1, dil_factor=1, dropout=0, trainable_weights=False): super(ExtractedFeatureConv, self).__init__() assert (n > 1) self.alg = [] self.out_size = size self.dropout = dropout self.log = logging.getLogger(__name__) self.log.debug( "Initializing convolution block with nin {0}, nout {1}, size {2}". format(nin, nout, size)) self.ndim = len(size) - 1 nframes = [nin, int(round(nin * expansion_factor))] diff = float(nframes[1] - nout) / (n - 1) nframes += [int(floor(nframes[1] - diff * i)) for i in range(n - 1)] for i in range(n): decay_factor = 1. - (i - 1) / (n - 1) fs = int(floor(size_factor / (i + 1.))) if fs < 2: fs = 2 st = int(round(stride_factor * i / (n - 1))) if st < 1: st = 1 dil = int(round(dil_factor**i)) pd = int(round(pad_factor * (fs - 1) * dil_factor * decay_factor)) self.alg.append( spconv.SparseConv2d(nframes[i], nframes[i + 1], fs, st, pd, dil, 1, trainable_weights)) self.log.debug( "added regular convolution, frames: {0} -> {1}".format( nframes[i], nframes[i + 1])) self.log.debug( "filter size: {0}, stride: {1}, pad: {2}, dil: {3}".format( fs, st, pd, dil)) self.alg.append(nn.BatchNorm1d(nframes[i + 1])) self.alg.append(nn.ReLU()) if self.dropout: self.alg.append(nn.Dropout(self.dropout)) arg_dict = { DIM: self.ndim, NIN: nframes[i], NOUT: nframes[i + 1], FS: [fs] * 4, STR: [st] * 4, PAD: [pd] * 4, DIL: [dil] * 4 } self.out_size = ModelValidation.calc_output_size( arg_dict, self.out_size, "cur", "prev", self.ndim) self.log.debug("Loop {0}, output size is {1}".format( i, self.out_size)) self.alg.append(spconv.ToDense()) self.network = spconv.SparseSequential(*self.alg)
def __init__(self, in_channel, pred_dim, chans=64): super(SparseNet3D, self).__init__() conv3d = [] up_bn = [] #batch norm layer for deconvolution conv3d_transpose = [] # self.conv3d = torch.nn.Conv3d(4, 32, (4,4,4), stride=(2,2,2), padding=(1,1,1)) # self.layers = [] self.down_in_dims = [in_channel, chans, 2 * chans] self.down_out_dims = [chans, 2 * chans, 4 * chans] self.down_ksizes = [4, 4, 4] self.down_strides = [2, 2, 2] padding = 1 #Note: this only holds for ksize=4 and stride=2! print('down dims: ', self.down_out_dims) for i, (in_dim, out_dim, ksize, stride) in enumerate( zip(self.down_in_dims, self.down_out_dims, self.down_ksizes, self.down_strides)): # print('3D CONV', end=' ') conv3d += [ spconv.SparseConv3d(in_channels=in_dim, out_channels=out_dim, kernel_size=ksize, stride=stride, padding=padding), nn.LeakyReLU(), nn.BatchNorm1d(num_features=out_dim), ] # self.conv3d = nn.ModuleList(conv3d) self.conv3d = spconv.SparseSequential(*conv3d) self.up_in_dims = [4 * chans, 6 * chans] self.up_bn_dims = [6 * chans, 3 * chans] self.up_out_dims = [4 * chans, 2 * chans] self.up_ksizes = [4, 4] self.up_strides = [2, 2] padding = 1 #Note: this only holds for ksize=4 and stride=2! print('up dims: ', self.up_out_dims) for i, (in_dim, bn_dim, out_dim, ksize, stride) in enumerate( zip(self.up_in_dims, self.up_bn_dims, self.up_out_dims, self.up_ksizes, self.up_strides)): conv3d_transpose += [ spconv.SparseConvTranspose3d(in_channels=in_dim, out_channels=out_dim, kernel_size=ksize, stride=stride, padding=padding), nn.LeakyReLU(), nn.BatchNorm1d(num_features=out_dim), ] up_bn.append(nn.BatchNorm1d(num_features=bn_dim)) # final 1x1x1 conv to get our desired pred_dim self.final_feature = spconv.SparseSequential( spconv.ToDense(), nn.Conv3d(in_channels=2 * chans, out_channels=pred_dim, kernel_size=1, stride=1, padding=0)) self.conv3d_transpose = spconv.SparseSequential(*conv3d_transpose) self.up_bn = nn.ModuleList(up_bn)
def _version1(self, nin, nout, n, size, to_dense, size_factor=3, pad_factor=0.0, stride_factor=1, dil_factor=1, pointwise_factor=0, depth_factor=0, dropout=0, trainable_weights=False): assert (n > 0) self.alg = [] self.out_size = size self.dropout = dropout self.log = logging.getLogger(__name__) self.log.debug( "Initializing convolution block with nin {0}, nout {1}, size {2}". format(nin, nout, size)) self.ndim = len(size) - 1 if nin != nout: if pointwise_factor > 0: nframes = [ nin, nin - int(floor((nin - nout) * pointwise_factor)) ] if n > 1: diff = float(nin - nout) / n for i in range(n - 1): val = int(floor(nframes[-1] - diff)) if val > nout: nframes += [val] else: nframes += [nout] elif depth_factor > 0: nframes = [nin, int(nin * depth_factor)] if n > 1: diff = float(nframes[-1] - nout) / (n - 1) for i in range(n - 1): val = int(floor(nframes[-1] - diff)) if val > nout: nframes += [val] else: nframes += [nout] else: diff = float(nin - nout) / n nframes = [int(floor(nin - diff * i)) for i in range(n + 1)] else: nframes = [nin] * (n + 1) for i in range(n): if pointwise_factor > 0: if n > 1: decay_factor = 1. - (i - 1) / (n - 1) else: decay_factor = 1. else: if n > 1: decay_factor = 1. - i / (n - 1) else: decay_factor = 1. fs = int(floor(size_factor / (i + 1.))) if fs < 2: fs = 2 st = int(round(stride_factor * i / (n - 1))) if st < 1: st = 1 dil = int(round(dil_factor**i)) pd = int(round(pad_factor * (fs - 1) * dil_factor * decay_factor)) if i == 0 and pointwise_factor > 0: pd, fs, dil, st = 0, 1, 1, 1 self.alg.append( spconv.SparseConv2d(nframes[i], nframes[i + 1], fs, st, pd, dil, 1, trainable_weights)) # self.alg.append(spconv.SubMConv2d(nframes[i], nframes[i + 1], fs, st, pd, dil, 1, trainable_weights)) self.log.debug( "added pointwise convolution, frames: {0} -> {1}".format( nframes[i], nframes[i + 1])) else: self.alg.append( spconv.SparseConv2d(nframes[i], nframes[i + 1], fs, st, pd, dil, 1, trainable_weights)) self.log.debug( "added regular convolution, frames: {0} -> {1}".format( nframes[i], nframes[i + 1])) self.log.debug( "filter size: {0}, stride: {1}, pad: {2}, dil: {3}".format( fs, st, pd, dil)) self.alg.append(nn.BatchNorm1d(nframes[i + 1])) self.alg.append(nn.ReLU()) if self.dropout: self.alg.append(nn.Dropout(self.dropout)) arg_dict = { DIM: self.ndim, NIN: nframes[i], NOUT: nframes[i + 1], FS: [fs] * 4, STR: [st] * 4, PAD: [pd] * 4, DIL: [dil] * 4 } self.out_size = ModelValidation.calc_output_size( arg_dict, self.out_size, "cur", "prev", self.ndim) self.log.debug("Loop {0}, output size is {1}".format( i, self.out_size)) if to_dense: self.alg.append(spconv.ToDense()) self.func = spconv.SparseSequential(*self.alg)
def _version3(self, nin, nout, n, size, to_dense, size_factor=3, pad_factor=0.0, stride_factor=1, dil_factor=1, expansion_factor=0, n_expansion=0, pointwise_factor=0, dropout=0, trainable_weights=False): self.alg = [] self.out_size = size self.dropout = dropout self.log = logging.getLogger(__name__) self.log.debug( "Initializing convolution block with nin {0}, nout {1}, size {2}". format(nin, nout, size)) self.ndim = len(size) - 1 if pointwise_factor > 0: n_contraction = n - 1 - n_expansion if n_contraction < 1: raise ValueError("n_contraction too large, must be < n - 1") else: n_contraction = n - n_expansion if n_contraction < 1: raise ValueError("n_contraction too large, must be < n") nframes = [nin] if pointwise_factor > 0: nframes.append(nin - int(floor((nin - nout) * pointwise_factor))) if n_expansion > 0: nframes += _get_frame_expansion(nframes[-1], expansion_factor, n_expansion) if n_contraction > 0: nframes += _get_frame_contraction(nframes[-1], nout, n_contraction) for i in range(n): if pointwise_factor > 0: if n > 1: decay_factor = 1. - (i - 1) / (n - 1) else: decay_factor = 1. else: if n > 1: decay_factor = 1. - i / (n - 1) else: decay_factor = 1. fs = int(ceil(size_factor * decay_factor)) if fs < 2: fs = 2 st = int(round(stride_factor * i / (n - 1))) if st < 1: st = 1 dil = int(round(dil_factor**i)) pd = int( round(pad_factor * ((fs - 1) / 2.) * dil_factor * decay_factor)) if i == 0 and pointwise_factor > 0: pd, fs, dil, st = 0, 1, 1, 1 self.alg.append( spconv.SparseConv2d(nframes[i], nframes[i + 1], fs, st, pd, dil, 1, trainable_weights)) # self.alg.append(spconv.SubMConv2d(nframes[i], nframes[i + 1], fs, st, pd, dil, 1, trainable_weights)) self.log.debug( "added pointwise convolution, frames: {0} -> {1}".format( nframes[i], nframes[i + 1])) else: self.alg.append( spconv.SparseConv2d(nframes[i], nframes[i + 1], fs, st, pd, dil, 1, trainable_weights)) self.log.debug( "added regular convolution, frames: {0} -> {1}".format( nframes[i], nframes[i + 1])) self.log.debug( "filter size: {0}, stride: {1}, pad: {2}, dil: {3}".format( fs, st, pd, dil)) self.alg.append(nn.BatchNorm1d(nframes[i + 1])) self.alg.append(nn.ReLU()) if self.dropout: self.alg.append(nn.Dropout(self.dropout)) arg_dict = { DIM: self.ndim, NIN: nframes[i], NOUT: nframes[i + 1], FS: [fs] * 4, STR: [st] * 4, PAD: [pd] * 4, DIL: [dil] * 4 } self.out_size = ModelValidation.calc_output_size( arg_dict, self.out_size, "cur", "prev", self.ndim) self.log.debug("Loop {0}, output size is {1}".format( i, self.out_size)) if to_dense: self.alg.append(spconv.ToDense()) self.func = spconv.SparseSequential(*self.alg)