MLP-入门教程

【例子】MLP神经网络例子-数值预测(分批训练)

作者 : 老饼 发表日期 : 2022-06-26 14:06:28 更新日期 : 2025-04-24 17:29:25
本站原创文章,转载请说明来自《老饼讲解-深度学习》www.bbbdata.com



一个MLP神经网络,只要隐神经元足够多、且训练顺利,则理论上它可以拟合任意关系

本文展示一个MLP神经网络用于数据预测的例子,并用pytorch进行SGD分批训练

通过本文可以了解,如何使用pytorch的SGD算法、分批训练一个MLP神经网络模型来拟合样本




   01. MLP神经网络数值预测-例子   




本节展示一个用MLP解决数值预测的例子,以及具体代码实现





    MLP解决数值预测例子-数据说明    


本节展示如何使用MLP神经网络来解决数值预测问题,为方便理解,不妨采用以下的简单数据:
 MLP神经网络来解决数值预测问题-数据 
上述即为sin函数在[-5,5]之间的20个采样数据
由于样本较为简单,我们不妨将三层MLP神经网络设为4个隐节点
 即MLP神经网络模型结构如下:
 MLP神经网络模型结构 
设置好以上的模型之后,使用均方差作为损失函数,使用SGD对其进行训练即可






    MLP解决数值预测例子-代码实现    


下面我们展示,如何使用pytorch的深度学习框架来实现一个MLP神经网络
这里我们SGD算法来训练模型,并对数据进行随机批量训练
 具体代码如下:
import torch
from   torch import nn
import matplotlib.pyplot  as plt 
from torch.utils.data     import Dataset
from   torch.utils.data   import DataLoader
torch.manual_seed(99)      # 设定随机种子,使得每次运行结果一样


#-------模型结构-------------------
# 定义神经网络的结构
class MLP(nn.Module):
    def __init__(self):
        super(MLP, self).__init__()
        self.stack=nn.Sequential(
            nn.Linear(1, 4),                                                       # 1输入,4输出
            nn.Tanh(),                                                             # 激活函数用Tanh
            nn.Linear(4, 1)                                                        # 4输入,1输出
            )                                                                      
    def forward(self, x):                                                          
        y = self.stack(x)                                                          # 按stack计算模型输出
        return y                                                                   # 输出y
    
# ------训练数据---------------- 
class MyDataset(Dataset):
    def __init__(self):
        self.X =  torch.linspace(-5,5,20).reshape(20,1)                            # 样本的输入数据x
        self.Y =  torch.sin(self.X)                                                # 样本的输出数据y
        
    def __len__(self):                                                          
        return self.X.shape[0]                                                     # 样本的个数
    
    def __getitem__(self, idx):
        return self.X[idx],self.Y[idx]                                             # 单个样本的获取方式
    
    
# 模型训练 
model      = MLP()                                                                 # 初始化模型
lossFun   = torch.nn.MSELoss()                                                     # 定义损失函数为MSE
optimizer = torch.optim.SGD(model.parameters(), lr=0.01,momentum =0.9)             # 初始化优化器

dataset = MyDataset()
dataloader = DataLoader(dataset, batch_size=4, shuffle=True)                       # 将数据装载到DataLoader
for epoch in range(10000):                                                                
    err_num  = 0                                                                   # 本次epoch评估错误的样本
    eval_num = 0                                                                   # 本次epoch已评估的样本
    for batch, (x, y) in enumerate(dataloader):                                   
	    # -----训练模型-----                                                       
        optimizer.zero_grad()                                                      # 将优化器里的参数梯度清空
        py   = model(x)                                                            # 计算模型的预测值   
        loss = lossFun(py, y)                                                      # 计算损失函数值
        loss.backward()                                                            # 更新参数的梯度
        optimizer.step()                                                           # 更新参数
    # -----计算当前模型误差----------                                  
    py   = model(dataset.X)                                                        # 计算模型的预测值   
    loss = lossFun(py, dataset.Y)                                                  # 计算损失函数值MSE
    print('第',epoch,'步,MSE:' ,loss.item())                                       # 打印MSE
    if(loss<=0.005):                                                               # 检查退出条件
        break                                                                              
# -------打印模型训练结果----------                                                
print('\n----模型训练结果---')                                                     # 打印标题    
print('MSE:' ,loss.item())                                                         # 打印MSE   

print('\n----模型参数---')                                                         # 打印标题   
param_dict = dict(model.named_parameters())                                        # 提取模型参数
for key in param_dict:                                                             # 逐层打印参数
    print(key,":",param_dict[key].data)                                            # 打印当前层的参数
	
# 绘制预测结果                                                                    
px = torch.linspace(-5,5,100).reshape(100,1)                                       # 测试数据,用于绘制网络的拟合曲线    
py = model(px).detach().numpy()                                                    # 网络的预测值
plt.scatter(x, y)                                                                  # 绘制样本
plt.plot(px[:,0],py[:,0])                                                          # 绘制拟合曲线 
plt.show()                                                                         # 显示画布  
运行结果如下:
 
代码运行结果
 
MLP的拟合效果 
可以看到,模型根据训练数据,已经较好地拟合出sin函数曲线
 将模型参数代回MLP神经网络的数学表达式,即可得到模型的数学表达式为:
 






好了,以上就是pytorch实现MLP神经网络-数值预测的例子了










 End 





内容纠正