python打卡day48

张量随机函数与广播机制

知识点回顾：

1. 随机张量的生成：torch.randn函数
2. 卷积和池化的计算公式（可以不掌握，会自动计算的）
3. pytorch的广播机制：加法和乘法的广播机制

ps：numpy运算也有类似的广播机制，基本一致

torch.randn()函数

在 PyTorch 中，torch.randn()是一个常用的随机张量生成函数，它可以创建一个由标准正态分布（均值为 0，标准差为 1）随机数填充的张量。这种随机张量在深度学习中非常实用，常用于初始化模型参数、生成测试数据或模拟输入特征

torch.randn(*size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)

• size：必选参数，表示输出张量的形状（如(3, 4)表示 3 行 4 列的矩阵）
• dtype：可选参数，指定张量的数据类型（如torch.float32、torch.int64等）
• device：可选参数，指定张量存储的设备（如'cpu'或'cuda'）
• requires_grad：可选参数，是否需要计算梯度（常用于训练模型时）

import torch# 生成标量（0维张量）
scalar = torch.randn(())# 生成向量（1维张量）
vector = torch.randn(5)  # 长度为5的向量# 生成矩阵（2维张量）
matrix = torch.randn(3, 4)  # 3行4列的矩阵# 生成3维张量（常用于图像数据的通道、高度、宽度）
tensor_3d = torch.randn(3, 224, 224)  # 3通道，高224，宽224# 生成4维张量（常用于批量图像数据：[batch, channel, height, width]）
tensor_4d = torch.randn(2, 3, 224, 224)  # 批量大小为2，3通道，高224，宽224

还有其他张量随机函数，生成数据分布不同，比如 torch.rand()：生成在 [0, 1) 范围内均匀分布的随机数；torch.randint()：生成指定范围内的随机整数；torch.normal()：生成指定均值和标准差的正态分布随机数，随便掌握得了，记多了也容易混（

输入输出特征图维度关系

卷积和池化的输入输出维度关系都满足下式，本质就是核窗口在输入特征图上移动的有效范围带来的，搞懂卷积层的具体原理就懂了

 举个例子吧，无填充输入序列位置：[0][1][2][3][4] （宽度=5）

步长为1的3x3卷积核覆盖范围（每次覆盖3个位置）：得到三个输出 (5 + 0 - 3)/1 + 1 = 3

• 第一次覆盖：0-2 → 输出位置[0]
• 第二次覆盖：1-3 → 输出位置[1]
• 第三次覆盖：2-4 → 输出位置[2]

pytorch的广播机制

pytorch的广播机制实现自动对形状不同的张量进行维度扩展，无需手动调整张量维度，但也要符合规则：从张量的最后一个维度（最右侧）开始向左逐维比较

• 相等维度：若两个张量在某一维度上大小相同，则继续比较下一维度
• 一维扩展：若其中一个张量在某一维度上大小为1，则该维度会被扩展为另一个张量对应维度的大小
• 不兼容错误：若某一维度大小既不相同也不为1，则抛出 `RuntimeError`-----维度必须满足广播规则，否则会报错

举个例子，二维和一维相加

import torch# 创建原始张量
a = torch.tensor([[10], [20], [30]])  # 形状: (3, 1)
b = torch.tensor([1, 2, 3])          # 形状: (3,)result = a + b
# 广播过程
# 1. b补全维度: (3,) → (1, 3)
# 2. a扩展列: (3, 1) → (3, 3)
# 3. b扩展行: (1, 3) → (3, 3)
# 最终形状: (3, 3)print("原始张量a:")
print(a)print("\n原始张量b:")
print(b)print("\n广播后a的值扩展:")
print(torch.tensor([[10, 10, 10],[20, 20, 20],[30, 30, 30]]))  # 实际内存中未复制，仅逻辑上扩展print("\n广播后b的值扩展:")
print(torch.tensor([[1, 2, 3],[1, 2, 3],[1, 2, 3]]))  # 实际内存中未复制，仅逻辑上扩展print("\n加法结果:")
print(result)# ------------------------ 以下打印结果 -------------------------
原始张量a:
tensor([[10],[20],[30]])原始张量b:
tensor([1, 2, 3])广播后a的值扩展:
tensor([[10, 10, 10],[20, 20, 20],[30, 30, 30]])广播后b的值扩展:
tensor([[1, 2, 3],[1, 2, 3],[1, 2, 3]])加法结果:
tensor([[11, 12, 13],[21, 22, 23],[31, 32, 33]])

二维与三维相加

# 创建原始张量
a = torch.tensor([[[1], [2]], [[3], [4]]])  # 形状: (2, 2, 1)
b = torch.tensor([[10, 20]])               # 形状: (1, 2)# 广播过程
# 1. b补全维度: (1, 2) → (1, 1, 2)
# 2. a扩展第三维: (2, 2, 1) → (2, 2, 2)
# 3. b扩展第一维: (1, 1, 2) → (2, 1, 2)
# 4. b扩展第二维: (2, 1, 2) → (2, 2, 2)
# 最终形状: (2, 2, 2)result = a + b
print("原始张量a:")
print(a)print("\n原始张量b:")
print(b)print("\n广播后a的值扩展:")
print(torch.tensor([[[1, 1],[2, 2]],[[3, 3],[4, 4]]]))  # 实际内存中未复制，仅逻辑上扩展print("\n广播后b的值扩展:")
print(torch.tensor([[[10, 20],[10, 20]],[[10, 20],[10, 20]]]))  # 实际内存中未复制，仅逻辑上扩展print("\n加法结果:")
print(result)# ------------------------ 以下打印结果 -------------------------
原始张量a:
tensor([[[1],[2]],[[3],[4]]])原始张量b:
tensor([[10, 20]])广播后a的值扩展:
tensor([[[1, 1],[2, 2]],[[3, 3],[4, 4]]])广播后b的值扩展:
tensor([[[10, 20],[10, 20]],[[10, 20],[10, 20]]])加法结果:
...[12, 22]],[[13, 23],[14, 24]]])

对于乘法的话，有点差异了

批量矩阵与单个矩阵相乘

import torch# A: 批量大小为2，每个是3×4的矩阵
A = torch.randn(2, 3, 4)  # 形状: (2, 3, 4)# B: 单个4×5的矩阵
B = torch.randn(4, 5)     # 形状: (4, 5)# 广播过程：
# 1. B补全维度: (4, 5) → (1, 4, 5)
# 2. B扩展第一维: (1, 4, 5) → (2, 4, 5)
# 矩阵乘法: (2, 3, 4) @ (2, 4, 5) → (2, 3, 5)
result = A @ B            # 结果形状: (2, 3, 5)print("A形状:", A.shape)  # 输出: torch.Size([2, 3, 4])
print("B形状:", B.shape)  # 输出: torch.Size([4, 5])
print("结果形状:", result.shape)  # 输出: torch.Size([2, 3, 5])

批量矩阵与批量矩阵相乘

# A: 批量大小为3，每个是2×4的矩阵
A = torch.randn(3, 2, 4)  # 形状: (3, 2, 4)# B: 批量大小为1，每个是4×5的矩阵
B = torch.randn(1, 4, 5)  # 形状: (1, 4, 5)# 广播过程：
# B扩展第一维: (1, 4, 5) → (3, 4, 5)
# 矩阵乘法: (3, 2, 4) @ (3, 4, 5) → (3, 2, 5)
result = A @ B            # 结果形状: (3, 2, 5)print("A形状:", A.shape)  # 输出: torch.Size([3, 2, 4])
print("B形状:", B.shape)  # 输出: torch.Size([1, 4, 5])
print("结果形状:", result.shape)  # 输出: torch.Size([3, 2, 5])

二维张量与三维张量相乘

# A: 批量大小为2，通道数为3，每个是4×5的矩阵
A = torch.randn(2, 3, 4, 5)  # 形状: (2, 3, 4, 5)# B: 单个5×6的矩阵
B = torch.randn(5, 6)        # 形状: (5, 6)# 广播过程：
# 1. B补全维度: (5, 6) → (1, 1, 5, 6)
# 2. B扩展第一维: (1, 1, 5, 6) → (2, 1, 5, 6)
# 3. B扩展第二维: (2, 1, 5, 6) → (2, 3, 5, 6)
# 矩阵乘法: (2, 3, 4, 5) @ (2, 3, 5, 6) → (2, 3, 4, 6)
result = A @ B               # 结果形状: (2, 3, 4, 6)print("A形状:", A.shape)     # 输出: torch.Size([2, 3, 4, 5])
print("B形状:", B.shape)     # 输出: torch.Size([5, 6])
print("结果形状:", result.shape)  # 输出: torch.Size([2, 3, 4, 6])

@浙大疏锦行