def __init__(self, **kwargs): super(FeatureBlock1, self).__init__(**kwargs) self.gru = rnn.GRU(128,layout='NTC',bidirectional=True, num_layers=1, dropout=0.2) self.conv3 = nn.Conv1D(channels=128, kernel_size=3, padding=1, strides=1, activation='relu') self.conv5 = nn.Conv1D(channels=128, kernel_size=3, padding=1, strides=1, activation='relu') self.conv7 = nn.Conv1D(channels=128, kernel_size=3, padding=1, strides=1, activation='relu') # self.gru_post_max = nn.MaxPool1D(pool_size=2) # self.gru_post_ave = nn.AvgPool1D(pool_size=2) self.gru_maxpool = nn.GlobalMaxPool1D() self.conv_maxpool = nn.GlobalMaxPool1D() ''' self.gru_avepool = nn.GlobalAvgPool1D() self.conv_avepool = nn.GlobalAvgPool1D() ''' self.conv_drop = nn.Dropout(0.5)
def __init__(self, n_dims, n_actions, hidden_dims=(32, 32), **kwargs): super(Net, self).__init__(**kwargs) self.n_dims = n_dims self.n_actions = n_actions self.hidden_dims = hidden_dims with self.name_scope(): self.embedding = nn.Embedding( 256, output_dim=16) # suggestion: not greater than 16 self.bn = nn.BatchNorm() # TODO: is this necessary? self.conv1 = nn.Conv1D(channels=32, kernel_size=3, activation='relu', padding=0, strides=1) self.conv2 = nn.Conv1D(channels=32, kernel_size=3, activation='relu', padding=0, strides=1) self.pool = nn.GlobalMaxPool1D() self.h1 = nn.Dense(32, activation='relu') self.h2 = nn.Dense(32, activation='relu') #for h_dim in self.hidden_dims: # x = Dense(h_dim, activation='relu')(x) # x = Dropout(0.2)(x) self.output = nn.Dense(self.n_actions, use_bias=False)
def __init__(self): super(WordContextNet, self).__init__() with self.name_scope(): self.embedding = nn.Embedding(vocab_size, region_size * emb_size) self.embedding_region = nn.Embedding(vocab_size, emb_size) self.max_pool = nn.GlobalMaxPool1D() self.dense = nn.Dense(n_classes)
def __init__(self): super(Net, self).__init__() with self.name_scope(): self.embedding = nn.Embedding(vocab_size, region_size * emb_size) self.embedding_region = nn.Embedding(vocab_size, emb_size) self.max_pool = nn.GlobalMaxPool1D() self.dense = nn.Dense(n_classes) self.dense1 = nn.Dense(max_sequence_length * 2, activation='relu') self.dense2 = nn.Dense(1)
def __init__(self, emb_size, **kwargs): super(GatedBlock, self).__init__(**kwargs) with self.name_scope(): self.W_a = self.params.get('gated_block_W_a', shape=(emb_size, emb_size)) self.W_b = self.params.get('gated_block_W_b', shape=(emb_size, emb_size)) self.b = self.params.get('gated_block_b', shape=emb_size) self.maxpooling = nn.GlobalMaxPool1D(layout='NWC')
def __init__(self, config, kernel_idx=0, **kwargs): super(ParaConvpool, self).__init__(**kwargs) with self.name_scope(): self.conv = nn.Conv2D( channels=config['feature_map'] * config['num_neighbor'], kernel_size=(config['kernel_size'][kernel_idx], config['embedding_dim']), strides=(1, config['embedding_dim']), groups=config['num_neighbor']) self.pooling = nn.GlobalMaxPool1D() self.norm = nn.BatchNorm(axis=1)
def __init__(self, voc, w2v_size, k_sizes, n_channels, **kwargs): super(TextCNN, self).__init__(**kwargs) self.embedding = nn.Embedding(len(voc), w2v_size) self.convs = nn.HybridSequential() for k, c in zip(k_sizes, n_channels): self.convs.add(nn.Conv1D(c, k, activation='relu')) self.pooling = nn.GlobalMaxPool1D() self.dropout_1 = nn.Dropout(0.3) self.dense_h = nn.Dense(6, activation='relu') self.dropout_2 = nn.Dropout(0.6) self.dense = nn.Dense(2) self.flat = nn.Flatten()
def __init__(self, vocab, embed_size, kernel_sizes, num_channels, **kwargs): super(Weibo_TextCNN, self).__init__(**kwargs) self.embedding = nn.Embedding( len(vocab), embed_size) # embed_size defined by fasttext model self.constant_embedding = nn.Embedding(len(vocab), embed_size) # stay constant self.convs = create_con_1d(num_channels, kernel_sizes) self.maxpool = nn.GlobalMaxPool1D( ) # connect a GloablMax after the convs self.dropout = nn.Dropout(0.5) self.decoder = nn.Dense(2) # we have two output
def __init__(self, vocab, embed_size, kernel_sizes, num_channels, **kwargs): super(TextCNN, self).__init__(**kwargs) self.embedding = nn.Embedding(len(vocab), embed_size) # 不参与训练的嵌入层 self.constant_embedding = nn.Embedding(len(vocab), embed_size) self.dropout = nn.Dropout(0.5) self.decoder = nn.Dense(2) # 时序最大池化层没有权重,所以可以共用一个实例 self.pool = nn.GlobalMaxPool1D() self.convs = nn.Sequential() # 创建多个一维卷积层 for c, k in zip(num_channels, kernel_sizes): self.convs.add(nn.Conv1D(c, k, activation='relu'))
def __init__(self, vocab, embed_size, kernel_sizes, num_channels, **kwargs): super(TextCNN, self).__init__(**kwargs) self.embedding = nn.Embedding(len(vocab), embed_size) # Embedding without training self.constant_embedding = nn.Embedding(len(vocab), embed_size) self.dropout = nn.Dropout(0.5) self.decoder = nn.Dense(2) #One time maxpooling self.pool = nn.GlobalMaxPool1D() self.convs = nn.Sequential() # create multi 1 dimensional cnn for c, k in zip(num_channels, kernel_sizes): self.convs.add(nn.Conv1D(c, k, activation='relu'))
def __init__(self, vocab, embed_size, kernel_sizes, num_channels, **kwargs): super(TextCNN, self).__init__(**kwargs) self.embedding = nn.Embedding(len(vocab), embed_size) # The embedding layer does not participate in training self.constant_embedding = nn.Embedding(len(vocab), embed_size) self.dropout = nn.Dropout(0.5) self.decoder = nn.Dense(2) # The max-over-time pooling layer has no weight, so it can share an # instance self.pool = nn.GlobalMaxPool1D() # Create multiple one-dimensional convolutional layers self.convs = nn.Sequential() for c, k in zip(num_channels, kernel_sizes): self.convs.add(nn.Conv1D(c, k, activation='relu'))
def net_define_eu(): net = nn.Sequential() with net.name_scope(): net.add(nn.Embedding(config.MAX_WORDS, config.EMBEDDING_DIM)) net.add(rnn.GRU(128,layout='NTC',bidirectional=True, num_layers=1, dropout=0.2)) net.add(transpose(axes=(0,2,1))) net.add(nn.GlobalMaxPool1D()) ''' net.add(FeatureBlock1()) ''' net.add(extendDim(axes=3)) net.add(PrimeConvCap(16, 32, kernel_size=(1,1), padding=(0,0),strides=(1,1))) net.add(CapFullyNGBlock(16, num_cap=12, input_units=32, units=16, route_num=3)) net.add(nn.Dropout(0.2)) net.add(nn.Dense(6, activation='sigmoid')) net.initialize(init=init.Xavier()) return net
def SequentialTextCNN(config): net = nn.Sequential() with net.name_scope(): net.add( nn.Embedding(input_dim=config['vocab_size'], output_dim=config['embedding_dim'])) net.add(nn.Lambda(lambda x: x.transpose((0, 2, 1)))) net.add( nn.Conv1D(channels=config['feature_map'], kernel_size=config['kernel_size'][0], strides=1)) net.add(nn.BatchNorm(axis=1)) net.add(nn.Activation('relu')) net.add(nn.GlobalMaxPool1D()) net.add(nn.Dropout(rate=config['dropout_rate'])) net.add(nn.Dense(units=2)) return net
def __init__(self, vocab, embedding_size, ngram_kernel_sizes, nums_channels, num_outputs, **kwargs): super(TextCNN, self).__init__(**kwargs) self.ngram_kernel_sizes = ngram_kernel_sizes self.embedding_static = nn.Embedding(len(vocab), embedding_size) self.embedding_non_static = nn.Embedding(len(vocab), embedding_size) for i in range(len(ngram_kernel_sizes)): # 一维卷积层。 conv = nn.Conv1D(nums_channels[i], kernel_size=ngram_kernel_sizes[i], strides=1, activation='relu') # 时序最大池化层。 bn = nn.BatchNorm() pool = nn.GlobalMaxPool1D() # 将 self.conv_{i} 置为第 i 个 conv。 setattr(self, 'conv_{i}', conv) setattr(self, 'bn_{i}', bn) # 将 self.pool_{i} 置为第 i 个 pool。 setattr(self, 'pool_{i}', pool) self.dropout = nn.Dropout(0.5) self.decoder = nn.Dense(num_outputs)
def __init__(self, ctx=mx.cpu(), warmup=5, runs=25, inputs=None): # Set the default Inputs default_parameters = { "data": (32, 3, 256), "data_initializer": nd.normal, "layout": "NCW", "run_backward": True, "dtype": "float32" } super().__init__(ctx=ctx, warmup=warmup, runs=runs, default_parameters=default_parameters, custom_parameters=inputs) self.data = get_mx_ndarray(ctx=self.ctx, in_tensor=self.inputs["data"], dtype=self.inputs["dtype"], initializer=self.inputs["data_initializer"], attach_grad=self.inputs["run_backward"]) self.block = nn.GlobalMaxPool1D(layout=self.inputs["layout"]) self.block.initialize(ctx=self.ctx)
def __init__(self, channels, kernel_size, **kwargs): super(Convpool, self).__init__(**kwargs) with self.name_scope(): self.conv = nn.Conv1D(channels, kernel_size, strides=1) self.pooling = nn.GlobalMaxPool1D()