update hapi/text/text.py

hapi/text/text.py

@@ -37,7 +37,7 @@
 import paddle.fluid as fluid
 import paddle.fluid.layers.utils as utils
 from paddle.fluid.layers.utils import map_structure, flatten, pack_sequence_as
-from paddle.fluid.dygraph import to_variable, Embedding, Linear, LayerNorm, GRUUnit
+from paddle.fluid.dygraph import to_variable, Embedding, Linear, LayerNorm, GRUUnit, Conv2D
 from paddle.fluid.data_feeder import convert_dtype
 
 from paddle.fluid import layers
@@ -49,7 +49,8 @@
     'BeamSearchDecoder', 'MultiHeadAttention', 'FFN',
     'TransformerEncoderLayer', 'TransformerEncoder', 'TransformerDecoderLayer',
     'TransformerDecoder', 'TransformerBeamSearchDecoder', 'Linear_chain_crf',
-    'Crf_decoding', 'SequenceTagging', 'GRUEncoderLayer'
+    'Crf_decoding', 'SequenceTagging', 'GRUEncoderLayer', 'SimCNNEncoder',
+    'SimBOWEncoder', 'SimpleConvPoolLayer', 'SimGRUEncoder', 'DynamicGRU', 'SimLSTMEncoder'
 ]
 
 
@@ -1896,3 +1897,227 @@ def forward(self, word, lengths, target=None):
             self.linear_chain_crf.weight = self.crf_decoding.weight
             crf_decode = self.crf_decoding(input=emission, length=lengths)
             return crf_decode, lengths
+
+class SimpleConvPoolLayer(Layer):
+    def __init__(self,
+                 num_channels,
+                 num_filters,
+                 filter_size,
+                 use_cudnn=False,
+                 act=None
+                 ):
+        super(SimpleConvPoolLayer, self).__init__()
+        self._conv2d = Conv2D(num_channels=num_channels,
+                              num_filters=num_filters,
+                              filter_size=filter_size,
+                              padding=[1, 1],
+                              use_cudnn=use_cudnn,
+                              act=act)
+
+    def forward(self, input):
+        x = self._conv2d(input)
+        x = fluid.layers.reduce_max(x, dim=-1)
+        x = fluid.layers.reshape(x, shape=[x.shape[0], -1])
+        return x
+
+
+class SimCNNEncoder(Layer):
+    """
+    simple CNNEncoder for simnet
+    """
+    def __init__(self,
+                 dict_size,
+                 emb_dim,
+                 filter_size,
+                 num_filters,
+                 hidden_dim,
+                 seq_len,
+                 padding_idx,
+                 act
+                 ):
+        super(SimCNNEncoder, self).__init__()
+        self.dict_size = dict_size
+        self.emb_dim = emb_dim
+        self.filter_size = filter_size
+        self.num_filters = num_filters
+        self.hidden_dim = hidden_dim
+        self.seq_len = seq_len
+        self.padding_idx = padding_idx
+        self.act = act
+        self.channels = 1
+        self.emb_layer = Embedding(size=[self.dict_size, self.emb_dim],
+                                   is_sparse=True,
+                                   padding_idx=self.padding_idx,
+                                   param_attr=fluid.ParamAttr(name='emb', initializer=fluid.initializer.Xavier()))
+        self.cnn_layer = SimpleConvPoolLayer(
+            self.channels,
+            self.num_filters,
+            self.filter_size,
+            use_cudnn=False,
+            act=self.act
+        )
+
+    def forward(self, input):
+        emb = self.emb_layer(input)
+        emb_reshape = fluid.layers.reshape(
+            emb, shape=[-1, self.channels, self.seq_len, self.hidden_dim])
+        emb_out=self.cnn_layer(emb_reshape)
+        return emb_out
+
+class SimBOWEncoder(Layer):
+    """
+    simple BOWEncoder for simnet
+    """
+    def __init__(self,
+                 dict_size,
+                 emb_dim,
+                 bow_dim,
+                 seq_len,
+                 padding_idx
+                 ):
+        super(SimBOWEncoder, self).__init__()
+        self.dict_size = dict_size
+        self.bow_dim = bow_dim
+        self.seq_len = seq_len
+        self.emb_dim = emb_dim
+        self.padding_idx=padding_idx
+        self.emb_layer = Embedding(size=[self.dict_size, self.emb_dim],
+                                   is_sparse=True,
+                                   padding_idx=self.padding_idx,
+                                   param_attr=fluid.ParamAttr(name='emb', initializer=fluid.initializer.Xavier()))
+
+    def forward(self, input):
+        emb = self.emb_layer(input)
+        emb_reshape = fluid.layers.reshape(
+            emb, shape=[-1, self.seq_len, self.bow_dim])
+        bow_emb = fluid.layers.reduce_sum(emb_reshape, dim=1)
+        return bow_emb
+
+class DynamicGRU(fluid.dygraph.Layer):
+    def __init__(self,
+                 size,
+                 h_0=None,
+                 param_attr=None,
+                 bias_attr=None,
+                 is_reverse=False,
+                 gate_activation='sigmoid',
+                 candidate_activation='tanh',
+                 origin_mode=False,
+                 init_size=None):
+        super(DynamicGRU, self).__init__()
+
+        self.gru_unit = GRUUnit(
+            size * 3,
+            param_attr=param_attr,
+            bias_attr=bias_attr,
+            activation=candidate_activation,
+            gate_activation=gate_activation,
+            origin_mode=origin_mode)
+
+        self.size = size
+        self.h_0 = h_0
+        self.is_reverse = is_reverse
+
+    def forward(self, inputs):
+        hidden = self.h_0
+        res = []
+        for i in range(inputs.shape[1]):
+            if self.is_reverse:
+                i = inputs.shape[1] - 1 - i
+            input_ = inputs[:, i:i + 1, :]
+            input_ = fluid.layers.reshape(
+                input_, [-1, input_.shape[2]], inplace=False)
+            hidden, reset, gate = self.gru_unit(input_, hidden)
+            hidden_ = fluid.layers.reshape(
+                hidden, [-1, 1, hidden.shape[1]], inplace=False)
+            res.append(hidden_)
+        if self.is_reverse:
+            res = res[::-1]
+        res = fluid.layers.concat(res, axis=1)
+        return res
+
+class SimGRUEncoder(Layer):
+    """
+    simple GRUEncoder for simnet
+    """
+    def __init__(self,
+                 dict_size,
+                 emb_dim,
+                 gru_dim,
+                 hidden_dim,
+                 padding_idx,
+                 seq_len
+                 ):
+        super(SimGRUEncoder, self).__init__()
+        self.dict_size = dict_size
+        self.emb_dim = emb_dim
+        self.gru_dim = gru_dim
+        self.seq_len=seq_len
+        self.hidden_dim = hidden_dim
+        self.padding_idx=self.padding_idx
+        self.emb_layer = Embedding(size=[self.dict_size, self.emb_dim],
+                                                    is_sparse=True,
+                                                    padding_idx=self.padding_idx,
+                                                    param_attr=fluid.ParamAttr(name='emb',
+                                                                               initializer=fluid.initializer.Xavier()))
+        self.gru_layer = DynamicGRU(self.gru_dim)
+        self.proj_layer = Linear(input_dim=self.hidden_dim, output_dim=self.gru_dim * 3)
+
+    def forward(self, input):
+        emb = self.emb_layer(input)
+        emb_proj = self.proj_layer(emb)
+        h_0 = np.zeros((emb_proj.shape[0], self.hidden_dim), dtype="float32")
+        h_0 = to_variable(h_0)
+        gru = self.gru_layer(emb_proj, h_0=h_0)
+        gru = fluid.layers.reduce_max(gru, dim=1)
+        gru = fluid.layers.tanh(gru)
+        return gru
+
+class SimLSTMEncoder(Layer):
+    """
+    simple LSTMEncoder for simnet
+    """
+    def __init__(self,
+                 dict_size,
+                 emb_dim,
+                 lstm_dim,
+                 hidden_dim,
+                 seq_len,
+                 padding_idx,
+                 is_reverse
+                 ):
+        """
+        initialize
+        """
+        super(SimLSTMEncoder, self).__init__()
+        self.dict_size = dict_size
+        self.emb_dim = emb_dim
+        self.lstm_dim = lstm_dim
+        self.hidden_dim = hidden_dim
+        self.seq_len = seq_len
+        self.is_reverse = False
+        self.padding_idx=padding_idx
+
+        self.emb_layer = Embedding(size=[self.dict_size, self.emb_dim],
+                                   is_sparse=True,
+                                   padding_idx=self.padding_idx,
+                                   param_attr=fluid.ParamAttr(name='emb', initializer=fluid.initializer.Xavier()))
+
+        self.lstm_cell = BasicLSTMCell(
+            hidden_size=self.lstm_dim, input_size=self.lstm_dim * 4
+        )
+        self.lstm_layer = RNN(
+            cell=self.lstm_cell, time_major=True, is_reverse=self.is_reverse
+        )
+        self.proj_layer = Linear(input_dim=self.hidden_dim, output_dim=self.lstm_dim * 4)
+
+    def forward(self, input):
+        emb = self.emb_layer(input)
+        emb_proj = self.proj_layer(emb)
+        emb_lstm, _ = self.lstm_layer(emb_proj)
+        emb_reduce = fluid.layers.reduce_max(emb_lstm, dim=1)
+        emb_reshape = fluid.layers.reshape(
+            emb_reduce, shape=[-1, self.seq_len, self.hidden_dim])
+        emb_lstm = fluid.layers.reduce_sum(emb_reshape, dim=1)
+        emb_last = fluid.layers.tanh(emb_lstm)
+        return emb_last