Tensor¶
Tensor 是 Paddle 中最为基础的数据结构，请参考 Tensor 介绍
用预先存在的
data数据创建 1 个 Tensor，请参考 to_tensor创建一个与其他 Tensor 具有相同
shape与dtype的 Tensor，请参考 ones_like 、 zeros_like 、 full_like
create_tensor(dtype, name=None, persistable=False)¶
根据数据类型 dtype 创建一个 Tensor。
返回：Tensor，数据类型为指定的 dtype。
返回类型：Tensor
代码示例
>>> import paddle
>>> tensor = paddle.tensor.create_tensor(dtype='float32')
clear_grad¶
将当前 Tensor 的梯度设为 0。仅适用于具有梯度的 Tensor，通常我们将其用于参数，因为其他临时 Tensor 没有梯度。
代码示例
import paddle input = paddle.uniform([10, 2]) linear = paddle.nn.Linear(2, 3) out = linear(input) out.backward() print("Before clear_grad, linear.weight.grad: {}".format(linear.weight.grad)) linear.weight.clear_grad() print("After clear_grad, linear.weight.grad: {}".format(linear.weight.grad))
clear_gradient¶
与 clear_grad 功能相同，请参考：clear_grad
dtype¶
查看一个 Tensor 的数据类型，支持：'bool'，'float16'，'float32'，'float64'，'uint8'，'int8'，'int16'，'int32'，'int64' 类型。
代码示例
import paddle x = paddle.to_tensor([1.0, 2.0, 3.0]) print("tensor's type is: {}".format(x.dtype))
type¶
查看一个 Tensor 的类型。
代码示例
>>> import paddle
>>> x = paddle.to_tensor(1.)
>>> print(x.type)
VarType.LOD_TENSOR
grad¶
查看一个 Tensor 的梯度，数据类型为 paddle.Tensor。
代码示例
import paddle x = paddle.to_tensor([1.0, 2.0, 3.0], stop_gradient=False) y = paddle.to_tensor([4.0, 5.0, 6.0], stop_gradient=False) z = x * y z.backward() print("tensor's grad is: {}".format(x.grad))
is_leaf¶
判断 Tensor 是否为叶子 Tensor。对于 stop_gradient 为 True 的 Tensor，它将是叶子 Tensor。对于 stop_gradient 为 False 的 Tensor， 如果它是由用户创建的，它也会是叶子 Tensor。
代码示例
import paddle x = paddle.to_tensor(1.) print(x.is_leaf) # True x = paddle.to_tensor(1., stop_gradient=True) y = x + 1 print(x.is_leaf) # True print(y.is_leaf) # True x = paddle.to_tensor(1., stop_gradient=False) y = x + 1 print(x.is_leaf) # True print(y.is_leaf) # False
item(*args)¶
将 Tensor 中特定位置的元素转化为 Python 标量，如果未指定位置，则该 Tensor 必须为单元素 Tensor。
代码示例
import paddle x = paddle.to_tensor(1) print(x.item()) #1 print(type(x.item())) #<class 'int'> x = paddle.to_tensor(1.0) print(x.item()) #1.0 print(type(x.item())) #<class 'float'> x = paddle.to_tensor(True) print(x.item()) #True print(type(x.item())) #<class 'bool'> x = paddle.to_tensor(1+1j) print(x.item()) #(1+1j) print(type(x.item())) #<class 'complex'> x = paddle.to_tensor([[1.1, 2.2, 3.3]]) print(x.item(2)) #3.3 print(x.item(0, 2)) #3.3
name¶
查看一个 Tensor 的 name，Tensor 的 name 是其唯一标识符，为 python 的字符串类型。
代码示例
import paddle print("Tensor name: ", paddle.to_tensor(1).name) # Tensor name: generated_tensor_0
ndim¶
查看一个 Tensor 的维度，也称作 rank。
代码示例
import paddle print("Tensor's number of dimensition: ", paddle.to_tensor([[1, 2], [3, 4]]).ndim) # Tensor's number of dimensition: 2
persistable¶
查看一个 Tensor 的 persistable 属性，该属性为 True 时表示持久性变量，持久性变量在每次迭代之后都不会删除。模型参数、学习率等 Tensor，都是 持久性变量。
代码示例
import paddle print("Whether Tensor is persistable: ", paddle.to_tensor(1).persistable) # Whether Tensor is persistable: false
place¶
查看一个 Tensor 的设备位置，Tensor 可能的设备位置有三种：CPU/GPU/固定内存，其中固定内存也称为不可分页内存或锁页内存， 其与 GPU 之间具有更高的读写效率，并且支持异步传输，这对网络整体性能会有进一步提升，但其缺点是分配空间过多时可能会降低主机系统的性能， 因为其减少了用于存储虚拟内存数据的可分页内存。
代码示例
import paddle cpu_tensor = paddle.to_tensor(1, place=paddle.CPUPlace()) print(cpu_tensor.place)
layout¶
查看一个 Tensor 的 layout，layout 是 Tensor 的一个重要的概念，其描述了 tensor 的数据格式。
代码示例
>>> import paddle
>>> x = paddle.to_tensor([1, 2, 3])
>>> print(x.layout)
NCHW
shape¶
查看一个 Tensor 的 shape，shape 是 Tensor 的一个重要的概念，其描述了 tensor 在每个维度上的元素数量。
代码示例
>>> import paddle
>>> x = paddle.to_tensor(1.0, stop_gradient=False)
>>> print(x.shape)
[]
strides¶
查看一个 Tensor 的 strides。
代码示例
>>> import paddle
>>> x = paddle.to_tensor([1, 2, 3])
>>> y = x[1]
>>> print(y.strides)
[]
dist_attr¶
查看一个 Tensor 的 dist_attr，只有分布式 Tensor 才会有 dist_attr 属性，其描述了 tensor 的分布式属性。
代码示例
>>> import paddle
>>> import paddle.distributed as dist
>>> mesh = dist.ProcessMesh([[2, 4, 5], [0, 1, 3]], dim_names=["x", "y"])
>>> dist_attr = dist.DistAttr(mesh=mesh, sharding_specs=['x', 'y'])
>>> a = paddle.to_tensor([[1,2,3],
... [5,6,7]])
>>> d_tensor = dist.shard_tensor(a, dist_attr=dist_attr)
>>> print(d_tensor.dist_attr)
offset¶
查看一个 Tensor 的第一个元素数据地址相对于 Tensor 持有的存储空间首地址的偏移量。
代码示例
>>> import paddle
>>> x = paddle.to_tensor([1, 2, 3])
>>> y = x[1]
>>> print(y.offset)
8
stop_gradient¶
查看一个 Tensor 是否计算并传播梯度，如果 stop_gradient 为 True，则该 Tensor 不会计算梯度，并会阻绝 Autograd 的梯度传播。 反之，则会计算梯度并传播梯度。用户自行创建的 Tensor，默认是 True，模型参数的 stop_gradient 都为 False。
代码示例
import paddle print("Tensor's stop_gradient: ", paddle.to_tensor([[1, 2], [3, 4]]).stop_gradient) # Tensor's stop_gradient: True
data¶
查看或者修改一个 Tensor 的数据。
代码示例
>>> import paddle
>>> x = paddle.to_tensor(1.)
>>> print(x)
Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True,
1.)
>>> print(x.data)
Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True,
1.)
>>> x.data = paddle.to_tensor(2.)
>>> print(x)
Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True,
2.)
>>> print(x.data)
Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True,
2.)
numpy()¶
返回：将 Tensor 转为 numpy 返回
返回类型：numpy.ndarray
代码示例
>>> import paddle
>>> data = paddle.uniform([30, 10, 32], dtype="float32", min=-1, max=1)
>>> linear = paddle.nn.Linear(32, 64)
>>> data = paddle.to_tensor(data)
>>> x = linear(data)
reconstruct_from_(other)¶
返回：使用 other 重新构建当前 Tensor
返回类型：None
代码示例
>>> import paddle
>>> t1 = paddle.to_tensor([1.0], stop_gradient=False)
>>> t2 = paddle.to_tensor([2.0], stop_gradient=True)
>>> t1.reconstruct_from_(t2)
>>> print(t1)
Tensor(shape=[1], dtype=float32, place=Place(cpu), stop_gradient=True, [2.])
clone()¶
返回：克隆的新的 Tensor
返回类型：Tensor
代码示例
>>> import paddle
>>> x = paddle.to_tensor(1.0, stop_gradient=False)
>>> clone_x = x.clone()
>>> clone_x.retain_grads()
>>> y = clone_x**2
>>> y.backward()
>>> print(clone_x.stop_gradient)
False
>>> print(clone_x.grad)
Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=False, 2.)
>>> print(x.stop_gradient)
False
>>> print(x.grad)
Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=False, 2.)
>>> x = paddle.to_tensor(1.0)
>>> clone_x = x.clone()
>>> clone_x.stop_gradient = False
>>> z = clone_x**3
>>> z.backward()
>>> print(clone_x.stop_gradient)
False
>>> print(clone_x.grad)
Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=False, 3.)
>>> print(x.stop_gradient)
True
>>> print(x.grad)
None
retain_grads()¶
返回：在 backward()时保留该 Tensor 的反向梯度
返回类型：None
代码示例
>>> import paddle
>>> x = paddle.to_tensor([1.0, 2.0, 3.0])
>>> x.stop_gradient = False
>>> y = x + x
>>> y.retain_grads()
>>> loss = y.sum()
>>> loss.backward()
>>> print(y.grad)
Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=False,
[1., 1., 1.])
>>> x = paddle.to_tensor([1.0, 2.0, 3.0])
>>> x.stop_gradient = False
>>> y = x + x
>>> y.retain_grads()
>>> loss = y.sum()
>>> loss.backward()
>>> print(y.grad)
Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=False,
[1., 1., 1.])
clear_gradient(set_to_zero=True)¶
清理 Tensor 的反向梯度。 参数：
set_to_zero (bool) - True 表示将梯度值覆盖为 0。False 则释放梯度持有的存储空间。
返回：None
代码示例
>>> import paddle
>>> input = paddle.uniform([10, 2])
>>> linear = paddle.nn.Linear(2, 3)
>>> out = linear(input)
>>> out.backward()
>>> print("Before clear_gradient, linear.weight.grad: {}".format(linear.weight.grad))
Before clear_gradient, linear.weight.grad: Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=False,
[[-0.03178465, -0.03178465, -0.03178465],
[-0.98546225, -0.98546225, -0.98546225]])
>>> linear.weight.clear_gradient()
>>> print("After clear_gradient, linear.weight.grad: {}".format(linear.weight.grad))
After clear_gradient, linear.weight.grad: Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=False,
[[0., 0., 0.],
[0., 0., 0.]])
detach()¶
返回：返回一个新的 Tensor，数据与本 Tensor 相等。但新的 Tensor 脱离当前计算图。
返回类型：Tensor
代码示例
>>> import paddle
>>> x = paddle.to_tensor([1.0], stop_gradient=False)
>>> detach_x = x.detach()
>>> detach_x[0] = 10.0
>>> print(x)
Tensor(shape=[1], dtype=float32, place=CPUPlace, stop_gradient=False, [10.])
>>> y = x**2
>>> y.backward()
>>> print(x.grad)
Tensor(shape=[1], dtype=float32, place=Place(cpu), stop_gradient=False, [20.])
>>> print(detach_x.grad) # None, 'stop_gradient=True' by default
None
>>> detach_x.stop_gradient = False # Set stop_gradient to be False, supported auto-grad
>>> z = detach_x**3
>>> z.backward()
>>> print(x.grad)
Tensor(shape=[1], dtype=float32, place=Place(cpu), stop_gradient=False, [20.])
>>> print(detach_x.grad)
Tensor(shape=[1], dtype=float32, place=Place(cpu), stop_gradient=False, [300.])
>>> # Due to sharing of data with origin Tensor, There are some unsafe operations:
>>> # y = 2 * x
>>> # detach_x[:] = 5.0
>>> # y.backward()
>>> # It will raise Error:
>>> # one of the variables needed for gradient computation has been modified by an inplace operation.
get_tensor()¶
返回：让当前 Tensor 内部的数据 Tensor，如 DenseTensor、DistTensor。
返回类型：DenseTensor/DistTensor
代码示例
>>> import paddle
>>> x = paddle.to_tensor([1.0], stop_gradient=False)
>>> underline_x = x.get_tensor()
>>> print(underline_x)
- place: Place(cpu)
- shape: [1]
- layout: NCHW
- dtype: float32
- data: [1]
is_dense()¶
返回：返回本 Tensor 是否为 DenseTensor。
返回类型：bool
代码示例
>>> import paddle
>>> x = paddle.to_tensor([1.0], stop_gradient=False)
>>> print(x.is_dense())
True
is_dist()¶
返回：返回本 Tensor 是否为 DistTensor。
返回类型：bool
代码示例
>>> import paddle
>>> x = paddle.to_tensor([1.0], stop_gradient=False)
>>> print(x.is_dist())
False
data_ptr()¶
返回：返回本 Tensor 第一个元素的数据地址。
返回类型：int
代码示例
>>> import paddle
>>> x = paddle.to_tensor([1, 2, 3])
>>> print(x.data_ptr())
93220864
get_strides()¶
返回：返回本 Tensor 的 strides。
返回类型：list
代码示例
>>> import paddle
>>> x = paddle.to_tensor([1, 2, 3])
>>> y = x[1]
>>> print(y.get_strides())
[]
contiguous()¶
返回：将本 Tensor 转为连续的 Tensor 返回。如果本 Tensor 已经是连续的则返回本 Tensor。
返回类型：Tensor。
代码示例
>>> import paddle
>>> x = paddle.to_tensor([1, 2, 3])
>>> y = x[1]
>>> y = y.contiguous()
>>> print(y)
Tensor(shape=[], dtype=int64, place=Place(cpu), stop_gradient=True, 2)
is_contiguous()¶
返回：本 Tensor 是否为连续的。
返回类型：bool
代码示例
>>> import paddle
>>> x = paddle.to_tensor([1, 2, 3])
>>> y = x[1]
>>> print(y.is_contiguous())
allclose(y, rtol=1e-05, atol=1e-08, equal_nan=False, name=None)¶
返回：计算后的 Tensor
返回类型：Tensor
请参考 allclose
isclose(x, y, rtol=1e-05, atol=1e-08, equal_nan=False, name=None)¶
返回：计算后的 Tensor
返回类型：Tensor
请参考 isclose
astype(dtype)¶
将 Tensor 的类型转换为 dtype，并返回一个新的 Tensor。
- 参数：
-
dtype (str) - 转换后的 dtype，支持'bool'，'float16'，'float32'，'float64'，'int8'，'int16'， 'int32'，'int64'，'uint8'。
返回：类型转换后的新的 Tensor
返回类型：Tensor
- 代码示例
-
import paddle x = paddle.to_tensor(1.0) print("original tensor's dtype is: {}".format(x.dtype)) print("new tensor's dtype is: {}".format(x.astype('float64').dtype))
backward(grad_tensor=None, retain_graph=False)¶
从当前 Tensor 开始计算反向的神经网络，传导并计算计算图中 Tensor 的梯度。
- 参数：
-
grad_tensor (Tensor, 可选) - 当前 Tensor 的初始梯度值。如果
grad_tensor是 None，当前 Tensor 的初始梯度值将会是值全为 1.0 的 Tensor；如果grad_tensor不是 None，必须和当前 Tensor 有相同的长度。默认值：None。retain_graph (bool, 可选) - 如果为 False，反向计算图将被释放。如果在 backward()之后继续添加 OP， 需要设置为 True，此时之前的反向计算图会保留。将其设置为 False 会更加节省内存。默认值：False。
返回：无
- 代码示例
-
import paddle x = paddle.to_tensor(5., stop_gradient=False) for i in range(5): y = paddle.pow(x, 4.0) y.backward() print("{}: {}".format(i, x.grad)) # 0: [500.] # 1: [1000.] # 2: [1500.] # 3: [2000.] # 4: [2500.] x.clear_grad() print("{}".format(x.grad)) # 0. grad_tensor=paddle.to_tensor(2.) for i in range(5): y = paddle.pow(x, 4.0) y.backward(grad_tensor) print("{}: {}".format(i, x.grad)) # 0: [1000.] # 1: [2000.] # 2: [3000.] # 3: [4000.] # 4: [5000.]
bucketize(sorted_sequence, out_int32=False, right=False, name=None)¶
返回: 根据给定的一维 Tensor sorted_sequence ，输入 x 对应的桶索引。
返回类型：Tensor。
请参考 bucketize
clone()¶
复制当前 Tensor，并且保留在原计算图中进行梯度传导。
返回：clone 后的 Tensor
- 代码示例
-
import paddle x = paddle.to_tensor(1.0, stop_gradient=False) clone_x = x.clone() y = clone_x**2 y.backward() print(clone_x.stop_gradient) # False print(clone_x.grad) # [2.0], support gradient propagation print(x.stop_gradient) # False print(x.grad) # [2.0], clone_x support gradient propagation for x x = paddle.to_tensor(1.0) clone_x = x.clone() clone_x.stop_gradient = False z = clone_x**3 z.backward() print(clone_x.stop_gradient) # False print(clone_x.grad) # [3.0], support gradient propagation print(x.stop_gradient) # True print(x.grad) # None
cosh(name=None)¶
对该 Tensor 中的每个元素求双曲余弦。
返回类型：Tensor
请参考 cosh
代码示例
>>> import paddle
>>> x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
>>> out = paddle.cosh(x)
>>> print(out)
Tensor(shape=[4], dtype=float32, place=Place(cpu), stop_gradient=True,
[1.08107233, 1.02006674, 1.00500417, 1.04533851])
count_nonzero(axis=None, keepdim=False, name=None)¶
返回：沿给定的轴 axis 统计输入 Tensor x 中非零元素的个数。
返回类型：Tensor
请参考 count_nonzero
cpu()¶
将当前 Tensor 的拷贝到 CPU 上，且返回的 Tensor 不保留在原计算图中。
如果当前 Tensor 已经在 CPU 上，则不会发生任何拷贝。
返回：拷贝到 CPU 上的 Tensor
- 代码示例
-
import paddle if paddle.device.cuda.device_count() > 0: x = paddle.to_tensor(1.0, place=paddle.CUDAPlace(0)) print(x.place) # CUDAPlace(0) x = paddle.to_tensor(1.0) y = x.cpu() print(y.place) # CPUPlace
cuda(device_id=None, blocking=False)¶
将当前 Tensor 的拷贝到 GPU 上，且返回的 Tensor 不保留在原计算图中。
如果当前 Tensor 已经在 GPU 上，且 device_id 为 None，则不会发生任何拷贝。
- 参数：
-
device_id (int, 可选) - 目标 GPU 的设备 Id，默认为 None，此时为当前 Tensor 的设备 Id，如果当前 Tensor 不在 GPU 上，则为 0。
blocking (bool, 可选) - 如果为 False 并且当前 Tensor 处于固定内存上，将会发生主机到设备端的异步拷贝。否则，会发生同步拷贝。默认为 False。
返回：拷贝到 GPU 上的 Tensor
- 代码示例
-
import paddle x = paddle.to_tensor(1.0, place=paddle.CPUPlace()) print(x.place) # CPUPlace if paddle.device.cuda.device_count() > 0: y = x.cuda() print(y.place) # CUDAPlace(0) y = x.cuda(1) print(y.place) # CUDAPlace(1)
dim()¶
查看一个 Tensor 的维度，也称作 rank。
代码示例
import paddle print("Tensor's number of dimensition: ", paddle.to_tensor([[1, 2], [3, 4]]).dim()) # Tensor's number of dimensition: 2
element_size()¶
返回 Tensor 单个元素在计算机中所分配的 bytes 数量。
返回：整数 int
- 代码示例
-
import paddle x = paddle.to_tensor(1, dtype='bool') x.element_size() # 1 x = paddle.to_tensor(1, dtype='float16') x.element_size() # 2 x = paddle.to_tensor(1, dtype='float32') x.element_size() # 4 x = paddle.to_tensor(1, dtype='float64') x.element_size() # 8 x = paddle.to_tensor(1, dtype='complex128') x.element_size() # 16
exponential_(lam=1.0, name=None)¶
该 OP 为 inplace 形式，通过 指数分布 随机数来填充该 Tensor。
lam 是 指数分布 的 \(\lambda\) 参数。随机数符合以下概率密度函数：
- 参数：
-
x (Tensor) - 输入 Tensor，数据类型为 float32/float64。
lam (float) - 指数分布的 \(\lambda\) 参数。
name (str，可选) - 具体用法请参见 Name，一般无需设置，默认值为 None。
返回：原 Tensor
- 代码示例
-
import paddle paddle.set_device('cpu') paddle.seed(100) x = paddle.empty([2,3]) x.exponential_() # [[0.80643415, 0.23211166, 0.01169797], # [0.72520673, 0.45208144, 0.30234432]]
fill_(x, value, name=None)¶
以 value 值填充 Tensor x 中所有数据。对 x 的原地 Inplace 修改。
- 参数：
-
x (Tensor) - 需要修改的原始 Tensor。
value (float) - 以输入 value 值修改原始 Tensor 元素。
name (str，可选) - 具体用法请参见 Name，一般无需设置，默认值为 None。
返回：修改原始 Tensor x 的所有元素为 value 以后的新的 Tensor。
- 代码示例
-
import paddle tensor = paddle.to_tensor([0,1,2,3,4]) tensor.fill_(0) print(tensor.tolist()) #[0, 0, 0, 0, 0]
zero_(x, name=None)¶
以 0 值填充 Tensor x 中所有数据。对 x 的原地 Inplace 修改。
- 参数：
-
x (Tensor) - 需要修改的原始 Tensor。
name (str，可选) - 具体用法请参见 Name，一般无需设置，默认值为 None。
返回：修改原始 Tensor x 的所有元素为 0 以后的新的 Tensor。
- 代码示例
-
import paddle tensor = paddle.to_tensor([0,1,2,3,4]) tensor.zero_() print(tensor.tolist()) #[0, 0, 0, 0, 0]
fill_diagonal_(x, value, offset=0, wrap=False, name=None)¶
以 value 值填充输入 Tensor x 的对角线元素值。对 x 的原地 Inplace 修改。 输入 Tensor x 维度至少是 2 维，当维度大于 2 维时要求所有维度值相等。 当维度等于 2 维时，两个维度可以不等，且此时 wrap 选项生效，详见 wrap 参数说明。
- 参数：
-
x (Tensor) - 需要修改对角线元素值的原始 Tensor。
value (float) - 以输入 value 值修改原始 Tensor 对角线元素。
offset (int，可选) - 所选取对角线相对原始主对角线位置的偏移量，正向右上方偏移，负向左下方偏移，默认为 0。
wrap (bool，可选) - 对于 2 维 Tensor，height>width 时是否循环填充，默认为 False。
name (str，可选) - 具体用法请参见 Name，一般无需设置，默认值为 None。
返回：修改原始 Tensor x 的对角线元素为 value 以后的新的 Tensor。
- 代码示例
-
import paddle x = paddle.ones((4, 3)) x.fill_diagonal_(2) print(x.tolist()) #[[2.0, 1.0, 1.0], [1.0, 2.0, 1.0], [1.0, 1.0, 2.0], [1.0, 1.0, 1.0]] x = paddle.ones((7, 3)) x.fill_diagonal_(2, wrap=True) print(x) #[[2.0, 1.0, 1.0], [1.0, 2.0, 1.0], [1.0, 1.0, 2.0], [1.0, 1.0, 1.0], [2.0, 1.0, 1.0], [1.0, 2.0, 1.0], [1.0, 1.0, 2.0]]
fill_diagonal_tensor(x, y, offset=0, dim1=0, dim2=1, name=None)¶
将输入 Tensor y 填充到 Tensor x 的以 dim1、dim2 所指定对角线维度作为最后一个维度的局部子 Tensor 中，输入 Tensor x 其余维度作为该局部子 Tensor 的 shape 中的前几个维度。 其中输入 Tensor y 的维度要求是：最后一个维度与 dim1、dim2 指定的对角线维度相同，其余维度与输入 Tensor x 其余维度相同，且先后顺序一致。 例如，有输入 Tensor x，x.shape = (2,3,4,5)时，若 dim1=2，dim2=3，则 y.shape=(2,3,4)；若 dim1=1，dim2=2，则 y.shape=(2,5,3)；
- 参数：
-
x (Tensor) - 需要填充局部对角线区域的原始 Tensor。
y (Tensor) - 需要被填充到原始 Tensor x 对角线区域的输入 Tensor。
offset (int，可选) - 选取局部区域对角线位置相对原始主对角线位置的偏移量，正向右上方偏移，负向左下方偏移，默认为 0。
dim1 (int，可选) - 指定对角线所参考第一个维度，默认为 0。
dim2 (int，可选) - 指定对角线所参考第二个维度，默认为 1。
name (str，可选) - 具体用法请参见 Name，一般无需设置，默认值为 None。
返回：将 y 的值填充到输入 Tensor x 对角线区域以后所组合成的新 Tensor。
- 代码示例
-
import paddle x = paddle.ones((4, 3)) * 2 y = paddle.ones((3,)) nx = x.fill_diagonal_tensor(y) print(nx.tolist()) #[[1.0, 2.0, 2.0], [2.0, 1.0, 2.0], [2.0, 2.0, 1.0], [2.0, 2.0, 2.0]]
fill_diagonal_tensor_(x, y, offset=0, dim1=0, dim2=1, name=None)¶
Inplace 版本的 fill_diagonal_tensor(x, y, offset=0, dim1=0, dim2=1, name=None) API，对输入 x 采用 Inplace 策略。
- 代码示例
-
import paddle x = paddle.ones((4, 3)) * 2 y = paddle.ones((3,)) x.fill_diagonal_tensor_(y) print(x.tolist()) #[[1.0, 2.0, 2.0], [2.0, 1.0, 2.0], [2.0, 2.0, 1.0], [2.0, 2.0, 2.0]]
gradient()¶
与 Tensor.grad 相同，查看一个 Tensor 的梯度，数据类型为 numpy.ndarray。
返回：该 Tensor 的梯度 返回类型：numpy.ndarray
- 代码示例
-
import paddle x = paddle.to_tensor([1.0, 2.0, 3.0], stop_gradient=False) y = paddle.to_tensor([4.0, 5.0, 6.0], stop_gradient=False) z = x * y z.backward() print("tensor's grad is: {}".format(x.grad))
nanmedian(axis=None, keepdim=True, name=None)¶
返回：沿着 axis 忽略 NAN 元素进行中位数计算的结果
返回类型：Tensor
请参考 nanmedian
ndimension()¶
查看一个 Tensor 的维度，也称作 rank。
代码示例
import paddle print("Tensor's number of dimensition: ", paddle.to_tensor([[1, 2], [3, 4]]).ndimension()) # Tensor's number of dimensition: 2
pin_memory(y, name=None)¶
将当前 Tensor 的拷贝到固定内存上，且返回的 Tensor 不保留在原计算图中。
如果当前 Tensor 已经在固定内存上，则不会发生任何拷贝。
返回：拷贝到固定内存上的 Tensor
- 代码示例
-
import paddle if paddle.device.cuda.device_count() > 0: x = paddle.to_tensor(1.0, place=paddle.CUDAPlace(0)) print(x.place) # CUDAPlace(0) y = x.pin_memory() print(y.place) # CUDAPinnedPlace
reciprocal_(name=None)¶
Inplace 版本的 reciprocal API，对输入 x 采用 Inplace 策略。
register_hook(hook)¶
为当前 Tensor 注册一个反向的 hook 函数。
该被注册的 hook 函数将会在每次当前 Tensor 的梯度 Tensor 计算完成时被调用。
被注册的 hook 函数不会修改输入的梯度 Tensor，但是 hook 可以返回一个新的临时梯度 Tensor 代替当前 Tensor 的梯度继续进行反向传播。
输入的 hook 函数写法如下：
hook(grad) -> Tensor or None
- 参数：
-
hook (function) - 一个需要注册到 Tensor.grad 上的 hook 函数
返回：一个能够通过调用其 remove() 方法移除所注册 hook 的对象
返回类型：TensorHookRemoveHelper
- 代码示例
-
import paddle # hook function return None def print_hook_fn(grad): print(grad) # hook function return Tensor def double_hook_fn(grad): grad = grad * 2 return grad x = paddle.to_tensor([0., 1., 2., 3.], stop_gradient=False) y = paddle.to_tensor([4., 5., 6., 7.], stop_gradient=False) z = paddle.to_tensor([1., 2., 3., 4.]) # one Tensor can register multiple hooks h = x.register_hook(print_hook_fn) x.register_hook(double_hook_fn) w = x + y # register hook by lambda function w.register_hook(lambda grad: grad * 2) o = z.matmul(w) o.backward() # print_hook_fn print content in backward # Tensor(shape=[4], dtype=float32, place=CUDAPlace(0), stop_gradient=False, # [2., 4., 6., 8.]) print("w.grad:", w.grad) # w.grad: [1. 2. 3. 4.] print("x.grad:", x.grad) # x.grad: [ 4. 8. 12. 16.] print("y.grad:", y.grad) # y.grad: [2. 4. 6. 8.] # remove hook h.remove()
scale(scale=1.0, bias=0.0, bias_after_scale=True, act=None, name=None)¶
返回：计算后的 Tensor
返回类型：Tensor
请参考 scale
scale_(scale=1.0, bias=0.0, bias_after_scale=True, act=None, name=None)¶
Inplace 版本的 scale API，对输入 x 采用 Inplace 策略。
set_value(value)¶
设置当前 Tensor 的值。
- 参数：
-
value (Tensor|np.ndarray) - 需要被设置的值，类型为 Tensor 或者 numpy.array。
- 代码示例
-
import paddle import numpy as np data = np.ones([3, 1024], dtype='float32') linear = paddle.nn.Linear(1024, 4) input = paddle.to_tensor(data) linear(input) # call with default weight custom_weight = np.random.randn(1024, 4).astype("float32") linear.weight.set_value(custom_weight) # change existing weight out = linear(input) # call with different weight
返回：计算后的 Tensor
sinh(name=None)¶
对该 Tensor 中逐个元素求双曲正弦。
代码示例
>>> import paddle
>>> x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
>>> out = paddle.sinh(x)
>>> print(out)
Tensor(shape=[4], dtype=float32, place=Place(cpu), stop_gradient=True,
[-0.41075233, -0.20133601, 0.10016675, 0.30452031])
to(*args, **kwargs)¶
转换 Tensor 的设备或/和数据类型，并且返回转换后的 Tensor。该函数将会从 args 以及 kwargs 中解析出要转换到的目标类型 dtype 以及目标设备 place。 目前支持一下三种方式调用该方法：
to(dtype, blocking=True)
to(device, dtype=None, blocking=True)
to(other, blocking=True)
其中， dtype 可以是 paddle.dtype, numpy.dtype 类型或者是 ["bfloat16", "float16", "float32", "float64", "int8", "int16", "int32", "int64", "uint8", "complex64", "complex128", "bool"] 中的任意一个 str。 device 可以是 paddle.CPUPlace(), paddle.CUDAPlace(), paddle.CUDAPinnedPlace(), paddle.XPUPlace(), paddle.CustomPlace() 或者 str。 other 需要是 Tensor 类型。
返回：类型转换后的新的 Tensor
返回类型：Tensor
代码示例
>>> import paddle
>>> tensorx = paddle.to_tensor([1,2,3])
>>> print(tensorx)
Tensor(shape=[3], dtype=int64, place=Place(gpu:0), stop_gradient=True,
[1, 2, 3])
>>> tensorx = tensorx.to("cpu")
>>> print(tensorx.place)
Place(cpu)
>>> tensorx = tensorx.to("float32")
>>> print(tensorx.dtype)
paddle.float32
>>> tensorx = tensorx.to("gpu", "int16")
>>> print(tensorx)
Tensor(shape=[3], dtype=int16, place=Place(gpu:0), stop_gradient=True,
[1, 2, 3])
>>> tensor2 = paddle.to_tensor([4,5,6])
>>> tensor2
Tensor(shape=[3], dtype=int64, place=Place(gpu:0), stop_gradient=True,
[4, 5, 6])
>>> tensor2 = tensor2.to(tensorx)
>>> print(tensor2)
Tensor(shape=[3], dtype=int16, place=Place(gpu:0), stop_gradient=True,
[4, 5, 6])
triangular_solve(b, upper=True, transpose=False, unitriangular=False, name=None)¶
返回：计算后的 Tensor
返回类型：Tensor
请参考 triangular_solve
uniform_(min=-1.0, max=1.0, seed=0, name=None)¶
Inplace 版本的 uniform，返回一个从均匀分布采样的随机数填充的 Tensor。输出 Tensor 将被置于输入 x 的位置。
- 参数：
-
x (Tensor) - 待被随机数填充的输入 Tensor。
min (float|int，可选) - 生成随机数的下界，min 包含在该范围内。默认为-1.0。
max (float|int，可选) - 生成随机数的上界，max 不包含在该范围内。默认为 1.0。
-
- seed (int，可选) - 用于生成随机数的随机种子。如果 seed 为 0，将使用全局默认生成器的种子（可通过 paddle.seed 设置）。
-
注意如果 seed 不为 0，该操作每次将生成同一个随机值。默认为 0。
name (str，可选) - 具体用法请参见 Name，一般无需设置，默认值为 None。
返回：由服从范围在[min, max)的均匀分布的随机数所填充的输入 Tensor x。
返回类型：Tensor
- 代码示例
-
import paddle x = paddle.ones(shape=[3, 4]) x.uniform_() print(x) # result is random # Tensor(shape=[3, 4], dtype=float32, place=CUDAPlace(0), stop_gradient=True, # [[ 0.97134161, -0.36784279, -0.13951409, -0.48410338], # [-0.15477282, 0.96190143, -0.05395842, -0.62789059], # [-0.90525085, 0.63603556, 0.06997657, -0.16352385]])
unique(return_index=False, return_inverse=False, return_counts=False, axis=None, dtype=int64, name=None)¶
返回：计算后的 Tensor
返回类型：Tensor
请参考 unique
where(x, y, name=None)¶
调用该 where 方法的 Tensor 作为 condition 来选择 x 或 y 中的对应元素组成新的 Tensor 并返回。
返回：计算后的 Tensor
返回类型：Tensor
注解
只有 bool 类型的 Tensor 才能调用该方法。
示例：(x>0).where(x, y)， 其中 x， y 都是数值 Tensor。
请参考 where
take_along_axis(arr, indices, axis, broadcast=True)¶
基于输入索引矩阵，沿着指定 axis 从 arr 矩阵里选取 1d 切片。索引矩阵必须和 arr 矩阵有相同的维度，需要能够 broadcast 与 arr 矩阵对齐。
返回：计算后的 Tensor
返回类型：Tensor
请参考 take_along_axis
put_along_axis(arr, indices, value, axis, reduce="assign", include_self=True, broadcast=True)¶
基于输入 indices 矩阵，将输入 value 沿着指定 axis 放置入 arr 矩阵。索引矩阵和 value 必须和 arr 矩阵有相同的维度，如果 broadcast 为 True，则需要能够 broadcast 与 arr 矩阵对齐。
返回：计算后的 Tensor
返回类型：Tensor
请参考 put_along_axis
take(index, mode='raise', name=None)¶
返回：一个新的 Tensor，其中包含给定索引处的输入元素。结果与 index 的形状相同
返回类型：Tensor
请参考 take
data_ptr()¶
仅用于动态图 Tensor。返回 Tensor 的数据的存储地址。比如，如果 Tensor 是 CPU 的，则返回内存地址，如果 Tensor 是 GPU 的，则返回显存地址。 返回：Tensor 的数据的存储地址
返回类型：int
trapezoid(y, x=None, dx=None, axis=-1, name=None)¶
在指定维度上对输入实现 trapezoid rule 算法。使用求和函数 sum。
返回：计算后的 Tensor
返回类型：Tensor
请参考 trapezoid
cumulative_trapezoid(y, x=None, dx=None, axis=-1, name=None)¶
在指定维度上对输入实现 trapezoid rule 算法。使用求和函数 cumsum。
返回：计算后的 Tensor
返回类型：Tensor
vander(x, n=None, increasing=False, name=None)¶
生成范德蒙德矩阵, 默认生成维度为 (x.shape[0],x.shape[0]) 且降序的范德蒙德矩阵。其中输入 x 必须为 1-D Tensor。输入 n 为矩阵的列数。输入 increasing 决定了矩阵的升降序，默认为降序。
返回：返回一个根据 n 和 increasing 创建的范德蒙德矩阵。
返回类型：Tensor
请参考 vander
unflatten(axis, shape, name=None)¶
将输入 Tensor 沿指定轴 axis 上的维度展成 shape 形状。
返回：沿指定轴将维度展开的后的 Tensor。
返回类型：Tensor
请参考 unflatten
i0e(x, name=None)¶
用于将输入的 Tensor 计算第一类指数缩放的零阶修正贝塞尔函数。
返回：一个第一类指数缩放的零阶修正贝塞尔函数上的 Tensor。
返回类型：Tensor
请参考 i0e
i1e(x, name=None)¶
用于将输入的 Tensor 计算第一类指数缩放的一阶修正贝塞尔函数。
返回：返回第一类指数缩放的一阶修正贝塞尔函数对应输出 Tensor。
返回类型：Tensor
请参考 i1e
nnz()¶
注解
只有 SparseCooTensor 、SparseCsrTensor 才可调用该方法。
返回：输入稀疏 Tensor 的非 0 元素的个数
返回类型：int
代码示例
import paddle indices = [[0, 1, 2], [1, 2, 0]] values = [1.0, 2.0, 3.0] dense_shape = [3, 3] coo = paddle.sparse.sparse_coo_tensor(indices, values, dense_shape) coo.nnz() # 3
indices()¶
注解
只有 SparseCooTensor 才可调用该方法。
返回：输入 SparseCooTensor 的非 0 元素的索引
返回类型：DenseTensor
代码示例
import paddle indices = [[0, 1, 2], [1, 2, 0]] values = [1.0, 2.0, 3.0] dense_shape = [3, 3] coo = paddle.sparse.sparse_coo_tensor(indices, values, dense_shape) coo.indices() # Tensor(shape=[2, 3], dtype=int64, place=Place(gpu:0), stop_gradient=True, # [[0, 1, 2], # [1, 2, 0]])
values()¶
注解
只有 SparseCooTensor 才可调用该方法。
返回：输入 SparseCooTensor 的非 0 元素的值
返回类型：DenseTensor
代码示例
import paddle indices = [[0, 1, 2], [1, 2, 0]] values = [1.0, 2.0, 3.0] dense_shape = [3, 3] coo = paddle.sparse.sparse_coo_tensor(indices, values, dense_shape) coo.values() # Tensor(shape=[3], dtype=float32, place=Place(gpu:0), stop_gradient=True, # [1., 2., 3.])
crows()¶
注解
只有 SparseCsrTensor 才可调用该方法。
返回：输入 SparseCsrTensor 的非 0 元素的压缩行信息
返回类型：DenseTensor
代码示例
import paddle crows = [0, 2, 3, 5] cols = [1, 3, 2, 0, 1] values = [1, 2, 3, 4, 5] dense_shape = [3, 4] csr = paddle.sparse.sparse_csr_tensor(crows, cols, values, dense_shape) csr.crows() # Tensor(shape=[4], dtype=int64, place=Place(gpu:0), stop_gradient=True, # [0, 2, 3, 5])
cols()¶
注解
只有 SparseCsrTensor 才可调用该方法。
返回：输入 SparseCsrTensor 的非 0 元素的列信息
返回类型：DenseTensor
代码示例
import paddle crows = [0, 2, 3, 5] cols = [1, 3, 2, 0, 1] values = [1, 2, 3, 4, 5] dense_shape = [3, 4] csr = paddle.sparse.sparse_csr_tensor(crows, cols, values, dense_shape) csr.cols() # Tensor(shape=[5], dtype=int64, place=Place(gpu:0), stop_gradient=True, # [1, 3, 2, 0, 1])
is_sparse()¶
当输入 SparseCooTensor/SparseCsrTensor 时，返回 True；当输入 DenseTensor 时，返回 False。
返回：是否为稀疏 Tensor（包括 SparseCooTensor 和 SparseCsrTensor）
返回类型：bool
代码示例
import paddle indices = [[0, 1, 2], [1, 2, 0]] values = [1.0, 2.0, 3.0] dense_shape = [3, 3] coo = paddle.sparse.sparse_coo_tensor(indices, values, dense_shape) coo.is_sparse() # True
is_sparse_coo()¶
当输入 SparseCooTensor 时，返回 True；当输入 DenseTensor/SparseCsrTensor 时，返回 False。
返回：是否为 SparseCooTensor
返回类型：bool
代码示例
import paddle indices = [[0, 1, 2], [1, 2, 0]] values = [1.0, 2.0, 3.0] dense_shape = [3, 3] coo = paddle.sparse.sparse_coo_tensor(indices, values, dense_shape) coo.is_sparse_coo() # True
is_sparse_csr()¶
当输入 SparseCsrTensor 时，返回 True；当输入 DenseTensor/SparseCooTensor 时，返回 False。
返回：是否为 SparseCsrTensor
返回类型：bool
代码示例
import paddle crows = [0, 2, 3, 5] cols = [1, 3, 2, 0, 1] values = [1, 2, 3, 4, 5] dense_shape = [3, 4] csr = paddle.sparse.sparse_csr_tensor(crows, cols, values, dense_shape) csr.is_sparse_csr() # True
to_sparse_csr()¶
注解
只有 DenseTensor 、SparseCooTensor 才可调用该方法。
将输入 Tensor 转换为 SparseCsrTensor。
当输入 SparseCooTensor 时，会将其稀疏格式由 Coo 转换为 Csr；当输入 DenseTensor 时，会将其以 Csr 稀疏格式来存储。
返回：转换为稀疏格式后的 SparseCsrTensor
返回类型：SparseCsrTensor
代码示例
import paddle indices = [[0, 1, 2], [1, 2, 0]] values = [1.0, 2.0, 3.0] dense_shape = [3, 3] coo = paddle.sparse.sparse_coo_tensor(indices, values, dense_shape) coo.to_sparse_csr() # Tensor(shape=[3, 3], dtype=paddle.float32, place=Place(gpu:0), stop_gradient=True, # crows=[0, 1, 2, 3], # cols=[1, 2, 0], # values=[1., 2., 3.])
is_same_shape(y)¶
返回两个 Tensor 形状比较的结果，判断当前 Tensor 与输入 y 的形状是否相同，支持 DenseTensor、SparseCsrTensor 与 SparseCooTensor 之间任意两种的形状比较。
返回：两个 Tensor 形状比较的结果，相同为 True，不同为 False。
返回类型：bool
请参考 is_same_shape
pca_lowrank(x, q=None, center=True, niter=2, name=None)¶
计算在低秩矩阵，批次的矩阵，或稀疏矩阵上的线性主成分分析(PCA)。
返回：对输入矩阵的主成分分析结果。
返回类型：tuple，包含结果（U，S，V）。
请参考 pca_lowrank
cummax(x, axis=None, dtype='int64', name=None)¶
沿给定 axis 计算 Tensor x 的累积最大值。
返回：计算后的 Tensor 和对应索引 Indices。
返回类型：Tensor，包含计算结果和索引。
请参考 cummax
cummin(x, axis=None, dtype='int64', name=None)¶
沿给定 axis 计算 Tensor x 的累积最小值。
返回：计算后的 Tensor 和对应索引 Indices。
返回类型：Tensor，包含计算结果和索引。
请参考 cummin
as_strided(x, shape, stride, offset=0, name=None)¶
使用特定的 shape、stride、offset，返回 x 的一个 view Tensor。
仅在动态图下可用，返回的 Tensor 和 x 共享内存。
返回：x 的一个 view Tensor。
返回类型：Tensor
请参考 as_strided
view(x, shape_or_dtype, name=None)¶
使用特定的 shape 或者 dtype，返回 x 的一个 view Tensor。
仅在动态图下可用，返回的 Tensor 和 x 共享内存。
返回：x 的一个 view Tensor。
返回类型：Tensor
请参考 view
view_as(x, other, name=None)¶
使用 other 的 shape，返回 x 的一个 view Tensor。
仅在动态图下可用，返回的 Tensor 和 x 共享内存。
返回：x 的一个 view Tensor。
返回类型：Tensor
请参考 view_as
unfold(x, axis, size, step, name=None)¶
返回 x 的一个 view Tensor。以滑动窗口式提取 x 的值。
仅在动态图下可用，返回的 Tensor 和 x 共享内存。
返回：x 的一个 view Tensor。
返回类型：Tensor
请参考 unfold
masked_fill(x, mask, value, name=None)¶
根据 mask 信息，将 value 中的值填充到 x 中 mask 对应为 True 的位置。
返回一个根据 mask 将对应位置填充为 value 的 Tensor。
请参考 masked_fill
masked_fill_(x, mask, value, name=None)¶
Inplace 版本的 masked_fill API，对输入 x 采用 Inplace 策略。
masked_scatter(x, mask, value, name=None)¶
根据 mask 信息，将 value 中的值逐个填充到 x 中 mask 对应为 True 的位置。
返回一个根据 mask 将对应位置填充为 value 中元素的 Tensor。
请参考 masked_scatter
masked_scatter_(x, mask, value, name=None)¶
Inplace 版本的 masked_scatter API，对输入 x 采用 Inplace 策略。
atleast_3d(name=None)¶
将输入转换为张量并返回至少为 3 维的视图。 3 维或更高维的输入会被保留。
返回至少为 3 维视图的 Tensor 。
请参考 atleast_3d diagonal_scatter(x, y, offset=0, axis1=0, axis2=1, name=None) ::::::::: 根据给定的轴 axis 和偏移量 offset，将张量 y 的值填充到张量 x 中。
返回：张量 y 填充到张量 x 中的结果。
返回类型：Tensor
请参考 diagonal_scatter
select_scatter(x, values, axis, index, name=None)¶
将 values 矩阵的值嵌入到 x 矩阵的第 axis 维的 index 列, values 的形状需要与 x 矩阵除去第 axis 维后的形状一致
返回：计算后的 Tensor
返回类型：Tensor
请参考 select_scatter
signbit(x, name=None)¶
返回 x 的判断值掩码 Tensor，若存在符号位，则输出 True，否则输出 False。
返回：判断值掩码 Tensor。
返回类型：Tensor
请参考 signbit