PyTorch张量基础与GPU加速深度学习实践

1. PyTorch张量（Tensor）基础概念解析

张量（Tensor）是PyTorch中最基本的数据结构，也是深度学习框架的核心组件。简单来说，张量就是多维数组的扩展形式，可以看作是Numpy数组的升级版，但具有GPU加速和自动求导等额外功能。

在PyTorch中，张量不仅仅是一个数据容器，它还承载着深度学习模型中的各种运算和梯度传播功能。我们可以将张量理解为：

• 0维张量：标量（如单个数字5）
• 1维张量：向量（如[1,2,3]）
• 2维张量：矩阵（如[[1,2],[3,4]]）
• 3维及以上：高阶张量（如图像数据通常是3维的）

张量的核心属性包括：

• dtype：数据类型（如torch.float32）
• shape：维度大小（如(3,224,224)表示3通道224x224图像）
• device：存储位置（CPU或GPU）
• requires_grad：是否计算梯度

实际经验：在创建张量时，明确指定dtype和device可以避免很多后续问题。特别是在混合精度训练时，数据类型不一致会导致难以排查的错误。

1.1 张量与Numpy数组的异同

虽然PyTorch张量与Numpy数组在概念上非常相似，但它们有几个关键区别：

1. 硬件加速：PyTorch张量可以在GPU上运行，而Numpy数组只能在CPU上运行。这使得PyTorch张量在大规模矩阵运算中具有显著优势。

2. 自动微分：PyTorch张量支持自动微分（autograd），这是深度学习模型训练的核心功能。Numpy数组没有这个功能。

3. 广播机制：两者都支持广播（broadcasting），但PyTorch的实现更严格，有时会报错而Numpy不会。

4. 内存共享：PyTorch张量和Numpy数组可以互相转换且共享内存，但需要注意同步问题。

python复制import torch
import numpy as np

# Numpy数组转PyTorch张量
np_array = np.array([1,2,3])
torch_tensor = torch.from_numpy(np_array)  # 共享内存

# PyTorch张量转Numpy数组
torch_tensor = torch.tensor([1,2,3])
np_array = torch_tensor.numpy()  # 共享内存

避坑提示：当张量在GPU上时，直接调用.numpy()会报错，需要先.cpu()移动到内存。这是初学者常犯的错误。

2. PyTorch张量的创建与基本操作

2.1 张量的创建方式

PyTorch提供了多种创建张量的方法，适用于不同场景：

1. 从Python列表创建：

python复制# 直接从列表创建
t1 = torch.tensor([1,2,3])  
t2 = torch.FloatTensor([[1,2],[3,4]])  # 明确指定类型

# 注意：torch.tensor()会复制数据，而torch.Tensor()是构造函数

2. 初始化特定形状的张量：

python复制# 全零张量
zeros = torch.zeros(2, 3)  # 2行3列的全零矩阵

# 全一张量
ones = torch.ones(2, 3, dtype=torch.float16)  # 指定数据类型

# 单位矩阵
eye = torch.eye(3)  # 3x3单位矩阵

# 随机张量
rand = torch.rand(2, 2)  # 均匀分布
randn = torch.randn(2, 2)  # 标准正态分布

3. 从已有张量创建：

python复制# 保持相同属性
new_tensor = torch.rand_like(ones)  # 形状和dtype与ones相同

# 改变数据类型
int_tensor = torch.randint(0, 10, (3,3))  # 0-10的随机整数

4. 特殊序列张量：

python复制# 等差数列
arange = torch.arange(0, 10, 2)  # 0,2,4,6,8

# 线性间隔
linspace = torch.linspace(0, 1, 5)  # 0到1之间等分5个数

2.2 张量的基本操作

张量支持丰富的数学运算和操作：

1. 算术运算：

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

# 逐元素运算
add = a + b  # 或torch.add(a,b)
sub = a - b
mul = a * b  # 逐元素乘
div = a / b

# 矩阵乘法
mat_a = torch.randn(2,3)
mat_b = torch.randn(3,4)
matmul = torch.matmul(mat_a, mat_b)  # 或使用@运算符

2. 索引和切片：

python复制t = torch.rand(4,3)

# 类似Numpy的索引
first_row = t[0]  # 第一行
first_col = t[:,0]  # 第一列
sub_tensor = t[1:3,0:2]  # 1-2行，0-1列

# 高级索引
mask = t > 0.5
selected = t[mask]  # 选择大于0.5的元素

3. 形状操作：

python复制t = torch.rand(2,3)

# 改变形状（不改变数据）
reshaped = t.reshape(3,2)  # 或.view(3,2)

# 转置
transposed = t.T  # 或.t()

# 增加/减少维度
unsqueezed = t.unsqueeze(0)  # 在第0维增加1维
squeezed = unsqueezed.squeeze(0)  # 去除第0维的1维

实操技巧：view()和reshape()功能相似，但view()要求内存连续，否则会报错。当不确定时，优先使用reshape()。

3. PyTorch张量的高级特性

3.1 GPU加速与设备管理

PyTorch张量可以在CPU和GPU之间移动，利用GPU的并行计算能力加速运算：

python复制# 检查GPU是否可用
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# 创建时指定设备
tensor_gpu = torch.rand(2,3, device=device)

# 在设备间移动
tensor_cpu = tensor_gpu.cpu()
tensor_gpu = tensor_cpu.to(device)  # 更通用的方式

# 多GPU情况
if torch.cuda.device_count() > 1:
    tensor_gpu = tensor_gpu.cuda(1)  # 使用第二个GPU

常见问题：当GPU显存不足时，PyTorch会抛出CUDA out of memory错误。解决方案包括减小batch size、使用梯度累积或混合精度训练。

3.2 自动微分与梯度计算

PyTorch的自动微分系统（autograd）是它的核心特性之一：

python复制# 需要计算梯度的张量
x = torch.tensor(2.0, requires_grad=True)
y = x ** 2 + 3 * x + 1

# 计算梯度
y.backward()  # 自动计算dy/dx
print(x.grad)  # 输出梯度值：2*2 + 3 = 7

实际训练中的典型流程：

python复制# 1. 前向传播
inputs = torch.randn(1,10)
weights = torch.randn(10,1, requires_grad=True)
bias = torch.randn(1, requires_grad=True)
outputs = torch.matmul(inputs, weights) + bias

# 2. 计算损失
target = torch.randn(1)
loss = (outputs - target).pow(2).mean()

# 3. 反向传播
loss.backward()

# 4. 查看梯度
print(weights.grad)
print(bias.grad)

注意事项：在训练循环中，每次反向传播前需要手动清零梯度，否则梯度会累积。这是初学者常犯的错误。

3.3 张量的广播机制

PyTorch支持广播（broadcasting），允许不同形状的张量进行运算：

python复制# 标量与张量
t = torch.ones(2,3)
result = t + 1  # 标量1被广播为与t相同形状

# 不同形状张量
a = torch.ones(2,1)
b = torch.ones(3)
result = a + b  # 结果为(2,3)张量

广播规则：

1. 从最后一个维度开始向前比较
2. 维度大小相同或其中一个为1时可以广播
3. 缺失的维度被视为1

调试技巧：当广播不符合预期时，可以使用.expand()或.unsqueeze()手动调整形状。

4. PyTorch张量的内存管理与优化

4.1 内存共享与复制

理解PyTorch张量的内存行为对性能优化至关重要：

python复制a = torch.tensor([1,2,3])
b = a  # 引用同一个内存
c = a.clone()  # 创建新的内存副本
d = a.detach()  # 共享数据但脱离计算图

# 修改a会影响b和d，但不会影响c
a[0] = 10
print(b)  # tensor([10,2,3])
print(d)  # tensor([10,2,3])
print(c)  # tensor([1,2,3])

内存共享场景：

• 切片操作共享内存
• 某些变形操作（如view）共享内存
• detach()后的张量与原张量共享数据

4.2 原地操作与性能优化

原地操作可以节省内存但需要谨慎使用：

python复制t = torch.rand(2,3)

# 非原地操作（创建新张量）
t_new = t + 1  # 新内存分配

# 原地操作（修改原张量）
t.add_(1)  # 下划线表示原地操作
t += 1  # 等价于原地操作

性能建议：在内存受限的情况下（如大模型训练），合理使用原地操作可以减少内存占用，但要注意不要意外修改需要保留的数据。

4.3 张量的连续性与高效访问

内存连续性影响张量操作的性能：

python复制t = torch.rand(3,4)
t_transposed = t.T  # 转置后通常不连续

# 检查连续性
print(t.is_contiguous())  # True
print(t_transposed.is_contiguous())  # False

# 使不连续张量变连续
t_cont = t_transposed.contiguous()

影响连续性的操作：

• 转置（.T或.t()）
• 某些切片操作
• permute维度重排

优化技巧：在需要频繁访问张量时（如卷积操作），确保张量是内存连续的可以提高性能。