PyTorch基础

PyTorch 是一个开源的机器学习库，基于 Torch 库，底层由 C++ 实现，主要用于进行计算机视觉（CV）、自然语言处理（NLP）、语音识别等领域的研究和开发。

PyTorch 主要有两大特征：

类似于 NumPy 的张量计算，能在 GPU 或 MPS 等硬件加速器上加速。
基于带自动微分系统的深度神经网络。

TensorFlow vs PyTorch

PyTorch 的动态计算图使得它更加灵活，适合快速实验和研究；而 TensorFlow 的静态计算图在生产环境中更具优化空间。
PyTorch 在调试时更加方便，TensorFlow 则在部署上更加成熟，支持更广泛的硬件和平台。
近年来，TensorFlow 也引入了动态图（如 TensorFlow 2.x），使得两者在功能上趋于接近。
其他深度学习框架，如 Keras、Caffe 等也有一定应用，但 PyTorch 由于其灵活性、易用性和社区支持，已经成为很多深度学习研究者和开发者的首选框架。

import torch
x = torch.rand(5, 3)
print(x)

tensor([[0.3380, 0.3845, 0.3217],
        [0.8337, 0.9050, 0.2650],
        [0.2979, 0.7141, 0.9069],
        [0.1449, 0.1132, 0.1375],
        [0.4675, 0.3947, 0.1426]])

PyTorch 主要有以下几个基础概念：张量（Tensor）、自动求导（Autograd）、神经网络模块（nn.Module）、优化器（optim）等。

张量（Tensor）：PyTorch 的核心数据结构，支持多维数组，并可以在 CPU 或 GPU 上进行加速计算。
自动求导（Autograd）：PyTorch 提供了自动求导功能，可以轻松计算模型的梯度，便于进行反向传播和优化。
神经网络（nn.Module）：PyTorch 提供了简单且强大的 API 来构建神经网络模型，可以方便地进行前向传播和模型定义。
优化器（Optimizers）：使用优化器（如 Adam、SGD 等）来更新模型的参数，使得损失最小化。
设备（Device）：可以将模型和张量移动到 GPU 上以加速计算。

PyTorch 架构图

┌─────────────────────────────────────────────────────────────┐
│                    PyTorch 生态系统                          │
├─────────────────────────────────────────────────────────────┤
│  torchvision  │  torchtext  │  torchaudio  │  其他专业库      │
├─────────────────────────────────────────────────────────────┤
│                     PyTorch 核心                             │
├───────────────┬─────────────────┬───────────────────────────┤
│   torch.nn    │   torch.optim   │      torch.utils          │
│   (神经网络)   │   (优化器)       │      (工具函数)             │
├───────────────┼─────────────────┼───────────────────────────┤
│               │                 │   torch.utils.data        │
│  torch 核心   │  autograd       │   (数据加载)                │
│  (张量计算)    │  (自动微分)       │                           │
└───────────────┴─────────────────┴───────────────────────────┘

PyTorch 采用分层架构设计，从上层到底层依次为：

1、Python API（顶层）

torch：核心张量计算（类似NumPy，支持GPU）。
torch.nn：神经网络层、损失函数等。
torch.autograd：自动微分（反向传播）。
开发者直接调用的接口，简单易用。

2、C++核心（中层）

ATen：张量运算核心库（400+操作）。
JIT：即时编译优化模型。
Autograd引擎：自动微分的底层实现。
高性能计算，连接Python与底层硬件。

3、基础库（底层）

TH/THNN：C语言实现的基础张量和神经网络操作。
THC/THCUNN：对应的CUDA（GPU）版本。
直接操作硬件（CPU/GPU），极致优化速度。

执行流程：
Python代码 → C++核心计算 → 底层CUDA/C库加速 → 返回结果。

自动求导（Automatic Differentiation，简称Autograd）是深度学习框架中的一个核心特性，它允许计算机自动计算数学函数的导数。

在深度学习中，自动求导主要用于两个方面：一是在训练神经网络时计算梯度，二是进行反向传播算法的实现。

自动求导基于链式法则（Chain Rule），这是一个用于计算复杂函数导数的数学法则。链式法则表明，复合函数的导数是其各个组成部分导数的乘积。在深度学习中，模型通常是由许多层组成的复杂函数，自动求导能够高效地计算这些层的梯度。

神经网络（nn.Module）

神经网络是一种模仿人脑神经元连接的计算模型，由多层节点（神经元）组成，用于学习数据之间的复杂模式和关系。

神经网络通过调整神经元之间的连接权重来优化预测结果，这一过程涉及前向传播、损失计算、反向传播和参数更新。

神经网络的类型包括前馈神经网络、卷积神经网络（CNN）、循环神经网络（RNN）和长短期记忆网络（LSTM），它们在图像识别、语音处理、自然语言处理等多个领域都有广泛应用。

PyTorch 提供了一个非常方便的接口来构建神经网络模型，即 torch.nn.Module。

我们可以继承 nn.Module 类并定义自己的网络层。

import torch.nn as nn
import torch.optim as optim

# 定义一个简单的全连接神经网络
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(2, 2)  # 输入层到隐藏层
        self.fc2 = nn.Linear(2, 1)  # 隐藏层到输出层
   
    def forward(self, x):
        x = torch.relu(self.fc1(x))  # ReLU 激活函数
        x = self.fc2(x)
        return x

# 创建网络实例
model = SimpleNN()

# 打印模型结构
print(model)

SimpleNN(
  (fc1): Linear(in_features=2, out_features=2, bias=True)
  (fc2): Linear(in_features=2, out_features=1, bias=True)
)

训练过程：

前向传播（Forward Propagation）：在前向传播阶段，输入数据通过网络层传递，每层应用权重和激活函数，直到产生输出。
计算损失（Calculate Loss）：根据网络的输出和真实标签，计算损失函数的值。
反向传播（Backpropagation）：反向传播利用自动求导技术计算损失函数关于每个参数的梯度。
参数更新（Parameter Update）：使用优化器根据梯度更新网络的权重和偏置。
迭代（Iteration）：重复上述过程，直到模型在训练数据上的性能达到满意的水平。

import torch
import torch.nn as nn
import torch.optim as optim

# 1. 定义一个简单的神经网络模型
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(2, 2)  # 输入层到隐藏层
        self.fc2 = nn.Linear(2, 1)  # 隐藏层到输出层
    
    def forward(self, x):
        x = torch.relu(self.fc1(x))  # ReLU 激活函数
        x = self.fc2(x)
        return x

# 2. 创建模型实例
model = SimpleNN()

# 3. 定义损失函数和优化器
criterion = nn.MSELoss()  # 均方误差损失函数
optimizer = optim.Adam(model.parameters(), lr=0.001)  # Adam 优化器

# 4. 假设我们有训练数据 X 和 Y
X = torch.randn(10, 2)  # 10 个样本，2 个特征
Y = torch.randn(10, 1)  # 10 个目标值

# 5. 训练循环
for epoch in range(100):  # 训练 100 轮
    optimizer.zero_grad()  # 清空之前的梯度
    output = model(X)  # 前向传播
    loss = criterion(output, Y)  # 计算损失
    loss.backward()  # 反向传播
    optimizer.step()  # 更新参数
    
    # 每 10 轮输出一次损失
    if (epoch+1) % 10 == 0:
        print(f'Epoch [{epoch+1}/100], Loss: {loss.item():.4f}')

Epoch [10/100], Loss: 1.5175
Epoch [20/100], Loss: 1.4934
Epoch [30/100], Loss: 1.4716
Epoch [40/100], Loss: 1.4520
Epoch [50/100], Loss: 1.4345
Epoch [60/100], Loss: 1.4189
Epoch [70/100], Loss: 1.4047
Epoch [80/100], Loss: 1.3917
Epoch [90/100], Loss: 1.3798
Epoch [100/100], Loss: 1.3686

在每 10 轮，程序会输出当前的损失值，帮助我们跟踪模型的训练进度。随着训练的进行，损失值应该会逐渐降低，表示模型在不断学习并优化其参数。

训练模型是一个迭代的过程，需要不断地调整和优化，直到达到满意的性能。这个过程涉及到大量的实验和调优，目的是使模型在新的、未见过的数据上也能有良好的泛化能力。

posted @ 2025-07-30 13:41 嘉禾世兴阅读(16) 评论(0) 收藏举报

刷新页面返回顶部

嘉禾世兴

PyTorch基础

TensorFlow vs PyTorch

PyTorch 架构图

神经网络（nn.Module）

公告