Python 课程15-PyTorch

已于 2024-09-17 22:42:37 修改
阅读量356 收藏 10
点赞数 11
分类专栏： Python教學 文章标签： python 开发语言 PyTorch 人工智能 机器学习
于 2024-09-17 22:41:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tim654654/article/details/142320080
版权

前言

PyTorch 是一个开源的深度学习框架，由 Facebook 开发，广泛应用于学术研究和工业领域。与 TensorFlow 类似，PyTorch 提供了强大的工具用于构建和训练深度学习模型。PyTorch 的动态计算图和灵活的 API 使得它特别适合研究和实验。它还支持 GPU 加速，适用于构建复杂的神经网络。

本教程将详细介绍 PyTorch 的每个常用指令和功能，帮助你从基础知识开始，逐步掌握如何使用 PyTorch 进行深度学习开发。

目录

  1. PyTorch 基础

    • 安装 PyTorch
    • 创建张量（Tensors）
    • 张量操作与计算
    • 自动微分与反向传播

  2. 神经网络构建

    • 使用 nn.Module 构建神经网络
    • 激活函数与损失函数
    • 优化器：SGD、Adam 等
    • 自定义训练循环

  3. 高级功能

    • 数据集与数据加载器
    • 使用 GPU 加速模型训练
    • 保存与加载模型

  4. 卷积神经网络 (CNN)

    • 构建 CNN 模型
    • 训练与评估 CNN

  5. 递归神经网络 (RNN)

    • 构建 RNN 与 LSTM
    • 训练与评估 RNN 模型

1. PyTorch 基础

安装 PyTorch

PyTorch 可以通过 pip 安装。你可以根据你的操作系统和硬件（例如 GPU）选择合适的安装命令：

pip install torch torchvision torchaudio

 导入 PyTorch：

import torch
创建张量（Tensors）

张量是 PyTorch 中的核心数据结构，它类似于 NumPy 数组，但支持 GPU 加速。

  • 创建张量： 
    # 创建一个 3x3 的随机张量
x = torch.rand(3, 3)
print(x)

# 创建一个全 0 张量
x = torch.zeros(3, 3)
print(x)

# 创建一个全 1 张量
x = torch.ones(3, 3)
print(x)
  • 从列表或 NumPy 创建张量： 
    import numpy as np

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

# 从 NumPy 数组创建张量
np_array = np.array([5, 6, 7, 8])
x = torch.from_numpy(np_array)
print(x)
    张量操作与计算

    PyTorch 提供了多种张量运算函数，如加法、乘法、矩阵乘法等。它们与 NumPy 的操作类似，但支持自动微分。

  • 基本运算： 
    x = torch.rand(3, 3)
y = torch.rand(3, 3)

# 加法
z = x + y
print(z)

# 乘法
z = x * y
print(z)

# 矩阵乘法
z = torch.matmul(x, y)
print(z)
  • 重塑张量： 
    x = torch.rand(16)

# 重塑为 4x4 的张量
x_reshaped = x.view(4, 4)
print(x_reshaped)
    自动微分与反向传播

    PyTorch 的自动微分机制通过 autograd 实现，它能够自动计算张量的梯度，从而实现反向传播。

  • 计算梯度： 
    # 创建一个张量，并设置 requires_grad=True 以跟踪其梯度
x = torch.tensor([2.0, 3.0], requires_grad=True)

# 定义一个简单的函数
y = x[0]**2 + x[1]**3

# 进行反向传播，计算梯度
y.backward()

# 输出梯度
print(x.grad)  # x[0] 的梯度是 4.0，x[1] 的梯度是 27.0

2. 神经网络构建

PyTorch 提供了 torch.nn 模块，用于构建神经网络。通过继承 nn.Module 类，你可以创建自定义的神经网络。

使用 nn.Module 构建神经网络

以下是一个使用 PyTorch 构建的简单前馈神经网络：

import torch.nn as nn

class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(28 * 28, 128)  # 输入层到隐藏层
        self.fc2 = nn.Linear(128, 64)       # 隐藏层
        self.fc3 = nn.Linear(64, 10)        # 输出层

    def forward(self, x):
        x = x.view(-1, 28 * 28)  # 展平输入
        x = torch.relu(self.fc1(x))  # 激活函数 ReLU
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x

# 创建模型实例
model = SimpleNN()
print(model)
激活函数与损失函数
  • 激活函数：PyTorch 提供了多种激活函数，可以在网络的前向传播中使用。 
    # 使用 ReLU 激活函数
x = torch.rand(5, 5)
x = torch.relu(x)
  • 损失函数：用于计算模型预测与真实标签之间的误差。
criterion = nn.CrossEntropyLoss()  # 适用于分类问题的交叉熵损失
优化器：SGD、Adam 等

优化器用于更新模型参数。PyTorch 提供了多种优化器，如 SGD 和 Adam。

  • 使用 SGD 优化器： 
    import torch.optim as optim

# 使用 SGD 优化器
optimizer = optim.SGD(model.parameters(), lr=0.01)
  • 使用 Adam 优化器： 
    optimizer = optim.Adam(model.parameters(), lr=0.001)
自定义训练循环

以下是一个简单的训练循环示例，用于训练神经网络模型。

# 假设我们有训练数据 loader
for epoch in range(10):
    for batch_idx, (data, target) in enumerate(train_loader):
        # 将梯度置零
        optimizer.zero_grad()

        # 前向传播
        output = model(data)
        loss = criterion(output, target)

        # 反向传播
        loss.backward()

        # 更新权重
        optimizer.step()

    print(f'Epoch {epoch + 1}, Loss: {loss.item()}')

3. 高级功能

数据集与数据加载器

PyTorch 提供了 torch.utils.data 模块，用于加载数据集。你可以使用内置的数据集，或者自定义自己的数据集。

  • 使用内置数据集（MNIST）： 
    from torchvision import datasets, transforms

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

# 加载 MNIST 数据集
train_dataset = datasets.MNIST(root='data', train=True, transform=transform, download=True)
test_dataset = datasets.MNIST(root='data', train=False, transform=transform, download=True)

# 创建数据加载器
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=32, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=32, shuffle=False)
  • 自定义数据集： 
    from torch.utils.data import Dataset

class MyDataset(Dataset):
    def __init__(self, data, labels):
        self.data = data
        self.labels = labels

    def __len__(self):
        return len(self.data)

    def __getitem__(self, idx):
        return self.data[idx], self.labels[idx]

使用 GPU 加速模型训练

PyTorch 支持使用 GPU 加速模型训练。你可以通过将模型和张量移动到 GPU 上来加速计算。

  • 检查 GPU 可用性： 
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(device)
  • 将模型和数据移动到 GPU：
model.to(device)

# 将数据移动到 GPU
data, target = data.to(device), target.to(device)
保存与加载模型

你可以通过保存和加载模型的权重来持久化训练的模型。

  • 保存模型： 
    torch.save(model.state_dict(), 'model.pth')
  • 加载模型： 
    model = SimpleNN()
model.load_state_dict(torch.load('model.pth'))

4. 卷积神经网络 (CNN)

卷积神经网络（CNN）在处理图像数据时非常有效。它能够通过卷积层提取图像的局部特征，并通过池化层减少特征图的维度。以下部分将详细介绍如何在 PyTorch 中构建和训练 CNN 模型。

构建 CNN 模型

我们将使用 PyTorch 的 torch.nn 模块构建一个 CNN 模型来处理 MNIST 手写数字分类任务。该模型包含卷积层、池化层和全连接层。

import torch.nn as nn
import torch.nn.functional as F

class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        # 卷积层 1：输入 1 个通道，输出 32 个通道，卷积核 3x3
        self.conv1 = nn.Conv2D(1, 32, kernel_size=3)
        # 卷积层 2：输入 32 个通道，输出 64 个通道
        self.conv2 = nn.Conv2D(32, 64, kernel_size=3)
        # 最大池化层：2x2 核
        self.pool = nn.MaxPool2D(2, 2)
        # 全连接层 1
        self.fc1 = nn.Linear(64 * 12 * 12, 128)  # MNIST 图像 28x28，经过两次卷积和池化后为 12x12
        # 全连接层 2
        self.fc2 = nn.Linear(128, 10)  # 输出为 10 类别（0-9）

    def forward(self, x):
        # 前向传播
        x = self.pool(F.relu(self.conv1(x)))  # 卷积 -> ReLU -> 池化
        x = self.pool(F.relu(self.conv2(x)))  # 卷积 -> ReLU -> 池化
        x = x.view(-1, 64 * 12 * 12)          # 展平张量以适配全连接层
        x = F.relu(self.fc1(x))               # 全连接层 -> ReLU
        x = self.fc2(x)                       # 输出层
        return x

# 实例化模型
model = CNN()
print(model)
训练与评估 CNN 模型

接下来，我们将训练这个 CNN 模型，并在 MNIST 数据集上进行评估。

  • 数据加载与准备： 
    import torch.optim as optim
from torchvision import datasets, transforms

# 定义图像变换：将图像转换为张量并标准化
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])

# 加载 MNIST 数据集
train_dataset = datasets.MNIST(root='data', train=True, transform=transform, download=True)
test_dataset = datasets.MNIST(root='data', train=False, transform=transform, download=True)

train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=32, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=32, shuffle=False)
  • 编译模型：我们将使用 交叉熵损失 和 Adam 优化器 来训练模型。 
    criterion = nn.CrossEntropyLoss()  # 交叉熵损失函数
optimizer = optim.Adam(model.parameters(), lr=0.001)  # Adam 优化器
  • 训练模型：以下是训练循环代码，它包括前向传播、计算损失、反向传播以及权重更新。 
    for epoch in range(10):  # 训练 10 个周期
    running_loss = 0.0
    for i, (inputs, labels) in enumerate(train_loader):
        # 梯度清零
        optimizer.zero_grad()

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

        # 反向传播
        loss.backward()
        optimizer.step()

        # 打印损失值
        running_loss += loss.item()
        if i % 100 == 99:  # 每 100 个 batch 打印一次
            print(f'Epoch {epoch + 1}, Batch {i + 1}, Loss: {running_loss / 100:.3f}')
            running_loss = 0.0
  • 模型评估：在测试集上评估模型的准确性。 
    correct = 0
total = 0
model.eval()  # 设置模型为评估模式
with torch.no_grad():  # 禁用梯度计算，以提高推理速度
    for inputs, labels in test_loader:
        outputs = model(inputs)
        _, predicted = torch.max(outputs, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f'Accuracy on test set: {100 * correct / total:.2f}%')

5. 递归神经网络 (RNN)

递归神经网络（RNN）特别适合处理序列数据，例如时间序列、自然语言处理等任务。PyTorch 提供了多种 RNN 层，如 RNN、GRU 和 LSTM。

构建 RNN 与 LSTM 模型

LSTM（长短期记忆网络）是一种改进的 RNN，能够更好地处理长期依赖关系。下面是一个简单的 LSTM 模型。

import torch.nn as nn

class LSTM(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, output_size):
        super(LSTM, self).__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        # 定义 LSTM 层
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
        # 全连接层
        self.fc = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        # 初始化隐藏状态和记忆状态
        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)
        c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)
        
        # 前向传播 LSTM
        out, _ = self.lstm(x, (h0, c0))
        
        # 取最后一个时间步的输出
        out = self.fc(out[:, -1, :])
        return out

# 实例化 LSTM 模型
model = LSTM(input_size=28, hidden_size=128, num_layers=2, output_size=10)
print(model)
训练与评估 RNN 模型
  • 数据加载：

假设我们使用 MNIST 数据集，但将每行像素视为序列输入。

train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=32, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=32, shuffle=False)
  • 训练模型：
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

for epoch in range(10):
    running_loss = 0.0
    for i, (inputs, labels) in enumerate(train_loader):
        inputs = inputs.view(-1, 28, 28)  # 将图像展平为序列形式
        optimizer.zero_grad()

        outputs = model(inputs)
        loss = criterion(outputs, labels)

        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        if i % 100 == 99:
            print(f'Epoch {epoch + 1}, Batch {i + 1}, Loss: {running_loss / 100:.3f}')
            running_loss = 0.0
  • 评估模型：
correct = 0
total = 0
model.eval()
with torch.no_grad():
    for inputs, labels in test_loader:
        inputs = inputs.view(-1, 28, 28)
        outputs = model(inputs)
        _, predicted = torch.max(outputs, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f'Accuracy on test set: {100 * correct / total:.2f}%')

结论

通过本教程，你已经学习了如何使用 PyTorch 进行深度学习项目的构建与训练。PyTorch 强大的灵活性和动态计算图，使它成为了学术研究和工业应用中的首选工具。它提供了简洁的 API，可以让你轻松实现复杂的神经网络模型，并通过 GPU 加速显著提升训练效率。

可愛小吉
关注
专栏目录
DnCNN-pytorch版本代码测试教程
假技术Po主
04-17 996
DnCNN-pytorch版本代码测试教程，抓紧订阅学习入门实战，尽快发论文哦！
Python深度学习-基于pytorch-1
fyh2944163240的博客
10-11 889
Python深度学习
(四) 三维点云课程---PointNet-Pytorch运行
qq_45369294的博客
10-29 5710
三维点云课程—PointNet-Pytorch运行 三维点云课程---PointNet-Pytorch运行三维点云课程---PointNet-Pytorch运行1.分类1.1训练1.2 分类训练可能出现的问题1.3测试分类后的模型文件1.4测试分类时源码可能遇到的问题2.分割2.1训练2.2分割训练可能出现的问题2.3测试分类后的模型文件2.4测试分类时源码可能遇到的问题 PointNet 源码下载地址:https://github.com/fxia22/pointnet.pytorch 源代码存在一些问题
江大白共学计划课程--Pytorch课程作业（1）
weixin_42538848的博客
10-19 201
江大白共学计划课程–Pytorch课程作业（1） import torch import torchvision.models as models from thop import profile # 加载模型结构 model = models.resnet18() # 读取权重和载入权重 pretrained_state_dict = torch.load('Lesson2/weights/resnet18-5c106cde.pth') model_state_dict = model.load_stat
python pytorch教程-带你从入门到实战（代码全部可运行）
热门推荐
weixin_43327597的博客
06-23 1万+
其实这个教程以前博主写过一次，不过，这回再写一次，打算内容写的多一点，由浅入神，然后加入一些实践案例。下面是我们的内容目录： 1.先从数据类型谈起2.数据类型和其操作谈完，选择某一个方向开始学习和实践（深度学习）。1.先从数据类型谈起那如果从数据类型谈起，我们就要从下面几个角度去谈：1.1 如何生成pytorch的各种数据类型？1.2 pytorch的各种数据类型有哪些属性？1.3 pytorch的各种数据类型有哪些函数操作？首先，我们知道pytorch是一个计算库，也有人说是深度学习库，那么计算库呢，肯
animegan2-pytorch 实现相机照片 转化为动漫滤镜效果图片
2301_82242670的博客
05-03 811
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
【我是土堆 - Pytorch教程】 知识点 学习总结笔记（一）
m0_57787115的博客
03-21 3267
此文章【我是土堆 - Pytorch教程】 知识点 学习总结笔记（一）包括：python学习中的2大法宝、Pycharm及Jupyter使用及对比、PyTorch加载数据初认识、Dataset类代码实战。
【Python】基于卷积神经网络的猫狗识别-PyTorch实现
m0_66304010的博客
03-02 4341
本实验通过对 Kaggle 上的 Cats.vs.Dogs图像数据集进行学习，实现识别图片 的猫狗类型。本实验挑选深度学习框架 pytorch，采用了基于 AlexNet的预训练 网络，分别对猫狗图像进行网络训练与测试。实验显示使用 AlexNet网络模型进 行识别的准确率达到了96.60%。文章内容来自我的《深度学习》课程作业实验报告。
人工智能算法工程师(中级)课程7-PyTorch神经网络之深度学习框架与代码详解
weixin_42878111的博客
07-11 765
大家好，我是微学AI，今天给大家介绍一下人工智能算法工程师(中级)课程7-PyTorch神经网络之深度学习框架与代码详解。深度学习作为人工智能领域的重要分支，已经在图像识别、自然语言处理、推荐系统等多个领域取得了显著成果。而PyTorch作为一个开源的深度学习框架，凭借其易用性、动态计算图和高灵活性，受到了广大研究者和开发者的喜爱。本文将详细介绍PyTorch的基本操作，包括Tensor的创建、形状和类型、梯度设置、运算，以及数据的读取和GPU的使用，并附上完整可运行的代码。
pointnet-pytorch运行
cangqiongxiaoye的博客
09-25 482
pointnet-pytorch运行
计算机视觉课程作业-PYtorch实现卷积神经网络(MTCNN)的人脸检测源码+文档说明
最新发布
09-16
计算机视觉课程作业-PYtorch实现卷积神经网络(MTCNN)的人脸检测源码+文档说明，含有代码注释，满分大作业资源，新手也可看懂，期末大作业、课程设计、高分必看，下载下来，简单部署，就可以使用。该项目可以作为课程...
python课程设计大作业-PyTorch实现图像识别基于卷积神经网络的识别方法RMB.zip
06-29
python课程设计大作业—PyTorch实现图像识别基于卷积神经网络的识别方法RMB。已获导师指导并通过的高分项目。 python课程设计大作业—PyTorch实现图像识别基于卷积神经网络的识别方法RMB。已获导师指导并通过的高分...
Python毕业设计-基于pytorch深度学习的车型识别系统（源码+文档使用说明）
08-18
Python毕业设计-基于pytorch深度学习的车型识别系统（源码+文档使用说明），含有代码注释，新手也可看懂，个人手打98分项目，导师非常认可的高分项目，毕业设计、期末大作业和课程设计高分必看，下载下来，简单部署...
python毕业设计-基于pytorch + bert的多标签文本分类源码+文档.zip
04-17
python毕业设计-基于pytorch + bert的多标签文本分类源码+文档.zip个人经导师指导并认可通过的高分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大...
python毕业设计-基于pytorch + bert的多标签文本分类（源码+文档）.zip
04-17
python毕业设计-基于pytorch + bert的多标签文本分类（源码+文档）.zip个人经导师指导并认可通过的高分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末...
Tcl lnit error: Can’t find a usable init.tcl in the following directories 问题解决
梦想闹钟
09-15 412
实际研究后发现，其实py2exe已经把打包需要的lib放在dist文件夹下了，但是打包后的程序运行后却没有去lib下找，而是去找系统自带的环境变量里找，所以找不到。这个问题出现在我用py2exe打包了一个包含tkinter的图形化界面，在当前电脑上运行无问题，在移动到新电脑上后提示报错、getcwd用于获取当前工作目录绝对路径，在设置环境的变量的时候它用的是绝对路径-所以也导致了在当前电脑上能用而移动后不能用。解决方法是在你的程序里重新设置下环境变量，而且是用相对路径的形式。
Python世界：力扣29题两数相除算法实践
来知晓的博客
09-13 412
除法运算本质是减法，从理解原理到真正实现还是有距离，建议初步理解后，不参考任何代码，完全自己复现一遍，体会更深。注意提示：目的就是提醒越界问题：-2^31/-1=2&31，超过了整数表达范围。本问题来自于力扣29题，在做完大数相乘后，顺带也看下两数相除。将两数相除，要求不使用乘法、除法和 mod 运算符。给定两个整数，被除数。
Python办公自动化案例（二）：对比两个Excel数据内容并标出不同
衍生星球的博客
09-14 445
在数据处理和分析的日常工作中，我们经常需要比较两个Excel文件的差异。这可能是为了验证数据的一致性、检查数据的准确性，或者在版本控制中追踪更改。手动比较这些文件不仅耗时，而且容易出错。幸运的是，Python的openpyxl库提供了一种自动化这一过程的方法。
JUC从实战到源码：中断机制与API实现
qq_43843951的博客
09-12 1152
在Java中，线程中断是一种机制，用于通知线程应该停止当前正在执行的任务。中断通常用于协同线程之间的合作，以便让线程在适当的时候终止其工作，尤其是在长时间运行的任务或阻塞操作中。通过学了多线程以及synchronized的相关知识，接下来就到了学习线程中断知识。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值