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

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