1. Tensor 是 PyTorch 的基本单位

PyTorch 里，模型吃进去的是 Tensor，参数保存的是 Tensor，梯度也是 Tensor，GPU 上跑的还是 Tensor。

你可以把 Tensor 理解成“加强版数组”。但这个说法不够准确。

普通数组只关心数值。Tensor 还关心这些数在哪里、怎么排、用什么精度、是否参与反向传播、由哪个后端执行。

官方 README 对 PyTorch 的核心定位很直接：它提供类似 NumPy 的 Tensor 计算，并且带强 GPU 加速；同时提供基于 autograd 的神经网络能力。

2. Tensor 的维度：别被高维吓住

Tensor 维度从标量、向量、矩阵到批量数据。

0 维 Tensor 是一个数。1 维 Tensor 是一排数。2 维 Tensor 像一张表。3 维、4 维 Tensor 就是很多张表叠起来。

图像分类里，常见输入是 [batch, channel, height, width]。文本模型里，常见输入是 [batch, sequence_length]。大模型里，Embedding 后会变成 [batch, sequence_length, hidden_size]。

import torch
x = torch.tensor([[1, 2, 3], [4, 5, 6]])
print(x.shape) # torch.Size([2, 3])
print(x.ndim) # 2
print(x.dtype) # torch.int64
print(x.device) # cpu

这段代码简单，但它暴露了 Tensor 的四个核心入口：shape、ndim、dtype、device。后面所有训练问题，很多都能回到这四个字段上排查。

3. Tensor 的本体：不是一个字段，而是一组元信息

Tensor 的核心组成：Storage、shape、stride、dtype、device、layout。

很多人以为 Tensor 本身就是一坨连续数据。其实更准确地说：Tensor 是一套“解释数据的规则”。

Storage 保存真实数据。shape 决定看成几行几列。stride 决定从一个元素走到下一个元素，要在底层内存里跳几步。dtype 决定每个数字占多大空间。device 决定这块数据放在 CPU、CUDA GPU 还是 MPS 后端。

所以，同一块 Storage，可以被不同的 shape 和 stride 解释成不同的 Tensor 视图。这个思想非常关键。它决定了 view、transpose、permute 为什么可以很快。

4. dtype 和 device：Tensor 的两张身份证

dtype 决定数值格式，device 决定计算设备。

dtype 管“一个数怎么存”。float32、float16、bfloat16、int64，本质都是数字格式。

device 管“这些数在哪算”。CPU 上的 Tensor 不能直接和 CUDA Tensor 混算。因为一个在主机内存，一个在显存。它们不是同一个地方。

x = torch.randn(2, 3, dtype=torch.float32, device='cpu')
# 有 NVIDIA GPU 时常见写法
# x = x.to('cuda')
# Apple Silicon 上常见写法
# x = x.to('mps')

训练大模型时，dtype 更敏感。float32 稳，但显存大。float16 和 bfloat16 更省显存，也更快，但要配合混合精度和数值稳定性策略。

5. Storage + Stride：Tensor 真正难懂的地方

Storage 是底层一维内存，Stride 决定多维坐标怎么映射到内存。

假设底层 Storage 是 [1, 2, 3, 4, 5, 6]。如果 shape 是 (2, 3)，stride 是 (3, 1)，它就被解释成两行三列。

访问第 i 行第 j 列时，PyTorch 不是真的去找“二维数组”。它会算一个内存偏移：offset = storage_offset + i * stride[0] + j * stride[1]。

这就是 Tensor 的强大之处：很多变形操作，不需要搬数据，只改元信息。

x = torch.arange(1, 7).reshape(2, 3)
print(x)
# tensor([[1, 2, 3],
# [4, 5, 6]])
print(x.stride()) # (3, 1)
y = x.t()
print(y.shape) # torch.Size([3, 2])
print(y.stride()) # (1, 3)
print(y.is_contiguous()) # False

transpose 之后，数据没有重新排列。只是读取顺序变了。所以它很快。但代价是：新 Tensor 可能不连续。

6. view、reshape、permute：看起来像一类，其实不一样

view 是“换一种看法”。它要求底层内存布局满足条件。满足就快，不满足就报错。

reshape 更温和。它会先尝试返回 view。实在不行，就复制一份连续内存。

permute 和 transpose 常常只改 stride，不搬数据。所以它们很快，但会让 Tensor 变成 non-contiguous。

contiguous 则相反。它会把数据重新整理成连续内存。可能慢，但后续算子更稳定。

x = torch.arange(12).reshape(3, 4)
y = x.t() # 转置后通常 non-contiguous
# y.view(12) # 可能报错
z = y.reshape(12) # 更安全，必要时会复制
z2 = y.contiguous().view(12)

7. Tensor 创建：不要只会 torch.tensor

PyTorch 创建 Tensor 的方式很多。每种方式都有明确场景。

torch.tensor 适合从 Python 数据创建新 Tensor。torch.zeros、torch.ones、torch.randn 适合快速初始化。torch.empty 只分配内存，不保证内容干净。from_numpy 可以和 NumPy 共享内存，要注意副作用。

a = torch.tensor([1, 2, 3]) # 从 Python 数据创建
b = torch.zeros(2, 3) # 全 0
c = torch.ones(2, 3) # 全 1
d = torch.randn(2, 3) # 正态分布随机数
e = torch.empty(2, 3) # 只分配，不初始化
# 推荐：跟随已有 Tensor 的 dtype 和 device
f = torch.zeros_like(d)
g = torch.randn_like(d)

工程里更推荐使用 zeros_like、ones_like、randn_like。它们能自动继承已有 Tensor 的 dtype 和 device，减少设备不一致问题。

8. 广播机制：小 Tensor 为什么能和大 Tensor 相加

广播不是复制一堆数据。广播是让小 Tensor 按规则“看起来像”大 Tensor。

例如，一个 [2, 3] 的矩阵加一个 [3] 的向量，PyTorch 会把 [3] 看成每一行都可用。

x = torch.tensor([[1, 2, 3], [4, 5, 6]])
bias = torch.tensor([10, 20, 30])
print(x + bias)
# tensor([[11, 22, 33],
# [14, 25, 36]])

广播让代码更短，也让计算更高效。但广播也容易隐藏 shape 问题。模型输出和标签维度不一致时，可能不会立刻报错，而是悄悄广播，最后 loss 变得很奇怪。

9. Tensor 在底层长什么样

在 Python 里，Tensor 看起来是一个 Python 对象。但 PyTorch 不是纯 Python 框架。关键数据结构和高性能算子主要在 C++ 层。

从源码角度看，Tensor 的核心不是 Python 这层壳，而是底层的 TensorImpl。TensorImpl 负责保存 Tensor 的核心元信息，例如 sizes、strides、dtype、device、layout、storage 等。

你可以把 TensorImpl 理解成 Tensor 的身份证。它不等于真实数据，也不等于计算本身。它告诉 PyTorch：这块数据如何被解释，应该走哪个后端。

// 简化理解，不是完整源码
class TensorImpl {
Storage storage_; // 数据存在哪里
SizesAndStrides sizes_; // shape 和 stride
TypeMeta dtype_; // 数据类型
Device device_; // cpu / cuda / mps
DispatchKeySet key_set_; // 该走哪个后端算子
};

真正执行加法、矩阵乘法、卷积时，PyTorch 会根据 dtype、device、layout、dispatch key 选择对应后端实现。CPU 走 CPU kernel，CUDA 走 CUDA kernel，MPS 走 MPS 后端。

这也是为什么 Tensor 的 device 不一致会报错：它们背后可能根本不是同一套执行后端。

10. Tensor 和自动求导的关系

Tensor 还可以带梯度关系。只要 requires_grad=True，PyTorch 就会在你做计算时记录操作，构建反向传播图。

x = torch.tensor(2.0, requires_grad=True)
y = x * x + 3 * x
y.backward()
print(x.grad) # tensor(7.)

这段代码里的 x 不只是一个数字。它还带着 requires_grad 标记。y 的计算过程会被 autograd 记录。调用 backward 后，梯度会回到 x.grad。

后面讲自动求导时，我们会深入 grad_fn、叶子节点、计算图、反向传播引擎。现在只需要记住：能求导，是 Tensor 的核心能力之一。

11. 新手最容易踩的坑

第一个坑：模型在 GPU，输入在 CPU。报错通常很长，但核心就一句：device 不一致。

第二个坑：标签 dtype 错。分类任务里的 CrossEntropyLoss 通常希望 target 是类别索引，也就是 long/int64。

第三个坑：transpose 后直接 view。因为 Tensor 可能已经 non-contiguous。

第四个坑：reshape 以为零成本。它不一定复制，但也不保证不复制。性能敏感时要小心。

第五个坑：对参与求导的 Tensor 乱用原地操作，例如 add_、relu_、copy_。原地操作可能破坏 autograd 需要的中间值。

12. 总结

Tensor 是 PyTorch 的第一块地基。学 PyTorch，不要先背 API。先理解 Tensor 的本质。

它不是数组。它是“数据 + 元信息 + 设备 + 内存视图 + 梯度能力”的组合体。

shape 决定外形。dtype 决定数值格式。device 决定计算位置。stride 决定如何读内存。storage 保存真实数据。requires_grad 决定是否进入自动求导。

理解这些，你再看 nn.Module、DataLoader、autograd、CUDA、分布式，就不会觉得它们是孤立模块。它们全都围绕 Tensor 运转。