devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

DeepLearning in Pytorch|我的第一个NN-共享单车预测

作者：2023面试高手 | 2024-03-09 11:11:50

赞

踩

DeepLearning in Pytorch|我的第一个NN-共享单车预测

目录

概要

一、数据准备

导入数据

数据可视化

二、设计神经网络

版本一

版本二（正片）

三、测试

小结

 

概要

我的第一个深度学习神经网络模型---利用Pytorch设计人工神经网络对某地区租赁单车的使用情况进行预测

输入节点为1个，隐含层为10个，输出节点数为1的小型人工神经网络，用数据的下标预测单车数量。

PS:

1.该神经网络无法达到解决实际问题的要求，但它结构简单，包含了神经网络的基本元素，可以达到初步入门深度学习以及熟悉Pytorch使用的效果，同时在实践过程中引出了过拟合现象。

2.Pytorch 2.2.1 (CPU) Python 3.6.13|Anaconda 环境

一、数据准备

导入数据

  1. #导入需要使用的库
  2. import numpy as np
  3. import pandas as pd #读取csv文件的库
  4. import matplotlib.pyplot as plt #绘图
  5. import torch
  6. import torch.optim as optim

这里我们使用来自GitHub的开源数据用作构建神经网络

  1. #读取数据到内存中，rides为一个dataframe对象
  2. data_path = 'dir/hour.csv' #文件路径
  3. rides = pd.read_csv(data_path)
  4. rides.head()

 可以看到成功读入的数据如下：c180d12fed994374b19958b1235a8648.png

数据可视化

我们用数据序号(0，1，2，3，···)与数据cnt(count)构建神经网络（hhh实际解决问题时当然不会这样做）

  1. #我们取出最后一列的前50条记录来进行预测
  2. counts = rides['cnt'][:50]
  3.  
  4. #获得变量x，它是1，2，……，50
  5. x = np.arange(len(counts))
  6.  
  7. # 将counts转成预测变量（标签）：y
  8. y = np.array(counts)
  9.  
  10. # 绘制一个图形，展示曲线长的样子
  11. plt.figure(figsize = (10, 7)) #设定绘图窗口大小
  12. plt.plot(x, y, 'o-') # 绘制原始数据
  13. plt.xlabel('X') #更改坐标轴标注
  14. plt.ylabel('Y') #更改坐标轴标注
  15. plt.show()

 这里我们取出前五十条记录用于模型，绘制出序号与cnt关系，大致数据分布图如下：

6e8d79ce91d948f0ae6f3135c89ca57e.png

二、设计神经网络

我们构建一个单一输入，10个隐含层单元，1个输出单元的人工神经网络预测器

版本一

  1. #取出数据库中的最后一列的前50条记录来进行预测
  2. counts = rides['cnt'][:50]
  3.  
  4. #创建变量x，它是1，2，……，50
  5. x = torch.tensor(np.arange(len(counts), dtype = float), requires_grad = True)
  6.  
  7. # 将counts转成预测变量（标签）：y
  8. y = torch.tensor(np.array(counts, dtype = float), requires_grad = True)
  9.  
  10. # 设置隐含层神经元的数量
  11. sz = 10
  12.  
  13. # 初始化所有神经网络的权重（weights）和阈值（biases）
  14. weights = torch.randn((1, sz), dtype = torch.double, requires_grad = True) #1*10的输入到隐含层的权重矩阵
  15. biases = torch.randn(sz, dtype = torch.double, requires_grad = True) #尺度为10的隐含层节点偏置向量
  16. weights2 = torch.randn((sz, 1), dtype = torch.double, requires_grad = True) #10*1的隐含到输出层权重矩阵
  17.  
  18. learning_rate = 0.001 #设置学习率
  19. losses = []
  20.  
  21. # 将 x 转换为(50,1)的维度，以便与维度为(1,10)的weights矩阵相乘
  22. x = x.view(50, -1)
  23. # 将 y 转换为(50,1)的维度
  24. y = y.view(50, -1)
  25.  
  26. for i in range(100000):
  27.     # 从输入层到隐含层的计算
  28.     hidden = x * weights + biases
  29.     # 将sigmoid函数作用在隐含层的每一个神经元上
  30.     hidden = torch.sigmoid(hidden)
  31.     #print(hidden.size())
  32.     # 隐含层输出到输出层，计算得到最终预测
  33.     predictions = hidden.mm(weights2)#
  34.     #print(predictions.size())
  35.     # 通过与标签数据y比较，计算均方误差
  36.     loss = torch.mean((predictions - y) ** 2) 
  37.     #print(loss.size())
  38.     losses.append(loss.data.numpy())
  39.     
  40.     # 每隔10000个周期打印一下损失函数数值
  41.     if i % 10000 == 0:
  42.         print('loss:', loss)
  43.         
  44.     #对损失函数进行梯度反传
  45.     loss.backward()
  46.     
  47.     #利用上一步计算中得到的weights，biases等梯度信息更新weights或biases中的data数值
  48.     weights.data.add_(- learning_rate * weights.grad.data)  
  49.     biases.data.add_(- learning_rate * biases.grad.data)
  50.     weights2.data.add_(- learning_rate * weights2.grad.data)
  51.     
  52.     # 清空所有变量的梯度值。
  53.     # 因为pytorch中backward一次梯度信息会自动累加到各个变量上，因此需要清空，否则下一次迭代会累加，造成很大的偏差
  54.     weights.grad.data.zero_()
  55.     biases.grad.data.zero_()
  56.     weights2.grad.data.zero_()

运行过程：7f9cf5dc759d4399b9bfa03035dc4496.png 

程序运行大约14min

  1. # 打印误差曲线
  2. plt.plot(losses)
  3. plt.xlabel('Epoch')
  4. plt.ylabel('Loss')
  5. plt.show()

打印出误差曲线如下 

2519015d83b14c7dbf929bb8e857d6c5.png

由该曲线可以看出，随着时间的推移，神经网络预测的误差的确在一步步减小。而且，大约到20000步后，误差基本就不会出现明显的下降了

  1. x_data = x.data.numpy() # 获得x包裹的数据
  2. plt.figure(figsize = (10, 7)) #设定绘图窗口大小
  3. xplot, = plt.plot(x_data, y.data.numpy(), 'o') # 绘制原始数据
  4.  
  5. yplot, = plt.plot(x_data, predictions.data.numpy())  #绘制拟合数据
  6. plt.xlabel('X') #更改坐标轴标注
  7. plt.ylabel('Y') #更改坐标轴标注
  8. plt.legend([xplot, yplot],['Data', 'Prediction under 1000000 epochs']) #绘制图例
  9. plt.show()

我们可以把训练好的网络对这50个数据点的预测曲线绘制出来，并与标准答案y进行对比： 

378621bc550142e0859e83852b78f0c7.png

预测曲线在第一个波峰比较好地拟合了数据，但在这之后却偏差较大

版本二（正片）

上面的程序之所以跑得慢，是因为x的取值范围1～50。 而由于所有权重和biases的取值范围被设定为-1,1的正态分布随机数，这样就导致 我们输入给隐含层节点的数值范围为-50~50， 要想将sigmoid函数的多个峰值调节到我们期望的位置需要耗费很多的计算时间

我们的解决方案就是将输入变量的范围归一化

  1. #取出最后一列的前50条记录来进行预测
  2. counts = rides['cnt'][:50]
  3.  
  4. #创建归一化的变量x，它的取值是0.02,0.04,...,1
  5. x = torch.tensor(np.arange(len(counts), dtype = float) / len(counts), requires_grad = True)
  6.  
  7. # 创建归一化的预测变量y，它的取值范围是0～1
  8. y = torch.tensor(np.array(counts, dtype = float), requires_grad = True)
  9.  
  10. #隐藏神经元个数
  11. sz = 10
  12.  
  13. # 初始化所有神经网络的权重（weights）和阈值（biases）
  14. weights = torch.randn((1, sz), dtype = torch.double, requires_grad = True) #1*10的输入到隐含层的权重矩阵
  15. biases = torch.randn(sz, dtype = torch.double, requires_grad = True) #尺度为10的隐含层节点偏置向量
  16. weights2 = torch.randn((sz, 1), dtype = torch.double, requires_grad = True) #10*1的隐含到输出层权重矩阵
  17.  
  18. learning_rate = 0.001 #设置学习率
  19. losses = []
  20.  
  21. # 将 x 转换为(50,1)的维度，以便与维度为(1,10)的weights矩阵相乘
  22. x = x.view(50, -1)
  23. # 将 y 转换为(50,1)的维度
  24. y = y.view(50, -1)
  25.  
  26. for i in range(100000):
  27.     # 从输入层到隐含层的计算
  28.     hidden = x * weights + biases
  29.     # 将sigmoid函数作用在隐含层的每一个神经元上
  30.     hidden = torch.sigmoid(hidden)
  31.     # 隐含层输出到输出层，计算得到最终预测
  32.     predictions = hidden.mm(weights2)# + biases2.expand_as(y)
  33.     # 通过与标签数据y比较，计算均方误差
  34.     loss = torch.mean((predictions - y) ** 2) 
  35.     losses.append(loss.data.numpy())
  36.     
  37.     # 每隔10000个周期打印一下损失函数数值
  38.     if i % 10000 == 0:
  39.         print('loss:', loss)
  40.         
  41.     #对损失函数进行梯度反传
  42.     loss.backward()
  43.     
  44.     #利用上一步计算中得到的weights，biases等梯度信息更新weights或biases中的data数值
  45.     weights.data.add_(- learning_rate * weights.grad.data)  
  46.     biases.data.add_(- learning_rate * biases.grad.data)
  47.     weights2.data.add_(- learning_rate * weights2.grad.data)
  48.     
  49.     # 清空所有变量的梯度值。
  50.     # 因为pytorch中backward一次梯度信息会自动累加到各个变量上，因此需要清空，否则下一次迭代会累加，造成很大的偏差
  51.     weights.grad.data.zero_()
  52.     biases.grad.data.zero_()
  53.     weights2.grad.data.zero_()

运行程序，耗时约9min 

  1. plt.semilogy(losses)
  2. plt.xlabel('Epoch')
  3. plt.ylabel('Loss')
  4. plt.show()

  绘出损失曲线：d5d5eb5946d344128eaf55a1b5d5ee8a.png

  1. x_data = x.data.numpy() # 获得x包裹的数据
  2. plt.figure(figsize = (10, 7)) #设定绘图窗口大小
  3. xplot, = plt.plot(x_data, y.data.numpy(), 'o') # 绘制原始数据
  4. yplot, = plt.plot(x_data, predictions.data.numpy())  #绘制拟合数据
  5. plt.xlabel('X') #更改坐标轴标注
  6. plt.ylabel('Y') #更改坐标轴标注
  7. plt.legend([xplot, yplot],['Data', 'Prediction']) #绘制图例
  8. plt.show()

得到曲线如下： 

7ab00ced5e4f44338319cfd32d3fc143.png 

显然拟合效果更好了！

三、测试

我们就需要用训练好的模型来做预测，将后面50条数据(50~100)作为测试集。此时x取值是51, 52, …, 100，同样也要除以50： 

  1. counts_predict = rides['cnt'][50:100] #读取待预测的接下来的50个数据点
  2.  
  3. #首先对接下来的50个数据点进行选取，注意x应该取51，52，……，100，然后再归一化
  4. x = torch.tensor((np.arange(50, 100, dtype = float) / len(counts))
  5.                  , requires_grad = True)
  6. #读取下50个点的y数值，不需要做归一化
  7. y = torch.tensor(np.array(counts_predict, dtype = float), requires_grad = True)
  8.  
  9. x = x.view(50, -1)
  10. y = y.view(50, -1)
  11.  
  12. # 从输入层到隐含层的计算
  13. hidden = x * weights + biases
  14.  
  15. # 将sigmoid函数作用在隐含层的每一个神经元上
  16. hidden = torch.sigmoid(hidden)
  17.  
  18. # 隐含层输出到输出层，计算得到最终预测
  19. predictions = hidden.mm(weights2)
  20.  
  21. # 计算预测数据上的损失函数
  22. loss = torch.mean((predictions - y) ** 2) 
  23. print(loss)
  24.  
  25.  
  26. x_data = x.data.numpy() # 获得x包裹的数据
  27. plt.figure(figsize = (10, 7)) #设定绘图窗口大小
  28. xplot, = plt.plot(x_data, y.data.numpy(), 'o') # 绘制原始数据
  29. yplot, = plt.plot(x_data, predictions.data.numpy())  #绘制拟合数据
  30. plt.xlabel('X') #更改坐标轴标注
  31. plt.ylabel('Y') #更改坐标轴标注
  32. plt.legend([xplot, yplot],['Data', 'Prediction']) #绘制图例
  33. plt.show()

得到结果如下：

直线是我们的模型给出的预测曲线，圆点是实际数据所对应的曲线。

62f5c9ff256e4f41bafb5906d352a872.png模型预测与实际数据竟然完全对不上！为什么我们的神经网络可以非常好地拟合已知的50个数据点，却在测试集上出错了呢？因为y（单车数量）与x（数据序号）根本没有关系！这就是在机器学习中最常见的困难---过拟合

过拟合（Overfitting）是指机器学习模型在训练数据上表现很好，但在测试数据上表现较差的情况。过拟合通常发生在模型过度复杂或者训练数据量太少的情况下。

对于我们的单车预测模型，问题显然在于我们要求模型学习 单车数量y 与 数据序号x 之间的关系，模型通过学习我们给出的前五十组数据（训练集）学会了它所认为的样本特征，但当我们引入后面50组样本（测试集）时，我们发现模型学到的特征是没有意义的，它只能反映训练集中的某些特点。

如果要解决这个问题，我们就应该让模型学习关于样本的更多特征，如：星期几、是否节假日、温度、湿度等（显然这些才是真正会影响x的因素）。当然从理论上讲，这样得到的神经网络更复杂，但显然他的预测更能达到我们想要的效果。

小结

对于我们的单车预测模型，问题显然在于我们要求模型学习 单车数量y 与 数据序号x 之间的关系，模型通过学习我们给出的前五十组数据（训练集）学会了它所认为的样本特征，但当我们引入后面50组样本（测试集）时，我们发现模型学到的特征是没有意义的，它只能反映训练集中的某些特点。

如果要解决这个问题，我们就应该让模型学习关于样本的更多特征，如：星期几、是否节假日、温度、湿度等（显然这些才是真正会影响x的因素）。当然从理论上讲，这样得到的神经网络更复杂，但显然他的预测更能达到我们想要的效果。

主要参考资料：《深度学习原理与Pytorch实践》

参考代码：

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/214858?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号