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( #定义卷积ng
            torch.nn.Conv2d(1,32,kernel_size=5,padding=2), #输入通道数为1，输出通道数为32，卷积核大小为5，填充为1
            torch.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( #定义卷积ng
            torch.nn.Conv2d(1,32,kernel_size=5,padding=2), #输入通道数为1，输出通道数为32，卷积核大小为5，填充为1
            torch.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