bike predictor

Size: px

Start display at page:

Download "bike predictor"

格改祝
5 years ago
Views:

7 data

8 找到一条直线, 使得它到所有点的距离都很小

9 找到一条直线, 使得它到所有点的距离都很小 0 L = N % (ax ) + b Y ) ) / )2

10 找到一条直线, 使得它到所有点的距离都很小 0 L = N % (ax ) + b Y ) ) / )2 min 6,8 L(a, b)

11 找到一条直线, 使得它到所有点的距离都很小 0 L = N % (ax ) + b Y ) ) / )2 L 计算梯度 : a, L b 梯度下降算法 : a :;2 = a : α = L a b :;2 = b : α = L b

12 Y = 0,30,,0 y x X =,2,,0

13 Y = 0,30,,0 y x X =,2,,0

14 y σ(x) = 2 2;DEF (HI) y w' y = σ wx + b b w x 0 x

15 y σ(x) = 2 2;DEF (HJI) y w' y = σ wx + b b w w=0 w= w=0. w=- x x w 控制着曲线的弯曲程度

16 y σ(x) = 2 2;DEF (H(JI;8)) y w' y = σ wx + b b b= b=- w b=0 x x b 控制着曲线的竖直位置

17 y σ(x) = J@ 2;DEF (HJ(I;8)) y w'=. w' y = σ wx + b w'= b w x w'= - x w' 控制着曲线的高矮

18 y y = w σ w 2 x + b 2 + w σ w / x + b / w w 2 b b 2 w w 2 x

19 y y = 2 σ w 2 x + b σ 2 x = σ / x = 2 + exp x + / σ w / x + b / y + exp ( x) w w 2 b b 2 b= b=0 w w 2 x x b 控制着曲线的竖直位置

20 y = + exp x exp ( x) y y = w σ w 2 x + b 2 +w σ w / x + b / y w w 2 b b 2 b= b=0 w w 2 x x b 控制着曲线的竖直位置

21 y = + exp ( x) + + exp ( x + ) y y = w σ w 2 x + b 2 +w σ w / x + b / y b=0, w'= w w 2 b b 2 x w w 2 b=-. w'= - x b 控制着曲线的竖直位置

22 y = + exp ( x) + + exp ( x + ) y y = w σ w 2 x + b 2 +w σ w / x + b / y w'= w w 2 b b 2 x w w 2 w'= - x b 控制着曲线的竖直位置

23 Y = 0,30,,0 y x X =,2,,0

24 Y = 2,30,,0 y x X =,2,,0

25 In []: # 导入需要使用的库 import numpy as np import pandas as pd import matplotlib.pyplot as plt import torch from torch.autograd import Variable # 让输出的图形直接在 Notebook 中显示 %matplotlib inline 导入处理 csv 文件的库有关 Tensor 操作的 torch 库用于 autograd 自动求导变量的库

26 In [2]: # 读取数据到内存中,rides 为一个 dataframe 对象 data_path = Bike- Sharing- Dataset/hour.csv rides = pd.read_csv(data_path) # 看看数据长什么样子 rides.head() 导入处理 csv 文件的库显示前几条记录 Out[2]: Variable containing: [torch.floattensor of size 2x2]

27 In [3]: counts = rides[ cnt ][:0] x = Variable(torch.FloatTensor(np.arange(len(counts), dtype = float)/len(counts))) y = Variable(torch.FloatTensor(np.array(counts, dtype = float))) sz = 0 # 初始化所有神经网络的权重 (weights) 和阈值 (biases) weights = Variable(torch.randn(, sz), requires_grad = True) biases = Variable(torch.randn(sz), requires_grad = True) weights2 = Variable(torch.randn(sz, ), requires_grad = True) 提取数据库的 cnt 字段前 0 条记录 0 行列 0 行列行 0 列 0 个元素的列向量 0 行列 y weights2 biases weights x

28 In [4]: learning_rate = # 设置学习率 losses = [] for i in range(000000): # 从输入层到隐含层的计算 hidden = x.expand(sz, len(x)).t() * weights.expand(len(x), sz) + biases.expand(len(x), sz) # 将 sigmoid 函数作用在隐含层的每一个神经元上 hidden = torch.sigmoid(hidden) # 隐含层输出到输出层, 计算得到最终预测 predictions = hidden.mm(weights2) # 通过与标签数据 y 比较, 计算误差 loss = torch.mean((predictions - y) ** 2) if i % 0000 == 0: print( loss:, loss) loss.backward() # 对损失函数进行梯度反传 # 利用上一步计算中得到的 weights,biases 等梯度信息更新 weights 或 biases 中的 data 数值 weights.data.add_(- learning_rate * weights.grad.data) biases.data.add_(- learning_rate * biases.grad.data) weights2.data.add_(- learning_rate * weights2.grad.data) # 梯度清空 weights.grad.data.zero_() biases.grad.data.zero_() weights2.grad.data.zero_()

29 In [4]: learning_rate = # 设置学习率 losses = [] for i in range(000000): # 从输入层到隐含层的计算 hidden = torch.t(x.expand(sz, len(x)).t() len(x))) * weights.expand(len(x), * sz) + biases.expand(len(x), sz) + sz) sz) # 将 sigmoid 函数作用在隐含层的每一个神经元上 hidden = torch.sigmoid(hidden) # 隐含层输出到输出层, 计算得到最终预测 predictions = hidden.mm(weights2) + biases2.expand_as(y) # 通过与标签数据 y 比较, 计算误差 expand loss = torch.mean((predictions x , -, y) 3 ** 2) losses.append(loss.data.numpy()) if i % 0000 == 0: print( loss:, loss) loss.backward() # 对损失函数进行梯度反传 * # 利用上一步计算中得到的 weights,biases 等梯度信息更新 weights 或 biases 中的 data 数值 weights.data.add_(- learning_rate * weights.grad.data) biases.data.add_(- learning_rate * biases.grad.data) weights2.data.add_(- learning_rate * weights2.grad.data) biases2.data.add_(- learning_rate * biases2.grad.data)

30 In [4]: learning_rate = # 设置学习率 losses = [] for i in range(000000): # 从输入层到隐含层的计算 hidden = torch.t(x.expand(sz, len(x)).t() len(x))) * weights.expand(len(x), * sz) + biases.expand(len(x), sz) + sz) sz) # 将 sigmoid 函数作用在隐含层的每一个神经元上 hidden = torch.sigmoid(hidden) # 隐含层输出到输出层, 计算得到最终预测 predictions = hidden.mm(weights2) + biases2.expand_as(y) # 通过与标签数据 y 比较, 计算误差 expand loss = torch.mean((predictions x , -, y) 3 ** 2) losses.append(loss.data.numpy()) if i % 0000 == 0: print( loss:, loss) loss.backward() # 对损失函数进行梯度反传 * *0 # 利用上一步计算中得到的 weights,biases expand 等梯度信息更新 weights 或 biases 中的 data 数值 weights.data.add_(- learning_rate * weights.grad.data) weights biases.data.add_(- learning_rate * biases.grad.data) weights2.data.add_(- learning_rate * weights2.grad.data) biases2.data.add_(- learning_rate * biases2.grad.data)

31 In [4]: learning_rate = # 设置学习率 losses = [] for i in range(000000): # 从输入层到隐含层的计算 hidden = torch.t(x.expand(sz, len(x))) * weights.expand(len(x), sz) + biases.expand(len(x), sz) # 将 sigmoid 函数作用在隐含层的每一个神经元上 hidden = torch.sigmoid(hidden) # 隐含层输出到输出层, 计算得到最终预测 predictions = hidden.mm(weights2) + biases2.expand_as(y) # 通过与标签数据 y 比较, 计算误差 loss = torch.mean((predictions - y) ** 2) losses.append(loss.data.numpy()) if i % 0000 == 0.0: print( loss:, 0.2 loss) hidden: mm = loss.backward() # 对损失函数进行梯度反传 # 利用上一步计算中得到的 weights,biases 等梯度信息更新.weights 或 biases 0. 中的 data 数值 weights.data.add_(- learning_rate * weights.grad.data) biases.data.add_(- learning_rate * biases.grad.data) weights2.data.add_(- learning_rate * weights2.grad.data) biases2.data.add_(- learning_rate * biases2.grad.data)

33 In []: counts_predict = rides['cnt'][0:00]# 读取待预测的接下来的 0 个数据点 # 首先对接下来的 0 个数据点进行选取, 注意 x 应该取,2,,00, 然后再归一化 x = Variable(torch.FloatTensor((np.arange(len(counts_predict), dtype = float) + len(counts)) / len(counts_predict))) # 读取下 0 个点的 y 数值 y = Variable(torch.FloatTensor(np.array(counts_predict, dtype = float))) # 从输入层到隐含层的计算 hidden = x.expand(sz, len(x)).t() * weights.expand(len(x), sz) # 将 sigmoid 函数作用在隐含层的每一个神经元上 hidden = torch.sigmoid(hidden) # 隐含层输出到输出层, 计算得到最终预测 predictions = hidden.mm(weights2) # 计算预测数据上的损失函数 loss = torch.mean((predictions - y) ** 2) print(loss)

34 Loss: 620.

37 data 编号季节月是否假期是否工作日温度湿度出行数量日期年小时星期几天气, 晴,2 雾体表温度风速

38 cnt: 自行车的数量

39 Y temperature

40 holiday y y temperature x x2 x3 x

41 数据处理构造网络训练网络测试网络分析结果原始数据训练数据测试数据

42 类型数据的处理 Weekday:,2,3,4,,6,0 星期类型变量类型编码星期日星期一星期二星期三星期四星期五星期六

43 One- hot 编码将一个变量扩展为 n 个变量,n 为类型数目

44 X XV σ(x) XV σ(x) XV XV + σ(x) 0

45 数据集

46 训练集测试集

47 小撮 (batch) 训练集 l 如何训练? l 将训练切割成小的撮 (batch) l 对每一个小撮进行误差计算反向传播, 调整权重

48 input_size = features.shape[] output_size = weights = Variable(torch.randn([input_size, hidden_size]), requires_grad = True) biases = Variable(torch.randn([hidden_size]), requires_grad = True) weights2 = Variable(torch.randn([hidden_size, output_size]), requires_grad = True) 定义一个 input_size*sz 的第一层权重矩阵定义一个 sz 尺度的向量 biases 定义一个 sz* 的第二层权重矩阵

49 neu= torch.nn.sequential( torch.nn.linear(input_size, hidden_size), torch.nn.sigmoid(), torch.nn.linear(hidden_size, output_size), ) 建立一个多步操作的神经网络模型第一步从输入层到隐含层节点为一个线性运算, 输入维度 input_size, 隐含维度 hidden_size 第二步为 Sigmoid, 作用到每一个隐含层神经元上第三步又是一个线性元算, 从隐含到输出, 神经元个数分别为 hidden_size 和 output_size 所有神经网络的参数都存储在 neu.parameters() 里面了

50 cost = torch.nn.mseloss() optimizer = torch.optim.sgd(neu.parameters(), lr = 0.0) torch.nn.mseloss() 等价于函数 torch.mean((x- y)^2) torch.optim.sgd(neu.parameters(), lr = 0.0) neu.parameters() 返回神经网络 neu 的所有权重偏置参数建立一个随机梯度下降优化器, 它可以代替 parameters.data.add_(lr * parameters.grad.data)

51 # 神经网络训练循环 for i in range(2000): batch_loss = [] # 记录每一个撮的损失 # 每 28 个样本点被划分为一个撮 # start 和 end 分别是提取一个 batch 数据的起始和终止下标 for start in range(0, len(x), batch_size): end = start + batch_size if start + batch_size < len(x) else len(x) xx = Variable(torch.FloatTensor(X[start:end])) yy = Variable(torch.FloatTensor(Y[start:end])) predict = neu(xx) # 模型预测 loss = cost(predict, yy) # 计算损失函数 ( 均方误差 ) optimizer.zero_grad() # 将优化器存储的那些参数的梯度设置为 0 loss.backward() # 开始反向传播, 计算所有梯度值 optimizer.step() # 优化器开始运行一步, 更新所有的参数 batch_loss.append(loss.data.numpy()) # 每隔 00 步输出一下损失值 (loss) if i % 00==0: losses.append(np.mean(batch_loss)) print(i, np.mean(batch_loss))

52 # 神经网络训练循环 for i in range(2000): batch_loss = [] # 记录每一个撮的损失 # 每 28 个样本点被划分为一个撮 # start 和 end 分别是提取一个 batch 数据的起始和终止下标 for start in range(0, len(x), batch_size): end = start + batch_size if start + batch_size < len(x) else len(x) xx = Variable(torch.FloatTensor(X[start:end])) yy = Variable(torch.FloatTensor(Y[start:end])) predict = neu(xx) # 模型预测 hidden = x.expand(sz, len(x)).t() * weights.expand(len(x), sz) + biases.expand(len(x), sz) loss = cost(predict, yy) # 计算损失函数 hidden = torch.sigmoid(hidden) ( 均方误差 ) optimizer.zero_grad() # 将优化器存储的那些参数的梯度设置为 predictions = hidden.mm(weights2) 0 loss.backward() # 开始反向传播, 计算所有梯度值 optimizer.step() # 优化器开始运行一步, 更新所有的参数 batch_loss.append(loss.data.numpy()) # 每隔 00 步输出一下损失值 (loss) if i % 00==0: losses.append(np.mean(batch_loss)) print(i, np.mean(batch_loss))

53 # 神经网络训练循环 for i in range(2000): batch_loss = [] # 记录每一个撮的损失 # 每 28 个样本点被划分为一个撮 # start 和 end 分别是提取一个 batch 数据的起始和终止下标 for start in range(0, len(x), batch_size): end = start + batch_size if start + batch_size < len(x) else len(x) xx = Variable(torch.FloatTensor(X[start:end])) yy = Variable(torch.FloatTensor(Y[start:end])) predict = neu(xx) # 模型预测 loss = cost(predict, yy) # 计算损失函数 weights.grad.data.zero_() ( 均方误差 ) optimizer.zero_grad() # 将优化器存储的那些参数的梯度设置为 biases.grad.data.zero_() 0 loss.backward() # 开始反向传播 weights2.grad.data.zero_(), 计算所有梯度值 optimizer.step() # 优化器开始运行一步, 更新所有的参数 batch_loss.append(loss.data.numpy()) # 每隔 00 步输出一下损失值 (loss) if i % 00==0: losses.append(np.mean(batch_loss)) print(i, np.mean(batch_loss))

54 # 神经网络训练循环 for i in range(2000): batch_loss = [] # 记录每一个撮的损失 # 每 28 个样本点被划分为一个撮 # start 和 end 分别是提取一个 batch 数据的起始和终止下标 for start in range(0, len(x), batch_size): end = start + batch_size if start + batch_size < len(x) else len(x) xx = Variable(torch.FloatTensor(X[start:end])) yy = Variable(torch.FloatTensor(Y[start:end])) predict = neu(xx) # 模型预测 loss = cost(predict, yy) # 计算损失函数 ( 均方误差 ) optimizer.zero_grad() # 将优化器存储的那些参数的梯度设置为 0 loss.backward() # 开始反向传播, 计算所有梯度值 weights.data.add_(- learning_rate * weights.grad.data) optimizer.step() # 优化器开始运行一步, 更新所有的参数 biases.data.add_(- learning_rate * biases.grad.data) batch_loss.append(loss.data.numpy()) weights2.data.add_(- learning_rate * weights2.grad.data) # 每隔 00 步输出一下损失值 (loss) if i % 00==0: losses.append(np.mean(batch_loss)) print(i, np.mean(batch_loss))

57 def feature(x, net): X = Variable(torch.from_numpy(X).type(torch.FloatTensor), requires_grad = False) dic = dict(net.named_parameters()) weights = dic['0.weight'] biases = dic['0.bias'] h = torch.sigmoid(x.mm(weights.t()) + biases.expand([len(x), len(biases)])) return h

60 周末

61 hr_2 中午 2 点 Weekday_0,6 周末 weathersit_3 雨雪雷电 Hr_6 早 6 点

63 hr_7,8 早高峰 hr_7,8 晚高峰 holiday 是否节假日 Weekday6,0 周末

64 预测不准是因为圣诞节假期的反常模式在 24 号预测值偏高是因为对节假日抑制单元的抑制不够由于圣诞节的缘故,22 23 这两天的午高峰出行较少, 甚至比一般节假日还少解决 : 特殊日期的训练需要提供更多数据, 或者手工调整权重

65 Pr( 属于多这个类 ) Pr( 属于少这个类 ), 一个 [0,] 的小数

66 input_size = features.shape[] hidden_size = 0 output_size = 2 batch_size = 28 neuc = torch.nn.sequential( torch.nn.linear(input_size, hidden_size), torch.nn.sigmoid(), torch.nn.linear(hidden_size, output_size), torch.nn.sigmoid(),) cost = torch.nn.crossentropyloss() optimizer = torch.optim.sgd(neuc.parameters(), lr = 0.) 建立一个多步操作的神经网络模型第一步从输入层到隐含层节点为一个线性运算, 输入维度 input_size, 隐含维度 0 第二步为 Sigmoid, 作用到每一个隐含层神经元上第三步又是一个线性运算, 从隐含到输出, 神经元个数分别为 0 和 2,2 为分类的类别数第四步是一个 Sigmoid, 把输出结果变换为概率所有神经网络的参数都存储在 neuc.parameters() 里面了新建对于分类的损失函数 cost 新建优化器

67 C 为样本数量 ^ L = % logpr (l i ) )2 l(i) 为样本 i 的分类标签

68 losses = [] errors = [] for i in range(2000): # 每 28 个样本点被划分为一个撮 batch_loss = [] batch_errors = [] for start, end in zip(range(0, len(x), batch_size), range(batch_size, len(x)+, batch_size)): xx = Variable(torch.FloatTensor(X[start:end])) yy = Variable(torch.LongTensor(Y_labels[start:end])) predict = neuc(xx) loss = cost(predict, yy) err = error_rate(predict.data.numpy(), yy.data.numpy()) # 计算当前 batch 中的错误率 %, 自定义函数 optimizer.zero_grad() loss.backward() optimizer.step() batch_loss.append(loss.data.numpy()) batch_errors.append(err) # 每隔 00 步输出一下损失值 (loss) if i % 00==0: losses.append(np.mean(batch_loss)) errors.append(np.mean(batch_errors)) print(i, np.mean(batch_loss), np.mean(batch_errors))

69 测试集上的平均错误率 :3.7%

3. 2. 3. 2. 2. 3. 2. 2. 3. 2. 2. 3. 2. 2. 3. 2. 2. 3. 3. 2. 3. 2. 2. 3. 2. 2. 3. 2. 2. 3. 2. 2. 3.. 2. 3. 3. 2. 3 2.

72 Labels:0,,,

clc

clc clc clear all % 一初始化部分 %1.1 预处理样本数据 % 选取训练样本 (x,y) for i=1:126 x=0+0.0251*(i-1); y(i)=(sin(x)+(x.^2/9+x/3)*exp((-0.5)*(x.^2)))/2; % 待逼近函数 AllSamIn=0:0.0251:pi; % 训练样本输入 AllSamOut=y; % 训练样本输出 % 选取测试样本