Skip to content

P
Paddle

BaiXuePrincess / Paddle
与 Fork 源项目一致

Fork自 PaddlePaddle / Paddle

通知 1
Star 1
Fork 0
P
Paddle
未验证 提交 140d786d 编写于 作者: 姜 姜永久 提交者： GitHub
浏览文件
操作

rm in_legacy_dygraph python/paddle/nn/functional/ part1 (#49258) 

* rm in_legacy_dygraph nn part1

* rm non_static_mode

* modify rrelu
上级 861fef52
隐藏空白更改
内联 并排
Showing with 508 addition and 785 deletion
python/paddle/nn/functional/activation.py
浏览文件 @ 140d786d
...@@ -18,11 +18,7 @@ from paddle.framework import core ...@@ -18,11 +18,7 @@ from paddle.framework import core
from paddle.utils.inplace_utils import inplace_apis_in_dygraph_only from paddle.utils.inplace_utils import inplace_apis_in_dygraph_only
from ...fluid.data_feeder import check_dtype, check_variable_and_dtype from ...fluid.data_feeder import check_dtype, check_variable_and_dtype
from ...fluid.framework import ( from ...fluid.framework import convert_np_dtype_to_dtype_, in_dygraph_mode
_in_legacy_dygraph,
convert_np_dtype_to_dtype_,
in_dygraph_mode,
)
from ...fluid.layer_helper import LayerHelper from ...fluid.layer_helper import LayerHelper
from ...tensor.manipulation import chunk from ...tensor.manipulation import chunk
from ...tensor.math import tanh # noqa: F401 from ...tensor.math import tanh # noqa: F401
...@@ -62,22 +58,21 @@ def celu(x, alpha=1.0, name=None): ...@@ -62,22 +58,21 @@ def celu(x, alpha=1.0, name=None):
""" """
if alpha == 0: if alpha == 0:
raise ZeroDivisionError("alpha cannot be 0 for celu") raise ZeroDivisionError("alpha cannot be 0 for celu")
if _in_legacy_dygraph():
return _legacy_C_ops.celu(x, 'alpha', alpha)
if in_dygraph_mode(): if in_dygraph_mode():
return _C_ops.celu(x, alpha) return _C_ops.celu(x, alpha)
else:
check_variable_and_dtype(x, 'x', ['float16', 'float32', 'float64'], 'celu') check_variable_and_dtype(
helper = LayerHelper("celu", **locals()) x, 'x', ['float16', 'float32', 'float64'], 'celu'
out = helper.create_variable_for_type_inference(x.dtype) )
helper.append_op( helper = LayerHelper("celu", **locals())
type='celu', out = helper.create_variable_for_type_inference(x.dtype)
inputs={'X': x}, helper.append_op(
outputs={'Out': out}, type='celu',
attrs={'alpha': alpha}, inputs={'X': x},
) outputs={'Out': out},
return out attrs={'alpha': alpha},
)
return out
def elu(x, alpha=1.0, name=None): def elu(x, alpha=1.0, name=None):
...@@ -117,19 +112,19 @@ def elu(x, alpha=1.0, name=None): ...@@ -117,19 +112,19 @@ def elu(x, alpha=1.0, name=None):
if in_dygraph_mode(): if in_dygraph_mode():
return _C_ops.elu(x, alpha) return _C_ops.elu(x, alpha)
if _in_legacy_dygraph(): else:
return _legacy_C_ops.elu(x, 'alpha', alpha) check_variable_and_dtype(
x, 'x', ['float16', 'float32', 'float64'], 'elu'
check_variable_and_dtype(x, 'x', ['float16', 'float32', 'float64'], 'elu') )
helper = LayerHelper("elu", **locals()) helper = LayerHelper("elu", **locals())
out = helper.create_variable_for_type_inference(x.dtype) out = helper.create_variable_for_type_inference(x.dtype)
helper.append_op( helper.append_op(
type='elu', type='elu',
inputs={'X': x}, inputs={'X': x},
outputs={'Out': out}, outputs={'Out': out},
attrs={'alpha': alpha}, attrs={'alpha': alpha},
) )
return out return out
@inplace_apis_in_dygraph_only @inplace_apis_in_dygraph_only
...@@ -187,20 +182,19 @@ def gelu(x, approximate=False, name=None): ...@@ -187,20 +182,19 @@ def gelu(x, approximate=False, name=None):
if in_dygraph_mode(): if in_dygraph_mode():
return _C_ops.gelu(x, approximate) return _C_ops.gelu(x, approximate)
else:
if _in_legacy_dygraph(): check_variable_and_dtype(
return _legacy_C_ops.gelu(x, 'approximate', approximate) x, 'x', ['float16', 'float32', 'float64'], 'gelu'
)
check_variable_and_dtype(x, 'x', ['float16', 'float32', 'float64'], 'gelu') helper = LayerHelper("gelu", **locals())
helper = LayerHelper("gelu", **locals()) out = helper.create_variable_for_type_inference(x.dtype)
out = helper.create_variable_for_type_inference(x.dtype) helper.append_op(
helper.append_op( type='gelu',
type='gelu', inputs={'X': x},
inputs={'X': x}, outputs={'Out': out},
outputs={'Out': out}, attrs={'approximate': approximate},
attrs={'approximate': approximate}, )
) return out
return out
def hardshrink(x, threshold=0.5, name=None): def hardshrink(x, threshold=0.5, name=None):
...@@ -238,22 +232,19 @@ def hardshrink(x, threshold=0.5, name=None): ...@@ -238,22 +232,19 @@ def hardshrink(x, threshold=0.5, name=None):
""" """
if in_dygraph_mode(): if in_dygraph_mode():
return _C_ops.hardshrink(x, threshold) return _C_ops.hardshrink(x, threshold)
else:
if _in_legacy_dygraph(): check_variable_and_dtype(
return _legacy_C_ops.hard_shrink(x, 'threshold', threshold) x, 'x', ['float16', 'float32', 'float64'], 'hardshrink'
)
check_variable_and_dtype( helper = LayerHelper('hardshrink', **locals())
x, 'x', ['float16', 'float32', 'float64'], 'hardshrink' out = helper.create_variable_for_type_inference(x.dtype)
) helper.append_op(
helper = LayerHelper('hardshrink', **locals()) type='hard_shrink',
out = helper.create_variable_for_type_inference(x.dtype) inputs={'X': x},
helper.append_op( outputs={'Out': out},
type='hard_shrink', attrs={'threshold': threshold},
inputs={'X': x}, )
outputs={'Out': out}, return out
attrs={'threshold': threshold},
)
return out
def hardtanh(x, min=-1.0, max=1.0, name=None): def hardtanh(x, min=-1.0, max=1.0, name=None):
...@@ -292,23 +283,20 @@ def hardtanh(x, min=-1.0, max=1.0, name=None): ...@@ -292,23 +283,20 @@ def hardtanh(x, min=-1.0, max=1.0, name=None):
if in_dygraph_mode(): if in_dygraph_mode():
return _C_ops.hardtanh(x, min, max) return _C_ops.hardtanh(x, min, max)
else:
check_variable_and_dtype(
x, 'x', ['float16', 'float32', 'float64'], 'hardtanh'
)
if _in_legacy_dygraph(): helper = LayerHelper('hardtanh', **locals())
return _legacy_C_ops.brelu(x, 't_min', min, 't_max', max) out = helper.create_variable_for_type_inference(dtype=x.dtype)
helper.append_op(
check_variable_and_dtype( type='brelu',
x, 'x', ['float16', 'float32', 'float64'], 'hardtanh' inputs={'X': x},
) outputs={'Out': out},
attrs={'t_min': min, 't_max': max},
helper = LayerHelper('hardtanh', **locals()) )
out = helper.create_variable_for_type_inference(dtype=x.dtype) return out
helper.append_op(
type='brelu',
inputs={'X': x},
outputs={'Out': out},
attrs={'t_min': min, 't_max': max},
)
return out
def hardsigmoid(x, slope=0.1666667, offset=0.5, name=None): def hardsigmoid(x, slope=0.1666667, offset=0.5, name=None):
...@@ -349,23 +337,20 @@ def hardsigmoid(x, slope=0.1666667, offset=0.5, name=None): ...@@ -349,23 +337,20 @@ def hardsigmoid(x, slope=0.1666667, offset=0.5, name=None):
if in_dygraph_mode(): if in_dygraph_mode():
return _C_ops.hardsigmoid(x, slope, offset) return _C_ops.hardsigmoid(x, slope, offset)
else:
check_variable_and_dtype(
x, 'x', ['float16', 'float32', 'float64'], 'hardsigmoid'
)
if _in_legacy_dygraph(): helper = LayerHelper('hardsigmoid', **locals())
return _legacy_C_ops.hard_sigmoid(x, 'slope', slope, 'offset', offset) out = helper.create_variable_for_type_inference(x.dtype)
helper.append_op(
check_variable_and_dtype( type='hard_sigmoid',
x, 'x', ['float16', 'float32', 'float64'], 'hardsigmoid' inputs={'X': x},
) outputs={'Out': out},
attrs={'slope': slope, 'offset': offset},
helper = LayerHelper('hardsigmoid', **locals()) )
out = helper.create_variable_for_type_inference(x.dtype) return out
helper.append_op(
type='hard_sigmoid',
inputs={'X': x},
outputs={'Out': out},
attrs={'slope': slope, 'offset': offset},
)
return out
def hardswish(x, name=None): def hardswish(x, name=None):
...@@ -401,20 +386,19 @@ def hardswish(x, name=None): ...@@ -401,20 +386,19 @@ def hardswish(x, name=None):
x = paddle.to_tensor([-4., 5., 1.]) x = paddle.to_tensor([-4., 5., 1.])
out = F.hardswish(x) # [0., 5., 0.666667] out = F.hardswish(x) # [0., 5., 0.666667]
""" """
if _in_legacy_dygraph():
return _legacy_C_ops.hard_swish(x)
if in_dygraph_mode(): if in_dygraph_mode():
return _C_ops.hardswish(x) return _C_ops.hardswish(x)
else:
check_variable_and_dtype(
x, 'x', ['float16', 'float32', 'float64'], 'hardswish'
)
check_variable_and_dtype( helper = LayerHelper('hardswish', **locals())
x, 'x', ['float16', 'float32', 'float64'], 'hardswish' out = helper.create_variable_for_type_inference(x.dtype)
) helper.append_op(
type='hard_swish', inputs={'X': x}, outputs={'Out': out}
helper = LayerHelper('hardswish', **locals()) )
out = helper.create_variable_for_type_inference(x.dtype) return out
helper.append_op(type='hard_swish', inputs={'X': x}, outputs={'Out': out})
return out
def leaky_relu(x, negative_slope=0.01, name=None): def leaky_relu(x, negative_slope=0.01, name=None):
...@@ -453,22 +437,19 @@ def leaky_relu(x, negative_slope=0.01, name=None): ...@@ -453,22 +437,19 @@ def leaky_relu(x, negative_slope=0.01, name=None):
""" """
if in_dygraph_mode(): if in_dygraph_mode():
return _C_ops.leaky_relu(x, negative_slope) return _C_ops.leaky_relu(x, negative_slope)
else:
if _in_legacy_dygraph(): check_variable_and_dtype(
return _legacy_C_ops.leaky_relu(x, 'alpha', negative_slope) x, 'x', ['float16', 'float32', 'float64'], 'leaky_relu'
)
check_variable_and_dtype( helper = LayerHelper('leaky_relu', **locals())
x, 'x', ['float16', 'float32', 'float64'], 'leaky_relu' out = helper.create_variable_for_type_inference(dtype=x.dtype)
) helper.append_op(
helper = LayerHelper('leaky_relu', **locals()) type='leaky_relu',
out = helper.create_variable_for_type_inference(dtype=x.dtype) inputs={'X': x},
helper.append_op( outputs={'Out': out},
type='leaky_relu', attrs={'alpha': negative_slope},
inputs={'X': x}, )
outputs={'Out': out}, return out
attrs={'alpha': negative_slope},
)
return out
def prelu(x, weight, data_format="NCHW", name=None): def prelu(x, weight, data_format="NCHW", name=None):
...@@ -559,20 +540,16 @@ def prelu(x, weight, data_format="NCHW", name=None): ...@@ -559,20 +540,16 @@ def prelu(x, weight, data_format="NCHW", name=None):
if in_dygraph_mode(): if in_dygraph_mode():
return _C_ops.prelu(x, weight, data_format, mode) return _C_ops.prelu(x, weight, data_format, mode)
if _in_legacy_dygraph(): else:
return _legacy_C_ops.prelu( helper = LayerHelper('prelu', **locals())
x, weight, 'mode', mode, 'data_format', data_format out = helper.create_variable_for_type_inference(x.dtype)
helper.append_op(
type="prelu",
inputs={"X": x, "Alpha": weight},
outputs={"Out": out},
attrs={"mode": mode, "data_format": data_format},
) )
return out
helper = LayerHelper('prelu', **locals())
out = helper.create_variable_for_type_inference(x.dtype)
helper.append_op(
type="prelu",
inputs={"X": x, "Alpha": weight},
outputs={"Out": out},
attrs={"mode": mode, "data_format": data_format},
)
return out
def rrelu(x, lower=1.0 / 8.0, upper=1.0 / 3.0, training=True, name=None): def rrelu(x, lower=1.0 / 8.0, upper=1.0 / 3.0, training=True, name=None):
...@@ -681,23 +658,23 @@ def rrelu(x, lower=1.0 / 8.0, upper=1.0 / 3.0, training=True, name=None): ...@@ -681,23 +658,23 @@ def rrelu(x, lower=1.0 / 8.0, upper=1.0 / 3.0, training=True, name=None):
is_test = not training is_test = not training
if _in_legacy_dygraph(): if in_dygraph_mode():
out, noise = _legacy_C_ops.rrelu( out, noise = _legacy_C_ops.rrelu(
x, 'lower', lower, 'upper', upper, 'is_test', is_test x, 'lower', lower, 'upper', upper, 'is_test', is_test
) )
return out return out
else:
helper = LayerHelper('rrelu', **locals()) helper = LayerHelper('rrelu', **locals())
out = helper.create_variable_for_type_inference(x.dtype) out = helper.create_variable_for_type_inference(x.dtype)
noise = helper.create_variable_for_type_inference(dtype=x.dtype) noise = helper.create_variable_for_type_inference(dtype=x.dtype)
attrs = {'lower': lower, 'upper': upper, 'is_test': is_test} attrs = {'lower': lower, 'upper': upper, 'is_test': is_test}
helper.append_op( helper.append_op(
type='rrelu', type='rrelu',
inputs={"X": x}, inputs={"X": x},
outputs={"Out": out, "Noise": noise}, outputs={"Out": out, "Noise": noise},
attrs=attrs, attrs=attrs,
) )
return out return out
def relu(x, name=None): def relu(x, name=None):
...@@ -729,13 +706,14 @@ def relu(x, name=None): ...@@ -729,13 +706,14 @@ def relu(x, name=None):
if in_dygraph_mode(): if in_dygraph_mode():
return _C_ops.relu(x) return _C_ops.relu(x)
if _in_legacy_dygraph(): else:
return _legacy_C_ops.relu(x) check_variable_and_dtype(
check_variable_and_dtype(x, 'x', ['float16', 'float32', 'float64'], 'relu') x, 'x', ['float16', 'float32', 'float64'], 'relu'
helper = LayerHelper('relu', **locals()) )
out = helper.create_variable_for_type_inference(x.dtype) helper = LayerHelper('relu', **locals())
helper.append_op(type='relu', inputs={'X': x}, outputs={'Out': out}) out = helper.create_variable_for_type_inference(x.dtype)
return out helper.append_op(type='relu', inputs={'X': x}, outputs={'Out': out})
return out
@inplace_apis_in_dygraph_only @inplace_apis_in_dygraph_only
...@@ -744,10 +722,7 @@ def relu_(x, name=None): ...@@ -744,10 +722,7 @@ def relu_(x, name=None):
Inplace version of ``relu`` API, the output Tensor will be inplaced with input ``x``. Inplace version of ``relu`` API, the output Tensor will be inplaced with input ``x``.
Please refer to :ref:`api_nn_cn_relu`. Please refer to :ref:`api_nn_cn_relu`.
""" """
if in_dygraph_mode(): return _C_ops.relu_(x)
return _C_ops.relu_(x)
if _in_legacy_dygraph():
return _legacy_C_ops.relu_(x)
def log_sigmoid(x, name=None): def log_sigmoid(x, name=None):
...@@ -777,17 +752,16 @@ def log_sigmoid(x, name=None): ...@@ -777,17 +752,16 @@ def log_sigmoid(x, name=None):
if in_dygraph_mode(): if in_dygraph_mode():
return _C_ops.logsigmoid(x) return _C_ops.logsigmoid(x)
else:
if _in_legacy_dygraph(): check_variable_and_dtype(
return _legacy_C_ops.logsigmoid(x) x, 'x', ['float16', 'float32', 'float64'], 'log_sigmoid'
)
check_variable_and_dtype( helper = LayerHelper("log_sigmoid", **locals())
x, 'x', ['float16', 'float32', 'float64'], 'log_sigmoid' out = helper.create_variable_for_type_inference(x.dtype)
) helper.append_op(
helper = LayerHelper("log_sigmoid", **locals()) type='logsigmoid', inputs={'X': x}, outputs={'Out': out}
out = helper.create_variable_for_type_inference(x.dtype) )
helper.append_op(type='logsigmoid', inputs={'X': x}, outputs={'Out': out}) return out
return out
def maxout(x, groups, axis=1, name=None): def maxout(x, groups, axis=1, name=None):
...@@ -844,28 +818,27 @@ def maxout(x, groups, axis=1, name=None): ...@@ -844,28 +818,27 @@ def maxout(x, groups, axis=1, name=None):
# [0.95313174 0.6228939 0.7129065 0.7087491 ] # [0.95313174 0.6228939 0.7129065 0.7087491 ]
# [0.7142536 0.88725346 0.61093384 0.38833922]]]] # [0.7142536 0.88725346 0.61093384 0.38833922]]]]
""" """
if _in_legacy_dygraph():
return _legacy_C_ops.maxout(x, 'groups', groups, 'axis', axis)
if in_dygraph_mode(): if in_dygraph_mode():
return _C_ops.maxout(x, groups, axis) return _C_ops.maxout(x, groups, axis)
check_variable_and_dtype(x, 'x', ['float32', 'float64'], 'maxout') else:
if axis not in [1, -1, 3]: check_variable_and_dtype(x, 'x', ['float32', 'float64'], 'maxout')
raise ValueError( if axis not in [1, -1, 3]:
"Attr(axis) should be 1 when data format is NCHW, -1 or 3 when data format is NHWC. Received " raise ValueError(
"Attr(axis): %s." % str(axis) "Attr(axis) should be 1 when data format is NCHW, -1 or 3 when data format is NHWC. Received "
) "Attr(axis): %s." % str(axis)
if axis == -1: )
axis = 3 if axis == -1:
axis = 3
helper = LayerHelper('maxout', **locals()) helper = LayerHelper('maxout', **locals())
out = helper.create_variable_for_type_inference(x.dtype) out = helper.create_variable_for_type_inference(x.dtype)
helper.append_op( helper.append_op(
type='maxout', type='maxout',
inputs={'X': x}, inputs={'X': x},
outputs={'Out': out}, outputs={'Out': out},
attrs={'groups': groups, 'axis': axis}, attrs={'groups': groups, 'axis': axis},
) )
return out return out
def relu6(x, name=None): def relu6(x, name=None):
...@@ -963,19 +936,19 @@ def selu( ...@@ -963,19 +936,19 @@ def selu(
if in_dygraph_mode(): if in_dygraph_mode():
return _C_ops.selu(x, scale, alpha) return _C_ops.selu(x, scale, alpha)
if _in_legacy_dygraph(): else:
return _legacy_C_ops.selu(x, 'scale', scale, 'alpha', alpha) check_variable_and_dtype(
x, 'x', ['float16', 'float32', 'float64'], 'selu'
check_variable_and_dtype(x, 'x', ['float16', 'float32', 'float64'], 'selu') )
helper = LayerHelper('selu', **locals()) helper = LayerHelper('selu', **locals())
out = helper.create_variable_for_type_inference(x.dtype) out = helper.create_variable_for_type_inference(x.dtype)
helper.append_op( helper.append_op(
type='selu', type='selu',
inputs={'X': x}, inputs={'X': x},
outputs={'Out': out}, outputs={'Out': out},
attrs={'scale': scale, 'alpha': alpha}, attrs={'scale': scale, 'alpha': alpha},
) )
return out return out
def silu(x, name=None): def silu(x, name=None):
...@@ -1007,14 +980,14 @@ def silu(x, name=None): ...@@ -1007,14 +980,14 @@ def silu(x, name=None):
if in_dygraph_mode(): if in_dygraph_mode():
return _C_ops.silu(x) return _C_ops.silu(x)
if _in_legacy_dygraph(): else:
return _legacy_C_ops.silu(x) check_variable_and_dtype(
x, 'x', ['float16', 'float32', 'float64'], 'silu'
check_variable_and_dtype(x, 'x', ['float16', 'float32', 'float64'], 'silu') )
helper = LayerHelper("silu", **locals()) helper = LayerHelper("silu", **locals())
out = helper.create_variable_for_type_inference(x.dtype) out = helper.create_variable_for_type_inference(x.dtype)
helper.append_op(type='silu', inputs={'X': x}, outputs={'Out': out}) helper.append_op(type='silu', inputs={'X': x}, outputs={'Out': out})
return out return out
def softmax(x, axis=-1, dtype=None, name=None): def softmax(x, axis=-1, dtype=None, name=None):
...@@ -1132,55 +1105,46 @@ def softmax(x, axis=-1, dtype=None, name=None): ...@@ -1132,55 +1105,46 @@ def softmax(x, axis=-1, dtype=None, name=None):
if (dtype is not None) and (not isinstance(dtype, core.VarDesc.VarType)): if (dtype is not None) and (not isinstance(dtype, core.VarDesc.VarType)):
dtype = convert_np_dtype_to_dtype_(dtype) dtype = convert_np_dtype_to_dtype_(dtype)
use_cudnn = True
if in_dygraph_mode(): if in_dygraph_mode():
outs_cast = x if dtype is None else _C_ops.cast(x, dtype) outs_cast = x if dtype is None else _C_ops.cast(x, dtype)
return _C_ops.softmax(outs_cast, axis) return _C_ops.softmax(outs_cast, axis)
else:
use_cudnn = True
if dtype is None:
check_variable_and_dtype(
x, 'x', ['float16', 'float32', 'float64'], 'softmax'
)
else:
check_dtype(
dtype,
'dtype',
['float32', 'float64'],
'softmax',
'If dtype is not None, it only support float32 or float64.',
)
if _in_legacy_dygraph(): helper = LayerHelper("softmax", **locals())
outs_cast = ( outs_cast = x
x if dtype is not None:
if dtype is None outs_cast = helper.create_variable_for_type_inference(dtype)
else _legacy_C_ops.cast(x, 'in_dtype', x.dtype, 'out_dtype', dtype) helper.append_op(
) type='cast',
return _legacy_C_ops.softmax( inputs={'X': x},
outs_cast, 'axis', axis, 'use_cudnn', use_cudnn outputs={'Out': outs_cast},
) attrs={'in_dtype': x.dtype, 'out_dtype': dtype},
)
if dtype is None: outs_softmax = helper.create_variable_for_type_inference(
check_variable_and_dtype( outs_cast.dtype
x, 'x', ['float16', 'float32', 'float64'], 'softmax'
)
else:
check_dtype(
dtype,
'dtype',
['float32', 'float64'],
'softmax',
'If dtype is not None, it only support float32 or float64.',
) )
helper = LayerHelper("softmax", **locals())
outs_cast = x
if dtype is not None:
outs_cast = helper.create_variable_for_type_inference(dtype)
helper.append_op( helper.append_op(
type='cast', type='softmax',
inputs={'X': x}, inputs={'X': outs_cast},
outputs={'Out': outs_cast}, outputs={'Out': outs_softmax},
attrs={'in_dtype': x.dtype, 'out_dtype': dtype}, attrs={'axis': axis, 'use_cudnn': use_cudnn},
) )
outs_softmax = helper.create_variable_for_type_inference(outs_cast.dtype) return outs_softmax
helper.append_op(
type='softmax',
inputs={'X': outs_cast},
outputs={'Out': outs_softmax},
attrs={'axis': axis, 'use_cudnn': use_cudnn},
)
return outs_softmax
@inplace_apis_in_dygraph_only @inplace_apis_in_dygraph_only
...@@ -1191,25 +1155,12 @@ def softmax_(x, axis=-1, dtype=None, name=None): ...@@ -1191,25 +1155,12 @@ def softmax_(x, axis=-1, dtype=None, name=None):
""" """
if (dtype is not None) and (not isinstance(dtype, core.VarDesc.VarType)): if (dtype is not None) and (not isinstance(dtype, core.VarDesc.VarType)):
dtype = convert_np_dtype_to_dtype_(dtype) dtype = convert_np_dtype_to_dtype_(dtype)
use_cudnn = True outs_cast = (
x
if in_dygraph_mode(): if dtype is None
outs_cast = ( else _legacy_C_ops.cast(x, 'in_dtype', x.dtype, 'out_dtype', dtype)
x )
if dtype is None return _C_ops.softmax_(outs_cast, axis)
else _legacy_C_ops.cast(x, 'in_dtype', x.dtype, 'out_dtype', dtype)
)
return _C_ops.softmax_(outs_cast, axis)
if _in_legacy_dygraph():
outs_cast = (
x
if dtype is None
else _legacy_C_ops.cast(x, 'in_dtype', x.dtype, 'out_dtype', dtype)
)
return _legacy_C_ops.softmax_(
outs_cast, 'axis', axis, 'use_cudnn', use_cudnn
)
def softplus(x, beta=1, threshold=20, name=None): def softplus(x, beta=1, threshold=20, name=None):
...@@ -1243,22 +1194,19 @@ def softplus(x, beta=1, threshold=20, name=None): ...@@ -1243,22 +1194,19 @@ def softplus(x, beta=1, threshold=20, name=None):
if in_dygraph_mode(): if in_dygraph_mode():
return _C_ops.softplus(x, beta, threshold) return _C_ops.softplus(x, beta, threshold)
else:
if _in_legacy_dygraph(): check_variable_and_dtype(
return _legacy_C_ops.softplus(x, 'beta', beta, 'threshold', threshold) x, 'x', ['float16', 'float32', 'float64'], 'softplus'
)
check_variable_and_dtype( helper = LayerHelper('softplus', **locals())
x, 'x', ['float16', 'float32', 'float64'], 'softplus' out = helper.create_variable_for_type_inference(x.dtype)
) helper.append_op(
helper = LayerHelper('softplus', **locals()) type='softplus',
out = helper.create_variable_for_type_inference(x.dtype) inputs={'X': x},
helper.append_op( outputs={'Out': out},
type='softplus', attrs={'beta': beta, 'threshold': threshold},
inputs={'X': x}, )
outputs={'Out': out}, return out
attrs={'beta': beta, 'threshold': threshold},
)
return out
def softshrink(x, threshold=0.5, name=None): def softshrink(x, threshold=0.5, name=None):
...@@ -1305,21 +1253,19 @@ def softshrink(x, threshold=0.5, name=None): ...@@ -1305,21 +1253,19 @@ def softshrink(x, threshold=0.5, name=None):
if in_dygraph_mode(): if in_dygraph_mode():
return _C_ops.softshrink(x, threshold) return _C_ops.softshrink(x, threshold)
if _in_legacy_dygraph(): else:
return _legacy_C_ops.softshrink(x, 'lambda', threshold) check_variable_and_dtype(
x, 'x', ['float16', 'float32', 'float64'], 'softshrink'
check_variable_and_dtype( )
x, 'x', ['float16', 'float32', 'float64'], 'softshrink' helper = LayerHelper('softshrink', **locals())
) out = helper.create_variable_for_type_inference(x.dtype)
helper = LayerHelper('softshrink', **locals()) helper.append_op(
out = helper.create_variable_for_type_inference(x.dtype) type='softshrink',
helper.append_op( inputs={'X': x},
type='softshrink', outputs={'Out': out},
inputs={'X': x}, attrs={'lambda': threshold},
outputs={'Out': out}, )
attrs={'lambda': threshold}, return out
)
return out
def softsign(x, name=None): def softsign(x, name=None):
...@@ -1392,16 +1338,19 @@ def swish(x, name=None): ...@@ -1392,16 +1338,19 @@ def swish(x, name=None):
""" """
if in_dygraph_mode(): if in_dygraph_mode():
return _C_ops.swish(x) return _C_ops.swish(x)
if _in_legacy_dygraph(): else:
return _legacy_C_ops.swish(x, 'beta', 1.0) check_variable_and_dtype(
x, 'x', ['float16', 'float32', 'float64'], 'swish'
check_variable_and_dtype(x, 'x', ['float16', 'float32', 'float64'], 'swish') )
helper = LayerHelper('swish', **locals()) helper = LayerHelper('swish', **locals())
out = helper.create_variable_for_type_inference(x.dtype) out = helper.create_variable_for_type_inference(x.dtype)
helper.append_op( helper.append_op(
type='swish', inputs={'X': x}, outputs={'Out': out}, attrs={'beta': 1.0} type='swish',
) inputs={'X': x},
return out outputs={'Out': out},
attrs={'beta': 1.0},
)
return out
def mish(x, name=None): def mish(x, name=None):
...@@ -1435,14 +1384,14 @@ def mish(x, name=None): ...@@ -1435,14 +1384,14 @@ def mish(x, name=None):
""" """
if in_dygraph_mode(): if in_dygraph_mode():
return _C_ops.mish(x, 20) return _C_ops.mish(x, 20)
if _in_legacy_dygraph(): else:
return _legacy_C_ops.mish(x) check_variable_and_dtype(
x, 'x', ['float16', 'float32', 'float64'], 'mish'
check_variable_and_dtype(x, 'x', ['float16', 'float32', 'float64'], 'mish') )
helper = LayerHelper('mish', **locals()) helper = LayerHelper('mish', **locals())
out = helper.create_variable_for_type_inference(x.dtype) out = helper.create_variable_for_type_inference(x.dtype)
helper.append_op(type='mish', inputs={'X': x}, outputs={'Out': out}) helper.append_op(type='mish', inputs={'X': x}, outputs={'Out': out})
return out return out
def tanhshrink(x, name=None): def tanhshrink(x, name=None):
...@@ -1474,17 +1423,16 @@ def tanhshrink(x, name=None): ...@@ -1474,17 +1423,16 @@ def tanhshrink(x, name=None):
""" """
if in_dygraph_mode(): if in_dygraph_mode():
return _C_ops.tanh_shrink(x) return _C_ops.tanh_shrink(x)
else:
if _in_legacy_dygraph(): check_variable_and_dtype(
return _legacy_C_ops.tanh_shrink(x) x, 'x', ['float16', 'float32', 'float64'], 'tanhshrink'
)
check_variable_and_dtype( helper = LayerHelper('tanh_shrink', **locals())
x, 'x', ['float16', 'float32', 'float64'], 'tanhshrink' out = helper.create_variable_for_type_inference(x.dtype)
) helper.append_op(
helper = LayerHelper('tanh_shrink', **locals()) type='tanh_shrink', inputs={'X': x}, outputs={'Out': out}
out = helper.create_variable_for_type_inference(x.dtype) )
helper.append_op(type='tanh_shrink', inputs={'X': x}, outputs={'Out': out}) return out
return out
def thresholded_relu(x, threshold=1.0, name=None): def thresholded_relu(x, threshold=1.0, name=None):
...@@ -1525,22 +1473,19 @@ def thresholded_relu(x, threshold=1.0, name=None): ...@@ -1525,22 +1473,19 @@ def thresholded_relu(x, threshold=1.0, name=None):
if in_dygraph_mode(): if in_dygraph_mode():
return _C_ops.thresholded_relu(x, threshold) return _C_ops.thresholded_relu(x, threshold)
else:
if _in_legacy_dygraph(): check_variable_and_dtype(
return _legacy_C_ops.thresholded_relu(x, 'threshold', threshold) x, 'x', ['float16', 'float32', 'float64'], 'thresholded_relu'
)
check_variable_and_dtype( helper = LayerHelper('thresholded_relu', **locals())
x, 'x', ['float16', 'float32', 'float64'], 'thresholded_relu' out = helper.create_variable_for_type_inference(x.dtype)
) helper.append_op(
helper = LayerHelper('thresholded_relu', **locals()) type='thresholded_relu',
out = helper.create_variable_for_type_inference(x.dtype) inputs={'X': x},
helper.append_op( outputs={'Out': out},
type='thresholded_relu', attrs={'threshold': threshold},
inputs={'X': x}, )
outputs={'Out': out}, return out
attrs={'threshold': threshold},
)
return out
def log_softmax(x, axis=-1, dtype=None, name=None): def log_softmax(x, axis=-1, dtype=None, name=None):
...@@ -1605,45 +1550,40 @@ def log_softmax(x, axis=-1, dtype=None, name=None): ...@@ -1605,45 +1550,40 @@ def log_softmax(x, axis=-1, dtype=None, name=None):
if dtype is not None: if dtype is not None:
x = _C_ops.cast(x, dtype) x = _C_ops.cast(x, dtype)
return _C_ops.log_softmax(x, axis) return _C_ops.log_softmax(x, axis)
else:
if dtype is None:
check_variable_and_dtype(
x, 'x', ['float16', 'float32', 'float64'], 'log_softmax'
)
else:
check_dtype(
dtype,
'dtype',
['float32', 'float64'],
'log_softmax',
'If dtype is not None, it only support float32 or float64.',
)
if _in_legacy_dygraph(): helper = LayerHelper("log_softmax", **locals())
out_cast = x
if dtype is not None: if dtype is not None:
x = _legacy_C_ops.cast(x, 'in_dtype', x.dtype, 'out_dtype', dtype) out_cast = helper.create_variable_for_type_inference(dtype)
return _legacy_C_ops.log_softmax(x, 'axis', axis) helper.append_op(
type='cast',
if dtype is None: inputs={'X': x},
check_variable_and_dtype( outputs={'Out': out_cast},
x, 'x', ['float16', 'float32', 'float64'], 'log_softmax' attrs={'in_dtype': x.dtype, 'out_dtype': dtype},
) )
else:
check_dtype(
dtype,
'dtype',
['float32', 'float64'],
'log_softmax',
'If dtype is not None, it only support float32 or float64.',
)
helper = LayerHelper("log_softmax", **locals()) out = helper.create_variable_for_type_inference(out_cast.dtype)
out_cast = x
if dtype is not None:
out_cast = helper.create_variable_for_type_inference(dtype)
helper.append_op( helper.append_op(
type='cast', type='log_softmax',
inputs={'X': x}, inputs={'X': out_cast},
outputs={'Out': out_cast}, outputs={'Out': out},
attrs={'in_dtype': x.dtype, 'out_dtype': dtype}, attrs={'axis': axis},
) )
out = helper.create_variable_for_type_inference(out_cast.dtype) return out
helper.append_op(
type='log_softmax',
inputs={'X': out_cast},
outputs={'Out': out},
attrs={'axis': axis},
)
return out
def glu(x, axis=-1, name=None): def glu(x, axis=-1, name=None):
......
python/paddle/nn/functional/common.py
浏览文件 @ 140d786d
...@@ -25,11 +25,7 @@ from ...fluid.data_feeder import ( ...@@ -25,11 +25,7 @@ from ...fluid.data_feeder import (
check_type, check_type,
check_variable_and_dtype, check_variable_and_dtype,
) )
from ...fluid.framework import ( from ...fluid.framework import in_dygraph_mode
_in_legacy_dygraph,
_non_static_mode,
in_dygraph_mode,
)
from ...tensor import clip, concat, sqrt, sum from ...tensor import clip, concat, sqrt, sum
from ...tensor.creation import zeros from ...tensor.creation import zeros
...@@ -927,24 +923,22 @@ def bilinear(x1, x2, weight, bias=None, name=None): ...@@ -927,24 +923,22 @@ def bilinear(x1, x2, weight, bias=None, name=None):
if in_dygraph_mode(): if in_dygraph_mode():
return _C_ops.bilinear_tensor_product(x1, x2, weight, bias) return _C_ops.bilinear_tensor_product(x1, x2, weight, bias)
elif _non_static_mode(): else:
return _legacy_C_ops.bilinear_tensor_product(x1, x2, weight, bias) check_variable_and_dtype(x1, 'x1', ['float32', 'float64'], 'bilinear')
check_variable_and_dtype(x2, 'x2', ['float32', 'float64'], 'bilinear')
check_variable_and_dtype(x1, 'x1', ['float32', 'float64'], 'bilinear')
check_variable_and_dtype(x2, 'x2', ['float32', 'float64'], 'bilinear')
inputs = {"X": x1, "Y": x2, "Weight": weight} inputs = {"X": x1, "Y": x2, "Weight": weight}
if bias is not None: if bias is not None:
inputs["Bias"] = bias inputs["Bias"] = bias
helper = LayerHelper("bilinear", **locals()) helper = LayerHelper("bilinear", **locals())
out = helper.create_variable_for_type_inference(dtype=x1.dtype) out = helper.create_variable_for_type_inference(dtype=x1.dtype)
helper.append_op( helper.append_op(
type="bilinear_tensor_product", inputs=inputs, outputs={"Out": out} type="bilinear_tensor_product", inputs=inputs, outputs={"Out": out}
) )
return out return out
def dropout( def dropout(
...@@ -1118,77 +1112,62 @@ def dropout( ...@@ -1118,77 +1112,62 @@ def dropout(
'downgrade_in_infer' if mode == 'downscale_in_infer' else mode 'downgrade_in_infer' if mode == 'downscale_in_infer' else mode
) # semantic transfer ) # semantic transfer
if _non_static_mode(): if in_dygraph_mode():
if default_main_program().random_seed != 0: if default_main_program().random_seed != 0:
seed = default_main_program().random_seed seed = default_main_program().random_seed
if in_dygraph_mode(): out, mask = _C_ops.dropout(
out, mask = _C_ops.dropout(
x,
None,
p,
not training,
mode,
seed if seed is not None else 0,
seed is not None,
)
return out
out, mask = _legacy_C_ops.dropout(
x, x,
'dropout_prob', None,
p, p,
'is_test',
not training, not training,
'fix_seed',
seed is not None,
'seed',
seed if seed is not None else 0,
'dropout_implementation',
mode, mode,
seed if seed is not None else 0,
seed is not None,
) )
return out
helper = LayerHelper('dropout', **locals()) return out
check_variable_and_dtype( else:
x, 'x', ['float16', 'float32', 'float64'], 'dropout' helper = LayerHelper('dropout', **locals())
) check_variable_and_dtype(
x, 'x', ['float16', 'float32', 'float64'], 'dropout'
)
out = helper.create_variable_for_type_inference(dtype=x.dtype) out = helper.create_variable_for_type_inference(dtype=x.dtype)
mask = helper.create_variable_for_type_inference( mask = helper.create_variable_for_type_inference(
dtype=core.VarDesc.VarType.UINT8, stop_gradient=True dtype=core.VarDesc.VarType.UINT8, stop_gradient=True
) )
def get_attrs(prog, dropout_prob, is_test, seed): def get_attrs(prog, dropout_prob, is_test, seed):
if (seed is None or seed == 0) and prog.random_seed != 0: if (seed is None or seed == 0) and prog.random_seed != 0:
seed = prog.random_seed seed = prog.random_seed
if isinstance( if isinstance(
dropout_prob, Variable dropout_prob, Variable
) and not dropout_prob.shape != [1]: ) and not dropout_prob.shape != [1]:
raise TypeError( raise TypeError(
"Required p.shape == [1] if type(p) is Variable, but received p.shape = {}".format( "Required p.shape == [1] if type(p) is Variable, but received p.shape = {}".format(
p.shape p.shape
)
) )
) attrs = {
attrs = { 'dropout_prob': dropout_prob,
'dropout_prob': dropout_prob, 'is_test': is_test,
'is_test': is_test, 'fix_seed': seed is not None,
'fix_seed': seed is not None, 'seed': seed if seed is not None else 0,
'seed': seed if seed is not None else 0, 'dropout_implementation': mode,
'dropout_implementation': mode, }
} return attrs
return attrs
attrs = get_attrs(helper.main_program, p, not training, seed) attrs = get_attrs(helper.main_program, p, not training, seed)
helper.append_op( helper.append_op(
type='dropout', type='dropout',
inputs={'X': [x]}, inputs={'X': [x]},
outputs={'Out': [out], 'Mask': [mask]}, outputs={'Out': [out], 'Mask': [mask]},
attrs=attrs, attrs=attrs,
) )
return out return out
else: # sometimes called dropout_nd #TODO: optimize with c++ else: # sometimes called dropout_nd #TODO: optimize with c++
if not in_dynamic_mode(): if not in_dynamic_mode():
check_variable_and_dtype(x, 'x', ['float32', 'float64'], 'dropout') check_variable_and_dtype(x, 'x', ['float32', 'float64'], 'dropout')
...@@ -1684,38 +1663,21 @@ def pad(x, pad, mode='constant', value=0.0, data_format="NCHW", name=None): ...@@ -1684,38 +1663,21 @@ def pad(x, pad, mode='constant', value=0.0, data_format="NCHW", name=None):
pad = pad.numpy().tolist() pad = pad.numpy().tolist()
out = _C_ops.pad3d(x, pad, mode, value, data_format) out = _C_ops.pad3d(x, pad, mode, value, data_format)
else: else:
if _in_legacy_dygraph(): attrs = {'mode': mode, 'value': value, 'data_format': data_format}
if isinstance(pad, Variable): inputs = {'X': [x]}
pad = pad.numpy().tolist() if isinstance(pad, Variable):
out = _legacy_C_ops.pad3d( inputs['Paddings'] = [pad]
x, attrs['paddings'] = []
"paddings",
pad,
"mode",
mode,
"value",
value,
"data_format",
data_format,
"name",
name,
)
else: else:
attrs = {'mode': mode, 'value': value, 'data_format': data_format} attrs['paddings'] = pad
inputs = {'X': [x]}
if isinstance(pad, Variable):
inputs['Paddings'] = [pad]
attrs['paddings'] = []
else:
attrs['paddings'] = pad
helper = LayerHelper('pad3d', **locals()) helper = LayerHelper('pad3d', **locals())
dtype = helper.input_dtype(input_param_name='input') dtype = helper.input_dtype(input_param_name='input')
out = helper.create_variable_for_type_inference(dtype) out = helper.create_variable_for_type_inference(dtype)
helper.append_op( helper.append_op(
type='pad3d', inputs=inputs, outputs={"Out": out}, attrs=attrs type='pad3d', inputs=inputs, outputs={"Out": out}, attrs=attrs
) )
if len(unsqueezed_dim) != 0: if len(unsqueezed_dim) != 0:
out = squeeze(out, axis=unsqueezed_dim) out = squeeze(out, axis=unsqueezed_dim)
...@@ -1873,46 +1835,34 @@ def linear(x, weight, bias=None, name=None): ...@@ -1873,46 +1835,34 @@ def linear(x, weight, bias=None, name=None):
# TODO(jiabin): using addmm for fast forward route # TODO(jiabin): using addmm for fast forward route
return _C_ops.linear(x, weight, bias) return _C_ops.linear(x, weight, bias)
else: else:
if _in_legacy_dygraph(): helper = LayerHelper('linear', **locals())
pre_bias = _legacy_C_ops.matmul_v2( dtype = x.dtype
x, weight, 'trans_x', False, 'trans_y', False
)
if bias is None:
return pre_bias
return _legacy_C_ops.elementwise_add(pre_bias, bias)
else:
helper = LayerHelper('linear', **locals())
dtype = x.dtype
check_variable_and_dtype( check_variable_and_dtype(
x, 'x', ['float16', 'float32', 'float64'], 'linear' x, 'x', ['float16', 'float32', 'float64'], 'linear'
) )
check_dtype( check_dtype(dtype, 'dtype', ['float16', 'float32', 'float64'], 'linear')
dtype, 'dtype', ['float16', 'float32', 'float64'], 'linear'
)
inputs = {'X': [x], 'Y': [weight]} inputs = {'X': [x], 'Y': [weight]}
attrs = {'trans_x': False, 'trans_y': False} attrs = {'trans_x': False, 'trans_y': False}
tmp = helper.create_variable_for_type_inference(dtype) tmp = helper.create_variable_for_type_inference(dtype)
helper.append_op(
type='matmul_v2',
inputs=inputs,
outputs={'Out': tmp},
attrs=attrs,
)
if bias is not None:
res = helper.create_variable_for_type_inference(dtype)
helper.append_op( helper.append_op(
type='matmul_v2', type='elementwise_add',
inputs=inputs, inputs={'X': [tmp], 'Y': [bias]},
outputs={'Out': tmp}, outputs={'Out': [res]},
attrs=attrs, attrs={'axis': len(x.shape) - 1},
) )
if bias is not None: else:
res = helper.create_variable_for_type_inference(dtype) res = tmp
helper.append_op( return res
type='elementwise_add',
inputs={'X': [tmp], 'Y': [bias]},
outputs={'Out': [res]},
attrs={'axis': len(x.shape) - 1},
)
else:
res = tmp
return res
def label_smooth(label, prior_dist=None, epsilon=0.1, name=None): def label_smooth(label, prior_dist=None, epsilon=0.1, name=None):
......
python/paddle/nn/functional/conv.py
浏览文件 @ 140d786d
...@@ -19,11 +19,7 @@ from paddle.device import ( ...@@ -19,11 +19,7 @@ from paddle.device import (
is_compiled_with_npu, is_compiled_with_npu,
is_compiled_with_rocm, is_compiled_with_rocm,
) )
from paddle.fluid.framework import ( from paddle.fluid.framework import _global_flags, in_dygraph_mode
_global_flags,
_in_legacy_dygraph,
in_dygraph_mode,
)
from paddle.tensor.math import _add_with_axis from paddle.tensor.math import _add_with_axis
from ...device import get_cudnn_version from ...device import get_cudnn_version
...@@ -489,30 +485,6 @@ def conv1d( ...@@ -489,30 +485,6 @@ def conv1d(
) )
if bias is not None: if bias is not None:
out = _add_with_axis(out, bias, axis=channel_dim) out = _add_with_axis(out, bias, axis=channel_dim)
elif _in_legacy_dygraph():
attrs = (
'strides',
stride,
'paddings',
padding,
'dilations',
dilation,
'groups',
groups,
'use_cudnn',
use_cudnn,
'use_mkldnn',
False,
'fuse_relu_before_depthwise_conv',
False,
"padding_algorithm",
padding_algorithm,
"data_format",
conv2d_data_format,
)
out = getattr(_legacy_C_ops, l_type)(x, weight, *attrs)
if bias is not None:
out = _add_with_axis(out, bias, axis=channel_dim)
else: else:
inputs = {'Input': [x], 'Filter': [weight]} inputs = {'Input': [x], 'Filter': [weight]}
attrs = { attrs = {
...@@ -1044,30 +1016,6 @@ def conv1d_transpose( ...@@ -1044,30 +1016,6 @@ def conv1d_transpose(
) )
if bias is not None: if bias is not None:
out = _add_with_axis(out, bias, axis=channel_dim) out = _add_with_axis(out, bias, axis=channel_dim)
elif _in_legacy_dygraph():
attrs = (
'output_padding',
output_padding,
'output_size',
output_size,
'strides',
stride,
'paddings',
padding,
'padding_algorithm',
padding_algorithm,
'dilations',
dilation,
'groups',
groups,
'use_cudnn',
use_cudnn,
'data_format',
conv2d_data_format,
)
out = getattr(_legacy_C_ops, op_type)(x, weight, *attrs)
if bias is not None:
out = _add_with_axis(out, bias, axis=channel_dim)
else: else:
inputs = {'Input': [x], 'Filter': [weight]} inputs = {'Input': [x], 'Filter': [weight]}
attrs = { attrs = {
...@@ -1350,33 +1298,6 @@ def conv2d_transpose( ...@@ -1350,33 +1298,6 @@ def conv2d_transpose(
return _add_with_axis(pre_bias, bias, axis=channel_dim) return _add_with_axis(pre_bias, bias, axis=channel_dim)
else: else:
return pre_bias return pre_bias
if _in_legacy_dygraph():
attrs = (
'output_padding',
output_padding,
'output_size',
output_size,
'strides',
stride,
'paddings',
padding,
'padding_algorithm',
padding_algorithm,
'dilations',
dilation,
'groups',
groups,
'use_cudnn',
use_cudnn,
'data_format',
data_format,
)
pre_bias = getattr(_legacy_C_ops, op_type)(x, weight, *attrs)
if bias is not None:
out = _add_with_axis(pre_bias, bias, axis=channel_dim)
else:
out = pre_bias
else: else:
inputs = {'Input': [x], 'Filter': [weight]} inputs = {'Input': [x], 'Filter': [weight]}
attrs = { attrs = {
...@@ -1823,33 +1744,6 @@ def conv3d_transpose( ...@@ -1823,33 +1744,6 @@ def conv3d_transpose(
return _add_with_axis(pre_bias, bias, axis=channel_dim) return _add_with_axis(pre_bias, bias, axis=channel_dim)
else: else:
return pre_bias return pre_bias
if _in_legacy_dygraph():
attrs = (
'output_padding',
output_padding,
'output_size',
output_size,
'paddings',
padding,
"padding_algorithm",
padding_algorithm,
'strides',
stride,
'dilations',
dilation,
'groups',
groups,
'use_cudnn',
use_cudnn,
"data_format",
data_format_,
)
pre_bias = getattr(_legacy_C_ops, op_type)(x, weight, *attrs)
if bias is not None:
out = _add_with_axis(pre_bias, bias, axis=channel_dim)
else:
out = pre_bias
else: else:
inputs = {'Input': [x], 'Filter': [weight]} inputs = {'Input': [x], 'Filter': [weight]}
attrs = { attrs = {
......
python/paddle/nn/functional/distance.py
浏览文件 @ 140d786d
...@@ -13,8 +13,8 @@ ...@@ -13,8 +13,8 @@
# limitations under the License. # limitations under the License.
import paddle import paddle
from paddle import _C_ops, _legacy_C_ops from paddle import _C_ops
from paddle.fluid.framework import _in_legacy_dygraph, in_dygraph_mode from paddle.fluid.framework import in_dygraph_mode
from ...fluid.data_feeder import check_type, check_variable_and_dtype from ...fluid.data_feeder import check_type, check_variable_and_dtype
from ...fluid.layer_helper import LayerHelper from ...fluid.layer_helper import LayerHelper
...@@ -81,36 +81,30 @@ def pairwise_distance(x, y, p=2.0, epsilon=1e-6, keepdim=False, name=None): ...@@ -81,36 +81,30 @@ def pairwise_distance(x, y, p=2.0, epsilon=1e-6, keepdim=False, name=None):
sub = _C_ops.add(sub, epsilon) sub = _C_ops.add(sub, epsilon)
return _C_ops.p_norm(sub, p, -1, 0.0, keepdim, False) return _C_ops.p_norm(sub, p, -1, 0.0, keepdim, False)
if _in_legacy_dygraph(): else:
sub = _legacy_C_ops.elementwise_sub(x, y) check_variable_and_dtype(
x, 'x', ['float32', 'float64'], 'PairwiseDistance'
)
check_variable_and_dtype(
y, 'y', ['float32', 'float64'], 'PairwiseDistance'
)
sub = paddle.subtract(x, y)
if epsilon != 0.0: if epsilon != 0.0:
epsilon = paddle.fluid.dygraph.base.to_variable( epsilon_var = sub.block.create_var(dtype=sub.dtype)
[epsilon], dtype=sub.dtype epsilon_var = paddle.full(
shape=[1], fill_value=epsilon, dtype=sub.dtype
) )
sub = _legacy_C_ops.elementwise_add(sub, epsilon) sub = paddle.add(sub, epsilon_var)
return _legacy_C_ops.p_norm( helper = LayerHelper("PairwiseDistance", name=name)
sub, 'axis', -1, 'porder', p, 'keepdim', keepdim, 'epsilon', 0.0 attrs = {
'axis': -1,
'porder': p,
'keepdim': keepdim,
'epsilon': 0.0,
}
out = helper.create_variable_for_type_inference(dtype=x.dtype)
helper.append_op(
type='p_norm', inputs={'X': sub}, outputs={'Out': out}, attrs=attrs
) )
check_variable_and_dtype(x, 'x', ['float32', 'float64'], 'PairwiseDistance') return out
check_variable_and_dtype(y, 'y', ['float32', 'float64'], 'PairwiseDistance')
sub = paddle.subtract(x, y)
if epsilon != 0.0:
epsilon_var = sub.block.create_var(dtype=sub.dtype)
epsilon_var = paddle.full(
shape=[1], fill_value=epsilon, dtype=sub.dtype
)
sub = paddle.add(sub, epsilon_var)
helper = LayerHelper("PairwiseDistance", name=name)
attrs = {
'axis': -1,
'porder': p,
'keepdim': keepdim,
'epsilon': 0.0,
}
out = helper.create_variable_for_type_inference(dtype=x.dtype)
helper.append_op(
type='p_norm', inputs={'X': sub}, outputs={'Out': out}, attrs=attrs
)
return out
python/paddle/nn/layer/norm.py
浏览文件 @ 140d786d
...@@ -34,17 +34,11 @@ import numpy as np ...@@ -34,17 +34,11 @@ import numpy as np
from paddle import _C_ops, _legacy_C_ops, in_dynamic_mode from paddle import _C_ops, _legacy_C_ops, in_dynamic_mode
from paddle.device import get_all_custom_device_type from paddle.device import get_all_custom_device_type
from paddle.fluid.framework import _in_legacy_dygraph, in_dygraph_mode from paddle.fluid.framework import in_dygraph_mode
from ...fluid import dygraph_utils from ...fluid import dygraph_utils
from ...fluid.data_feeder import check_variable_and_dtype from ...fluid.data_feeder import check_variable_and_dtype
from ...framework import ( from ...framework import ParamAttr, _global_flags, get_default_dtype, no_grad
ParamAttr,
_global_flags,
_non_static_mode,
get_default_dtype,
no_grad,
)
from .. import Layer from .. import Layer
from .. import functional as F from .. import functional as F
from ..functional import batch_norm, instance_norm, layer_norm from ..functional import batch_norm, instance_norm, layer_norm
...@@ -492,20 +486,6 @@ class GroupNorm(Layer): ...@@ -492,20 +486,6 @@ class GroupNorm(Layer):
dtype=input.dtype, stop_gradient=True dtype=input.dtype, stop_gradient=True
) )
if _in_legacy_dygraph():
pre_act, _, _ = _legacy_C_ops.group_norm(
input,
self.weight,
self.bias,
mean_out,
variance_out,
'epsilon',
self._epsilon,
'groups',
self._num_groups,
)
return pre_act
inputs = {'X': input} inputs = {'X': input}
if self.bias is not None: if self.bias is not None:
inputs['Bias'] = self.bias inputs['Bias'] = self.bias
...@@ -1005,121 +985,86 @@ class BatchNorm(Layer): ...@@ -1005,121 +985,86 @@ class BatchNorm(Layer):
self._trainable_statistics = trainable_statistics self._trainable_statistics = trainable_statistics
def forward(self, input): def forward(self, input):
# create output if in_dygraph_mode():
# mean and mean_out share the same memory batch_norm_out, t1, t2, t3, t4, _ = _C_ops.batch_norm(
mean_out = self._mean input,
# variance and variance out share the same memory self._mean,
variance_out = self._variance self._variance,
self.weight,
if _non_static_mode(): self.bias,
if in_dygraph_mode(): not self.training,
batch_norm_out, t1, t2, t3, t4, _ = _C_ops.batch_norm( self._momentum,
input, self._epsilon,
self._mean, self._data_layout,
self._variance, self._use_global_stats,
self.weight, self._trainable_statistics,
self.bias, )
not self.training,
self._momentum,
self._epsilon,
self._data_layout,
self._use_global_stats,
self._trainable_statistics,
)
return dygraph_utils._append_activation_in_dygraph(
batch_norm_out, act=self._act, use_mkldnn=self._use_mkldnn
)
elif _in_legacy_dygraph():
attrs = (
"momentum",
self._momentum,
"epsilon",
self._epsilon,
"is_test",
not self.training,
"data_layout",
self._data_layout,
"use_mkldnn",
self._use_mkldnn,
"fuse_with_relu",
self._fuse_with_relu,
"use_global_stats",
self._use_global_stats,
'trainable_statistics',
self._trainable_statistics,
)
batch_norm_out, _, _, _, _, _ = _legacy_C_ops.batch_norm(
input,
self.weight,
self.bias,
self._mean,
self._variance,
None,
mean_out,
variance_out,
*attrs
)
return dygraph_utils._append_activation_in_dygraph( return dygraph_utils._append_activation_in_dygraph(
batch_norm_out, act=self._act, use_mkldnn=self._use_mkldnn batch_norm_out, act=self._act, use_mkldnn=self._use_mkldnn
) )
else:
# create output
# mean and mean_out share the same memory
mean_out = self._mean
# variance and variance out share the same memory
variance_out = self._variance
check_variable_and_dtype(
input, 'input', ['float16', 'float32', 'float64'], 'BatchNorm'
)
check_variable_and_dtype( attrs = {
input, 'input', ['float16', 'float32', 'float64'], 'BatchNorm' "momentum": self._momentum,
) "epsilon": self._epsilon,
"is_test": self._is_test,
attrs = { "data_layout": self._data_layout,
"momentum": self._momentum, "use_mkldnn": False,
"epsilon": self._epsilon, "fuse_with_relu": self._fuse_with_relu,
"is_test": self._is_test, "use_global_stats": self._use_global_stats,
"data_layout": self._data_layout, "trainable_statistics": self._trainable_statistics,
"use_mkldnn": False, }
"fuse_with_relu": self._fuse_with_relu,
"use_global_stats": self._use_global_stats, inputs = {
"trainable_statistics": self._trainable_statistics, "X": [input],
} "Scale": [self.weight],
"Bias": [self.bias],
inputs = { "Mean": [self._mean],
"X": [input], "Variance": [self._variance],
"Scale": [self.weight], }
"Bias": [self.bias],
"Mean": [self._mean], saved_mean = self._helper.create_variable_for_type_inference(
"Variance": [self._variance], dtype=self._dtype, stop_gradient=True
} )
saved_variance = self._helper.create_variable_for_type_inference(
saved_mean = self._helper.create_variable_for_type_inference( dtype=self._dtype, stop_gradient=True
dtype=self._dtype, stop_gradient=True )
) reserve_space = self._helper.create_variable_for_type_inference(
saved_variance = self._helper.create_variable_for_type_inference( dtype=self._helper.input_dtype(input), stop_gradient=True
dtype=self._dtype, stop_gradient=True )
)
reserve_space = self._helper.create_variable_for_type_inference(
dtype=self._helper.input_dtype(input), stop_gradient=True
)
batch_norm_out = (
input
if self._in_place
else self._helper.create_variable_for_type_inference(self._dtype)
)
outputs = { batch_norm_out = (
"Y": [batch_norm_out], input
"MeanOut": [mean_out], if self._in_place
"VarianceOut": [variance_out], else self._helper.create_variable_for_type_inference(
"SavedMean": [saved_mean], self._dtype
"SavedVariance": [saved_variance], )
} )
if reserve_space is not None:
outputs["ReserveSpace"] = [reserve_space]
self._helper.append_op( outputs = {
type="batch_norm", inputs=inputs, outputs=outputs, attrs=attrs "Y": [batch_norm_out],
) "MeanOut": [mean_out],
"VarianceOut": [variance_out],
"SavedMean": [saved_mean],
"SavedVariance": [saved_variance],
}
if reserve_space is not None:
outputs["ReserveSpace"] = [reserve_space]
self._helper.append_op(
type="batch_norm", inputs=inputs, outputs=outputs, attrs=attrs
)
# Currently, we don't support inplace in dygraph mode # Currently, we don't support inplace in dygraph mode
return self._helper.append_activation(batch_norm_out, self._act) return self._helper.append_activation(batch_norm_out, self._act)
class BatchNorm1D(_BatchNormBase): class BatchNorm1D(_BatchNormBase):
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或