卡尔曼滤波器实现RBF神经网络训练

一、MATLAB实现

1.1 主程序：卡尔曼滤波RBF神经网络

matlab 复制代码

%% 卡尔曼滤波器实现RBF神经网络训练
% 功能：使用卡尔曼滤波算法训练RBF神经网络
% 特点：在线学习、递归估计、收敛速度快

clear; clc; close all;
fprintf('=== 卡尔曼滤波RBF神经网络训练开始 ===\n');

%% 1. 数据生成
fprintf('生成训练数据...\n');

% 生成非线性函数数据：y = sin(x) + 0.1*noise
N_train = 200;          % 训练样本数
N_test = 100;           % 测试样本数
input_dim = 1;          % 输入维度
output_dim = 1;         % 输出维度

% 训练数据
x_train = linspace(-pi, pi, N_train)';
noise_train = 0.1 * randn(N_train, 1);
y_train = sin(x_train) + noise_train;

% 测试数据
x_test = linspace(-pi, pi, N_test)';
y_test = sin(x_test);

% 可视化数据
figure('Position', [100, 100, 800, 400]);
subplot(1, 2, 1);
plot(x_train, y_train, 'b.', 'MarkerSize', 8);
hold on;
plot(x_test, y_test, 'r-', 'LineWidth', 2);
xlabel('x'); ylabel('y');
title('训练数据与真实函数');
legend('训练数据', '真实函数', 'Location', 'best');
grid on;

%% 2. RBF神经网络结构
fprintf('设计RBF神经网络结构...\n');

% RBF网络参数
hidden_neurons = 15;      % 隐含层神经元数
spread = 0.5;             % RBF函数扩展系数

% 初始化RBF中心（使用k-means聚类）
centers = kmeans_initializer(x_train, hidden_neurons);

% 计算RBF激活函数
function activation = rbf_activation(x, centers, spread)
    % 高斯径向基函数
    n_samples = size(x, 1);
    n_centers = size(centers, 1);
    activation = zeros(n_samples, n_centers);
    
    for i = 1:n_centers
        diff = x - centers(i);
        activation(:, i) = exp(-(diff.^2) / (2 * spread^2));
    end
end

% 计算隐含层输出
Phi_train = rbf_activation(x_train, centers, spread);
Phi_test = rbf_activation(x_test, centers, spread);

fprintf('RBF网络结构：%d-%d-%d\n', input_dim, hidden_neurons, output_dim);
fprintf('隐含层激活函数：高斯径向基\n');

%% 3. 卡尔曼滤波训练算法
fprintf('初始化卡尔曼滤波器...\n');

% 3.1 卡尔曼滤波参数
state_dim = hidden_neurons;    % 状态维度（权重数量）
obs_dim = 1;                 % 观测维度

% 初始化状态（权重）
W = zeros(state_dim, 1);     % 初始权重
P = eye(state_dim) * 100;     % 初始状态协方差（不确定度高）
Q = eye(state_dim) * 1e-6;   % 过程噪声协方差（小，权重变化慢）
R = 0.1;                    % 观测噪声协方差（根据噪声水平调整）

% 3.2 卡尔曼滤波递归更新
fprintf('开始卡尔曼滤波递归更新...\n');

W_history = zeros(state_dim, N_train);  % 权重历史
P_history = zeros(state_dim, state_dim, N_train);  % 协方差历史
prediction_error = zeros(N_train, 1);  % 预测误差

for k = 1:N_train
    % 当前时刻的输入和观测
    Phi_k = Phi_train(k, :)';      % 隐含层输出（观测矩阵H）
    y_k = y_train(k);              % 实际输出（观测值z）
    
    % ===== 卡尔曼滤波预测步骤 =====
    % 状态预测：W_pred = W (无控制输入，状态不变)
    W_pred = W;
    
    % 协方差预测：P_pred = P + Q
    P_pred = P + Q;
    
    % ===== 卡尔曼滤波更新步骤 =====
    % 计算卡尔曼增益：K = P_pred * H' * inv(H * P_pred * H' + R)
    H = Phi_k';  % 观测矩阵
    K = (P_pred * H') / (H * P_pred * H' + R);
    
    % 更新状态估计：W = W_pred + K * (y_k - H * W_pred)
    innovation = y_k - H * W_pred;
    W = W_pred + K * innovation;
    
    % 更新协方差：P = (I - K * H) * P_pred
    I = eye(state_dim);
    P = (I - K * H) * P_pred;
    
    % 记录历史
    W_history(:, k) = W;
    P_history(:, :, k) = P;
    prediction_error(k) = innovation;
    
    % 显示进度
    if mod(k, 50) == 0
        fprintf('  样本 %d/%d: 误差=%.4f\n', k, N_train, abs(innovation));
    end
end

fprintf('卡尔曼滤波训练完成！\n');

%% 4. 网络性能评估
fprintf('评估网络性能...\n');

% 4.1 训练集预测
y_train_pred = Phi_train * W;
train_mse = mean((y_train - y_train_pred).^2);
train_rmse = sqrt(train_mse);

% 4.2 测试集预测
y_test_pred = Phi_test * W;
test_mse = mean((y_test - y_test_pred).^2);
test_rmse = sqrt(test_mse);

% 4.3 计算R²决定系数
SS_res = sum((y_test - y_test_pred).^2);
SS_tot = sum((y_test - mean(y_test)).^2);
R_squared = 1 - SS_res/SS_tot;

fprintf('\n=== 性能评估 ===\n');
fprintf('训练集RMSE: %.4f\n', train_rmse);
fprintf('测试集RMSE: %.4f\n', test_rmse);
fprintf('R²决定系数: %.4f\n', R_squared);

% 4.4 可视化预测结果
subplot(1, 2, 2);
plot(x_test, y_test, 'r-', 'LineWidth', 2, 'DisplayName', '真实值');
hold on;
plot(x_test, y_test_pred, 'b--', 'LineWidth', 1.5, 'DisplayName', '预测值');
xlabel('x'); ylabel('y');
title('测试集预测结果');
legend('Location', 'best');
grid on;

%% 5. 卡尔曼滤波收敛分析
fprintf('分析卡尔曼滤波收敛性...\n');

figure('Position', [100, 100, 1200, 400]);

% 5.1 权重收敛过程
subplot(1, 3, 1);
plot(1:N_train, W_history', 'LineWidth', 1);
xlabel('迭代次数'); ylabel('权重值');
title('权重收敛过程');
grid on;

% 5.2 预测误差
subplot(1, 3, 2);
plot(1:N_train, prediction_error, 'k-', 'LineWidth', 1.5);
xlabel('迭代次数'); ylabel('预测误差');
title('预测误差变化');
grid on;

% 5.3 协方差迹（不确定性度量）
subplot(1, 3, 3);
covariance_trace = zeros(N_train, 1);
for k = 1:N_train
    covariance_trace(k) = trace(P_history(:, :, k));
end
semilogy(1:N_train, covariance_trace, 'r-', 'LineWidth', 1.5);
xlabel('迭代次数'); ylabel('协方差迹 (log scale)');
title('估计不确定性衰减');
grid on;

%% 6. 与传统RBF训练方法对比
fprintf('与传统最小二乘法对比...\n');

% 6.1 最小二乘法（伪逆）
W_ls = pinv(Phi_train) * y_train;
y_train_ls = Phi_train * W_ls;
y_test_ls = Phi_test * W_ls;

% 6.2 计算性能
train_mse_ls = mean((y_train - y_train_ls).^2);
test_mse_ls = mean((y_test - y_test_ls).^2);

fprintf('\n=== 方法对比 ===\n');
fprintf('方法\t\t训练RMSE\t测试RMSE\n');
fprintf('卡尔曼滤波\t%.4f\t\t%.4f\n', train_rmse, test_rmse);
fprintf('最小二乘法\t%.4f\t\t%.4f\n', sqrt(train_mse_ls), sqrt(test_mse_ls));

% 6.3 可视化对比
figure('Position', [100, 100, 800, 400]);

subplot(1, 2, 1);
plot(x_test, y_test, 'k-', 'LineWidth', 2, 'DisplayName', '真实值');
hold on;
plot(x_test, y_test_pred, 'b--', 'LineWidth', 1.5, 'DisplayName', '卡尔曼滤波');
plot(x_test, y_test_ls, 'r:', 'LineWidth', 1.5, 'DisplayName', '最小二乘法');
xlabel('x'); ylabel('y');
title('不同训练方法对比');
legend('Location', 'best');
grid on;

% 6.4 误差分布
subplot(1, 2, 2);
errors_kf = y_test - y_test_pred;
errors_ls = y_test - y_test_ls;

histogram(errors_kf, 20, 'Normalization', 'probability', ...
          'FaceColor', 'b', 'EdgeColor', 'k', 'DisplayName', '卡尔曼滤波');
hold on;
histogram(errors_ls, 20, 'Normalization', 'probability', ...
          'FaceColor', 'r', 'EdgeColor', 'k', 'DisplayName', '最小二乘法');
xlabel('预测误差'); ylabel('概率');
title('误差分布对比');
legend('Location', 'best');
grid on;

%% 7. 多步预测（在线学习演示）
fprintf('演示在线学习能力...\n');

figure('Position', [100, 100, 1000, 400]);

% 初始化卡尔曼滤波器
W_online = zeros(hidden_neurons, 1);
P_online = eye(hidden_neurons) * 100;
Q_online = eye(hidden_neurons) * 1e-6;
R_online = 0.1;

% 在线学习过程
window_size = 50;
online_errors = zeros(N_test, 1);
predictions_history = zeros(N_test, window_size);

for k = 1:N_test
    % 获取当前输入
    x_k = x_test(k);
    y_k = y_test(k);
    
    % 计算RBF激活
    Phi_k = zeros(1, hidden_neurons);
    for i = 1:hidden_neurons
        diff = x_k - centers(i);
        Phi_k(i) = exp(-(diff^2) / (2 * spread^2));
    end
    
    % 预测
    y_pred = Phi_k * W_online;
    online_errors(k) = y_k - y_pred;
    
    % 卡尔曼滤波更新
    H = Phi_k;
    K = (P_online * H') / (H * P_online * H' + R_online);
    innovation = y_k - H * W_online;
    W_online = W_online + K * innovation;
    P_online = (eye(hidden_neurons) - K * H) * P_online;
    
    % 记录预测历史
    if k <= window_size
        predictions_history(k, 1:k) = (Phi_test(1:k, :) * W_online)';
    else
        predictions_history(k, :) = (Phi_test(k-window_size+1:k, :) * W_online)';
    end
end

% 可视化在线学习
subplot(1, 2, 1);
plot(1:N_test, online_errors, 'b-', 'LineWidth', 1.5);
xlabel('时间步'); ylabel('预测误差');
title('在线学习误差变化');
grid on;

subplot(1, 2, 2);
% 绘制最后20步的预测轨迹
steps_to_show = min(20, N_test);
for i = N_test-steps_to_show+1:N_test
    plot(i-steps_to_show:N_test-1, predictions_history(i, 1:steps_to_show), 'b-', 'LineWidth', 1);
    hold on;
end
plot(1:N_test, y_test, 'r-', 'LineWidth', 2, 'DisplayName', '真实值');
xlabel('时间步'); ylabel('预测值');
title('在线预测轨迹');
legend('Location', 'best');
grid on;

%% 8. 参数敏感性分析
fprintf('进行参数敏感性分析...\n');

% 测试不同RBF中心数的影响
center_counts = [5, 10, 15, 20, 25];
performance_centers = zeros(length(center_counts), 2);

for idx = 1:length(center_counts)
    n_centers = center_counts(idx);
    
    % 重新初始化RBF网络
    centers_temp = kmeans_initializer(x_train, n_centers);
    Phi_train_temp = rbf_activation(x_train, centers_temp, spread);
    Phi_test_temp = rbf_activation(x_test, centers_temp, spread);
    
    % 卡尔曼滤波训练
    W_temp = zeros(n_centers, 1);
    P_temp = eye(n_centers) * 100;
    Q_temp = eye(n_centers) * 1e-6;
    R_temp = 0.1;
    
    for k = 1:N_train
        Phi_k = Phi_train_temp(k, :)';
        y_k = y_train(k);
        
        % 卡尔曼滤波
        W_pred = W_temp;
        P_pred = P_temp + Q_temp;
        H = Phi_k';
        K = (P_pred * H') / (H * P_pred * H' + R_temp);
        innovation = y_k - H * W_pred;
        W_temp = W_pred + K * innovation;
        P_temp = (eye(n_centers) - K * H) * P_pred;
    end
    
    % 测试性能
    y_test_pred_temp = Phi_test_temp * W_temp;
    test_mse_temp = mean((y_test - y_test_pred_temp).^2);
    performance_centers(idx, :) = [n_centers, sqrt(test_mse_temp)];
end

% 测试不同扩展系数的影响
spreads = [0.1, 0.3, 0.5, 0.7, 1.0];
performance_spreads = zeros(length(spreads), 2);

for idx = 1:length(spreads)
    sp = spreads(idx);
    
    % 重新初始化RBF网络
    Phi_train_temp = rbf_activation(x_train, centers, sp);
    Phi_test_temp = rbf_activation(x_test, centers, sp);
    
    % 卡尔曼滤波训练
    W_temp = zeros(hidden_neurons, 1);
    P_temp = eye(hidden_neurons) * 100;
    Q_temp = eye(hidden_neurons) * 1e-6;
    R_temp = 0.1;
    
    for k = 1:N_train
        Phi_k = Phi_train_temp(k, :)';
        y_k = y_train(k);
        
        % 卡尔曼滤波
        W_pred = W_temp;
        P_pred = P_temp + Q_temp;
        H = Phi_k';
        K = (P_pred * H') / (H * P_pred * H' + R_temp);
        innovation = y_k - H * W_pred;
        W_temp = W_pred + K * innovation;
        P_temp = (eye(hidden_neurons) - K * H) * P_pred;
    end
    
    % 测试性能
    y_test_pred_temp = Phi_test_temp * W_temp;
    test_mse_temp = mean((y_test - y_test_pred_temp).^2);
    performance_spreads(idx, :) = [sp, sqrt(test_mse_temp)];
end

% 可视化敏感性分析
figure('Position', [100, 100, 1000, 400]);

subplot(1, 2, 1);
plot(performance_centers(:, 1), performance_centers(:, 2), 'bo-', 'LineWidth', 2, 'MarkerSize', 8);
xlabel('RBF中心数量'); ylabel('测试集RMSE');
title('中心数量对性能的影响');
grid on;

subplot(1, 2, 2);
plot(performance_spreads(:, 1), performance_spreads(:, 2), 'ro-', 'LineWidth', 2, 'MarkerSize', 8);
xlabel('RBF扩展系数'); ylabel('测试集RMSE');
title('扩展系数对性能的影响');
grid on;

%% 9. 保存结果
fprintf('保存训练结果...\n');

% 保存模型参数
model.W = W;
model.centers = centers;
model.spread = spread;
model.hidden_neurons = hidden_neurons;
model.train_rmse = train_rmse;
model.test_rmse = test_rmse;
model.R_squared = R_squared;

% 保存工作空间
save('kalman_rbf_model.mat', 'model', 'x_train', 'y_train', 'x_test', 'y_test', ...
     'W_history', 'P_history', 'prediction_error');

fprintf('\n=== 训练完成 ===\n');
fprintf('模型已保存到 kalman_rbf_model.mat\n');

1.2 辅助函数：K-means初始化

matlab 复制代码

%% K-means聚类初始化RBF中心
function centers = kmeans_initializer(data, n_centers)
    % 使用K-means聚类确定RBF中心
    % 输入：
    %   data: 训练数据
    %   n_centers: 中心数量
    % 输出：
    %   centers: RBF中心
    
    % 使用MATLAB内置kmeans函数
    opts = statset('MaxIter', 100, 'Display', 'off');
    centers = kmeans(data, n_centers, 'Options', opts);
    
    % 如果kmeans失败，使用随机初始化
    if isempty(centers)
        fprintf('警告：K-means聚类失败，使用随机初始化\n');
        min_val = min(data);
        max_val = max(data);
        centers = min_val + (max_val - min_val) * rand(n_centers, 1);
    end
end

1.3 扩展：扩展卡尔曼滤波（EKF）RBF

matlab 复制代码

%% 扩展卡尔曼滤波RBF神经网络
function [W, P] = ekf_rbf_training(x_train, y_train, centers, spread, W_init, P_init)
    % 扩展卡尔曼滤波训练RBF网络
    % 适用于非线性观测模型
    
    N = length(y_train);
    state_dim = length(W_init);
    
    % 初始化
    W = W_init;
    P = P_init;
    
    % EKF参数
    Q = eye(state_dim) * 1e-6;  % 过程噪声
    R = 0.1;                    % 观测噪声
    
    for k = 1:N
        % 计算RBF激活
        Phi_k = zeros(1, state_dim);
        for i = 1:state_dim
            diff = x_train(k) - centers(i);
            Phi_k(i) = exp(-(diff^2) / (2 * spread^2));
        end
        
        % ===== 预测步骤 =====
        W_pred = W;
        P_pred = P + Q;
        
        % ===== 更新步骤 =====
        % 计算观测雅可比矩阵（线性观测模型）
        H = Phi_k;
        
        % 计算卡尔曼增益
        K = (P_pred * H') / (H * P_pred * H' + R);
        
        % 更新状态
        y_pred = H * W_pred;
        innovation = y_train(k) - y_pred;
        W = W_pred + K * innovation;
        
        % 更新协方差
        I = eye(state_dim);
        P = (I - K * H) * P_pred;
    end
end

1.4 无迹卡尔曼滤波（UKF）RBF

matlab 复制代码

%% 无迹卡尔曼滤波RBF神经网络
function [W, P] = ukf_rbf_training(x_train, y_train, centers, spread, W_init, P_init)
    % 无迹卡尔曼滤波训练RBF网络
    % 使用UT变换处理非线性
    
    N = length(y_train);
    state_dim = length(W_init);
    
    % 初始化
    W = W_init;
    P = P_init;
    
    % UKF参数
    alpha = 1e-3;      % UT缩放参数
    beta = 2;           % 高斯分布的beta参数
    kappa = 0;          % 二阶尺度参数
    lambda = alpha^2 * (state_dim + kappa) - state_dim;
    
    % 权重计算
    Wm = zeros(2*state_dim+1, 1);
    Wc = zeros(2*state_dim+1, 1);
    
    Wm(1) = lambda / (state_dim + lambda);
    Wc(1) = lambda / (state_dim + lambda) + (1 - alpha^2 + beta);
    
    for i = 2:2*state_dim+1
        Wm(i) = 1 / (2*(state_dim + lambda));
        Wc(i) = 1 / (2*(state_dim + lambda));
    end
    
    % 过程噪声和观测噪声
    Q = eye(state_dim) * 1e-6;
    R = 0.1;
    
    for k = 1:N
        % ===== 生成Sigma点 =====
        sqrt_P = chol((state_dim + lambda) * P, 'lower');
        sigma_points = zeros(state_dim, 2*state_dim+1);
        sigma_points(:, 1) = W;
        
        for i = 1:state_dim
            sigma_points(:, i+1) = W + sqrt_P(:, i);
            sigma_points(:, i+1+state_dim) = W - sqrt_P(:, i);
        end
        
        % ===== 预测步骤 =====
        % 传递Sigma点通过观测模型
        Y_pred = zeros(1, 2*state_dim+1);
        for i = 1:2*state_dim+1
            % 计算RBF输出
            Phi = zeros(1, state_dim);
            for j = 1:state_dim
                diff = x_train(k) - centers(j);
                Phi(j) = exp(-(diff^2) / (2 * spread^2));
            end
            Y_pred(i) = Phi * sigma_points(:, i);
        end
        
        % 计算预测均值和协方差
        y_mean = 0;
        for i = 1:2*state_dim+1
            y_mean = y_mean + Wm(i) * Y_pred(i);
        end
        
        Pyy = R;
        for i = 1:2*state_dim+1
            diff = Y_pred(i) - y_mean;
            Pyy = Pyy + Wc(i) * (diff * diff');
        end
        
        % ===== 更新步骤 =====
        % 计算互协方差
        Pxy = zeros(state_dim, 1);
        for i = 1:2*state_dim+1
            diff_x = sigma_points(:, i) - W;
            diff_y = Y_pred(i) - y_mean;
            Pxy = Pxy + Wc(i) * (diff_x * diff_y');
        end
        
        % 卡尔曼增益
        K = Pxy / Pyy;
        
        % 更新状态
        innovation = y_train(k) - y_mean;
        W = W + K * innovation;
        
        % 更新协方差
        P = P - K * Pyy * K';
    end
end

二、算法原理详解

2.1 卡尔曼滤波RBF网络结构

复制代码

输入层 (x) → RBF层 (Φ) → 输出层 (y = Φ·W)
                    ↑
             高斯径向基函数
             φ_i(x) = exp(-||x-c_i||²/(2σ²))

2.2 卡尔曼滤波状态空间模型

状态方程 ：
Wk=Wk−1+wkW_k = W_{k-1} + w_kWk=Wk−1+wk

其中 wk∼N(0,Q)w_k \sim N(0, Q)wk∼N(0,Q) 是过程噪声。

观测方程 ：
yk=ΦkTWk+vky_k = \Phi_k^T W_k + v_kyk=ΦkTWk+vk

其中 vk∼N(0,R)v_k \sim N(0, R)vk∼N(0,R) 是观测噪声。

2.3 卡尔曼滤波五大公式

步骤	公式	说明
预测	$\hat{W}_{k	k-1} = \hat{W}_{k-1
协方差预测	$P_{k	k-1} = P_{k-1
卡尔曼增益	$K_k = P_{k	k-1} \Phi_k (\Phi_k^T P_{k
状态更新	$\hat{W}_{k	k} = \hat{W}_{k
协方差更新	$P_{k	k} = (I - K_k \Phi_k^T) P_{k

参考代码卡尔曼滤波器算法实现RBF神经网络训练 www.youwenfan.com/contentcsu/63139.html

三、性能优化与扩展

3.1 自适应卡尔曼滤波

matlab 复制代码

%% 自适应卡尔曼滤波（Sage-Husa）
function [W, P] = adaptive_kalman_rbf(x_train, y_train, centers, spread)
    % 自适应调整观测噪声R
    
    N = length(y_train);
    state_dim = length(centers);
    
    % 初始化
    W = zeros(state_dim, 1);
    P = eye(state_dim) * 100;
    Q = eye(state_dim) * 1e-6;
    R = 0.1;
    
    % 自适应参数
    beta = 0.95;  % 遗忘因子
    
    for k = 1:N
        % 计算RBF激活
        Phi_k = zeros(1, state_dim);
        for i = 1:state_dim
            diff = x_train(k) - centers(i);
            Phi_k(i) = exp(-(diff^2) / (2 * spread^2));
        end
        
        % 预测
        W_pred = W;
        P_pred = P + Q;
        
        % 计算残差
        residual = y_train(k) - Phi_k * W_pred;
        
        % 自适应估计观测噪声
        R_hat = residual^2;
        R = beta * R + (1-beta) * R_hat;
        
        % 更新
        K = (P_pred * Phi_k') / (Phi_k * P_pred * Phi_k' + R);
        W = W_pred + K * residual;
        P = (eye(state_dim) - K * Phi_k) * P_pred;
    end
end

3.2 平方根卡尔曼滤波（数值稳定）

matlab 复制代码

%% 平方根卡尔曼滤波（SRKF）
function [W, S] = srkf_rbf_training(x_train, y_train, centers, spread)
    % 使用Cholesky分解保持协方差矩阵正定
    
    N = length(y_train);
    state_dim = length(centers);
    
    % 初始化
    W = zeros(state_dim, 1);
    S = chol(eye(state_dim) * 100, 'lower');  % 协方差平方根
    Q_sqrt = chol(eye(state_dim) * 1e-6, 'lower');
    R = 0.1;
    
    for k = 1:N
        % 计算RBF激活
        Phi_k = zeros(1, state_dim);
        for i = 1:state_dim
            diff = x_train(k) - centers(i);
            Phi_k(i) = exp(-(diff^2) / (2 * spread^2));
        end
        
        % 预测步骤（平方根形式）
        S_pred = [S, Q_sqrt; zeros(state_dim, state_dim), zeros(state_dim, state_dim)];
        S_pred = chol(update(S_pred * S_pred'), 'lower');
        
        % 更新步骤
        y_pred = Phi_k * W;
        residual = y_train(k) - y_pred;
        
        % 计算卡尔曼增益
        S_pred_phi = S_pred' * Phi_k';
        S_residual = chol(Phi_k * (S_pred * S_pred') * Phi_k' + R, 'lower');
        K = (S_pred * S_pred_phi) / S_residual;
        
        % 更新状态
        W = W + K * residual;
        
        % 更新协方差平方根
        U = S_pred * S_pred';
        V = K * S_residual;
        S = chol(U - V * V', 'lower');
    end
end

3.3 多输出RBF网络

matlab 复制代码

%% 多输出RBF神经网络
function [W, P] = multioutput_kalman_rbf(x_train, Y_train, centers, spread)
    % 多输出RBF网络（每个输出独立卡尔曼滤波）
    
    N = size(x_train, 1);
    state_dim = length(centers);
    output_dim = size(Y_train, 2);
    
    % 为每个输出维护独立的卡尔曼滤波器
    W_all = zeros(state_dim, output_dim);
    P_all = zeros(state_dim, state_dim, output_dim);
    
    % 初始化
    for d = 1:output_dim
        W_all(:, d) = zeros(state_dim, 1);
        P_all(:, :, d) = eye(state_dim) * 100;
    end
    
    Q = eye(state_dim) * 1e-6;
    R = 0.1;
    
    for k = 1:N
        % 计算RBF激活
        Phi_k = zeros(1, state_dim);
        for i = 1:state_dim
            diff = x_train(k) - centers(i);
            Phi_k(i) = exp(-(diff^2) / (2 * spread^2));
        end
        
        % 对每个输出独立更新
        for d = 1:output_dim
            % 预测
            W_pred = W_all(:, d);
            P_pred = P_all(:, :, d) + Q;
            
            % 更新
            K = (P_pred * Phi_k') / (Phi_k * P_pred * Phi_k' + R);
            innovation = Y_train(k, d) - Phi_k * W_pred;
            W_all(:, d) = W_pred + K * innovation;
            P_all(:, :, d) = (eye(state_dim) - K * Phi_k) * P_pred;
        end
    end
    
    W = W_all;
    P = P_all;
end

四、实际应用建议

4.1 参数调优指南

参数	推荐值	调优建议
RBF中心数	10~20	根据数据复杂度调整，过多易过拟合
扩展系数	0.3~0.7	太大导致欠拟合，太小导致过拟合
过程噪声Q	1e-6~1e-4	小值表示权重变化慢，大值表示快速适应
观测噪声R	0.05~0.2	根据数据噪声水平调整

4.2 收敛性诊断

matlab 复制代码

%% 诊断卡尔曼滤波收敛性
function diagnose_kalman_convergence(W_history, P_history)
    % 检查权重是否收敛
    % 检查协方差是否递减
    % 检查创新序列是否白噪声
    
    N = size(W_history, 2);
    state_dim = size(W_history, 1);
    
    figure('Position', [100, 100, 1000, 600]);
    
    % 1. 权重稳定性
    subplot(2, 2, 1);
    plot(1:N, W_history', 'LineWidth', 1);
    xlabel('迭代次数'); ylabel('权重值');
    title('权重收敛过程');
    grid on;
    
    % 2. 协方差迹
    subplot(2, 2, 2);
    trace_history = zeros(N, 1);
    for k = 1:N
        trace_history(k) = trace(P_history(:, :, k));
    end
    semilogy(1:N, trace_history, 'b-', 'LineWidth', 1.5);
    xlabel('迭代次数'); ylabel('协方差迹 (log)');
    title('估计不确定性衰减');
    grid on;
    
    % 3. 创新序列自相关
    subplot(2, 2, 3);
    innovations = diff(W_history(1, :));  % 使用第一个权重的变化
    [acf, lags] = autocorr(innovations, 50);
    stem(lags, acf, 'b.', 'MarkerSize', 10);
    xlabel('滞后'); ylabel('自相关系数');
    title('创新序列自相关');
    grid on;
    
    % 4. 权重变化率
    subplot(2, 2, 4);
    weight_changes = zeros(N-1, 1);
    for k = 2:N
        weight_changes(k-1) = norm(W_history(:, k) - W_history(:, k-1));
    end
    plot(1:N-1, weight_changes, 'r-', 'LineWidth', 1.5);
    xlabel('迭代次数'); ylabel('权重变化范数');
    title('权重变化率');
    grid on;
end

4.3 在线部署建议

初始化：使用离线数据预训练RBF中心
实时更新：每接收一个新样本就更新权重
异常处理：监测创新序列，异常时重置滤波器
内存管理：滑动窗口存储最近N个样本
多模型融合：使用多个卡尔曼滤波器并行

五、总结

卡尔曼滤波训练RBF神经网络具有以下优势：

在线学习能力：逐样本更新，适合实时应用
收敛速度快：相比梯度下降法收敛更快
不确定性量化：提供权重估计的协方差信息
数值稳定性：平方根形式保证数值稳定
自适应能力：可自适应调整噪声参数

该算法特别适用于：

非线性系统辨识
时间序列预测
自适应控制
传感器数据融合
实时信号处理