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

PyTorch笔记6----------神经网络案例

news 2025/7/16 9:09:41

1.回归网络

波士顿房价预测模型搭建

波士顿房价数据集下载链接：百度网盘 请输入提取码 提取码: 5279 

  • 导入所需包
import torch
import numpy as np
import re
  • 读取数据
ff = open('housing.data').readlines()
data = []
for item in ff:out = re.sub(r"\s{2,}"," ",item).strip() #通过正则表达式去除所有空格data.append(out.split(" ")) #将每一个数据以空格为分隔符进行分割
data = np.array(data).astype(np.float64) #将数据转换为浮点型
Y = data[:,-1] #将最后一列作为标签
X = data[:,0:-1] #将前n-1列作为特征
X_train = X[0:496,...] #将前496行作为训练集
Y_train = Y[0:496,...] #将前496行作为训练集
X_test = X[496:,...] #将剩余行作为测试集
Y_test = Y[496:,...] #将剩余行作为测试集
print('X_train.shape:',X_train.shape)
print('Y_train.shape:',Y_train.shape)
print('X_test.shape:',X_test.shape)
print('Y_test.shape:',Y_test.shape)

        结果为： 

X_train.shape: (496, 13)
Y_train.shape: (496,)
X_test.shape: (10, 13)
Y_test.shape: (10,)
  •  定义回归网络模型
class Net(torch.nn.Module): #继承torch.nn.Module#初始化def __init__(self,n_feature,n_output):super(Net,self).__init__() #继承__init__功能self.predict = torch.nn.Linear(n_features, n_output) #定义线性回归模型#定义前向传播def forward(self,x):out = self.predict(x)return out
net = Net(13,1) #定义网络
  • 定义损失函数
loss_func = torch.nn.MSELoss() #定义均方误差损失函数
  • 定义优化器
optimizer = torch.optim.SGD(net.parameters(),lr=0.01) #定义随机梯度下降优化器，学习率为0.01
  • 训练模型
for i in range(1000):x_data = torch.tensor(X_train,dtype=torch.float32) #将训练集转换为张量y_data = torch.tensor(Y_train,dtype=torch.float32) #将训练集转换为张量pred = net.forward(x_data) #前向传播pred = torch.squeeze(pred) #将输出转换为一维张量loss = loss_func(pred,y_data) * 0.001 #计算损失optimizer.zero_grad() #清空梯度loss.backward() #反向传播optimizer.step() #更新参数print("ite:{},loss:{}".format(i,loss))print('前10个预测值:',pred[0:10])print('前10个真实值:',y_data[0:10])

        最后一轮打印的结果

ite:999,loss:0.08831662684679031
前10个预测值:tensor([22.8808, 18.8566, 20.0100, 20.6557, 20.1837, 19.5407, 23.6228, 21.4776,20.9730, 21.6817], grad_fn=<SliceBackward0>)
前10个真实值:tensor([24.0000, 21.6000, 34.7000, 33.4000, 36.2000, 28.7000, 22.9000, 27.1000,16.5000, 18.9000])
  • 测试模型
for i in range(1000):x_data = torch.tensor(X_test,dtype=torch.float32) #将测试集转换为张量y_data = torch.tensor(Y_test,dtype=torch.float32) #将测试集转换为张量pred = net.forward(x_data) #前向传播pred = torch.squeeze(pred) #将输出转换为一维张量loss = loss_func(pred,y_data) * 0.001 #计算损失print("ite:{},loss:{}".format(i,loss))

        测试最后一轮的结果

ite:999,loss:0.11018833518028259
  • 模型保存
torch.save(net,"houseModel.pkl")
  • 整体代码
import torch
import numpy as np
import re
#读取及处理房价数据
ff = open('housing.data').readlines()
data = []
for item in ff:out = re.sub(r"\s{2,}"," ",item).strip() #通过正则表达式去除所有空格data.append(out.split(" ")) #将每一个数据以空格为分隔符进行分割
data = np.array(data).astype(np.float64) #将数据转换为浮点型
Y = data[:,-1] #将最后一列作为标签
X = data[:,0:-1] #将前n-1列作为特征
X_train = X[0:496,...] #将前496行作为训练集
Y_train = Y[0:496,...] #将前496行作为训练集
X_test = X[496:,...] #将剩余行作为测试集
Y_test = Y[496:,...] #将剩余行作为测试集
#定义回归网络模型
class Net(torch.nn.Module): #继承torch.nn.Module#初始化def __init__(self,n_feature,n_output):super(Net,self).__init__() #继承__init__功能self.predict = torch.nn.Linear(n_feature, n_output) #定义线性回归模型#定义前向传播def forward(self,x):out = self.predict(x)return out
net = Net(13,1) #定义网络
#定义损失函数
loss_func = torch.nn.MSELoss() #定义均方误差损失函数
#定义优化器
optimizer = torch.optim.SGD(net.parameters(),lr=0.0001) #定义随机梯度下降优化器，学习率为0.0001
#模型训练
for i in range(1000):x_data = torch.tensor(X_train,dtype=torch.float32) #将训练集转换为张量y_data = torch.tensor(Y_train,dtype=torch.float32) #将训练集转换为张量pred = net.forward(x_data) #前向传播pred = torch.squeeze(pred) #将输出转换为一维张量loss = loss_func(pred,y_data) * 0.001 #计算损失optimizer.zero_grad() #清空梯度loss.backward() #反向传播optimizer.step() #更新参数
#模型测试
for i in range(1000):x_data = torch.tensor(X_test,dtype=torch.float32) #将测试集转换为张量y_data = torch.tensor(Y_test,dtype=torch.float32) #将测试集转换为张量pred = net.forward(x_data) #前向传播pred = torch.squeeze(pred) #将输出转换为一维张量loss = loss_func(pred,y_data) * 0.001 #计算损失
torch.save(net,"houseModel.pkl")
  • 使用保存的模型
import torch
import numpy as np
import re
#定义回归网络模型
class Net(torch.nn.Module): #继承torch.nn.Module#初始化def __init__(self,n_feature,n_output):super(Net,self).__init__() #继承__init__功能self.predict = torch.nn.Linear(n_feature, n_output) #定义线性回归模型#定义前向传播def forward(self,x):out = self.predict(x)return out
#读取及处理房价数据
ff = open('housing.data').readlines()
data = []
for item in ff:out = re.sub(r"\s{2,}"," ",item).strip() #通过正则表达式去除所有空格data.append(out.split(" ")) #将每一个数据以空格为分隔符进行分割
data = np.array(data).astype(np.float64) #将数据转换为浮点型
Y = data[:,-1] #将最后一列作为标签
X = data[:,0:-1] #将前n-1列作为特征
X_train = X[0:496,...] #将前496行作为训练集
Y_train = Y[0:496,...] #将前496行作为训练集
X_test = X[496:,...] #将剩余行作为测试集
Y_test = Y[496:,...] #将剩余行作为测试集
net = torch.load("houseModel.pkl", weights_only=False) #加载模型,加载模型时需要指定weights_only=False,这样 PyTorch 就会加载整个模型（包括结构和权重）
loss_func = torch.nn.MSELoss() #定义均方误差损失函数
x_data = torch.tensor(X_test,dtype=torch.float32) #将测试集转换为张量
y_data = torch.tensor(Y_test,dtype=torch.float32) #将测试集转换为张量
pred = net.forward(x_data) #前向传播
pred = torch.squeeze(pred) #将输出转换为一维张量
loss = loss_func(pred,y_data) * 0.001 #计算损失
print("loss:{}".format(loss))

        运行结果为：

loss:0.028316091746091843

1.分类网络

手写数字分类

  • 导入所需包
import torch
import torchvision.datasets as datasets # 导入手写数字数据集
import torchvision.transforms as transforms #数据预处理
import torch.utils.data as data_utils #数据处理
  • 数据处理
train_data = datasets.MNIST(root="",train=True,transform=transforms.ToTensor(),download=True) #下载数据集，并加载训练集
test_data = datasets.MNIST(root="",train=False,transform=transforms.ToTensor(),download=False) #并加载测试集
train_loader = data_utils.DataLoader(dataset=train_data,batch_size=64,shuffle=True) #将数据集分成64个batch,并打乱顺序
test_loader = data_utils.DataLoader(dataset=test_data,batch_size=64,shuffle=True) #将数据集分成64个batch,并打乱顺序
  • 定义分类网络模型
class CNN(torch.nn.Module):def __init__(self):super(CNN,self).__init__()self.conv = torch.nn.Sequential( #定义卷积ngtorch.nn.Conv2d(1,32,kernel_size=5,padding=2), #输入通道数为1，输出通道数为32，卷积核大小为5，填充为1torch.nn.BatchNorm2d(32), #批归一化torch.nn.ReLU(), #激活函数torch.nn.MaxPool2d(2) #最大池化)self.fc = torch.nn.Linear(14*14*32,10) #定义全连接层def forward(self,x):out =self.conv(x) #卷积层out = out.view(out.size()[0],-1) #将输出展平out = self.fc(out) #全连接层return out
cnn =CNN()
  • 定义损失函数
loss_fn = torch.nn.CrossEntropyLoss() #交叉熵损失函数
  • 定义优化器
optimizer = torch.optim.Adam(cnn.parameters(),lr=0.001) #Adam优化器
  • 训练模型
#训练模型
for epoch in range(10): #训练10个epoch  for i,(images,labels) in enumerate(train_loader): #遍历训练集output = cnn(images) #将输入数据传入模型loss = loss_fn(output,labels) #计算损失optimizer.zero_grad() #清空梯度loss.backward() #反向传播optimizer.step() #更新参数print("epoch is {},ite is{}/{},loss is {}".format(epoch+1,i,len(train_data)//64,loss.item()))

        训练中其中一条训练结果

epoch is 2,ite is41/937,loss is 0.013103657402098179
  • 测试模型 

        因为训练时间太久，这里就不放训练结果了

loss_test = 0
accuracy = 0
for epoch in range(10):for i,(images,labels) in enumerate(test_loader):outputs = cnn(images)loss_test += loss_fn(outputs,labels) _,pred = output.max(1)accuracy += (pred == labels).sum().item()accuracy = accuracy / len(test_data)loss_test = loss_test / (len(test_data)//64)print("epoch is {},loss is {},accuracy is {}".format(epoch+1,loss_test.item(),accuracy))
  • 模型保存
torch.save(cnn,"handwriteNumber.pkl")
  •  整体代码
import torch
import torchvision.datasets as datasets # 导入手写数字数据集
import torchvision.transforms as transforms #数据预处理
import torch.utils.data as data_utils #数据处理
#数据处理
train_data = datasets.MNIST(root="",train=True,transform=transforms.ToTensor(),download=True) #下载数据集，并加载训练集
test_data = datasets.MNIST(root="",train=False,transform=transforms.ToTensor(),download=False) #并加载测试集
train_loader = data_utils.DataLoader(dataset=train_data,batch_size=64,shuffle=True) #将数据集分成64个batch,并打乱顺序
test_loader = data_utils.DataLoader(dataset=test_data,batch_size=64,shuffle=True) #将数据集分成64个batch,并打乱顺序
#网络模型搭建
class CNN(torch.nn.Module):def __init__(self):super(CNN,self).__init__()self.conv = torch.nn.Sequential( #定义卷积ngtorch.nn.Conv2d(1,32,kernel_size=5,padding=2), #输入通道数为1，输出通道数为32，卷积核大小为5，填充为1torch.nn.BatchNorm2d(32), #批归一化torch.nn.ReLU(), #激活函数torch.nn.MaxPool2d(2) #最大池化)self.fc = torch.nn.Linear(14*14*32,10) #定义全连接层def forward(self,x):out =self.conv(x) #卷积层out = out.view(out.size()[0],-1) #将输出展平out = self.fc(out) #全连接层return out
cnn =CNN()
#定义损失函数
loss_fn = torch.nn.CrossEntropyLoss() #交叉熵损失函数
#定义优化器
optimizer = torch.optim.Adam(cnn.parameters(),lr=0.001) #Adam优化器
#训练模型
for epoch in range(10): #训练10个epoch  for i,(images,labels) in enumerate(train_loader): #遍历训练集output = cnn(images) #将输入数据传入模型loss = loss_fn(output,labels) #计算损失optimizer.zero_grad() #清空梯度loss.backward() #反向传播optimizer.step() #更新参数print("epoch is {},ite is{}/{},loss is {}".format(epoch+1,i,len(train_data)//64,loss.item()))
print('############################')
#测试模型 
loss_test = 0
accuracy = 0
for epoch in range(10):for i,(images,labels) in enumerate(test_loader):outputs = cnn(images)loss_test += loss_fn(outputs,labels) _,pred = output.max(1)accuracy += (pred == labels).sum().item()accuracy = accuracy / len(test_data)loss_test = loss_test / (len(test_data)//64)print("epoch is {},loss is {},accuracy is {}".format(epoch+1,loss_test.item(),accuracy))
#模型保存
torch.save(cnn,"handwriteNumber.pkl")

知识点为听课总结笔记，课程为B站“2025最新整合！公认B站讲解最强【PyTorch】入门到进阶教程，从环境配置到算法原理再到代码实战逐一解读，比自学效果强得多！”：2025最新整合！公认B站讲解最强【PyTorch】入门到进阶教程，从环境配置到算法原理再到代码实战逐一解读，比自学效果强得多！_哔哩哔哩_bilibili

http://www.lryc.cn/news/589108.html

相关文章：

  • 【人工智能99问】神经网络的工作原理是什么？(4/99)
  • Android中Launcher简介
  • MySQL索引与事务详解：用大白话讲透核心概念
  • compose、 pipe 组合函数实现
  • 从底层技术到产业落地：优秘企业智脑的 AI 革命路径解析
  • Basilisk库教程（二）
  • QT——QList的详细讲解
  • SpringBoot3.0 +GraalVM17 + Docker
  • AI大模型训练相关函数知识补充
  • MongoDB基础增删改查命令
  • vscode配置运行完整C代码项目
  • B/S 架构通信原理详解
  • 高标准农田气象站的功能
  • 亚矩阵云手机：破解 Yandex 广告平台多账号风控难题的利器
  • 云服务器如何管理数据库（MySQL/MongoDB）？
  • 《大数据技术原理与应用》实验报告四 MapReduce初级编程实践
  • Keepalived双机热备概述
  • 死锁问题以及读写锁和自旋锁介绍【Linux操作系统】
  • Sersync和Rsync部署
  • 免杀学习篇（1）—— 工具使用
  • Dify的默认端口怎么修改
  • 算法学习day16----Python数据结构--模拟队列
  • Nuxt3宝塔PM2管理器部署
  • linux系统------LVS+KeepAlived+Nginx高可用方案
  • LVS（Linux Virtual Server）详细笔记（理论篇）
  • 李宏毅《生成式人工智能导论》 | 第9讲 AI Agent
  • Jfinal+SQLite java工具类复制mysql表数据到 *.sqlite
  • 设计模式笔记_结构型_适配器模式
  • Redis 中的持久化机制：RDB 与 AOF
  • 基于STM32设计的智能厨房