def __init__(self, input_size, channel_last=True, hidden_size=50, **kwargs): # Defaults self.input_length = 20 self.input_size = input_size self.hidden_size = hidden_size self.num_classes = 2 self.label_embedding_size = self.num_classes self.prob_classes = torch.ones(self.num_classes) self.dropout = 0.5 self.label_type = 'required' self.channel_last = channel_last # Set kwargs (might overried above attributes) for key, value in kwargs.items(): setattr(self, key, value) super(CNNCGANDiscriminator, self).__init__(self.input_size, self.label_type) # Build CNN layer self.label_embeddings = nn.Embedding(self.num_classes, self.label_embedding_size) Conv1d_ = lambda k: Conv1d(hidden_size, hidden_size, k) layers_input_size = self.input_size + self.label_embedding_size layers_output_size = 5 * hidden_size ## Build CNN layer self.layers = nn.Sequential( Conv1d(layers_input_size, hidden_size, 1), LeakyReLU(0.2), # output size: (-1, 50, 20) Conv1d_(3), ReplicationPad1d(1), LeakyReLU(0.2), Conv1d_(3), ReplicationPad1d(1), LeakyReLU(0.2), AvgPool1d(2, 2), # output size: (-1, 50, 10) Conv1d_(3), ReplicationPad1d(1), LeakyReLU(0.2), Conv1d_(3), ReplicationPad1d(1), LeakyReLU(0.2), AvgPool1d(2, 2), # output size: (-1, 50, 5) Flatten(), Linear(layers_output_size, 1) # output size: (-1, 1) ) # Initialize all weights. self._weight_initializer()
def __init__(self): super(MultiScaleDiscriminator, self).__init__() self.discriminators = nn.ModuleList([ DiscriminatorS(use_spectral_norm=True), DiscriminatorS(), DiscriminatorS(), ]) self.meanpools = nn.ModuleList( [AvgPool1d(4, 2, padding=2), AvgPool1d(4, 2, padding=2)])
def __init__(self, debug=False): super().__init__() self.discriminators = nn.ModuleList( [ DiscriminatorS(use_spectral_norm=True, debug=debug), DiscriminatorS(debug=debug), DiscriminatorS(debug=debug), ] ) self.meanpools = nn.ModuleList([AvgPool1d(4, 2, padding=2), AvgPool1d(4, 2, padding=2)])
def __init__(self): super(MultiScaleDiscriminator, self).__init__() self.discriminators = nn.ModuleList([ Discriminator(), Discriminator(), Discriminator(), ]) self.meanpools = nn.ModuleList( [AvgPool1d(4, 2, padding=2), AvgPool1d(4, 4, padding=2)])
def __init__(self, out_channels, kernel_size, stride, dilation): super(cnnseq, self).__init__() self.Conv=Conv1d(in_channels=1,out_channels=out_channels,\ kernel_size=kernel_size,\ stride=stride,padding=0,dilation=dilation) self.pool = AvgPool1d(kernel_size=5, stride=3) self.Conv2=Conv1d(in_channels=out_channels,\ out_channels=out_channels,kernel_size=3,stride=stride,dilation=dilation) self.act = ReLU() self.pool2 = AvgPool1d(kernel_size=3, stride=2) self.linear = Linear(out_channels * 4, 1) self.sigm = Sigmoid()
def __init__(self, use_cond=False, c_in=1): super(MultiScaleDiscriminator, self).__init__() from utils.commons.hparams import hparams self.discriminators = nn.ModuleList([ DiscriminatorS(use_spectral_norm=True, use_cond=use_cond, upsample_rates=[4, 4, hparams['hop_size'] // 16], c_in=c_in), DiscriminatorS(use_cond=use_cond, upsample_rates=[4, 4, hparams['hop_size'] // 32], c_in=c_in), DiscriminatorS(use_cond=use_cond, upsample_rates=[4, 4, hparams['hop_size'] // 64], c_in=c_in), ]) self.meanpools = nn.ModuleList( [AvgPool1d(4, 2, padding=1), AvgPool1d(4, 2, padding=1)])
def __init__(self, num_labels: int, hidden_size: int, max_seq_length: int, filter_size: int = 9, out_channels: int = 16, padding=True, hidden_dropout_prob: float = 0.1) -> Tensor: super().__init__() self.dropout = Dropout(hidden_dropout_prob) padding_size = int((filter_size - 1) / 2) if padding else 0 self.conv1 = Conv1d(in_channels=hidden_size, out_channels=out_channels, kernel_size=filter_size, padding=padding_size) self.max_pool = AvgPool1d(kernel_size=2) self.classifier_in_size = int(out_channels * max_seq_length / 2) if padding else \ int((out_channels * (max_seq_length - filter_size + 1)) / 2) self.classifier = Linear(self.classifier_in_size, num_labels)
def __init__(self, in_channels: int): """Initialize the layers.""" super().__init__() self.layers = Sequential( self._get_conv_block(in_channels, 64, kernel_size=5), # 512 => 256 self._get_conv_block(64, 64, kernel_size=5), # 256 => 128 self._get_conv_block(64, 128), # 128 => 64 self._get_conv_block(128, 128, stride=1), # 64 => 64 self._get_conv_block(128, 256, stride=1), # 64 => 64 AvgPool1d(kernel_size=2), # 64 => 32 )
def avg_pool1d(): """ 一维均值池化器 @:param kernel_size – the size of the window @:param stride – the stride of the window. Default value is kernel_size @:param padding – implicit zero padding to be added on both sides @:param ceil_mode – when True, will use ceil instead of floor to compute the output shape @:param count_include_pad – when True, will include the zero-padding in the averaging calculation """ pool = AvgPool1d(kernel_size=3, stride=1) input = tensor([[[0, 1, 2, 2, 3, 3, 3, 4, 4, 4]]], dtype=float32) output = pool(input) print(output)
def __init__(self, in_channel,out_channel,cnn_ker,cnn_stride,\ pool_stride,pool_ker ,bn): super(CnnModule, self).__init__() mylist=ModuleList() mylist.append(Conv1d(in_channel,out_channel, kernel_size=cnn_ker, \ stride=cnn_stride, padding=0, bias=False)) if bn==1: mylist.append(BatchNorm1d(out_channel)) if pool_ker>0: mylist.append( AvgPool1d(kernel_size=pool_ker,stride=pool_stride)) self.mylist=Sequential(*mylist)
def __init__(self, input_shape=(1280, 64), n_classes=3): super(LexNet, self).__init__() self.c1 = Conv1d(64, 256, kernel_size=2) l = input_shape[0] l -= 1 self.c2 = Conv1d(256, 128, kernel_size=2) l -= 1 self.pool = AvgPool1d(kernel_size=2) l = int(np.floor(((l - 2) / 2.) + 1)) self.d1 = Dropout(0.25) self.c3 = Conv1d(128, 128, kernel_size=2) l -= 1 self.d2 = Dropout(0.25) l = int(np.floor(((l - 2) / 2.) + 1)) self.mlp = MLP([l * 128, 128, 128]) self.final = Lin(128, 3) self.soft = nn.Softmax()
def forward(self, words_embed, chr_rep): attention_coefficients = self._calc_attention_coefficients() # dynamic average and max pool according to batch sentence length activate_avg_pool = AvgPool1d(words_embed.shape[1], 1) activate_max_pool = MaxPool1d(words_embed.shape[1], 1) # embed_word concat with embed chr level -> Bi-LSTM layer x = self._embeddings(words_embed) x = torch.cat([x, chr_rep], dim=2) # 3 layers Bi-LSTM + skip connections + dropout layers in between output_seq, _ = self._lstm_layer_0(x) output_seq = self._dropout_0(output_seq) output_seq, _ = self._lstm_layer_1(torch.cat([x, output_seq], dim=2)) output_seq = self._dropout_1(output_seq) output_seq, _ = self._lstm_layer_2(torch.cat([x, output_seq], dim=2)) output_seq = self._dropout_2(output_seq) # final vec + attention avg_pool = activate_avg_pool(output_seq.transpose(1, 2)).squeeze(dim=2) max_pool = activate_max_pool(output_seq.transpose(1, 2)).squeeze(dim=2) gate_attention = torch.sum(output_seq * attention_coefficients, dim=1) x = torch.cat([gate_attention, avg_pool, max_pool], dim=1) return x
def __init__(self, n_filters_time, filter_time_length, n_filters_spat, pool_time_length, pool_time_stride, conv_nonlin, pool_mode, pool_nonlin, batch_norm, batch_norm_alpha, drop_prob, final_conv_length, **kwargs): super().__init__(**kwargs) self.sequential = Sequential() split_cnn = SplitConv(in_size=self.input_size, middle_size=n_filters_time, out_size=n_filters_spat, time_kernel_size=filter_time_length, input_in_rnn_format=False) self.sequential.add_module('split_cnn', split_cnn) if batch_norm: bn = BatchNorm1d(n_filters_spat) self.sequential.add_module('batch_norm', bn) non_lin = Expression(square) self.sequential.add_module('non_lin_0', non_lin) pool = AvgPool1d(kernel_size=pool_time_length, stride=pool_time_stride) self.sequential.add_module('pool_1', pool) # non_lin = Expression(safe_log) self.sequential.add_module('non_lin_1', non_lin) dropout = Dropout(p=drop_prob) self.sequential.add_module('dropout', dropout) conv = nn.Conv1d(in_channels=n_filters_spat, out_channels=self.output_size, kernel_size=final_conv_length, bias=True) self.sequential.add_module('conv', conv)
def __init__(self, kernel_size, stride, padding): super(ChannelPool3d, self).__init__(kernel_size, stride, padding) self.pool_1d = AvgPool1d(self.kernel_size, self.stride, self.padding, self.ceil_mode)
def dim_reduce(t): m = AvgPool1d(20) t = m(t.unsqueeze(1)) return t.squeeze()
def forward(self, words_embed, pos_embed, ner_embed, chr_rep, semantic_tree, per_mask, org_mask): attention_coefficients_i, attention_coefficients_o = self._calc_attention_coefficients( ) # dynamic average and max pool according to batch sentence length activate_avg_pool = AvgPool1d(words_embed.shape[1], 1) activate_max_pool = MaxPool1d(words_embed.shape[1], 1) # concat following [ semantic_parent | chr_embed | word_embed | POS_embed | NER_embed ] semantic_tree = semantic_tree.unsqueeze(dim=2) embed_word = self._embeddings_words(words_embed) x = torch.cat([ semantic_tree, chr_rep, embed_word, self._embeddings_pos(pos_embed), self._embeddings_ner(ner_embed) ], dim=2) # ========================================= ENCODER ========================================= # 3 layers Bi-LSTM + skip connections + dropout layers in between output_seq, _ = self._encoder_layer_0(x) output_seq = self._dropout(output_seq) output_seq, _ = self._encoder_layer_1( torch.cat([semantic_tree, chr_rep, embed_word, output_seq], dim=2)) output_seq = self._dropout(output_seq) output_seq, _ = self._encoder_layer_2( torch.cat([semantic_tree, chr_rep, embed_word, output_seq], dim=2)) # attention avg_pool = activate_avg_pool(output_seq.transpose(1, 2)).squeeze(dim=2) max_pool = activate_max_pool(output_seq.transpose(1, 2)).squeeze(dim=2) gate_attention_i = torch.sum(output_seq * attention_coefficients_i, dim=1) gate_attention_o = torch.sum(output_seq * attention_coefficients_o, dim=1) x = torch.cat([gate_attention_i, gate_attention_o, avg_pool, max_pool], dim=1).unsqueeze(dim=1) x = torch.stack([x.squeeze(dim=1) for _ in range(embed_word.shape[1])]).transpose(0, 1) # ========================================= DECODER ========================================= output_seq, _ = self._decoder_layer_0( torch.cat([chr_rep, embed_word, x], dim=2)) output_seq = self._dropout(output_seq) output_seq, _ = self._decoder_layer_1( torch.cat([chr_rep, embed_word, output_seq], dim=2)) output_seq = self._dropout(output_seq) output_seq, _ = self._decoder_layer_2( torch.cat([chr_rep, embed_word, output_seq], dim=2)) per_mask = torch.stack([per_mask for _ in range(output_seq.shape[2])], dim=2).float() org_mask = torch.stack([org_mask for _ in range(output_seq.shape[2])], dim=2).float() max_pool = MaxPool1d(output_seq.shape[1]) per_org_rep = torch.cat([ max_pool((per_mask * output_seq).transpose(1, 2)).squeeze(dim=2), max_pool((org_mask * output_seq).transpose(1, 2)).squeeze(dim=2) ], dim=1) # per_org_rep = torch.cat([torch.sum((org_mask*output_seq), dim=1), # torch.sum((per_mask*output_seq), dim=1)], dim=1) return per_org_rep