神经网络模型实现（训练、测试）

news2024/11/26 17:21:07

目录

  • 一、神经网络骨架：
  • 二、卷积操作：
  • 三、卷积层：
  • 四、池化层：
  • 五、激活函数（以ReLU为例）：
  • 六、模型搭建：
  • 七、损失函数、梯度下降：
  • 八、模型保存与加载：
  • 九、模型训练：
  • 十、模型测试：

一、神经网络骨架：

import torch
from torch import nn


#神经网络
class CLH(nn.Module):
    def __init__(self):
        super().__init__()

    def forward(self, input):
        output=input+1
        return output

clh = CLH()
x = torch.tensor(1.0)
output = clh(x)
print(output)

二、卷积操作：

import torch
import torch.nn.functional as F

input = torch.tensor([
    [1,2,0,3,1],
    [0,1,2,3,1],
    [1,2,1,0,0],
    [5,2,3,1,1],
    [2,1,0,1,1]
])
#卷积核
kernel = torch.tensor([
    [1,2,1],
    [0,1,0],
    [2,1,0]
])
#变化为卷积规定输入格式的维度：这里二维（x,y）转四维（t,z,x,y）
input = torch.reshape(input,(1,1,5,5))
kernel = torch.reshape(kernel,(1,1,3,3))

#对输入矩阵的上下左右进行分别padding扩充1列0，执行一次stride步长为1的卷积
output = F.conv2d(input, kernel, stride=1, padding=1)
print(output)

运行结果：
在这里插入图片描述

执行过程：
在这里插入图片描述

三、卷积层：

卷积在神经网络中用于提取输入数据的特征，通过与卷积核进行卷积操作来实现特征的提取和学习。

import torchvision
from torch import nn
from torch.utils.data import DataLoader
import torch.nn.functional as F

test_data = torchvision.datasets.CIFAR10("./dataset",train=False,transform=torchvision.transforms.ToTensor(),download=False)
#将数据划分为batch，每个batch有64个样本
dataloader = DataLoader(test_data,batch_size=64)

#神经网络
class CLH(nn.Module):
    def __init__(self):
        super(CLH,self).__init__()
        #神经网络中设置一个卷积层，in_channels表示输入通道数，out_channels表示输出通道数，并且卷积核尺寸为3×3的随机矩阵
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=6, kernel_size=3, stride=1, padding=0)
    def forward(self,input):
        #对输入数据执行一次二维卷积
        return self.conv1(input)

clh = CLH()

#data是一个batch
for data in dataloader:
    imgs,targets = data
    output = clh(imgs)
    #torch.Size([64, 3, 32, 32])表示[batchs大小，每个batch的通道数，每个通道x轴像素数，每个通道y轴像素数]
    print(imgs.shape)
    #torch.Size([64, 6, 30, 30])表示[batchs大小，每个batch的通道数，每个通道x轴像素数，每个通道y轴像素数]
    #其中每个通道由32×32像素变为30×30像素，其余的像素点组合成该batch的其他通道
    print(output.shape)

在这里插入图片描述

四、池化层：

最大池化的作用是为了保留特征同时将数据量缩小。
例如：1080p图像经过最大池化层变为720p。

import torch
from torch import nn
from torch.nn import MaxPool2d
#输入像素变为tensor类型
input = torch.tensor([
    [1,2,0,3,1],
    [0,1,2,3,1],
    [1,2,1,0,0],
    [5,2,3,1,1],
    [2,1,0,1,1]
],dtype=torch.float32)
#变化为池化规定输入格式的维度：这里二维（x,y）转四维（t,z,x,y）
input = torch.reshape(input,(1,1,5,5))

#神经网络
class CLH(nn.Module):
    def __init__(self):
        super(CLH,self).__init__()
        #神经网络中设置一个池化层，ceil_mode表示池化合覆盖输入数据不够时是否计算
        self.maxpool1 = MaxPool2d(kernel_size=3, ceil_mode=True)
    def forward(self,input):
        #对输入数据执行一次最大池化操作
        return self.maxpool1(input)

#创建神经网络
clh = CLH()

output = clh(input)
print(output)

运行结果：
在这里插入图片描述

执行过程：
1

五、激活函数（以ReLU为例）：

import torch
from torch import nn
from torch.nn import MaxPool2d, ReLU

#输入像素变为tensor类型
input = torch.tensor([
    [1,2,0,3,1],
    [0,1,2,3,1],
    [1,2,1,0,0],
    [5,2,3,1,1],
    [2,1,0,1,1]
],dtype=torch.float32)
#变化为池化规定输入格式的维度：这里二维（x,y）转四维（t,z,x,y）
input = torch.reshape(input,(1,1,5,5))

#神经网络
class CLH(nn.Module):
    def __init__(self):
        super(CLH,self).__init__()
        #神经网络中设置一个激活函数
        self.relu = ReLU()
    def forward(self,input):
        #对输入数据执行一次最大池化操作
        return self.relu(input)

#创建神经网络
clh = CLH()

output = clh(input)
print(output)

运行结果：
在这里插入图片描述

六、模型搭建：

在这里插入图片描述
上面的卷积神经网络模型共有8个隐藏层（卷积层+池化层）和1个输出层。

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


# 神经网络
class CLH(nn.Module):
    def __init__(self):
        super(CLH, self).__init__()
        #搭建模型架构，模型会按顺序从上到下执行
        self.model1 = Sequential(
            #卷积层，提取特征
            Conv2d(3, 32, 5, padding=2),
            #最大池化层，减小数据维度，防止过拟合
            MaxPool2d(2),
            #卷积层
            Conv2d(32, 32, 5, padding=2),
            #最大池化层
            MaxPool2d(2),
            #卷积层
            Conv2d(32, 64, 5, padding=2),
            #最大池化层
            MaxPool2d(2),
            #展平层，将输入数据展平为一维
            Flatten(),
            #全连接（线性）层，输入1024长度的一维向量，学习输入数据的非线性关系，输出64的特征一维向量
            Linear(1024, 64),

        )

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


clh = CLH()
print(clh)
#构建一个全0的输入，batch大小64，三通道，宽高为32×32
input = torch.ones((64, 3, 32, 32))
output = clh(input)
print(output.shape)

输出结果：
在这里插入图片描述

七、损失函数、梯度下降：

from torch import nn
from torch.nn import Conv2d
from torch.nn import MaxPool2d,Flatten,Linear, Sequential
import torch
import torchvision
from torch.utils.data import DataLoader
#获取数据，CIFAR10是一个十分类数据集
dataset = torchvision.datasets.CIFAR10("./dataset",train= False, transform =torchvision.transforms.ToTensor(), download=False)
#切分数据为batch
dataloader = DataLoader(dataset, batch_size=1, drop_last=True)

#神经网络模型搭建
class Tudui(nn.Module):
    def __init__(self):
        super(Tudui,self).__init__()
        self.model1 = Sequential(
            Conv2d(3, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32,64,5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024,64),
            Linear(64, 10)
        )
    def forward(self, x):
        x = self.model1(x)
        return x

tudui = Tudui()

#损失函数
loss = nn.CrossEntropyLoss()
#SGD（随机梯度下降）优化器，用于更新模型clh中的参数以最小化损失函数
optim = torch.optim.SGD(tudui.parameters(), lr=0.01)

#每个batch（data）执行如下操作
for data in dataloader:
    #特征和真实标签值
    imgs, targets = data
    #训练结果
    outputs = tudui(imgs)
    #计算损失
    result_loss = loss(outputs, targets)
    #每轮训练梯度清零，避免梯度累积
    optim.zero_grad()
    #反向传播计算损失函数关于模型各个参数的梯度（偏导数）
    result_loss.backward()
    #根据梯度更新模型参数，使用梯度下降算法进行参数更新
    optim.step()
    print(result_loss)

运行结果：
在这里插入图片描述

八、模型保存与加载：

保存：

import torchvision
import torch
vgg16 = torchvision.models.vgg16(pretrained=False)
# 保存方式1--保存模型结构及模型参数
torch.save(vgg16,"vgg16_method1.pth")

# 保存方式2--仅保存模型参数存为字典，不保存模型结构（官方推荐）
torch.save(vgg16.state_dict(),"vgg16_method2.pth")

读取：

import torch
import torchvision
# 保存方式1对应的加载模型结构 + 参数方式
model = torch.load("vgg16_method1.pth")
print(model)

# 保存方式2对应的加载模型参数方式
model2 = torch.load("vgg16_method2.pth") #加载的是字典
print(model2)

vgg16 = torchvision.models.vgg16(pretrained=False) #为方式2创建模型结构并加载参数的完整写法
vgg16.load_state_dict(torch.load("vgg16_method2.pth"))
print(vgg16)

九、模型训练：

在这里插入图片描述
上面的卷积神经网络模型共有8个隐藏层（卷积层+池化层）和1个输出层。

from torch.utils.tensorboard import SummaryWriter

import torch
import torchvision
import torch.nn as nn
from torch.utils.data import DataLoader

# 定义训练的设备
device = torch.device("cuda")
# 准备训练集
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)
# len()获取数据集长度
train_data_size = len(train_data)
test_data_size = len(test_data)
print("训练数据集的长度为：{}".format(train_data_size))
print("测试数据集的长度为：{}".format(test_data_size))

# 利用dataloader加载数据集,一个batch包含64个图片样本
train_dataloader = DataLoader(train_data, batch_size=64, drop_last=True)
test_dataloader = DataLoader(test_data, batch_size=64, drop_last=True)


# 创建网络模型，这里一般将网络模型单独定义一个文件
class CLH(nn.Module):
    def __init__(self):
        super(CLH, self).__init__()
        self.model = nn.Sequential(
            #卷积层
            nn.Conv2d(3, 32, 5, 1, 2),
            #最大池化层
            nn.MaxPool2d(2),
            nn.Conv2d(32, 32, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 5, 1, 2),
            nn.MaxPool2d(2),
            #展平为一维
            nn.Flatten(),  # 展平后的序列长度为 64*4*4=1024
            #全连接层
            nn.Linear(1024, 64),
            nn.Linear(64, 10)

        )

    def forward(self, x):
        x = self.model(x)
        return x


clh = CLH()
#设置为GPU训练
clh = clh.to(device)

# 损失函数
loss_fn = nn.CrossEntropyLoss()
loss_fn = loss_fn.to(device)

# 优化器（梯度下降算法）对clh.parameters()中的参数进行更新
learning_rate = 1e-2
optimizer = torch.optim.SGD(clh.parameters(), lr=learning_rate)

# 设置训练网络的一些参数
# 1.记录训练的次数
total_train_step = 0
# 2.记录测试的次数
total_test_step = 0
# 3.训练的轮数
epoch = 10

# 添加tensorboard可视化结果
writer = SummaryWriter("../logs_train")

#训练epoch轮
for i in range(epoch):
    print("-------------第 {} 轮训练开始------------".format(i + 1))
    # 训练步骤开始
    clh.train()
    #对于每个batch（data，包含64张图片）
    for data in train_dataloader:
        #获取batch中的样本和真实值标签
        imgs, targets = data

        imgs = imgs.to(device)
        targets = targets.to(device)
        #该batch的训练结果
        output = clh(imgs)
        #计算该batch（data）上的损失
        loss = loss_fn(output, targets)

        # 优化器优化模型
        #梯度清零
        optimizer.zero_grad()
        #计算损失函数关于每个参数的梯度
        loss.backward()
        #梯度下降算法更新参数
        optimizer.step()
        total_train_step = total_train_step + 1
        print("训练次数：{}， Loss：{}".format(total_train_step, loss.item()))
        writer.add_scalar("train_loss", loss.item(), total_train_step)


    # 测试步骤开始（感觉更像验证，但是并没有更新一些学习率之类的参数，仅仅进行了测试）
    clh.eval()
    total_test_loss = 0
    total_accuracy = 0
    #设置禁止更新梯度，防止测试集更新模型参数
    with torch.no_grad():
        #对于测试集上的每个batch（data，包含64张图片）
        for data in test_dataloader:
            imgs, targets = data
            imgs = imgs.to(device)
            targets = targets.to(device)
            #仅计算预测结果而不更新参数（torch.no_grad()）
            outputs = clh(imgs)
            #计算该batch（data）上的损失
            loss = loss_fn(outputs, targets)
            #计算整个测试集上的损失
            total_test_loss = total_test_loss + loss.item()
    print("整个测试集上的Loss：{}".format(total_test_loss))
    writer.add_scalar("test_loss", total_test_loss, total_test_step)
    total_test_step = total_test_step + 1

    #每轮（epoch）训练完成后保存该轮的训练模型
    torch.save(clh, "clh_{}.pth".format(i))
    print("-------------第{}轮训练结束，模型已保存-------------".format(i + 1))

writer.close()

部分执行结果：
在这里插入图片描述
在这里插入图片描述

十、模型测试：

import torchvision
from PIL import Image
import torch
#注意导入模型结构文件
from CLHmodule import *

#获取测试样本
image_path = "./dog.png"
image = Image.open(image_path)
print(image)

#将测试样本转换为模型规定的格式（和训练集样本尺寸要一样）
image = image.convert('RGB')
transform = torchvision.transforms.Compose([torchvision.transforms.Resize((32,32)),
                                            torchvision.transforms.ToTensor()
                                           ])
image = transform(image)
print(image)
image = torch.reshape(image,(1,3,32,32))

#加载模型
model = torch.load("clh_0.pth",map_location=torch.device("cuda"))
print(model)

#执行预测
model.eval()
with torch.no_grad():
    image = image.to("cuda")
    output = model(image)
#预测结果，十分类结果为10个值的一维向量，表示各个分类上的可能性
print(output)
#输出可能性最大的结果
print(output.argmax(1))

输出结果：
在这里插入图片描述

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

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

相关文章

Linux下安装JDK、Tomact、MySQL以及Nginx的超详细步骤

Linux下安装JDK、Tomact、MySQL以及Nginx的超详细步骤

目录 1、为什么安装这些软件 2、安装软件的方式 3、安装JDK 3.1 下载Linux版本的JDK 3.2 将压缩包拖拽到Linux系统下 3.3 解压jdk文件 3.4 修改文件夹名字 3.5 配置环境变量 4、安装Tomcat 4.1 下载Tomcat 4.2 将Tomcat放入Linux系统并解压，步骤如上面的…
阅读更多...
MenuToolButton自绘控件，带下拉框的QToolButton，附源码

MenuToolButton自绘控件，带下拉框的QToolButton，附源码

MenuToolButton自绘控件，带下拉框的QToolButton 效果 下拉样式可自定义 跟随QToolButton的Qt::ToolButtonStyle属性改变图标文字样式 使用示例 正常UI文件创建QToolButton然后提升，或者直接代码创建都可以。 // 创建一个 QList 对象来存储 QPixm…
阅读更多...
JDK、JRE、JVM的区别java的基本数据类型

JDK、JRE、JVM的区别java的基本数据类型

说一说JDK、JRE、JVM的区别在哪？ JDK： Java Delopment kit是java工具包，包含了编译器javac，调试器（jdb）以及其他用于开发和调试java程序的工具。JDK是开发人员在开发java应用程序时候所需要的的基本工具。…
阅读更多...
10道JVM经典面试题

10道JVM经典面试题

1、 JVM中，new出来的对象是在哪个区？ 2、 说说类加载有哪些步骤？ 3、 JMM是什么？ 4、 说说JVM内存结构？ 5、 MinorGC和FullGC有什么区别？ 6、 什么是STW? 7、 什么情况下会发生堆/栈溢出&#xff1f…
阅读更多...
【高中数学/对数函数】log_x_x+1与(x+1)/x,log_x+1_x与x/(x+1)的图线有着惊人的相似性

【高中数学/对数函数】log_x_x+1与(x+1)/x,log_x+1_x与x/(x+1)的图线有着惊人的相似性

【图像】 褐线与蓝线&#xff0c;黄线与绿线&#xff0c;只是像左右平移了一样。 【生成图像的代码】 <!DOCTYPE html> <html lang"utf-8"> <meta http-equiv"Content-Type" content"text/html; charsetutf-8"/> <head>…
阅读更多...
大模型学习笔记十二：AI产品部署

大模型学习笔记十二：AI产品部署

文章目录 一、如何选择GPU和云服务器厂商&#xff0c;追求最高性价比1&#xff09;根据场景选择GPU2&#xff09;训练或微调所需显卡&#xff08;以Falcon为例子&#xff09;3&#xff09;服务器价格计算器 二、全球大模型了解1&#xff09;llm所有模型2&#xff09;模型综合排…
阅读更多...
基于Python+Django，开发的一个在线教育系统

基于Python+Django，开发的一个在线教育系统

一、项目简介 使用Python的web框架Django进行开发的一个在线教育系统&#xff01; 二、所需要的环境与组件 Python3.6 Django1.11.7 Pymysql Mysql pure_pagination DjangoUeditor captcha xadmin crispy_forms 三、安装 1. 下载项目后进入项目目录cd Online-educ…
阅读更多...
企业微信PC版应用跳转到默认浏览器，避坑指南，欢迎补充（Vue项目版）。。。

企业微信PC版应用跳转到默认浏览器，避坑指南，欢迎补充（Vue项目版）。。。

引子 关于企业微信PC版应用跳转到默认浏览器&#xff0c;我之前写过一篇文章&#xff1a;企业微信PC版应用跳转到默认浏览器&#xff0c;避坑指南&#xff0c;欢迎补充。。。 以前的文章里用的前后端一体的Jsp项目&#xff0c;这次我使用的是前后端分离的Vue项目&#xff0c;…
阅读更多...
数据库——单表查询

数据库——单表查询

一、建立数据库mydb8_worker mysql> use mydb8_worker; 二、建立表 1.创建表 mysql> create table t_worker(department_id int(11) not null comment 部门号,-> worder_id int(11) primary key not null comment 职工号,-> worker_date date not null comment…
阅读更多...
Git安装教程 | Git配置教程 | Github

Git安装教程 | Git配置教程 | Github

&#x1f64b;大家好&#xff01;我是毛毛张! &#x1f308;个人首页&#xff1a; 神马都会亿点点的毛毛张 &#x1f4cc;本片教程是分享的Git教程的第1️⃣期&#xff1a;Git的安装与配置✈️ 文章目录 1.前言&#x1f347;2.Git下载&#x1f34e;3.Git 的安装&#x1f95d…
阅读更多...
Python数据风险案例54——人工智能热门概念股爬虫分析其价值(三因子模型)

Python数据风险案例54——人工智能热门概念股爬虫分析其价值(三因子模型)

案例背景 人工智能概念如火如荼的夏天&#xff0c;在这个2024年&#xff0c;我觉得需要提早布局一下这个概念。所以我们找一下A股里面人们的人工智能概念股&#xff0c;然后分析他们的数据应用三因子模型&#xff0c;也就是最经典的资本资产定价模型的衍生版去研究他们各自的投…
阅读更多...
内网穿透原理解析及软件

内网穿透原理解析及软件

&#x1f308;所属专栏&#xff1a;【其它】✨作者主页&#xff1a; Mr.Zwq✔️个人简介&#xff1a;一个正在努力学技术的Python领域创作者&#xff0c;擅长爬虫&#xff0c;逆向&#xff0c;全栈方向&#xff0c;专注基础和实战分享&#xff0c;欢迎咨询&#xff01; 您的点…
阅读更多...
OpenGL笔记十四之GLM数学库的配置与使用

OpenGL笔记十四之GLM数学库的配置与使用

OpenGL笔记十四之GLM数学库的配置与使用 —— 2024-07-20 中午 bilibili赵新政老师的教程看后笔记 code review! 文章目录 OpenGL笔记十四之GLM数学库的配置与使用1.旋转变换运行效果2.平移变换运行效果3.缩放变换运行效果4.复合变换&#xff1a;先旋转 再平移运行效果5.复合…
阅读更多...
Linux网络：应用层协议HTTP（一）

Linux网络：应用层协议HTTP（一）

一、什么是HTTP协议 虽然我们说, 应用层协议是我们程序猿自己定的. 但实际上, 已经有大佬们定义了一些现成的, 又非常好用的应用层协议, 供我们直接参考使用. HTTP(超文本传输协议)就是其中之一。 在互联网世界中&#xff0c;HTTP&#xff08;HyperText Transfer Protocol&…
阅读更多...
8 个实用写歌词技巧，让歌词富有感染力

8 个实用写歌词技巧，让歌词富有感染力

在音乐的领域中&#xff0c;一首好歌往往离不开充满感染力的歌词。这些歌词能够触动人们的心灵&#xff0c;引发共鸣&#xff0c;让人沉浸其中。接下来&#xff0c;为您分享 8 个实用技巧&#xff0c;帮助您创作出富有感染力的歌词&#xff0c;同时为您介绍“妙笔生词智能写歌词…
阅读更多...
OpenAI突发新模型GPT-4o mini，GPT-3.5退役!

OpenAI突发新模型GPT-4o mini，GPT-3.5退役!

OpenAI突发新模型&#xff0c;全面取代老去的GPT-3.5——GPT-4o mini&#xff01; 免费用户已可使用GPT-4o mini模型。 GPT-4o mini&#xff0c;能力接近原版GPT-4&#xff0c;价格却要便宜一个数量级&#xff1a; GPT-4o mini:每百万输入tokens&#xff0c;15美分&#xff0…
阅读更多...
降雨量预测 | Matlab基于ARIMA-RBF降雨量预测

降雨量预测 | Matlab基于ARIMA-RBF降雨量预测

目录 效果一览基本介绍程序设计参考资料 效果一览 基本介绍 降雨量预测 | Matlab基于ARIMA-RBF降雨量预测 注&#xff1a;程序和数据放在一个文件夹。 程序语言为matlab&#xff0c;程序可出预测效果图&#xff0c;指标图; 代码特点&#xff1a;参数化编程、参数可方便更改、代…
阅读更多...
SQL每日一题：寻找用户推荐人

SQL每日一题：寻找用户推荐人

题干 表: Customer -------------------- | Column Name | Type | -------------------- | id | int | | name | varchar | | referee_id | int | -------------------- 在 SQL 中&#xff0c;id 是该表的主键列。 该表的每一行表示一个客户的 id、姓名以及推荐他们的客户的 …
阅读更多...
如何建立一颗二叉树？（数据结构：树 + hash表 / 广搜BFS）

如何建立一颗二叉树？（数据结构：树 + hash表 / 广搜BFS）

一个二叉树&#xff0c;树中每个节点的权值互不相同。 现在给出它的后序遍历和中序遍历&#xff0c;请你输出它的层序遍历。 输入格式 第一行包含整数 N&#xff0c;表示二叉树的节点数。 第二行包含 N 个整数&#xff0c;表示二叉树的后序遍历。 第三行包含 N 个整数&…
阅读更多...
pytest常用命令行参数解析

pytest常用命令行参数解析

简介&#xff1a;pytest作为一个成熟的测试框架&#xff0c;它提供了许多命令行参数来控制测试的运行方式&#xff0c;以配合适用于不同的测试场景。例如 -x 可以用于希望出现错误就停止&#xff0c;以便定位和分析问题。–rerunsnum适用于希望进行失败重跑等个性化测试策略。 …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023