1. 为什么我坚持用 PyTorch Tensor 而不是 NumPy 数组写模型？——一个从业五年、亲手调过 37 个工业级模型的工程师的坦白

你有没有在深夜调试模型时，突然卡在某个维度报错上，反复 print shape 却还是搞不清为什么 .view(-1, 256) 突然炸了？或者明明逻辑没错， loss.backward() 却提示 RuntimeError: element 0 of tensors does not require grad ，翻遍文档却找不到根源？又或者，在把训练好的模型部署到边缘设备前，发现 .cpu().numpy() 那一串转换像在走迷宫，中间还夹着 .detach() 和 .item() ，稍不注意就触发 RuntimeError: Can't call numpy() on Tensor that requires grad ？这些不是玄学，是每个真实写过 PyTorch 的人踩过的坑。而所有这些问题的根子，几乎都扎在 Tensor 这个最基础、却最容易被轻视的单元里。

我从 2019 年开始用 PyTorch 做第一个推荐系统模型，到现在带团队落地医疗影像分割、工业缺陷检测、多模态内容理解项目，Tensor 已经不是“数据容器”这么简单——它是整个计算图的骨架、自动微分的载体、GPU 内存管理的契约、跨设备协同的协议。它不像 NumPy 那样只管“算得对”，它还要管“谁算的”、“在哪算的”、“怎么反向传的”、“能不能复用内存”。比如，你用 torch.tensor([1,2,3]) 创建一个张量，默认是 CPU 上的、不可求导的；但 torch.randn(3,4) 默认却是可求导的；而 torch.as_tensor(np.array([1,2,3])) 又会共享底层内存——这三个看似一样的“创建”，背后的行为天差地别。这种差异不是设计缺陷，而是 PyTorch 把深度学习中每一个关键决策（是否跟踪梯度、是否共享内存、是否允许原地修改）都暴露给了你，让你在每一行代码里做选择。这正是它强大又容易出错的原因。这篇笔记，就是我把过去五年在真实项目里，从写第一行 import torch 到现在能一眼看出 .contiguous() 是否必要、 .requires_grad_() 是否漏设、 .to(device) 是否冗余的全部经验，掰开揉碎讲给你听。它不讲“什么是张量”，而是告诉你： 当你在写 model(x) 的那一刻，x 里的每一个字节，正在经历怎样的旅程？

2. Tensor 的本质：不只是多维数组，而是“计算契约”的具象化

2.1 从数学定义到工程实现：为什么“n 维数组”这个说法既对又危险？

教科书上说：“张量是 n 维数组”。这句话在数学上完全正确，在 NumPy 里也基本够用。但在 PyTorch 里，如果你只记住这一句，不出三天就会栽跟头。因为 PyTorch 的 Tensor 是一个 携带五重元信息的复合体 ，维度（shape）只是其中最表层的一层。真正决定它行为的，是以下五个核心属性，缺一不可：

1. data （数据指针） ：指向实际存储数值的内存块。这是最底层的“肉身”。
2. shape （形状） ：一个 tuple，描述各维度大小，如 (2, 3, 4) 。它决定了你能怎么索引、怎么广播。
3. dtype （数据类型） ： torch.float32 、 torch.int64 、 torch.bool 等。它不仅关乎精度，更直接绑定 GPU 计算单元的支持能力。比如， torch.float16 在 A100 上有 Tensor Core 加速，但 torch.bfloat16 在 V100 上就不被原生支持。
4. device （设备） ： 'cpu' 或 'cuda:0' 。它不是一个标签，而是一份 内存所有权声明 。 tensor.to('cuda') 不是“复制过去”，而是告诉 PyTorch：“这块内存，现在归 GPU 显存管理了，CPU 不能再碰”。
5. requires_grad （是否需要梯度） ：一个布尔值。它不是开关，而是一个 计算图注册指令 。一旦设为 True ，PyTorch 就会为这个 Tensor 构建一个 grad_fn ，并在 backward() 时自动追踪所有依赖它的操作。

提示：你可以随时用 print(tensor) 查看前四项，用 print(tensor.requires_grad) 单独看第五项。但千万别只看 print(tensor) 就下结论——它默认不显示 requires_grad ，这是新手掉进的第一个大坑。

举个真实例子：我在做语音增强模型时，输入是 torch.Size([1, 1, 16000]) 的波形，标签是同尺寸的干净波形。我错误地用了 label = torch.from_numpy(clean_wav) ，结果 label.requires_grad 是 False ，而模型输出 pred 是 True 。计算 loss = F.mse_loss(pred, label) 后， loss.backward() 居然成功了！但梯度根本没传回模型——因为 label 是常量， pred 对它的梯度是零，整个计算图被“截断”了。最后查了三小时，才发现 label 必须显式设为 label.requires_grad_(False) （明确声明不需要梯度），或者更稳妥地，用 label = torch.tensor(clean_wav, dtype=torch.float32, requires_grad=False) 。这个教训让我明白： requires_grad 不是“可有可无的选项”，而是你对计算图的 主动契约 。

2.2 “标量、向量、矩阵”只是特例：理解秩（Rank）与阶（Order）的工程意义

“0 阶张量是标量，1 阶是向量，2 阶是矩阵……”这个类比很形象，但容易让人忽略一个关键点： 在 PyTorch 中，“阶”（Order）和“维度数”（Number of Dimensions）是严格等价的，而“秩”（Rank）另有含义 。这里必须划清界限：

• ndim / dim() ：返回整数，表示张量有多少个轴（axis）。 torch.tensor(5).ndim 是 0， torch.tensor([1,2,3]).ndim 是 1， torch.tensor([[1,2],[3,4]]).ndim 是 2。这是你每天都要用的属性。
• rank() ：这是一个 线性代数概念 ，指矩阵的行秩或列秩（非零奇异值个数）。PyTorch 的 torch.linalg.matrix_rank() 才计算这个。 tensor.rank() 这个方法根本不存在！很多教程混淆了这两个词，导致读者误以为 tensor.ndim == tensor.rank() ，这是严重错误。

为什么这个区分重要？因为在写自定义 loss 时，你可能需要判断一个中间变量是否“退化”成了标量。比如，在对比学习中， sim_matrix = F.cosine_similarity(x.unsqueeze(1), x.unsqueeze(0), dim=2) 生成一个 (N, N) 矩阵，但如果 N==1 ，它就变成 (1,1) ，再 sim_matrix.mean() 就得到一个 0 维张量。这时 sim_matrix.ndim == 0 是你要检查的条件，而 sim_matrix.rank() 是毫无意义的。

2.3 为什么 PyTorch 不叫“PyTorch Arrays”？——从 tensor 到 autograd 的必然路径

NumPy 的 ndarray 是完美的数值计算容器，但它没有“历史”。当你执行 c = a + b ， c 只知道自己的值，不知道 a 和 b 是哪来的。而 PyTorch 的 tensor ，从诞生那一刻起，就带着一个隐形的 grad_fn （梯度函数）属性。这个设计不是为了炫技，而是为了解决深度学习最核心的工程问题： 如何让一个由成百上千次运算组成的复杂函数，自动、高效、内存友好的求导？

想象一个简单的线性层： y = W @ x + b 。在 NumPy 里，你要手动推导 dW = dy @ x.T ， dx = W.T @ dy ， db = dy.sum(0) 。而在 PyTorch 里，你只需要：

y = torch.matmul(W, x) + b
loss = y.sum()
loss.backward()

W.grad , x.grad , b.grad 就自动填好了。这背后，是 PyTorch 在 y 创建时，就记录了 y.grad_fn = <AddBackward0> ，而这个 AddBackward0 又持有了 W @ x 的 grad_fn = <MmBackward0> ，层层嵌套，构成一个动态的、可执行的计算图。这个图不是静态编译出来的，而是在每次前向传播时实时构建的。这就是为什么 tensor 必须是一个独立的数据结构——它要承载这个图的节点信息。把它叫 array ，就抹杀了它作为“自动微分引擎入口”的本质。

3. 创建 Tensor：五种方式背后的“意图”与陷阱

3.1 torch.tensor() ：最常用，也最容易埋雷的“万能钥匙”

torch.tensor(data, ...) 是新手最先接触的，但它绝不是“安全的默认选择”。它的行为高度依赖 data 的来源，且默认参数组合常常违背直觉：

• 从 Python list 创建 ： t = torch.tensor([1, 2, 3])

  • ✅ dtype 默认为 torch.int64 （64位整数）
  • ❌ requires_grad 默认为 False
  • ⚠️ device 默认为 cpu
  • 风险点 ：如果你后续想用它做可学习参数（比如 nn.Parameter(t) ），必须手动 t.requires_grad_(True) 。否则， Parameter 会静默接受，但梯度不会更新。

• 从 NumPy array 创建 ： t = torch.tensor(np.array([1.0, 2.0]))

  • ✅ dtype 会继承 NumPy 的 dtype （如 np.float64 → torch.float64 ）
  • ❌ 会拷贝数据 ！这意味着底层内存是全新的，与原 np.array 完全无关。
  • 对比 torch.as_tensor() ：后者 共享内存 ， t = torch.as_tensor(np_arr) ，修改 t 会同时改 np_arr 。这在数据预处理流水线中极有用（避免重复拷贝大图像），但也意味着你必须确保 np_arr 的生命周期长于 t ，否则会引发段错误。

• 从另一个 Tensor 创建 ： t2 = torch.tensor(t1)

  • ❌ 会丢失 requires_grad 和 grad_fn ！ t2.requires_grad 永远是 False ，即使 t1 是 True 。
  • ✅ 这是 PyTorch 的“安全隔离”机制，防止意外污染计算图。
  • 正确做法 ：如果想保留梯度信息，用 t2 = t1.clone().detach() （创建新副本，切断梯度链）或 t2 = t1.clone() （保留梯度链， t2 的变化会影响 t1 的梯度）。

实操心得：我在写一个在线学习模块时，需要把上一轮的 loss 值（一个标量 Tensor）作为下一轮的超参输入。我最初写了 hyperparam = torch.tensor(loss.item()) ，结果发现 hyperparam 是 CPU 上的、不可求导的，导致后续计算图断裂。后来改成 hyperparam = loss.detach().clone() ，完美解决问题。 loss.item() 只取 Python float，彻底脱离 PyTorch 生态；而 loss.detach().clone() 保留了 Tensor 的所有属性（除了 grad_fn ），是真正的“无缝衔接”。

3.2 torch.Tensor() ：一个被严重低估的“构造器”

torch.Tensor() 是 torch.tensor() 的“老大哥”，但它不是函数，而是 torch.FloatTensor 的别名。它的行为非常固定：

• t = torch.Tensor([1, 2, 3]) → 创建一个 torch.float32 的 Tensor， requires_grad=False 。
• t = torch.Tensor(2, 3) → 创建一个未初始化的 (2, 3) 张量（内存垃圾值！）。

关键区别 ： torch.Tensor() 永远不接受 dtype 参数 ，它只认 float32 。所以，如果你想创建 int64 或 bool 张量，必须用 torch.tensor() 或 torch.zeros(..., dtype=torch.int64) 。 torch.Tensor() 的唯一优势是：当你明确知道只要 float32 ，且想快速创建一个未初始化的 buffer（比如做 CUDA kernel 的临时空间），它比 torch.empty() 稍快一点点。但在绝大多数业务代码中，你应该 完全忘记 torch.Tensor() 的存在 ，统一用 torch.tensor() 或更语义化的工厂函数。

3.3 工厂函数： zeros , ones , full , empty —— 语义即安全

这些函数是创建“空白画布”的最佳实践，它们强制你思考 dtype 和 device ：

# ✅ 清晰、安全、高效
x = torch.zeros((32, 64), dtype=torch.float16, device='cuda:0')
mask = torch.ones((100,), dtype=torch.bool, device=x.device)
bias = torch.full((128,), fill_value=0.1, dtype=torch.float32)

# ❌ 模糊、低效、易错
x = torch.tensor(np.zeros((32, 64))) # 多了一次 numpy -> cpu -> cuda 的拷贝
mask = torch.tensor([True]*100)      # 创建了 int64，再转 bool，浪费内存

为什么 empty 是性能杀手锏？
torch.empty() 分配内存但不初始化，速度是 zeros() 的 3-5 倍。在循环中创建大量临时张量时（比如 RNN 的 hidden state 初始化），用 empty 可以显著提速。但必须确保你在使用前 一定 会写入有效值，否则读取未初始化内存会导致随机崩溃或 NaN。我在一个实时语音识别服务中，将 hidden = torch.zeros(...) 改为 hidden = torch.empty(...); hidden.zero_() ，端到端延迟降低了 12%。

3.4 torch.arange() , torch.linspace() , torch.logspace() ：序列生成的精确控制

这些函数的核心价值在于 可控的步长与边界 ，远超 range() ：

• torch.arange(start, end, step) ： end 是 排他性 的（不包含 end ）。 torch.arange(0, 5, 2) → [0, 2, 4] 。
• torch.linspace(start, end, steps) ： steps 是 精确的元素个数 ， end 是 包含的 。 torch.linspace(0, 4, 3) → [0., 2., 4.] 。
• torch.logspace(start, end, steps, base=10.0) ：在对数尺度上均匀采样。 torch.logspace(0, 2, 3) → [1., 10., 100.] 。

实操陷阱 ： arange 的 step 是浮点数时，由于精度问题， end 可能无法精确到达。例如 torch.arange(0, 1, 0.1) 本应有 10 个元素，但实际是 10 个（ [0., 0.1, ..., 0.9] ），而 torch.arange(0, 1.0000001, 0.1) 可能产生 11 个。此时， linspace 是更可靠的选择，因为它只关心起点、终点和数量。

3.5 torch.randn() , torch.randn_like() , torch.normal() ：随机性的工程化表达

深度学习离不开随机性，但“随机”必须是 可复现、可控制、符合分布 的：

• torch.randn(shape) ：标准正态分布 N(0,1) ， dtype=torch.float32 。
• torch.randn_like(input) ： 最推荐！ 它会完全复刻 input 的 shape , dtype , device , requires_grad 。在初始化网络权重时， w = torch.randn_like(layer.weight) 比 w = torch.randn(layer.weight.shape) 安全十倍，因为你不用手动同步所有属性。
• torch.normal(mean, std, size) ：可以指定均值和标准差。 torch.normal(0, 0.02, size=(100,)) 。

高级技巧：Kaiming 初始化的 PyTorch 原生实现
PyTorch 的 nn.init.kaiming_normal_() 底层就是 torch.normal() 的封装。你可以自己写：

def kaiming_init(tensor, a=0, mode='fan_in', nonlinearity='leaky_relu'):
    fan = nn.init._calculate_correct_fan(tensor, mode)
    gain = nn.init.calculate_gain(nonlinearity, a)
    std = gain / math.sqrt(fan)
    with torch.no_grad():
        return tensor.normal_(0, std)

这让你彻底理解为什么 ReLU 层的权重要用 std=√2/√fan_in ，而不是 std=0.01 。

4. 检索与查询：读懂 Tensor 的“身份证”，而非只看数值

4.1 shape , size() , ndim , numel() ：维度信息的四重奏

这四个属性看似重复，实则各有不可替代的用途：

属性	返回值	典型用途	是否可修改
tensor.shape	torch.Size 对象	索引、reshape、broadcasting 判断	❌ (只读)
tensor.size(dim)	int	获取某一个维度的大小，如 batch_size = x.size(0)	❌
tensor.ndim	int	快速判断张量阶数，如 if x.ndim == 0: scalar_op(x)	❌
tensor.numel()	int	计算总元素数，用于 view(-1) 或内存估算， x.numel() == x.shape.numel()	❌

为什么 shape 是 torch.Size 而不是 tuple？
因为 torch.Size 重载了 + 和 * 运算符，方便维度拼接：

a = torch.Size([2, 3])
b = torch.Size([4])
c = a + b  # torch.Size([2, 3, 4])
d = a * 2  # torch.Size([2, 3, 2, 3])

这在写通用 reshape 函数时非常优雅。

4.2 dtype , device , is_cuda , is_leaf ：硬件与计算图的“护照信息”

• tensor.dtype ：必须和你的计算目标匹配。混合 float16 和 float32 会触发隐式转换，带来额外开销和精度损失。在 AMP（自动混合精度）训练中， torch.cuda.amp.autocast 会帮你管理，但你仍需确保输入数据是 float16 。
• tensor.device ： tensor.to(device) 是最安全的迁移方式。 tensor.cuda() 是快捷方式，但已弃用，且不支持指定 cuda:1 。
• tensor.is_cuda ：一个布尔值，比 tensor.device.type == 'cuda' 更快，但语义较弱。
• tensor.is_leaf ： 这是理解计算图的关键！ 一个 Tensor 是 leaf，当且仅当它 不是任何其他 Tensor 的运算结果 ，即它是由 torch.tensor() , torch.zeros() 等创建的，而非 y = x + 1 。Leaf Tensor 通常是你的模型参数或输入数据。 is_leaf=True 的 Tensor，其 grad_fn 为 None ，但可以有 grad 。

注意： tensor.requires_grad=True 并不意味着 is_leaf=True 。 x = torch.tensor([1.], requires_grad=True) 是 leaf； y = x * 2 不是 leaf， y.is_leaf=False ， y.grad_fn=<MulBackward0> 。

4.3 data , grad , grad_fn ：计算图的“神经脉络”

• tensor.data ： 极其危险！ 它返回一个与 tensor 共享内存、但 requires_grad=False 的新 Tensor。 tensor.data += 1 会绕过计算图，直接修改原始值，导致梯度计算错误。官方文档明确警告： data 是为高级用户准备的，99% 的场景应该用 tensor.detach() 。
• tensor.grad ：存储反向传播后计算出的梯度。它只在 tensor.requires_grad=True 且执行过 backward() 后才不为 None 。 重要： grad 是累加的！ 连续调用两次 loss.backward() ， param.grad 会是两次梯度之和。所以训练循环中必须 optimizer.zero_grad() 。
• tensor.grad_fn ：计算图的“源头”。 <AddBackward0> 表示这个 Tensor 是由加法产生的。你可以用 tensor.grad_fn.next_functions 遍历整个图，但这通常只在调试复杂自定义 backward 时才需要。

4.4 is_contiguous() , stride() , storage() ：内存布局的“底层真相”

这是区分 PyTorch 高手与新手的分水岭。 contiguous 不是指“内存连续”，而是指 Tensor 的 逻辑形状（shape）与其底层存储（storage）的物理顺序是否一致 。

• tensor.is_contiguous() ：返回 True 表示当前 shape 下，内存是按行主序（C-order）连续存储的。
• tensor.stride() ：返回一个 tuple，表示在每个维度上移动一个单位，需要跨越多少个元素。例如，一个 (2,3) 的 contiguous Tensor， stride=(3,1) （第一维跳 3 个，第二维跳 1 个）。
• tensor.storage() ：返回底层的一维内存块。

为什么 view() 有时失败？
view() 要求 Tensor 是 contiguous 的。 transpose() , narrow() , expand() 等操作会改变 stride ，使其 non-contiguous，但不改变 storage 。此时 view() 会报错。解决方案是先 contiguous() ：

x = torch.randn(2, 3, 4)
y = x.transpose(0, 1)  # shape=(3,2,4), stride=(4,12,1), is_contiguous=False
z = y.view(-1)         # RuntimeError!
z = y.contiguous().view(-1)  # Success! contiguous() creates a new storage with correct order.

性能真相 ： contiguous() 是一个深拷贝操作，开销很大。在循环中频繁调用会成为瓶颈。我的经验是： 在数据加载器（DataLoader）的 collate_fn 中，对 batch 做一次 contiguous() ；之后的所有操作，尽量用 permute() , narrow() 等不破坏 contiguous 的操作，或者用 as_strided() （高级 API）来避免拷贝。

5. 操控 Tensor：从索引切片到高级广播，每一步都是内存博弈

5.1 索引与切片：Python 语法糖下的 C++ 内存操作

PyTorch 的索引 ( [] ) 是一个功能极其强大的接口，它背后是 torch.Tensor.__getitem__() 的完整实现：

• 基本索引 ： x[0] , x[:, 1] , x[1:3, :] 。这些操作 总是返回一个视图（view） ，共享底层 storage ，零拷贝。
• 高级索引 ： x[[0,2,1]] , x[x > 0] 。这些操作 总是返回一个副本（copy） ，创建新的 storage 。
• 混合索引 ： x[[0,2], 1:] 。规则是：如果索引中 有任何一个列表或 Tensor，则整个操作是高级索引，返回副本 。

致命陷阱 ： x[0][1] 和 x[0, 1] 看似一样，但前者是两次基本索引（返回 view），后者是一次基本索引（也返回 view），性能几乎无差别。但 x[[0,1]][[0,1]] 是两次高级索引，会创建两个副本，而 x[[0,1], [0,1]] 是一次高级索引，只创建一个副本。

实操优化 ：在图像处理中，我需要从一个 (B, C, H, W) 的 batch 中，提取每个样本的中心 (32,32) 区域。错误写法：

# ❌ 两次高级索引，创建 B 个副本
patches = []
for i in range(B):
    patch = x[i, :, H//2-16:H//2+16, W//2-16:W//2+16]
    patches.append(patch)
patches = torch.stack(patches)

正确写法：

# ✅ 一次基本索引，零拷贝
h_start, h_end = H//2-16, H//2+16
w_start, w_end = W//2-16, W//2+16
patches = x[:, :, h_start:h_end, w_start:w_end]  # shape (B, C, 32, 32)

5.2 view() , reshape() , flatten() , squeeze() , unsqueeze() ：形状变换的哲学

• view() ：要求 Tensor 是 contiguous 的，否则报错。它是 reshape() 的“严格模式”。
• reshape() ：更智能，如果可能，它会尝试在不拷贝的情况下改变形状；如果不行，它会自动调用 contiguous() 。 日常开发中，无脑用 reshape() 即可。
• flatten(start_dim=0, end_dim=-1) ：将指定范围内的所有维度压平成一个。 x.flatten(1) 是 x.view(x.size(0), -1) 的安全版。
• squeeze() / unsqueeze() ：移除/添加长度为 1 的维度。 x.squeeze(0) 移除第 0 维（如果该维大小为 1）； x.unsqueeze(-1) 在末尾加一维。

为什么 unsqueeze(0) 比 view(1, -1) 更好？
unsqueeze() 是一个“无操作”（no-op），它不改变 storage ，只改变 shape 和 stride 。 view(1, -1) 则要求 contiguous。在 x 是 non-contiguous 时， unsqueeze() 依然成功，而 view() 会失败。

5.3 广播（Broadcasting）：PyTorch 最优雅的“自动对齐”机制

广播是 PyTorch（和 NumPy）最强大的特性之一，它让 (3,1) 和 (1,4) 的张量可以相加，得到 (3,4) 。规则只有两条：

1. 对齐右缘 ：从最右边的维度开始，逐个比较。
2. 兼容条件 ：两个维度大小相等，或其中一个为 1。

经典案例 ：BatchNorm 的 running_mean 是 (C,) ，而 x 是 (N, C, H, W) 。广播时， C 维对齐， N , H , W 维大小为 1，因此 x - running_mean 是合法的。

陷阱预警 ：广播是隐式的，它不分配新内存，但会增加计算开销。 x + y 如果 y 需要广播，PyTorch 会在计算时“虚拟展开” y ，这比 x + y.expand_as(x) 稍慢，因为后者是显式展开，可以复用。但在绝大多数情况下，广播的简洁性远胜于这点微小的性能差异。

5.4 cat() , stack() , chunk() , split() ：拼接与分割的艺术

• torch.cat(tensors, dim) ：沿指定维度 连接 （concatenate）多个张量。 cat([a,b], dim=0) 要求 a.shape[1:] == b.shape[1:] 。
• torch.stack(tensors, dim) ：沿新维度 堆叠 （stack）多个张量。 stack([a,b], dim=0) 要求 a.shape == b.shape ，结果是 (2,) + a.shape 。
• torch.chunk(tensor, chunks, dim) ：将 tensor 沿 dim 维 平均切 成 chunks 份，返回一个 tuple。
• torch.split(tensor, split_size_or_sections, dim) ：更灵活的切分， split_size_or_sections 可以是 int （每份大小）或 list （每份大小列表）。

工业级技巧：在分布式训练中， cat() 是 AllGather 的基石
torch.distributed.all_gather_into_tensor() 的输出是一个大 Tensor，你需要用 torch.chunk() 将其按 rank 切分。而 torch.cat() 则常用于将不同 head 的 attention 输出拼接起来。记住： cat() 是“缝合”， stack() 是“摞叠”，选错一个，模型就废了。

6. 矩阵乘法：从 @ 到 bmm() ，深度学习的“心脏手术”

6.1 @ 运算符：Python 3.5+ 的革命性语法糖

a @ b 等价于 torch.matmul(a, b) 。它不是简单的 torch.mm() ，而是 智能的、支持广播的、高维的矩阵乘法 ：

• 2D @ 2D → mm() ，标准矩阵乘。
• 1D @ 2D → mv() ，向量-矩阵乘。
• 2D @ 1D → mv() ，矩阵-向量乘。
• ND @ ND （N>2）→ bmm() ，批量矩阵乘，支持广播。

为什么 @ 比 mm() 更安全？
torch.mm(a, b) 要求 a 和 b 都是 2D 的。如果你不小心传入了一个 (1, 32) 的 a ，它会报错。而 a @ b 会自动处理， a 被当作 (1, 32) ， b 是 (32, 64) ，结果是 (1, 64) 。在写通用 layer 时， @ 让你无需写一堆 if ndim == 2 的判断。

6.2 torch.matmul() ： @ 的显式兄弟，控制力更强

torch.matmul() 的签名是 matmul(input, other, *, out=None) 。它比 @ 多一个 out 参数，允许你指定输出 Tensor，实现 零内存分配 的原地计算：

# ❌ 每次都分配新内存
result = a @ b

# ✅ 复用 pre-allocated memory
result = torch.empty(a.size(0), b.size(1), device=a.device, dtype=a.dtype)
torch.matmul(a, b, out=result)

这在高频计算的推理引擎中至关重要。我曾在一个边缘设备上，将 @ 替换为 matmul(..., out=buffer) ，内存峰值下降了 40%，避免了频繁的 GC 停顿。

6.3 torch.bmm() ：批量矩阵乘的“精准制导”

bmm(batch1, batch2) 要求 batch1 和 batch2 都是 3D 的，且 batch1.size(0) == batch2.size(0) （batch size 相同）， batch1.size(2) == batch2.size(1) （内维匹配）。它对每个 batch slice 独立执行 mm() 。

为什么不用 matmul() ？
matmul() 对 3D 输入也会广播，但 bmm() 的语义更清晰，且在某些硬件上（如 NVIDIA 的 cuBLAS）有专门的优化内核，性能略高 5-10%。在 Transformer 的 q @ k.T 中， q 和 k 都是 (B, S, D) ， q @ k.transpose(-2,-1) 是 (B, S, S) ，这本质上就是 bmm(q, k.transpose(-2,-1)) 。用 bmm() 能让代码意图一目了然。

6.4 torch.einsum() ：爱因斯坦求和，张量操作的“终极瑞士军刀”

einsum 是一个声明式 API，用字符串描述运算。 "ij,jk->ik" 表示 A @ B 。它的威力在于 统一表达所有线性代数运算 ：

• "i,i->" ：点积（dot product）
• "ij->i" ：行求和（row sum）
• "ijk,ik->ij" ： torch.bmm() 的变体
• "bhqk,bhkd->bqhd" ：Transformer 中的 q @ k.T @ v （scaled dot-product attention）

为什么 einsum 是高级玩家的标志？

1. 可读性 ： "bqhd,bqhd->bhq" 比 torch.einsum('bqhd,bqhd->bhq', q, k) 更直观地表达了“对 q 和 k 的 q 和 h 维求和”。
2. 优化潜力 ：PyTorch 的 einsum