深度学习之神经网络框架搭建及模型优化

server/2025/2/12 3:50:25/

神经网络框架搭建及模型优化

目录

  • 神经网络框架搭建及模型优化
    • 1 数据及配置
      • 1.1 配置
      • 1.2 数据
      • 1.3 函数导入
      • 1.4 数据函数
      • 1.5 数据打包
    • 2 神经网络框架搭建
      • 2.1 框架确认
      • 2.2 函数搭建
      • 2.3 框架上传
    • 3 模型优化
      • 3.1 函数理解
      • 3.2 训练模型和测试模型代码
    • 4 最终代码测试
      • 4.1 SGD优化算法
      • 4.2 Adam优化算法
      • 4.3 多次迭代

1 数据及配置

1.1 配置

需要安装PyTorch,下载安装torch、torchvision、torchaudio，GPU需下载cuda版本，CPU可直接下载

cuda版本较大，最后通过控制面板pip install +存储地址离线下载，
CPU版本需再下载安装VC_redist.x64.exe，可下载上述三个后运行，通过报错网址直接下载安装

1.2 数据

使用的是 torchvision.datasets.MNIST的手写数据，包括特征数据和结果类别

1.3 函数导入

python">import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import ToTensor

1.4 数据函数

python">train_data = datasets.MNIST(root='data',        # 数据集存储的根目录train=True,         # 加载训练集download=True,      # 如果数据集不存在，自动下载transform=ToTensor() # 将图像转换为张量
)
  • root 指定数据集存储的根目录。如果数据集不存在，会自动下载到这个目录。
  • train 决定加载训练集还是测试集。True 表示加载训练集，False 表示加载测试集。
  • download 如果数据集不在 root 指定的目录中，是否自动下载数据集。True 表示自动下载。
  • transform 对加载的数据进行预处理或转换。通常用于将数据转换为模型所需的格式，如将图像转换为张量。

1.5 数据打包

train_dataloader = DataLoader(train_data, batch_size=64)

  • train_data, 打包数据
  • batch_size=64，打包个数

代码展示：

python">import torch
print(torch.__version__)
import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import ToTensortrain_data = datasets.MNIST(root = 'data',train = True,download = True,transform = ToTensor()
)
test_data = datasets.MNIST(root = 'data',train = False,download = True,transform = ToTensor()
)
print(len(train_data))
print(len(test_data))
from matplotlib import pyplot as plt
figure = plt.figure()
for i in range(9):img,label = train_data[i+59000]figure.add_subplot(3,3,i+1)plt.title(label)plt.axis('off')plt.imshow(img.squeeze(),cmap='gray')a = img.squeeze()
plt.show()train_dataloader = DataLoader(train_data, batch_size=64)
test_dataloader= DataLoader(test_data, batch_size=64)

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

在这里插入图片描述

调试查看:

在这里插入图片描述
：

2 神经网络框架搭建

2.1 框架确认

在搭建神经网络框架前，需先确认建立怎样的框架，目前并没有理论的指导，凭经验建立框架如下：

输入层：输入的图像数据（28*28）个神经元。
中间层1：全连接层，128个神经元，
中间层2：全连接层，256个神经元，
输出层：全连接层，10个神经元，对应10个类别。
需注意，中间层需使用激励函数激活，对累加数进行非线性的映射，以及forward前向传播过程的函数名不可更改，

2.2 函数搭建

  • nn.Flatten() ， 将输入展平为一维向量
  • nn.Linear(28*28, 128) ，全连接层，需注意每个连接层的输入输出需前后对应
  • torch.sigmoid(x)，对中间层的输出应用Sigmoid激活函数
python"># 定义一个神经网络类，继承自 nn.Module
class NeuralNetwork(nn.Module):def __init__(self):super().__init__()  # 调用父类 nn.Module 的构造函数# 定义网络层self.flatten = nn.Flatten()  # 将输入展平为一维向量，适用于将图像数据（如28x28）展平为784维self.hidden1 = nn.Linear(28*28, 128)  # 第一个全连接层，输入维度为784（28*28），输出维度为128self.hidden2 = nn.Linear(128, 256)    # 第二个全连接层，输入维度为128，输出维度为256self.out = nn.Linear(256, 10)         # 输出层，输入维度为256，输出维度为10（对应10个类别）# 定义前向传播过程def forward(self, x):x = self.flatten(x)       # 将输入数据展平x = self.hidden1(x)       # 通过第一个全连接层x = torch.sigmoid(x)      # 对第一个全连接层的输出应用Sigmoid激活函数x = self.hidden2(x)       # 通过第二个全连接层x = torch.sigmoid(x)      # 对第二个全连接层的输出应用Sigmoid激活函数x = self.out(x)           # 通过输出层return x                  # 返回最终的输出

2.3 框架上传

  • device = ‘cuda’ if torch.cuda.is_available() else ‘mps’ if torch.backends.mps.is_available() else ‘cpu’，确认设备， 检查是否有可用的GPU设备，如果有则使用GPU，否则使用CPU
  • model = NeuralNetwork().to(device)，框架上传到GPU/CPU

模型输出展示：

在这里插入图片描述

3 模型优化

3.1 函数理解

  • optimizer = torch.optim.Adam(model.parameters(), lr=0.001)，定义优化器：
    • Adam(）使用Adam优化算法，也可为SGD等优化算法
    • model.parameters()为优化模型的参数，
    • lr为学习率/梯度下降步长为0.001
  • loss_fn = nn.CrossEntropyLoss(pre,y)，定义损失函数，使用交叉熵损失函数，适用于分类任务
    • pre,预测结果
    • y,真实结果
    • loss_fn.item()，当前损失值
  • model.train() ，将模型设置为训练模式，模型参数是可变的
  • x, y = x.to(device), y.to(device)，将数据移动到指定设备（GPU或CPU）
  • 反向传播：清零梯度，计算梯度，更新模型参数
    • optimizer.zero_grad() ，清零梯度缓存
      loss.backward()， 计算梯度
      optimizer.step() ， 更新模型参数
  • model.eval()，将模型设置为评估模式，模型参数是不可变
  • with torch.no_grad()，禁用梯度计算，在测试过程中不需要计算梯度

3.2 训练模型和测试模型代码

python">optimizer = torch.optim.Adam(model.parameters(),lr=0.001)
loss_fn = nn.CrossEntropyLoss()
def train(dataloader,model,loss_fn,optimizer):model.train()batch_size_num = 1for x,y in dataloader:x,y = x.to(device),y.to(device)pred = model.forward(x)loss = loss_fn(pred,y)optimizer.zero_grad()loss.backward()optimizer.step()loss_value = loss.item()if batch_size_num %100 ==0:print(f'loss: {loss_value:>7f}  [number: {batch_size_num}]')batch_size_num +=1train(train_dataloader,model,loss_fn,optimizer)def test(dataloader,model,loss_fn):size = len(dataloader.dataset)num_batches = len(dataloader)model.eval()test_loss,correct = 0,0with torch.no_grad():for x,y in dataloader:x,y = x.to(device),y.to(device)pred = model.forward(x)test_loss += loss_fn(pred,y).item()correct +=(pred.argmax(1) == y).type(torch.float).sum().item()a = (pred.argmax(1)==y)b = (pred.argmax(1)==y).type(torch.float)test_loss /=num_batchescorrect /= sizeprint(f'test result: \n Accuracy: {(100*correct)}%, Avg loss:{test_loss}')

4 最终代码测试

4.1 SGD优化算法

torch.optim.SGD(model.parameters(),lr=0.01)

代码展示：

python">import torchprint(torch.__version__)
import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import ToTensortrain_data = datasets.MNIST(root = 'data',train = True,download = True,transform = ToTensor()
)
test_data = datasets.MNIST(root = 'data',train = False,download = True,transform = ToTensor()
)
print(len(train_data))
print(len(test_data))
from matplotlib import pyplot as plt
figure = plt.figure()
for i in range(9):img,label = train_data[i+59000]figure.add_subplot(3,3,i+1)plt.title(label)plt.axis('off')plt.imshow(img.squeeze(),cmap='gray')a = img.squeeze()
plt.show()train_dataloader = DataLoader(train_data, batch_size=64)
test_dataloader= DataLoader(test_data, batch_size=64)
device = 'cuda' if torch.cuda.is_available() else 'mps' if torch.backends.mps.is_available() else 'cpu'
print(f'Using {device} device')
class NeuralNetwork(nn.Module):def __init__(self):super().__init__()self.flatten = nn.Flatten()self.hidden1 = nn.Linear(28*28,128)self.hidden2 = nn.Linear(128, 256)self.out = nn.Linear(256,10)def forward(self,x):x = self.flatten(x)x = self.hidden1(x)x = torch.sigmoid(x)x = self.hidden2(x)x = torch.sigmoid(x)x = self.out(x)return x
model = NeuralNetwork().to(device)
#
print(model)
optimizer = torch.optim.SGD(model.parameters(),lr=0.01)
loss_fn = nn.CrossEntropyLoss()
def train(dataloader,model,loss_fn,optimizer):model.train()batch_size_num = 1for x,y in dataloader:x,y = x.to(device),y.to(device)pred = model.forward(x)loss = loss_fn(pred,y)optimizer.zero_grad()loss.backward()optimizer.step()loss_value = loss.item()if batch_size_num %100 ==0:print(f'loss: {loss_value:>7f}  [number: {batch_size_num}]')batch_size_num +=1def test(dataloader,model,loss_fn):size = len(dataloader.dataset)num_batches = len(dataloader)model.eval()test_loss,correct = 0,0with torch.no_grad():for x,y in dataloader:x,y = x.to(device),y.to(device)pred = model.forward(x)test_loss += loss_fn(pred,y).item()correct +=(pred.argmax(1) == y).type(torch.float).sum().item()a = (pred.argmax(1)==y)b = (pred.argmax(1)==y).type(torch.float)test_loss /=num_batchescorrect /= sizeprint(f'test result: \n Accuracy: {(100*correct)}%, Avg loss:{test_loss}')
#train(train_dataloader,model,loss_fn,optimizer)
test(test_dataloader,model,loss_fn)

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

4.2 Adam优化算法

自适应算法，torch.optim.Adam(model.parameters(),lr=0.01)

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

4.3 多次迭代

代码展示：

python">import torchprint(torch.__version__)
import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import ToTensortrain_data = datasets.MNIST(root = 'data',train = True,download = True,transform = ToTensor()
)
test_data = datasets.MNIST(root = 'data',train = False,download = True,transform = ToTensor()
)
print(len(train_data))
print(len(test_data))
from matplotlib import pyplot as plt
figure = plt.figure()
for i in range(9):img,label = train_data[i+59000]figure.add_subplot(3,3,i+1)plt.title(label)plt.axis('off')plt.imshow(img.squeeze(),cmap='gray')a = img.squeeze()
plt.show()train_dataloader = DataLoader(train_data, batch_size=64)
test_dataloader= DataLoader(test_data, batch_size=64)
device = 'cuda' if torch.cuda.is_available() else 'mps' if torch.backends.mps.is_available() else 'cpu'
print(f'Using {device} device')
class NeuralNetwork(nn.Module):def __init__(self):super().__init__()self.flatten = nn.Flatten()self.hidden1 = nn.Linear(28*28,128)self.hidden2 = nn.Linear(128, 256)self.out = nn.Linear(256,10)def forward(self,x):x = self.flatten(x)x = self.hidden1(x)x = torch.sigmoid(x)x = self.hidden2(x)x = torch.sigmoid(x)x = self.out(x)return x
model = NeuralNetwork().to(device)
#
print(model)
optimizer = torch.optim.Adam(model.parameters(),lr=0.01)
loss_fn = nn.CrossEntropyLoss()
def train(dataloader,model,loss_fn,optimizer):model.train()batch_size_num = 1for x,y in dataloader:x,y = x.to(device),y.to(device)pred = model.forward(x)loss = loss_fn(pred,y)optimizer.zero_grad()loss.backward()optimizer.step()loss_value = loss.item()if batch_size_num %100 ==0:print(f'loss: {loss_value:>7f}  [number: {batch_size_num}]')batch_size_num +=1def test(dataloader,model,loss_fn):size = len(dataloader.dataset)num_batches = len(dataloader)model.eval()test_loss,correct = 0,0with torch.no_grad():for x,y in dataloader:x,y = x.to(device),y.to(device)pred = model.forward(x)test_loss += loss_fn(pred,y).item()correct +=(pred.argmax(1) == y).type(torch.float).sum().item()a = (pred.argmax(1)==y)b = (pred.argmax(1)==y).type(torch.float)test_loss /=num_batchescorrect /= sizeprint(f'test result: \n Accuracy: {(100*correct)}%, Avg loss:{test_loss}')
#train(train_dataloader,model,loss_fn,optimizer)
test(test_dataloader,model,loss_fn)
#
e = 30
for i in range(e):print(f'e: {i+1}\n------------------')train(train_dataloader, model, loss_fn, optimizer)
print('done')test(test_dataloader, model, loss_fn)

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


http://www.ppmy.cn/server/166937.html

相关文章

Vue与Konva：解锁Canvas绘图的无限可能

Vue与Konva：解锁Canvas绘图的无限可能

前言 在现代Web开发中，动态、交互式的图形界面已成为提升用户体验的关键要素。Vue.js，作为一款轻量级且高效的前端框架，凭借其响应式数据绑定和组件化开发模式，赢得了众多开发者的青睐。而当Vue.js邂逅Konva.js，两者结…
阅读更多...
MybatisPlusCRUD接口使用

MybatisPlusCRUD接口使用

1. MybatisPlus的CRUD接口 MybatisPlus提供了很多CRUD接口&#xff0c;可以直接使用这些接口来操作数据库。而不用像Mybatis那样写大量的XML文件及SQL语句。 Mapper CRUD接口 主要关键是继承BaseMapper<T>&#xff0c;其中T是实体类。 使用案例 Mapper层继承BaseMapper接…
阅读更多...
AWS Savings Plans 监控与分析工具使用指南

AWS Savings Plans 监控与分析工具使用指南

一、背景介绍 1.1 什么是 Savings Plans？ AWS Savings Plans 是一种灵活的定价模式，通过承诺持续使用一定金额的 AWS 服务来获得折扣价格。它可以帮助用户降低 AWS 使用成本，适用于 EC2、Fargate 和 Lambda 等服务。 1.2 为什么需要监控？ 优化成本支出跟踪使用情况评估投…
阅读更多...
Go语言构建微服务：从入门到实战

Go语言构建微服务：从入门到实战

引言 在云原生时代&#xff0c;微服务架构已成为构建复杂分布式系统的首选方案。Go语言凭借其卓越的并发支持、简洁的语法和高效的运行时&#xff0c;成为微服务开发的利器。本文将深入探讨如何用Go构建健壮的微服务系统&#xff0c;并通过完整案例演示关键实现细节。 一、微…
阅读更多...
Qt简单使用正则表达式

Qt简单使用正则表达式

正则表达式 用于数据处理&#xff0c;数据查询&#xff0c;数据格式验证&#xff0c;替换文本&#xff0c;提取字串&#xff0c;相比str函数正则技术&#xff0c;开销小 在Qt简单使用正则表达式 在qt中使用类QRegExp类使用正则表达式 需要使用头文件 #include <QRegExp>…
阅读更多...
Android Knowledge

Android Knowledge

1、安卓采用Log工具打印日志&#xff0c;将日志分为5个等级 Log.e:表示错误信息 Log.w:表示警告信息 Log.i:表示一般信息 Log.d:表示调试信息。可把程序运行时的变量值打印出来&#xff0c;方便跟踪调试 Log.v:表示冗余信息 2、pc如何与Android os之间进行连接&#xff1a;通过…
阅读更多...
深入理解指针初阶：从概念到实践

深入理解指针初阶：从概念到实践

一、引言 在 C 语言的学习旅程中&#xff0c;指针无疑是一座必须翻越的高峰。它强大而灵活&#xff0c;掌握指针&#xff0c;能让我们更高效地操作内存&#xff0c;编写出更优化的代码。但指针也常常让初学者望而生畏&#xff0c;觉得它复杂难懂。别担心&#xff0c;本文将用通…
阅读更多...
HarmonyOS：时间日期国际化

HarmonyOS：时间日期国际化

一、使用场景 在不同的国家和文化中&#xff0c;时间和日期格式的表示方法有所不同&#xff0c;使用惯例的不同点包括&#xff1a;日期中年月日的顺序、时间中时分秒的分隔符等。若应用中需展示时间日期&#xff0c;要确保界面以合适的方式显示&#xff0c;以便用户能够理解。 …
阅读更多...
最新文章

Copyright @ 2022~2023