算法介绍及实现——基于遗传算法改进的BP神经网络算法（附完整Python实现）

---

目录

一、算法介绍

1.1 遗传算法

1.2 为什么要使用遗传算法进行改进

二、算法原理

三、算法实现

3.1 算子选择

3.2 代码实现

---

一、算法介绍

1.1 遗传算法

        遗传算法是受启发于自然界中生物对于自然环境 “适者生存”的强大自适应能力，通过对生物演化过程模拟和抽象，构建了以自然界生物演变进化为逻辑基础的遗传算法。遗传算法包括了自然界生物在演变过程中的主要步骤，即选择、（基因）变异和（基因）交叉，对应着遗传算法中的三个运算算子。在具体的优化问题下，遗传算法会产生多个问题的可行解作为种群，然后让种群进行模拟意义上生物进化中的选择、变异、交叉等操作。在种群繁衍（迭代）一定次数之后，通过计算种群的适应度，寻找最终种群中的最优个体，该个体即代表优化问题的近似最优解。上述此即为遗传算法主要思想。其流程图如下：

1.2 为什么要使用遗传算法进行改进

        BP算法原理不多赘述，可见我之前博文BP原理介绍，在BP训练过程中，很容易出现陷入局部最小值的情况，所以引入遗传算法进行优化。遗传作为一种模拟生物进化的全局寻优算法，有着优秀的全局寻优能力，能够以一个种群为基础不断的迭代进化，最后获得问题的最优解或近似最优解。BP算法和遗传算法都是人们广泛使用的算法，而且两算法具有明显的优势互补，故而很多研究者都在探索两个算法的融合方法，以期能提高算法性能、提升算法精度。

二、算法原理

        基于遗传算法改进的BP神经网络算法（GA-BP算法）的主要思想即为：通过遗传算法的全局寻优能力获得最优的BP网络的初始权值和阈值，将寻优算法获得的最优初始权值和阈值作为BP神经网络的初始权值和阈值，然后进行训练以避免陷入局部最小值。遗传算法改进后的BP神经网络权值不是随机产生的，而是遗传算法寻优模块获得的。BP算法中的初始权值和阈值作为遗传算法个体的基因值，个体长度即为BP神经网络中权值和阈值的个数，每个基因即代表一个权值或阈值，基因上的数值就是BP神经网络中连接权值或阈值的真实值，如此便组成了遗传算法中的一个染色体。一定数量的染色体作为遗传算法训练的初始种群，再经过遗传算法的选择运算、交叉运算、变异运算等迭代过程后获得一个最优个体，然后以最优个体作为BP网络的初始参数进行训练，此即为GA-BP算法的原理。流程图如下：

三、算法实现

3.1 算子选择

         对于(e)所述的组织方法，是当影响因子数据和目标数据没有很强的相关性的情况下，用前一时序区间的数据作为该时序数据的影响因子来进行训练。

3.2 代码实现

         实例为基于一段时序监测数据的滑坡位移预测，监测影响因子数据有：温度、降雨、风力、灌溉等，监测的目标数据是坡体的裂缝宽度数据。实验表明影响因子数据和目标数据不具有强相关性，所以选择用目标数据本身作为影响因子数据。

        将整个算法分成如下模块：

1. chrom_code # 基因编码模块
2. chrom_mutate # 变异算子模块
3. chrom_cross # 交叉算子模块
4. chrom_select # 选择算子模块
5. chrom_fitness # 染色体适应度计算模块
6. data_prepare # 数据准备模块
7. BP_network # BPNN模块
8. chrom_test # 染色体检测模块
10. new_GA-BP # 改进算法主程序

chrom_test.py  检测生成的染色体基因有没有超限。

1. # 染色体检查
2. # 检查染色体中有没有超出基因范围的基因
4. def test(code_list,bound):
5. """
6. :param code_list: code_list: 染色体个体
7. :param bound: 各基因的取值范围
8. :return: bool
9. """
10. for i in range(len(code_list)):
11. if code_list[i] < bound[i][0] or code_list[i] > bound[i][1]:
12. return False
13. else:
14. return True

 chrom_code.py  基因编码。

1. # 基因编码模块
3. import random
4. import numpy as np
5. import chrom_test
7. def code(chrom_len,bound):
8. """
9. :param chrom_len: 染色体的长度，为一个数，采用实数编码即为基因的个数
10. :param bound: 取值范围，为一个二维数组，每个基因允许的取值范围
11. :return: 对应长度的编码
12. """
13. code_list = []
14. count = 0
15. while True:
16. pick = random.uniform(0,1)
17. if pick == 0:
18. continue
19. else:
20. pick = round(pick,3)
21. temp = bound[count][0] + (bound[count][1] - bound[count][0])*pick
22. temp = round(temp,3)
23. code_list.append(temp)
24. count = count + 1
25. if count == chrom_len:
26. if chrom_test.test(code_list,bound):
27. break
28. else:
29. count = 0
30. return code_list

BP_network.py    完成网络结构的构建。

1. # BP模块 借助PyTorch实现
3. import torch
5. # 引入了遗传算法参数的BP模型
6. class BP_net(torch.nn.Module):
8. def __init__(self, n_feature, n_hidden, n_output, GA_parameter):
9. super(BP_net, self).__init__()
10. # 构造隐含层和输出层
11. self.hidden = torch.nn.Linear(n_feature, n_hidden)
12. self.output = torch.nn.Linear(n_hidden, n_output)
13. # 给定网络训练的初始权值和偏执等
14. self.hidden.weight = torch.nn.Parameter(GA_parameter[0])
15. self.hidden.bias = torch.nn.Parameter(GA_parameter[1])
16. self.output.weight = torch.nn.Parameter(GA_parameter[2])
17. self.output.bias = torch.nn.Parameter(GA_parameter[3])
19. def forward(self, x):
20. # 前向计算
21. hid = torch.tanh(self.hidden(x))
22. out = torch.tanh(self.output(hid))
23. return out
25. # 传统的BP模型
26. class ini_BP_net(torch.nn.Module):
28. def __init__(self, n_feature, n_hidden, n_output):
29. super(ini_BP_net, self).__init__()
30. # 构造隐含层和输出层
31. self.hidden = torch.nn.Linear(n_feature, n_hidden)
32. self.output = torch.nn.Linear(n_hidden, n_output)
34. def forward(self, x):
35. # 前向计算
36. hid = torch.tanh(self.hidden(x))
37. out = torch.tanh(self.output(hid))
38. return out
40. def train(model, epochs, learning_rate, x_train, y_train):
41. """
42. :param model: 模型
43. :param epochs: 最大迭代次数
44. :param learning_rate:学习率
45. :param x_train:训练数据（输入）
46. :param y_train:训练数据（输出）
47. :return: 最终的loss值（MSE）
48. """
49. # path = "log.txt"
50. # f = open(path, 'w',encoding='UTF-8')
51. # f.write("train log\n------Train Action------\n"
52. # "Time：{}\n".format(time.ctime()))
53. loss_fc = torch.nn.MSELoss(reduction="sum")
54. optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
55. loss_list = []
56. for i in range(epochs):
57. model.train()
58. # 前向计算
59. data = model(x_train)
60. # 计算误差
61. loss = loss_fc(data, y_train)
62. loss_list.append(loss)
63. # 更新梯度
64. optimizer.zero_grad()
65. # 方向传播
66. loss.backward()
67. # 更新参数
68. optimizer.step()
69. # print("This is {} th iteration,MSE is {}。".format(i+1,loss))
70. loss_ls = [loss_list[i].detach().numpy() for i in range(len(loss_list))]
71. return loss_ls

 chrom_fitness.py   适应度计算

1. # 适应度计算模块
2. # 功能；传入一个编码，返回一个适应度值
3. from torchvision.transforms import transforms
4. import torch
5. import BP_network
6. import numpy as np
8. # 最小二乘思想获得两组数据的误差
9. def zxec_PC(X, Y):
10. X = np.array(X, dtype=np.float).flatten()
11. Y = np.array(Y, dtype=np.float).flatten()
12. if len(X) != len(Y):
13. print("Wrong!")
14. n = len(X)
15. Wc = 0
16. for i in range(n):
17. Wc = Wc + (X[i] - Y[i]) * (X[i] - Y[i])
18. return Wc
20. def calculate_fitness(code,n_feature,n_hidden,n_output,epochs
21. ,learning_rate,x_train,y_train):
22. """
23. :param code: 染色体编码
24. :param n_feature: 输入层个数
25. :param n_hidden: 隐含层个数
26. :param n_output: 输出层个数
27. :param epochs: 最多迭代次数
28. :param learning_rate: 学习率
29. :param x_train: 训练（输入）数据
30. :param y_train: 训练（输出）数据
31. :return: fitness 适应度值
32. """
33. Parameter = code[:]
34. # 参数提取
35. hidden_weight = Parameter[0:n_feature * n_hidden]
36. hidden_bias = Parameter[n_feature * n_hidden:
37. n_feature * n_hidden + n_hidden]
38. output_weight = Parameter[n_feature * n_hidden + n_hidden:
39. n_feature * n_hidden + n_hidden + n_hidden * n_output]
40. output_bias = Parameter[n_feature * n_hidden + n_hidden + n_hidden * n_output:
41. n_feature * n_hidden + n_hidden + n_hidden * n_output + n_output]
43. # 类型转换
44. tensor_tran = transforms.ToTensor()
45. hidden_weight = tensor_tran(np.array(hidden_weight).reshape((n_hidden, n_feature))).to(torch.float32)
46. hidden_bias = tensor_tran(np.array(hidden_bias).reshape((1, n_hidden))).to(torch.float32)
47. output_weight = tensor_tran(np.array(output_weight).reshape((n_output,n_hidden))).to(torch.float32)
48. output_bias = tensor_tran(np.array(output_bias).reshape((1, n_output))).to(torch.float32)
49. # 形装转换
50. hidden_weight = hidden_weight.reshape((n_hidden,n_feature))
51. hidden_bias = hidden_bias.reshape(n_hidden)
52. output_weight = output_weight.reshape((n_output,n_hidden))
53. output_bias = output_bias.reshape(n_output)
54. # 带入模型计算
55. GA = [hidden_weight, hidden_bias, output_weight, output_bias]
56. BP_model = BP_network.BP_net(n_feature,n_hidden,n_output,GA)
57. loss = BP_network.train(BP_model,epochs,learning_rate,x_train,y_train)
58. # 计算适应度
59. prediction = BP_model(x_train)
60. fitness = 10 - zxec_PC(prediction.detach().numpy(),y_train.detach().numpy())
61. return round(fitness,4)

 chrom_mutate.py  选择算子

1. # 变异算子
2. import random
4. def mutate(chrom_sum, size, p_mutate, chrom_len, bound, maxgen, nowgen):
5. """
6. :param chrom_sum: 染色体群，即种群，里面为一定数量的染色体 类型为一个二维列表
7. :param size: 种群规模，即染色体群里面有多少个染色体 为一个数
8. :param p_mutate: 交叉概率 为一个浮点数
9. :param chrom_len: 种群长度，即一条染色体的长度，即基因的个数 为一个数
10. :param bound: 各基因的取值范围
11. :param maxgen: 最大迭代次数
12. :param nowgen: 当前迭代次数
13. :return: 变异算子后的种群
14. """
15. count = 0
16. # print("\n---这是第{}次遗传迭代...".format(nowgen))
17. while True:
18. # 随机选择变异染色体
19. # print("{}-{}".format(nowgen,count+1))
20. seek = random.uniform(0,1)
21. while seek == 1:
22. seek = random.uniform(0,1)
23. index = int(seek * size)
24. # print("可能变异的染色体号数为：",index)
25. # 判断是否变异
26. flag = random.uniform(0,1)
27. if p_mutate >= flag:
28. # 选择变异位置
29. # print("发生变异中...")
30. seek1 = random.uniform(0,1)
31. while seek1 == 1:
32. seek1 = random.uniform(0,1)
33. pos = int(seek1 * chrom_len)
34. # print("变异的基因号数为：",pos)
35. # 开始变异
36. seek3 = random.uniform(0,1)
37. fg = pow(seek3*(1-nowgen/maxgen),2) # 约到迭代后期，其至越接近0，变异波动就越小
38. # print("变异前基因为：",chrom_sum[index][pos])
39. if seek3 > 0.5:
40. chrom_sum[index][pos] = round(chrom_sum[index][pos] +
41. (bound[pos][1] - chrom_sum[index][pos])*fg,3)
42. else:
43. chrom_sum[index][pos] = round(chrom_sum[index][pos] -
44. (chrom_sum[index][pos] - bound[pos][0])*fg,3)
45. # print("变异后基因为：", chrom_sum[index][pos])
46. count = count + 1
47. else:
48. # print("未发生变异。")
49. count = count + 1
50. if count == size:
51. break
52. return chrom_sum

chrom_cross.py  交叉算子

1. # 交叉算子
2. import random
3. import chrom_test
5. def cross(chrom_sum, size, p_cross, chrom_len, bound):
6. """
7. :param chrom_sum:种群集合，为二维列表
8. :param size:种群总数，即染色体的个数
9. :param p_cross:交叉概率
10. :param chrom_len:染色提长度，每个染色体含基因数
11. :param bound:每个基因的范围
12. :return: 交叉后的种群集合
13. """
14. count = 0
15. while True:
16. # 第一步 先选择要交叉的染色体
17. seek1 = random.uniform(0,1)
18. seek2 = random.uniform(0,1)
19. while seek1 == 0 or seek2 == 0 or seek1 == 1 or seek2 == 1:
20. seek1 = random.uniform(0, 1)
21. seek2 = random.uniform(0, 1)
22. # index_1(2)为选中交叉的个体在种群中的索引
23. index_1 = int(seek1 * size)
24. index_2 = int(seek2 * size)
25. if index_1 == index_2:
26. if index_2 == size - 1:
27. index_2 = index_2 - 1
28. else:
29. index_2 = index_2 + 1
30. # print("可能交叉的两个染色体为：",index_1,index_2)
31. # 第二步 判断是否进行交叉
32. flag = random.uniform(0,1)
33. while flag == 0:
34. flag = random.uniform(0,1)
35. if p_cross >= flag:
36. # 第三步 开始交叉
37. # print("开始交叉...")
38. p_pos = random.uniform(0, 1)
39. while p_pos == 0 or p_pos == 1:
40. p_pos = random.uniform(0, 1)
41. pos = int(p_pos * chrom_len)
42. # print("交叉的极影位置为：",pos)
43. var1 = chrom_sum[index_1][pos]
44. var2 = chrom_sum[index_2][pos]
45. pick = random.uniform(0,1)
46. # print("交叉前染色体为：")
47. # print(chrom_sum[index_1])
48. # print(chrom_sum[index_2])
49. chrom_sum[index_1][pos] = round((1-pick) * var1 + pick * var2,3)
50. chrom_sum[index_2][pos] = round(pick * var1 + (1-pick) * var2,3)
51. # print("交叉后染色体为：")
52. # print(chrom_sum[index_1])
53. # print(chrom_sum[index_2])
54. if chrom_test.test(chrom_sum[index_1],bound) and chrom_test.test(chrom_sum[index_2],bound):
55. count = count + 1
56. else:
57. continue
58. else:
59. # print("没有发生交叉。")
60. count = count + 1
61. # print("本次循环结束\n")
62. if count == size:
63. break
64. return chrom_sum

chrom_select.py   选择算子 

1. # 选择算子
2. import numpy as np
3. import random
5. def select(chrom_sum,fitness_ls):
6. """
7. :param chrom_sum:种群
8. :param fitness_ls: 各染色体的适应度值
9. :return: 更新后的种群
10. """
11. # print("种群适应度分别为：",fitness_ls)
12. fitness_ls = np.array(fitness_ls,dtype=np.float64)
13. sum_fitness_ls = np.sum(fitness_ls,dtype=np.float64)
14. P_inh = []
15. M = len(fitness_ls)
16. for i in range(M):
17. P_inh.append(fitness_ls[i]/sum_fitness_ls)
18. # 将概率累加
19. for i in range(len(P_inh)-1):
20. P_temp = P_inh[i] + P_inh[i+1]
21. P_inh[i+1] = round(P_temp, 2)
22. P_inh[-1] = 1
23. # 轮盘赌算法选择染色体
24. account = []
25. for i in range(M):
26. rand = random.random()
27. for j in range(len(P_inh)):
28. if rand <= P_inh[j]:
29. account.append(j)
30. break
31. else:
32. continue
33. # 根据索引号跟新种群
34. # print("轮盘赌的结果为：",account)
35. new_chrom_sum = []
36. for i in account:
37. new_chrom_sum.append(chrom_sum[i])
38. return new_chrom_sum

data_prepare.py  数据准备

1. # 数据准备
2. import numpy as np
3. import pandas as pd
5. def Data_loader():
6. # 文件路径
7. ENU_measure_path = "18-10-25至19-3-25三方向位移数据.xlsx"
8. t_path = "天气数据.xls"
9. M_path = "data.csv"
10. # 三方向数据
11. df_1 = pd.read_excel(ENU_measure_path)
12. ENU_df = pd.DataFrame(df_1)
13. ENU_E = ENU_df["E/m"]
14. ENU_E = np.array(ENU_E)
15. ENU_N = ENU_df["N/m"]
16. ENU_N = np.array(ENU_N)
17. ENU_U = ENU_df["U/m"]
18. ENU_U = np.array(ENU_U)
19. ENU_R = ENU_df['R/m']
20. ENU_R = np.array(ENU_R)
22. df_2 = pd.read_excel(t_path)
23. t_df = pd.DataFrame(df_2)
24. # 最大温度数据
25. max_tem = t_df["bWendu"]
26. max_tem_ls = []
27. for i in range(len(max_tem)):
28. temp = str(max_tem[i])
29. temp = temp.replace("℃","")
30. max_tem_ls.append(eval(temp))
31. max_tem = np.array(max_tem_ls)
32. # 最低温度数据
33. min_tem = t_df["yWendu"]
34. min_tem_ls = []
35. for i in range(len(min_tem)):
36. temp = str(min_tem[i])
37. temp = temp.replace("℃","")
38. min_tem_ls.append(eval(temp))
39. min_tem =np.array(min_tem_ls)
40. # 天气数据
41. tianqi = t_df["Tian_Qi"]
42. tianqi = np.array(tianqi)
43. # 风力数据
44. Feng = t_df["Feng"]
45. Feng = np.array(Feng)
46. # 降雨数据
47. rain = t_df["rainfall"]
48. rain = np.array(rain)
49. # 灌溉数据
50. guangai = t_df["guangai"]
51. guangai = np.array(guangai)
52. # 获取时间数据
53. namels = t_df["ymd"]
54. name_ls = []
55. for i in range(len(namels)):
56. temp = str(namels[i])
57. temp = temp.replace(" 00:00:00","")
58. name_ls.append(str(temp))
59. # 读取另一文件数据，该数据为位移计和GNSS监测数据
60. df_3 = pd.read_csv(M_path)
61. M_df = pd.DataFrame(df_3)
62. M_data = M_df["Measurerel"]
63. R_data = M_df["R"]
64. M_data = np.array(M_data)
65. R_data = np.array(R_data)
67. return [ENU_R, M_data, R_data, ENU_U, ENU_E, ENU_N,max_tem,min_tem,name_ls]

---

主程序！！！！

1. # 改进算法主程序
2. import sys
3. import chrom_code # 基因编码模块
4. import chrom_mutate # 变异算子模块
5. import chrom_cross # 交叉算子模块
6. import chrom_select # 选择算子模块
7. import chrom_fitness # 染色体适应度计算模块
8. import data_prepare # 数据准备模块
9. import BP_network # BPNN模块
10. import torch
11. import torch.nn.functional as F
12. from torchvision.transforms import transforms
13. import numpy as np
14. import matplotlib.pyplot as plt
15. import time
17. plt.rcParams['font.sans-serif'] = ['SimHei']
18. plt.rcParams['axes.unicode_minus'] = False
20. # -----参数设置-----
21. epochs = 300 # 神经网络最大迭代次数
22. learning_rate = 0.01 # 学习率
23. n_feature = 6 # 输入层个数
24. n_hidden = 9 # 隐含层个数
25. n_output = 1 # 输出层个数
27. chrom_len = n_feature * n_hidden + n_hidden + n_hidden * n_output + n_output # 染色体长度
28. size = 15 # 种群规模
29. bound = np.ones((chrom_len, 2))
30. sz = np.array([[-1, 0], [0, 1]])
31. bound = np.dot(bound, sz) # 各基因取值范围
32. p_cross = 0.4 # 交叉概率
33. p_mutate = 0.01 # 变异概率
34. maxgen = 30 # 遗传最大迭代次数
36. # 数据准备
37. # ========================================= #
38. data_set = data_prepare.Data_loader()
39. displace = data_set[1]
40. name_ls = data_set[-1]
41. in_train_data = []
42. in_test_data = []
44. # 数目分配
45. train_num = 120
46. test_num = len(displace) - train_num - n_feature
48. for i in range(len(displace)):
49. temp = []
50. if i <= train_num-1: # 用于控制训练数据和预测数据的分配
51. temp = [round(displace[i + j], 5) for j in range(n_feature)]
52. in_train_data.append(temp)
53. else:
54. temp = [round(displace[i + j], 5) for j in range(n_feature)]
55. in_test_data.append(temp)
56. if i == len(displace)-n_feature-1:
57. break
59. # 格式转化
60. in_train_data = np.array(in_train_data)
61. in_test_data = np.array(in_test_data)
62. # 数据分割，用于建模和预测
63. out_train_data = displace[n_feature:train_num+n_feature]
64. out_test_data = displace[train_num+n_feature:len(displace)]
66. # 测试输出
67. # print(in_train_data)
68. # print(out_train_data)
69. # print(in_test_data)
70. # print(out_test_data)
71. # print(train_num)
72. # print(test_num)
74. # 数据格式转换及数据归一化
75. tensor_tran = transforms.ToTensor()
76. # 训练过程中的输入层数据
77. in_train_data = tensor_tran(in_train_data).to(torch.float)
78. in_train_data = F.normalize(in_train_data)
79. in_train_data = in_train_data.reshape(train_num, n_feature)
80. # 预测过程中的输入层数据
81. in_test_data = tensor_tran(in_test_data).to(torch.float)
82. in_test_data = F.normalize(in_test_data)
83. in_test_data = in_test_data.reshape(test_num, n_feature)
84. # 训练过程中的输出层数据
85. out_train_data = out_train_data.reshape(len(out_train_data), 1)
86. out_train_data = tensor_tran(out_train_data).to(torch.float)
87. un_norm1 = out_train_data[0][0]
88. out_train_data = F.normalize(out_train_data)
89. norm1 = out_train_data[0][0]
90. out_train_data = out_train_data.reshape(train_num, n_output)
91. fanshu_train = round(float(un_norm1 / norm1), 4) # 建模时，训练数据中输出数据的范数
92. # 预测中用于检验的输出层数据
93. out_test_data = out_test_data.reshape(len(out_test_data), 1)
94. out_test_data = tensor_tran(out_test_data).to(torch.float)
95. un_norm = out_test_data[0][0] # 归一化前
96. out_test_data = F.normalize(out_test_data)
97. norm = out_test_data[0][0] # 归一化后
98. out_test_data = out_test_data.reshape(test_num, n_output)
99. fanshu = round(float(un_norm / norm), 4) # 预测时，测试数据中输出数据的范数
101. # 建模训练数据
102. x_train = in_train_data
103. y_train = out_train_data
104. x_test = in_test_data
105. y_label = out_test_data
106. # ========================================== #
108. chrom_sum = [] # 种群，染色体集合
109. for i in range(size):
110. chrom_sum.append(chrom_code.code(chrom_len, bound))
111. account = 0 # 遗传迭代次数计数器
112. best_fitness_ls = [] # 每代最优适应度
113. ave_fitness_ls = [] # 每代平均适应度
114. best_code = [] # 迭代完成适应度最高的编码值
116. # 适应度计算
117. fitness_ls = []
118. for i in range(size):
119. fitness = chrom_fitness.calculate_fitness(chrom_sum[i], n_feature, n_hidden, n_output,
120. epochs, learning_rate, x_train, y_train)
121. fitness_ls.append(fitness)
122. # 收集每次迭代的最优适应值和平均适应值
123. fitness_array = np.array(fitness_ls).flatten()
124. fitness_array_sort = fitness_array.copy()
125. fitness_array_sort.sort()
126. best_fitness = fitness_array_sort[-1]
127. best_fitness_ls.append(best_fitness)
128. ave_fitness_ls.append(fitness_array.sum() / size)
130. while True:
131. # 选择算子
132. # print("\n这是第{}次遗传迭代。".format(account+1))
133. # print("平均适应度为：",fitness_array.sum()/size)
134. chrom_sum = chrom_select.select(chrom_sum, fitness_ls)
135. # 交叉算子
136. chrom_sum = chrom_cross.cross(chrom_sum, size, p_cross, chrom_len, bound)
137. # 变异算子
138. chrom_sum = chrom_mutate.mutate(chrom_sum, size, p_mutate, chrom_len, bound, maxgen, account + 1)
139. # 适应度计算
140. fitness_ls = []
141. for i in range(size):
142. fitness = chrom_fitness.calculate_fitness(chrom_sum[i], n_feature, n_hidden, n_output,
143. epochs, learning_rate, x_train, y_train)
144. fitness_ls.append(fitness)
145. # 收集每次迭代的最优适应值和平均适应值
146. fitness_array = np.array(fitness_ls).flatten()
147. fitness_array_sort = fitness_array.copy()
148. fitness_array_sort.sort()
149. best_fitness = fitness_array_sort[-1] # 获取最优适应度值
150. best_fitness_ls.append(best_fitness)
151. ave_fitness_ls.append(fitness_array.sum() / size)
152. # 计数器加一
153. account = account + 1
154. if account == maxgen:
155. index = fitness_ls.index(max(fitness_ls)) # 返回最大值的索引
156. best_code = chrom_sum[index] # 通过索引获得对于染色体
157. break
159. # 参数提取
160. hidden_weight = best_code[0:n_feature * n_hidden]
161. hidden_bias = best_code[n_feature * n_hidden:
162. n_feature * n_hidden + n_hidden]
163. output_weight = best_code[n_feature * n_hidden + n_hidden:
164. n_feature * n_hidden + n_hidden + n_hidden * n_output]
165. output_bias = best_code[n_feature * n_hidden + n_hidden + n_hidden * n_output:
166. n_feature * n_hidden + n_hidden + n_hidden * n_output + n_output]
167. # 类型转换
168. tensor_tran = transforms.ToTensor()
169. hidden_weight = tensor_tran(np.array(hidden_weight).reshape((n_hidden, n_feature))).to(torch.float32)
170. hidden_bias = tensor_tran(np.array(hidden_bias).reshape((1, n_hidden))).to(torch.float32)
171. output_weight = tensor_tran(np.array(output_weight).reshape((n_output, n_hidden))).to(torch.float32)
172. output_bias = tensor_tran(np.array(output_bias).reshape((1, n_output))).to(torch.float32)
173. # 形装转换
174. hidden_weight = hidden_weight.reshape((n_hidden, n_feature))
175. hidden_bias = hidden_bias.reshape(n_hidden)
176. output_weight = output_weight.reshape((n_output, n_hidden))
177. output_bias = output_bias.reshape(n_output)
178. GA = [hidden_weight, hidden_bias, output_weight, output_bias]
180. # 带入模型计算
181. BP_model = BP_network.BP_net(n_feature, n_hidden, n_output, GA)
182. ini_BP_model = BP_network.ini_BP_net(n_feature, n_hidden, n_output)
183. # 网络训练
184. loss = BP_network.train(BP_model, epochs, learning_rate, x_train, y_train)
185. ini_loss = BP_network.train(ini_BP_model, epochs, learning_rate, x_train, y_train)
186. # 建模效果
187. model_x = BP_model(x_train)
188. ini_model_x = ini_BP_model(x_train)
189. # 网络预测
190. prediction = BP_model(x_test)
191. ini_prediction = ini_BP_model(x_test)
193. # 建模数据反归一化(都换算到厘米级)
194. y_train = y_train.detach().numpy() * fanshu_train
195. model_x = model_x.detach().numpy() * fanshu_train
196. ini_model_x = ini_model_x.detach().numpy() * fanshu_train
197. # 建模绘图
198. train_name_ls = name_ls[6:126]
199. xlabel = [i for i in range(0, 120, 14)]
200. plt.plot(y_train, markersize=4, marker='.', label="真值", c='r')
201. plt.plot(model_x, markersize=4, marker='.', label="GA-BP预测值", c='b')
202. plt.title("GA-BP算法建模情况")
203. plt.ylabel("累计裂缝宽度（mm）")
204. plt.xticks(xlabel, [train_name_ls[i] for i in xlabel], rotation=25)
205. plt.grid(linestyle='-.') # 设置虚线
206. plt.legend()
208. f2 = plt.figure()
209. plt.plot(y_train, markersize=4, marker='.', label="真值", c='r')
210. plt.plot(ini_model_x, markersize=4, marker='.', label="BP预测值", c='g')
211. plt.title("BP算法建模情况")
212. plt.ylabel("累计裂缝宽度（mm）")
213. plt.xticks(xlabel, [train_name_ls[i] for i in xlabel], rotation=25)
214. plt.grid(linestyle='-.')
215. plt.legend()
217. # 预测数据格式转换（厘米级）
218. GABP_prediction = prediction.detach().numpy()
219. BP_prediction = ini_prediction.detach().numpy()
220. y_label = y_label.detach().numpy()
221. # 预测数据反归一化（厘米级）
222. GABP_prediction = GABP_prediction * fanshu
223. BP_prediction = BP_prediction * fanshu
224. y_label = y_label * fanshu
226. # 计算预测结果的SSE误差
227. def get_MSE(argu1, argu2):
228. if len(argu1) != len(argu2):
229. return 0
230. error = 0
231. for i in range(len(argu1)):
232. error = error + pow((argu1[i] - argu2[i]), 2)
233. error = float(error[0])
234. return round(error, 5)
237. error_BP = get_MSE(y_label, BP_prediction)
238. error_GA_BP = get_MSE(y_label, GABP_prediction)
239. print("BP算法预测MSE误差为：", error_BP)
240. print("GA-BP算法预测MSE误差为：", error_GA_BP)
242. # 将巡行情况和运行结果写入日志
243. f = open("log.txt",'a',encoding='UTF-8') # 追加写打开文件
244. f.write("运行时间：" + str(time.ctime()) + '\n')
245. f.write("训练数据长度为：" + str(train_num) + '\n'
246. + "测试数据长度为：" + str(test_num) + '\n')
247. f.write("网络结构层数为：{}、{}、{}\n".format(n_feature,n_hidden,n_output))
248. f.write("遗传迭代所获得的最优权值为：" + str(best_code) + "\n")
249. f.write("======预测结果如下======\n真值数据为：" + str(y_label.flatten()) + '\n')
250. f.write("BP预测结果为：" + str(BP_prediction.flatten()) + "\n"
251. + "GA-BP预测结果为：" + str(GABP_prediction.flatten()) + '\n')
252. f.write("-->>BP预测MSE误差为：" + str(error_BP) + '平方厘米\n'
253. + "-->>GA-BP预测MSE误差为：" + str(error_GA_BP) + '平方厘米\n\n')
254. f.close()
256. # 预测绘图
257. test_name_ls = name_ls[126:152]
258. xlabel2 = [i for i in range(0, 26, 4)]
260. f3 = plt.figure()
261. plt.plot(y_label, markersize=4, marker='.', label="真值", c='r')
262. plt.plot(GABP_prediction, markersize=4, marker='*', label="GA-BP预测值", c='b')
263. plt.plot(BP_prediction, markersize=4, marker='^', label="BP预测值", c='g')
264. plt.title("算法预测情况对比")
265. plt.ylabel("累计裂缝宽度（mm）")
266. plt.xticks(xlabel2, [test_name_ls[i] for i in xlabel2], rotation=20)
267. plt.legend()
268. plt.grid(linestyle='-.')
270. f4 = plt.figure()
271. plt.plot(y_label, markersize=4, marker='.', label="真值", c='r')
272. plt.plot(BP_prediction, markersize=4, marker='^', label="BP预测值", c='g')
273. plt.title("BP算法预测情况")
274. plt.ylabel("累计裂缝宽度（mm）")
275. plt.xticks(xlabel2, [test_name_ls[i] for i in xlabel2], rotation=20)
276. plt.legend()
277. plt.grid(linestyle='-.')
279. f5 = plt.figure()
280. plt.plot(y_label, markersize=4, marker='.', label="真值", c='r')
281. plt.plot(GABP_prediction, markersize=4, marker='*', label="GA-BP预测值", c='b')
282. plt.title("GA-BP算法预测情况")
283. plt.ylabel("累计裂缝宽度（mm）")
284. plt.xticks(xlabel2, [test_name_ls[i] for i in xlabel2], rotation=20)
285. plt.legend()
286. plt.grid(linestyle='-.')
288. plt.show()

对比结果确实有提升：

 资源获取：

链接：https://pan.baidu.com/s/1ZiqgN98bhnyEdoQxuDB3SQ?pwd=ervf 
提取码：ervf 
--来自百度网盘超级会员V4的分享

---

才疏学浅，水平有限。敬请批评指正！

共勉！

---