def __init__(self): super(CnnModel, self).__init__() # in_channel == number of features (1 in b/w images, 3 in colored images, 45 in our case) # out_channel == number of filters to learn # kernel_size == window/filter size # padding = kernel_size / 2 - 1 to conserve sequence length self.conv1 = Conv1d(in_channels=45, out_channels=16, kernel_size=9, padding=4) # 8 output categories self.conv2 = Conv1d(in_channels=16, out_channels=8, kernel_size=3, padding=1)
def __init__( self, embedding_dim: int, num_filters: int, ngram_filter_sizes: Tuple[int, ...] = (2, 3, 4, 5), # pylint: disable=bad-whitespace conv_layer_activation=torch.nn.functional.relu, output_dim: Optional[int] = None) -> None: super(CnnEncoder, self).__init__() self._embedding_dim = embedding_dim self._num_filters = num_filters self._ngram_filter_sizes = ngram_filter_sizes self._activation = conv_layer_activation self._output_dim = output_dim self._convolution_layers = [ Conv1d(in_channels=self._embedding_dim, out_channels=self._num_filters, kernel_size=ngram_size) for ngram_size in self._ngram_filter_sizes ] for i, conv_layer in enumerate(self._convolution_layers): self.add_module('conv_layer_%d' % i, conv_layer) maxpool_output_dim = self._num_filters * len(self._ngram_filter_sizes) if self._output_dim: self.projection_layer = Linear(maxpool_output_dim, self._output_dim) else: self.projection_layer = None self._output_dim = maxpool_output_dim
def __init__(self, n_in_channels, n_out_channels, n_blocks, n_init_features, growth_rate, drop_rate, kernel_internal, glu_act): super(DenseDeep1D_incept, self).__init__() self.n_blocks = n_blocks self.init_features = torch.nn.ModuleList() for conv_level, vals in enumerate(n_init_features): if vals > 0: self.init_features.append( Conv1d(n_in_channels, vals, kernel_size=1 + 2 * conv_level, padding_mode='zeros', padding=conv_level)) total_init_features = sum(n_init_features) self.norm0 = LayerNorm([total_init_features, 107]) self.act0 = ReLU(inplace=True) self.features = torch.nn.Sequential(OrderedDict()) for k_block in range(n_blocks): self.features.add_module( 'block_{}'.format(k_block), _DenseConvBlock(total_init_features + k_block * growth_rate, growth_rate=growth_rate, drop_rate=drop_rate, kernel_size=kernel_internal, glu_act=glu_act)) self.act_final = ReLU(inplace=True) self.regression = Linear(total_init_features + n_blocks * growth_rate, n_out_channels)
def __init__(self, in_size, out_size, num_layers, kernel_size, dilation, input_in_rnn_format=False, batch_norm=False): super().__init__() self.input_in_rnn_format = input_in_rnn_format self.sequential = Sequential() for i in range(num_layers): conv = Conv1d(in_channels=in_size, out_channels=out_size, kernel_size=kernel_size, dilation=dilation, bias=not batch_norm) self.sequential.add_module('cnn_c_%s' % i, conv) non_lin = ReLU() self.sequential.add_module('non_lin_%s' % i, non_lin) if batch_norm: bnn = BatchNorm1d(out_size) self.sequential.add_module('bnn_c_%s' % i, bnn) in_size = out_size
def __init__(self, num_channels): super().__init__() self.num_channels = num_channels self.conv1_input = Conv1d(self.num_channels, self.num_channels, kernel_size=3, padding=1) self.relu = ReLU() self.conv1 = Conv1d(self.num_channels, 32, kernel_size=3) self.conv2 = Conv1d(32, 32, kernel_size=3) self.pool1 = MaxPool1d(kernel_size=2) self.conv3 = Conv1d(32, 16, kernel_size=3) self.flatten = Flatten() self.linear1 = Linear(16, 100) self.linear2 = Linear(100, 50) self.linear3 = Linear(50, 1)
def __init__(self, input_dim: int, num_filters: int, ngram_filter_sizes: Tuple[int, ...], padding_sizes: Tuple[int, ...], keep_prob: float = .8, conv_layer_activation=F.relu, output_dim: Optional[int] = None) -> None: super(SelfAwareEmbedding, self).__init__() self.input_dim = input_dim self.num_filters = num_filters self.ngram_filter_sizes = ngram_filter_sizes self.padding_sizes = padding_sizes self.activation = conv_layer_activation self.output_dim = output_dim self.dropout = nn.Dropout(1 - keep_prob) self.convolution_layers = [ Conv1d(in_channels=self.input_dim, out_channels=self.num_filters, kernel_size=ngram_size, padding=padding) for ngram_size, padding in zip( self.ngram_filter_sizes, self.padding_sizes) ] for i, conv_layer in enumerate(self.convolution_layers): self.add_module('conv_layer_%d' % i, conv_layer) maxpool_output_dim = self.num_filters * len(self.ngram_filter_sizes) if self.output_dim: self.projection_layer = Linear(maxpool_output_dim, self.output_dim) else: self.projection_layer = None self.output_dim = maxpool_output_dim
def __init__(self, in_channels=2, num_layers=5, filter_width=11, channels=[16, 32, 64, 128, 256], dropout=0.3, rate=44100, duration=0.5, flat_dim=512): assert num_layers == len(channels) super(ConvTwin, self).__init__() extra_px = filter_width // 2 channels = [in_channels] + channels total_len = int(2**np.floor(np.log2(rate * duration))) conv_block = lambda in_ch, out_ch, p=dropout, fw=filter_width, pd=extra_px: nn.Sequential( Conv1d(in_ch, out_ch, kernel_size=fw, padding=pd), BatchNorm1d(out_ch), ReLU(), Dropout(p=p), MaxPool1d(kernel_size=2) ) convs = [] for i in range(1, len(channels)): convs.append(conv_block(channels[i - 1], channels[i])) self.dense = Linear(total_len * channels[-1] // (2**len(convs)), flat_dim) self.L = total_len self.convs = convs self.convs = nn.Sequential(*self.convs)
def __init__(self, embedding_dim, num_filters, ngram_filter_sizes=(2, 3, 4, 5), conv_layer_activation=ReLU(), output_dim=None): super(CNNEncoder, self).__init__() self._embedding_dim = embedding_dim self._num_filters = num_filters self._ngram_filter_sizes = ngram_filter_sizes self._activation = conv_layer_activation self._output_dim = output_dim self._convolution_layers = [ Conv1d(in_channels=self._embedding_dim, out_channels=self._num_filters, kernel_size=ngram_size) for ngram_size in self._ngram_filter_sizes ] for i, conv_layer in enumerate(self._convolution_layers): self.add_module('conv_layer_%d' % i, conv_layer) maxpool_output_dim = self._num_filters * len(self._ngram_filter_sizes) if self._output_dim: self.projection_layer = Linear(maxpool_output_dim, self._output_dim) else: self.projection_layer = None self._output_dim = maxpool_output_dim
def __init__(self,batch_size, inputs, outputs): # initilize the super class & store the parameters super(cnnRegressor,self).__init__() self.batch_size= batch_size self.inputs= inputs self_outputs= outputs # define input layers (input channels, output channels, kernel size) self.input_layer = Conv1d(inputs, batch_size,1) #(kernel size) self.max_pooling_layer= MaxPool1d(1) self.conv_layer= Conv1d(batch_size, 128,1) self.flatten_layer=Flatten() #(inputs, outputs) self.linear_layer= Linear(128,64) self.output_layer= Linear(64, outputs)
def conv(c_in, c_out, ks, stride=1, bias=False, dilation=1, groups=1): if stride > 1 and dilation > 1: raise ValueError("Dilation and stride can not both be greater than 1") return Conv1d( c_in, c_out, ks, stride=stride, padding=(ks // 2) * dilation, bias=bias, dilation=dilation, groups=groups )
def __init__(self, in_channels, out_channels, slope=0.01, kern_size=5, max_pool=2, eps=1e-05, momentum=0.1, use_skip=True): super(DoubleConvConcatAndDilate, self).__init__() padding = kern_size // 2 transpose_padding = padding - 1 # we need to account for the skip connection if use_skip: in_channels += in_channels self.conv1 = ConvTranspose1d(in_channels, out_channels, stride=max_pool, kernel_size=kern_size, padding=transpose_padding) self.batch_norm_1 = BatchNorm1d(out_channels) self.relu_1 = LeakyReLU(negative_slope=slope) self.conv2 = Conv1d(out_channels, out_channels, kernel_size=kern_size, padding=padding) self.batch_norm_2 = BatchNorm1d(out_channels) self.relu_2 = LeakyReLU(negative_slope=slope)
def __init__(self, hidden_dim=512, embedding_dim=256, vocab_size=10000, num_layers=10, kernel_size=3, dropout=0.25, PAD_token=0, max_len=50): super().__init__() self.kernel_size = kernel_size self.PAD_token = PAD_token self.num_layers = num_layers self.vocab_size = vocab_size self.max_len = max_len self.token_embedding = Embedding(vocab_size, embedding_dim) self.position_embedding = Embedding(max_len, embedding_dim) self.embedd2hidden = Linear(embedding_dim, hidden_dim) self.hidden2embedd = Linear(hidden_dim, embedding_dim) self.attention_layer = Attention(embedding_dim, hidden_dim) self.decoder_conv = DecoderConv(kernel_size, dropout, PAD_token) self.convs = ModuleList([ Conv1d(in_channels=hidden_dim, out_channels=2 * hidden_dim, kernel_size=kernel_size) for _ in range(num_layers) ]) self.out = Linear(embedding_dim, vocab_size) self.dropout = Dropout(dropout)
def __init__(self): super(Generator, self).__init__() self.conv_pre = weight_norm(Conv1d(80, 512, 7, 1, padding=3)) self.ups = nn.ModuleList([ weight_norm(ConvTranspose1d(512, 256, 16, 8, padding=4)), weight_norm(ConvTranspose1d(256, 128, 16, 8, padding=4)), weight_norm(ConvTranspose1d(128, 64, 4, 2, padding=1)), weight_norm(ConvTranspose1d(64, 32, 4, 2, padding=1)) ]) self.resblocks = nn.ModuleList([ ResBlock(256, 256), ResBlock(128, 128), ResBlock(64, 64), ResBlock(32, 32) ]) self.conv_post = weight_norm(Conv1d(32, 1, 7, 1, padding=3))
def __init__(self, input_channels, output_channels, kernel, dropout=0.0, activation='identity', dilation=1, groups=1, batch_norm=True): super(ConvBlock, self).__init__() self._groups = groups p = (kernel - 1) * dilation // 2 padding = p if kernel % 2 != 0 else (p, p + 1) layers = [ ConstantPad1d(padding, 0.0), Conv1d(input_channels, output_channels, kernel, padding=0, dilation=dilation, groups=groups, bias=(not batch_norm)) ] if batch_norm: layers += [BatchNorm1d(output_channels)] layers += [get_activation(activation)] layers += [Dropout(dropout)] self._block = Sequential(*layers)
def __init__(self, channels, kernel, reduction=2, use_hard_sigmoid=False): """ Channel-wise attention module, Squeeze-and-Excitation Networks Jie Hu1, Li Shen, Gang Sun - https://arxiv.org/pdf/1709.01507v2.pdf :param channels: Number of input channels :param reduction: Reduction factor for the number of hidden units """ super(_ChannelAttentionModule, self).__init__() if use_hard_sigmoid: act_type = "hard_sigmoid" else: act_type = "sigmoid" self.avg_pool = AdaptiveAvgPool2d(1) self.body = Sequential( Conv1d(in_channels=channels, out_channels=channels, kernel_size=kernel, padding=kernel // 2, stride=1, bias=True), get_act("sigmoid")) self.fc = Sequential( Linear(channels, channels // reduction, bias=False), ReLU(inplace=True), Linear(channels // reduction, channels, bias=False), get_act(act_type))
def __init__(self, L=32, W=np.array([11] * 8 + [21] * 4 + [41] * 4), AR=np.array([1] * 4 + [4] * 4 + [10] * 4 + [25] * 4)): super().__init__() self.CL = 2 * (AR * (W - 1)).sum() # context length self.conv1 = Conv1d(4, L, 1) self.skip1 = Skip(L) self.residual_blocks = ModuleList() for i, (w, r) in enumerate(zip(W, AR)): self.residual_blocks.append(ResidualUnit(L, w, r)) if (i + 1) % 4 == 0: self.residual_blocks.append(Skip(L)) if (len(W) + 1) % 4 != 0: self.residual_blocks.append(Skip(L)) self.last = Conv1d(L, 3, 1)
def __init__(self, args): self.k = 10 self.hidden1 = is_in_args(args, 'hidden1', 32) self.hidden2 = self.hidden1 // 4 self.hidden_fcn = is_in_args(args, 'hidden_fcn', 32) use_bn = args.constant_size & (args.batch_size > 8) super(Conan, self).__init__() self.continuous_clusters = Sequential( Conv1d_bn(in_channels=args.feature_depth, out_channels=self.hidden1, dropout=args.dropout, use_bn=use_bn), Conv1d_bn(in_channels=self.hidden1, out_channels=self.hidden2, dropout=args.dropout, use_bn=use_bn), Conv1d_bn(in_channels=self.hidden2, out_channels=self.hidden1, dropout=args.dropout, use_bn=use_bn), ) self.weights = Sequential( Conv1d(in_channels=self.hidden1, out_channels=1, kernel_size=1), ReLU()) self.classifier = Sequential( Dense_bn(in_channels=(self.hidden1 + 1) * 2 * self.k + self.hidden1, out_channels=self.hidden_fcn, dropout=args.dropout, use_bn=use_bn), Dense_bn(in_channels=self.hidden_fcn, out_channels=self.hidden_fcn, dropout=args.dropout, use_bn=use_bn), Linear(in_features=self.hidden_fcn, out_features=1), Sigmoid())
def __init__(self, embedding_dim: int, num_filters: int, ngram_filter_sizes: Tuple[int, ...] = (2, 3, 4, 5), # pylint: disable=bad-whitespace ) -> None: super(CnnSeq2SeqEncoder, self).__init__() self._embedding_dim = embedding_dim self._num_filters = num_filters self._ngram_filter_sizes = ngram_filter_sizes # 确认卷积核的大小是基数 for ngram_size in self._ngram_filter_sizes: assert ngram_size % 2 == 1 """ torch.nn.Conv1d(last_dim, layer[1] * 2, layer[0], stride=1, padding=layer[0] - 1, bias=True)""" self._convolution_layers = [Conv1d(in_channels=self._embedding_dim, out_channels=self._num_filters, padding = ngram_size // 2, kernel_size=ngram_size) for ngram_size in self._ngram_filter_sizes] for i, conv_layer in enumerate(self._convolution_layers): self.add_module('conv_layer_%d' % i, conv_layer) # 多少个卷积核 * 卷积类型数目 self._output_dim = self._num_filters * len(self._ngram_filter_sizes)
def __init__(self, input_dim: int, num_filters: int, ngram_filter_sizes: Tuple[int, ...], dropout: float = .0, conv_layer_activation = F.relu, output_dim: Optional[int] = None) -> None: super(CNNEncoder, self).__init__() self.input_dim = input_dim self.num_filters = num_filters self.ngram_filter_sizes = ngram_filter_sizes self.activation = conv_layer_activation self.output_dim = output_dim self.dropout = nn.Dropout(dropout) self.convolution_layers = [Conv1d(in_channels=self.input_dim, out_channels=self.num_filters, kernel_size=ngram_size) for ngram_size in self.ngram_filter_sizes] for i, conv_layer in enumerate(self.convolution_layers): self.add_module('conv_layer_%d' % i, conv_layer) maxpool_output_dim = self.num_filters * len(self.ngram_filter_sizes) if self.output_dim: self.projection_layer = Linear(maxpool_output_dim, self.output_dim) else: self.projection_layer = None self.output_dim = maxpool_output_dim
def __init__( self, embedding_dim: int, num_filters: int, ngram_filter_sizes: Tuple[int, ...] = (2, 3, 4, 5), # pylint: disable=bad-whitespace conv_layer_activation: Activation = None, output_dim: Optional[int] = None) -> None: super(ExplainableCnnEncoder, self).__init__() self._embedding_dim = embedding_dim self._num_filters = num_filters self._ngram_filter_sizes = ngram_filter_sizes self._activation = conv_layer_activation or Activation.by_name( 'relu')() self._output_dim = output_dim self._convolution_layers = [(Conv1d(in_channels=self._embedding_dim, out_channels=self._num_filters, kernel_size=ngram_size), MaxPool1dAll(kernel_size=None)) for ngram_size in self._ngram_filter_sizes] for i, (conv_layer, maxpool_layer) in enumerate(self._convolution_layers): self.add_module('conv_layer_%d' % i, conv_layer) self.add_module('maxpool_layer_%d' % i, maxpool_layer) maxpool_output_dim = self._num_filters * len(self._ngram_filter_sizes) if self._output_dim: self.projection_layer = Linear(maxpool_output_dim, self._output_dim) else: self.projection_layer = None self._output_dim = maxpool_output_dim
def __init__( self, embedding_dim: int, num_filters: int, ngram_filter_sizes: Tuple[int, ...] = (2, 3, 4, 5), conv_layer_activation: Activation = None, output_dim: Optional[int] = None, ) -> None: super().__init__() self._embedding_dim = embedding_dim self._num_filters = num_filters self._ngram_filter_sizes = ngram_filter_sizes self._activation = conv_layer_activation or Activation.by_name( "relu")() self._convolution_layers = [ Conv1d( in_channels=self._embedding_dim, out_channels=self._num_filters, kernel_size=ngram_size, ) for ngram_size in self._ngram_filter_sizes ] for i, conv_layer in enumerate(self._convolution_layers): self.add_module("conv_layer_%d" % i, conv_layer) maxpool_output_dim = self._num_filters * len(self._ngram_filter_sizes) if output_dim: self.projection_layer = Linear(maxpool_output_dim, output_dim) self._output_dim = output_dim else: self.projection_layer = None self._output_dim = maxpool_output_dim
def __init__( self, embedding_dim: int, num_filters: int, ngram_filter_sizes: Tuple[int, ...] = (2, 3, 4, 5), # pylint: disable=bad-whitespace conv_layer_activation: Activation = None, output_dim: Optional[int] = None) -> None: super(CnnEncoder, self).__init__() self._embedding_dim = embedding_dim self._num_filters = num_filters self._ngram_filter_sizes = ngram_filter_sizes self._activation = conv_layer_activation or Activation.by_name( 'relu')() self._output_dim = output_dim self._convolution_layers = [ Conv1d(in_channels=self._embedding_dim, out_channels=self._num_filters, kernel_size=ngram_size) for ngram_size in self._ngram_filter_sizes ] for i, conv_layer in enumerate(self._convolution_layers): self.add_module('conv_layer_%d' % i, conv_layer) self._output_dim = self._num_filters * len(self._ngram_filter_sizes)
def __init__(self, embedding_dim , num_filters , ngram_filter_sizes = (2, 3, 4, 5), # pylint: disable=bad-whitespace conv_layer_activation = None, output_dim = None) : super(CnnEncoder, self).__init__() self._embedding_dim = embedding_dim self._num_filters = num_filters self._ngram_filter_sizes = ngram_filter_sizes self._activation = conv_layer_activation or Activation.by_name(u'relu')() self._output_dim = output_dim self._convolution_layers = [Conv1d(in_channels=self._embedding_dim, out_channels=self._num_filters, kernel_size=ngram_size) for ngram_size in self._ngram_filter_sizes] for i, conv_layer in enumerate(self._convolution_layers): self.add_module(u'conv_layer_%d' % i, conv_layer) maxpool_output_dim = self._num_filters * len(self._ngram_filter_sizes) if self._output_dim: self.projection_layer = Linear(maxpool_output_dim, self._output_dim) else: self.projection_layer = None self._output_dim = maxpool_output_dim
def __init__( self, embedding_dim, num_filters=100, ngram_filter_sizes=(2, 3, 4, 5), conv_layer_activation="relu", output_dim=None, ): """TODO: to be defined1. """ nn.Module.__init__(self) self.embedding_dim = embedding_dim self.num_filters = num_filters self.ngram_filter_sizes = ngram_filter_sizes self.conv_layer_activation = torch.nn.functional.relu self.output_dim = output_dim self.convolution_layers = nn.ModuleList() for ngram_size in self.ngram_filter_sizes: self.convolution_layers.append( Conv1d( in_channels=self.embedding_dim, out_channels=self.num_filters, kernel_size=ngram_size, )) maxpool_output_dim = self.num_filters * len(self.ngram_filter_sizes) if self.output_dim: self.projection_layer = Linear(maxpool_output_dim, self.output_dim) else: self.projection_layer = None self.output_dim = maxpool_output_dim
def __init__(self, feature_extractor_params: ClonableModule, k, arch): """ In the constructor we instantiate the snail module """ super(SNAILNetwork, self).__init__() self.feature_extractor = FeaturesExtractorFactory()( **feature_extractor_params) self.arch = arch input_dim = self.feature_extractor.output_dim + 1 layers = [] for i, (layer_type, layer_infos) in enumerate(arch): if layer_type == 'att': key_size, value_size = layer_infos layer = AttentionBlock(input_dim, key_size, value_size) input_dim = input_dim + value_size elif layer_type == 'tc': kernel_size = layer_infos layer = TCBlock(input_dim, k + 1, kernel_size) input_dim = layer.output_dim else: raise Exception( "Impossible to create that type of layer in this model") layers.append(layer) layers.append(Transpose(1, 2)) layers.append(Conv1d(input_dim, 1, 1)) layers.append(Transpose(1, 2)) self.net = Sequential(*layers)
def __init__(self, params): super(VerticalAttention, self).__init__() self.att_fc_size = params["att_fc_size"] self.features_size = params["features_size"] self.use_location = params["use_location"] self.use_coverage_vector = params["use_coverage_vector"] self.coverage_mode = params["coverage_mode"] self.use_hidden = params["use_hidden"] self.min_height = params["min_height_feat"] self.min_width = params["min_width_feat"] self.stop_mode = params["stop_mode"] self.ada_pool = AdaptiveMaxPool2d((None, self.min_width)) self.dense_width = Linear(self.min_width, 1) self.dense_enc = Linear(self.features_size, self.att_fc_size) self.dense_align = Linear(self.att_fc_size, 1) if self.stop_mode == "learned": self.ada_pool_height = AdaptiveMaxPool1d(self.min_height) self.conv_decision = Conv1d(self.att_fc_size, self.att_fc_size, kernel_size=5, padding=2) self.dense_height = Linear(self.min_height, 1) if self.use_hidden: self.dense_decision = Linear( params["hidden_size"] + self.att_fc_size, 2) else: self.dense_decision = Linear(self.att_fc_size, 2) in_ = 0 if self.use_location: in_ += 1 if self.use_coverage_vector: in_ += 1 self.norm = InstanceNorm1d(in_, track_running_stats=False) self.conv_block = Conv1d(in_, 16, kernel_size=15, padding=7) self.dense_conv_block = Linear(16, self.att_fc_size) if self.use_hidden: self.hidden_size = params["hidden_size"] self.dense_hidden = Linear(self.hidden_size, self.att_fc_size) self.dropout = Dropout(params["att_dropout"]) self.h_features = None
def __init__( self, resblock, upsample_rates, upsample_kernel_sizes, upsample_initial_channel, resblock_kernel_sizes, resblock_dilation_sizes, initial_input_size=80, apply_weight_init_conv_pre=False, ): super().__init__() self.num_kernels = len(resblock_kernel_sizes) self.num_upsamples = len(upsample_rates) self.conv_pre = weight_norm( Conv1d(initial_input_size, upsample_initial_channel, 7, 1, padding=3)) resblock = ResBlock1 if resblock == 1 else ResBlock2 self.ups = nn.ModuleList() for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)): self.ups.append( weight_norm( ConvTranspose1d( upsample_initial_channel // (2**i), upsample_initial_channel // (2**(i + 1)), k, u, padding=(k - u) // 2, ))) self.resblocks = nn.ModuleList() for i in range(len(self.ups)): ch = upsample_initial_channel // (2**(i + 1)) for j, (k, d) in enumerate( zip(resblock_kernel_sizes, resblock_dilation_sizes)): self.resblocks.append(resblock(ch, k, d)) self.conv_post = weight_norm(Conv1d(ch, 1, 7, 1, padding=3)) self.ups.apply(init_weights) self.conv_post.apply(init_weights) if apply_weight_init_conv_pre: self.conv_pre.apply(init_weights)
def __init__(self, up_ratio=4): super(up_projection_unit, self).__init__() self.conv1 = nn.Sequential( Conv1d(in_channels=648, out_channels=128, kernel_size=1), nn.ReLU()) self.up_block1 = up_block(up_ratio=4, in_channels=128 + 2) self.up_block2 = up_block(up_ratio=4, in_channels=128 + 2) self.down_block = down_block(up_ratio=4, in_channels=128)
def __init__(self, in_channels, out_channels, stride, kernel_size, nb_filters, bottleneck_size, use_bottleneck): super().__init__() self.bottleneck_size = bottleneck_size self.stride = stride self.kernel_size = kernel_size self.nb_filters = nb_filters self.use_bottleneck = use_bottleneck self.input = Identity() self.bottleneckInput = Conv1d(in_channels, self.bottleneck_size, kernel_size=1, padding=0, bias=False) # kernel_size_s = [3, 5, 8, 11, 17] kernel_size_s = [self.kernel_size // (2**i) for i in range(3)] #print("kernel size"); #print(kernel_size_s) self.conv_list = [] self.temp_input = self.bottleneck_size for i in range(len(kernel_size_s)): setattr( self, "cov_parallel_%d" % kernel_size_s[i], Conv1d(self.temp_input, self.nb_filters, kernel_size=kernel_size_s[i], stride=self.stride, padding=0, bias=False)) self.temp_input = self.nb_filters self.conv_list.append( getattr(self, "cov_parallel_%d" % kernel_size_s[i])) self.max_pool = MaxPool1d(kernel_size=3, stride=self.stride, padding=0) self.conv = Conv1d(self.bottleneck_size, self.nb_filters, kernel_size=1, padding=0, bias=False) self.bn = BatchNorm1d(self.nb_filters)
def __init__( self, in_channels, out_channels, dim, kernel_size, hidden_channels=None, dilation=1, bias=True, **kwargs, ): super(XConv, self).__init__() self.in_channels = in_channels if hidden_channels is None: hidden_channels = in_channels // 4 assert hidden_channels > 0 self.hidden_channels = hidden_channels self.out_channels = out_channels self.dim = dim self.kernel_size = kernel_size self.dilation = dilation self.kwargs = kwargs C_in, C_delta, C_out = in_channels, hidden_channels, out_channels D, K = dim, kernel_size self.mlp1 = S( L(dim, C_delta), ELU(), BN(C_delta), L(C_delta, C_delta), ELU(), BN(C_delta), Reshape(-1, K, C_delta), ) self.mlp2 = S( L(D * K, K ** 2), ELU(), BN(K ** 2), Reshape(-1, K, K), Conv1d(K, K ** 2, K, groups=K), ELU(), BN(K ** 2), Reshape(-1, K, K), Conv1d(K, K ** 2, K, groups=K), BN(K ** 2), Reshape(-1, K, K), ) C_in = C_in + C_delta depth_multiplier = int(ceil(C_out / C_in)) self.conv = S( Conv1d(C_in, C_in * depth_multiplier, K, groups=C_in), Reshape(-1, C_in * depth_multiplier), L(C_in * depth_multiplier, C_out, bias=bias), ) self.reset_parameters()