def __init__(self, name_scope='PointNet2_MSG_Seg_', num_classes=16, num_parts=50, normal_channel=False): super(PointNet2_MSG_Seg, self).__init__() if normal_channel: additional_channel = 3 else: additional_channel = 0 self.num_classes = num_classes self.normal_channel = normal_channel self.sa1 = PointNetSetAbstractionMsg( 512, [0.1, 0.2, 0.4], [32, 64, 128], 3 + additional_channel, [[32, 32, 64], [64, 64, 128], [64, 96, 128]]) self.sa2 = PointNetSetAbstractionMsg( 128, [0.4, 0.8], [64, 128], 128 + 128 + 64, [[128, 128, 256], [128, 196, 256]]) self.sa3 = PointNetSetAbstraction(npoint=None, radius=None, nsample=None, in_channel=512 + 3, mlp=[256, 512, 1024], group_all=True) self.fp3 = PointNetFeaturePropagation(in_channel=1536, mlp=[256, 256]) self.fp2 = PointNetFeaturePropagation(in_channel=576, mlp=[256, 128]) self.fp1 = PointNetFeaturePropagation(in_channel=150 + additional_channel, mlp=[128, 128]) self.conv1 = nn.Conv1D(128, 128, 1) self.bn1 = nn.BatchNorm1D(128) self.drop1 = nn.Dropout(0.5) self.conv2 = nn.Conv1D(128, num_parts, 1)
def __init__(self, num_classes=10, max_points=1024): super(PointNet_Basic_Clas, self).__init__() self.mlp_1 = nn.Sequential( nn.Conv1D(3, 64, 1), nn.BatchNorm(64), nn.ReLU(), nn.Conv1D(64, 64, 1), nn.BatchNorm(64), nn.ReLU(), ) self.mlp_2 = nn.Sequential( nn.Conv1D(64, 64, 1), nn.BatchNorm(64), nn.ReLU(), nn.Conv1D(64, 128, 1), nn.BatchNorm(128), nn.ReLU(), nn.Conv1D(128, max_points, 1), nn.BatchNorm(max_points), nn.ReLU(), ) self.fc = self.fc = nn.Sequential(nn.Linear(1024, 512), nn.ReLU(), nn.Linear(512, 256), nn.ReLU(), nn.Dropout(p=0.7), nn.Linear(256, num_classes))
def __init__(self, num_attention_heads, attention_probs_dropout_prob, cin, q_groups=1, k_groups=1, v_groups=1): super().__init__() if cin % num_attention_heads != 0: raise ValueError( f"cin ({cin}) is not a multiple of the number of attention heads ({num_attention_heads})" ) self.num_attention_heads = num_attention_heads self.attention_head_size = int(cin / num_attention_heads) self.all_head_size = self.num_attention_heads * self.attention_head_size self.query = nn.Conv1D(in_channels=cin, out_channels=cin, kernel_size=1, groups=q_groups) self.key = nn.Conv1D(in_channels=cin, out_channels=cin, kernel_size=1, groups=k_groups) self.value = nn.Conv1D(in_channels=cin, out_channels=cin, kernel_size=1, groups=v_groups) self.dropout = nn.Dropout(attention_probs_dropout_prob) self.softmax = nn.Softmax(axis=-1) self.matmul_qk = MatMulWrapper() self.matmul_qkv = MatMulWrapper()
def __init__(self, block, layers, num_filters, feature_dim, encoder_type='SAP', n_mels=40, log_input=True, **kwargs): super(ResNetSE, self).__init__() print('Embedding size is %d, encoder %s.' % (feature_dim, encoder_type)) self.inplanes = num_filters[0] self.encoder_type = encoder_type self.n_mels = n_mels self.log_input = log_input self.conv1 = nn.Conv2D(1, num_filters[0], kernel_size=3, stride=1, padding=1) self.relu = nn.ReLU() self.bn1 = nn.BatchNorm2D(num_filters[0]) self.layer1 = self._make_layer(block, num_filters[0], layers[0]) self.layer2 = self._make_layer(block, num_filters[1], layers[1], stride=(2, 2)) self.layer3 = self._make_layer(block, num_filters[2], layers[2], stride=(2, 2)) self.layer4 = self._make_layer(block, num_filters[3], layers[3], stride=(2, 2)) outmap_size = int(self.n_mels / 8) self.attention = nn.Sequential( nn.Conv1D(num_filters[3] * outmap_size, 128, kernel_size=1), nn.ReLU(), nn.BatchNorm1D(128), nn.Conv1D(128, num_filters[3] * outmap_size, kernel_size=1), nn.Softmax(axis=2), ) if self.encoder_type == "SAP": out_dim = num_filters[3] * outmap_size elif self.encoder_type == "ASP": out_dim = num_filters[3] * outmap_size * 2 else: raise ValueError('Undefined encoder') self.fc = nn.Linear(out_dim, feature_dim)
def __init__(self, num_state, num_node, bias=False): super(GCN, self).__init__() self.conv1 = nn.Conv1D(num_node, num_node, kernel_size=1) self.relu = nn.ReLU() self.conv2 = nn.Conv1D(num_state, num_state, kernel_size=1, bias_attr=bias)
def __init__(self, feature_channels=256, num_classes=50, max_points=1024): super(VFE_Seg, self).__init__() self.max_points = max_points self.vfe = VFE(feature_channels, max_points) self.seg_net = nn.Sequential( nn.Conv1D(max_points + feature_channels * 2, 512, 1), nn.BatchNorm(512), nn.ReLU(), nn.Conv1D(512, 256, 1), nn.BatchNorm(256), nn.ReLU(), nn.Conv1D(256, 128, 1), nn.BatchNorm(128), nn.ReLU(), nn.Conv1D(128, 128, 1), nn.BatchNorm(128), nn.ReLU(), nn.Conv1D(128, num_classes, 1))
def __init__(self, vocab_size, emb_dim=256, hidden_size=512, kernel_size=9, n_layers=32, padding_idx=0, dropout_rate=0.1, epsilon=1e-6): super(ResnetEncoderModel, self).__init__() self.hidden_size = hidden_size self.n_layers = n_layers self.token_embedding = nn.Embedding(vocab_size, emb_dim, padding_idx=padding_idx) max_pos_len = 3000 self.pos_embedding = nn.Embedding(max_pos_len, emb_dim, padding_idx=padding_idx) self.padded_conv = nn.Sequential( nn.BatchNorm1D(emb_dim, data_format="NLC"), nn.ReLU(), nn.Conv1D(in_channels=emb_dim, out_channels=hidden_size, kernel_size=kernel_size, padding="same", \ data_format="NLC", weight_attr=nn.initializer.KaimingNormal()), nn.Dropout(p=dropout_rate) ) self.residual_block_1 = nn.Sequential( nn.BatchNorm1D(hidden_size, data_format="NLC"), nn.ReLU(), nn.Conv1D(in_channels=hidden_size, out_channels=hidden_size, kernel_size=kernel_size, padding="same", \ data_format="NLC", weight_attr=nn.initializer.KaimingNormal()), nn.Dropout(p=dropout_rate), nn.BatchNorm1D(hidden_size, data_format="NLC"), nn.ReLU(), nn.Conv1D(in_channels=hidden_size, out_channels=hidden_size, kernel_size=kernel_size, padding="same", \ data_format="NLC", weight_attr=nn.initializer.KaimingNormal()), nn.Dropout(p=dropout_rate) ) self.residual_block_n = nn.Sequential( nn.BatchNorm1D(hidden_size, data_format="NLC"), nn.ReLU(), nn.Conv1D(in_channels=hidden_size, out_channels=hidden_size, kernel_size=kernel_size, dilation=2, \ padding="same", data_format="NLC", weight_attr=nn.initializer.KaimingNormal()), nn.Dropout(p=dropout_rate), nn.BatchNorm1D(hidden_size, data_format="NLC"), nn.ReLU(), nn.Conv1D(in_channels=hidden_size, out_channels=hidden_size, kernel_size=kernel_size, dilation=2, \ padding="same", data_format="NLC", weight_attr=nn.initializer.KaimingNormal()), nn.Dropout(p=dropout_rate) )
def __init__(self, num_classes=50, max_points=1024): super(PointNet_Basic_Seg, self).__init__() self.max_points = max_points self.pointnet_bacic = PointNet_Basic(max_points) self.seg_net = nn.Sequential(nn.Conv1D(max_points + 64, 512, 1), nn.BatchNorm(512), nn.ReLU(), nn.Conv1D(512, 256, 1), nn.BatchNorm(256), nn.ReLU(), nn.Conv1D(256, 128, 1), nn.BatchNorm(128), nn.ReLU(), nn.Conv1D(128, 128, 1), nn.BatchNorm(128), nn.ReLU(), nn.Conv1D(128, num_classes, 1))
def __init__(self, name_scope='KDNet_', num_classes=10): super(KDNet, self).__init__() self.conv1 = nn.Conv1D(3, 32 * 3, 1, 1) self.conv2 = nn.Conv1D(32, 64 * 3, 1, 1) self.conv3 = nn.Conv1D(64, 64 * 3, 1, 1) self.conv4 = nn.Conv1D(64, 128 * 3, 1, 1) self.conv5 = nn.Conv1D(128, 128 * 3, 1, 1) self.conv6 = nn.Conv1D(128, 256 * 3, 1, 1) self.conv7 = nn.Conv1D(256, 256 * 3, 1, 1) self.conv8 = nn.Conv1D(256, 512 * 3, 1, 1) self.conv9 = nn.Conv1D(512, 512 * 3, 1, 1) self.conv10 = nn.Conv1D(512, 128 * 3, 1, 1) self.fc = nn.Linear(128, num_classes)
def __init__(self, in_dim): super().__init__() self.channle_in = in_dim self.query_conv = nn.Conv1D( in_channels=in_dim, out_channels=in_dim // 2, kernel_size=1) self.key_conv = nn.Conv1D( in_channels=in_dim, out_channels=in_dim // 2, kernel_size=1) self.value_conv_vis = nn.Conv1D( in_channels=in_dim, out_channels=in_dim, kernel_size=1) self.value_conv_word = nn.Conv1D( in_channels=in_dim, out_channels=in_dim, kernel_size=1) self.softmax_vis = nn.Softmax(axis=-1) self.softmax_word = nn.Softmax(axis=-2)
def __init__(self, vocab_size, num_class, emb_dim=512, hidden_size=512, head_num=4, layer_num=4, padding_idx=0, epsilon=1e-5, dropout_rate=0.1): """Init model Args: vocab_size (int): vocab size. num_class (int): num classes. emb_dim (int, optional): embeding dimension. Defaults to 512. hidden_size (int, optional): hidden size. Defaults to 512. head_num (int, optional): head_num. Defaults to 4. layer_num (int, optional): layer num. Defaults to 4. padding_idx (int, optional): padding index. Defaults to 0. epsilon (float, optional): epsilon. Defaults to 1e-5. dropout_rate (float, optional): dropout rate. Defaults to 0.1. """ super().__init__() self.padding_idx = padding_idx self.embedder = nn.Embedding(vocab_size, emb_dim, padding_idx=padding_idx) self.layer_norm = nn.LayerNorm(normalized_shape=emb_dim, epsilon=epsilon) self.dropout = nn.Dropout(p=dropout_rate) self.transformer_encoder = TransformerEncoder( d_model=emb_dim, nhead=head_num, num_encoder_layers=layer_num, dim_feedforward=hidden_size * 4, dropout=dropout_rate, attn_dropout=dropout_rate, act_dropout=dropout_rate, ) in_channels = hidden_size self.conv_encoder = nn.Conv1D(in_channels=in_channels, out_channels=hidden_size, kernel_size=5, padding=2) self.output_layer = nn.Conv1D(in_channels=hidden_size, out_channels=num_class, kernel_size=3, padding=1)
def __init__(self, max_len, latent_dim): super(CNNEncoder, self).__init__() self.latent_dim = latent_dim self.max_len = max_len self.conv1 = nn.Conv1D(DECISION_DIM, 9, 9) self.conv2 = nn.Conv1D(9, 9, 9) self.conv3 = nn.Conv1D(9, 10, 11) self.last_conv_size = max_len - 9 + 1 - 9 + 1 - 11 + 1 self.w1 = nn.Linear(self.last_conv_size * 10, 435) self.mean_w = nn.Linear(435, latent_dim) self.log_var_w = nn.Linear(435, latent_dim) weights_init(self)
def __init__( self, in_channels, out_channels, kernel_size, stride=1, padding="same", dilation=1, groups=1, bias=True, padding_mode="reflect", ): super(Conv1d, self).__init__() self.kernel_size = kernel_size self.stride = stride self.dilation = dilation self.padding = padding self.padding_mode = padding_mode self.conv = nn.Conv1D( in_channels, out_channels, self.kernel_size, stride=self.stride, padding=0, dilation=self.dilation, groups=groups, bias_attr=bias, )
def __init__(self, cin, cout, groups, act): super().__init__() self.conv1d = nn.Conv1D(in_channels=cin, out_channels=cout, kernel_size=1, groups=groups) self.act = ACT2FN[act]
def __init__(self, config): super(ProteinSequenceModel, self).__init__() self.config = config self.output_dim = config['output_dim'] self.embed_dim = config['embed_dim'] self.max_protein_len = config['max_protein_len'] self.vocab_size = len(ProteinTokenizer.vocab) self.num_filters = config.get('num_filters', 32) self.pool_type = config.get('pool_type', 'mean') self.initializer_range = config.get('initializer_range', 0.02) self.protein_embeddings = nn.Embedding( self.vocab_size, self.embed_dim, weight_attr=nn.initializer.TruncatedNormal( std=self.initializer_range)) self.conv1d = nn.Conv1D(self.embed_dim, self.num_filters, kernel_size=8, padding='SAME', data_format='NLC') if self.max_protein_len < 0: self.fc = nn.Linear(self.num_filters, self.output_dim) else: self.fc = nn.Linear(self.num_filters * self.max_protein_len, self.output_dim)
def __init__(self, in_channels, out_channels, kernel_size, padding=0, stride=1, conv_cfg='Conv1D', norm_cfg='None', **kwargs): super().__init__() if (conv_cfg == 'Conv1D'): self._conv = nn.Conv1D(in_channels, out_channels, kernel_size, stride=stride, padding=padding, **kwargs) if (conv_cfg == 'Conv2D'): self._conv = nn.Conv2D(in_channels, out_channels, kernel_size, stride=stride, padding=padding, **kwargs) if 'data_format' in kwargs: data_format = kwargs['data_format'] else: data_format = 'NCHW' if (norm_cfg != 'None'): self._batch_norm = layers.SyncBatchNorm(out_channels, data_format=data_format) else: self._batch_norm = None
def __init__(self, vocab_text_size, vocab_tag_size, emb_dim, hid_dim, win_size, margin, neg_size, text_len): super(TagspaceLayer, self).__init__() self.vocab_text_size = vocab_text_size self.vocab_tag_size = vocab_tag_size self.emb_dim = emb_dim self.hid_dim = hid_dim self.win_size = win_size self.margin = margin self.neg_size = neg_size self.text_len = text_len self.text_embedding = paddle.nn.Embedding( self.vocab_text_size, self.emb_dim, padding_idx=75377, sparse=True, name="text_emb") self.tag_embedding = paddle.nn.Embedding( self.vocab_tag_size, self.emb_dim, sparse=True, name="tag_emb") self.conv = nn.Conv1D( in_channels=self.emb_dim, out_channels=self.hid_dim, kernel_size=self.win_size, data_format='NLC') self.hid_fc = paddle.nn.Linear( in_features=self.hid_dim, out_features=self.emb_dim, name="text_hid")
def __init__(self, vocab_size, num_class, emb_dim=512, hidden_size=512, n_lstm_layer=3, is_bidirectory=True, padding_idx=0, epsilon=1e-5, dropout_rate=0.1): """Init model Args: vocab_size (int): vocab size. num_class (int): num of classes. emb_dim (int, optional): embedding dimmension. Defaults to 512. hidden_size (int, optional): hidden size. Defaults to 512. n_lstm_layer (int, optional): number of lstm layer. Defaults to 3. is_bidirectory (bool, optional): use bidirect lstm. Defaults to True. padding_idx (int, optional): padding index. Defaults to 0. epsilon (float, optional): epsilon. Defaults to 1e-5. dropout_rate (float, optional): dropout rate. Defaults to 0.1. """ super().__init__() self.padding_idx = padding_idx self.embedder = nn.Embedding(vocab_size, emb_dim, padding_idx=padding_idx) self.layer_norm = nn.LayerNorm(normalized_shape=emb_dim, epsilon=epsilon) self.dropout = nn.Dropout(p=dropout_rate) direction = 'bidirectional' if is_bidirectory else 'forward' self.lstm_encoder = nn.LSTM(emb_dim, hidden_size, num_layers=n_lstm_layer, direction=direction) # kernel_size = (5, hidden_size * 2) if is_bidirectory else (5, hidden_size) in_channels = hidden_size * 2 if is_bidirectory else hidden_size self.conv_encoder = nn.Conv1D(in_channels=in_channels, out_channels=hidden_size, kernel_size=5, padding=2) self.output_layer = nn.Conv1D(in_channels=hidden_size, out_channels=num_class, kernel_size=3, padding=1)
def __init__(self, inplanes=256, planes=256, kernel_size=9, dilation=1, dropout_rate=0.1): super(ResnetBasicBlock, self).__init__() self.conv1 = nn.Conv1D(in_channels=inplanes, out_channels=planes, kernel_size=kernel_size, dilation=dilation, \ padding="same", data_format="NLC", weight_attr=nn.initializer.KaimingNormal()) self.bn1 = nn.BatchNorm1D(planes, data_format="NLC") self.gelu1 = nn.GELU() self.dropout1 = nn.Dropout(p=dropout_rate) self.conv2 = nn.Conv1D(in_channels=planes, out_channels=planes, kernel_size=kernel_size, dilation=dilation, \ padding="same", data_format="NLC", weight_attr=nn.initializer.KaimingNormal()) self.bn2 = nn.BatchNorm1D(planes, data_format="NLC") self.gelu2 = nn.GELU() self.dropout2 = nn.Dropout(p=dropout_rate)
def __init__(self, cin, cout, groups, dropout_prob): super().__init__() self.conv1d = nn.Conv1D(in_channels=cin, out_channels=cout, kernel_size=1, groups=groups) self.layernorm = SqueezeBertLayerNorm(cout) self.dropout = nn.Dropout(dropout_prob)
def conv1d(ni: int, no: int, ks: int = 1, stride: int = 1, padding: int = 0, bias: bool = False): "Create and initialize a `nn.Conv1d` layer with spectral normalization." conv = nn.Conv1D(ni, no, ks, stride=stride, padding=padding, bias_attr=bias) return Spectralnorm(conv)
def __init__(self, in_channel, mlp): super(PointNetFeaturePropagation, self).__init__() self.mlp_convs = [] self.mlp_bns = [] last_channel = in_channel for out_channel in mlp: self.mlp_convs.append(nn.Conv1D(last_channel, out_channel, 1)) self.mlp_bns.append(nn.BatchNorm1D(out_channel)) last_channel = out_channel
def __init__(self, num_state=128, num_node=64, bias=False): super().__init__() self.conv1 = nn.Conv1D( num_node, num_node, kernel_size=1, padding=0, stride=1, groups=1, ) self.relu = nn.ReLU() self.conv2 = nn.Conv1D(num_state, num_state, kernel_size=1, padding=0, stride=1, groups=1, bias_attr=bias)
def __init__(self, n_inputs, n_outputs, kernel_size, stride, dilation, padding, dropout=0.2): super(TemporalBlock, self).__init__() self.conv1 = weight_norm( nn.Conv1D( n_inputs, n_outputs, kernel_size, stride=stride, padding=padding, dilation=dilation)) # Chomp1d is used to make sure the network is causal. # We pad by (k-1)*d on the two sides of the input for convolution, # and then use Chomp1d to remove the (k-1)*d output elements on the right. self.chomp1 = Chomp1d(padding) self.relu1 = nn.ReLU() self.dropout1 = nn.Dropout(dropout) self.conv2 = weight_norm( nn.Conv1D( n_outputs, n_outputs, kernel_size, stride=stride, padding=padding, dilation=dilation)) self.chomp2 = Chomp1d(padding) self.relu2 = nn.ReLU() self.dropout2 = nn.Dropout(dropout) self.net = nn.Sequential(self.conv1, self.chomp1, self.relu1, self.dropout1, self.conv2, self.chomp2, self.relu2, self.dropout2) self.downsample = nn.Conv1D(n_inputs, n_outputs, 1) if n_inputs != n_outputs else None self.relu = nn.ReLU() self.init_weights()
def __init__(self, in_channels=3, out_channels=3, kernel_size=3, *args): super(Block, self).__init__() self.nn = nn.Sequential( nn.Conv1D(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, padding=0, bias_attr=False), nn.BatchNorm1D(num_features=out_channels), nn.LeakyReLU(.2), nn.Dropout(p=.2))
def __init__(self, config): super().__init__() self.conv = nn.Conv1D( config.hidden_size, config.hidden_size, kernel_size=config.num_conv_pos_embeddings, padding=config.num_conv_pos_embeddings // 2, groups=config.num_conv_pos_embedding_groups, ) # self.conv = nn.utils.weight_norm(self.conv, name="weight", axis=2) self.padding = Wav2Vec2SamePadLayer(config.num_conv_pos_embeddings) self.activation = ACT2FN[config.feat_extract_activation]
def __init__(self, max_points=1024): super(PointNet_Basic, self).__init__() self.mlp_1 = nn.Sequential( nn.Conv1D(3, 64, 1), nn.BatchNorm(64), nn.ReLU(), nn.Conv1D(64, 64, 1), nn.BatchNorm(64), nn.ReLU(), ) self.mlp_2 = nn.Sequential( nn.Conv1D(64, 64, 1), nn.BatchNorm(64), nn.ReLU(), nn.Conv1D(64, 128, 1), nn.BatchNorm(128), nn.ReLU(), nn.Conv1D(128, max_points, 1), nn.BatchNorm(max_points), nn.ReLU(), )
def __init__(self, n_fft: int = 2048, hop_length: Optional[int] = None, win_length: Optional[int] = None, window: str = 'hann', center: bool = True, pad_mode: str = 'reflect', one_sided: bool = True, dtype: str = 'float64'): super(STFT, self).__init__() assert pad_mode in ['constant', 'reflect' ], ('pad_mode must be choosen ' + 'between "constant" and "reflect", ' + f'but received pad_mode={pad_mode} instead') self.n_fft = n_fft self.hop_length = hop_length self.win_length = win_length self.window = window self.center = center self.pad_mode = pad_mode # By default, use the entire frame. if self.win_length is None: self.win_length = n_fft # Set the default hop, if it's not already specified. if self.hop_length is None: self.hop_length = int(self.win_length // 4) fft_window = F.get_window(window, self.win_length, fftbins=True, dtype=dtype) fft_window = F.center_padding(fft_window, n_fft) # DFT & IDFT matrix. dft_mat = F.dft_matrix(n_fft, dtype=dtype) if one_sided: out_channels = n_fft // 2 + 1 else: out_channels = n_fft self.conv = nn.Conv1D(1, out_channels * 2, n_fft, stride=self.hop_length, bias_attr=False) weight = fft_window.unsqueeze([1, 2]) * dft_mat[:, 0:out_channels, :] weight = weight.transpose([1, 2, 0]) weight = weight.reshape([-1, weight.shape[-1]]) self.conv.load_dict({'weight': weight.unsqueeze(1).astype('float32')}) # by default, the STFT is not learnable for param in self.parameters(): param.stop_gradient = True
def __init__(self, name_scope='PointNet2_SSG_Seg_', num_classes=16, num_parts=50, normal_channel=False): super(PointNet2_SSG_Seg, self).__init__() if normal_channel: additional_channel = 3 else: additional_channel = 0 self.num_classes = num_classes self.normal_channel = normal_channel self.sa1 = PointNetSetAbstraction(npoint=512, radius=0.2, nsample=32, in_channel=6 + additional_channel, mlp=[64, 64, 128], group_all=False) self.sa2 = PointNetSetAbstraction(npoint=128, radius=0.4, nsample=64, in_channel=128 + 3, mlp=[128, 128, 256], group_all=False) self.sa3 = PointNetSetAbstraction(npoint=None, radius=None, nsample=None, in_channel=256 + 3, mlp=[256, 512, 1024], group_all=True) self.fp3 = PointNetFeaturePropagation(in_channel=1280, mlp=[256, 256]) self.fp2 = PointNetFeaturePropagation(in_channel=384, mlp=[256, 128]) self.fp1 = PointNetFeaturePropagation(in_channel=128 + 16 + 6 + additional_channel, mlp=[128, 128, 128]) self.conv1 = nn.Conv1D(128, 128, 1) self.bn1 = nn.BatchNorm1D(128) self.drop1 = nn.Dropout(0.5) self.conv2 = nn.Conv1D(128, num_parts, 1)
def __init__(self, config, layer_id=0): super().__init__() self.in_conv_dim = config.conv_dim[layer_id] if layer_id > 0 else 1 self.out_conv_dim = config.conv_dim[layer_id] self.conv = nn.Conv1D( self.in_conv_dim, self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], stride=config.conv_stride[layer_id], bias_attr=config.conv_bias, ) self.activation = ACT2FN[config.feat_extract_activation]