随机函数与广播机制
知识点回顾：
- 随机张量的生成：torch.randn函数
- 卷积和池化的计算公式（可以不掌握，会自动计算的）
- pytorch的广播机制：加法和乘法的广播机制
ps：numpy运算也有类似的广播机制，基本一致
作业：自己多借助ai举几个例子帮助自己理解即可
import torch
import torch.nn as nn# 生成输入张量 (批量大小, 通道数, 高度, 宽度)
input_tensor = torch.randn(1, 3, 32, 32) # 例如CIFAR-10图像
print(f"输入尺寸: {input_tensor.shape}") # 输出: [1, 3, 32, 32]# 定义卷积层
conv_layer = nn.Conv2d(in_channels=3, out_channels=64, kernel_size=3, stride=1, padding=1) # 示例参数
print(f"卷积层参数: {conv_layer}") # 输出: 卷积层的参数# 前向传播
output_tensor = conv_layer(input_tensor) # 卷积操作
print(f"卷积后尺寸: {output_tensor.shape}") # 输出: [1, 64, 32, 32]# 2. 池化层操作 (减小空间尺寸)
pool = nn.MaxPool2d(kernel_size=2, stride=2) # 创建一个最大池化层
pool_output = pool(output_tensor)
print(f"池化后尺寸: {pool_output.shape}") # 输出: [1, 64, 16, 16]# 3. 将多维张量展平为向量
flattened = pool_output.view(pool_output.size(0), -1)
print(f"展平后尺寸: {flattened.shape}") # 输出: [1, 64 * 16 * 16] = [1, 16384]# 4. 线性层操作
fc1 = nn.Linear(in_features=16384, # 输入特征数out_features=128 # 输出特征数
)
fc_output = fc1(flattened)
print(f"线性层后尺寸: {fc_output.shape}") # 输出: [1, 128]# 5. 再经过一个线性层（例如分类器）
fc2 = nn.Linear(128, 10) # 假设是10分类问题
final_output = fc2(fc_output)
print(f"最终输出尺寸: {final_output.shape}") # 输出: [1, 10]
print(final_output)# 使用Softmax替代Sigmoid
softmax = nn.Softmax(dim=1) # 在类别维度上进行Softmax
class_probs = softmax(final_output)
print(f"Softmax输出: {class_probs}") # 总和为1的概率分布
print(f"Softmax输出总和: {class_probs.sum():.4f}")输入尺寸: torch.Size([1, 3, 32, 32])
卷积层参数: Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
卷积后尺寸: torch.Size([1, 64, 32, 32])
池化后尺寸: torch.Size([1, 64, 16, 16])
展平后尺寸: torch.Size([1, 16384])
线性层后尺寸: torch.Size([1, 128])
最终输出尺寸: torch.Size([1, 10])
tensor([[-0.1682, -0.2191, 0.4092, 0.1416, 0.2290, 0.1882, 0.2205, -0.0307,0.1588, -0.5265]], grad_fn=<AddmmBackward0>)
Softmax输出: tensor([[0.0786, 0.0747, 0.1401, 0.1072, 0.1170, 0.1123, 0.1160, 0.0902, 0.1090,0.0549]], grad_fn=<SoftmaxBackward0>)
Softmax输出总和: 1.0000广播机制可以理解为：计算机帮你偷偷“复制粘贴”小数据，让不同形状的数组/张量能直接做运算。
比如你有两个“表格”（张量）要做加法，但它们的形状不一样。这时候广播机制会自动把小表格的数据“复制”成和大表格一样的形状，然后再相加。整个过程不需要你手动写循环或复制代码，计算机自己搞定。
举个生活中的例子：
假设你要把一杯糖水（1勺糖 + 100ml水）和一桶水（1000ml水）混合。广播机制就像：
- 发现糖水太少（形状小），自动把糖水“复制”10份（变成10勺糖 + 1000ml水），然后和一桶水混合。
技术上的条件（能广播的前提）：
两个张量的维度要“从后往前对齐”，要么尺寸相同，要么其中一个尺寸是1。例如：
- 形状
(3, 2)和(1, 2)：可以广播（第二个维度都是2，第一个维度一个是3，一个是1 → 把1扩展成3）。 - 形状
(3, 2)和(2, 3)：不能广播（维度对不齐）。
# 张量A：形状(3, 2)（3行2列）
A = torch.tensor([[1, 2], [3, 4], [5, 6]])# 张量B：形状(1, 2)（1行2列）
B = torch.tensor([[10, 20]])# 广播后，B会被“复制”成(3, 2)（3行2列，每行都是[10,20]）
# 然后A + B 等价于：
# [[1+10, 2+20],
# [3+10, 4+20],
# [5+10, 6+20]]
result = A + B
print(result) # 输出: [[11, 22], [13, 24], [15, 26]]好处：
不用手动写循环复制数据，代码更简洁。比如给一个大矩阵的每个元素加一个数（标量），广播机制会自动把标量“复制”到所有元素的位置，直接运算。
合法广播和非法广播是广播机制中的两种情况，核心区别是两个张量的形状是否满足广播规则：
合法广播：
如果两个张量的形状“从最后一个维度开始向前对齐”时，每个对应的维度满足以下任一条件：
- 两个维度尺寸相同（可以直接运算）；
- 其中一个维度尺寸为1（可以自动扩展成另一个维度的尺寸）。
此时计算机会自动帮你扩展小张量的形状，完成运算，这就是合法广播。
非法广播：
如果两个张量的形状在“从后往前对齐”时，存在某个对应的维度尺寸既不相同，也不为1，此时无法自动扩展，计算机会报错，这就是非法广播。
举个具体例子（用PyTorch张量）：
合法广播：
# 张量A：形状(3, 2)（3行2列）
A = torch.tensor([[1, 2], [3, 4], [5, 6]])# 张量B：形状(1, 2)（1行2列）
B = torch.tensor([[10, 20]]) # 最后一个维度是2（和A的最后一个维度相同），前一个维度是1（可以扩展）# 广播后B会被扩展成(3, 2)（每行都是[10,20]），然后相加
result = A + B # 合法！输出: [[11,22], [13,24], [15,26]]非法广播：
# 张量C：形状(3, 2)（3行2列）
C = torch.tensor([[1, 2], [3, 4], [5, 6]])# 张量D：形状(2, 3)（2行3列）
D = torch.tensor([[10, 20, 30], [40, 50, 60]]) # 最后一个维度是3（C的最后一个维度是2，不相等且不为1）result = C + D # 非法！会报错："shape mismatch"（形状不匹配）总结：
合法广播是“规则允许的形状匹配”，计算机会偷偷帮你扩展；非法广播是“形状完全对不上”，必须手动调整形状（比如用reshape）才能运算。
2.1加法的广播机制：
二维张量与一维向量相加
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]]])加法结果:
tensor([[[11, 21],[12, 22]],[[13, 23],[14, 24]]])二维张量与标量相加
# 创建原始张量
a = torch.tensor([[1, 2], [3, 4]]) # 形状: (2, 2)
b = 10 # 标量，形状视为 ()# 广播过程
# 1. b补全维度: () → (1, 1)
# 2. b扩展第一维: (1, 1) → (2, 1)
# 3. b扩展第二维: (2, 1) → (2, 2)
# 最终形状: (2, 2)result = a + b
print("原始张量a:")
print(a)
# 输出:
# tensor([[1, 2],
# [3, 4]])print("\n标量b:")
print(b)
# 输出: 10print("\n广播后b的值扩展:")
print(torch.tensor([[10, 10],[10, 10]])) # 实际内存中未复制，仅逻辑上扩展print("\n加法结果:")
print(result)
# 输出:
# tensor([[11, 12],
# [13, 14]])原始张量a:
tensor([[1, 2],[3, 4]])标量b:
10广播后b的值扩展:
tensor([[10, 10],[10, 10]])加法结果:
tensor([[11, 12],[13, 14]])高维张量与低维张量相加
# 创建原始张量
a = torch.tensor([[[1, 2], [3, 4]]]) # 形状: (1, 2, 2)
b = torch.tensor([[5, 6]]) # 形状: (1, 2)# 广播过程
# 1. b补全维度: (1, 2) → (1, 1, 2)
# 2. b扩展第二维: (1, 1, 2) → (1, 2, 2)
# 最终形状: (1, 2, 2)result = a + b
print("原始张量a:")
print(a)
# 输出:
# tensor([[[1, 2],
# [3, 4]]])print("\n原始张量b:")
print(b)
# 输出:
# tensor([[5, 6]])print("\n广播后b的值扩展:")
print(torch.tensor([[[5, 6],[5, 6]]])) # 实际内存中未复制，仅逻辑上扩展print("\n加法结果:")
print(result)
# 输出:
# tensor([[[6, 8],
# [8, 10]]])原始张量a:
tensor([[[1, 2],[3, 4]]])原始张量b:
tensor([[5, 6]])广播后b的值扩展:
tensor([[[5, 6],[5, 6]]])加法结果:
tensor([[[ 6, 8],[ 8, 10]]])关键总结：
- 尺寸变化：广播后的形状由各维度的最大值决定（示例2中最终形状为(2,2,2）)。
- 值扩展：维度为1的张量通过复制扩展值（示例1中b从[1,2,3]扩展为三行相同的值）。
- 内存效率：扩展是逻辑上的，实际未复制数据，避免了内存浪费。
2.2乘法的广播机制：
矩阵乘法(@)
的特殊规则
矩阵乘法除了遵循通用广播规则外，还需要满足矩阵乘法的维度约束：
最后两个维度必须满足：A.shape[-1]==B.shape[-2](即A的列数等于B的行数)
其他维度（批量维度）：遵循通用广播规则
批量矩阵与单个矩阵相乘
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形状: torch.Size([2, 3, 4])
B形状: torch.Size([4, 5])
结果形状: 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形状: torch.Size([3, 2, 4])
B形状: torch.Size([1, 4, 5])
结果形状: 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])A形状: torch.Size([2, 3, 4, 5])
B形状: torch.Size([5, 6])
结果形状: torch.Size([2, 3, 4, 6])@浙大疏锦行
)
