paddle01-Tensor相關操作 【完】

• ✈ paddle2.0 API目錄
• Tensor
  • 0.易錯乘法
  • ⭐ 一、 創建相關
  • ⭐ 二、random 相關(也可以看做生成) 10個函數
  • ⭐⭐ 三、數學操作(paddleAPI, paddle類成員函數) 42個
  • ⭐ 四、線性代數相關
  • ⭐ 五、邏輯操作: 17函數
    • 5.1 is 邏輯 (5_func)
    • 5.2 相等性判斷
    • 5.3 與或非邏輯
  • ⭐⭐ 六、class paddle.Tensor屬性&方法()
  • ⭐⭐ 七、元素查找相關 15個
  • 🌟🌟🌟 八、廣播、索引、切片、重組 25個
  • 九、不會 & 其他

✈ 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]]
  • 2.10.paddle.zeros(shape, dtype=None)

    創建形狀為 shape 且值全為 0 的tensor
    data = paddle.zeros(shape=[2,3])
    

• 🌙 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]
    

• 🌙 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)
    

⭐ 二、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, 模型參數都是: False

  x = paddle.to_tensor([[1,2], [3, 4]])
  x.stop_gradient
  

• 4.x.grad:查看一個 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(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.]])