机器学习周报（9.16-9.22）-Pytorch学习（四）

news2024/9/22 14:45:16

文章目录

    • 摘要
    • Abstract
    • 1 完整模型训练套路及模型验证套路
      • 1.1 模型及训练代码
      • 1.2 利用GPU训练模型
      • 1.3 完整的模型验证（测试）套路
    • 2 CNN 实现mnist手写数字识别
      • 2.1 网络模型搭建
      • 2.2 测试训练好的模型
    • 总结

摘要

通过学习CNN模型的训练及验证套路，对模型训练以及模型验证套路有了基本认识，并趁热打铁使用CNN模型实现mnist手写数字识别的实操

Abstract

By learning the training and verification routines of CNN model, I have a basic understanding of the training and verification routines of the model, and use the CNN model to realize the practical operation of mnist handwritten digit recognition

1 完整模型训练套路及模型验证套路

完整模型训练套路(以CIFAR10数据集为例)
在这里插入图片描述

1.1 模型及训练代码

model.py

import torch
import torch.nn as nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential

# model
class model(nn.Module):
    def __init__(self):
        super(model, self).__init__()
        self.m = Sequential(
            Conv2d(in_channels=3, out_channels=32, kernel_size=5, stride=1, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, 1, 2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, 1, 2),
            MaxPool2d(2),
            Flatten(),
            Linear(64*4*4, 64),
            Linear(64, 10)
        )

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

# 在该模块中测试model
if __name__ == '__main__':
    m = model()
    input = torch.ones([64, 3, 32, 32])
    output = m(input)
    print(output.shape)

补充：

  • argmax()使用
import torch

output = torch.tensor([[0.1, 0.5],
                       [0.2, 0.4]])

# dim = 1 数组横向比较中较大的下标
print(output.argmax(dim=1))  # tensor([1, 1])
# dim = 0 数组纵向比较中较大的下标
print(output.argmax(dim=0))  # tensor([1, 0])

train,py

import torch
import torchvision
from torch.utils.data import DataLoader
from torch.nn import CrossEntropyLoss
from torch.utils.tensorboard import SummaryWriter
# 引入网络模型
from model import *


# 训练数据集
train_data = torchvision.datasets.CIFAR10("dataset2", train=True, transform=torchvision.transforms.ToTensor())
# 测试数据集
test_data = torchvision.datasets.CIFAR10("dataset2", train=False, transform=torchvision.transforms.ToTensor())

# 数据长度
train_data_size = len(train_data)
test_data_size =len(test_data)
print("训练集数据长度为：{}".format(train_data_size))  # 50000
print("测试集数据长度为：{}".format(test_data_size))   # 10000

# 利用DataLoader来加载数据集
train_Dataloader = DataLoader(train_data, batch_size=64)
test_Dataloader = DataLoader(test_data, batch_size=64)

# 创建网络模型
mm = model()

# 损失函数
loss_fn = CrossEntropyLoss()

# 优化器
# 学习率：learing_rate = 0.01
# 1e-2 = 1×(10)^（-2)=1/100 = 0.01
learning_rate = 1e-2
optimizer = torch.optim.SGD(mm.parameters(),lr=learning_rate)

# 设置训练网络的一些参数
# 记录训练的次数
total_train_step = 0
# 记录测试的次数
total_test_step = 0
# 训练的轮数
epoch = 20

# 添加tensorboard
writer = SummaryWriter("logs_train")

# 训练的轮数
for i in range(epoch):
    print("--------第{}轮训练开始------".format(i+1))

    # 训练步骤开始
    mm.train()
    for data in train_Dataloader:
        imgs, target = data
        outputs = mm(imgs)
        loss = loss_fn(outputs,target)

        # 优化器优化模型
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        total_train_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(), global_step=total_train_step)

    # 测试步骤开始
    mm.eval()
    # 记录整个测试集上的loss
    total_test_loss = 0
    # 整体正确的个数
    total_accuracy = 0
    with torch.no_grad():
        for data in test_Dataloader:
            imgs, target = data
            outputs = mm(imgs)
            loss = loss_fn(outputs, target)
            total_test_loss = total_test_loss + loss.item()
            accuracy = (outputs.argmax(1) == target).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 = total_test_step + 1

    torch.save(mm, "model_{}.pth".format(i))
    print("模型已保存")


writer.close()

在这里插入图片描述
注：在train.py代码中，在模型开始训练和开始测试前分别加上model.train() 和 model.eval() ，在模型中有dropout、BatchNorm等网络层时，会起作用

1.2 利用GPU训练模型

xx = xx.cuda()

if torch.cuda.is_available():
    # 网络模型使用GPU
    module = module.cuda()
 
 
if torch.cuda.is_available():
    # 损失函数使用GPU
    loss_func = loss_func.cuda()
 
 
# 训练数据使用GPU
    if torch.cuda.is_available():
        imgs = imgs.cuda()
        targets = targets.cuda()
 
 
# 测试数据使用GPU
   if torch.cuda.is_available():
       imgs = imgs.cuda()
       targets = targets.cuda()

xx = xx.to(device)

# 定义训练的设备
# device = torch.device("cuda:0")
# device = torch.device("cuda:1")
device = torch.device("cuda")
 
# 网络模型使用GPU
module = module.to(device)
 
# 损失函数使用GPU
loss_func = loss_func.to(device)
 
# 训练数据使用GPU
imgs = imgs.to(device)
targets = targets.to(device)
 
# 测试数据使用GPU
imgs = imgs.to(device)
targets = targets.to(device)

1.3 完整的模型验证（测试）套路

利用已经训练好的模型，给它提供输入

# 测试model
import torch
from PIL import Image
import torch.nn as nn

import torchvision

# 读取测试图片

img_path = "./images/horse.png"
img = Image.open(img_path)
print(img)  # <PIL.PngImagePlugin.PngImageFile image mode=RGBA size=500x299 at 0x1DB5DC6E880>

transform = torchvision.transforms.Compose([torchvision.transforms.Resize((32, 32)),
                                            torchvision.transforms.ToTensor()])
# 将其改为三通道
# 将img转换为RGB的形式
img = img.convert('RGB')

img = transform(img)
# torch.Size([3, 32, 32])
print(img.shape)

# 加载已训练好的模型

# model
class model(nn.Module):
    def __init__(self):
        super(model, self).__init__()
        self.m = Sequential(
            Conv2d(in_channels=3, out_channels=32, kernel_size=5, stride=1, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, 1, 2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, 1, 2),
            MaxPool2d(2),
            Flatten(),
            Linear(64*4*4, 64),
            Linear(64, 10)
        )

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


m = torch.load("model_19.pth", map_location=torch.device('cpu'))
print(model)
img = torch.reshape(img, (1, 3, 32, 32))

# 验证开始
m.eval()
# 不进行反向传播，计算梯度
with torch.no_grad():
    result = m(img)

print(result)
print(result.argmax(1).item())

测试图片：

在这里插入图片描述

在这里插入图片描述

输入数组中，下标7的值最大，对应为horse
在这里插入图片描述

# 使用gpu训练保存的模型在cpu上使用
model = torch.load("XXXX.pth",map_location= torch.device("cpu"))

2 CNN 实现mnist手写数字识别

MNIST手写数字数据集来源于是美国国家标准与技术研究所，是著名的公开数据集之一。数据集中的数字图片是由250个不同职业的人纯手写绘制

MNIST手写数字数据集中包含了70000张图片，其中60000张为训练数据，10000为测试数据

在这里插入图片描述

2.1 网络模型搭建

CNN模型搭建（借用参考文章网络结构图）

在这里插入图片描述

model.py

import torch.nn as nn
from torch.nn import Conv2d, MaxPool2d,Flatten, Linear,Sequential


class model(nn.Module):
    def __init__(self):
        super(model, self).__init__()
        self.m = Sequential(
            Conv2d(in_channels=1, out_channels=32, kernel_size=3, stride=1, padding=0),
            MaxPool2d(2),
            Conv2d(32, 64, kernel_size=3, stride=1, padding=0),
            MaxPool2d(2),
            Flatten(),
            Linear(64*5*5, 64),
            Linear(64, 10)
        )

    def forward(self, input):
        return self.m(input)

# 在该模块中测试model
if __name__ == '__main__':
    m = model()
    print(m)

train.py 进行网络模型的训练

import torch
from torch.utils.data import DataLoader
import torchvision
from model import *
from torch.nn import CrossEntropyLoss
from torch.utils.tensorboard import SummaryWriter

transforms = torchvision.transforms.Compose([
    torchvision.transforms.ToTensor(),
    torchvision.transforms.Normalize((0.1307,), (0.3081,)) #归一化
])

# 获取训练集
train_datas = torchvision.datasets.MNIST(root="dataset", train=True,transform=transforms ,download=True)

# 获取测试集
test_datas = torchvision.datasets.MNIST(root="dataset", train=False, transform=transforms, download=True)

'''
img, target = train_datas[0]
print(img.shape) # torch.Size([1, 28, 28])
'''

# 数据长度
train_datas_size = len(train_datas)
test_datas_size = len(test_datas)
print("训练集数据长度为：{}".format(train_datas_size)) # 60000
print("测试集数据长度：{}".format(test_datas_size)) # 10000

# 使用DataLoader加载数据
train_DataLoader = DataLoader(train_datas, batch_size=64)
test_DataLoader = DataLoader(test_datas, batch_size=64)

# 创建网络模型
m = model()
if torch.cuda.is_available():
    m = m.cuda()

# 损失函数
loss_fn = CrossEntropyLoss()
if torch.cuda.is_available():
    loss_fn = loss_fn.cuda()

# 优化器
# 学习率：learing_rate = 0.0001
learning_rate = 1e-3
optimizer = torch.optim.SGD(m.parameters(), lr=learning_rate)


# 设置训练网络的一些参数
# 记录训练的次数
total_train_step = 0
# 记录测试的次数
total_test_step = 0
# 训练的轮数
epoch = 60

# 添加tensorboard
writer = SummaryWriter("logs_train")


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

    # 训练步骤开始
    m.train()
    for data in train_DataLoader:
        img, target = data
        if torch.cuda.is_available():
            img =img.cuda()
            target = target.cuda()
        output = m(img)
        loss = loss_fn(output, target)

        # 优化器优化模型
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        total_train_step = total_train_step+1

        #没训练一百次z， 记录一下
        if total_train_step % 100 == 0:
            print("训练次数：{},Loss:{}".format(total_train_step, loss))
            writer.add_scalar("train_loss", loss.item(), global_step=total_train_step)


    #测试步骤开始
    m.eval()
    total_test_loss = 0
    # 整体正确的个数
    total_accuracy = 0
    with torch.no_grad():
        for data in test_DataLoader:
            img, target = data
            if torch.cuda.is_available():
                img = img.cuda()
                target = target.cuda()
            output = m(img)
            loss = loss_fn(output, target)
            total_test_loss = total_test_loss + loss
            accuracy = (output.argmax(1) == target).sum()
            total_accuracy = total_accuracy + accuracy


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


    torch.save(m, "model_{}.pth".format(i))
    print("模型已保存")

writer.close()

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

2.2 测试训练好的模型

import torch
from PIL import Image
import torchvision
from model import *

imgPath = "images/test.png"
image = Image.open(imgPath)
print(image)

print(image.mode) # RGBA 四通道
transform = torchvision.transforms.ToTensor()
image =image.convert('RGB')
print(image.mode)   # RGB 三通道

# 通道转换
def change_image_channels(image):
    # 3通道转单通道
    if image.mode == 'RGB':
        r, g, b = image.split()
    return r, g, b

image1, image2, image3 = change_image_channels(image)
print(image1)   # <PIL.Image.Image image mode=L size=28x28 at 0x1EC38C14DF0>
print(image2)   # <PIL.Image.Image image mode=L size=28x28 at 0x1EC38B76B80>
print(image3)   # <PIL.Image.Image image mode=L size=28x28 at 0x1EC478718E0>
# image1.show()
image1 = transform(image1)
print(image1.shape)
image1 = torch.reshape(image1,[-1, 1, 28, 28])
print(image1.shape)

model = torch.load("model_59.pth", map_location=torch.device('cpu'))
with torch.no_grad():
    output = model(image1)
print(output)
print(output.argmax().item())

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

总结

通过学习模型的基本训练套路和验证套路，对代码的使用有了基本的认识，但还是要多加训练和使用。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2155285.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【服务器入门】Linux系统基础知识

【服务器入门】Linux系统基础知识

【服务器入门】Linux系统基础知识 远程登录与文件传输基础命令与文本编辑vi/vim使用shell脚本基本命令1、目录操作2、文件创建与删改3、文件连接与查看 参考 目前超算使用的系统以Linux系统为主&#xff0c;肯定需要了解一些相关知识。本博客就以本人运行WRF模型所需&#xff0…
阅读更多...
LeetCode[中等] 155. 最小栈

LeetCode[中等] 155. 最小栈

设计一个支持 push &#xff0c;pop &#xff0c;top 操作&#xff0c;并能在常数时间内检索到最小元素的栈。 实现 MinStack 类: MinStack() 初始化堆栈对象。void push(int val) 将元素val推入堆栈。void pop() 删除堆栈顶部的元素。int top() 获取堆栈顶部的元素。int get…
阅读更多...
Docker配置代理解决pull超时问题

Docker配置代理解决pull超时问题

操作系统: CentOS Linux 8 Docker版本: 26.1.3 前置&#xff1a;你需拥有&#x1f431; 1. 配置 proxy.conf 1.1 创建配置文件目录 创建 docker.service.d&#xff0c;进入到 docker.service.d 中打开 proxy.conf (没有文件打开会自动创建)。 注意&#xff1a;每个人的路径可…
阅读更多...
【数据结构-二维差分】力扣2536. 子矩阵元素加 1

【数据结构-二维差分】力扣2536. 子矩阵元素加 1

给你一个正整数 n &#xff0c;表示最初有一个 n x n 、下标从 0 开始的整数矩阵 mat &#xff0c;矩阵中填满了 0 。 另给你一个二维整数数组 query 。针对每个查询 query[i] [row1i, col1i, row2i, col2i] &#xff0c;请你执行下述操作&#xff1a; 找出 左上角 为 (row1…
阅读更多...
【漏洞复现】Nacos Derby SQL注入漏洞

【漏洞复现】Nacos Derby SQL注入漏洞

Nacos Derby SQL注入漏洞 Nacos Derby SQL注入漏洞&#xff08;CNVD-2020-67618&#xff09;是一个重要的安全问题&#xff0c;它涉及到Nacos中使用的Derby数据库存在的SQL注入风险。SQL注入是一种攻击手段&#xff0c;攻击者通过在应用程序的输入字段中插入恶意的SQL代码&…
阅读更多...
Day6:反转链表

Day6:反转链表

题目&#xff1a;给你单链表的头节点head&#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 输入&#xff1a;head[1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1] public ListNode reverseList() {if (head null) {return head;}ListNode cur head.next;head.next null…
阅读更多...
virtualbox中的网络模式，网络设置，固定IP

virtualbox中的网络模式，网络设置，固定IP

virtualbox关于网络设置的文档&#xff1a;https://www.virtualbox.org/manual/topics/networkingdetails.html#networkingdetails DHCP Dynamic Host Configuration Protocol&#xff1a;动态主机配置协议&#xff0c;是专门用来给网络中的节点分发IP地址&#xff0c;确保每…
阅读更多...
浏览器插件利器--allWebPluginV2.0.0.20-stable版发布

浏览器插件利器--allWebPluginV2.0.0.20-stable版发布

allWebPlugin简介 allWebPlugin中间件是一款为用户提供安全、可靠、便捷的浏览器插件服务的中间件产品&#xff0c;致力于将浏览器插件重新应用到所有浏览器。它将现有ActiveX控件直接嵌入浏览器&#xff0c;实现插件加载、界面显示、接口调用、事件回调等。支持Chrome、Firefo…
阅读更多...
【ChatGPT】提示词助力高效文献处理、公文撰写、会议纪要与视频总结

【ChatGPT】提示词助力高效文献处理、公文撰写、会议纪要与视频总结

博客主页&#xff1a; [小ᶻZ࿆] 本文专栏: AIGC | ChatGPT 文章目录 &#x1f4af;前言&#x1f4af;高效英文文献阅读提示词使用方法 &#x1f4af;高效公文写作提示词使用方法 &#x1f4af;高效会议纪要提示词使用方法 &#x1f4af;高效视频内容分析提示词使用方法 &a…
阅读更多...
空栈压数 - 华为OD统一考试(E卷)

空栈压数 - 华为OD统一考试(E卷)

2024华为OD机试&#xff08;E卷D卷C卷&#xff09;最新题库【超值优惠】Java/Python/C合集 题目描述 向一个空栈压入正整数&#xff0c;每当压入一个整数时&#xff0c;执行以下规则&#xff08;设&#xff1a;栈顶至栈底整数依次编号为 $n_1, n_2, \dots, n_x $&#xff0c;其…
阅读更多...
MATLAB入门基础篇

MATLAB入门基础篇

1. 数值计算和符号计算功能 在MATLAB环境中，有超过500种数学、统计、科学及工程方面的函数可使用，函数的标示自然，使得问题和解答像数学式子一般简单明了，让使用者可全力发挥在解题方面，而非浪费在电脑操作上. 2.图形功能 利用MATLAB的高级图形命令可以轻而易举地绘…
阅读更多...
LangChain基础知识大全

LangChain基础知识大全

LangChain基础知识大全 一、部署ChatGLM-6B1.拉取源码2.安装环境3.下载模型4.修改api.py配置5.运行api.py 二、Models组件1.LLM&#xff08;大语言模型&#xff09;2.Chat Model&#xff08;聊天模型&#xff09;3.Embedding Model&#xff08;嵌入模型&#xff09;3.1 下载中文…
阅读更多...
介绍 2款 Oracle 开发工具

介绍 2款 Oracle 开发工具

准备工作 Oracle SQL Developer 下载&#xff08;免费&#xff09; Oracle 的官方网站下载 Oracle SQL Developer。以下是下载的步骤&#xff1a; 访问 Oracle SQL Developer 官方下载页面。点击页面上的“下载”链接。选择适合你操作系统的版本&#xff08;Windows、macO…
阅读更多...
Spark原理及调优

Spark原理及调优

spark官档 hints&#xff1a;https://spark.apache.org/docs/3.0.0/sql-ref-syntax-qry-select-hints.html调优参数&#xff1a;https://spark.apache.org/docs/latest/sql-performance-tuning.html#join-strategy-hints-for-sql-queries作者几乎把所有的RDD API查了个遍&…
阅读更多...
Python 中的 Socket 编程入门

Python 中的 Socket 编程入门

Python 中的 Socket 编程入门 Socket 编程是网络编程的重要组成部分&#xff0c;允许计算机通过网络进行通信。在 Python 中&#xff0c;使用内置的 socket 模块&#xff0c;开发者可以轻松地实现客户端和服务器之间的交互。本文将详细介绍 Python 中的 Socket 编程&#xff0…
阅读更多...
微服务Docker相关指令

微服务Docker相关指令

1、拉取容器到镜像仓库 docker pull xxx //拉取指令到 镜像仓库 例如 docker pull mysql 、docker pull nginx docker images //查看镜像仓库 2、删除资源 2.1、删除镜像仓库中的资源 docker rmi mysql:latest //删除方式一&#xff1a;格式 docker rmi 要…
阅读更多...
19.初始C语言指针

19.初始C语言指针

初始C语言指针 1.指针的认识2.指针变量的引入3.指针变量的类型4.指针的应用场景15.指针的应用场景26.作业 1.指针的认识 指针 地址 //int a 10; //类型 变量名 内存地址 值 1.变量名直接访问2.通过地址访问&&#xff1a;取地址运算符* &#xff1a;将地址内的值读取…
阅读更多...
数据库数据恢复—Oracle报错“需要更多的恢复来保持一致性”的数据恢复案例

数据库数据恢复—Oracle报错“需要更多的恢复来保持一致性”的数据恢复案例

Oracle数据库故障&检测&#xff1a; 打开oracle数据库报错“system01.dbf需要更多的恢复来保持一致性&#xff0c;数据库无法打开”。 数据库没有备份&#xff0c;无法通过备份去恢复数据库。用户方联系北亚企安数据恢复中心并提供Oracle_Home目录中的所有文件&#xff0c;…
阅读更多...
GitHub 上高星 AI 开源项目推荐

GitHub 上高星 AI 开源项目推荐

FIFO-Diffusion 介绍&#xff1a;FIFO-Diffusion 是一个创新的开源项目&#xff0c;它能够基于文本描述生成无限长度的高品质视频&#xff0c;而无需任何预先的模型训练。这一技术的核心在于其高效的内存管理策略和先进的扩散模型&#xff0c;使得即使是小型GPU配置也能轻松应…
阅读更多...
1018. 可被 5 整除的二进制前缀

1018. 可被 5 整除的二进制前缀

目录 一&#xff1a;题目&#xff1a; 二&#xff1a;代码&#xff1a; 三&#xff1a;结果&#xff1a; 一&#xff1a;题目&#xff1a; 给定一个二进制数组 nums ( 索引从0开始 )。 我们将xi 定义为其二进制表示形式为子数组 nums[0..i] (从最高有效位到最低有效位)。 …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023