基于自适应迭代无迹卡尔曼滤波算法的锂离子电池SOC估计

自适应迭代无迹卡尔曼滤波算法AIUKF锂离子电池SOC估计递推最小二乘法辩识电池参数具有良好的鲁棒性，初值误差为30%，仍能快速收敛采用马里兰大学18650电池公开数据集FUDS工况在电池管理系统（BMS）中，准确估计锂离子电池的荷电状态（SOC）至关重要。今天咱们就来聊聊基于自适应迭代无迹卡尔曼滤波算法（AIUKF）在锂离子电池SOC估计上的应用，以及递推最小二乘法在辩识电池参数中的作用。

iCjMuKUypQs

209人浏览 · 2026-02-17 18:15:00

iCjMuKUypQs · 2026-02-17 18:15:00 发布

自适应迭代无迹卡尔曼滤波算法AIUKF 锂离子电池SOC估计递推最小二乘法辩识电池参数具有良好的鲁棒性，初值误差为30%，仍能快速收敛采用马里兰大学18650电池公开数据集 FUDS工况

在电池管理系统（BMS）中，准确估计锂离子电池的荷电状态（SOC）至关重要。今天咱们就来聊聊基于自适应迭代无迹卡尔曼滤波算法（AIUKF）在锂离子电池SOC估计上的应用，以及递推最小二乘法在辩识电池参数中的作用。

算法背景

自适应迭代无迹卡尔曼滤波算法（AIUKF）

AIUKF是一种在非线性系统状态估计中表现出色的算法。传统的卡尔曼滤波适用于线性系统，而在处理锂离子电池这种具有高度非线性特性的系统时，无迹卡尔曼滤波（UKF）更具优势。它通过UT变换来近似非线性系统的均值和协方差，而AIUKF在此基础上加入了自适应机制和迭代过程，能更好地跟踪系统状态变化。

递推最小二乘法辩识电池参数

要准确估计SOC，首先得对电池参数有精确了解。递推最小二乘法（RLS）是一种常用的在线参数估计方法。它通过不断更新估计值，在每次获得新的数据时，以最小化误差平方和为目标来调整参数估计，从而快速准确地辨识电池参数。

数据集与工况

此次研究采用了马里兰大学18650电池公开数据集，并且是在FUDS工况下进行分析。FUDS（Federal Urban Driving Schedule）工况模拟了城市驾驶过程中频繁的加速、减速、停车等复杂情况，非常贴近实际应用场景，能更好地验证算法在真实条件下的性能。

代码实现与分析

递推最小二乘法代码示例（Python）

import numpy as np


def rls(y, x, theta_hat, P, lamda=1):
    # y为测量值，x为输入向量，theta_hat为参数估计值，P为协方差矩阵，lamda为遗忘因子
    K = P.dot(x) / (lamda + x.dot(P).dot(x))
    theta_hat = theta_hat + K * (y - x.dot(theta_hat))
    P = (np.eye(len(theta_hat)) - K.dot(x)).dot(P) / lamda
    return theta_hat, P


# 假设初始化参数
theta_hat = np.array([0.1, 0.2])
P = np.eye(2)
# 模拟数据输入
x = np.array([1, 2])
y = 3
theta_hat, P = rls(y, x, theta_hat, P)
print("更新后的参数估计值：", theta_hat)
print("更新后的协方差矩阵：", P)

在这段代码中，rls函数实现了递推最小二乘法。首先计算增益矩阵K，它决定了新数据对参数估计更新的影响程度。然后根据增益矩阵K来更新参数估计值thetahat，通过测量值y与预测值x.dot(thetahat)的误差来修正估计。最后更新协方差矩阵P，反映估计的不确定性。

AIUKF部分代码示例（Python，简化示意）

import numpy as np


def aiukf_predict(x_hat, P, Q, f, h, R, alpha, beta, kappa):
    n = len(x_hat)
    lambda_ = alpha ** 2 * (n + kappa) - n
    Wm = np.zeros(2 * n + 1)
    Wc = np.zeros(2 * n + 1)
    Wm[0] = lambda_ / (n + lambda_)
    Wc[0] = lambda_ / (n + lambda_) + (1 - alpha ** 2 + beta)
    for i in range(1, 2 * n + 1):
        Wm[i] = 1 / (2 * (n + lambda_))
        Wc[i] = 1 / (2 * (n + lambda_))
    sigma_points = np.zeros((2 * n + 1, n))
    sigma_points[0] = x_hat
    for i in range(n):
        sigma_points[i + 1] = x_hat + np.sqrt((n + lambda_) * P)[i]
        sigma_points[n + i + 1] = x_hat - np.sqrt((n + lambda_) * P)[i]
    # 预测步骤
    x_hat_pred = np.zeros(n)
    for i in range(2 * n + 1):
        x_hat_pred = x_hat_pred + Wm[i] * f(sigma_points[i])
    P_pred = np.zeros((n, n))
    for i in range(2 * n + 1):
        y = f(sigma_points[i]) - x_hat_pred
        P_pred = P_pred + Wc[i] * y.reshape(-1, 1).dot(y.reshape(1, -1))
    P_pred = P_pred + Q
    return x_hat_pred, P_pred


def aiukf_update(x_hat_pred, P_pred, z, h, R, alpha, beta, kappa):
    n = len(x_hat_pred)
    lambda_ = alpha ** 2 * (n + kappa) - n
    Wm = np.zeros(2 * n + 1)
    Wc = np.zeros(2 * n + 1)
    Wm[0] = lambda_ / (n + lambda_)
    Wc[0] = lambda_ / (n + lambda_) + (1 - alpha ** 2 + beta)
    for i in range(1, 2 * n + 1):
        Wm[i] = 1 / (2 * (n + lambda_))
        Wc[i] = 1 / (2 * (n + lambda_))
    sigma_points = np.zeros((2 * n + 1, n))
    sigma_points[0] = x_hat_pred
    for i in range(n):
        sigma_points[i + 1] = x_hat_pred + np.sqrt((n + lambda_) * P_pred)[i]
        sigma_points[n + i + 1] = x_hat_pred - np.sqrt((n + lambda_) * P_pred)[i]
    z_pred = np.zeros(len(z))
    for i in range(2 * n + 1):
        z_pred = z_pred + Wm[i] * h(sigma_points[i])
    Pzz = np.zeros((len(z), len(z)))
    Pxz = np.zeros((n, len(z)))
    for i in range(2 * n + 1):
        y = h(sigma_points[i]) - z_pred
        Pzz = Pzz + Wc[i] * y.reshape(-1, 1).dot(y.reshape(1, -1))
        y1 = sigma_points[i] - x_hat_pred
        Pxz = Pxz + Wc[i] * y1.reshape(-1, 1).dot(y.reshape(1, -1))
    Pzz = Pzz + R
    K = Pxz.dot(np.linalg.inv(Pzz))
    x_hat = x_hat_pred + K.dot(z - z_pred)
    P = P_pred - K.dot(Pzz).dot(K.T)
    return x_hat, P


# 假设一些简单的函数f和h
def f(x):
    return x + 0.1


def h(x):
    return x + 0.05


# 初始化参数
x_hat = np.array([0.5])
P = np.array([[0.1]])
Q = np.array([[0.001]])
R = np.array([[0.01]])
alpha = 0.001
beta = 2
kappa = 0
z = np.array([0.6])
x_hat_pred, P_pred = aiukf_predict(x_hat, P, Q, f, h, R, alpha, beta, kappa)
x_hat, P = aiukf_update(x_hat_pred, P_pred, z, h, R, alpha, beta, kappa)
print("更新后的状态估计值：", x_hat)
print("更新后的协方差矩阵：", P)

这段代码简单示意了AIUKF的预测和更新步骤。在预测步骤中，首先计算西格玛点，通过加权计算预测状态均值和协方差。更新步骤则基于测量值进一步修正预测结果，通过计算卡尔曼增益K，利用测量值与预测值的误差来更新状态估计值和协方差矩阵。