data¶

paddle.fluid. data ( name, shape, dtype='float32', lod_level=0 ) [source]

Data Layer

This function creates a variable on the global block. The global variable can be accessed by all the following operators in the graph. The variable is a placeholder that could be fed with input, such as Executor can feed input into the variable.

Note

paddle.fluid.layers.data is deprecated. It will be removed in a future version. Please use this paddle.fluid.data.

The paddle.fluid.layers.data set shape and dtype at compile time but does NOT check the shape or the dtype of fed data, this paddle.fluid.data checks the shape and the dtype of data fed by Executor or ParallelExecutor during run time.

To feed variable size inputs, users can set None or -1 on the variable dimension when using paddle.fluid.data, or feed variable size inputs directly to paddle.fluid.layers.data and PaddlePaddle will fit the size accordingly.

The default stop_gradient attribute of the Variable created by this API is true, which means the gradient won’t be passed backward through the data Variable. Set var.stop_gradient = False If user would like to pass backward gradient.

Parameters

• name (str) – The name/alias of the variable, see Name for more details.

• shape (list|tuple) – List|Tuple of integers declaring the shape. You can set “None” or -1 at a dimension to indicate the dimension can be of any size. For example, it is useful to set changeable batch size as “None” or -1.

• dtype (np.dtype|VarType|str, optional) – The type of the data. Supported dtype: bool, float16, float32, float64, int8, int16, int32, int64, uint8. Default: float32.

• lod_level (int, optional) – The LoD level of the LoDTensor. Usually users don’t have to set this value. For more details about when and how to use LoD level, see user_guide_lod_tensor . Default: 0.

Returns

The global variable that gives access to the data.

Return type

Variable

Examples

import paddle
import paddle.fluid as fluid
import numpy as np
paddle.enable_static()

# Creates a variable with fixed size [3, 2, 1]
# User can only feed data of the same shape to x
x = fluid.data(name='x', shape=[3, 2, 1], dtype='float32')

# Creates a variable with changeable batch size -1.
# Users can feed data of any batch size into y,
# but size of each data sample has to be [2, 1]
y = fluid.data(name='y', shape=[-1, 2, 1], dtype='float32')

z = x + y

# In this example, we will feed x and y with np-ndarray "1"
# and fetch z, like implementing "1 + 1 = 2" in PaddlePaddle
feed_data = np.ones(shape=[3, 2, 1], dtype=np.float32)

exe = fluid.Executor(fluid.CPUPlace())
out = exe.run(fluid.default_main_program(),
              feed={
                  'x': feed_data,
                  'y': feed_data
              },
              fetch_list=[z.name])

# np-ndarray of shape=[3, 2, 1], dtype=float32, whose elements are 2
print(out)