深度学习：PyTorch张量基本运算、形状改变、索引操作、升维降维、维度转置、张量拼接

本文目录：

• 一、张量数值运算
• • （一）基本运算
  • （二）点乘运算
  • （三）矩阵乘法
  • **扩展**：广播规则
• 二、运算函数
• [三、索引操作：类似于loc[ ]、iloc[ ]](#三、索引操作：类似于loc[ ]、iloc[ ])
• 四、形状操作
• • （一）reshape
  • （二）view
• 五、squeeze与unsqueeze
• 六、transpose和permute
• 七、张量拼接操作
• • （一）cat/concat
  • （二）stack

一、张量数值运算

（一）基本运算

+、-、*、/、add、sub、mul、div、neg

例：
data = torch.randint(0, 10, [2, 3])
print(data)
# 1. 不修改原数据
new_data = data.add(10)  # 等价 new_data = data + 10
print(new_data)
# 2. 直接修改原数据 注意: 带下划线的函数为修改原数据本身
data.add_(10)  # 等价 data += 10
print(data)
# 3. 其他函数
print(data.sub(100))
print(data.mul(100))
print(data.div(100))
print(data.neg())   #对元素取负

（二）点乘运算

点乘（Hadamard）为元素间相乘，指的是相同形状的张量对应位置的元素相乘，使用mul和运算符 * 实现。

例：
data1 = torch.tensor([[1, 2], [3, 4]])
data2 = torch.tensor([[5, 6], [7, 8]])
# 第一种方式
data = torch.mul(data1, data2)
print(data)
# 第二种方式
data = data1 * data2
print(data)

（三）矩阵乘法

要求第一个矩阵 shape: (n, m)，第二个矩阵 shape: (m, p), 两个矩阵点积运算 shape 为: (n, p)。运算符包括@、matmul（要求至少2维向量；对最后两个维度进行矩阵乘法，其他维度【如果有】按广播规则处理。）、dot（仅针对1维张量）

例：
# 点积运算
data1 = torch.tensor([[1, 2], [3, 4], [5, 6]])
data2 = torch.tensor([[5, 6], [7, 8]])
# 方式一:
data3 = data1 @ data2
print("data3-->", data3)
# 方式二:
data4 = torch.matmul(data1, data2)
print("data4-->", data4)

扩展：广播规则

NumPy、PyTorch、TensorFlow 等科学计算库中的一种重要机制，用于自动扩展不同形状的张量（或数组），使它们能够按元素进行运算（如加减乘除、矩阵乘法等）。它的核心目的是简化代码，避免显式复制数据，同时保持计算效率。

例：
import numpy as np

a = np.array([1, 2, 3])  # shape (3,)
b = 2                    # shape () （标量）
c = a + b                # 广播：b 被扩展为 [2, 2, 2]
print(c)                 # 输出: [3 4 5]

a = np.array([[1], [2], [3]])  # shape (3, 1)
b = np.array([10, 20])         # shape (2,)
c = a + b                      # 广播步骤：
                               # 1. a 扩展为 (3, 2): [[1, 1], [2, 2], [3, 3]]
                               # 2. b 扩展为 (3, 2): [[10, 20], [10, 20], [10, 20]]
print(c)
# 输出:
# [[11 21]
#  [12 22]
#  [13 23]]

a = np.random.rand(2, 1, 3)  # shape (2, 1, 3)
b = np.random.rand(4, 3)     # shape (4, 3)
c = a + b                    # 广播步骤：
                             # 1. a 扩展为 (2, 4, 3)
                             # 2. b 扩展为 (2, 4, 3)
print(c.shape)               # 输出: (2, 4, 3)

二、运算函数

min、sum、max、pow。。。。。。

dim=0：按列计算；dim=1：按行计算。

例：
import torch

data = torch.randint(0, 10, [2, 3], dtype=torch.float64)
print(data)
# 1. 计算均值
# 注意: tensor 必须为 Float 或者 Double 类型
print(data.mean())
print(data.mean(dim=0))  # 按列计算均值
print(data.mean(dim=1))  # 按行计算均值
# 2. 计算总和
print(data.sum())
print(data.sum(dim=0))
print(data.sum(dim=1))
# 3. 计算平方
print(torch.pow(data，2))
# 4. 计算平方根
print(data.sqrt())
# 5. 指数计算, e^n 次方
print(data.exp())
# 6. 对数计算
print(data.log())  # 以 e 为底
print(data.log2())
print(data.log10())

三、索引操作：类似于loc[ ]、iloc[ ]

例：
import torch


# 随机生成数据
data = torch.randint(0, 10, [4, 5])
print(data)

# 1.简单行、列索引
print(data[0])
print(data[:, 0])

# 2.列表索引
# 返回 (0, 1)、(1, 2) 两个位置的元素
print(data[[0, 1], [1, 2]])
# 返回 0、1 行的 1、2 列共4个元素
print(data[[[0], [1]], [1, 2]])


# 3.范围索引
# 前3行的前2列数据
print(data[:3, :2])
# 第2行到最后的前2列数据
print(data[2:, :2])

# 4.布尔索引
# 第三列大于5的行数据
print(data[data[:, 2] > 5])
# 第二行大于5的列数据
print(data[:, data[1] > 5])

# 5.多维索引
# 随机生成三维数据
data = torch.randint(0, 10, [3, 4, 5])
print(data)
# 获取0轴上的第一个数据
print(data[0, :, :])
# 获取1轴上的第一个数据
print(data[:, 0, :])
# 获取2轴上的第一个数据
print(data[:, :, 0])

四、形状操作

（一）reshape

保证数据不变的情况下改变形状，可处理连续变量也可处理非连续变量；

例：
import torch

data = torch.tensor([[10, 20, 30], [40, 50, 60]])
# 1. 使用 shape 属性或者 size 方法都可以获得张量的形状
print(data.shape, data.shape[0], data.shape[1])
print(data.size(), data.size(0), data.size(1))

# 2. 使用 reshape 函数修改张量形状
new_data = data.reshape(1, 6)
print(new_data.shape)

（二）view

只可处理连续变量，处理前可用is_contiguous作连续性判断。另外，当张量的底层数据在内存中的存储顺序与其逻辑顺序不一致，view函数无法对这样的张量进行变形处理，例如: 一个张量经过了 transpose 或者 permute 函数的处理之后，就无法使用 view 函数进行形状操作。

例：
# 1 一个张量经过了 transpose 或者 permute 函数的处理之后，就无法使用 view 函数进行形状操作； 若要使用view函数, 需要使用contiguous() 变成连续以后再使用view函数。
# 2 判断张量是否连续
data = torch.tensor([[10, 20, 30],[40, 50, 60]])
print('data--->', data, data.shape)
# 1 判断张量是否连续
print(data.is_contiguous()) # True
# 2 view
mydata2 = data.view(3, 2)
print('mydata2--->', mydata2, mydata2.shape)
# 3 判断张量是否连续
print('mydata2.is_contiguous()--->', mydata2.is_contiguous())
# 4 使用 transpose 函数修改形状
mydata3 = torch.transpose(data, 0, 1)  
print('mydata3--->', mydata3, mydata3.shape)
print('mydata3.is_contiguous()--->', mydata3.is_contiguous())
# 5 需要先使用 contiguous 函数转换为连续的张量，再使用 view 函数
print (mydata3.contiguous().is_contiguous())
mydata4 = mydata3.contiguous().view(2, 3)
print('mydata4--->', mydata4.shape, mydata4)

五、squeeze与unsqueeze

squeeze：删除指定位置形状为1的维度，不指定位置删除所有形状为1的维度，降维；> unsqueeze：在指定位置添加形状为1的维度，升维

注意：reshape、切片、view也可通过改变形状变相实现升维降维功能，但不是标准用法。

例：
mydata1 = torch.tensor([1, 2, 3, 4, 5])             
print('mydata1--->', mydata1.shape, mydata1) # 一个普通的数组 1维数据
mydata2 = mydata1.unsqueeze(dim=0)
print('在0维度上 拓展维度：', mydata2, mydata2.shape)  # 1*5
mydata3 = mydata1.unsqueeze(dim=1)
print('在1维度上 拓展维度：', mydata3, mydata3.shape)  # 5*1
mydata4 = mydata1.unsqueeze(dim=-1)
print('在-1维度上 拓展维度：', mydata4, mydata4.shape) # 5*1
mydata5 = mydata4.squeeze()
print('压缩维度：', mydata5, mydata5.shape)  # 1*5

六、transpose和permute

transpose：实现交换张量形状的指定维度, 例如: 一个张量的形状为 (2, 3, 4) ，把 3 和 4 进行交换, 将张量的形状变为 (2, 4, 3) ；

permute：一次交换更多的维度。

例：
data = torch.tensor(np.random.randint(0, 10, [3, 4, 5]))
print('data shape:', data.size())
# 1. 交换1和2维度
mydata2 = torch.transpose(data, 1, 2)
print('mydata2.shape--->', mydata2.shape)
# 2. 将data 的形状修改为 (4, 5, 3), 需要变换多次
mydata3 =  torch.transpose(data, 0, 1)
mydata4 = torch.transpose(mydata3, 1, 2)
print('mydata4.shape--->', mydata4.shape)
# 3. 使用 permute 函数将形状修改为 (4, 5, 3)
# 3-1 方法1
mydata5 = torch.permute(data, [1, 2, 0])
print('mydata5.shape--->', mydata5.shape)
# 3-2 方法2
mydata6 = data.permute([1, 2, 0])
print('mydata6.shape--->', mydata6.shape)

七、张量拼接操作

（一）cat/concat

        沿着现有维度连接一系列张量。
      所有输入张量除了指定的拼接维度外，其他维度必须匹配，即指定拼接维度可不一样，其它维度必须一样。

例：
import torch

data1 = torch.randint(0, 10, [1, 2, 3])
data2 = torch.randint(0, 10, [1, 2, 3])
print(data1)
print(data2)
# 1. 按0维度拼接
new_data = torch.cat([data1, data2], dim=0)
print(new_data)
print(new_data.shape)
# 2. 按1维度拼接
new_data = torch.cat([data1, data2], dim=1)
print(new_data)
print(new_data.shape)
# 3. 按2维度拼接
new_data = torch.cat([data1, data2], dim=2)
print(new_data)
print(new_data.shape)

（二）stack

在一个新的维度上连接一系列张量，这会增加一个新维度；所有输入张量的形状必须完全相同。

二维张量（比如（2,3））之所以在stack上有0、1、2三个维度拼接方式，是因为stack可以在末尾创造一个新维度。

stack关于二维张量的拼接操作：

例：
import torch
data1 = torch.randint(0, 10, [2, 3])
data2 = torch.randint(0, 10, [2, 3])
print(data1)
print(data2)
# 1. 在0维度上拼接
new_data = torch.stack([data1, data2], dim=0)
print(new_data)
print(new_data.shape)
# 2. 在1维度上拼接
new_data = torch.stack([data1, data2], dim=1)
print(new_data)
print(new_data.shape)
# 3. 在2维度上拼接
new_data = torch.stack([data1, data2], dim=2)
print(new_data)
print(new_data.shape)

今天的分享到此结束。