本文档是对课程内容的简单整理。

  • 前缀Z_ 为正课视频的简称，如Z1为正课视频第1课
  • 前缀G_ 为更新视频的简称，如G1为更新视频第1课

灰色预测 Matlab

（1）数据是以年份度量的非负数据（如果是月份或者季度数据一定要用我们上一讲学过的时间序列模型）；
（2）数据能经过准指数规律的检验（除了前两期外，后面至少90%的期数的光滑比要低于0.5）；
（3）数据的期数较短且和其他数据之间的关联性不强（小于等于10，也不能太短了，比如只有3期数据），要是数据期数较长，一般用传统的时间序列模型比较合适。

级比检验方法：
清风 / 老哥 两种

清风代码：

D:\00000MCM\清风\0 课件和代码\正课配套的课件和代码\第12讲.预测模型\代码和例题数据\灰色预测\main.m
三种方式

  • 原始
  • 新信息
  • 新陈代谢

老哥代码 PPT：

D:\00000MCM\清风\0 课件和代码\正课配套的课件和代码\第12讲.预测模型\代码和例题数据\灰色预测\laoge_huiseyuce.m

PPT 级比检验讲解
D:\00000MCM\B站老哥带你学数模课程课件\老哥带你学数模课件\课件\6.1 6.2 6.3 老哥带你学数模-数学建模灰色预测模型汇总..pdf

神经网络预测

文章
必须说明数据划分 训练验证测试
2020B 0089：BP神经网络
2020B 0019：BP神经网络（双输出 不同参数对比试验 隐含层元素 学习率）
2020B 0019：BP神经网络（分为三个小网络）

Matlab操作

数据归一化 反归一化操作
bp神经网络及matlab实现 - phlsheji - 博客园Matlab中的数据预处理-归一化(mapminmax)与标准化(mapstd)_hqh45的专栏-CSDN博客_mapminmax

需要归一化数据
D:\00000MCM\0 codes\2020B\q3.m

  1. clc
  2. clear
  3. close all
  5. %% 加载数据 (模型)
  6. % [num_input,txt_input,raw_input]=xlsread('input') ;
  7. % [num_output,txt_output,raw_output]=xlsread('output') ;
  8. % input_0 = num_input(:,3:end);
  9. % input = num_input;
  10. % output = num_output;
  12. load('q3_21')
  13. % input
  14. % output
  15. % output = output(:, 2);
  17. % load('model_1')
  20. %% 数据预处理
  21. cut = 300;
  22. % 原始数据：样本*变量维度
  23. % data_train_input = input(1:cut,:);  
  24. % data_train_output = output(1:cut,:);
  25. data_train_input = input;    % 采用全部数据输入 神经网络默认分割为 70训练-15验证-15测试
  26. data_train_output = output;
  27. data_test_input = input(cut + 1:end,:);
  28. data_test_output = output(cut + 1:end,:);
  30. % 神经网络接收数据：转置 变量维度*样本
  31. input_train = data_train_input';  
  32. output_train = data_train_output';
  33. input_test = data_test_input';
  34. output_test = data_test_output';
  36. %训练数据归一化
  37. [inputn,inputps] = mapminmax(input_train);
  38. [outputn,outputps] = mapminmax(output_train);
  43. % 定义网络
  44. net = newff(inputn, outputn, 50);  % 获取 变量维度 变量维度 隐藏层神经元个数
  45. %参数设置
  46. net.trainParam.epochs=1000;%迭代次数
  47. net.trainParam.lr=0.4;%学习率
  48. net.trainParam.goal=0.00000000001;%收敛目标
  50. %神经网络训练
  51. net = train(net, inputn, outputn);
  52. % 保存网络
  53. save('model_1', 'net')
  55. %测试数据归一化
  56. inputn_test = mapminmax('apply', input_test, inputps);
  58. %神经网络测试输出
  59. an = sim(net,inputn_test);
  60. BPoutput = mapminmax('reverse', an, outputps);
  66. % 数据可视化
  67. % 数值
  68. figure(1)
  69. plot(BPoutput(1,:), '-', 'Color', [1 0.5 0], 'linewidth', 1.5)  % 橘色
  70. hold on
  71. plot(output_test(1,:), '.',  'Color', [0 0.60 1], 'linewidth', 1.5, 'MarkerSize', 15);  % 青蓝
  72. hold on
  73. plot(BPoutput(2,:),'k') %
  74. hold on
  75. plot(output_test(2,:),'g.');
  76. legend('模拟值(含硫量)','原始值（含硫量）','模拟值（辛烷值）','原始值（辛烷值）')
  77. % legend('模拟值（辛烷值）','原始值（辛烷值）')
  78. title('title')
  79. ylabel('ylabel')
  80. xlabel('xlabel')
  81. % axis([0 11, 85 95])
  84. % 误差
  85. err = abs(BPoutput - output_test);
  86. err_mean = mean(err, 1);
  87. figure(2)
  88. plot(err_mean,'-*')
  89. title('测试误差')
  90. ylabel('平均误差')
  91. xlabel('样本')
  93. % 数值百分比
  94. err_rate = err_mean ./ mean(output_test) * 100;
  95. figure(3)
  96. plot(err_rate,'-*')
  97. title('测试误差百分比')
  98. ylabel('平均误差百分比')
  99. xlabel('样本')

Python操作

需要归一化数据
D:\00000py\1\mcm nn_maxmin.py

  1. import torch
  2. import torch.nn.functional as F     # 激励函数都在这
  3. import torch
  4. import matplotlib.pyplot as plt
  6. import numpy as np
  7. import xlrd
  9. #### 数据预处理重要 使用Max-Min归一化     Z-Score效果不正常
  10. #### 数据选取可能重要
  13. # 读取数据
  14. data = xlrd.open_workbook(r'D:\00000MCM\0 codes\2020B\q3.xlsx')  # datas q2xxhg
  16. # 转为ndarray
  17. table = data.sheet_by_index(0) #按索引获取工作表，0就是工作表1
  18. resArray = []
  19. for i in range(1, table.nrows): #table.nrows表示总行数   去除第一行
  20.     line=table.row_values(i) #读取每行数据，保存在line里面，line是list
  21.     resArray.append(line) #将line加入到resArray中，resArray是二维list
  22. resArray=np.array(resArray) #将resArray从二维list变成数组
  23. # print(resArray)
  25. # 数据归一化
  26. mins = np.min(resArray, axis=0)
  27. maxs = np.max(resArray, axis=0)
  28. gyh = (resArray - mins) / (maxs - mins)
  29. # gyh = resArray
  31. # 选择数据
  32. x = gyh[..., 2:]  # 325,365
  33. y = gyh[..., 1]  # 325,1  # 未使用第一列
  35. # 523/5=65  0 64,65 129,130 194,195 259,260 324
  36. # train_range = range(0, 259 + 1)
  37. # test_range = range(260, 324 + 1)
  38. train_range = [i for i in range(0, 259 + 1)]  # 数据范围
  39. test_range = [i for i in range(260, 324 + 1)]
  40. train_n = len(train_range)  # 数据数量
  41. test_n = len(test_range)
  43. x_train = x[train_range, ...]
  44. x_test = x[test_range, ...]
  45. y_train = y[train_range, ...]
  46. y_test = y[test_range, ...]
  49. # 转为tensor
  50. # xt = torch.tensor(x, dtype=torch.float32)
  51. # yt = torch.tensor(y, dtype=torch.float32)
  52. x_train_t = torch.tensor(x_train, dtype=torch.float32)
  53. x_test_t = torch.tensor(x_test, dtype=torch.float32)
  54. y_train_t = torch.tensor(y_train, dtype=torch.float32)
  55. y_test_t = torch.tensor(y_test, dtype=torch.float32)
  60. # 建立神经网络 优化器 损失函数
  61. class Net(torch.nn.Module):  # 继承 torch 的 Module
  62.     def __init__(self, n_feature, n_hidden, n_output):
  63.         super(Net, self).__init__()     # 继承 __init__ 功能
  64.         # 定义每层用什么样的形式
  65.         self.hidden = torch.nn.Linear(n_feature, n_hidden)   # 隐藏层线性输出
  66.         self.predict = torch.nn.Linear(n_hidden, n_output)   # 输出层线性输出
  68.     def forward(self, x):   # 这同时也是 Module 中的 forward 功能
  69.         # 正向传播输入值, 神经网络分析出输出值
  70.         x = F.leaky_relu(self.hidden(x))      # 激励函数(隐藏层的线性值)
  71.         x = self.predict(x)             # 输出值
  72.         return x
  74. in_fature = x.shape[1] if len(x.shape) == 2 else 1
  75. out_fature = y.shape[1] if len(y.shape) == 2 else 1
  76. net = Net(n_feature=in_fature, n_hidden=50, n_output=out_fature)  # 365 125
  77. # print(net)  # net 的结构
  78. optimizer = torch.optim.SGD(net.parameters(), lr=0.002)  # 传入 net 的所有参数, 学习率
  79. loss_func = torch.nn.MSELoss()      # 预测值和真实值的误差计算公式 (均方差)
  82. losses = []
  83. epochs = 500
  85. # 训练网络
  86. for t in range(epochs):
  87.     # for i in range
  88.     prediction = net(x_train_t)     # 喂给 net 训练数据 x, 输出预测值
  90.     loss = loss_func(prediction, y_train_t) * 1.0     # 计算两者的误差
  91.     print('train' + str(t) + 'loss: ', end='')
  92.     print(loss.item() / train_n)  # 单个样本loss
  93.     losses.append(loss.item())
  95.     optimizer.zero_grad()   # 清空上一步的残余更新参数值
  96.     loss.backward()         # 误差反向传播, 计算参数更新值
  97.     optimizer.step()        # 将参数更新值施加到 net 的 parameters 上
  100.     # # 可视化训练过程
  101.     # if t % 10 == 0:
  102.     #     plt.cla()
  103.     #     plt.scatter(x.data.numpy(), y.data.numpy())
  104.     #     plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5)
  105.     #     plt.text(0.5, 0, 'Loss=%.4f' % loss.data.numpy(), fontdict={'size': 20, 'color':  'red'})
  106.     #     if t<90:
  107.     #         plt.pause(0.1)
  108.     #     else:
  109.     #         plt.pause(1)
  112. # 画loss下降图
  113. pltx = range(epochs)
  114. plt.plot(pltx, losses)
  115. plt.show()
  118. # 测试
  119. net.eval()
  120. final_output = net(x_test_t)
  121. final_loss = loss_func(final_output, y_test_t)  # 计算两者的误差
  122. print('final output loss: ', end='')
  123. print(final_loss.item() / train_n)
  126. # 画对比图
  127. pltxx = range(test_n)  # 画图用x值
  128. final = np.array(final_output.detach())  # 测试结果 -> ndarray
  129. final_re = final * (maxs[1] - mins[1]) + mins[1]  # final  (65, 1) 需要减少维数final_re = final_re.squeeze()
  130. final_re = final_re.squeeze()
  131. final_true = y_test * (maxs[1] - mins[1]) + mins[1]  # y_test  (65, )
  132. plt.plot(pltxx, final_re)
  133. plt.plot(pltxx, final_true)
  134. # plt.legend()
  135. plt.show()
  138. # 误差计算
  139. err = final_re - final_true  # 样本误差 (65, )
  140. final_mae = ((sum(abs(final_re - final_true)) / test_n) / (sum(abs(final_true)) / test_n)) * 100.0
  141. print('final output loss rate: ', end='')
  142. print(final_mae, end=' ')
  143. print('%')
  147. print('finish')