Skip to content

H
hapi

PaddlePaddle / hapi

通知 11
Star 2
Fork 0
H
hapi
提交 3b5e6d9c 编写于 作者: J jinyuKing
浏览文件
操作

update text.py

上级 3e180974
隐藏空白更改
内联 并排
Showing with 204 addition and 153 deletion
hapi/text/text.py
浏览文件 @ 3b5e6d9c
......@@ -1898,14 +1898,16 @@ class SequenceTagging(fluid.dygraph.Layer):
crf_decode = self.crf_decoding(input=emission, length=lengths)
return crf_decode, lengths
class Conv1dPoolLayer(Layer):
"""
This interface is used to construct a callable object of the ``Conv1DPoolLayer`` class.The ``Conv1DPoolLayer`` is composed of a ``Conv2D`` and a ``Pool2D`` .
For more details, refer to code examples.The ``Conv1DPoolLayer`` layer calculates the output based on the input, filter and strides, paddings, dilations,
groups,global_pooling, pool_type,ceil_mode,exclusive parameters.Input and Output are in NCH format, where N is batch size, C is the number of the feature map,
H is the height of the feature map.The data type of Input data and Output data is 'float32' or 'float64'.
This interface is used to construct a callable object of the ``Conv1DPoolLayer`` class.
The ``Conv1DPoolLayer`` class does a ``Conv1D`` and a ``Pool1D`` .For more details,
refer to code examples.The ``Conv1DPoolLayer`` layer calculates the output based on the
input, filter and strides, paddings, dilations, groups,global_pooling, pool_type,ceil_mode,
exclusive parameters.
Args:
Parameters:
input(Variable):3-D Tensor, shape is [N, C, H], data type can be float32 or float64
num_channels(int): The number of channels in the input data.
num_filters(int): The number of filters. It is the same as the output channels.
......@@ -1915,147 +1917,174 @@ class Conv1dPoolLayer(Layer):
pool_stride (int): The stride size of the pool layer in Conv1DPoolLayer. Default: 1
conv_padding (int): The padding size of the conv Layer in Conv1DPoolLayer. Default: 0
pool_padding (int): The padding of pool layer in Conv1DPoolLayer. Default: 0
pool_type (str): Pooling type can be `max` for max-pooling or `avg` for average-pooling. Default: math:`max`
global_pooling (bool): Whether to use the global pooling. If global_pooling = true, pool_size and pool_padding while be ignored. Default: False
pool_type (str): Pooling type can be `max` for max-pooling or `avg` for average-pooling.
Default: math:`max`
global_pooling (bool): Whether to use the global pooling. If global_pooling = true,
pool_size and pool_padding while be ignored. Default: False
dilation (int): The dilation size of the conv Layer. Default: 1.
groups (int): The groups number of the conv Layer. According to grouped convolution in Alex Krizhevsky's Deep CNN paper: when group=2,
the first half of the filters is only connected to the first half of the input channels, while the second half of the filters is only
connected to the second half of the input channels. Default: 1.
param_attr (ParamAttr|None): The parameter attribute for learnable parameters/weights of conv layer. If it is set to None or one attribute of
ParamAttr, conv2d will create ParamAttr as param_attr. If the Initializer of the param_attr is not set, the parameter is initialized
with :`Normal(0.0, std)`,and the :`std` is :`(\\frac{2.0 }{filter\_elem\_num})^{0.5}`.Default: None.
bias_attr (ParamAttr|bool|None): The parameter attribute for the bias of conv.If it is set to False, no bias will be added to the output units.
If it is set to None or one attribute of ParamAttr, conv2d will create ParamAttr as bias_attr. If the Initializer of the bias_attr is not
set, the bias is initialized zero. Default: None.
name(str, optional): The default value is None. Normally there is no need for user to set this property. Default: None
act (str): Activation type for conv layer, if it is set to None, activation is not appended. Default: None.
use_cudnn (bool): Use cudnn kernel or not, it is valid only when the cudnn library is installed. Default: False
ceil_mode (bool, optional): Whether to use the ceil function to calculate output height and width.
False is the default. If it is set to False, the floor function will be used. Default: False.
exclusive (bool, optional): Whether to exclude padding points in average pooling mode. Default: True.
Return:
3-D Tensor, the result of input after conv and pool, with the same data type as :`input`
Return Type:
Variable
groups (int): The groups number of the conv Layer. According to grouped convolution in
Alex Krizhevsky's Deep CNN paper: when group=2, the first half of the filters is
only connected to the first half of the input channels, while the second half
of the filters is only connected to the second half of the input channels.
Default: 1.
param_attr (ParamAttr|None): The parameter attribute for learnable parameters/weights
of conv layer. If it is set to None or one attribute of ParamAttr, conv2d will
create ParamAttr as param_attr. If the Initializer of the param_attr
is not set, the parameter is initialized with :`Normal(0.0, std)`,and
the :`std` is :`(\\frac{2.0 }{filter\_elem\_num})^{0.5}`.Default: None.
bias_attr (ParamAttr|bool|None): The parameter attribute for the bias of conv.If it
is set to False, no bias will be added to the output units.If it is set to
None or one attribute of ParamAttr, conv2d will create ParamAttr as bias_attr.
If the Initializer of the bias_attr is not set, the bias is initialized zero.
Default: None.
act (str): Activation type for conv layer, if it is set to None, activation is not appended.
Default: None.
use_cudnn (bool): Use cudnn kernel or not, it is valid only when the cudnn library
is installed. Default: False
ceil_mode (bool, optional): Whether to use the ceil function to calculate output
height and width.False is the default. If it is set to False, the floor function
will be used. Default: False.
exclusive (bool, optional): Whether to exclude padding points in average pooling mode.
Default: True.
Example:
```python
import paddle.fluid as fluid
from hapi.text import Conv1dPoolLayer
test=np.random.uniform(-1,1,[2,3,4]).astype('float32')
with fluid.dygraph.guard():
paddle_input=to_variable(test)
print(paddle_input.shape)
cov2d=Conv1dPoolLayer(3,4,2,2)
paddle_out=cov2d(paddle_input)
print(paddle_out.shape)#[2,4,2]
```
.. code-block:: python
import paddle.fluid as fluid
from paddle.incubate.hapi.text import Conv1dPoolLayer
test=np.random.uniform(-1,1,[2,3,4]).astype('float32')
with fluid.dygraph.guard():
paddle_input=to_variable(test)
cov2d=Conv1dPoolLayer(3,4,2,2)
paddle_out=cov2d(paddle_input)
print(paddle_out.shape)#[2,4,2]
"""
def __init__(self,
num_channels,
num_filters,
filter_size,
pool_size,
conv_stride=1,
pool_stride=1,
conv_padding=0,
pool_padding=0,
pool_type='max',
global_pooling=False,
dilation=1,
groups=None,
param_attr=None,
bias_attr=None,
act=None,
use_cudnn=False,
ceil_mode=False,
exclusive=True,
):
def __init__(
self,
num_channels,
num_filters,
filter_size,
pool_size,
conv_stride=1,
pool_stride=1,
conv_padding=0,
pool_padding=0,
pool_type='max',
global_pooling=False,
dilation=1,
groups=None,
param_attr=None,
bias_attr=None,
act=None,
use_cudnn=False,
ceil_mode=False,
exclusive=True, ):
super(Conv1dPoolLayer, self).__init__()
self._conv2d = Conv2D(num_channels=num_channels,
num_filters=num_filters,
filter_size=[filter_size,1],
stride=[conv_stride,1],
padding=[conv_padding,0],
dilation=[dilation,1],
groups=groups,
param_attr=param_attr,
bias_attr=bias_attr,
use_cudnn=use_cudnn,
act=act)
self._pool2d = Pool2D(pool_size=[pool_size,1],
pool_type=pool_type,
pool_stride=[pool_stride,1],
pool_padding=[pool_padding,0],
global_pooling=global_pooling,
use_cudnn=use_cudnn,
ceil_mode=ceil_mode,
exclusive=exclusive
)
self._conv2d = Conv2D(
num_channels=num_channels,
num_filters=num_filters,
filter_size=[filter_size, 1],
stride=[conv_stride, 1],
padding=[conv_padding, 0],
dilation=[dilation, 1],
groups=groups,
param_attr=param_attr,
bias_attr=bias_attr,
use_cudnn=use_cudnn,
act=act)
self._pool2d = Pool2D(
pool_size=[pool_size, 1],
pool_type=pool_type,
pool_stride=[pool_stride, 1],
pool_padding=[pool_padding, 0],
global_pooling=global_pooling,
use_cudnn=use_cudnn,
ceil_mode=ceil_mode,
exclusive=exclusive)
def forward(self, inputs):
x = fluid.layers.unsqueeze(inputs,axes=[-1])
"""
Performs :Code:`Conv1dPoolLayer.forward` receives input data. After a conv and a pool,
the result will be output.
Parameters:
inputs(Variable): Inputs are 3-D Tensor, shape is [N, C, H] , where N is batch size,
C is the number of the feature map, H is the height of the feature map.The data
type of Input data is 'float32' or 'float64'.
Returns:
3-D Tensor, with the same data type as :`input`
"""
x = fluid.layers.unsqueeze(inputs, axes=[-1])
x = self._conv2d(x)
x = self._pool2d(x)
x = fluid.layers.squeeze(x, axes=[-1])
return x
class CNNEncoder(Layer):
"""
This interface is used to construct a callable object of the ``CNNEncoder`` class.The ``CNNEncoder`` is composed of a ``Embedding`` and a ``Conv1dPoolLayer`` .
For more details, refer to code examples. The ``CNNEncoder`` layer calculates the output based on the input, dict_size and emb_dim, filter_size, num_filters,
use_cuda, is_sparse, param_attr parameters. The type of Input data is a 3-D Tensor .The data type of Input data is 'float32'. Output data are in NCH
format, where N is batch size, C is the number of the feature map, H is the height of the feature map. The data type of Output data is 'float32' or 'float64'.
Args:
num_channels(int|list|tuple): The number of channels in the input data.If num_channels is a list or tuple, the length of num_channels must equal layer_num.If num_channels
is a int, all conv1dpoollayer's num_channels are the value of num_channels.
num_filters(int|list|tuple): The number of filters. It is the same as the output channels. If num_filters is a list or tuple, the length of num_filters must equal layer_num.If num_filters
is a int, all conv1dpoollayer's num_filters are the value of num_filters.
filter_size(int|list|tuple): The filter size of Conv1DPoolLayer in CNNEncoder. If filter_size is a list or tuple, the length of filter_size must equal layer_num.If filter_size
is a int, all conv1dpoollayer's filter_size are the value of filter_size.
pool_size(int|list|tuple): The pooling size of Conv1DPoolLayer in CNNEncoder.If pool_size is a list or tuple, the length of pool_size must equal layer_num.If pool_size
is a int, all conv1dpoollayer's pool_size are the value of pool_size.
layer_num(int): The number of conv1dpoolLayer used in CNNEncoder.
conv_stride(int|list|tuple): The stride size of the conv Layer in Conv1DPoolLayer. If conv_stride is a list or tuple, the length of conv_stride must equal layer_num.If conv_stride
is a int, all conv1dpoollayer's conv_stride are the value of conv_stride. Default: 1
pool_stride(int|list|tuple): The stride size of the pool layer in Conv1DPoolLayer. If pool_stride is a list or tuple, the length of pool_stride must equal layer_num.If pool_stride
is a int, all conv1dpoollayer's pool_stride are the value of pool_stride. Default: 1
conv_padding(int|list|tuple): The padding size of the conv Layer in Conv1DPoolLayer.If conv_padding is a list or tuple, the length of conv_padding must equal layer_num.If conv_padding
is a int, all conv1dpoollayer's conv_padding are the value of conv_padding. Default: 0
pool_padding(int|list|tuple): The padding of pool layer in Conv1DPoolLayer. If pool_padding is a list or tuple, the length of pool_padding must equal layer_num.If pool_padding
is a int, all conv1dpoollayer's pool_padding are the value of pool_padding. Default: 0
use_cudnn (bool): Use cudnn kernel or not, it is valid only when the cudnn library is installed. Default: False
act (str|list|tuple): Activation type for `Conv1dPoollayer` layer, if it is set to None, activation is not appended. Default: None.
Return:
3-D Tensor, the result of input after embedding and conv1dPoollayer
Return Type:
Variable
This interface is used to construct a callable object of the ``CNNEncoder`` class.The ``CNNEncoder``
is composed of ``Conv1dPoolLayer`` .``CNNEncoder`` can define every Conv1dPoolLayer with different
or same parameters. The ``Conv1dPoolLayer`` in ``CNNEncoder`` is parallel.The result of every
``Conv1dPoolLayer`` will concat as the final output.For more details, refer to code examples.
The ``CNNEncoder`` layer calculates the output based on the input, dict_size and emb_dim,
filter_size, num_filters, use_cuda, is_sparse, param_attr parameters.
Parameters:
num_channels(int|list|tuple): The number of channels in the input data.If num_channels is
a list or tuple, the length of num_channels must equal layer_num.If num_channels
is a int, all conv1dpoollayer's num_channels are the value of num_channels.
num_filters(int|list|tuple): The number of filters. It is the same as the output channels.
If num_filters is a list or tuple, the length of num_filters must equal layer_num.
If num_filters is a int, all conv1dpoollayer's num_filters are the value of num_filters.
filter_size(int|list|tuple): The filter size of Conv1DPoolLayer in CNNEncoder. If filter_size
is a list or tuple, the length of filter_size must equal layer_num.If filter_size is a
int, all conv1dpoollayer's filter_size are the value of filter_size.
pool_size(int|list|tuple): The pooling size of Conv1DPoolLayer in CNNEncoder.If pool_size is
a list or tuple, the length of pool_size must equal layer_num.If pool_size is a int,
all conv1dpoollayer's pool_size are the value of pool_size.
layer_num(int): The number of conv1dpoolLayer used in CNNEncoder.
conv_stride(int|list|tuple): The stride size of the conv Layer in Conv1DPoolLayer. If
conv_stride is a list or tuple, the length of conv_stride must equal layer_num.
If conv_stride is a int, all conv1dpoollayer's conv_stride are the value of
conv_stride. Default: 1
pool_stride(int|list|tuple): The stride size of the pool layer in Conv1DPoolLayer. If
pool_stride is a list or tuple, the length of pool_stride must equal layer_num.
If pool_stride is a int, all conv1dpoollayer's pool_stride are the value of
pool_stride. Default: 1
conv_padding(int|list|tuple): The padding size of the conv Layer in Conv1DPoolLayer.
If conv_padding is a list or tuple, the length of conv_padding must equal layer_num.
If conv_padding is a int, all conv1dpoollayer's conv_padding are the value of
conv_padding. Default: 0
pool_padding(int|list|tuple): The padding of pool layer in Conv1DPoolLayer. If pool_padding is
a list or tuple, the length of pool_padding must equal layer_num.If pool_padding is a
int, all conv1dpoollayer's pool_padding are the value of pool_padding. Default: 0
use_cudnn (bool): Use cudnn kernel or not, it is valid only when the cudnn library is installed.
Default: False
act (str|list|tuple): Activation type for `Conv1dPoollayer` layer, if it is set to None,
activation is not appended. Default: None.
Example:
```python
import paddle.fluid as fluid
from hapi.text import CNNEncoder
test=np.random.uniform(1,5,[2,3,4]).astype('float32')
with fluid.dygraph.guard():
paddle_input=to_variable(test)
#print(paddle_input.shape)
cov2d=CNNEncoder(3,4,2,2,3)
paddle_out=cov2d(paddle_input)
print(paddle_out)#[2,12,2]
.. code-block:: python
import paddle.fluid as fluid
from paddle.incubate.hapi.text import Conv1dPoolLayer
```
test=np.random.uniform(-1,1,[2,3,4]).astype('float32')
with fluid.dygraph.guard():
paddle_input=to_variable(test)
cov2d=CNNEncoder(3,4,2,2,3)
paddle_out=cov2d(paddle_input)
print(paddle_out)#[2,12,2]
"""
def __init__(self,
num_channels,
num_filters,
......@@ -2067,33 +2096,55 @@ class CNNEncoder(Layer):
conv_padding=0,
pool_padding=0,
use_cudnn=False,
act=None
):
act=None):
super(CNNEncoder, self).__init__()
self.num_channels=num_channels
self.num_filters=num_filters
self.filter_size=filter_size
self.pool_size=pool_size
self.layer_num=layer_num
self.conv_stride=conv_stride
self.pool_stride=pool_stride
self.conv_padding=conv_padding
self.pool_padding=pool_padding
self.use_cudnn=use_cudnn
self.act=act
self.conv_layer = fluid.dygraph.LayerList([Conv1dPoolLayer(num_channels=self.num_channels if isinstance(self.num_channels,int) else self.num_channels[i],
num_filters=self.num_filters if isinstance(self.num_channels,int) else self.num_filters [i],
filter_size=self.filter_size if isinstance(self.filter_size,int) else self.filter_size[i],
pool_size=self.pool_size if isinstance(self.pool_size,int) else self.pool_size[i],
conv_stride=self.conv_stride if isinstance(self.conv_stride,int) else self.conv_stride[i],
pool_stride=self.pool_stride if isinstance(self.pool_stride,int) else self.pool_stride[i],
conv_padding= self.conv_padding if isinstance(self.conv_padding,int) else self.conv_padding[i],
pool_padding=self.pool_padding if isinstance(self.pool_padding,int) else self.pool_padding[i],
act=self.act[i] if isinstance(self.act,(list,tuple)) else self.act,
use_cudnn=self.use_cudnn
) for i in range(layer_num)])
self.num_channels = num_channels
self.num_filters = num_filters
self.filter_size = filter_size
self.pool_size = pool_size
self.layer_num = layer_num
self.conv_stride = conv_stride
self.pool_stride = pool_stride
self.conv_padding = conv_padding
self.pool_padding = pool_padding
self.use_cudnn = use_cudnn
self.act = act
self.conv_layer = fluid.dygraph.LayerList([
Conv1dPoolLayer(
num_channels=self.num_channels if
isinstance(self.num_channels, int) else self.num_channels[i],
num_filters=self.num_filters
if isinstance(self.num_channels, int) else self.num_filters[i],
filter_size=self.filter_size
if isinstance(self.filter_size, int) else self.filter_size[i],
pool_size=self.pool_size
if isinstance(self.pool_size, int) else self.pool_size[i],
conv_stride=self.conv_stride
if isinstance(self.conv_stride, int) else self.conv_stride[i],
pool_stride=self.pool_stride
if isinstance(self.pool_stride, int) else self.pool_stride[i],
conv_padding=self.conv_padding if
isinstance(self.conv_padding, int) else self.conv_padding[i],
pool_padding=self.pool_padding if
isinstance(self.pool_padding, int) else self.pool_padding[i],
act=self.act[i]
if isinstance(self.act, (list, tuple)) else self.act,
use_cudnn=self.use_cudnn) for i in range(layer_num)
])
def forward(self, input):
res=[Conv1dPoolLayer(input) for Conv1dPoolLayer in self.conv_layer]
out=fluid.layers.concat(input=res,axis=1)
return out
\ No newline at end of file
"""
Performs :Code:`CNNEncoder.forward` receives input data.The result of every ``Conv1dPoolLayer``
will store in a list. Then, the results will be concated as the final output.
Parameters:
inputs(Variable): Inputs are 3-D Tensor, shape is [N, C, H] , where N is batch size,
C is the number of the feature map, H is the height of the feature map.The data
type of Input data is 'float32' or 'float64'.
Returns:
3-D Tensor, with the same data type as :`input`
"""
res = [Conv1dPoolLayer(input) for Conv1dPoolLayer in self.conv_layer]
out = fluid.layers.concat(input=res, axis=1)
return out
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或