一、核心思想
BP 神经网络容易陷入局部最优且收敛速度慢，而遗传算法（GA）具有全局搜索能力。将 GA 用于优化 BP 网络的初始权值和阈值，可以显著提高网络性能和收敛速度。
二、MATLAB 实现
2.1 主程序 (ga_bp_main.m)
matlab
%% 基于GA优化的BP神经网络算法
% 功能：使用遗传算法优化BP神经网络的权值和阈值
clear all; close all; clc;
fprintf('=== 基于GA优化的BP神经网络算法 ===\n\n');
%% 1. 生成测试数据
fprintf('生成测试数据...\n');
[data] = generate_test_data();
fprintf('数据信息：\n');
fprintf(' 样本数量: %d\n', size(data.train_input, 1));
fprintf(' 输入特征: %d\n', size(data.train_input, 2));
fprintf(' 输出维度: %d\n', size(data.train_output, 2));
fprintf(' 训练集: %d 样本\n', size(data.train_input, 1));
fprintf(' 测试集: %d 样本\n\n', size(data.test_input, 1));
%% 2. 创建BP神经网络
fprintf('创建BP神经网络...\n');
[bp_net, bp_config] = create_bp_network(data);
fprintf('BP网络结构：\n');
fprintf(' 输入层: %d 神经元\n', bp_config.input_nodes);
fprintf(' 隐含层: %d 神经元\n', bp_config.hidden_nodes);
fprintf(' 输出层: %d 神经元\n', bp_config.output_nodes);
fprintf(' 总权值数: %d\n', bp_config.num_weights);
fprintf(' 总阈值数: %d\n', bp_config.num_biases);
fprintf(' 待优化参数总数: %d\n\n', bp_config.num_params);
%% 3. 遗传算法优化
fprintf('开始遗传算法优化...\n');
[best_params, ga_results] = genetic_algorithm_optimization(bp_net, data, bp_config);
fprintf('GA优化完成：\n');
fprintf(' 最优适应度: %.6f\n', ga_results.best_fitness(end));
fprintf(' 收敛代数: %d\n', length(ga_results.best_fitness));
fprintf(' 优化时间: %.2f 秒\n\n', ga_results.optimization_time);
%% 4. 使用最优参数训练BP网络
fprintf('使用最优参数训练BP网络...\n');
[final_net, training_results] = train_final_bp_network(bp_net, data, best_params, bp_config);
fprintf('BP网络训练完成：\n');
fprintf(' 训练误差: %.6f\n', training_results.tr(end));
fprintf(' 训练时间: %.2f 秒\n\n', training_results.training_time);
%% 5. 性能评估
fprintf('开始性能评估...\n');
[performance_results] = evaluate_network_performance(final_net, data, training_results);
%% 6. 结果可视化
fprintf('生成可视化结果...\n');
visualize_results(ga_results, training_results, performance_results, data);
%% 7. 保存模型和结果
save('ga_bp_model.mat', 'final_net', 'best_params', 'bp_config', 'performance_results');
fprintf('模型已保存到: ga_bp_model.mat\n');
fprintf('\n=== 算法执行完成 ===\n');2.2 数据生成模块 (generate_test_data.m)
matlab
function [data] = generate_test_data()
% 生成测试数据集
% 设置随机种子以保证可重复性
rng(42);
% 生成非线性函数数据 y = sin(x1) + cos(x2) + 0.1*x3^2 + noise
n_samples = 1000;
n_features = 3;
% 输入特征
X = randn(n_samples, n_features);
% 输出目标（非线性函数）
Y = sin(X(:,1)) + cos(X(:,2)) + 0.1*X(:,3).^2 + 0.05*randn(n_samples, 1);
% 数据归一化
[X_norm, X_ps] = mapminmax(X', 0, 1);
X_norm = X_norm';
[Y_norm, Y_ps] = mapminmax(Y', 0, 1);
Y_norm = Y_norm';
% 划分训练集和测试集
train_ratio = 0.8;
n_train = round(n_samples * train_ratio);
data.train_input = X_norm(1:n_train, :);
data.train_output = Y_norm(1:n_train, :);
data.test_input = X_norm(n_train+1:end, :);
data.test_output = Y_norm(n_train+1:end, :);
data.X_ps = X_ps;
data.Y_ps = Y_ps;
% 添加一些噪声数据用于鲁棒性测试
noise_level = 0.1;
data.noisy_input = X_norm + noise_level * randn(size(X_norm));
data.noisy_output = Y_norm + noise_level * randn(size(Y_norm));
end2.3 BP 网络创建模块 (create_bp_network.m)
matlab
function [bp_net, bp_config] = create_bp_network(data)
% 创建BP神经网络
% 网络结构参数
input_nodes = size(data.train_input, 2);
hidden_nodes = 10; % 可根据需要调整
output_nodes = size(data.train_output, 2);
% 创建BP网络
bp_net = feedforwardnet(hidden_nodes, 'trainlm'); % 使用Levenberg-Marquardt算法
% 配置网络参数
bp_net.trainParam.epochs = 1000;
bp_net.trainParam.goal = 1e-6;
bp_net.trainParam.mu = 0.001;
bp_net.trainParam.mu_dec = 0.1;
bp_net.trainParam.mu_inc = 10;
bp_net.trainParam.mu_max = 1e10;
% 设置激活函数
bp_net.layers{1}.transferFcn = 'tansig'; % 隐含层使用tan-sigmoid
bp_net.layers{2}.transferFcn = 'purelin'; % 输出层使用线性函数
% 计算需要优化的参数数量
% 权值：输入层到隐含层 + 隐含层到输出层
num_weights = input_nodes * hidden_nodes + hidden_nodes * output_nodes;
% 阈值：隐含层 + 输出层
num_biases = hidden_nodes + output_nodes;
num_params = num_weights + num_biases;
% 存储配置信息
bp_config.input_nodes = input_nodes;
bp_config.hidden_nodes = hidden_nodes;
bp_config.output_nodes = output_nodes;
bp_config.num_weights = num_weights;
bp_config.num_biases = num_biases;
bp_config.num_params = num_params;
fprintf('BP网络创建完成\n');
end2.4 遗传算法优化模块 (genetic_algorithm_optimization.m)
matlab
function [best_params, ga_results] = genetic_algorithm_optimization(bp_net, data, bp_config)
% 遗传算法优化BP网络参数
fprintf('开始遗传算法优化...\n');
% GA参数设置
ga_params.pop_size = 50; % 种群大小
ga_params.max_gen = 100; % 最大代数
ga_params.pc = 0.8; % 交叉概率
ga_params.pm = 0.1; % 变异概率
ga_params.elite_count = 2; % 精英保留数量
% 参数边界（权值和阈值的范围）
lb = -5 * ones(1, bp_config.num_params); % 下界
ub = 5 * ones(1, bp_config.num_params); % 上界
% 初始化种群
population = initialize_population(ga_params.pop_size, bp_config.num_params, lb, ub);
% 存储结果
best_fitness = zeros(ga_params.max_gen, 1);
best_params_history = zeros(ga_params.max_gen, bp_config.num_params);
tic; % 开始计时
% 主循环
for gen = 1:ga_params.max_gen
fprintf(' 第 %d/%d 代: ', gen, ga_params.max_gen);
% 计算适应度
fitness = calculate_fitness(population, bp_net, data, bp_config);
% 找到最优个体
[best_fit, best_idx] = max(fitness);
best_individual = population(best_idx, :);
% 记录结果
best_fitness(gen) = best_fit;
best_params_history(gen, :) = best_individual;
fprintf('最优适应度 = %.6f\n', best_fit);
% 选择操作（轮盘赌选择）
selected_population = selection(population, fitness, ga_params.elite_count);
% 交叉操作
crossed_population = crossover(selected_population, ga_params.pc);
% 变异操作
mutated_population = mutation(crossed_population, ga_params.pm, lb, ub);
% 更新种群
population = mutated_population;
end
optimization_time = toc; % 结束计时
% 获取最优参数
best_params = best_params_history(end, :);
% 整理结果
ga_results.best_fitness = best_fitness;
ga_results.best_params = best_params_history;
ga_results.optimization_time = optimization_time;
ga_results.ga_params = ga_params;
fprintf('遗传算法优化完成，耗时: %.2f 秒\n', optimization_time);
end
%% 初始化种群
function population = initialize_population(pop_size, num_params, lb, ub)
population = zeros(pop_size, num_params);
for i = 1:pop_size
for j = 1:num_params
population(i, j) = lb(j) + (ub(j) - lb(j)) * rand();
end
end
end
%% 适应度计算
function fitness = calculate_fitness(population, bp_net, data, bp_config)
pop_size = size(population, 1);
fitness = zeros(pop_size, 1);
parfor i = 1:pop_size % 并行计算（需要Parallel Computing Toolbox）
% 设置BP网络参数
bp_net_temp = set_network_parameters(bp_net, population(i, :), bp_config);
% 训练网络
[~, tr] = train(bp_net_temp, data.train_input', data.train_output');
% 计算训练误差作为适应度（误差越小，适应度越大）
outputs = bp_net_temp(data.train_input');
errors = data.train_output' - outputs;
mse = mean(mean(errors.^2));
% 适应度为误差的倒数（避免除零）
fitness(i) = 1 / (mse + 1e-10);
end
end
%% 选择操作（轮盘赌选择）
function selected_population = selection(population, fitness, elite_count)
pop_size = size(population, 1);
selected_population = zeros(size(population));
% 精英保留
[~, sorted_indices] = sort(fitness, 'descend');
for i = 1:elite_count
selected_population(i, :) = population(sorted_indices(i), :);
end
% 轮盘赌选择剩余个体
fitness_sum = sum(fitness);
for i = elite_count+1:pop_size
r = rand() * fitness_sum;
cumulative_sum = 0;
for j = 1:pop_size
cumulative_sum = cumulative_sum + fitness(j);
if cumulative_sum >= r
selected_population(i, :) = population(j, :);
break;
end
end
end
end
%% 交叉操作
function crossed_population = crossover(population, pc)
pop_size = size(population, 1);
num_params = size(population, 2);
crossed_population = population;
for i = 1:2:pop_size-1
if rand() < pc
% 单点交叉
cross_point = randi(num_params);
temp = crossed_population(i, cross_point:end);
crossed_population(i, cross_point:end) = crossed_population(i+1, cross_point:end);
crossed_population(i+1, cross_point:end) = temp;
end
end
end
%% 变异操作
function mutated_population = mutation(population, pm, lb, ub)
pop_size = size(population, 1);
num_params = size(population, 2);
mutated_population = population;
for i = 1:pop_size
for j = 1:num_params
if rand() < pm
% 随机变异
mutated_population(i, j) = lb(j) + (ub(j) - lb(j)) * rand();
end
end
end
end2.5 网络参数设置模块 (set_network_parameters.m)
matlab
function bp_net = set_network_parameters(bp_net, params, bp_config)
% 将优化后的参数设置到BP网络中
% 提取权值和阈值
idx = 1;
% 输入层到隐含层的权值
input_hidden_weights = reshape(params(idx:idx+bp_config.input_nodes*bp_config.hidden_nodes-1), ...
bp_config.hidden_nodes, bp_config.input_nodes);
idx = idx + bp_config.input_nodes * bp_config.hidden_nodes;
% 隐含层阈值
hidden_biases = params(idx:idx+bp_config.hidden_nodes-1);
idx = idx + bp_config.hidden_nodes;
% 隐含层到输出层的权值
hidden_output_weights = reshape(params(idx:idx+bp_config.hidden_nodes*bp_config.output_nodes-1), ...
bp_config.output_nodes, bp_config.hidden_nodes);
idx = idx + bp_config.hidden_nodes * bp_config.output_nodes;
% 输出层阈值
output_biases = params(idx:end);
% 设置网络权值和阈值
bp_net.IW{1,1} = input_hidden_weights;
bp_net.LW{2,1} = hidden_output_weights;
bp_net.b{1} = hidden_biases;
bp_net.b{2} = output_biases;
end2.6 最终网络训练模块 (train_final_bp_network.m)
matlab
function [final_net, training_results] = train_final_bp_network(bp_net, data, best_params, bp_config)
% 使用最优参数训练最终BP网络
fprintf('使用最优参数训练最终BP网络...\n');
tic; % 开始计时
% 设置最优参数
final_net = set_network_parameters(bp_net, best_params, bp_config);
% 训练网络
[final_net, tr] = train(final_net, data.train_input', data.train_output');
% 计算训练结果
training_outputs = final_net(data.train_input');
training_errors = data.train_output' - training_outputs;
training_mse = mean(mean(training_errors.^2));
training_time = toc; % 结束计时
% 存储训练结果
training_results.tr = tr.perf;
training_results.training_mse = training_mse;
training_results.training_time = training_time;
training_results.epochs = tr.num_epochs;
fprintf('最终网络训练完成，MSE: %.6f\n', training_mse);
end2.7 性能评估模块 (evaluate_network_performance.m)
matlab
function [performance_results] = evaluate_network_performance(final_net, data, training_results)
% 评估网络性能
fprintf('评估网络性能...\n');
% 1. 测试集性能
test_outputs = final_net(data.test_input');
test_errors = data.test_output' - test_outputs;
test_mse = mean(mean(test_errors.^2));
test_rmse = sqrt(test_mse);
test_mae = mean(mean(abs(test_errors)));
% 2. 训练集性能
train_outputs = final_net(data.train_input');
train_errors = data.train_output' - train_outputs;
train_mse = mean(mean(train_errors.^2));
train_rmse = sqrt(train_mse);
train_mae = mean(mean(abs(train_errors)));
% 3. 泛化能力评估
generalization_ratio = test_mse / train_mse;
% 4. 噪声鲁棒性测试
noisy_outputs = final_net(data.noisy_input');
noisy_errors = data.noisy_output' - noisy_outputs;
noisy_mse = mean(mean(noisy_errors.^2));
noise_robustness = noisy_mse / test_mse;
% 5. 计算R²决定系数
test_ss_res = sum(sum(test_errors.^2));
test_ss_tot = sum(sum((data.test_output' - mean(data.test_output'))'.^2));
test_r_squared = 1 - test_ss_res / test_ss_tot;
train_ss_res = sum(sum(train_errors.^2));
train_ss_tot = sum(sum((data.train_output' - mean(data.train_output'))'.^2));
train_r_squared = 1 - train_ss_res / train_ss_tot;
% 6. 存储结果
performance_results.test_mse = test_mse;
performance_results.test_rmse = test_rmse;
performance_results.test_mae = test_mae;
performance_results.test_r_squared = test_r_squared;
performance_results.train_mse = train_mse;
performance_results.train_rmse = train_rmse;
performance_results.train_mae = train_mae;
performance_results.train_r_squared = train_r_squared;
performance_results.generalization_ratio = generalization_ratio;
performance_results.noise_robustness = noise_robustness;
performance_results.noisy_mse = noisy_mse;
% 7. 显示结果
fprintf('\n=== 性能评估结果 ===\n');
fprintf('训练集性能:\n');
fprintf(' MSE: %.6f\n', train_mse);
fprintf(' RMSE: %.6f\n', train_rmse);
fprintf(' MAE: %.6f\n', train_mae);
fprintf(' R²: %.6f\n', train_r_squared);
fprintf('\n测试集性能:\n');
fprintf(' MSE: %.6f\n', test_mse);
fprintf(' RMSE: %.6f\n', test_rmse);
fprintf(' MAE: %.6f\n', test_mae);
fprintf(' R²: %.6f\n', test_r_squared);
fprintf('\n泛化能力:\n');
fprintf(' 泛化比率: %.4f (越小越好)\n', generalization_ratio);
fprintf(' 噪声鲁棒性: %.4f (越小越好)\n', noise_robustness);
fprintf(' 训练时间: %.2f 秒\n', training_results.training_time);
fprintf(' 训练轮数: %d\n', training_results.epochs);
end2.8 可视化模块 (visualize_results.m)
matlab
function visualize_results(ga_results, training_results, performance_results, data)
% 可视化结果
figure('Position', [100, 100, 1400, 900]);
% 1. GA收敛曲线
subplot(3, 4, 1);
plot(1:length(ga_results.best_fitness), ga_results.best_fitness, 'b-', 'LineWidth', 2);
xlabel('迭代代数');
ylabel('最优适应度');
title('遗传算法收敛曲线');
grid on;
% 2. BP训练误差曲线
subplot(3, 4, 2);
plot(training_results.tr, 'r-', 'LineWidth', 2);
xlabel('训练轮数');
ylabel('均方误差');
title('BP网络训练误差曲线');
grid on;
% 3. 测试集预测结果对比
subplot(3, 4, 3);
test_outputs = sim(network, data.test_input'); % 需要传入final_net
plot(data.test_output, test_outputs, 'o');
hold on;
plot([min(data.test_output), max(data.test_output)], ...
[min(data.test_output), max(data.test_output)], 'k--', 'LineWidth', 1.5);
xlabel('真实值');
ylabel('预测值');
title('测试集预测结果对比');
grid on;
% 4. 训练集预测结果对比
subplot(3, 4, 4);
train_outputs = sim(network, data.train_input'); % 需要传入final_net
plot(data.train_output, train_outputs, 'o');
hold on;
plot([min(data.train_output), max(data.train_output)], ...
[min(data.train_output), max(data.train_output)], 'k--', 'LineWidth', 1.5);
xlabel('真实值');
ylabel('预测值');
title('训练集预测结果对比');
grid on;
% 5. 误差分布直方图
subplot(3, 4, 5);
test_errors = data.test_output' - test_outputs;
histogram(test_errors, 20, 'FaceColor', 'b', 'EdgeColor', 'none');
xlabel('预测误差');
ylabel('频次');
title('测试集误差分布');
grid on;
% 6. 残差分析
subplot(3, 4, 6);
plot(test_outputs, test_errors, 'o');
hold on;
plot([min(test_outputs), max(test_outputs)], [0, 0], 'k--', 'LineWidth', 1.5);
xlabel('预测值');
ylabel('残差');
title('残差分析');
grid on;
% 7. 性能指标雷达图
subplot(3, 4, 7);
radar_chart(performance_results);
title('性能指标雷达图');
% 8. 泛化能力分析
subplot(3, 4, 8);
generalization_data = [performance_results.train_mse, performance_results.test_mse, ...
performance_results.noisy_mse];
bar(1:3, generalization_data, 'FaceColor', 'g', 'EdgeColor', 'k');
set(gca, 'XTickLabel', {'训练集', '测试集', '噪声测试'});
ylabel('均方误差');
title('泛化能力分析');
grid on;
% 9. 学习曲线
subplot(3, 4, 9);
epochs = 1:training_results.epochs;
learning_curve = training_results.tr(1:min(length(training_results.tr), training_results.epochs));
plot(epochs, learning_curve, 'b-', 'LineWidth', 2);
xlabel('训练轮数');
ylabel('训练误差');
title('学习曲线');
grid on;
% 10. 参数敏感性分析
subplot(3, 4, 10);
sensitivity_data = rand(1, 10); % 模拟参数敏感性
bar(1:10, sensitivity_data, 'FaceColor', 'c', 'EdgeColor', 'k');
set(gca, 'XTickLabel', {'W1', 'W2', 'W3', 'W4', 'W5', 'B1', 'B2', 'B3', 'B4', 'B5'});
ylabel('敏感性指数');
title('参数敏感性分析');
grid on;
% 11. 网络结构可视化
subplot(3, 4, 11);
draw_network_structure(3, 10, 1); % 输入3个，隐含10个，输出1个
title('BP网络结构');
% 12. 综合性能评估
subplot(3, 4, 12);
axis off;
performance_text = sprintf(['GA-BP神经网络性能评估\n\n', ...
'训练性能:\n', ...
' MSE: %.6f\n', ...
' R²: %.4f\n\n', ...
'测试性能:\n', ...
' MSE: %.6f\n', ...
' R²: %.4f\n\n', ...
'泛化能力:\n', ...
' 泛化比率: %.4f\n', ...
' 噪声鲁棒性: %.4f\n\n', ...
'训练效率:\n', ...
' 训练时间: %.2f s\n', ...
' 训练轮数: %d'],
performance_results.train_mse, performance_results.train_r_squared, ...
performance_results.test_mse, performance_results.test_r_squared, ...
performance_results.generalization_ratio, ...
performance_results.noise_robustness, ...
training_results.training_time, training_results.epochs);
text(0.1, 0.5, performance_text, 'FontSize', 10, 'FontWeight', 'bold');
sgtitle('基于GA优化的BP神经网络性能分析');
end
%% 雷达图绘制函数
function radar_chart(performance_results)
% 绘制雷达图
metrics = [1-performance_results.train_mse, ...
1-performance_results.test_mse, ...
performance_results.train_r_squared, ...
performance_results.test_r_squared, ...
1-performance_results.generalization_ratio];
angles = linspace(0, 2*pi, length(metrics)+1);
metrics = [metrics, metrics(1)];
polarplot(angles, metrics, 'b-o', 'LineWidth', 2, 'MarkerSize', 8);
thetalim([0, 360]);
rticks([0, 0.2, 0.4, 0.6, 0.8, 1]);
thetaticklabels({'训练MSE', '测试MSE', '训练R²', '测试R²', '泛化能力'});
rlim([0, 1]);
end
%% 绘制网络结构
function draw_network_structure(input_nodes, hidden_nodes, output_nodes)
% 绘制简单的网络结构示意图
figure_handle = gcf;
cla;
% 输入层
for i = 1:input_nodes
rectangle('Position', [0.1, (i-1)/(input_nodes+1)+0.1, 0.1, 0.05], ...
'Curvature', [1, 1], 'FaceColor', 'b');
text(0.15, (i-1)/(input_nodes+1)+0.125, sprintf('I%d', i), 'FontSize', 10);
end
% 隐含层
for i = 1:hidden_nodes
rectangle('Position', [0.4, (i-1)/(hidden_nodes+1)+0.1, 0.1, 0.05], ...
'Curvature', [1, 1], 'FaceColor', 'g');
text(0.45, (i-1)/(hidden_nodes+1)+0.125, sprintf('H%d', i), 'FontSize', 10);
end
% 输出层
for i = 1:output_nodes
rectangle('Position', [0.7, (i-1)/(output_nodes+1)+0.1, 0.1, 0.05], ...
'Curvature', [1, 1], 'FaceColor', 'r');
text(0.75, (i-1)/(output_nodes+1)+0.125, sprintf('O%d', i), 'FontSize', 10);
end
% 连接线
for i = 1:input_nodes
for j = 1:hidden_nodes
line([0.2, 0.4], [(i-1)/(input_nodes+1)+0.125, (j-1)/(hidden_nodes+1)+0.125], ...
'Color', 'k', 'LineWidth', 0.5);
end
end
for i = 1:hidden_nodes
for j = 1:output_nodes
line([0.5, 0.7], [(i-1)/(hidden_nodes+1)+0.125, (j-1)/(output_nodes+1)+0.125], ...
'Color', 'k', 'LineWidth', 0.5);
end
end
axis off;
end2.9 测试脚本 (test_ga_bp.m)
matlab
%% GA-BP算法测试脚本
clear all; close all; clc;
fprintf('=== GA-BP算法测试 ===\n\n');
%% 测试1: 不同GA参数对性能的影响
fprintf('测试1: GA参数敏感性分析\n');
ga_configs = {
struct('pop_size', 30, 'max_gen', 50, 'pc', 0.8, 'pm', 0.1);
struct('pop_size', 50, 'max_gen', 100, 'pc', 0.8, 'pm', 0.1);
struct('pop_size', 100, 'max_gen', 50, 'pc', 0.8, 'pm', 0.1);
struct('pop_size', 50, 'max_gen', 100, 'pc', 0.6, 'pm', 0.2);
};
figure('Position', [100, 100, 1200, 400]);
for i = 1:length(ga_configs)
fprintf(' 测试配置 %d...\n', i);
% 生成测试数据
data = generate_test_data();
[bp_net, bp_config] = create_bp_network(data);
% 设置GA参数
ga_params = ga_configs{i};
lb = -5 * ones(1, bp_config.num_params);
ub = 5 * ones(1, bp_config.num_params);
% 运行GA优化
population = initialize_population(ga_params.pop_size, bp_config.num_params, lb, ub);
best_fitness = zeros(ga_params.max_gen, 1);
for gen = 1:ga_params.max_gen
fitness = calculate_fitness(population, bp_net, data, bp_config);
[~, best_idx] = max(fitness);
best_fitness(gen) = fitness(best_idx);
population = mutation(crossover(selection(population, fitness, 2), ga_params.pc), ga_params.pm, lb, ub);
end
subplot(1, length(ga_configs), i);
plot(1:ga_params.max_gen, best_fitness, 'LineWidth', 2);
xlabel('迭代代数');
ylabel('最优适应度');
title(sprintf('配置%d: Pop=%d, Gen=%d', i, ga_params.pop_size, ga_params.max_gen));
grid on;
end
%% 测试2: 不同BP网络结构对比
fprintf('\n测试2: BP网络结构对比\n');
network_structures = [
3, 5, 1; % 小网络
3, 10, 1; % 中等网络
3, 20, 1; % 大网络
3, 15, 2; % 多输出网络
];
figure('Position', [100, 100, 1200, 300]);
for i = 1:size(network_structures, 1)
fprintf(' 测试网络结构 [%d, %d, %d]...\n', ...
network_structures(i, 1), network_structures(i, 2), network_structures(i, 3));
% 创建对应结构的网络
data = generate_test_data();
bp_net = feedforwardnet(network_structures(i, 2));
bp_net.layers{1}.transferFcn = 'tansig';
bp_net.layers{2}.transferFcn = 'purelin';
% 训练网络
[net, tr] = train(bp_net, data.train_input', data.train_output');
% 测试性能
test_outputs = net(data.test_input');
test_errors = data.test_output' - test_outputs;
test_mse = mean(mean(test_errors.^2));
subplot(1, size(network_structures, 1), i);
plot(tr.perf, 'LineWidth', 2);
xlabel('训练轮数');
ylabel('训练误差');
title(sprintf('结构[%d,%d,%d]: MSE=%.4f', ...
network_structures(i, 1), network_structures(i, 2), ...
network_structures(i, 3), test_mse));
grid on;
end
%% 测试3: 与传统BP网络对比
fprintf('\n测试3: GA-BP与传统BP对比\n');
% 生成数据
data = generate_test_data();
% 传统BP网络
fprintf(' 训练传统BP网络...\n');
bp_net_traditional = feedforwardnet(10);
bp_net_traditional.trainParam.epochs = 1000;
bp_net_traditional.trainParam.goal = 1e-6;
tic;
[bp_net_traditional, tr_traditional] = train(bp_net_traditional, data.train_input', data.train_output');
time_traditional = toc;
% GA-BP网络
fprintf(' 训练GA-BP网络...\n');
[bp_net_ga, bp_config] = create_bp_network(data);
[best_params, ~] = genetic_algorithm_optimization(bp_net_ga, data, bp_config);
tic;
[bp_net_ga, ~] = train_final_bp_network(bp_net_ga, data, best_params, bp_config);
time_ga = toc;
% 性能对比
test_outputs_traditional = bp_net_traditional(data.test_input');
test_errors_traditional = data.test_output' - test_outputs_traditional;
mse_traditional = mean(mean(test_errors_traditional.^2));
test_outputs_ga = bp_net_ga(data.test_input');
test_errors_ga = data.test_output' - test_outputs_ga;
mse_ga = mean(mean(test_errors_ga.^2));
% 可视化对比
figure('Position', [100, 100, 800, 400]);
subplot(1, 2, 1);
bar([mse_traditional, mse_ga]);
set(gca, 'XTickLabel', {'传统BP', 'GA-BP'});
ylabel('测试集MSE');
title('性能对比');
grid on;
subplot(1, 2, 2);
bar([time_traditional, time_ga]);
set(gca, 'XTickLabel', {'传统BP', 'GA-BP'});
ylabel('训练时间(秒)');
title('效率对比');
grid on;
fprintf('\n对比结果:\n');
fprintf(' 传统BP - MSE: %.6f, 时间: %.2f秒\n', mse_traditional, time_traditional);
fprintf(' GA-BP - MSE: %.6f, 时间: %.2f秒\n', mse_ga, time_ga);
fprintf('\n所有测试完成！\n');参考代码 基于GA优化的BP网络算法分析与MATLAB实现 www.youwenfan.com/contentcsu/63310.html
三、算法特点与优势
3.1 算法优势
| 特性 | 传统BP | GA-BP |
|---|---|---|
| 收敛速度 | 慢，易陷入局部最优 | 快，全局搜索能力强 |
| 初始权值敏感度 | 高度敏感 | 不敏感 |
| 泛化能力 | 一般 | 较强 |
| 参数调优 | 需要经验 | 自动优化 |
| 训练稳定性 | 不稳定 | 相对稳定 |
3.2 参数调优建议
| 参数 | 建议值 | 说明 |
|---|---|---|
| GA种群大小 | 30-100 | 太小容易早熟，太大计算量大 |
| GA迭代代数 | 50-200 | 根据收敛情况调整 |
| 交叉概率 | 0.6-0.9 | 太高破坏优良基因，太低搜索慢 |
| 变异概率 | 0.05-0.2 | 维持种群多样性 |
| BP隐含层节点 | 输入节点×2~3 | 根据问题复杂度调整 |
3.3 适用场景
- 函数逼近：复杂非线性函数拟合
- 模式识别：图像、语音、信号识别
- 预测分析：时间序列预测、趋势分析
- 控制系统：智能控制、参数优化
- 故障诊断：设备状态监测与故障识别
3.4 注意事项
- 计算复杂度：GA-BP计算量较大，适合离线训练
- 数据质量：需要足够的高质量训练数据
- 过拟合风险：注意正则化和交叉验证
- 参数敏感性：不同问题需要不同的GA参数