paddle.static.nn. fc ( x, size, num_flatten_dims=1, weight_attr=None, bias_attr=None, activation=None, name=None ) [source]

Fully-Connected layer can take a tensor or a list of tensor as its inputs. It creates a 2-D weight tensor for each input tensor, which represents its weight matrix from each input unit to each output unit. The fully connected layer multiplies each input tensor with its corresponding weight to produce an output tensor with shape \([batch\_size, *, size]\) , where \(*\) means any number of additional dimensions. If a list of tensor is given, the results of multiple output tensors with shape \([batch\_size, *, size]\) will be summed up. If bias_attr is not False, a 1-D bias tensor will be created and added to the output. Finally, if activation is not None, it will be applied to the output as well.

For a single input tensor \(X\) , the equation is:

\[Out = Act({XW + b})\]

For a list of input tensor, the equation is:

\[Out = Act({\sum_{i=0}^{N-1}X_iW_i + b})\]


  • \(N\): The number of the input tensors. \(N\) equals to \(len(X)\) if \(X\) is list of tensor.

  • \(X_i\): The i-th input tensor.

  • \(W_i\): The i-th weight matrix corresponding i-th input tensor.

  • \(b\): The bias created by this layer (if needed).

  • \(Act\): The activation function.

  • \(Out\): The output tensor.

# Case 1, input is a single tensor:
x.data = [[[0.1, 0.2],
           [0.3, 0.4]]]
x.shape = (1, 2, 2) # 1 is batch_size

out = paddle.static.nn.fc(x=x, size=1, num_flatten_dims=2)

# Get the output:
out.data = [[0.83234344], [0.34936576]]
out.shape = (1, 2, 1)

# Case 2, input is a list of tensor:
x0.data = [[[0.1, 0.2],
            [0.3, 0.4]]]
x0.shape = (1, 2, 2) # 1 is batch_size

x1.data = [[[0.1, 0.2, 0.3]]]
x1.shape = (1, 1, 3)

out = paddle.static.nn.fc(x=[x0, x1], size=2)

# Get the output:
out.data = [[0.18669507, 0.1893476]]
out.shape = (1, 2)
  • x (Tensor|list[Tensor]|tuple[Tensor]) – A tensor or a list/tuple of tensors. The number of dimensions of each tensor is at least 2. The data type should be float16, float32 or float64.

  • size (int) – The number of output units in this layer, which also means the feature size of output tensor.

  • num_flatten_dims (int, optional) – The fc layer can accept an input tensor with more than two dimensions. If this happens, the multi-dimensional tensor will first be flattened into a 2-D matrix. The parameter num_flatten_dims determines how the input tensor is flattened: the first \(num\_flatten\_dims\) (inclusive, index starts from 1) dimensions will be flatten to form the first dimension of the final matrix (height of the matrix), and the rest \(rank(x) - num\_flatten\_dims\) dimensions are flattened to form the second dimension of the final matrix (width of the matrix). For example, assuming that x is a 5-dimensional tensor with a shape \([2, 3, 4, 5, 6]\) , and num_flatten_dims = 3. Then, the flattened matrix will have a shape \([2 * 3 * 4, 5 * 6] = [24, 30]\) . Default: 1.

  • weight_attr (ParamAttr, optional) – The attribute for the learnable weight. The default value is None, and the weight will be initialized to zero. For detailed information, please refer to paddle.ParamAttr. Warning, if x is a list of tensor, weight_attr should also be a list of same length.

  • bias_attr (ParamAttr|bool, optional) – The attribute of the learnable bias. If it is set to False, no bias will be added to the output. If it is set to None or one kind of ParamAttr, a bias parameter will be created according to ParamAttr. For detailed information, please refer to paddle.ParamAttr. The default value is None and the bias will be initialized to zero.

  • activation (str, optional) – Activation to be applied to the output of this layer, such as tanh, softmax, sigmoid, relu. For more information, please refer to Activation Function . Default: None.

  • name (str, optional) – The default value is None. Normally there is no need for user to set it. For more information, please refer to Name .


Tensor, its shape is \([batch\_size, *, size]\) , and the data type is same with input.


>>> import paddle
>>> paddle.enable_static()

>>> # When input is a single tensor
>>> x = paddle.static.data(name="x", shape=[1, 2, 2], dtype="float32")
>>> out = paddle.static.nn.fc(
...     x=x,
...     size=1,
...     num_flatten_dims=2,
...     weight_attr=paddle.ParamAttr(initializer=paddle.nn.initializer.Constant(value=0.5)),
...     bias_attr=paddle.ParamAttr(initializer=paddle.nn.initializer.Constant(value=1.0)))
>>> print(out)
var fc_0.tmp_1 : LOD_TENSOR.shape(1, 2, 1).dtype(float32).stop_gradient(False)

>>> # When input is multiple tensors
>>> x0 = paddle.static.data(name="x0", shape=[1, 2, 2], dtype="float32")
>>> x1 = paddle.static.data(name="x1", shape=[1, 1, 3], dtype="float32")

>>> out = paddle.static.nn.fc(
...     x=[x0, x1],
...     size=2,
...     weight_attr=paddle.ParamAttr(initializer=paddle.nn.initializer.Constant(value=0.5)),
...     bias_attr=paddle.ParamAttr(initializer=paddle.nn.initializer.Constant(value=1.0)))
>>> print(out)
var fc_1.tmp_3 : LOD_TENSOR.shape(1, 2).dtype(float32).stop_gradient(False)

Used in the guide/tutorials