diff --git a/python/paddle/fluid/executor.py b/python/paddle/fluid/executor.py index 3dc30767e5aa42d6a0a9f673e093f40045cbed87..7d067b6347844e7a8c87f83304b311672c61a237 100644 --- a/python/paddle/fluid/executor.py +++ b/python/paddle/fluid/executor.py @@ -94,12 +94,13 @@ def scope_guard(scope): Examples: .. code-block:: python - import paddle.fluid as fluid + import paddle import numpy + paddle.enable_static() - new_scope = fluid.Scope() - with fluid.scope_guard(new_scope): - fluid.global_scope().var("data").get_tensor().set(numpy.ones((2, 2)), fluid.CPUPlace()) + new_scope = paddle.static.Scope() + with paddle.static.scope_guard(new_scope): + paddle.static.global_scope().var("data").get_tensor().set(numpy.ones((2, 2)), paddle.CPUPlace()) numpy.array(new_scope.find_var("data").get_tensor()) """ diff --git a/python/paddle/fluid/layers/nn.py b/python/paddle/fluid/layers/nn.py index b3908e3c8ebc1923f431ad7b7e05f2fdf9c03592..1bd279c1e821dcea7ed644fc8be4d76e940ced49 100755 --- a/python/paddle/fluid/layers/nn.py +++ b/python/paddle/fluid/layers/nn.py @@ -13546,15 +13546,15 @@ def py_func(func, x, out, backward_func=None, skip_vars_in_backward_input=None): """ :api_attr: Static Graph - This OP is used to register customized Python OP to Paddle Fluid. The design - principe of py_func is that LodTensor and numpy array can be converted to each + This OP is used to register customized Python OP to Paddle. The design + principe of py_func is that Tensor and numpy array can be converted to each other easily. So you can use Python and numpy API to register a python OP. The forward function of the registered OP is ``func`` and the backward function of that is ``backward_func``. Paddle will call ``func`` at forward runtime and call ``backward_func`` at backward runtime(if ``backward_func`` is not None). - ``x`` is the input of ``func``, whose type must be LoDTensor; ``out`` is - the output of ``func``, whose type can be either LoDTensor or numpy array. + ``x`` is the input of ``func``, whose type must be Tensor; ``out`` is + the output of ``func``, whose type can be either Tensor or numpy array. The input of the backward function ``backward_func`` is ``x``, ``out`` and the gradient of ``out``. If some variables of ``out`` have no gradient, the @@ -13572,14 +13572,14 @@ def py_func(func, x, out, backward_func=None, skip_vars_in_backward_input=None): func (callable): The forward function of the registered OP. When the network is running, the forward output ``out`` will be calculated according to this function and the forward input ``x``. In ``func`` , it's suggested that we - actively convert LoDTensor into a numpy array, so that we can use Python and + actively convert Tensor into a numpy array, so that we can use Python and numpy API arbitrarily. If not, some operations of numpy may not be compatible. x (Variable|tuple(Variale)|list[Variale]): The input of the forward function ``func``. - It can be Variable|tuple(Variale)|list[Variale], where Variable is LoDTensor or + It can be Variable|tuple(Variale)|list[Variale], where Variable is Tensor or Tenosor. In addition, Multiple Variable should be passed in the form of tuple(Variale) or list[Variale]. out (Variable|tuple(Variale)|list[Variale]): The output of the forward function ``func``, - it can be Variable|tuple(Variale)|list[Variale], where Variable can be either LoDTensor + it can be Variable|tuple(Variale)|list[Variale], where Variable can be either Tensor or numpy array. Since Paddle cannot automatically infer the shape and type of ``out``, you must create ``out`` in advance. backward_func (callable, optional): The backward function of the registered OP. @@ -13600,16 +13600,18 @@ def py_func(func, x, out, backward_func=None, skip_vars_in_backward_input=None): .. code-block:: python # example 1: - import paddle.fluid as fluid + import paddle import six - # Creates a forward function, LodTensor can be input directly without + paddle.enable_static() + + # Creates a forward function, Tensor can be input directly without # being converted into numpy array. def tanh(x): return np.tanh(x) # Skip x in backward function and return the gradient of x - # LodTensor must be actively converted to numpy array, otherwise, + # Tensor must be actively converted to numpy array, otherwise, # operations such as +/- can't be used. def tanh_grad(y, dy): return np.array(dy) * (1 - np.square(np.array(y))) @@ -13619,36 +13621,38 @@ def py_func(func, x, out, backward_func=None, skip_vars_in_backward_input=None): print(x) def create_tmp_var(name, dtype, shape): - return fluid.default_main_program().current_block().create_var( + return paddle.static.default_main_program().current_block().create_var( name=name, dtype=dtype, shape=shape) def simple_net(img, label): hidden = img for idx in six.moves.range(4): - hidden = fluid.layers.fc(hidden, size=200) + hidden = paddle.static.nn.fc(hidden, size=200) new_hidden = create_tmp_var(name='hidden_{}'.format(idx), dtype=hidden.dtype, shape=hidden.shape) # User-defined forward and backward - hidden = fluid.layers.py_func(func=tanh, x=hidden, + hidden = paddle.static.nn.py_func(func=tanh, x=hidden, out=new_hidden, backward_func=tanh_grad, skip_vars_in_backward_input=hidden) - # User-defined debug functions that print out the input LodTensor - fluid.layers.py_func(func=debug_func, x=hidden, out=None) + # User-defined debug functions that print out the input Tensor + paddle.static.nn.py_func(func=debug_func, x=hidden, out=None) - prediction = fluid.layers.fc(hidden, size=10, act='softmax') - loss = fluid.layers.cross_entropy(input=prediction, label=label) - return fluid.layers.mean(loss) + prediction = paddle.static.nn.fc(hidden, size=10, act='softmax') + loss = paddle.static.nn.cross_entropy(input=prediction, label=label) + return paddle.mean(loss) # example 2: - # This example shows how to turn LoDTensor into numpy array and + # This example shows how to turn Tensor into numpy array and # use numpy API to register an Python OP - import paddle.fluid as fluid + import paddle import numpy as np + paddle.enable_static() + def element_wise_add(x, y): - # LodTensor must be actively converted to numpy array, otherwise, + # Tensor must be actively converted to numpy array, otherwise, # numpy.shape can't be used. x = np.array(x) y = np.array(y) @@ -13664,24 +13668,24 @@ def py_func(func, x, out, backward_func=None, skip_vars_in_backward_input=None): return result def create_tmp_var(name, dtype, shape): - return fluid.default_main_program().current_block().create_var( + return paddle.static.default_main_program().current_block().create_var( name=name, dtype=dtype, shape=shape) def py_func_demo(): - start_program = fluid.default_startup_program() - main_program = fluid.default_main_program() + start_program = paddle.static.default_startup_program() + main_program = paddle.static.default_main_program() # Input of the forward function - x = fluid.data(name='x', shape=[2,3], dtype='int32') - y = fluid.data(name='y', shape=[2,3], dtype='int32') + x = paddle.static.data(name='x', shape=[2,3], dtype='int32') + y = paddle.static.data(name='y', shape=[2,3], dtype='int32') # Output of the forward function, name/dtype/shape must be specified output = create_tmp_var('output','int32', [3,1]) # Multiple Variable should be passed in the form of tuple(Variale) or list[Variale] - fluid.layers.py_func(func=element_wise_add, x=[x,y], out=output) + paddle.static.nn.py_func(func=element_wise_add, x=[x,y], out=output) - exe=fluid.Executor(fluid.CPUPlace()) + exe=paddle.static.Executor(paddle.CPUPlace()) exe.run(start_program) # Feed numpy array to main_program diff --git a/python/paddle/fluid/layers/tensor.py b/python/paddle/fluid/layers/tensor.py index 2fba578ec077f2a74388d433bf3ab5b3098e81ad..c633f7022d75e1c352f7ae1f51dc324064359e31 100644 --- a/python/paddle/fluid/layers/tensor.py +++ b/python/paddle/fluid/layers/tensor.py @@ -103,9 +103,9 @@ def create_parameter(shape, Examples: .. code-block:: python - import paddle.fluid as fluid - import paddle.fluid.layers as layers - W = layers.create_parameter(shape=[784, 200], dtype='float32') + import paddle + paddle.enable_static() + W = paddle.static.create_parameter(shape=[784, 200], dtype='float32') """ check_type(shape, 'shape', (list, tuple, numpy.ndarray), 'create_parameter') for item in shape: @@ -161,9 +161,9 @@ def create_global_var(shape, Examples: .. code-block:: python - import paddle.fluid as fluid - import paddle.fluid.layers as layers - var = layers.create_global_var(shape=[2,3], value=1.0, dtype='float32', + import paddle + paddle.enable_static() + var = paddle.static.create_global_var(shape=[2,3], value=1.0, dtype='float32', persistable=True, force_cpu=True, name='new_var') """ check_type(shape, 'shape', (list, tuple, numpy.ndarray), diff --git a/python/paddle/fluid/param_attr.py b/python/paddle/fluid/param_attr.py index a76faf10590684e09f361cef3c6bbd5f3b9ce799..83f54fc8208dbab4274e1594bf340d1073fca724 100644 --- a/python/paddle/fluid/param_attr.py +++ b/python/paddle/fluid/param_attr.py @@ -61,15 +61,15 @@ class ParamAttr(object): Examples: .. code-block:: python - import paddle.fluid as fluid - - w_param_attrs = fluid.ParamAttr(name="fc_weight", - learning_rate=0.5, - regularizer=fluid.regularizer.L2Decay(1.0), - trainable=True) - print(w_param_attrs.name) # "fc_weight" - x = fluid.data(name='X', shape=[None, 1], dtype='float32') - y_predict = fluid.layers.fc(input=x, size=10, param_attr=w_param_attrs) + import paddle + paddle.enable_static() + + weight_attr = paddle.ParamAttr(name="weight", + learning_rate=0.5, + regularizer=paddle.regularizer.L2Decay(1.0), + trainable=True) + print(weight_attr.name) # "weight" + paddle.nn.Linear(3, 4, weight_attr=weight_attr) """ def __init__(self, @@ -206,7 +206,7 @@ class ParamAttr(object): class WeightNormParamAttr(ParamAttr): """ - :api_attr: Static Graph + :api_attr: Static Graph Note: Please use 'paddle.nn.utils.weight_norm' in dygraph mode. diff --git a/python/paddle/static/__init__.py b/python/paddle/static/__init__.py index 0f65083dc52e7fbf711b92e97d95e9907c753be7..909a1b6f39503cee7c908a9e302fe9929b13dfee 100644 --- a/python/paddle/static/__init__.py +++ b/python/paddle/static/__init__.py @@ -23,6 +23,7 @@ __all__ = [ ] from . import nn +from ..fluid import Scope #DEFINE_ALIAS from .input import data #DEFINE_ALIAS from .input import InputSpec #DEFINE_ALIAS from ..fluid.executor import Executor #DEFINE_ALIAS @@ -50,3 +51,5 @@ from ..fluid.io import save_inference_model #DEFINE_ALIAS from ..fluid.io import load_inference_model #DEFINE_ALIAS from ..fluid.io import load_program_state #DEFINE_ALIAS from ..fluid.io import set_program_state #DEFINE_ALIAS +from ..fluid.layers import create_parameter #DEFINE_ALIAS +from ..fluid.layers import create_global_var #DEFINE_ALIAS diff --git a/python/paddle/static/nn/__init__.py b/python/paddle/static/nn/__init__.py index 510e11312f4ce1d037e687b18f79d36b0b8f1104..31a99f6282718c562e2420a017215454f2dfd059 100644 --- a/python/paddle/static/nn/__init__.py +++ b/python/paddle/static/nn/__init__.py @@ -33,6 +33,7 @@ __all__ = [ 'multi_box_head', 'nce', 'prelu', + 'py_func', 'row_conv', 'spectral_norm', 'switch_case', @@ -57,6 +58,7 @@ from ...fluid.layers import layer_norm #DEFINE_ALIAS from ...fluid.layers import multi_box_head #DEFINE_ALIAS from ...fluid.layers import nce #DEFINE_ALIAS from ...fluid.layers import prelu #DEFINE_ALIAS +from ...fluid.layers import py_func #DEFINE_ALIAS from ...fluid.layers import row_conv #DEFINE_ALIAS from ...fluid.layers import spectral_norm #DEFINE_ALIAS from ...fluid.layers import switch_case #DEFINE_ALIAS diff --git a/tools/wlist.json b/tools/wlist.json index 3ca14cd1dd6f964f87031e31128bfb2cb1c733a1..22bab658464cb55f04488c20c86cf0c35f8c3968 100644 --- a/tools/wlist.json +++ b/tools/wlist.json @@ -279,7 +279,6 @@ "thresholded_relu", "group_norm", "random_crop", - "py_func", "row_conv", "hard_shrink", "ssd_loss",