当前位置： 首页 > article >正文

使用pytorch深度学习框架搭建神经网络

article 2024/11/15 5:59:28

简介

现在主流有两个框架pytorch和TensorFlow,本文主要介绍pytorch

  • PyTorch：由 Facebook 的人工智能研究小组开发和维护。PyTorch 以其动态计算图（Dynamic Computational Graph）和易用性著称，非常适合研究人员和开发者进行实验和快速原型开发。
  • TensorFlow：由 Google 开发和维护。TensorFlow 是一个更加成熟和全面的框架，支持大规模的生产环境部署，特别是在云计算和分布式计算方面具有优势。

然后介绍两个小工具：

dir()打开该包，看看里面有什么东西；如果IDE使用的是pycharm的话，按住Ctrl直接跳转，输入函数的参数的时候按住Ctrl+P可以看需要填哪些参数

help()官方解释文档，教你如何使用该工具

神经网络搭建步骤

数据集介绍

 数据集为CIFAR10，

CIFAR-10 数据集由 10 个类的 60000 张 32x32 彩色图像组成，每个类有 6000 张图像。有 50000 张训练图像和 10000 张测试图像。图像大小为3x32x32

数据集分为 5 个训练批次和 1 个测试批次，每个批次有 10000 张图像。测试批次包含每个类中随机选择的 1000 张图像。训练批次包含按随机顺序排列的剩余图像，但某些训练批次可能包含来自一个类的图像多于另一个类的图像。在它们之间，训练批次正好包含来自每个类的 5000 张图像。

以下是数据集中的类，以及每个类的 10 张随机图像：

运行下列代码会导入数据集，没有下载的会自动下载

datasets导入数据集

dataloader分发数据，每批次送入64图片进入网络训练

transform更改图片数据的类型，比如将PIL改成tensor类型

train_data = torchvision.datasets.CIFAR10("./dataset",train=True,transform=torchvision.transforms.ToTensor(),download=True)
test = train_data.classes
print(test)
test_data = torchvision.datasets.CIFAR10("./dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)
train_dataloader = DataLoader(train_data,batch_size=64)
test_dataloader = DataLoader(test_data,batch_size=64)

搭建网络 

由官网可知（官网链接：PyTorch documentation — PyTorch 2.4 documentation），使用pytorch搭建网络至少需要重写2个函数，一个__init__() 初始化函数，另一个forward()前向传播函数，下图为官网截图：

按照官网给的例子我们重写，我们的网络结构如下图所示 

网络结构如下图所示

代码思路：输入：3x32x32--->最后输出10个参数，具体过程如下图所示：

 二维卷积参数计算公式如下图，根据输入输出计算padding和stride

代码实现

使用sequential()

class Wisdom(nn.Module):
    def __init__(self):
        super(Wisdom, self).__init__()
        self.model1 = Sequential(
            nn.Conv2d(3, 32, 5, padding=2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 32, 5, padding=2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 5, padding=2),
            nn.MaxPool2d(2),
            nn.Flatten(),
            nn.Linear(1024, 64),
            nn.Linear(64, 10)

        )

    def forward(self, x):
        x = self.model1(x)

        return x

 不使用sequential()

class Wisdom(nn.Module):
    def __init__(self):
        super(Wisdom, self).__init__()
        self.conv1=Conv2d(3,32,5,padding=2)
        self.maxpool1=MaxPool2d(2)
        self.conv2=Conv2d(32,32,5,padding=2)
        self.maxpool2=MaxPool2d(2)
        self.conv3=Conv2d(32,64,5,padding=2)
        self.maxpool3=MaxPool2d(2)
        self.flatten=Flatten()
        self.linear1=Linear(1024,64)
        self.linear2= Linear(64, 10)

    def forward(self,x):
        x=self.conv1(x)
        x=self.maxpool1(x)
        x=self.conv2(x)
        x=self.maxpool2(x)
        x=self.conv3(x)
        x=self.maxpool3(x)
        x=self.flatten(x)
        x=self.linear1(x)
        x=self.linear2(x)

        return x

实例化神经网络对象，损失函数，优化器

#创建神经网络
wisdom = Wisdom()
wisdom=wisdom.cuda()
#损失函数
loss_fn= nn.CrossEntropyLoss()
loss_fn=loss_fn.cuda()
#优化器
learn_rate =0.01
optimizer = torch.optim.SGD(wisdom.parameters(),lr=learn_rate)

损失函数（Loss Function）

常见的损失函数包括：

选择哪种损失函数取决于具体的任务和模型类型。在训练过程中，目标是最小化损失函数的值，从而提高模型的预测准确性。

优化器

优化器（Optimizer）是机器学习中用于调整模型参数以最小化损失函数的算法。优化器通过迭代过程逐步更新模型的权重和偏置，以找到损失函数的最小值。以下是一些常用的优化器：

设置网络参数

使用writer = SummaryWriter("logs_train")可以可视化整个训练过程
#设置网络的一些参数
#记录的训练次数
total_train_step = 0
#记录测试次数
total_test_step = 0
#训练的轮数
epoch=10
#添加tensorboard
writer = SummaryWriter("logs_train")

 训练和验证网络并将重要信息可视化屏幕

重要代码解析：

wisdom.train()标志网络进入训练状态

loss = loss_fn(outputs,targets)计算损失函数

optimizer.zero_grad() 梯度置零，防止上个梯度对本轮训练产生影响
loss.backward()反向传播
optimizer.step()梯度更新

wisdom.eval()模型进入测试状态

将损失值和精度闯入writer并绘制曲线图

writer.add_scalar("test_loss", total_test_loss, total_test_step) writer.add_scalar("test_accuracy", total_accuracy/test_data_size, total_test_step)

torch.save(wisdom,"./model_train/wisdom_{}.pth".format(i))保存训练好模型
for i in range(epoch):
    print("----第{}轮开始----".format(i+1))
    #开始训练
    #进入训练状态
    wisdom.train()

    for data in train_dataloader:
        imgs,targets = data
        imgs=imgs.cuda()
        targets=targets.cuda()
        outputs = wisdom(imgs)
        loss = loss_fn(outputs,targets)
        #优化器调优
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        total_train_step += 1
        if total_train_step % 100 ==0:
            print("训练次数：{},loss:{}:".format(total_train_step,loss))
            writer.add_scalar("train_loss",loss.item(),total_train_step)

    #模型测试
    #模型进入测试状态
    wisdom.eval()
    total_test_loss=0
    total_accuracy = 0
    with torch.no_grad():# 提高推理速度和节省内存
        for data in test_dataloader:
            imgs,targets = data
            imgs = imgs.cuda()
            targets = targets.cuda()
            outputs = wisdom(imgs )
            loss = loss_fn(outputs,targets)
            total_test_loss=total_test_loss+loss.item()
            accuracy = (outputs.argmax(1)==targets).sum()
            total_accuracy=total_accuracy+accuracy

    print("整体测试集合的loss:{}".format(total_test_loss))
    print("整体测试集合的准确率:{}".format(total_accuracy/test_data_size))
    writer.add_scalar("test_loss", total_test_loss, total_test_step)
    writer.add_scalar("test_accuracy", total_accuracy/test_data_size, total_test_step)
    total_test_step +=1

    torch.save(wisdom,"./model_train/wisdom_{}.pth".format(i))
    print("模型已经保存！")
    #torch.save(wisdom.state_dict(),"./model_train/wisdom_{}.pth".format(i))
writer.close()

使用GPU加速训练

确保电脑有显卡并正确安装驱动，而且要正确下载对应cuda 

下载教程：

进入pytorch官网

根据自己的系统选择，一般使用anaconda 在Windows下进行python环境管理，复制红框部分，在Anaconda Prompt 粘贴运行，注意自己的cuda版本是否支持

查看cuda版本，打开英伟达控制面板，桌面右键或者系统右下角，然后点击系统信息，之后点击组件

GPU程序设置

在神经网络，损失函数的实例对象后加.cuda()即可，以及在图片数据后加.cuda()

wisdom=wisdom.cuda()
loss_fn=loss_fn.cuda()
imgs=imgs.cuda()
targets=targets.cuda()

 保存模型

torch.save(wisdom,"./model_train/wisdom_{}.pth".format(i))

使用训练好的网络进行分类任务

加载网络模型

model = torch.load("./model_train/wisdom_49.pth")

若出现runtime error 将模型加载方式换成下列语句，将GPU训练的模型映射到CPU

出现runtimer error 将模型加载方式换成下列语句，将GPU训练的模型映射到CPU

或者将分类的图片进行cuda加速

image = image.cuda()#使用GPU训练的模型需要加CUDA

 使用SummaryWriter使训练可视化

打开Anaconda Prompt再激活环境后运行下列命令：

tensorboard --logdir "D:\pyc_workspace\learn_pytorch\logs_train

上列的地址根据train.py代码中的这个语句确定

writer = SummaryWriter("logs_train")

一定要改成自己的文件地址,具体操作见下图

可视化结果如下图所示

最后解释一个语句，with torch.no_grad()提高推理速度和节省内存

with torch.no_grad():# 提高推理速度和节省内存
        for data in test_dataloader:
            imgs,targets = data
            imgs = imgs.cuda()
            targets = targets.cuda()
            outputs = wisdom(imgs )
            loss = loss_fn(outputs,targets)
            total_test_loss=total_test_loss+loss.item()
            accuracy = (outputs.argmax(1)==targets).sum()
            total_accuracy=total_accuracy+accuracy

程序汇总 

train.py

使用cpu训练网络

import torchvision
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

from model import *

train_data = torchvision.datasets.CIFAR10("./dataset",train=True,transform=torchvision.transforms.ToTensor(),download=True)

test_data = torchvision.datasets.CIFAR10("./dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)

#length长度
train_data_size = len(train_data)
test_data_size = len(test_data)
print("训练集长度：{}".format(train_data_size))
print("测试集长度：{}".format(test_data_size))

#使用dataloader加载数据集
train_dataloader = DataLoader(train_data,batch_size=64)
test_dataloader = DataLoader(test_data,batch_size=64)

#创建神经网络
wisdom = Wisdom()
#损失函数
loss_fn= nn.CrossEntropyLoss()
#优化器
learn_rate =0.01
optimizer = torch.optim.SGD(wisdom.parameters(),lr=learn_rate)

#设置网络的一些参数
#记录的训练次数
total_train_step = 0
#记录测试次数
total_test_step = 0
#训练的轮数
epoch=10
#添加tensorboard
writer = SummaryWriter("logs_train")
#tensorboard --logdir "D:\pyc_workspace\learn_pytorch\logs_train"

for i in range(epoch):
    print("----第{}轮开始----".format(i+1))
    #开始训练
    #进入训练状态
    wisdom.train()

    for data in train_dataloader:
        imgs,targets = data
        outputs = wisdom(imgs)
        loss = loss_fn(outputs,targets)
        #优化器调优
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        total_train_step += 1
        if total_train_step % 100 ==0:
            print("训练次数：{},loss:{}:".format(total_train_step,loss))
            writer.add_scalar("train_loss",loss.item(),total_train_step)

    #模型测试
    #模型进入测试状态
    wisdom.eval()
    total_test_loss=0
    total_accuracy = 0
    with torch.no_grad():
        for data in test_dataloader:
            imgs,targets = data
            outputs = wisdom(imgs )
            loss = loss_fn(outputs,targets)
            total_test_loss=total_test_loss+loss.item()
            accuracy = (outputs.argmax(1)==targets).sum()
            total_accuracy=total_accuracy+accuracy

    print("整体测试集合的loss:{}".format(total_test_loss))
    print("整体测试集合的准确率:{}".format(total_accuracy/test_data_size))
    writer.add_scalar("test_loss", total_test_loss, total_test_step)
    writer.add_scalar("test_accuracy", total_accuracy/test_data_size, total_test_step)
    total_test_step +=1

    torch.save(wisdom,"./model_train/wisdom_{}.pth".format(i))
    print("模型已经保存！")
    #torch.save(wisdom.state_dict(),"./model_train/wisdom_{}.pth".format(i))
writer.close()

train_gpu.py 

使用GPU训练网络

import torch
import torchvision
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter


train_data = torchvision.datasets.CIFAR10("./dataset",train=True,transform=torchvision.transforms.ToTensor(),download=True)
test = train_data.classes
print(test)
test_data = torchvision.datasets.CIFAR10("./dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)

class Wisdom(nn.Module):
    def __init__(self):
        super(Wisdom, self).__init__()
        self.model1 = Sequential(
            nn.Conv2d(3, 32, 5, padding=2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 32, 5, padding=2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 5, padding=2),
            nn.MaxPool2d(2),
            nn.Flatten(),
            nn.Linear(1024, 64),
            nn.Linear(64, 10)

        )

    def forward(self, x):
        x = self.model1(x)

        return x

#length长度
train_data_size = len(train_data)
test_data_size = len(test_data)
print("训练集长度：{}".format(train_data_size))
print("测试集长度：{}".format(test_data_size))

#使用dataloader加载数据集
train_dataloader = DataLoader(train_data,batch_size=64)
test_dataloader = DataLoader(test_data,batch_size=64)

#创建神经网络
wisdom = Wisdom()
wisdom=wisdom.cuda()
#损失函数
loss_fn= nn.CrossEntropyLoss()
loss_fn=loss_fn.cuda()
#优化器
learn_rate =0.01
optimizer = torch.optim.SGD(wisdom.parameters(),lr=learn_rate)

#设置网络的一些参数
#记录的训练次数
total_train_step = 0
#记录测试次数
total_test_step = 0
#训练的轮数
epoch=10
#添加tensorboard
writer = SummaryWriter("logs_train")
#tensorboard --logdir "D:\pyc_workspace\learn_pytorch\logs_train"

for i in range(epoch):
    print("----第{}轮开始----".format(i+1))
    #开始训练
    #进入训练状态
    wisdom.train()

    for data in train_dataloader:
        imgs,targets = data
        imgs=imgs.cuda()
        targets=targets.cuda()
        outputs = wisdom(imgs)
        loss = loss_fn(outputs,targets)
        #优化器调优
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        total_train_step += 1
        if total_train_step % 100 ==0:
            print("训练次数：{},loss:{}:".format(total_train_step,loss))
            writer.add_scalar("train_loss",loss.item(),total_train_step)

    #模型测试
    #模型进入测试状态
    wisdom.eval()
    total_test_loss=0
    total_accuracy = 0
    with torch.no_grad():# 提高推理速度和节省内存
        for data in test_dataloader:
            imgs,targets = data
            imgs = imgs.cuda()
            targets = targets.cuda()
            outputs = wisdom(imgs )
            loss = loss_fn(outputs,targets)
            total_test_loss=total_test_loss+loss.item()
            accuracy = (outputs.argmax(1)==targets).sum()
            total_accuracy=total_accuracy+accuracy

    print("整体测试集合的loss:{}".format(total_test_loss))
    print("整体测试集合的准确率:{}".format(total_accuracy/test_data_size))
    writer.add_scalar("test_loss", total_test_loss, total_test_step)
    writer.add_scalar("test_accuracy", total_accuracy/test_data_size, total_test_step)
    total_test_step +=1

    torch.save(wisdom,"./model_train/wisdom_{}.pth".format(i))
    print("模型已经保存！")
    #torch.save(wisdom.state_dict(),"./model_train/wisdom_{}.pth".format(i))
writer.close()

test.py

利用神经网络模型进行分类，记得把

img_path ="dog.jpg"改成自己的路径
import torch
import torchvision
from PIL import Image
from torch import nn
from torch.nn import Sequential

train_data = torchvision.datasets.CIFAR10("./dataset",train=True,transform=torchvision.transforms.ToTensor(),download=True)
classes_list = train_data.classes#分类物体列表

img_path ="dog.jpg"
# img_path ="airplane.jpg"
image = Image.open(img_path)
#image = image.convert("RGB")#只保留为3通道

transform = torchvision.transforms.Compose([torchvision.transforms.Resize((32,32,)),torchvision.transforms.ToTensor()])
image = transform(image)
print(image.shape)
class Wisdom(nn.Module):
    def __init__(self):
        super(Wisdom, self).__init__()
        self.model1 = Sequential(
            nn.Conv2d(3, 32, 5, padding=2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 32, 5, padding=2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 5, padding=2),
            nn.MaxPool2d(2),
            nn.Flatten(),
            nn.Linear(1024, 64),
            nn.Linear(64, 10)

        )

    def forward(self, x):
        x = self.model1(x)

        return x

#加载网络模型
model = torch.load("./model_train/wisdom_49.pth")
#出现runtimer error 将模型加载方式换成下列语句，将GPU训练的模型映射到CPU
#model = torch.load("./model_train/wisdom_9.pth",map_location=torch.device("cpu"))
print(model)

image=torch.reshape(image,(1,3,32,32))#增加batch_size维度
model.eval()
with torch.no_grad():
    image = image.cuda()#使用GPU训练的模型需要加CUDA
    output = model(image)
print(output)
classes_index=output.argmax(1).item()
print(classes_list)

print("测试图片为：{}".format(classes_list[classes_index]))

总结：------>多看官网 <------


http://www.kler.cn/a/292714.html

相关文章：

  • 为什么hbase在大数据领域渐渐消失
  • 比ChatGPT更酷的AI工具
  • HBase使用create创建表时报错ERROR: KeeperErrorCode = NoNode for /hbase/master
  • 【OH】openHarmony开发环境搭建（基于windows子系统WSL）
  • 实现 MVC 模式
  • 性能优化、安全
  • 使用Python中的igraph为绘图添加标题和图例
  • Ventoy启动盘制作
  • 计算机网络10——数据库语法1
  • 【2024数模国赛赛题思路公开】国赛B题第二套思路丨附可运行代码丨无偿自提
  • 数字电子技术-码制
  • 总结24个Python接单赚钱平台与详细教程，兼职月入5000+
  • 视频编码与传输 学习笔记 1 一些视频压缩算法的介绍
  • Android kernel 配置docker
  • 前后端时间正确传递
  • 【扇贝编程】python爬虫——爬取动态网页笔记
  • getent passwd 获取linux并显示用户账户信息
  • 【数据结构-二维前缀异或和】【分区算法优化】力扣1738. 找出第 K 大的异或坐标值
  • CNN的魅力：探索卷积神经网络的无限可能
  • 信息安全--（五）物理与环境安全技术（二）机房安全分析与防护
  • Redis从简单使用到底层原理与分布式缓存
  • STM32外部中断（总结了易出现的BUG）
  • 基于springboot的二手车交易系统的设计与实现
  • 在 Cloud TPU Pod 上训练 PyTorch 模型
  • Java重修笔记 第四十八天 TreeSet 类、TreeMap 类
  • 计算机毕设选题推荐-基于python的剧本杀预约服务平台【python-爬虫-大数据定制】