初试记录时间：2022.6.7

学习教程来源：

Tensor

Tensor类似与数组，它是一个多维的数据。理论上Tensor可以是无限维数。
Tensor的数据：floats/ints/complex numbers。
Tensor的数据格式：数组必须类似于“矩形”。
shape：定义Tensor的维数。
dtype：定义Tensor的数据类型。int8/int16/int32/int64/float16/float32/float32/complex64/complex128/uint8/bool。
place：指定分配的设备位置。CPU/GPU/固定内存。(CPU：place = paddle.CPUPlace() / place = CPUPlace；GPU：place = paddle.CUDAPlace(0) / place = CUDAPlace(0)；固定内存：place = paddle.CUDAPinnedPlace() / place = CUDAPinnedPlace)

Tensor的转换方式：

  1. ndim_2_tensor = paddle.to_tensor([[1.0, 2.0, 3.0],
  2.                                   [4.0, 5.0, 6.0]])
  3. print(ndim_2_tensor)
  1. Tensor(shape=[2, 3], dtype=float32, place=CUDAPlace(0), stop_gradient=True,
  2.        [[1., 2., 3.],
  3.         [4., 5., 6.]])
  1. # Tensor可以有任意数量的轴（也称为维度）
  2. ndim_3_tensor = paddle.to_tensor([[[1, 2, 3, 4, 5],
  3.                                    [6, 7, 8, 9, 10]],
  4.                                   [[11, 12, 13, 14, 15],
  5.                                    [16, 17, 18, 19, 20]]])
  6. print(ndim_3_tensor)
  1. Tensor(shape=[2, 2, 5], dtype=int64, place=CUDAPlace(0), stop_gradient=True,
  2.        [[[1, 2, 3, 4, 5],
  3.          [ 6,  7,  8,  9, 10]],
  4.         [[11, 12, 13, 14, 15],
  5.          [16, 17, 18, 19, 20]]])

Tensor转换为numpy array：

转换函数Tensor.numpy()

转换方式：

  1. ndim_2_tensor.numpy()
  1. array([[1., 2., 3.],
  2.        [4., 5., 6.]], dtype=float32)

numpy array转换为Tensor：

转换方式与Tensor的创建方式相同。

改变Tensor的shape

利用reshape()函数改变Tensor的shape

  1. ndim_3_tensor = paddle.reshape(ndim_3_tensor, [2, 5, 3])

通过cast改变dtype：

  1. float64_tensor = paddle.cast(float32_tensor, dtype='float64')

Tensor的name：

Tensor的name是Tensor的唯一标识。

数学运算符：

数学运算：

  1. x.abs()                       #逐元素取绝对值
  2. x.ceil()                      #逐元素向上取整
  3. x.floor()                     #逐元素向下取整
  4. x.round()                     #逐元素四舍五入
  5. x.exp()                       #逐元素计算自然常数为底的指数
  6. x.log()                       #逐元素计算x的自然对数
  7. x.reciprocal()                #逐元素求倒数
  8. x.square()                    #逐元素计算平方
  9. x.sqrt()                      #逐元素计算平方根
  10. x.sin()                       #逐元素计算正弦
  11. x.cos()                       #逐元素计算余弦
  12. x.add(y)                      #逐元素相加
  13. x.subtract(y)                 #逐元素相减
  14. x.multiply(y)                 #逐元素相乘
  15. x.divide(y)                   #逐元素相除
  16. x.mod(y)                      #逐元素相除并取余
  17. x.pow(y)                      #逐元素幂运算
  18. x.max()                       #指定维度上元素最大值，默认为全部维度
  19. x.min()                       #指定维度上元素最小值，默认为全部维度
  20. x.prod()                      #指定维度上元素累乘，默认为全部维度
  21. x.sum()                       #指定维度上元素的和，默认为全部维度
  1. x + y  -> x.add(y)            #逐元素相加
  2. x - y  -> x.subtract(y)       #逐元素相减
  3. x * y  -> x.multiply(y)       #逐元素相乘
  4. x / y  -> x.divide(y)         #逐元素相除
  5. x % y  -> x.mod(y)            #逐元素相除并取余
  6. x ** y -> x.pow(y)            #逐元素幂运算

逻辑运算

  1. x.isfinite()                  #判断tensor中元素是否是有限的数字，即不包括inf与nan
  2. x.equal_all(y)                #判断两个tensor的全部元素是否相等，并返回shape为[1]的bool Tensor
  3. x.equal(y)                    #判断两个tensor的每个元素是否相等，并返回shape相同的bool Tensor
  4. x.not_equal(y)                #判断两个tensor的每个元素是否不相等
  5. x.less_than(y)                #判断tensor x的元素是否小于tensor y的对应元素
  6. x.less_equal(y)               #判断tensor x的元素是否小于或等于tensor y的对应元素
  7. x.greater_than(y)             #判断tensor x的元素是否大于tensor y的对应元素
  8. x.greater_equal(y)            #判断tensor x的元素是否大于或等于tensor y的对应元素
  9. x.allclose(y)                 #判断tensor x的全部元素是否与tensor y的全部元素接近，并返回shape为[1]的bool Tensor
  1. x == y  -> x.equal(y)         #判断两个tensor的每个元素是否相等
  2. x != y  -> x.not_equal(y)     #判断两个tensor的每个元素是否不相等
  3. x < y   -> x.less_than(y)     #判断tensor x的元素是否小于tensor y的对应元素
  4. x <= y  -> x.less_equal(y)    #判断tensor x的元素是否小于或等于tensor y的对应元素
  5. x > y   -> x.greater_than(y)  #判断tensor x的元素是否大于tensor y的对应元素
  6. x >= y  -> x.greater_equal(y) #判断tensor x的元素是否大于或等于tensor y的对应元素

bool运算操作：

  1. x.logical_and(y)              #对两个bool型tensor逐元素进行逻辑与操作
  2. x.logical_or(y)               #对两个bool型tensor逐元素进行逻辑或操作
  3. x.logical_xor(y)              #对两个bool型tensor逐元素进行逻辑亦或操作
  4. x.logical_not(y)              #对两个bool型tensor逐元素进行逻辑非操作

线性代数相关运算：

  1. x.cholesky()                  #矩阵的cholesky分解
  2. x.t()                         #矩阵转置
  3. x.transpose([1, 0])           #交换axis 0 与axis 1的顺序
  4. x.norm('fro')                 #矩阵的Frobenius 范数
  5. x.dist(y, p=2)                #矩阵（x-y）的2范数
  6. x.matmul(y)                   #矩阵乘法

cholesky分解：

矩阵A为一个正定的矩阵。
则A可以必定可以写成一个下三角矩阵和其转置矩阵的乘积。
将A分解为一个这样的下三角矩阵则称为cholesky分解。

正定矩阵：

矩阵A和矩阵的转置AT相等。即矩阵A关于对角线对称。

Frobenius范数：

Frobenius范数，简称F范数，记为：||·||F。

定义：

矩阵各项元素的绝对值平方的总和开根。