【机器学习入门】第16讲：深度学习框架入门（PyTorch）——从张量到智能创造的钥匙

原创已于 2025-04-24 20:02:14 修改 · 272 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#机器学习 #深度学习 #pytorch

于 2025-04-15 00:15:00 首次发布

人工智能同时被 2 个专栏收录

33 篇文章

订阅专栏

机器学习

28 篇文章

订阅专栏

【资源软件】动作暨昝绳鹤锁多好 /_494b36Tkwj😕
链接：https://pan.quark.cn/s/43159509c536
「微信被删好友检测工具」筷莱坌教狴犴狾夺郝链接：https://pan.quark.cn/s/43159509c536
链接：https://pan.quark.cn/s/4598337f6b3e
「【美剧系列】」链接：https://pan.quark.cn/s/663e3ca79519

复制群口令 !0b7236TlXn!😕
将加入群聊免费医院分享

引言：为什么说“框架”是深度学习的加速器？

假设你正在开发一个自动驾驶感知系统：

目标：实时识别道路上的车辆、行人、交通标志
挑战：
- 需要快速实验不同模型架构（CNN、Transformer等）
- 计算资源有限，需高效利用GPU加速
- 梯度计算复杂，手动实现易出错

PyTorch作为最受欢迎的深度学习框架之一，提供了灵活的张量操作与自动求导机制，让研究者专注于模型设计而非底层实现。本文将带你从零掌握PyTorch核心功能，开启高效深度学习开发之旅。

一、张量（Tensor）：PyTorch的数据基石

1.1 张量 vs Numpy数组

特性	Numpy数组	PyTorch张量
硬件加速	仅CPU	支持CPU/GPU
自动求导	不支持	支持
动态计算图	不支持	支持

代码示例：创建与转换

import torch  
import numpy as np  

# 从列表创建张量  
data = [[1, 2], [3, 4]]  
tensor = torch.tensor(data)  

# 与Numpy互转  
np_array = np.array(data)  
tensor_from_np = torch.from_numpy(np_array)  
np_from_tensor = tensor.numpy()  

# GPU加速（需可用GPU）  
if torch.cuda.is_available():  
    tensor_gpu = tensor.cuda()

1.2 张量运算：GPU加速的数学魔法

# 基本运算  
x = torch.rand(2, 3)  
y = torch.ones(2, 3)  
z = x + y  # 逐元素加法  

# 矩阵乘法  
a = torch.rand(3, 4)  
b = torch.rand(4, 5)  
c = torch.matmul(a, b)  # 结果形状(3,5)  

# 广播机制  
d = torch.rand(3, 1)  
e = torch.rand(1, 3)  
f = d + e  # 自动扩展为(3,3)

二、自动求导（Autograd）：让机器自己学习

2.1 计算图与梯度追踪

requires_grad=True：启用梯度跟踪
.backward()：自动计算梯度
.grad：查看梯度值

示例：线性回归梯度计算

# 定义参数  
w = torch.tensor(2.0, requires_grad=True)  
b = torch.tensor(1.0, requires_grad=True)  

# 前向计算  
x = torch.tensor(3.0)  
y_pred = w * x + b  
loss = (y_pred - 5.0) ** 2  # 假设真实值5.0  

# 反向传播  
loss.backward()  

print("dL/dw:", w.grad)  # 2*(wx + b - y)*x = 2*(6+1-5)*3=12  
print("dL/db:", b.grad)  # 2*(wx + b - y) = 4

2.2 梯度清零与禁用追踪

# 训练循环中的梯度管理  
optimizer.zero_grad()  # 清零累积梯度  
loss.backward()        # 计算新梯度  
optimizer.step()       # 更新参数  

# 禁用梯度跟踪（推理时）  
with torch.no_grad():  
    y = model(x)

三、神经网络构建：nn.Module的模块化设计

3.1 定义网络结构

import torch.nn as nn  

class MLP(nn.Module):  
    def __init__(self):  
        super().__init__()  
        self.layers = nn.Sequential(  
            nn.Linear(784, 256),   # 输入层→隐藏层  
            nn.ReLU(),  
            nn.Linear(256, 10)     # 隐藏层→输出层  
        )  

    def forward(self, x):  
        return self.layers(x)  

model = MLP()  
print(model)

3.2 参数查看与设备迁移

# 打印所有参数  
for name, param in model.named_parameters():  
    print(f"{name}: {param.shape}")  

# 模型移至GPU  
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")  
model.to(device)

四、实战案例：Fashion MNIST图像分类

4.1 数据加载与预处理

from torchvision import datasets, transforms  

# 定义数据变换  
transform = transforms.Compose([  
    transforms.ToTensor(),  
    transforms.Normalize((0.5,), (0.5,))  
])  

# 加载数据集  
train_set = datasets.FashionMNIST(  
    root='./data',   
    train=True,  
    download=True,  
    transform=transform  
)  
train_loader = torch.utils.data.DataLoader(train_set, batch_size=64, shuffle=True)

4.2 训练循环完整实现

# 定义损失函数与优化器  
criterion = nn.CrossEntropyLoss()  
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)  

# 训练循环  
for epoch in range(10):  
    for images, labels in train_loader:  
        images, labels = images.to(device), labels.to(device)  
        images = images.view(-1, 784)  # 展平为[64,784]  

        # 前向传播  
        outputs = model(images)  
        loss = criterion(outputs, labels)  

        # 反向传播与优化  
        optimizer.zero_grad()  
        loss.backward()  
        optimizer.step()  

    print(f'Epoch [{epoch+1}/10], Loss: {loss.item():.4f}')

五、模型保存与部署

5.1 保存/加载模型

# 保存整个模型  
torch.save(model.state_dict(), 'fashion_mnist.pth')  

# 加载模型  
new_model = MLP()  
new_model.load_state_dict(torch.load('fashion_mnist.pth'))

5.2 ONNX格式导出

dummy_input = torch.randn(1, 784)  
torch.onnx.export(  
    model,   
    dummy_input,  
    "model.onnx",  
    input_names=["input"],  
    output_names=["output"]  
)