张量、矢量、矩阵傻傻分不清？一张图带你理清它们的关系与在PyTorch中的区别

金七言

254人浏览 · 2026-06-03 16:57:37

金七言 · 2026-06-03 16:57:37 发布

从零理解张量：PyTorch实践中的维度思维革命

在深度学习的世界里，张量（Tensor）就像空气一样无处不在却又容易被忽视。当我第一次看到PyTorch代码中那些神秘的 torch.Tensor 对象时，脑海中浮现的是一堆问号：这到底是数学概念还是编程术语？为什么简单的数字在不同场景下要被称为0阶、1阶张量？本文将用全新的维度视角，带你彻底理解张量本质，并通过PyTorch实战演示如何驾驭这个深度学习的基础数据结构。

1. 维度认知：从标量到张量的思维跃迁

张量本质上是多维数组的统一抽象 ，这种抽象的美妙之处在于它统一了各种常见数据形式的表示方式。想象你正在整理衣柜：

标量（0阶张量） ：就像统计袜子数量时说的"我有5双袜子"，这个数字5就是一个标量，它只有大小没有方向。在PyTorch中，我们这样创建标量：

import torch
temperature = torch.tensor(25.3)  # 表示室温25.3度的标量

向量（1阶张量） ：当你记录每周每天穿的衣服件数时，就形成了一个向量，比如 [2, 3, 1, 4, 2, 3, 1] 。PyTorch中的向量操作：

weekly_clothes = torch.tensor([2, 3, 1, 4, 2, 3, 1])  # 周一到周日的穿衣件数

矩阵（2阶张量） ：扩展到记录一个月四周的穿衣数据，就形成了4×7的矩阵。在PyTorch中：

monthly_clothes = torch.tensor([
    [2, 3, 1, 4, 2, 3, 1],  # 第一周
    [1, 2, 2, 3, 1, 2, 2],  # 第二周
    [3, 1, 2, 2, 3, 1, 2],  # 第三周
    [2, 3, 1, 4, 2, 3, 1]   # 第四周
])

高阶张量 ：当我们要处理彩色图片时，就需要3阶张量。例如224×224像素的RGB图片可以表示为224×224×3的张量，其中3代表颜色通道。PyTorch中图像张量的典型形状是(通道, 高度, 宽度)：

image_tensor = torch.randn(3, 224, 224)  # 随机生成一个彩色图像张量

关键理解：张量的"阶"(order)或"秩"(rank)指的是需要的索引数量。标量不需要索引(rank=0)，向量需要1个索引(rank=1)，矩阵需要2个索引(rank=2)，以此类推。

2. PyTorch张量核心操作解析

PyTorch张量不仅仅是存储容器，它们还支持丰富的数学运算和自动微分功能，这是深度学习模型的基础。

2.1 张量创建与属性查看

创建张量有多种方式，每种方式对应不同的使用场景：

# 从Python列表创建
data_tensor = torch.tensor([[1, 2], [3, 4]])

# 创建全零张量（常用于初始化）
zeros_tensor = torch.zeros(2, 3)  # 2行3列的零矩阵

# 创建随机张量（权重初始化常用）
random_tensor = torch.rand(2, 2)  # 均匀分布
normal_tensor = torch.randn(2, 2) # 正态分布

# 查看张量属性
print(f"形状: {normal_tensor.shape}")  # 输出torch.Size([2, 2])
print(f"数据类型: {normal_tensor.dtype}")  # 输出torch.float32
print(f"存储设备: {normal_tensor.device}")  # 输出cpu或cuda:0

2.2 张量运算：从基础到广播机制

张量运算可以分为元素级运算和矩阵运算两大类：

元素级运算 （逐元素操作）：

a = torch.tensor([1, 2, 3])
b = torch.tensor([4, 5, 6])

# 加法
c = a + b  # tensor([5, 7, 9])
# 等价于
c = torch.add(a, b)

# 乘法（元素级）
d = a * b  # tensor([4, 10, 18])

矩阵乘法 ：

mat_a = torch.tensor([[1, 2], [3, 4]])
mat_b = torch.tensor([[5, 6], [7, 8]])

# 矩阵乘法
mat_c = torch.matmul(mat_a, mat_b)  # tensor([[19, 22], [43, 50]])
# 等价于
mat_c = mat_a @ mat_b

广播机制 是PyTorch中强大的特性，它允许不同形状的张量进行运算：

# 标量与张量运算
scalar = 2
tensor = torch.ones(2, 2)
result = scalar * tensor  # tensor([[2., 2.], [2., 2.]])

# 不同形状张量运算
a = torch.ones(3, 1)  # 3行1列
b = torch.ones(1, 3)  # 1行3列
c = a + b  # 结果形状为(3,3)

2.3 张量变形与维度操作

改变张量形状是预处理和网络层连接时的常见操作：

original = torch.arange(6)  # tensor([0, 1, 2, 3, 4, 5])

# 改变形状
reshaped = original.reshape(2, 3)  # tensor([[0, 1, 2], [3, 4, 5]])

# 转置操作
transposed = reshaped.T  # tensor([[0, 3], [1, 4], [2, 5]])

# 增加/减少维度
unsqueezed = original.unsqueeze(0)  # 在第0维增加维度，shape变为(1,6)
squeezed = unsqueezed.squeeze()  # 移除所有长度为1的维度，恢复为(6,)

3. 张量在深度学习中的实际应用模式

理解张量在深度学习流水线中的流动方式，是构建有效模型的关键。让我们通过一个完整的图像分类流程来看张量的维度变化。

3.1 数据加载与批处理

现代深度学习通常采用小批量(mini-batch)训练方式，这直接影响我们的张量形状设计：

# 假设我们有一批32张224×224的RGB图像
batch_size = 32
channels = 3
height = width = 224

# 创建模拟图像批次（实际中来自DataLoader）
image_batch = torch.randn(batch_size, channels, height, width)
print(image_batch.shape)  # 输出: torch.Size([32, 3, 224, 224])

PyTorch的 DataLoader 会自动将单个样本组合成批次张量。理解这个维度顺序(批量,通道,高,宽)对于避免后续层形状错误至关重要。

3.2 卷积神经网络中的张量流动

让我们跟踪张量通过一个简单CNN时的形状变化：

import torch.nn as nn

# 定义简单CNN
model = nn.Sequential(
    nn.Conv2d(3, 16, kernel_size=3, stride=1, padding=1),  # 输入3通道，输出16通道
    nn.ReLU(),
    nn.MaxPool2d(2),  # 下采样
    nn.Flatten(),     # 展平为向量
    nn.Linear(16 * 112 * 112, 10)  # 全连接层输出10类
)

# 前向传播
output = model(image_batch)
print(output.shape)  # 输出: torch.Size([32, 10])

各层张量形状变化如下表所示：

网络层	输入形状	输出形状	关键参数
输入图像	[32,3,224,224]	-	-
Conv2d	[32,3,224,224]	[32,16,224,224]	16个3×3滤波器
MaxPool2d	[32,16,224,224]	[32,16,112,112]	2×2池化
Flatten	[32,16,112,112]	[32,16 112 112]	-
Linear	[32,200704]	[32,10]	输出10类

3.3 张量内存视图与性能优化

PyTorch张量的一个强大特性是内存视图机制，它允许多个张量共享同一存储，从而高效执行各种操作：

original = torch.arange(10)  # 内存中存储[0,1,2,...,9]
view1 = original[::2]  # tensor([0, 2, 4, 6, 8]), 不复制数据
view2 = original.view(2, 5)  # tensor([[0,1,2,3,4], [5,6,7,8,9]]), 不复制

# 修改视图会影响原始张量
view2[0, 0] = 100
print(original)  # tensor([100, 1, 2, 3, 4, 5, 6, 7, 8, 9])

注意： view() 要求张量在内存中是连续的，否则需要先调用 contiguous() 。而 reshape() 会自动处理连续性问题，但可能产生隐式拷贝。

4. 张量高级技巧与常见陷阱

4.1 自动微分与梯度积累

PyTorch的张量可以记录计算历史并自动计算梯度，这是其核心特性之一：

x = torch.tensor(2.0, requires_grad=True)
y = x ** 2 + 3 * x + 1
y.backward()  # 计算梯度
print(x.grad)  # 输出: 7.0 (因为dy/dx=2x+3, x=2时为7)

在训练循环中，我们通常需要：

optimizer.zero_grad()  # 清除旧梯度
loss.backward()        # 计算新梯度
optimizer.step()       # 更新参数

忘记 zero_grad() 会导致梯度积累，这是初学者常见错误。

4.2 设备转移与并行计算

现代深度学习常使用GPU加速，张量设备管理很重要：

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# 创建时指定设备
tensor_on_gpu = torch.randn(3, 3, device=device)

# 转移现有张量
cpu_tensor = torch.ones(2, 2)
gpu_tensor = cpu_tensor.to(device)  # 转移到GPU

# 注意：不同设备的张量不能直接运算
try:
    cpu_tensor + gpu_tensor  # 会引发RuntimeError
except RuntimeError as e:
    print(f"错误: {e}")

4.3 常见形状问题与调试技巧

形状不匹配是深度学习中最常见的错误来源之一。以下是一些调试技巧：

# 1. 使用assert检查形状
assert tensor.shape == expected_shape, f"期望{expected_shape}但得到{tensor.shape}"

# 2. 在关键位置打印形状
print(f"卷积层输入形状: {x.shape}")

# 3. 使用einsum进行复杂操作验证
# 例如矩阵乘法验证：
A = torch.randn(3, 4)
B = torch.randn(4, 5)
C1 = A @ B
C2 = torch.einsum("ij,jk->ik", A, B)  # 更明确的维度说明
print(torch.allclose(C1, C2))  # 应为True