PyTorch张量基础：从创建到GPU加速的全面指南

1. PyTorch张量基础概念解析

张量(Tensor)是PyTorch中最核心的数据结构，可以简单理解为多维数组的扩展。与NumPy的ndarray类似，PyTorch张量提供了高效的数值计算能力，但额外支持GPU加速和自动微分功能，这使得它成为深度学习领域的首选数据结构。

1.1 张量的维度与形状

张量的维度(ndim)决定了数据的组织方式：

• 0维张量：标量（单个数字）
• 1维张量：向量（一列数字）
• 2维张量：矩阵（行列式）
• 3维及以上：高阶张量（如图像数据通常为3维：通道×高度×宽度）

形状(shape)属性描述了每个维度的大小。例如，一个形状为(3, 224, 224)的张量表示3通道、224像素高度的224像素宽度的图像数据。

python复制# 创建不同维度的张量示例
scalar = torch.tensor(3.14)       # 0维
vector = torch.arange(5)          # 1维
matrix = torch.randn(3, 3)        # 2维
image = torch.zeros(3, 224, 224)  # 3维
video = torch.rand(10, 3, 224, 224) # 4维

1.2 张量的数据类型

PyTorch支持丰富的数据类型，常见的有：

• 浮点型：torch.float32(默认)、torch.float64
• 整型：torch.int8、torch.int16、torch.int32、torch.int64
• 布尔型：torch.bool

创建时可以显式指定数据类型：

python复制# 指定数据类型的张量创建
double_tensor = torch.rand(2, 2, dtype=torch.float64)
int_tensor = torch.ones(3, 3, dtype=torch.int32)

注意：不同数据类型的张量不能直接运算，需要先统一类型。使用.to()方法或.type()方法可以转换数据类型。

2. 张量创建与初始化方法

2.1 直接创建方法

PyTorch提供了多种直接创建张量的方式：

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

# 创建特定形状的空张量（未初始化）
empty_tensor = torch.empty(3, 3)

# 创建全零张量
zeros = torch.zeros(2, 2, dtype=torch.float32)

# 创建全一张量
ones = torch.ones_like(zeros)  # 保持与zeros相同的形状和类型

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

# 创建等差数列
range_tensor = torch.arange(0, 10, 2)  # 0,2,4,6,8

2.2 随机初始化方法

深度学习模型通常需要随机初始化的参数：

python复制# 均匀分布随机数 [0,1)
uniform_random = torch.rand(3, 3)

# 标准正态分布随机数
normal_random = torch.randn(3, 3)

# 设置随机种子保证可重复性
torch.manual_seed(42)
reproducible_random = torch.rand(2, 2)

# 特定范围的随机整数
randint_tensor = torch.randint(low=0, high=10, size=(3,3))

专业技巧：在模型训练前设置全局随机种子可以确保实验可重复性：

python复制torch.manual_seed(42)  # CPU随机种子
torch.cuda.manual_seed_all(42)  # 所有GPU随机种子

3. 张量的数学运算

3.1 基本算术运算

PyTorch支持所有基本的元素级运算：

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

# 加法
add_result = a + b  # 或 torch.add(a, b)

# 减法
sub_result = a - b

# 乘法（元素级）
mul_result = a * b

# 除法
div_result = b / a

# 幂运算
pow_result = a ** 2

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

3.2 广播机制

PyTorch的广播规则与NumPy一致，允许不同形状的张量进行运算：

python复制# 标量与张量运算
scalar = 2
tensor = torch.ones(3, 3)
result = scalar * tensor  # 标量广播到整个张量

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

广播规则总结：

1. 从最后一个维度开始向前比较
2. 两个维度要么相等，要么其中一个为1，或者其中一个不存在
3. 不满足上述条件则不能广播

3.3 高级数学函数

PyTorch提供了丰富的数学函数库：

python复制x = torch.tensor([0, math.pi/2, math.pi])

# 三角函数
sin_x = torch.sin(x)
cos_x = torch.cos(x)

# 指数和对数
exp_x = torch.exp(x)
log_x = torch.log(x + 1)  # 避免log(0)

# 取整函数
a = torch.tensor([1.2, -1.8])
floor_a = torch.floor(a)  # 向下取整
ceil_a = torch.ceil(a)    # 向上取整
round_a = torch.round(a)  # 四舍五入

# 裁剪操作
x = torch.randn(5)
clipped = torch.clamp(x, min=-0.5, max=0.5)  # 限制在[-0.5,0.5]范围内

4. 张量的索引与切片

4.1 基础索引

PyTorch的索引方式与Python列表和NumPy数组类似：

python复制tensor = torch.arange(1, 10).view(3, 3)  # 3x3张量

# 获取单个元素
elem = tensor[1, 2]  # 第2行第3列

# 获取整行或整列
row = tensor[1, :]    # 第2行
col = tensor[:, 0]    # 第1列

# 使用步长
every_other = tensor[::2, ::2]  # 隔行隔列取样

4.2 高级索引

PyTorch支持更复杂的高级索引方式：

python复制# 布尔索引
mask = tensor > 5
filtered = tensor[mask]  # 返回所有大于5的元素

# 整数数组索引
indices = torch.tensor([0, 2])
selected = tensor[indices]  # 选择第1和第3行

# 组合索引
result = tensor[1:, [0, 2]]  # 第2行到最后一行，第1和第3列

4.3 修改张量值

索引不仅可以读取，还可以修改张量内容：

python复制# 修改单个元素
tensor[0, 0] = 10

# 修改整行
tensor[1, :] = torch.tensor([-1, -2, -3])

# 使用掩码修改
mask = tensor < 0
tensor[mask] = 0  # 将所有负数置零

注意事项：索引操作返回的通常是原始张量的视图(view)，修改视图会影响原始张量。如果需要独立副本，应使用.clone()方法。

5. 张量的形状操作

5.1 改变张量形状

python复制tensor = torch.arange(12)

# reshape/view方法（不改变数据）
matrix = tensor.reshape(3, 4)  # 或tensor.view(3,4)

# 转置操作
transposed = matrix.T  # 或matrix.t()

# 交换维度
permuted = matrix.permute(1, 0)  # 等价于转置

# 展平操作
flattened = matrix.flatten()  # 变为1维

5.2 增加/减少维度

python复制tensor = torch.tensor([1, 2, 3])

# 增加维度
matrix = tensor.unsqueeze(0)  # 形状从(3)变为(1,3)
tensor4d = tensor.reshape(1,1,1,3)  # 4维张量

# 减少维度
squeezed = matrix.squeeze()  # 移除所有长度为1的维度

5.3 连接与分割张量

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

# 沿行连接（垂直堆叠）
cat_rows = torch.cat([a, b], dim=0)  # 形状(4,2)

# 沿列连接（水平堆叠）
cat_cols = torch.cat([a, b], dim=1)  # 形状(2,4)

# 分割张量
chunks = torch.chunk(cat_rows, 2, dim=0)  # 分成2部分
split = torch.split(cat_cols, 2, dim=1)   # 每2列一组

6. GPU加速与性能优化

6.1 张量的设备迁移

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

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

# 迁移现有张量
cpu_tensor = torch.ones(3, 3)
gpu_tensor = cpu_tensor.to(device)  # 移动到GPU
back_to_cpu = gpu_tensor.cpu()      # 移回CPU

6.2 内存优化技巧

1. 就地操作：使用后缀为_的操作可以节省内存

   python复制a = torch.rand(3, 3)
   a.add_(1)  # 就地加法，不创建新张量
   

2. 重用内存：通过out参数指定输出张量

   python复制result = torch.empty(3, 3)
   torch.matmul(a, b, out=result)  # 结果存入预分配内存
   

3. 梯度清零：训练循环中及时释放不需要的梯度

   python复制optimizer.zero_grad()  # 防止梯度累积
   

6.3 性能基准测试

使用torch.utils.benchmark可以比较不同操作的性能：

python复制from torch.utils.benchmark import Timer

# 比较CPU和GPU矩阵乘法
size = 1024
a = torch.rand(size, size)
b = torch.rand(size, size)

cpu_timer = Timer(
    stmt='torch.matmul(a, b)',
    globals={'a': a, 'b': b}
)

gpu_timer = Timer(
    stmt='torch.matmul(a, b)',
    globals={'a': a.cuda(), 'b': b.cuda()}
)

print(cpu_timer.timeit(100))
print(gpu_timer.timeit(100))

7. 常见问题与解决方案

7.1 形状不匹配错误

问题：RuntimeError: The size of tensor a (3) must match the size of tensor b (4) at non-singleton dimension 1

解决方案：

1. 检查张量形状：print(a.shape, b.shape)
2. 使用.reshape()或.view()调整形状
3. 必要时使用广播机制

7.2 GPU内存不足

问题：CUDA out of memory

解决方案：

1. 减小批量大小
2. 使用更小的模型
3. 清理缓存：torch.cuda.empty_cache()
4. 使用混合精度训练

7.3 自动微分相关问题

问题：RuntimeError: element 0 of tensors does not require grad and does not have a grad_fn

解决方案：

1. 确保输入张量设置了requires_grad=True
2. 检查是否意外调用了.detach()或.data
3. 在训练模式下运行模型：model.train()

7.4 性能优化检查表

1. 确保在GPU上运行计算密集型操作
2. 使用torch.backends.cudnn.benchmark = True启用cuDNN自动调优
3. 避免在训练循环中频繁创建新张量
4. 使用torch.no_grad()上下文管理器禁用不需要的计算图构建
5. 定期使用torch.cuda.empty_cache()清理缓存

8. 实际应用案例

8.1 图像数据处理

python复制# 模拟RGB图像数据 (3通道, 高256, 宽256)
image = torch.rand(3, 256, 256)

# 归一化到[-1,1]
normalized = (image - 0.5) * 2

# 随机裁剪
from torchvision import transforms
crop = transforms.RandomCrop(224)(image)

# 批量处理 (16张图像)
batch = torch.stack([image]*16)  # 形状(16,3,256,256)

8.2 神经网络层实现

python复制# 实现简单的全连接层
def linear_layer(x, weight, bias):
    return x @ weight.t() + bias

# 参数初始化
in_features, out_features = 784, 256
weight = torch.randn(out_features, in_features) * 0.01
bias = torch.zeros(out_features)

# 前向传播
x = torch.randn(32, 784)  # 批量大小32
output = linear_layer(x, weight, bias)

8.3 自定义损失函数

python复制def custom_loss(predictions, targets):
    # Huber损失
    diff = predictions - targets
    abs_diff = diff.abs()
    quadratic = torch.min(abs_diff, torch.ones_like(abs_diff))
    linear = abs_diff - quadratic
    return 0.5 * quadratic**2 + linear

pred = torch.randn(10, requires_grad=True)
target = torch.randn(10)
loss = custom_loss(pred, target)
loss.backward()

9. 张量与NumPy互操作

PyTorch与NumPy可以无缝转换，共享内存：

python复制import numpy as np

# NumPy数组转PyTorch张量
np_array = np.random.rand(3, 3)
torch_tensor = torch.from_numpy(np_array)

# PyTorch张量转NumPy数组
new_np_array = torch_tensor.numpy()

# 共享内存验证
np_array[0, 0] = 42
print(torch_tensor[0, 0])  # 输出42，说明共享内存

注意：GPU上的张量需要先移动到CPU才能转换为NumPy数组：

python复制gpu_tensor = torch.rand(3,3, device='cuda')
cpu_tensor = gpu_tensor.cpu()
np_array = cpu_tensor.numpy()

10. 高级技巧与最佳实践

10.1 内存高效操作

1. 使用原地操作：后缀_的操作如.add_()可以节省内存
2. 预分配内存：对于循环中的重复操作，预先分配结果张量
3. 延迟计算：利用PyTorch的延迟执行特性，避免中间结果存储

10.2 并行计算策略

python复制# 使用多GPU数据并行
if torch.cuda.device_count() > 1:
    model = torch.nn.DataParallel(model)

# 使用torch.jit.script编译优化
@torch.jit.script
def fast_function(x):
    return x * x + x.sqrt()

10.3 调试技巧

1. 检查NaN/Inf：

   python复制def check_nan(tensor):
       return torch.isnan(tensor).any() or torch.isinf(tensor).any()
   

2. 梯度检查：

   python复制for name, param in model.named_parameters():
       if param.grad is None:
           print(f"No gradient for {name}")
       elif check_nan(param.grad):
           print(f"NaN in gradients of {name}")
   

3. 设备一致性检查：

   python复制def check_device(*tensors):
       devices = {t.device for t in tensors}
       if len(devices) > 1:
           raise RuntimeError(f"Tensors on different devices: {devices}")
   

掌握PyTorch张量的高效使用是深度学习开发的基础。通过合理利用GPU加速、内存优化技巧和高效的张量操作，可以显著提升模型训练和推理的性能。在实际项目中，建议结合具体任务特点，灵活运用各种张量操作，并注意保持代码的可读性和可维护性。