m53297601
/
Paddle
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[API 2.0]Update 2.0 api from fluid to paddle. (#27598)

Browse Source
my_2.0rc
Wilber 4 years ago committed by GitHub
parent 7f9b198d59
commit 488152a6d0
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 58 additions and 49 deletions
Show Stats Download Patch File Download Diff File

9
python/paddle/fluid/executor.py
Unescape View File

@ -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())
"""

60
python/paddle/fluid/layers/nn.py
Unescape View File

@ -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

12
python/paddle/fluid/layers/tensor.py
Unescape View File

@ -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),

12
python/paddle/fluid/param_attr.py
Unescape View File

@ -61,15 +61,15 @@ class ParamAttr(object):
Examples:
.. code-block:: python
import paddle.fluid as fluid
import paddle
paddle.enable_static()
w_param_attrs = fluid.ParamAttr(name="fc_weight",
weight_attr = paddle.ParamAttr(name="weight",
learning_rate=0.5,
regularizer=fluid.regularizer.L2Decay(1.0),
regularizer=paddle.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)
print(weight_attr.name) # "weight"
paddle.nn.Linear(3, 4, weight_attr=weight_attr)
"""
def __init__(self,

3
python/paddle/static/__init__.py
Unescape View File

@ -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

2
python/paddle/static/nn/__init__.py
Unescape View File

@ -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

1
tools/wlist.json
Unescape View File

@ -279,7 +279,6 @@
"thresholded_relu",
"group_norm",
"random_crop",
"py_func",
"row_conv",
"hard_shrink",
"ssd_loss",

Write Preview
Loading…
Cancel
Save