You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
242 lines
9.5 KiB
242 lines
9.5 KiB
# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
# TODO: define the extention functions
|
|
from ...fluid.layers import add_position_encoding #DEFINE_ALIAS
|
|
from ...fluid.layers import multiclass_nms #DEFINE_ALIAS
|
|
from ...fluid.layers import target_assign #DEFINE_ALIAS
|
|
from ...fluid.layers import temporal_shift #DEFINE_ALIAS
|
|
|
|
from ...fluid.layers import continuous_value_model #DEFINE_ALIAS
|
|
from ...fluid.layers import filter_by_instag #DEFINE_ALIAS
|
|
from ...fluid.layers import polygon_box_transform #DEFINE_ALIAS
|
|
from ...fluid.layers import random_crop #DEFINE_ALIAS
|
|
from ...fluid.layers import rpn_target_assign #DEFINE_ALIAS
|
|
from ...fluid.layers import similarity_focus #DEFINE_ALIAS
|
|
from ...fluid.layers import warpctc #DEFINE_ALIAS
|
|
|
|
__all__ = [
|
|
'add_position_encoding',
|
|
# 'autoincreased_step_counter',
|
|
'continuous_value_model',
|
|
'filter_by_instag',
|
|
# 'linear_chain_crf',
|
|
# 'merge_selected_rows',
|
|
'multiclass_nms',
|
|
'polygon_box_transform',
|
|
'random_crop',
|
|
'row_conv',
|
|
'rpn_target_assign',
|
|
'similarity_focus',
|
|
'target_assign',
|
|
'temporal_shift',
|
|
'warpctc',
|
|
'diag_embed'
|
|
]
|
|
|
|
import numpy as np
|
|
from ...fluid.data_feeder import check_dtype
|
|
from ...fluid.layer_helper import LayerHelper
|
|
from ...fluid.framework import Variable, in_dygraph_mode
|
|
from ...fluid.layers.tensor import assign
|
|
from ...fluid import core, dygraph_utils
|
|
from ...fluid.layers.layer_function_generator import templatedoc
|
|
|
|
|
|
def diag_embed(input, offset=0, dim1=-2, dim2=-1):
|
|
"""
|
|
:alias_main: paddle.nn.functional.diag_embed
|
|
:alias: paddle.nn.functional.diag_embed,paddle.nn.functional.extension.diag_embed
|
|
|
|
This OP creates a tensor whose diagonals of certain 2D planes (specified by dim1 and dim2)
|
|
are filled by ``input``. By default, a 2D plane formed by the last two dimensions
|
|
of the returned tensor will be selected.
|
|
|
|
The argument ``offset`` determines which diagonal is generated:
|
|
|
|
- If offset = 0, it is the main diagonal.
|
|
- If offset > 0, it is above the main diagonal.
|
|
- If offset < 0, it is below the main diagonal.
|
|
|
|
Args:
|
|
input(Variable|numpy.ndarray): The input tensor. Must be at least 1-dimensional. The input data type should be float32, float64, int32, int64.
|
|
offset(int, optional): Which diagonal to consider. Default: 0 (main diagonal).
|
|
dim1(int, optional): The first dimension with respect to which to take diagonal. Default: -2.
|
|
dim2(int, optional): The second dimension with respect to which to take diagonal. Default: -1.
|
|
|
|
Returns:
|
|
Variable, the output data type is the same as input data type.
|
|
|
|
Examples:
|
|
.. code-block:: python
|
|
|
|
import paddle.nn.functional as F
|
|
import paddle.fluid.dygraph as dg
|
|
import numpy as np
|
|
|
|
diag_embed = np.random.randn(2, 3).astype('float32')
|
|
# [[ 0.7545889 , -0.25074545, 0.5929117 ],
|
|
# [-0.6097662 , -0.01753256, 0.619769 ]]
|
|
with dg.guard():
|
|
data1 = F.diag_embed(diag_embed)
|
|
data1.numpy()
|
|
# [[[ 0.7545889 , 0. , 0. ],
|
|
# [ 0. , -0.25074545, 0. ],
|
|
# [ 0. , 0. , 0.5929117 ]],
|
|
|
|
# [[-0.6097662 , 0. , 0. ],
|
|
# [ 0. , -0.01753256, 0. ],
|
|
# [ 0. , 0. , 0.619769 ]]]
|
|
|
|
data2 = F.diag_embed(diag_embed, offset=-1, dim1=0, dim2=2)
|
|
data2.numpy()
|
|
# [[[ 0. , 0. , 0. , 0. ],
|
|
# [ 0.7545889 , 0. , 0. , 0. ],
|
|
# [ 0. , -0.25074545, 0. , 0. ],
|
|
# [ 0. , 0. , 0.5929117 , 0. ]],
|
|
#
|
|
# [[ 0. , 0. , 0. , 0. ],
|
|
# [-0.6097662 , 0. , 0. , 0. ],
|
|
# [ 0. , -0.01753256, 0. , 0. ],
|
|
# [ 0. , 0. , 0.619769 , 0. ]]]
|
|
|
|
data3 = F.diag_embed(diag_embed, offset=1, dim1=0, dim2=2)
|
|
data3.numpy()
|
|
# [[[ 0. , 0.7545889 , 0. , 0. ],
|
|
# [ 0. , -0.6097662 , 0. , 0. ]],
|
|
#
|
|
# [[ 0. , 0. , -0.25074545, 0. ],
|
|
# [ 0. , 0. , -0.01753256, 0. ]],
|
|
#
|
|
# [[ 0. , 0. , 0. , 0.5929117 ],
|
|
# [ 0. , 0. , 0. , 0.619769 ]],
|
|
#
|
|
# [[ 0. , 0. , 0. , 0. ],
|
|
# [ 0. , 0. , 0. , 0. ]]]
|
|
"""
|
|
inputs = {'Input': [input]}
|
|
attrs = {'offset': offset, 'dim1': dim1, 'dim2': dim2}
|
|
|
|
if not isinstance(input, Variable):
|
|
input = assign(input)
|
|
|
|
def __check_input(input, offset, dim1, dim2):
|
|
check_dtype(input.dtype, 'Input',
|
|
['int32', 'int64', 'float16', 'float32', 'float64'],
|
|
'diag_embed')
|
|
|
|
input_shape = list(input.shape)
|
|
assert len(input_shape) >= 1, \
|
|
"Input must be at least 1-dimensional, " \
|
|
"But received Input's dimensional: %s.\n" % \
|
|
len(input_shape)
|
|
|
|
assert np.abs(dim1) <= len(input_shape), \
|
|
"Dim1 is out of range (expected to be in range of [%d, %d], but got %d).\n" \
|
|
% (-(len(input_shape) + 1), len(input_shape), dim1)
|
|
|
|
assert np.abs(dim2) <= len(input_shape), \
|
|
"Dim2 is out of range (expected to be in range of [%d, %d], but got %d).\n" \
|
|
% (-(len(input_shape) + 1), len(input_shape), dim2)
|
|
|
|
dim1_ = dim1 if dim1 >= 0 else len(input_shape) + dim1 + 1
|
|
dim2_ = dim2 if dim2 >= 0 else len(input_shape) + dim2 + 1
|
|
assert dim1_ != dim2_, \
|
|
"dim1 and dim2 cannot be the same dimension." \
|
|
"But received dim1 = %d, dim2 = %d\n"%(dim1, dim2)
|
|
|
|
if not in_dygraph_mode():
|
|
__check_input(input, offset, dim1, dim2)
|
|
helper = LayerHelper("diag_embed", **locals())
|
|
|
|
out = helper.create_variable_for_type_inference(dtype=input.dtype)
|
|
|
|
helper.append_op(
|
|
type='diag_embed',
|
|
inputs={'Input': [input]},
|
|
attrs={'offset': offset,
|
|
'dim1': dim1,
|
|
'dim2': dim2},
|
|
outputs={'Out': [out]})
|
|
out.stop_gradient = True
|
|
return out
|
|
|
|
|
|
@templatedoc()
|
|
def row_conv(input, weight, act=None):
|
|
"""
|
|
:alias_main: paddle.nn.functional.row_conv
|
|
:alias: paddle.nn.functional.row_conv,paddle.nn.functional.extension.row_conv
|
|
|
|
${comment}
|
|
|
|
Args:
|
|
input (Variable): the input(X) is a LodTensor or tensor, LodTensor(X)
|
|
supports variable time-length input sequences. The underlying
|
|
tensor in this LoDTensor is a matrix with shape (T, D), where
|
|
T is the total time steps in this mini-batch and D is the input
|
|
data dimension.
|
|
If the input is a padded minibatch, the shape of the input is
|
|
(N, T, D), N is batch size, T is the max time steps in the batch,
|
|
D is the input data dimension.
|
|
weight (Variable): The weight. A Tensor with shape
|
|
(future_context_size + 1, D), where future_context_size is the
|
|
context size of the RowConv operator.
|
|
act (str): Non-linear activation to be applied to output variable.
|
|
|
|
Returns:
|
|
${out_comment}.
|
|
|
|
Examples:
|
|
.. code-block:: python
|
|
|
|
from paddle import fluid, nn
|
|
import paddle.fluid.dygraph as dg
|
|
import paddle.nn.functional as F
|
|
import numpy as np
|
|
|
|
batch_size = 4
|
|
time_steps = 8
|
|
feature_size = 6
|
|
context_size = 4
|
|
x = np.random.randn(batch_size, time_steps, feature_size).astype(np.float32)
|
|
weight = np.random.randn(context_size + 1, feature_size).astype(np.float32)
|
|
|
|
place = fluid.CPUPlace()
|
|
with dg.guard(place):
|
|
x_var = dg.to_variable(x)
|
|
w_var = dg.to_variable(weight)
|
|
y_var = F.row_conv(x_var, w_var)
|
|
y_np = y_var.numpy()
|
|
|
|
print(y_np.shape)
|
|
|
|
# (4, 8, 6)
|
|
"""
|
|
|
|
if in_dygraph_mode():
|
|
pre_act = core.ops.row_conv(input, weight)
|
|
out = dygraph_utils._append_activation_in_dygraph(pre_act, act)
|
|
return out
|
|
else:
|
|
helper = LayerHelper('row_conv', **locals())
|
|
dtype = helper.input_dtype()
|
|
|
|
inputs = {'X': [input], 'Filter': [weight]}
|
|
pre_act = helper.create_variable_for_type_inference(dtype)
|
|
outputs = {'Out': [pre_act]}
|
|
helper.append_op(type='row_conv', inputs=inputs, outputs=outputs)
|
|
out = helper.append_activation(pre_act)
|
|
return out
|