paddle01-Tensor相关操作 【完】
✈ paddle2.0 API目录
| 目录 | 功能和包含API |
|---|---|
| paddle.* | paddle根目录保留常用API,当前: paddle.tensor/framework/device目录API |
| paddle.tensor | tensor操作相关API |
| paddle.framework | 框架通用API和动态图模式的API， 如 no_grad, save, load等 |
| paddle.device | 设备管理相关API，比如: set_device，get_device等 |
| paddle.amp | paddle自动混合精度策略, auto_cast, GradScaler等。 |
| paddle.callbacks | paddle日志回调类, 包括 ModelCheckpoint、ProgBarLogger等; |
| paddle.nn | 组网相关的API，例如Linear、LSTM、CrossEntropyLoss、ReLU等。 |
| paddle.static | 静态图下基础框架相关API，如Variable, Program, Executor等; |
| paddle.static.nn | 静态图下组网专用API, 例如:全连接fc，控制流: while_loop/cond |
| paddle.optimizer | 优化算法相关API，例如: SGD、Adagrad、Adam. |
| paddle.optimier.lr | 学习率衰减相关API，例如 NoamDecay、StepDeacy、PiecewiseDecay |
| paddle.metric | 评估指标相关的API， 例如: Accuracy, Auc等。 |
| paddle.io | 数据输入输出相关API, 比如: Dataset, DataLoader |
| paddle.distributed | 分布式相关基础API |
| paddle.distributed.fleet | 分布式相关高层API |
| paddle.vision | 视觉领域API，例如数据集: cifar10，基础网络结构 ResNet等。 |
| paddle.text | NLP领域API，例如 imdb等 |
Tensor
0.易错乘法
点积: 向量的内积、数量积, 向量a·向量b=|a||b|cos<a,b>
叉积: 向量的外乘、向量积, |向量c|=|向量a×向量b|=|a||b|sin<a,b>
本质两种乘法: 1.逐个对应元素相乘. 2.向量*向量，点乘(矩阵乘法:多个向量乘法)
共8个函数: 其中
1).paddle.multiply(x,y) 为对应元素乘法,输入x,y 支持广播到形状一致;
2).paddle.prod(x) 为指定axis 累积，类似sum()
3).paddle.cross(x,y)计算叉积，一般用不到
4).paddle.dot() 两种使用:1) 两个向量计算; 2)二维:batch 两个向量计算; [b, m] * [b,m] 形状必须一样，不能广播;
5).paddle.bmm(x,y) 只有一种使用: 输入必须都是三维, 且:[b, m,n] * [b, n,z] = [b, m, z]
6).paddle.mv(mat, vec) 矩阵*向量，其中 mat只可以是 二维矩阵， vec必须是向量，且满足乘法；
X Y Res
1D[m] 1D[m] [1] paddle.dot() paddle.mm() paddle.matmul()
2D[M,N] 1D[N] [M] paddle.mv() paddle.mm() paddle.matmul()
ND 1D N-1D paddle.mm() paddle.matmul()
1D ND N-1D paddle.mm() paddle.matmul()
3D 3D 3D paddle.bmm() paddle.mm() paddle.matmul()
ND ND 广播 paddle.matmul()
ND ND 不能广播 paddle.mm() paddle.matmul()
7)paddle.mm() 不能广播,torch中只能做 2D*2D，paddle无限制:
# batched matrix * broadcasted matrix [10,1,5,2]*[1,3,2,5] 不能广播，报错
* 例 1: paddle.matmul() 可以
input: [B, ..., M, K], mat2: [B, ..., K, N]
out: [B, ..., M, N]
* 例 2: paddle.matmul() 可以
input: [B, M, K], mat2: [B, K, N]
out: [B, M, N]
* 例 3: paddle.matmul() 等价
input: [B, M, K], mat2: [K, N]
out: [B, M, N]
* 例 4: paddle.matmul() 等价
input: [M, K], mat2: [K, N]
out: [M, N]
* 例 5: paddle.matmul() 也可以实现,但是出现值不相等????
input: [B, M, K], mat2: [K]
out: [B, M]
* 例 6: paddle.matmul() 也可以实现, 会出现值不想等？？？ 精度问题？
input: [K], mat2: [K]
out: [1]
* 例 7: 报错.......
input: [M], mat2: [N]
out: [M, N]
* 例8: paddle.matmul() 支持广播,paddle.mm 报错
input:[10,1,5,2]*[1,3,2,5]
out: 报错
8)paddle.matmul(x, y) 支持广播
# vector * vector 1D情况下: paddle.dot() 如果x是 一维tensor,则看做: [1, D], 如果y是一维tensor,看做: [D, 1]
# matrix * vector [10, 5] * [5] => [10, 5] * [5, 1] =>[10, 1] => [10]
# batched matrix * broadcasted vector [10, 5, 2]*[2] => [10,5,2]*[10,2,1]=[10,5,1]=>[10,5]
# batched matrix * broadcasted matrix [10,1,5,2]*[1,3,2,5] => [10,3,5,2]*[10,3,2,5] =>[10,3,5,5]
* 如果两个张量均为一维，则获得点积结果。
* 如果两个张量都是二维的，则获得矩阵与矩阵的乘积。
* 如果 x 是1维的，而 y 是2维的，则将1放在 x 维度之前，以进行矩阵乘法。矩阵相乘后，将删除前置尺寸。
* 如果 x 是2维的，而 y 是1维的，获得矩阵与向量的乘积。
* 如果两个输入至少为一维，且至少一个输入为N维（其中N> 2），则将获得批矩阵乘法。 如果第一个自变量是一维的，则将1放在其维度的前面，以便进行批量矩阵的乘法运算，然后将其删除。 如果第二个参数为一维，则将1附加到其维度后面，以实现成批矩阵倍数的目的，然后将其删除。 根据广播规则广播非矩阵维度（不包括最后两个维度）。 例如，如果输入 x 是（j，1，n，m）Tensor，另一个 y 是（k，m，p）Tensor，则out将是（j，k，n，p）张量。
- 按照需求分类:
1. vec * vec, 仅限一维， 带batch的只能 paddle.dot()
a = paddle.to_tensor([1, 2, 3], dtype="float32")
b = paddle.to_tensor([1, 1, 1], dtype="float32")
c = paddle.mm(a, b)
d = paddle.matmul(a, b)
e = paddle.dot(a, b)
f = paddle.mv(a,b) 不行
g = paddle.bmm(a,b) 不行
2. mat * vec
3. vec * mat
4. mat * mat
- 1.paddle.matmul(x, y, transpose_x= False, transpose_y=False) 计算两个tensor的乘积(广播)
可以根据输入实现:1）paddle.dot(两个一维向量内积)，2）两个二维(矩阵乘法) paddle.mm, 3）batch-matmul() paddle.bmm计算两个tensor的乘积,遵循广播机制，与 numpy.matmul() 一致，输入维数可以是任意数量。 * 如果transpose=True,则对应tensor的后两维会转置。如果tensor一维，转置无效。 * 如果x是 一维tensor,则看做: [1, D], 如果y是一维tensor,看做: [D, 1] * 如果两个张量均是一维,则获得点积结果; paddle.dot() 仅限1维; batch vec * vec 只能用paddle.dot() * 如果两个张量都是 二维的,则获得 矩阵与矩阵的 乘积。 paddle.mm() * 如果 x 是一维的, 而 y 是二维的, 则将 1 放在 x 维度之前, 以进行矩阵乘法， 矩阵相乘后,将删除前置尺寸。 paddle.mm() * 如果 x 是二维的, 而 y 是一维的， --> 矩阵与向量乘积 paddle.mm() paddle.mv() * 如果两个输入至少为 1维, 且至少 一个输入为 N维(其中N>2),则获得 批矩阵乘法。 x:1维,则转为[1, D], 批计算然后删除； y:1维,[D, 1],批计算然后删除。 服从广播机制........不包括最后两个维度,符合矩阵乘法即可。 * x:tensor float32/64 * y:tensor float32/64 transpose_x: bool, 可选， 默认False, 相乘前是否转置。 transpose_y: bool, 可选, 默认False, 相乘前是否转置。 # vector * vector x_data = np.random.random([10]).astype(np.float32) y_data = np.random.random([10]).astype(np.float32) x = paddle.to_tensor(x_data) y = paddle.to_tensor(y_data) z = paddle.matmul(x, y) print(z.numpy().shape) # [1] # matrix * vector x_data = np.random.random([10, 5]).astype(np.float32) y_data = np.random.random([5]).astype(np.float32) x = paddle.to_tensor(x_data) y = paddle.to_tensor(y_data) z = paddle.matmul(x, y) print(z.numpy().shape) # [10] # batched matrix * broadcasted vector x_data = np.random.random([10, 5, 2]).astype(np.float32) y_data = np.random.random([2]).astype(np.float32) x = paddle.to_tensor(x_data) y = paddle.to_tensor(y_data) z = paddle.matmul(x, y) print(z.numpy().shape) # [10, 5] # batched matrix * broadcasted matrix x_data = np.random.random([10, 1, 5, 2]).astype(np.float32) y_data = np.random.random([1, 3, 2, 5]).astype(np.float32) x = paddle.to_tensor(x_data) y = paddle.to_tensor(y_data) z = paddle.matmul(x, y) print(z.numpy().shape) # [10, 3, 5, 5] - 2.paddle.bmm(x, y) batch矩阵相乘, 两个输入的维度都必须为 3
两个输入的维度必须等于 3， 且矩阵 x 和 矩阵 y 的第一维必须相等 同时矩阵x的第三维度 必须等于 矩阵y的第三维。 若x和y分别为（b, m, k）和 （b, k, n)的矩阵，则函数的输出为一个（b, m, n）的矩阵 - 3.paddle.mm(x, y) 返回两个矩阵(任意维度)的乘积
两个输入的形状可以为任意维度，但是当任一输入维度大于 3 时，两个输入的维度必须相等 注意: 如果x或y的rank为1(向量)且未转置,则相乘后的前置或附加维度1将移除。 * x: tensor * y: tensor * 例 1: input: [B, ..., M, K], mat2: [B, ..., K, N] 都必须大于3 out: [B, ..., M, N] * 例 2: input: [B, M, K], mat2: [B, K, N] out: [B, M, N] * 例 3: input: [B, M, K], mat2: [K, N] out: [B, M, N] * 例 4: input: [M, K], mat2: [K, N] out: [M, N] * 例 5: input: [B, M, K], mat2: [K] out: [B, M] * 例 6: input: [K], mat2: [K] out: [1] * 例 7: input: [M], mat2: [N] out: [M, N] ，错误， 报错 nput = paddle.arange(1, 7).reshape((3, 2)).astype('float32') mat2 = paddle.arange(1, 9).reshape((2, 4)).astype('float32') out = paddle.mm(input, mat2) # Tensor(shape=[3, 4] - 4.paddle.dot(x, y) 计算向量内积, x,y 可以1-D / 2-D， 必须形状一样
注意: 如果都是二维tensor,矩阵的第一个维度是 batch_size * x: 1-D / 2-D tensor float32/64 * y: 1-D / 2-D tensor float32/64 data = paddle.to_tensor([[1, 2, 3, 4], [5, ,6, 7,8]]) data1 - paddle.to_tensor([[1,1,1,1], [1,1,1,1]]) res = paddle.dot(data, data1) [[10], [26]] - 5.paddle.mv(x, vec) 计算 矩阵x 和 向量 vec 的乘积。 vec:只能是vec， x只能2维矩阵
* x:tensor, 二维矩阵 * vec: vector, 只能是向量 data = paddle.to_tensor([[1,2,3],[1,2,3]], dtype="float64") data1 = paddle.to_tensor([1,1,1], dtype="float64") res1 = paddle.mv(data, data1) [[6],[6]] - 6.不懂 paddle.cross(x, y, axis) 计算张量 x 和 y 在axis维度上的向量积(叉积)
x 和 y 必须有相同的形状，且指定的 axis 的长度必须为3. 如果未指定 axis ，默认选取第一个长度为3的 axis * x: tensor * y: tensor * axis: int, 可选 x = paddle.to_tensor([[1.0, 1.0, 1.0], [2.0, 2.0, 2.0], [3.0, 3.0, 3.0]]) y = paddle.to_tensor([[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]]) z1 = paddle.cross(x, y) # [[-1. -1. -1.] # [ 2. 2. 2.] # [-1. -1. -1.]] z2 = paddle.cross(x, y, axis=1) # [[0. 0. 0.] # [0. 0. 0.] # [0. 0. 0.]] - 7.paddle.prod(x, axis= None, keepdim=False, dtype= None) 对指定维度上的 tensor元素进行求乘积运算，类似 paddle.sum()
对指定维度上的 tensor元素进行求 乘积运算，并输出相应的计算结果。 * x: tensor * axis: int/list/tuple, 可选, 求乘积运算的维度。 如果是None,则计算所有元素的乘积并返回包含单个元素的 tensor. * keepdim: bool, 可选 data = paddle.to_tensor([[0.2, 0.3, 0.5, 0.9], [0.1, 0.2, 0.6, 0.7]]) res1 = paddle.prod(data) # [0.0002268] res2 = paddle.prod(data, -1) [0.027, 0.0084] - 8.paddle.multiply(x, y) 逐元素 相乘(广播) x*y ,返回结果是两个广播结果形状
输入x与输入y逐元素相乘,并将各个位置的输出元素保存到 返回结果中。 * x: 多维tensor * y: 维度必须 小于等于 X维度的 tensor. x = paddle.to_tensor([[[1,2,3],[1,2,3]]]) y = paddle.to_tensor([2]) res = paddle.multiply(x, y) [[2,4,6],[2,4,6]]
⭐ 一、 创建相关
Tensor 是 paddle中最为基础的数据结构，有三种创建方法:
-
🌙 1.to_tensor()：用预先存在的 data 数据创建 1个Tensor。
- paddle.to_tensor(data, dtype=None, place= None, stop_gradient=True)
- list 转 tensor
- numpy 转 tensor
data: scalar, list, tuple, numpy.ndarry, paddle.tensor 如果data已经是tensor,且dtype, place没有发生变化，则返回原来的tensor. * place (CPUPlace|CUDAPinnedPlace|CUDAPlace, optional) - 创建tensor的设备位置，可以是 CPUPlace, CUDAPinnedPlace, CUDAPlace。默认值为None，使用全局的place * stop_gradient (bool, optional) - 是否阻断Autograd的梯度传导。默认值为True，此时不进行梯度传传导 paddle.to_tensor(1) # data: [1] paddle.to_tensor([[1.0, 2.0], [3.0, 4.0]]) # data:[[1.0, 2.0], [3.0, 4.0]] paddle.to_tensor((1.1, 2.2)) # data: [1.1, 2.2] paddle.to_tensor([1+1j]) # data: [1+1j] - paddle.assign(x, output= None) 将输入Tensor或numpy数组拷贝至输出tensor
input: tensor、numpy数组 data = paddle.full(shape=[3,2], fill_value= 2.5) data1 = np.array([1,1]) res1 = paddle.assign(data)
-
🌙 2.创建指定shape的 tensor 10个函数
- 2.1.paddle.arange(start=0, end=None, step=1, dtype=None, name=None)
返回以步长step均匀分割给定数值区间[start, end) 的1-D tensor,数据类型为dtype start: float/int/tensor end:float/int/tensor step:float/int/tensor 默认:1 res1 = paddle.arange(5) # [0, 1, 2, 3, 4] res2 = paddle.arange(3, 9, 2.0) # [3, 5, 7] - 2.2.paddle.diag(x, offset=0, paddling_value=0, name=None)
如果X是向量(1-D),则返回 带有X元素作为对角线的2-D方阵 如果X是矩阵(2-D),则提取 X的对角线元素,以1-D张量返回. 参数offset控制对角线偏移量: * 如果offset = 0, 则为主对角线 * 如果offset < 0, 则为下对角线 * 如果offset > 0, 则为上对角线 * x:输入tensor, 1-D/2-D * offset:(int, 可选) * paddle_value:(int/float, 可选) x = paddle.to_tensor([1, 2, 3]) # [1, 2, 3] y = paddle.diag(x) # [[1, 0, 0], [0, 2, 0], [0, 0, 3]] z = paddle.diag(y) @ [1, 2,3] - 2.3.paddle.empty(shape, dtype=None, name= None)
创建形状大小为shape的 tensor, 其中元素值是未初始化的。 * shape:list/tuple/tensor * dtype: np.dtype/str data = paddle.empty([2, 3]) - 2.4.paddle.eye(num_rows, num_columns= None)
构建二维tensor(主对角线是1，其他元素是0) num_rows: 生成2D tensor的行数 num_columns:生成2D tensor的列数,默认等于 num_rows data = paddle.eye(3) - 2.5.paddle.full(shape, fill_value)
创建形状大小为 shape的tensor, 元素值为: fill_value * shape: list/tuple/tensor * fill_value: bool/float/int/tensor data = paddle.full(shape= [2, 3], fill_value=1) - 🐌 2.6.paddle.linspace(start, stop, num, dtype=None)
返回一个tensor,tensor值为: 区间[start,stop]上均匀间隔的num个值 ，输出tensor的长度是num. * start: int/float/tensor * stop: int/float/tensor * num: int/tensor data= paddle.linspace(0, 10, 5) # [0, 2.5, 5, 7.5, 10] data= paddle.linspace(0, 10, 1) # [0.0] - 🐌 2.7.paddle.meshgrid()
- 2.8.paddle.numel(x)
返回一个长度为1且元素值为 X元素个数 的tensor * x:输入 tensor x = paddle.fill(shape=[4,5,7], fill_value=0) numel = paddle.numel(x) # 140 相当于: x.size # 140 - 2.9.paddle.ones(shape, dtype=None)
创建形状为 shape， 且值全为1的Tensor- shape: tuple/list/tensor
data = paddle.ones(shape=[2,3])
[[1,2,3],[4,5,6]]
- shape: tuple/list/tensor
- 2.10.paddle.zeros(shape, dtype=None)
创建形状为 shape 且值全为 0 的tensor data = paddle.zeros(shape=[2,3])
- 2.1.paddle.arange(start=0, end=None, step=1, dtype=None, name=None)
-
🌙 3.创建一个与其他Tensor具有相同 shape 和 dtype 的 tensor. 4个函数
- 3.1.paddle.empty_like(x, dtype=None)
根据x的shape创建未初始化的 tensor. data = paddle/to_tensor([2,3]) res1 = paddle.empty_like(data) [[无穷小, 无穷小...],[]] - 3.2.paddle.full_like(x, fill_value, dtype= None)
创建一个和X具有相同形状的，其中元素值均为 fill_value * x: 输入tensor * fill_value: (bool/float/int) 用于初始化输出 张量的 常量数据的值 data = paddle.to_tensor([1,2,3]) res1 = paddle.full_like(data, fill_value= 1) # [1,1,1] - 3.3.paddle.ones_like(x, dtype=None)
返回一个和 x 具有相同形状的数值都为1的tensor. * x:输入tensor data = paddle.to_tensor([1,2,3]) res1 = paddle.ones_like(x) # [1,2,3] - 3.4.paddle.zeros_like(x, dtype=None)
返回一个和 X 具有相同形状的 全零Tensor,数据类型为dtype,或者和X相同 * x: tensor data1 = paddle.to_tensor([1,2,3]) res1 = paddle.zeros_like(x) # [0, 0, 0]
- 3.1.paddle.empty_like(x, dtype=None)
-
🌙 4.参数创建:
- 4.1 class paddle.ParamAttr(name=None, initializer=None, learning_rate=1.0, regularizer=None, trainable=True, do_model_average=False, need_clip=True)
返回: 表示参数属性的对象。 类, 创建一个参数属性对象，用户可以设置参数的名称、初始化方式、学习率、正则化规则、是否需要训练、梯度裁剪方式、是否做模型平均等属性。 一般用在paddle.nn* 下面的模型初始化过程中,进行 类的实例化 * name: str,可选， 参数的名称。 默认值: None， 表示框架自动创建参数的名称。 * initializer: Initializer, 可选，参数的初始化方式， 默认:None,表示权重参数采用Xavier初始化方式,偏置参数全0 * learning_rate: float, 可选, 参数的学习率。 实际参数的学习率等于全局学习率乘以参数的学习率，再乘以learning rate schedule的系数。 * regularizer: 可选，正则化方法,支持两种正则化策略: api_paddle_regularizer_L1Decay 、 api_paddle_regularizer_L2Decay, 如果在 optimizer (例如 api_paddle_optimizer_SGD ) 中也 设置了正则化，optimizer 中的正则化将被忽略。默认值为None，表示没有正则化。 * trainanle: bool, 可选, 参数是否需要训练。 默认值为True. * do_model_average: bool, 可选, 是否做模型平均， 默认值: True. 仅在 ExponentialMovingAverage 下使用。 * need_clip: bool, 可选, 参数是否进行梯度裁剪。 默认值True, 表示该参数的梯度会根据优化器中中设置的裁剪规则进行裁剪。 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)
- 4.1 class paddle.ParamAttr(name=None, initializer=None, learning_rate=1.0, regularizer=None, trainable=True, do_model_average=False, need_clip=True)
⭐ 二、random 相关(也可以看做生成) 10个函数
-
1.paddle.bernoulli(x)
输入x为概率，生成一个 伯努利分布(0-1分布)的tensor, 输出tensor的形状和数据类型与输入x相同 x: 输入概率值，数据类型: float32/float64 x = paddle.rand([2, 3]) data = paddle.nernoulli(x) -
2.paddle.multinomial(x)
输入x为概率，输出为: 生成一个多项分布的 tensor -
3.paddle.rand(shape, dtype= None, name= None)
返回符合均匀分布，范围在[0,1]的tensor,形状为shape,数据类型为dtype * shape: list/tuple/tensor data = paddle.rand(shape=[2,3]) [[0.34, 0.33],[]] dim1 = paddle.to_tensor([2]) dim2 = paddle.to_tensor([3]) data = paddle.rand(shape=[dim1, dim2, 2]) -
4.paddle.randint(low=0, high=None, shape=[1], dtype=None)
返回均匀分布的，范围在[low, high)的随机采样生成tensor,形状为 shape. 当high为None时(默认),钧宇采用区间为 [0, low) * low: (int) 随机范围下限 * high: (int,可选), 随机范围上限 * shape:(list/tuple/tensor) * dtype: 默认None, 输出tensor: int64 data = paddle.randint(low= -5, high= 5, shape= [3]) [0, -3, 2] random -
5.paddle.uniform(shape, dtype="float32", min= -1.0, max= 1.0, seed= 0)
返回数值服从范围 [min, max) 内均匀分布的 随机tensor，形状为 shape, 数据类型dtype * shape: list/tuple/tensor * dtype: 可选 * min: float/int， 可选 * max: float/int, 可选 * seed: int, 可选 data1 = paddle.uniform(shape= [2, 3]) -
6.paddle.randn(shape, dtype=None) 返回符合标准正态分布(均值为0,标准差为1的标准正太分布)的 随机tensor,形状为shape
返回符合标准正态分布(均值为0， 标准差为1 的标准正太分布)的 随机tensor,形状为shape * shape: list/tuple/tensor data = paddle.randn(shape= [2,3]) [[],[]] random -
7.paddle.standard_normal(shape, dtype=None) 返回符合标准正太分布的(均值0,标准差1)的随机tensor
paddle.normal() 的特殊版本, 和 paddle.rand() 没区别? * shape (list|tuple|Tensor) - 生成的随机Tensor的形状 out1 = paddle.standard_normal(shape=[2, 3]) # [[-2.923464 , 0.11934398, -0.51249987], # random # [ 0.39632758, 0.08177969, 0.2692008 ]] # random -
8.paddle.normal(mean= 0.0, std= 1.0, shape= None)
返回符合正态分布(均值为 mean, 标准差为 std的正太随机分布)的 随机tensor * mean: float/tensor, 可选 * std: float/tensor, 可选 * shape: list/tuple/tensor, 可选,如果 mean 或者 std 是Tensor，输出Tensor的形状和 mean 或者 std 相同(此时 shape 无效) data1 = paddle.normal(shape= [2,3]) # [[ 0.17501129 0.32364586 1.561118 ] # random # [-1.7232178 1.1545963 -0.76156676]] # random x = paddle.to_tensor([1.0, 2.0, 3.0]) data2 = paddle.normal(mean= x) # [ 0.18644847 -1.19434458 3.93694787] # random std_tensor = paddle.to_tensor([1.0, 2.0, 3.0]) data3 = paddle.normal(mean=x, std= std_tensor) # [1.00780561 3.78457445 5.81058198] # random -
9.paddle.randperm(n,dtype="int64")
返回一个数值在 0~n-1、随机排列的 1-D tensor n: int, 随机数列的上限 data1 = paddle.randperm(5) [4, 1, 3, 2, 0] -
10.paddle.seed(seed)
设置全局默认 generator 的随机种子 * seed: 要设置的随机种子 * 返回: 全局默认 generator 对象 paddle.seed(102)
⭐⭐ 三、数学操作(paddleAPI, paddle类成员函数) 42个
-
1.paddle.abs(x) 逐元素 取 对值函
* x: tensor， 类型: float32/float64 x = paddle.to_tensor([-1, -2, -3, -4], dtype='float32') res = paddle.abs(x) print(res) # [1, 2, 3, 4] -
2.paddle.ceil(x) 逐元素 向上取整
* x: tensor, 类型: float16/32/64 x = paddle.to_tensor([[-1.5,6], [1,15.6]]) res = paddle.ceil(x) print(res) # [[-1. 6.] # [ 1. 16.]] -
3.paddle.floor() 逐元素 向下取整
* x: tensor, float32/64 -
4.paddle.clip(x, min=None, max= None) 将输入的所有元素进行裁剪,使得输出元素限制在 [min, max]内。
将输入的所有元素进行裁剪,使得输出元素限制在 [min, max]内 * x: tensor * min: float32/tensor, 可选，若为空，则不限制 * max: float/32tensor, 可选 x = np.array([[1.2,3.5], [4.5,6.4]]).astype('float32') x1 = paddle.to_tensor(x) out1 = paddle.clip(x1, min=3.5, max=5.0) out2 = paddle.clip(x1, min=2.5) print(out1) # [[3.5, 3.5] # [4.5, 5.0]] print(out2) # [[2.5, 3.5] # [[4.5, 6.4] -
5.paddle.round(x) 逐元素四舍五入
将输入中的数值四舍五入到最接近的整数数值 * x: tensor x = paddle.to_tensor([1.2, -0.9, 3.4, 0.9], dtype='float32') result = paddle.round(x) print(result) # result=[1., -1., 3., 1.] -
6.paddle.exp(x) 逐元素计算 x 的自然常数为底的指数
x = paddle.to_tensor([[-1.5,6],[1,15.6]]) y = paddle.exp(x) print(y) # [[2.23130160e-01 4.03428793e+02] # [2.71828183e+00 5.95653801e+06]] -
7.paddle.log(x) 逐元素计算 x 的自然对数
x = [[2,3,4], [7,8,9]] x = paddle.to_tensor(x, dtype='float32') res = paddle.log(x) # [[0.693147, 1.09861, 1.38629], [1.94591, 2.07944, 2.19722]] -
8.paddle.log10(x) 逐元素计算 底为10的对数
x_i = paddle.to_tensor([[1.0], [10.0]]) res = paddle.log10(x_i) # [[0.], [1.0]] -
9.paddle.log2(x)
x_i = paddle.to_tensor([[1.0], [2.0]]) res = paddle.log2(x_i) print(res) # [[0.], [1.0] -
10.paddle.logsumexp(x, axis=None, keepdim= False) 沿着 axis 计算 x 的以e为底的指数的和的自然对数
logsumexp(x) = log(exp(x1)+exp(x2)+.....) * x: tensor * axis: 默认None，对于全部计算。 list/tuple/int 可选 x = paddle.to_tensor([[-1.5, 0., 2.], [3., 1.2, -2.4]]) out1 = paddle.logsumexp(x) # [3.4691226] out2 = paddle.logsumexp(x, 1) # [2.15317821, 3.15684602] -
11.paddle.reciprocal(x) 逐元素 计算倒数
x = paddle.to_tensor([1, 2, 3, 4], dtype='float32') result = paddle.reciprocal(x) -
12.paddle.square(x) 逐元素 计算平方
x = paddle.rand(shape=[32, 784]) y = paddle.square(x) -
13.paddle.sqrt(x) 逐元素 计算平方根
x = paddle.to_tensor([0., 9., 36.]) y = paddle.sqrt(x) print(y) # y=[0., 3., 6.] -
14.paddle.sign(x) 对输入中每个元素进行正负判断,输出正负判断值：1代表正，-1代表负，0代表零
data = np.array([3.0, 0.0, -2.0, 1.7], dtype='float32') x = paddle.to_tensor(data) out = paddle.sign(x=x) print(out) # [1.0, 0.0, -1.0, 1.0] -
15.paddle.scale(x, scale=1.0, bias=0.0, bias_after_scale=True, act=None) 缩放算子
对输入tesor进行缩放和偏置 * x (Tensor) - 要进行缩放的多维Tensor * scale (float|Tensor) - 缩放的比例，是一个float类型或者一个shape为[1] * bias (float) - 缩放的偏置 * bias_after_scale (bool) - 判断在缩放之前或之后添加偏置。为True时，先缩放再偏置 * act (str，可选) - 应用于输出的激活函数，如tanh、softmax、sigmoid、relu等 data = paddle.randn(shape=[2,3], dtype='float32') res = paddle.scale(data, scale=2.0, bias=1.0) -
16.paddle.sin(x) 逐元素计算 sin() 函数
x = paddle.to_tensor([0, 45, 90], dtype='float32') y = paddle.sin(x) print(y) # y=[0., 0.85090351, 0.89399666] -
17.paddle.cos(x) 逐元素计算 cos() 函数
-
18.paddle.sinh(x) 双曲正弦函数
* out = exp(x)-exp(-x)/2 x = paddle.to_tensor([-2.0, -1.0, 1.0, 2.0]) out = paddle.sinh(x) -
19.paddle.cosh() 双曲余弦函数
out = (exp(x)+exp(-x))/2 -
20..paddle.asin(x) 逐元素 计算 arcsine() 函数
x = paddle.to_tensor([-0.8183, 0.4912, -0.6444, 0.0371]) res = paddle.asin(x) print(res) # [-0.9585, 0.5135, -0.7003, 0.0372] -
21.paddle.acos(x) 逐元素计算 arccosine() 函数
-
21.paddle.atan(x) arctan函数
-
22.paddle.tanh(x) tanh 激活函数/三角函数 tangent
x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3]) y = paddle.tanh(x) print(y) # y=[-0.37994900, -0.19737528, 0.09966799, 0.29131261] -
23.不懂:paddle.rsqrt() rsqrt 激活函数
-
24.不懂:paddle.stanh() stanh 激活函数
-
25.paddle.add(x, y) 逐元素 相加(广播) x+y
输入x和y必须可以广播为相同的形状。 * x: 多维tensor * y: 多维tensor x = paddle.to_tensor([1,2,3]) y = paddle.to_tensor([2,3,4]) paddle.add(x, y) [3,5,7] -
26.paddle.add_n(inputs) 对输入的一至多个 tensor求和， 和paddle.add() 基本没区别，但不能广播
* inputs: tensor/list[tensor], 输入的1~N 个tensor,多个tensor的 shape和类型应该一致。 input0 = paddle.to_tensor([[1, 2, 3], [4, 5, 6]], dtype='float32') input1 = paddle.to_tensor([[7, 8, 9], [10, 11, 12]], dtype='float32') output = paddle.add_n([input0, input1]) # [[8., 10., 12.], # [14., 16., 18.]] -
27.paddle.addmm(input, x, y, alpha=1.0, beta=1.0) 计算x和y的乘积，将结果乘以标量alpha，再加上input与beta的乘积，得到输出
input与x、y乘积的维度必须是可广播的 out = alpha * x * y + beta * input -
28.paddle.sum(x, axis=None, dtype=None, keepdim=False) 对指定维度上的tensor元素进行求和运算
对指定维度上的tensor元素进行求和运算,并输出相应的计算结果。 指定维度: 在指定维度上求和...该维度取消了 * x: tensor * axis: int/list/tuple，可选，如果为None,则对整个tensor进行求和 * keepdim: bool, 输出tensor中是否保留减少的维度。 data = paddle.to_tensor([[0.2, 0.3, 0.5, 0.9], [0.1, 0.2, 0.6, 0.7]]) res1 = paddle.sum(x) [3.5] res2 = paddle.sum(x, axis=0) [0.3, 0.5, 1.1, 1.6] res3 = paddle/sum(x, axis=-1) [1.9, 1.6] res4 = paddle.sum(x, axis=-1, keepdim=True) [[1.9], [1.6]] -
paddle1.0用法(已经舍弃): paddle.fluid.layers.sums(input) 计算多个输入Tensor逐个元素相加的和
-
29.paddle.cumsum(x, axis=None, dtype=None) 沿给定axis计算张量X的累加和。
* x: tensor, 累加的输入 * axis: int, 可选, 指明需要累加的维度. 默认: None,将输入展开为 1维变量，再进行累加计算。 y = paddle.cumsum(data) # [ 0 1 3 6 10 15 21 28 36 45 55 66] y = paddle.cumsum(data, axis=0) # [[ 0 1 2 3] # [ 4 6 8 10] # [12 15 18 21]] y = paddle.cumsum(data, axis=-1) # [[ 0 1 3 6] # [ 4 9 15 22] # [ 8 17 27 38]] -
30..paddle.subtract(x, y) 逐元素相减(遵守广播机制) x-y
x = paddle.to_tensor([[[1, 2, 3], [1, 2, 3]]]) y = paddle.to_tensor([1, 0, 4]) res = paddle.subtract(x, y) print(res) # [[[ 0, 2, -1], # [ 0, 2, -1]]] -
31.paddle.multiply(x, y) 逐元素 相乘(广播) x*y
输入x与输入y逐元素相乘,并将各个位置的输出元素保存到 返回结果中。 * x: 多维tensor * y: 维度必须 小于等于 X维度的 tensor. x = paddle.to_tensor([[[1,2,3],[1,2,3]]]) y = paddle.to_tensor([2]) res = paddle.multiply(x, y) [[2,4,6],[2,4,6]] -
32.paddle.divide(x, y) 逐元素 相除(广播) x / y
输入x和y逐元素相除,并将各个位置的输出元素保存到返回结果中。 np_x = np.array([2, 3, 4]).astype('float64') np_y = np.array([1, 5, 2]).astype('float64') x = paddle.to_tensor(np_x) y = paddle.to_tensor(np_y) z = paddle.divide(x, y) print(z) # [2., 0.6, 2.] -
33.paddle.prod(x, axis= None, keepdim=False, dtype= None) 对指定维度上的 tensor元素进行求乘积运算，类似 paddle.sum()
对指定维度上的 tensor元素进行求 乘积运算，并输出相应的计算结果。 * x: tensor * axis: int/list/tuple, 可选, 求乘积运算的维度。 如果是None,则计算所有元素的乘积并返回包含单个元素的 tensor. * keepdim: bool, 可选 data = paddle.to_tensor([[0.2, 0.3, 0.5, 0.9], [0.1, 0.2, 0.6, 0.7]]) res1 = paddle.prod(data) # [0.0002268] res2 = paddle.prod(data, -1) [0.027, 0.0084] -
34.paddle.mod(x, y) 逐元素 相除并取余 x % y
-
35.paddle.pow(x, y) 逐元素 幂运算 x**y
* x: tensor * y: float/int/tensor x = paddle.to_tensor([1, 2, 3], dtype='float32') res = paddle.pow(x, 2) print(res) # Tensor(shape=[3], dtype=float32, place=CUDAPlace(0), stop_gradient=True, # [1., 4., 9.]) -
36.paddle.mean(x, axis=None, keepdim=False) 沿axis计算X的平均值
* x:tensor * axis: int/list/tuple, 可选 * keepdim: bool, 可选 x = paddle.to_tensor([[[1., 2., 3., 4.], [5., 6., 7., 8.], [9., 10., 11., 12.]], [[13., 14., 15., 16.], [17., 18., 19., 20.], [21., 22., 23., 24.]]]) # shape:[2, 3, 4] out4 = paddle.mean(x, axis=[0, 2]) # [ 8.5 12.5 16.5] -
37.paddle.median(x, axis=None, keepdim=False) 沿给定axis计算x中元素的中位数
* x: tensor * axis: int, 可选 x = paddle.arange(12).reshape([3, 4]) # x is [[0 , 1 , 2 , 3 ], # [4 , 5 , 6 , 7 ], # [8 , 9 , 10, 11]] y2 = paddle.median(x, axis=0) # y2 is [4., 5., 6., 7.] -
38.paddle.var(x, axis=None, unbiased=True, keepdim=False) 沿注定的axis轴计算x中元素的方差
* x: tensor * axis: int/list/tuple, 可选 * unbiased: bool, 可选, 是否使用无偏估计来计算 * keepdim: bool, 可选 x = paddle.to_tensor([[1.0, 2.0, 3.0], [1.0, 4.0, 5.0]]) out1 = paddle.var(x) # [2.66666667] out2 = paddle.var(x, axis=1) # [1. 4.33333333] -
39.paddle.std(x, axis= None, unbiased=True, keepdim=Flase) 沿指定的 axis 轴计算 x中元素的 标准差
* x:tensor * axis: int/list/tuple, 可选 * unbiased: bool, 可选 * keepdim: bool, 可选 x = paddle.to_tensor([[1.0, 2.0, 3.0], [1.0, 4.0, 5.0]]) out1 = paddle.std(x) # [1.63299316] out2 = paddle.std(x, axis=1) # [1. 2.081666] -
40.paddle.trace(x, offset=0, axis1= 0, axis2=1) 计算输入tensor在指定平面上的对角线元素之和
如果输入的维度等于2D，则返回对角线元素之和 如果输入的维度大于2D，则返回一个 由对角线元素之和组成的数组。 * offset: 确定从指定二维平面中获取对角线的位置 * offset =0..... * axis1: int, 可选 * axis2: int, 可选 case1 = paddle.randn([2, 3]) case2 = paddle.randn([3, 10, 10]) case3 = paddle.randn([3, 10, 5, 10]) data1 = paddle.trace(case1) # data1.shape = [1] data2 = paddle.trace(case2, offset=1, axis1=1, axis2=2) # data2.shape = [3] data3 = paddle.trace(case3, offset=-3, axis1=1, axis2=-1) # data2.shape = [3, 5] -
41.paddle.all(x, axis=None, keepdim= False) 对指定维度上的 tensor元素进行 逻辑 与 运算
* x: tensor, 数据类型为 bool * axis: int/list/tuple, 可选 * keepdim: bool x = paddle.assign(np.array([[1, 0], [1, 1]], dtype='int32')) x = paddle.cast(x, 'bool') out1 = paddle.all(x) # [False] -
42.paddle.any(x, axis=None, keepdim=False) 对指定维度上的 tensor元素进行 逻辑 或 运算
* x: tensor, bool类型 * axis: int/list/tuple, 可选 * keepdim: bool, 可选
⭐ 四、线性代数相关
-
1.paddle.cholesky(x, upper=False) 计算一个对称正定矩阵或一批对称正定矩阵的Cholesky分解
如果 upper 是 True ， 则分解形式为 A=UTU , 返回的矩阵U是上三角矩阵。 否则，分解形式为 A=LLT ，并返回矩阵 L 是下三角矩阵。 * x :(Tensor）- 输入变量为多维Tensor，它的维度应该为 [*, M, N] ,其中*为零或更大的批次尺寸， 并且最里面的两个维度上的矩阵都应为对称的正定矩阵，支持数据类型为float32，float64。 * upper （bool）- 指示是否返回上三角矩阵或下三角矩阵。默认值：False。 a = np.random.rand(3, 3) a_t = np.transpose(a, [1, 0]) x_data = np.matmul(a, a_t) + 1e-03 x = paddle.to_tensor(x_data) out = paddle.cholesky(x, upper=False) print(out) # [[1.190523 0. 0. ] # [0.9906703 0.27676893 0. ] # [1.25450498 0.05600871 0.06400121]] -
2.paddle.t(x) 对小于等于2维的Tensor进行数据转置
0维和1维Tensor返回本身，2维Tensor等价于perm设置为0，1的 transpose 函数 * x: tensor, N维(N<=2) tensor x = tensor([0.79, 0.84, 0.32], [0.64, 0.14, 0.57]) paddle.t(x) = tensor([0.79, 0.64], [0.84, 0.14], [0.32, 0.57]) -
3.不太懂paddle.norm(x, p="fro", axis=None, keepdim=False) 计算矩阵范数 、 向量范数
计算给定Tensor的矩阵范数（Frobenius 范数）和向量范数（向量1范数、2范数、或者通常的p范数） * x: tensor * p:float/string,可选 * axis: int/list/tuple， 可选 x = paddle.to_tensor(np_input) #[[[-12. -11. -10. -9.] [ -8. -7. -6. -5.] [ -4. -3. -2. -1.]] # [[ 0. 1. 2. 3.] [ 4. 5. 6. 7.] [ 8. 9. 10. 11.]]] # compute 2-order norm along [0,1] dimension. out_pnorm = paddle.norm(x, p=2, axis=[0,1]) # out_pnorm.numpy(): [17.435596 16.911535 16.7332 16.911535] -
4.不太懂,paddle.dist(x, y, p=2) 矩阵 (x-y) 的 p范数 x,y形状之间可广播
* x: 每个输入至少1维 * p: float, 可选，用于设置需要计算的范数 -
5.paddle.histogram(x, bins= 100, min=0, max=0) 计算输入张量的直方图
以min和max为range边界，将其均分成bins个直条，然后将排序好的数据划分到各个直条(bins)中。 如果min和max都为0, 则利用数据中的最大最小值作为边界。 * x: tensor * bins: int, 直方图 bins(直条)的个数,默认100 * min: int, 下届(包含) * max: int, 上界(包含) inputs = paddle.to_tensor([1, 2, 1]) result = paddle.histogram(inputs, bins=4, min=0, max=3) print(result) # [0, 2, 1, 0] -
6.paddle.rank(x) 计算输入 tensor的维度(秩) x.dim() x.ndimension()
* x: tensor, 任意类型 input = paddle.rand((3, 100, 100)) rank = paddle.rank(input) 3 -
7.paddle.tril(x, diagonal=0) 返回输入矩阵的下三角部分,其余部分被设为0
* x: 输入 * diagonal: int,可选： 指定的对角线, 默认值:0, 表示主对角线 tril2 = paddle.tensor.tril(x, diagonal=2) # array([[ 1, 2, 3, 0], # [ 5, 6, 7, 8], # [ 9, 10, 11, 12]]) -
8.paddle.triu(x, diagonal=0) 返回输入矩阵的 上三角 部分,其余部分设为0
triu2 = paddle.tensor.triu(x, diagonal=2) # array([[0, 0, 3, 4], # [0, 0, 0, 8], # [0, 0, 0, 0]]) -
9.paddle.inverse(x) 计算方阵(.MM)的逆
mat = paddle.to_tensor([[2, 0], [0, 2]], dtype='float32') inv = paddle.inverse(mat) print(inv) # [[0.5, 0], [0, 0.5]] -
10.paddle.conj(x) 逐元素计算Tensor的共轭运算
* x:(Tensor) - 输入的复数值的Tensor，数据类型为：complex64/128、float32/64、int32/64 data=paddle.to_tensor([[1+1j, 2+2j, 3+3j], [4+4j, 5+5j, 6+6j]]) #Tensor(shape=[2, 3], dtype=complex64, place=CUDAPlace(0), stop_gradient=True, # [[(1+1j), (2+2j), (3+3j)], # [(4+4j), (5+5j), (6+6j)]]) conj_data=paddle.conj(data) #Tensor(shape=[2, 3], dtype=complex64, place=CUDAPlace(0), stop_gradient=True, # [[(1-1j), (2-2j), (3-3j)], # [(4-4j), (5-5j), (6-6j)]])
⭐ 五、逻辑操作: 17函数
- 概述
* is逻辑
* paddle.isnan
* paddle.isinf()
* paddle.isfinite()
* paddle.is_empty()
* paddle.is_tensor()
* 相等判断
* paddle.equal_all()
* paddle.equal()
* paddle.not_equal()
* paddle.less_than()
* paddle.less_equal()
* paddle.grater_than()
* paddle.grater_equal()
* paddle.allclose()
* 与或非
* paddle.logical_and()
* paddle.logical_or()
* paddle.logical_xor()
* paddle.logical_not()
5.1 is 逻辑 (5_func)
- 1.paddle.isfinite() tensor的每一个值是否为Finite（既非 +/-INF 也非 +/-NaN ）
x_np = np.array([float('-inf'), -2, 3.6, float('inf'), 0, float('-nan'), float('nan')]) x = paddle.to_tensor(x_np) out = paddle.isfinite(x) print(out) # [False, True, True, False, True, False, False] - 2.paddle.is_empty(X) 测试变量是否为空
X: 测试变量 input = paddle.rand(shape=[4, 32, 32], dtype='float32') res = paddle.is_empty(x=input) print("res:", res) # ('res:', Tensor: eager_tmp_1 # - place: CPUPlace # - shape: [1] # - layout: NCHW # - dtype: bool # - data: [0]) ``` - 3.paddle.is_tensor(X) 测试对象是否是 paddle.Tensor
返回：布尔值，如果x是paddle.Tensor的话返回True，否则返回False。 input1 = paddle.rand(shape=[2, 3, 5], dtype='float32') check = paddle.is_tensor(input1) print(check) #True - 4.paddle.isinf(x) 判断 tensor 的每一个值是否是 +/- INF
返回: Tensor, 每个元素是一个bool值，表示输入 x 的每个元素是否为 +/-INF 。 x_np = np.array([float('-inf'), -2, 3.6, float('inf'), 0, float('-nan'), float('nan')]) x = paddle.to_tensor(x_np) out = paddle.isinf(x) print(out) # [True, False, False, True, False, False, False] - 5.paddle.isnan(x) 判断tensor 的每一个值为否是 +/- NaN
返回: Tensor, 每个元素是一个bool值，表示输入 x 的每个元素是否为 +/-NaN 。 x_np = np.array([float('-inf'), -2, 3.6, float('inf'), 0, float('-nan'), float('nan')]) x = paddle.to_tensor(x_np) out = paddle.isnan(x) print(out) # [False, False, False, False, False, True, True]
5.2 相等性判断
- 6.paddle.equal_all(x, y) 判断两个 tensor 的全部元素是否相等;
返回的结果只有一个元素值，如果所有相同位置的元素相同返回True，否则返回False x = paddle.to_tensor([1.0, 2.0, 3.0]) y = paddle.to_tensor([1.0, 2.0, 3.0]) z = paddle.to_tensor([1.0, 4.0, 3.0]) result1 = paddle.equal_all(x, y) print(result1) # result1 = [True ] result2 = paddle.equal_all(x, z) print(result2) # result2 = [False ] - 7.paddle.equal(x, y) 判断两个tensor逐元素是否相等 x==y
x = paddle.to_tensor([1.0, 2.0, 3.0]) y = paddle.to_tensor([1.0, 3.0, 2.0]) result1 = paddle.equal(x, y) print(result1) # result1 = [True False False] - 8.paddle.not_equal(x, y) x != y
x = paddle.to_tensor([1, 2, 3]) y = paddle.to_tensor([1, 3, 2]) result = paddle.not_equal(x, y) print(result) # result = [False, True, True] - 9.paddle.less_than(x, y) 每个元素是否 小于, x < y
- 10.paddle.less_equal() x <= y
- 11.paddle.greater_than() x > y
- 12.paddle.greater_equal() x >= y
- 13.paddle.allclose(x, y, rtol=1e-08, equal_nan=False)
* rtol (float，可选) - 相对容忍误差，默认值为1e-5 * atol (float，可选) - 绝对容忍误差，默认值为1e-8
5.3 与或非逻辑
- 14.paddle.logical_and(x, y) 两个bool型 tensor进行逻辑 与 操作(广播)
* x: tensor, bool * y: tensor, bool x = paddle.to_tensor([True]) y = paddle.to_tensor([True, False, True, False]) res = paddle.logical_and(x, y) print(res) # [True False True False] - 15.paddle.logical_or(x, y) 两个bool型 tensor进行逻辑 或 操作(广播)
* x,y: bool tensor x_data = np.array([True, False], dtype=np.bool).reshape(2, 1) y_data = np.array([True, False, True, False], dtype=np.bool).reshape(2, 2) x = paddle.to_tensor(x_data) y = paddle.to_tensor(y_data) res = paddle.logical_or(x, y) print(res) # [[True, True] [True, False]] - 16.paddle.logical_xor(x, y) 两个boool型 tensor进行逻辑 亦或 操作(广播)
x,y: bool, tensor 两个不一致为: True x_data = np.array([True, False], dtype=np.bool).reshape([2, 1]) y_data = np.array([True, False, True, False], dtype=np.bool).reshape([2, 2]) x = paddle.to_tensor(x_data) y = paddle.to_tensor(y_data) res = paddle.logical_xor(x, y) print(res) # [[False, True], [True, False]] - 17.paddle.logical_not(x) tensor 逐元素进行 非 操作
* x: bool tensor x = paddle.to_tensor([True, False, True, False]) result = paddle.logical_not(x) print(result) # [False, True, False, True]
⭐⭐ 六、class paddle.Tensor属性&方法()
- class paddle.Tensor: Tensor是paddle中最为基础的数据结构。
- 概述:
* shape相关:
* x.size
* x.dim()
* x.ndimension() paddle.rand()
* x.ndim
* x.shape
* type:
* x.dtype()
* x.astype()
* 梯度
* x.grad
* x.stop_gradient
* x.gradient()
* loss.clean_gradient()
* loss.backward()
* 设备
* x.place
* x.cpu()
* x.cuda()
* x.pin_memory()
* x.clone()
* x.detach()
* 其他
* x.name
* x.persistable
* x.reverse()
-
1.shape: 查看一个 tensor 的 shape,其描述了 tensor 在每个维度上的 元素数量。
x = paddle.to_tensor([[1, 2], [2, 3]]) x.shape // [2, 2] -
2.dtype: 查看一个tensor的数据类型
支持:"bool","float16","float32","float64","unit8","int8","int16","int32","int64" （9种）import paddle x = paddle.to_tensor([1.0, 2.0, 3.0]) print(x.dtype) -
3.stop_gradient: 查看一个 tensor 是否计算并传播梯度
如果 stop_gradient= True, 则该 tensor 不会计算梯度，并会阻绝 Autograd 的梯度传播。
反之: 计算梯度并传播。
用户自己创建的tensor, 默认为 True, 模型参数都是: Falsex = paddle.to_tensor([[1,2], [3, 4]]) x.stop_gradient -
4.x.grad:查看一个 tensor 的梯度
数据类型为: numpy.ndarrayimport 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(x.grad) -
x.gradient() 同:x.grad, 查看一个tensor的梯度,数据类型为 numpy.ndarray
返回：该Tensor的梯度 返回类型：numpy.ndarray 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() x.gradient() -
x.clean_gradient() 清除当前Tensor的梯度。 返回：无
x = np.ones([2, 2], np.float32) inputs2 = [] for _ in range(10): tmp = paddle.to_tensor(x) tmp.stop_gradient=False inputs2.append(tmp) ret2 = paddle.add_n(inputs2) loss2 = paddle.sum(ret2) loss2.backward() print(loss2.gradient()) loss2.clear_gradient() print("After clear {}".format(loss2.gradient())) -
x.backward(retain_graph=False) 从当前Tensor开始计算反向的神经网络，传导并计算计算图中Tensor的梯度
返回: 无 * retain_graph: bool, 可选,如果为False，反向计算图将被释放。如果在backward()之后继续添加OP， 需要设置为True，此时之前的反向计算图会保留。将其设置为False会更加节省内存。默认值：False。 x = np.ones([2, 2], np.float32) inputs = [] for _ in range(10): tmp = paddle.to_tensor(x) # if we don't set tmp's stop_gradient as False then, all path to loss will has no gradient since # there is no one need gradient on it. tmp.stop_gradient=False inputs.append(tmp) ret = paddle.add_n(inputs) loss = paddle.sum(ret) loss.backward() -
不懂...paddle.grad(outputs, inputs, grad_outputs=None, retain_graph=None, create_graph=False, only_inputs=True, allow_unused=False, no_grad_vars=None) 对于每个inputs,计算所有 outputs相对于其的梯度和。
-
5.name:查看一个tensor的name
Tensor的name是其唯一标识符，为python的字符串类型。import paddle x = paddle.to_tensor(1) print(x.name) -
6.ndim:查看一个 tensor 的维度,也叫做 rank paddle.rank(x)
x = paddle.to_tensor([[1, 2], [3, 4]]) x.ndim -
x.dim() 查看一个Tensor的维度，也称作rank。 paddle.rank(x)
print("Tensor's number of dimensition: ", paddle.to_tensor([[1, 2], [3, 4]]).dim()) # Tensor's number of dimensition: 2 -
x.ndimension() 查看一个Tensor的维度，也称作rank, paddle.rank(x)
print("Tensor's number of dimensition: ", paddle.to_tensor([[1, 2], [3, 4]]).ndimension()) # Tensor's number of dimensition: 2 -
7.persistable: 查看一个tensor是否是持久性变量
persistable = True, 表示为 持久变量，持久变量在每次迭代之后都不会删除，例如: 模型参数、学习率等Tensor。x = paddle.to_tensor(1) x.persisitable -
8.place: 查看一个 Tensor 的设备位置，tensor可能的设备位置有三种: CPU/GPU/固定内存。
cpu_tensor = paddle.to_tensor(1, place= paddle.CPUPlace()) cpu_tensor.place -
9.x.size tensor:x 有多少元素,
-
x.size() 好像报错？ paddle.1.X paddle.fluid.layers.size(input) 可不管
-
x.astype(dtype) 将Tensor的类型转换为 dtype ，并返回一个新的Tensor。 同:paddle.cast()
dtype (str) - 转换后的dtype，支持'bool'，'float16'，'float32'，'float64'，'int8'，'int16'， 'int32'，'int64'，'uint8' 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)) -
x.clone() 复制当前tensor, 并且保留在 原计算图中进行梯度传导。
返回: clone后的Tensor x = paddle.to_tensor([1.0, stop_gradient= False]) clone_x = x.clone() y = clone_x ** 2 y.backward() clone_x.stop_gradient False clone_x.grad 2.0 x._stop_gradient False x.grad 2.0 克隆变量和原始变量共享梯度传播 -
x.detach() 返回一个新的 tensor,从当前计算图分离
返回：与当前计算图分离的Tensor data = np.random.uniform(-1, 1, [30, 10, 32]).astype('float32') linear = paddle.nn.Linear(32, 64) data = paddle.to_tensor(data) x = linear(data) y = x.detach() -
cpu() 将当前的 tensor 拷贝到CPU上，且返回的 tensor 不保留在原计算图中。
返回：拷贝到CPU上的Tensor 如果当前Tensor已经在CPU上，则不会发生任何拷贝。 x = paddle.to_tensor(1.0, place=paddle.CUDAPlace(0)) print(x.place) # CUDAPlace(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, optional) - 如果为False并且当前Tensor处于固定内存上，将会发生主机到设备端的异步拷贝。否则，会发生同步拷贝。默认为False 代码暂时没 -
x.pin_memory() 将当前Tensor的拷贝到固定内存上，且返回的Tensor不保留在原计算图中
返回：拷贝到固定内存上的Tensor x = paddle.to_tensor(1.0, place=paddle.CUDAPlace(0)) print(x.place) # CUDAPlace(0) y = x.pin_memory() print(y.place) # CUDAPinnedPlace -
x.set_value(value) 设置当前Tensor的值
* value (Tensor|np.ndarray) - 需要被设置的值，类型为Tensor或者numpy.array 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 -
x.reverse(axis=None) 对输入tensor 在指定 axis轴上进行数据的逆序操作
pp1.x: paddle.fluid.layers.reverse(x, axis)
⭐⭐ 七、元素查找相关 15个
- 概述:
* 1.max/min: 6个
* paddle.max(） paddle.argmax() paddle.maximum(x,y)
* paddle.min() paddle.argmin() paddle.minimum(x, y)
* 2.sort: 2个
* paddle.sort() paddle.argsort()
* 3.排序:2个
* paddle.topk(x, k, axis= None, largest=True, sorted=True) # 沿着可选的axis查找 topk最大或 最小的结果， 和 结果所在的索引信息
* paddle.unique(x, retun_index=False, retunr_inverse= False, return_counts=False,axis=None,dtype="int64") 返回tensor按升序 排序后的独有元素(去重)
* 4.index采样相关:3个
* paddle.index_select(x, index, axis=0) 沿着指定axis轴 对 输入 x进行索引,并取 index 中指定的相应项,创建一个新的Tensor
* paddle.index_sample(x, index) 对输入 x 中的元素进行批量抽样,取index指定的对应下标的元素。 重新生成张量
* paddle.masked_select(x, mask) 返回 1-D Tensor, tensor的值根据mask对输入X进行选择的
* 5.满足条件筛选:2个
* paddle.nonzero(x, as_tuple= False) 返回输入x中非零元素的坐标
* paddle.where(condition, x, y) 返回一个根据输入 condition, 选择 x 或 y 的元素组成的多维 tensor.
-
1.paddle.max(x, axis=None, keepdim=False) 对指定维度上的tensor元素求最大值，并输出相应的计算结果
对指定维度上的tensor元素求最大值，并输出相应的计算结果。 * x: tensor * axis: list/int, 可选 * keepdim: bool, 可选 x = paddle.to_tensor([[0.2, 0.3, 0.5, 0.9], [0.1, 0.2, 0.6, 0.7]]) result1 = paddle.max(x) [0.9] y = paddle.to_tensor([[[1.0, 2.0], [3.0, 4.0]], [[5.0, 6.0], [7.0, 8.0]]]) result5 = paddle.max(y, axis=[1, 2]) print(result5) #[4. 8.] -
2.paddle.argmax(x, axis= None, keepdim=False, dtype= "int64") 沿axis计算输入x的最大元素的索引
* x:tensor * axis: int, 可选 * keepdim: bool, 可选 data = [[5,8,9,5], [0,0,1,7], [6,9,2,4]] x = paddle.to_tensor(data) out1 = paddle.argmax(x) print(out1) # 2 out2 = paddle.argmax(x, axis=1) print(out2) # [2 3 1] -
3.paddle.maximum(x, y) 逐元素对比输入两个tensor(广播)，并把各个位置更大的元素保存到返回结果中。
* x:tensor * y:tensor x = paddle.to_tensor([[1, 2], [7, 8]]) y = paddle.to_tensor([[3, 4], [5, 6]]) res = paddle.maximum(x, y) print(res) # [[3, 4], # [7, 8]] x = paddle.to_tensor([[1, 2, 3], [1, 2, 3]]) y = paddle.to_tensor([3, 0, 4]) res = paddle.maximum(x, y) print(res) # [[3, 2, 4], # [3, 2, 4]] -
4.paddle.min(x, axis=None, keepdim=False) 对指定维度上的tensor元素求最小值，并输出相应的计算结果
-
5.paddle.argmin(x, axis=None, keepdim=False) 沿axis计算输入x的最小元素的索引
-
6.paddle.minimum(x, y) 逐元素对比输入两个tensor,并把各个位置更小的元素保存到返回结果中。
-
7.paddle.sort(x, axis=-1, descendiing=False) 对输入按照指定维度进行排序,输出排序好的结果，默认升序
* x: tensor * axis: int, 可选 * descending: bool, 可选， True: 降序， False:升序 x = paddle.to_tensor([[[5,8,9,5], [0,0,1,7], [6,9,2,4]], [[5,2,4,2], [4,7,7,9], [1,7,0,6]]], dtype='float32') out1 = paddle.sort(x=x, axis=-1) #[[[5. 5. 8. 9.] # [0. 0. 1. 7.] # [2. 4. 6. 9.]] # [[2. 2. 4. 5.] # [4. 7. 7. 9.] # [0. 1. 6. 7.]]] -
8.paddle.argsort(x, axis= -1, descending= False) 对输入按照指定维度进行排序,输出排序好的数据的相应索引(原来数据), 默认升序
* x: tensor * axis: int, 可选 * descending: bool, 可选, True:降序排序， Flase: 升序排序 x = paddle.to_tensor([[[5,8,9,5], [0,0,1,7], [6,9,2,4]], [[5,2,4,2], [4,7,7,9], [1,7,0,6]]], dtype='float32') out1 = paddle.argsort(x=x, axis=-1) #[[[0 3 1 2] # [0 1 2 3] # [2 3 0 1]] # [[1 3 2 0] # [0 1 2 3] # [2 0 3 1]]] -
9.paddle.topk(x, k, axis= None, largest=True, sorted=True) # 沿着可选的axis查找 topk最大或 最小的结果， 和 结果所在的索引信息
* x: tensor * k: int/tensor, 在指定轴上进行 top寻找的数量 * axis: int, 可选, 默认: -1 * largest: bool, 可选， 指定排序方向, True: 降序 False:升序 * sorted: bool, 可选, 返回结果是否按照有序返回。 默认: True， GPU上:总是返回 有序结果 data_2 = paddle.to_tensor([[1, 4, 5, 7], [2, 6, 2, 5]]) value_2, indices_2 = paddle.topk(data_2, k=1) print(value_2) # [[7], [6]] print(indices_2) # [[3], [1]] -
10.paddle.unique(x, retun_index=False, retunr_inverse= False, return_counts=False,axis=None,dtype="int64") 返回tensor按升序 排序后的独有元素(去重)
输入： * x (Tensor) - 输入的 Tensor ，数据类型为：float32、float64、int32、int64。 * return_index (bool, 可选) - 如果为True，则还返回独有元素在输入Tensor中的索引。 * return_inverse (bool, 可选) - 如果为True，则还返回输入Tensor的元素对应在独有元素中的索引，该索引可用于重构输入Tensor * return_counts (bool, 可选) - 如果为True，则还返回每个独有元素在输入Tensor中的个数 * axis (int, 可选) - 指定选取独有元素的轴。默认值为None，将输入平铺为1-D的Tensor后再选取独有元素 * dtype (np.dtype|str, 可选) - 用于设置 index，inverse 或者 counts 的类型，应该为int32或者int64。默认：int64 返回: * out (Tensor) - 独有元素构成的Tensor，数据类型与输入一致。 * index (Tensor, 可选) - 独有元素在输入Tensor中的索引，仅在 return_index 为True时返回 * inverse (Tensor, 可选) - 输入Tensor的元素对应在独有元素中的索引，仅在 return_inverse 为True时返回 * counts (Tensor, 可选) - 每个独有元素在输入Tensor中的个数，仅在 return_counts 为True时返回 x_data = np.array([2, 3, 3, 1, 5, 3]) x = paddle.to_tensor(x_data) unique = paddle.unique(x) np_unique = unique.numpy() # [1 2 3 5] _, indices, inverse, counts = paddle.unique(x, return_index=True, return_inverse=True, return_counts=True) np_indices = indices.numpy() # [3 0 1 4] np_inverse = inverse.numpy() # [1 2 2 0 3 2] np_counts = counts.numpy() # [1 1 3 1] -
11.paddle.index_select(x, index, axis=0) 沿着指定axis轴 对 输入 x进行索引,并取 index 中指定的相应项,创建一个新的Tensor
* x: tensor * index: tensor, 包含索引下标的 1-D tensor * axis: int, 可选 data = np.array([[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0], [9.0, 10.0, 11.0, 12.0]]) data_index = np.array([0, 1, 1]).astype('int32') out_z2 = paddle.index_select(x=x, index=index, axis=1) #[[ 1. 2. 2.] # [ 5. 6. 6.] # [ 9. 10. 10.]] -
12.paddle.index_sample(x, index) 对输入 x 中的元素进行批量抽样,取index指定的对应下标的元素。 重新生成张量
* x: tensor, 二维张量 * index: 二维张量, 包含索引。 index 的第一维度与 输入x的第一维度必须相同。 x = paddle.to_tensor([[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0], [9.0, 10.0, 11.0, 12.0]], dtype='float32') index = paddle.to_tensor([[0, 1, 2], [1, 2, 3], [0, 0, 0]], dtype='int32') out_z1 = paddle.index_sample(x, index) print(out_z1) #[[1. 2. 3.] # [6. 7. 8.] # [9. 9. 9.]] -
13.paddle.masked_select(x, mask) 返回 1-D Tensor, tensor的值根据mask对输入X进行选择的。
* x:输入 tensor * mask: tensor, 用于索引的 二进制掩码tensor, 数据类型为 bool data = np.array([[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0], [9.0, 10.0, 11.0, 12.0]]).astype('float32') mask_data = np.array([[True, False, False, False], [True, True, False, False], [True, False, False, False]]).astype('bool') x = paddle.to_tensor(data) mask = paddle.to_tensor(mask_data) out = paddle.masked_select(x, mask) #[1.0 5.0 6.0 9.0] -
14.paddle.nonzero(x, as_tuple= False) 返回输入x中非零元素的坐标
-
15.paddle.where(condition, x, y) 返回一个根据输入 condition, 选择 x 或 y 的元素组成的多维 tensor.
* condition: tensor, 选择x 或 y元素的条件 * x: 多维tensor * y: 多维tensor x = paddle.to_tensor([0.9383, 0.1983, 3.2, 1.2]) y = paddle.to_tensor([1.0, 1.0, 1.0, 1.0]) out = paddle.where(x>1, x, y) print(out) #out: [1.0, 1.0, 3.2, 1.2] 如果 x > 1,则选择x对应元素，否则选择y的元素
🌟🌟🌟 八、广播、索引、切片、重组 25个
- 概括:
tensor.shape:长度变化(维度增多、减少),数值乘积结果变化
* 🐯 1.长度不变,数量不变: 针对tensor本身做形状变化
* 1) paddle.transpose(x, perm) 根据 perm对输入的多维 tensor 进行数据重排
* 2) paddle.reshape() tensor所有元素重新按照shape排列
* 🐯 2.长度不变,数量变: 某个维度元素数量 增加(多个tensor拼接)、减少(tensor一部分拼接)
* 1) paddle.concat() 多个tensor按照axis进行拼接，指定axis数目变大;
* 2) paddle.gather(x, index, axis=None) tensor.shape长度不改变 根据索引index 获取输入x的指定axis维度的条目,并将他们拼接在一起
* 3）paddle.slice(input, axes, starts, ends) 沿多个轴生成 input 的切片(可能多个维度都不完整) data[0:2,a:b]同样可以得到 【切片】
* 🐯 3.长度变,数量变: 广播、现有tensor复制、expand、多个tensor堆叠、当前tensor做切分[某一维度全切、指定数量平均切、定制维度切分大小]
* 1) paddle.broadcast_to(x, shape) 根据指定shape形状进行广播,广播后,x形状和shape指定的形状一致, 同 expand()
* 2) paddle.broadcast_shape(x_shape, y_shape) 返回对X_shape 和 y_shape 张量做广播操作后得到的shape
* 3) paddle.tile(x, repeat_times) 根据参数 repeat_times 对输入 x 的各维度进行复制, 返回tensor.shape可变
* 4) paddle.expand(x, shape) 根据shape指定形状进行扩展X，扩展后 x 的形状和shape指定的形状一致 同:paddle.broadcast_to()
* 5) paddle.expand_as(x, y) 根据 y 的现状扩展x,扩展后, x和y 的形状相同
* 6) paddle.stack(x, axis=0) 沿axis轴对输入X进行堆叠操作, 增加了一个维度，x.shape 长度+1 【x:list[tensor] / tuple[tensor]， 输入x是多个tensor, 维度和数据类型必须相同】
* 7) paddle.unstack(x, axis=0, num=None) 将单个 dim 为 D的tensor沿axis轴 unpack为 num个dim为 D-1 的维度 【可以指定num,则和 paddle.chunk一致】
* 8) paddle.chunk(x, chunks, axis=0) 将输入的 tensor 分割成多个 子 tensor. 和paddle.unstack() 区别? 【x.shape 长度不变，将tensor按照指定 chunks平均切分】
* 9) paddle.unbind(input, axis=0) 将输入Tensor按照指定维度分割成多个子 tensor(对应该维度大小),并删除该维度 【将tensor按照某一维度切成多块】
* 10) paddle.slice(input, axes, starts, ends) 沿多个轴生成 input 的切片(可能多个维度都不完整) data[0:2,a:b]同样可以得到 【切片】
* 11) paddle.split(x, num_or_sectionsm axis=0) 将输入tensor分割成多个子 tensor, 切割可不等大小 【定制某维度切分大小】
* 🐯 4.长度变,数量不变: 原有tensor形状进行变化:展开、铺平、重设size
* 1) paddle.reshape(x, shape) 在保持输入x数据不变的情况下，改变x的形状
* 2) paddle.flatten(x, start_axis=0, stop_axis=-1) 根据给定的 start_axis 和 stop_axis 将连续的维度展平
* 3) paddle.squeeze(x, axis= None) 删除输入tensor中尺寸为1的维度，如果指定axis，则删除axis中指定的尺寸为1的维度
* 4) paddle.unsqueeze(x, axis) 向输入tensor的shape中 一个或者多个位置(axis)插入尺寸为1的维度
* 其他:
* paddle.cast(x, dtype=None) 将输入的x数据类型转换为 dtype 并输出 x.astype()
* paddle.flip(x, axis) 沿指定axis轴反转 N 维 tensor
* paddle.strided_slice(x, axes, starts, ends, strides) 沿多个轴生成x的切片，strides:步长+方向
*
-
1.索引原则:
data = paddle.to_tensor([[1,2,3],[4,5,6]]) data[0][0] [1] 先得到: data[0]=[1,2,3] 再进一步: [0] 得到1 data[0,0] [1] 但是两个意思完全不同, 直接在 data上面找 [0,0] data[0] = data[0,:] data[:2][:2] [[1, 2, 3], [4, 5, 6]] 两次操作相当于没操作，都对第一维度操作。 data[:2, :2] # [[1, 2], [3, 4]] 直接对于data操作 -
2.广播原则:
-
2.1 每个张量至少为 1维 张量
-
2.2 从后往前比较张量的形状，当前维度的大小要么相等，要么其中一个等于1，要么其中一个不存在。
-
2.3 广播后 张量的形状计算规则:
- 如果两个张量的形状长度不一致,那么需要在较小形状长度的 矩阵向前添加1， 直到两个张量的形状长度相等。
- 保证两个张量形状相等后，每个维度上的 结果维度就是当前维度上 较大的那个。
-
-
3.paddle.broadcast_to(x, shape) 根据指定shape形状进行广播,广播后,x形状和shape指定的形状一致, 同 expand()
* x:tensor * shape: list/tuple/tensor data = paddle.to_tensor([1,2,3]) res1 = paddle.broadcast_to(data, shape=[2,3]) [[1,2,3],[1,2,3]] -
4.paddle.broadcast_shape(x_shape, y_shape) 返回对X_shape 和 y_shape 张量做广播操作后得到的shape
* x_shape: list[int]/tuple[int] * y_shape: list[int]/tuple[int] 返回类型: list[int] shape = paddle.broadcast_shape([2, 1, 3], [1, 3, 1]) # [2, 3, 3] -
5.paddle.reshape(x, shape) 在保持输入x数据不变的情况下，改变x的形状
注意: 动态图模式下,输出tensor和输入tensor共享数据,并且没有数据拷贝过程。 如果不希望输入与输出共享数据，请使用 Tensor,clone() 在指定目标shape时存在一些技巧: 1. -1: 表示这个维度的值是从 x 的元素总数 和 剩余维度推断出来的,因此，只有一个维度可以被设置为 -1. 2. 0: 表示实际的维数是 从x的对应维数复制出来的, 因此shape中0的索引值不能超过x的维度 * x: tensor, N-D * shape: list/tuple/tensor x = paddle.rand([2, 4, 6], dtype="float32") out = paddle.reshape(x, [-1, 0, 3, 2]) # the shape is [2,4,3,2]. -
6.paddle.reshape_()
-
7.paddle.expand(x, shape) 根据shape指定形状进行扩展X，扩展后 x 的形状和shape指定的形状一致 同:paddle.broadcast_to()
x的维数 和 shape的元素数应该小于等于6，并且shape中的元素数应该 大于等于 X 的维数， 扩展的维度的 维度值应该是: 1(啥意思?) * broadcast_to 和 expand 区别? 无 * x: tensor * shape: list/tuple/tensor data = paddle.to_tensor([1, 2, 3], dtype='int32') out = paddle.expand(data, shape=[2, 3]) print(out) # [[1, 2, 3], [1, 2, 3]] -
8.paddle.expand_as(x, y) 根据 y 的现状扩展x,扩展后, x和y 的形状相同。
* x: 输入 tensor * y: tensor 目标tensor, 使用该形状 np_data_x = np.array([1, 2, 3]).astype('int32') np_data_y = np.array([[1, 2, 3], [4, 5, 6]]).astype('int32') out = paddle.expand_as(data_x, data_y) # [[1, 2, 3], [1, 2, 3]] -
9.paddle.flatten(x, start_axis=0, stop_axis=-1) 根据给定的 start_axis 和 stop_axis 将连续的维度展平。
注意: 动态图下,输出tensor 和 输入tensor 共享数据 * x: 多维度 tensor * start_axis: int, flatten展开的起始维度。 * stop_axis: int, flatten展开的结束维度。 image_shape=(2, 3, 4, 4) x = paddle.arange(end=image_shape[0] * image_shape[1] * image_shape[2] * image_shape[3]) img = paddle.reshape(x, image_shape) / 100 out = paddle.flatten(img, start_axis=1, stop_axis=2) # out shape is [2, 12, 4] # 在动态图模式下，输出out与输入img共享数据 img[0, 0, 0, 0] = -1 print(out[0, 0, 0]) # [-1] -
10.paddle.stack(x, axis=0) 沿axis轴对输入X进行堆叠操作, 增加了一个维度，x.shape 长度+1
要求: 所有输入tensot具有相同的shape和数据类型. 例如，输入 x 为 N 个 Shape 为 [A, B]的 Tensor, 如果 axis==0 , 则输出 Tensor 的 Shape 为 [N, A, B]; 如果 axis==1 , 则输出 Tensor 的 Shape 为 [A, N, B]; 以此类推。 * x: list[tensor] / tuple[tensor]， 输入x是多个tensor, 维度和数据类型必须相同。 * axis: int, 可选 x1 = paddle.to_tensor([[1.0, 2.0]]) x2 = paddle.to_tensor([[3.0, 4.0]]) x3 = paddle.to_tensor([[5.0, 6.0]]) out = paddle.stack([x1, x2, x3], axis=0) print(out.shape) # [3, 1, 2] print(out) # [[[1., 2.]], # [[3., 4.]], # [[5., 6.]]] -
11.paddle.unstack(x, axis=0, num=None) 将单个 dim 为 D的tensor沿axis轴 unpack为 num个dim为 D-1 的维度
* x: tensor, dim>0 * axis: int, 可选 * num: int, 可选 x = paddle.ones(name='x', shape=[2, 3, 5], dtype='float32') # create a tensor with shape=[2, 3, 5] y = paddle.unstack(x, axis=1) # unstack with second axis, which results 3 tensors with shape=[2, 5] -
12.paddle.concat(x, axis=0) 对输入沿着 axis轴进行链接，返回一个新的tensor, tensor.shape 元素长度不变。
* x: list[tensor]/tuple[tensor], x中所有tensor的数据类型应该一致 * axis: int/tensor,可选 in1 = np.array([[1, 2, 3], [4, 5, 6]]) in2 = np.array([[11, 12, 13], [14, 15, 16]]) in3 = np.array([[21, 22], [23, 24]]) x1 = paddle.to_tensor(in1) x2 = paddle.to_tensor(in2) x3 = paddle.to_tensor(in3) out1 = paddle.concat(x=[x1, x2, x3], axis=-1) out2 = paddle.concat(x=[x1, x2], axis=0) # out1 # [[ 1 2 3 11 12 13 21 22] # [ 4 5 6 14 15 16 23 24]] # out2 out3 # [[ 1 2 3] # [ 4 5 6] # [11 12 13] # [14 15 16]] -
13.paddle.tile(x, repeat_times) 根据参数 repeat_times 对输入 x 的各维度进行复制, 返回tensor.shape可变
x 的维数和 repeat_times 中的元素数量应小于等于6，并且repeat_times中的元素数量应该小于等于6 * x (Tensor) - 输入的Tensor * repeat_times: list/tuple/tensor, 指定输入x每个维度的复制次数。 np_data = np.array([1, 2, 3]).astype('int32') data = paddle.to_tensor(np_data) out = paddle.tile(data, repeat_times=[2, 1]) np_out = out.numpy() # [[1, 2, 3], [1, 2, 3]] out = paddle.tile(data, repeat_times=[2, 2]) np_out = out.numpy() # [[1, 2, 3, 1, 2, 3], [1, 2, 3, 1, 2, 3]] -
14.paddle.gather(x, index, axis=None) tensor.shape长度不改变 根据索引index 获取输入x的指定axis维度的条目,并将他们拼接在一起
返回：和输入的秩相同的输出Tensor * x: tensor, 维度大于等于1 * index: tensor, 索引tensot, rank = 1 * axis: int/tensor， 指定index 获取输入的维度. input_1 = np.array([[1,2],[3,4],[5,6]]) index_1 = np.array([0,1]) input = paddle.to_tensor(input_1) index = paddle.to_tensor(index_1) output = paddle.gather(input, index, axis=0) # expected output: [[1,2],[3,4]] -
15.paddle.gather_nd() paddle.gather的高维推广 , 不懂
是 gather 的高维推广，并且支持多轴同时索引。 index 是一个K维度的张量，它可以认为是从 x 中取K-1维张量 -
16.paddle.chunk(x, chunks, axis=0) 将输入的 tensor 分割成多个 子 tensor. 和paddle.unstack() 区别?
* x: tensor * chunks: int, 整数，表示将输入tensor划分成多少个相同大小的子 tensor * axis: int/tensor, 可选 x_np = np.random.random([3, 9, 5]).astype("int32") x = paddle.to_tensor(x_np) out0, out1, out2 = paddle.chunk(x, chunks=3, axis=1) # out0.shape [3, 3, 5] # out1.shape [3, 3, 5] # out2.shape [3, 3, 5] -
17.paddle.unbind(input, axis=0) 将输入Tensor按照指定维度分割成多个子 tensor(对应该维度大小),并删除该维度
* input: tensor * axis: int32/int64, 可选 # input is a Tensor which shape is [3, 4, 5] np_input = np.random.rand(3, 4, 5).astype('float32') input = paddle.to_tensor(np_input) [x0, x1, x2] = paddle.unbind(input, axis=0) # x0.shape [4, 5] # x1.shape [4, 5] # x2.shape [4, 5] [x0, x1, x2, x3] = paddle.unbind(input, axis=1) # x0.shape [3, 5] # x1.shape [3, 5] # x2.shape [3, 5] # x3.shape [3, 5] -
18.paddle.slice(iiniput, axes, starts, ends) 沿多个轴生成 input 的切片(可能多个维度都不完整) data[0:2,a:b]同样可以得到
* input: 多维tensor * axes: list[int]/tuple[int], 表示切片的轴 * starts: list/tuple/tensor, int32, 各个轴上切片的开始索引值。 * ends: list/tuple/tensor, int32, 各个轴上切片的结束索引值 给定： data=[[1,2,3,4],[5,6,7,8],] starts=[0,1] ends=[-1,1000] # 此处-1表示第0维的反向第0个位置，索引值是1。 则： result=[[2,3,4],] # 即 data[0:1, 1:4] -
19.paddle.strided_slice(x, axes, starts, ends, strides) 沿多个轴生成x的切片，strides:步长+方向
* strides: list/tuple/tensor 给定： data=[[1,2,3,4],[5,6,7,8],] axes=[0,1] starts=[1,0] ends=[2,3] strides=[1,1] 则： result=[[5,6,7],] 给定： data=[[1,2,3,4],[5,6,7,8],] axes=[0,1] starts=[1,3] ends=[2,0] strides=[1,-1] 则： result=[[8,7,6],] -
20.paddle.split(x, num_or_sectionsm axis=0) 将输入tensor分割成多个子 tensor, 切割可不等大小
返回: 分割后的Tensor列表。 * x； tensor * num_or_sections: list/int/tuple, 如果整数,则平均切分,如果list/tuple，则对应切分后该维度的数目 x = paddle.rand([3, 9, 5]) out0, out1, out2 = paddle.split(x, num_or_sections=3, axis=1) print(out0.shape) # [3, 3, 5] print(out1.shape) # [3, 3, 5] print(out2.shape) # [3, 3, 5] out0, out1, out2 = paddle.split(x, num_or_sections=[2, 3, 4], axis=1) print(out0.shape) # [3, 2, 5] print(out1.shape) # [3, 3, 5] print(out2.shape) # [3, 4, 5] -
21.paddle.squeeze(x, axis= None) 删除输入tensor中尺寸为1的维度，如果指定axis，则删除axis中指定的尺寸为1的维度
* 注意: 动态图下, 输入 tensor 和 输出tensor 共享数据 * x: tensor * axis: int/list/tuple x = paddle.rand([5, 1, 10]) output = paddle.squeeze(x, axis=1) print(x.shape) # [5, 1, 10] print(output.shape) # [5, 10] -
22.paddle.unsqueeze(x, axis) 向输入tensor的shape中 一个或者多个位置(axis)插入尺寸为1的维度。
注意: 动态图下, 输出tensor 和 输入tensor共享数据 * x: tensor * axis: int/list/tuple, 表示要插入的维度 x = paddle.rand([5, 10]) print(x.shape) # [5, 10] out1 = paddle.unsqueeze(x, axis=0) print(out1.shape) # [1, 5, 10] out2 = paddle.unsqueeze(x, axis=[0, 2]) print(out2.shape) # [1, 5, 1, 10] -
23.paddle.transpose(x, perm) 根据 perm对输入的多维 tensor 进行数据重排
返回多维tensor 的第 i 维，对应输入 tensor 的 perm[i] 维 * x: tensor * perm: list/tuple perm长度必须和X的维度数相同,并依照perm中数据重排 x = [[[ 1 2 3 4] [ 5 6 7 8] [ 9 10 11 12]] [[13 14 15 16] [17 18 19 20] [21 22 23 24]]] shape(x) = [2,3,4] # 例0 perm0 = [1,0,2] y_perm0 = [[[ 1 2 3 4] [13 14 15 16]] [[ 5 6 7 8] [17 18 19 20]] [[ 9 10 11 12] [21 22 23 24]]] shape(y_perm0) = [3,2,4] -
24paddle.flip(x, axis) 沿指定axis轴反转 N 维 tensor
参数: 1.x:tensor,输入张量,维度为 多维。 2.axis: list, 需要反转的轴 返回: 在指定axis上翻转后的张量,与输入X数据类型相同。 image_shape = (3,2,2) x = paddle.arange(image_shape[0]*image_shape[1]*image_shape[2], dtype="float32").reshape(image_shape) res = paddle.flip(x, [0,1]) # [[[10,11][8, 9]],[[6, 7],[4, 5]] [[2, 3],[0, 1]]] -
25.paddle.cast(x, dtype=None) 将输入的x数据类型转换为 dtype 并输出 x.astype()
支持输入和输出的数据类型相同 * x: tensor * dtype: bool等 8种 x = paddle.to_tensor([2, 3, 4], 'float64') y = paddle.cast(x, 'uint8')
九、不会 & 其他
-
paddle.roll()
-
paddle.scatter(x, index, updates, overwrite=True) 通过基于 updates 来更新选定索引 index 上的输入来获得输出
-
paddle.sactter_nd()
-
paddle.scatter_nd_add()
-
paddle.shard_index(nput, index_num, nshards, shard_id, ignore_value=- 1) 根据分片（shard）的偏移量重新计算分片的索引
-
paddle.erf(x) 逐元素计算 Erf 激活函数
-
paddle.increment(x, value=1.0) 在控制流程中用来让 x 的数值增加 value(鸡肋，不能自己加？)
-
paddle.kron(x, y) 计算两个张量的克罗内克积，结果是一个合成的张量
-
paddle.multiplex(inputs, index) 阴间API,获取特定行直接取不可以吗？ 根据给定的index参数，该OP从每个输入Tensor中选择特定行构造输出Tensor
-
paddle.imag(x) 返回一个包含输入复数Tensor的虚部数值的新Tensor
x = paddle.to_tensor( [[1 + 6j, 2 + 5j, 3 + 4j], [4 + 3j, 5 + 2j, 6 + 1j]]) # Tensor(shape=[2, 3], dtype=complex64, place=CUDAPlace(0), stop_gradient=True, # [[(1+6j), (2+5j), (3+4j)], # [(4+3j), (5+2j), (6+1j)]]) imag_res = paddle.imag(x) # Tensor(shape=[2, 3], dtype=float32, place=CUDAPlace(0), stop_gradient=True, # [[6., 5., 4.], # [3., 2., 1.]]) imag_t = x.imag() # Tensor(shape=[2, 3], dtype=float32, place=CUDAPlace(0), stop_gradient=True, # [[6., 5., 4.], # [3., 2., 1.]]) -
padlle.real(x) 返回一个包含输入复数Tensor的实部数值的新Tensor
x = paddle.to_tensor( [[1 + 6j, 2 + 5j, 3 + 4j], [4 + 3j, 5 + 2j, 6 + 1j]]) # Tensor(shape=[2, 3], dtype=complex64, place=CUDAPlace(0), stop_gradient=True, # [[(1+6j), (2+5j), (3+4j)], # [(4+3j), (5+2j), (6+1j)]]) real_res = paddle.real(x) # Tensor(shape=[2, 3], dtype=float32, place=CUDAPlace(0), stop_gradient=True, # [[1., 2., 3.], # [4., 5., 6.]]) real_t = x.real() # Tensor(shape=[2, 3], dtype=float32, place=CUDAPlace(0), stop_gradient=True, # [[1., 2., 3.], # [4., 5., 6.]])
