Unscented Kalman filter无迹卡尔曼滤波

最新推荐文章于 2021-09-11 10:47:09 发布
最新推荐文章于 2021-09-11 10:47:09 发布
阅读量1.3w 收藏 30
点赞数 4
分类专栏： SLAM知识学习 文章标签： python 经验分享 卡尔曼滤波算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hanmoge/article/details/113781216
版权

扩展卡尔曼滤波（EKF）用一阶导数来对非线性模型做局部线性化，而无迹卡尔曼滤波UKF使用所谓“统计线性化”方法，从一个已知的分布中做采样，也就是“生成sigma points”，来“模拟”非线性模型的随机分布。UKF也包含经典的“预测”和“更新”过程，只不过多了一步sigma points的采样。

参考：

我们将通过参考链接中的python代码简介无迹卡尔曼滤波的计算过程。

计算Unscented Transform参数

Unscented Transform是无迹卡尔曼滤波的参数，指的是采样sigma points的已知分布的一些参数：

UT

计算权重weights

weights
这部分的代码为：


#  UKF Parameter 无迹卡尔曼滤波参数设定值：
ALPHA = 0.001
BETA = 2
KAPPA = 0

def setup_ukf(nx):
    lamb = ALPHA ** 2 * (nx + KAPPA) - nx
    # calculate weights
    wm = [lamb / (lamb + nx)]
    wc = [(lamb / (lamb + nx)) + (1 - ALPHA ** 2 + BETA)]
    for i in range(2 * nx):
        wm.append(1.0 / (2 * (nx + lamb)))
        wc.append(1.0 / (2 * (nx + lamb)))
    gamma = math.sqrt(nx + lamb)

    wm = np.array([wm])
    wc = np.array([wc])

    return wm, wc, gamma

生成sigma points

sigma
这部分代码为：

def generate_sigma_points(xEst, PEst, gamma):
    '''
    sigma点的生成：
    X_0 = 均值
    X_i = 均值 + (sqrt((nx+lamb)协方差))_i, for i=1,2,...,n
    X_i = 均值 - (sqrt((nx+lamb)协方差))_i-n, for i=n+1,n+2,...,2n
    
    返回的sigma矩阵形式举例：
    [[ 0.     0.002  0.     0.     0.    -0.002  0.     0.     0.   ]
     [ 0.     0.     0.002  0.     0.     0.    -0.002  0.     0.   ]
     [ 0.     0.     0.     0.002  0.     0.     0.    -0.002  0.   ]
     [ 0.     0.     0.     0.     0.002  0.     0.     0.    -0.002]]
    '''
    # X_0是均值
    sigma = xEst
    # 协方差矩阵的开平方：
    Psqrt = scipy.linalg.sqrtm(PEst)
    n = len(xEst[:, 0])
    # Positive direction
    for i in range(n):
        sigma = np.hstack((sigma, xEst + gamma * Psqrt[:, i:i + 1]))
    # Negative direction
    for i in range(n):
        sigma = np.hstack((sigma, xEst - gamma * Psqrt[:, i:i + 1]))
    return sigma

UKF过程

预测：

pre
更新：

up
这一过程的代码在：

def ukf_estimation(xEst, PEst, z, u, wm, wc, gamma):
    '''
    z: 带噪声的观测
    u: 带噪声的输入
    wm, wc, gamma: 无迹变换参数
    '''
    #  Predict 预测
    # 生成sigma采样点：
    sigma = generate_sigma_points(xEst, PEst, gamma)
    # 运动模型预测：
    sigma = predict_sigma_motion(sigma, u)
    # 将采样点与权重相乘求对均值的估计：
    xPred = (wm @ sigma.T).T
    # 求协方差的估计：
    PPred = calc_sigma_covariance(xPred, sigma, wc, Q)

    #  Update 更新
    zPred = observation_model(xPred)
    # 求残差：
    y = z - zPred
    # 对上一步计算过的均值的估计再次生成sigma采样点：
    sigma = generate_sigma_points(xPred, PPred, gamma)
    zb = (wm @ sigma.T).T
    z_sigma = predict_sigma_observation(sigma)
    st = calc_sigma_covariance(zb, z_sigma, wc, R)
    Pxz = calc_pxz(sigma, xPred, z_sigma, zb, wc)
    K = Pxz @ np.linalg.inv(st)
    xEst = xPred + K @ y
    PEst = PPred - K @ st @ K.T

    return xEst, PEst

但需要注意的是，以上代码的“更新”部分与上面的6-14式不能完全一一对应，但因为在这个python实例中， h ( ) h() h()观测模型是简单的x、y位置输出，所以实际上和6-14式的计算是一样的。

为便于理解，我把这部分代码做了调整：

def ukf_estimation(xEst, PEst, z, u, wm, wc, gamma):
    '''
    z: 带噪声的观测
    u: 带噪声的输入
    wm, wc, gamma: 无迹变换参数
    '''
    #  Predict 预测
    # 生成sigma采样点： 2:
    sigma = generate_sigma_points(xEst, PEst, gamma)
    # 运动模型预测： 3:
    sigma = predict_sigma_motion(sigma, u)
    # 将采样点与权重相乘求对均值的估计： 4:
    xPred = (wm @ sigma.T).T
    # 求协方差的估计： 5: 
    PPred = calc_sigma_covariance(xPred, sigma, wc, Q)

    #  Update 更新
    # 对上一步计算过的均值的估计再次生成sigma采样点： 6:
    sigma = generate_sigma_points(xPred, PPred, gamma)
    # 用生成的sigma采样点做观测预测： 7:
    z_sigma = predict_sigma_observation(sigma)
    # 求均值：  8:
    zPred = (wm @ z_sigma.T).T
    # 求卡尔曼增益计算中的S：   9:
    st = calc_sigma_covariance(zPred, z_sigma, wc, R)
    # 求xz间协方差：   10: 
    Pxz = calc_pxz(sigma, xPred, z_sigma, zPred, wc)
    # 计算卡尔曼增益：  11:
    K = Pxz @ np.linalg.inv(st)
    y = z - zPred
    # 更新均值：  12: 
    xEst = xPred + K @ y
    # 更新协方差：  13: 
    PEst = PPred - K @ st @ K.T

    return xEst, PEst

最后附上带有注释的、调整后的完整python代码：

"""

Unscented kalman filter (UKF) localization sample

author: Atsushi Sakai (@Atsushi_twi)

modification: Junchuan Zhang

"""

import math

import matplotlib.pyplot as plt
import numpy as np
import scipy.linalg

# Covariance for UKF 协方差矩阵
# 运动过程协方差：
Q = np.diag([
    0.1,  # variance of location on x-axis
    0.1,  # variance of location on y-axis
    np.deg2rad(1.0),  # variance of yaw angle
    1.0  # variance of velocity
]) ** 2  # predict state covariance
# 观测协方差
R = np.diag([1.0, 1.0]) ** 2  # Observation x,y position covariance

#  Simulation parameter 仿真噪声参数
INPUT_NOISE = np.diag([1.0, np.deg2rad(30.0)]) ** 2 # 输入噪声
GPS_NOISE = np.diag([0.5, 0.5]) ** 2 # GPS值噪声

DT = 0.1  # time tick [s]
SIM_TIME = 100  # simulation time [s]

#  UKF Parameter 无迹卡尔曼滤波参数设定值：
ALPHA = 0.001
BETA = 2
KAPPA = 0

show_animation = True


def calc_input():
    v = 1.0  # [m/s]
    yawRate = 0.1  # [rad/s]
    u = np.array([[v, yawRate]]).T
    return u


def observation(xTrue, xd, u):
    xTrue = motion_model(xTrue, u)

    # add noise to gps x-y
    z = observation_model(xTrue) + GPS_NOISE @ np.random.randn(2, 1)

    # add noise to input
    ud = u + INPUT_NOISE @ np.random.randn(2, 1)

    xd = motion_model(xd, ud)

    return xTrue, z, xd, ud


def motion_model(x, u):
    F = np.array([[1.0, 0, 0, 0],
                  [0, 1.0, 0, 0],
                  [0, 0, 1.0, 0],
                  [0, 0, 0, 0]])

    B = np.array([[DT * math.cos(x[2]), 0],
                  [DT * math.sin(x[2]), 0],
                  [0.0, DT],
                  [1.0, 0.0]])

    x = F @ x + B @ u

    return x


def observation_model(x):
    H = np.array([
        [1, 0, 0, 0],
        [0, 1, 0, 0]
    ])

    z = H @ x

    return z


def generate_sigma_points(xEst, PEst, gamma):
    '''
    sigma点的生成：
    X_0 = 均值
    X_i = 均值 + (sqrt((nx+lamb)协方差))_i, for i=1,2,...,n
    X_i = 均值 - (sqrt((nx+lamb)协方差))_i-n, for i=n+1,n+2,...,2n
    
    返回的sigma矩阵形式举例：
    [[ 0.     0.002  0.     0.     0.    -0.002  0.     0.     0.   ]
     [ 0.     0.     0.002  0.     0.     0.    -0.002  0.     0.   ]
     [ 0.     0.     0.     0.002  0.     0.     0.    -0.002  0.   ]
     [ 0.     0.     0.     0.     0.002  0.     0.     0.    -0.002]]
    '''
    # X_0是均值
    sigma = xEst
    # 协方差矩阵的开平方：
    Psqrt = scipy.linalg.sqrtm(PEst)
    n = len(xEst[:, 0])
    # Positive direction
    for i in range(n):
        sigma = np.hstack((sigma, xEst + gamma * Psqrt[:, i:i + 1]))
    # Negative direction
    for i in range(n):
        sigma = np.hstack((sigma, xEst - gamma * Psqrt[:, i:i + 1]))
    return sigma


def predict_sigma_motion(sigma, u):
    """
        Sigma Points prediction with motion model
    """
    for i in range(sigma.shape[1]):
        sigma[:, i:i + 1] = motion_model(sigma[:, i:i + 1], u)

    return sigma


def predict_sigma_observation(sigma):
    """
        Sigma Points prediction with observation model
    """
    for i in range(sigma.shape[1]):
        sigma[0:2, i] = observation_model(sigma[:, i])

    sigma = sigma[0:2, :]

    return sigma


def calc_sigma_covariance(x, sigma, wc, Pi):
    nSigma = sigma.shape[1]
    d = sigma - x[0:sigma.shape[0]]
    P = Pi
    for i in range(nSigma):
        P = P + wc[0, i] * d[:, i:i + 1] @ d[:, i:i + 1].T
        
    return P


def calc_pxz(sigma, x, z_sigma, zb, wc):
    nSigma = sigma.shape[1]
    dx = sigma - x
    dz = z_sigma - zb[0:2]
    P = np.zeros((dx.shape[0], dz.shape[0]))

    for i in range(nSigma):
        P = P + wc[0, i] * dx[:, i:i + 1] @ dz[:, i:i + 1].T

    return P


def ukf_estimation(xEst, PEst, z, u, wm, wc, gamma):
    '''
    z: 带噪声的观测
    u: 带噪声的输入
    wm, wc, gamma: 无迹变换参数
    '''
    #  Predict 预测
    # 生成sigma采样点： 2:
    sigma = generate_sigma_points(xEst, PEst, gamma)
    # 运动模型预测： 3:
    sigma = predict_sigma_motion(sigma, u)
    # 将采样点与权重相乘求对均值的估计： 4:
    xPred = (wm @ sigma.T).T
    # 求协方差的估计： 5: 
    PPred = calc_sigma_covariance(xPred, sigma, wc, Q)

    #  Update 更新
    # 对上一步计算过的均值的估计再次生成sigma采样点： 6:
    sigma = generate_sigma_points(xPred, PPred, gamma)
    # 用生成的sigma采样点做观测预测： 7:
    z_sigma = predict_sigma_observation(sigma)
    # 求均值：  8:
    zPred = (wm @ z_sigma.T).T
    # 求卡尔曼增益计算中的S：   9:
    st = calc_sigma_covariance(zPred, z_sigma, wc, R)
    # 求xz间协方差：   10: 
    Pxz = calc_pxz(sigma, xPred, z_sigma, zPred, wc)
    # 计算卡尔曼增益：  11:
    K = Pxz @ np.linalg.inv(st)
    y = z - zPred
    # 更新均值：  12: 
    xEst = xPred + K @ y
    # 更新协方差：  13: 
    PEst = PPred - K @ st @ K.T

    return xEst, PEst


def plot_covariance_ellipse(xEst, PEst):  # pragma: no cover
    Pxy = PEst[0:2, 0:2]
    eigval, eigvec = np.linalg.eig(Pxy)

    if eigval[0] >= eigval[1]:
        bigind = 0
        smallind = 1
    else:
        bigind = 1
        smallind = 0

    t = np.arange(0, 2 * math.pi + 0.1, 0.1)
    a = math.sqrt(eigval[bigind])
    b = math.sqrt(eigval[smallind])
    x = [a * math.cos(it) for it in t]
    y = [b * math.sin(it) for it in t]
    angle = math.atan2(eigvec[bigind, 1], eigvec[bigind, 0])
    rot = np.array([[math.cos(angle), math.sin(angle)],
                    [-math.sin(angle), math.cos(angle)]])
    fx = rot @ np.array([x, y])
    px = np.array(fx[0, :] + xEst[0, 0]).flatten()
    py = np.array(fx[1, :] + xEst[1, 0]).flatten()
    plt.plot(px, py, "--r")


def setup_ukf(nx):
    lamb = ALPHA ** 2 * (nx + KAPPA) - nx
    # calculate weights
    wm = [lamb / (lamb + nx)]
    wc = [(lamb / (lamb + nx)) + (1 - ALPHA ** 2 + BETA)]
    for i in range(2 * nx):
        wm.append(1.0 / (2 * (nx + lamb)))
        wc.append(1.0 / (2 * (nx + lamb)))
    gamma = math.sqrt(nx + lamb)

    wm = np.array([wm])
    wc = np.array([wc])

    return wm, wc, gamma


def main():
    print(__file__ + " start!!")

    nx = 4  # State Vector [x y yaw v]'
    xEst = np.zeros((nx, 1))
    xTrue = np.zeros((nx, 1))
    PEst = np.eye(nx)
    xDR = np.zeros((nx, 1))  # Dead reckoning
    # 初始化参数：
    wm, wc, gamma = setup_ukf(nx)

    # history
    hxEst = xEst
    hxTrue = xTrue
    hxDR = xTrue
    hz = np.zeros((2, 1))

    time = 0.0

    while SIM_TIME >= time:
        time += DT
        u = calc_input()

        xTrue, z, xDR, ud = observation(xTrue, xDR, u)

        xEst, PEst = ukf_estimation(xEst, PEst, z, ud, wm, wc, gamma)

        # store data history
        hxEst = np.hstack((hxEst, xEst))
        hxDR = np.hstack((hxDR, xDR))
        hxTrue = np.hstack((hxTrue, xTrue))
        hz = np.hstack((hz, z))

        if show_animation:
            plt.cla()
            # for stopping simulation with the esc key.
            plt.gcf().canvas.mpl_connect('key_release_event',
                    lambda event: [exit(0) if event.key == 'escape' else None])
            plt.plot(hz[0, :], hz[1, :], ".g")
            plt.plot(np.array(hxTrue[0, :]).flatten(),
                     np.array(hxTrue[1, :]).flatten(), "-b")
            plt.plot(np.array(hxDR[0, :]).flatten(),
                     np.array(hxDR[1, :]).flatten(), "-k")
            plt.plot(np.array(hxEst[0, :]).flatten(),
                     np.array(hxEst[1, :]).flatten(), "-r")
            plot_covariance_ellipse(xEst, PEst)
            plt.axis("equal")
            plt.grid(True)
            plt.pause(0.001)


if __name__ == '__main__':
    main()
寒墨阁
关注
  • 4
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
Neural Network training using the Unscented Kalman Filter：使用无迹卡尔曼滤波器训练 MLP 神经网络的函数-matlab开发
06-01
与使用扩展卡尔曼滤波器类似，也可以使用无迹卡尔曼滤波器通过参数估计来训练神经网络。 该文件为此提供了一个功能。 它还包含一个示例来展示如何使用此功能。 它需要无迹卡尔曼滤波器，ukf函数，可从以下网址下载： http : //www.mathworks.com/matlabcentral/fileexchange/loadFile.do? objectId=18217&objectType=FILE
Kalman Filter 通俗讲解
分享人工智能学习心得与实践经验，探讨应用场景，见证变革与进步
06-03 5万+
引言 Kalman Filter，很多人刚听到这个名词时，总是会下意识认为这就是个滤波器。我这里想要重点声明的是，Kalman Filter不是滤波，它是一种信息融合的过程。 那么Kalman Filter到底是什么？它在那些方面有着应用，它的基本原理又是什么。如果你参考国内的论坛或者教材上，你一定会发现，大部分都是一些复杂公式与枯燥抽象的说明。这里我们将通过尽量通俗易懂的讲解来给大家解释下什...
手撕自动驾驶算法——无迹卡尔曼滤波（UKF）
xiaohu的博客
08-18 2万+
参考
六.卡尔曼滤波器开发实践之六: 无损卡尔曼滤波器(UKF)进阶-白话讲解篇
okgwf的博客
09-11 3697
未完待续...
无迹卡尔曼滤波（UKF）超详细解释
热门推荐
咸鱼的技术博客
01-21 6万+
前言：本文翻译自[https://blog.csdn.net/qq_41011336/article/details/84401835] 初次翻译，如有错误请多指正。 1.UKF 非线性可以表现在两个方面：量测模型与过程模型 量测：一个雷达，量测对于目标的倾斜长度，取平方根来计算x，y的坐标。 雷达通过发射一束无线电波并通过扫描回波工作。任何物体都会在这束路径上返回一些信息给雷达。通过对于返回雷...
无迹卡尔曼滤波 (Unscented Kalman Filter)
Frankgoogle的博客
04-15 9462
最近读了一篇文献，里面用到了无迹卡尔曼滤波(Unscented Kalman Filter)。这里写一下我对这种方法的理解。卡尔曼滤波的理解部分可以参考我之前的文章。 我的一点点理解 无迹卡尔曼滤波是对卡尔曼滤波的一种改进。这种改进主要是针对非线性的信号。因为在卡尔曼滤波中，预测模型以及测量空间对应的转换矩阵都是都是线性转换。但是在面对非线性信号时，会出现无法拟合的情况。所以就有了无迹卡尔曼滤波。...
扩展、统计线性化和无迹RTS平滑器
calabash_man的博客
05-15 2111
扩展、统计线性化和无迹RTS平滑器扩展RTS平滑器（ERTSS）扩展RTS平滑器统计线性化RTS平滑器无迹RTS平滑器 本文介绍基于线性化、统计线性化和无迹变换的RTS平滑器，分别对应EKF、SLF和ULF。 这些平滑器用于对非线性状态空间模型贝叶斯解的高斯逼近。 扩展RTS平滑器（ERTSS） ERTSS对平滑分布的高斯逼近表达式为：由下式叠加模型：xk=f(xk−1)+qk−1yk=h(xk)+r \bm{x_k = f(x_{k-1})+q_{k-1}} \\ \bm{y_k = h(x_k)+r}
Basics Algorithms|无迹卡尔曼滤波器(Unscented Kalman Filter, UKF)
TURBOTX的博客
05-29 775
Unscented Kalman Filter is an improved version of the Kalman Filter. It utilized an unscented transform to incorporate non-linearity within the model.The parameters optimized here are , and . 1.贝叶斯估计(Bayes Estimation) 许多系统需要由带噪声的传感器度量来估计系统状态，如机器人控制、股票..
unscented kalman filter
weixin_38715812的博客
04-05 1176
UKF 原理及仿真UKF的优势UKF的问题UKF原理UKF 步骤stepstwo problemsHow to choose the sigma points?How to set the weights?其他参数的选择UKF 算法 UKF的优势 EKF是线性卡尔曼滤波，会引入线性化误差 EKF需要计算Jacobian矩阵，不易实现 UKF的问题 低维状态仿真效果超好，实际生产过程中的高维状...
python 无迹卡尔曼（filterpy.kalman.UnscentedKalmanFilter）调参
weixin_46180132的博客
05-20 4173
python 无迹卡尔曼（filterpy.kalman）调参 1. filter.kalman.MerweScaledSigmaPoints，Van der Merwe式sigma点选择，UT变换最好用的sigma点选择算法 input： n ：状态维度 alpha ：均值附近sigma点的分布，通常选0.1~1之间。调节中心点与周围点的权重。 beta ：由先验知识，高斯分布选2。 kappa ：k = 3-n output: Wm ：sigma点均值的权重 Wc ：sigma点协方差的权重 可以看到，
Unscented-Kalman过滤器车辆跟踪：通过使用Unscented卡尔曼过滤器融合嘈杂的激光雷达和雷达测量，在模拟的高速公路交通上对多辆汽车进行状态估计和跟踪
02-15
无味卡尔曼滤波器车辆跟踪 在该项目中，实现了无味卡尔曼滤波器，以使用嘈杂的激光雷达和雷达测量来跟踪和估算高速公路上多辆汽车的状态，如图所示。 main.cpp正在使用highway.h来创建一个直行的3车道高速公路环境，其中有3辆交通汽车和主要的自我汽车在中心。 观看者场景以自我汽车为中心，坐标系也相对于自我汽车。 自我汽车为绿色，而其他交通汽车为蓝色。 交通车辆将加速并改变其转向以改变车道。 每辆运输车都有自己的UKF对象生成，并将在每个时间步更新每个独立的对象。 汽车上方的红色球体表示（x，y）激光雷达检测，紫色线显示雷达测量值以及沿检测角度的速度大小。 跟踪仅沿X / Z轴进行。 跟踪不考虑Z轴。 其他重要依赖 cmake> = 3.5 所有操作系统： make> = 4.1（Linux，Mac），3.81（Windows） Linux：大多数Linux发行版默认都安装
Unscented Kalman Filter Tutorial
02-09
Unscented Kalman Filter Tutorial无迹卡尔曼滤波简介：Gabriel A. Terejanu Department of Computer Science and Engineering, University at Buffalo
卡尔曼滤波.zip经典卡尔曼Kalman filtering和UKF滤波实验代码
04-02
经典卡尔曼Kalman filtering和无痕迹卡尔曼Unscented Kalman Filter实验代码是C#写的，都是一维滤波动态性滤波。
unscented_kalman_filter_驾驶_无迹卡尔曼_卡尔曼滤波_无人驾驶_车辆卡尔曼_
09-29
无人驾驶车辆使用无迹卡尔曼滤波算法进行定位和跟踪
UKF（Unscented Kalman Filter) 无迹卡尔曼滤波程序代码
06-05
本代码实现是对UKF（无迹卡尔曼滤波）的MATLAB实现
Ensemble Kalman filter集合卡尔曼滤波
hanmoge的博客
02-07 2万+
在气象预测领域，很多时候，模型具有巨大的量级，如果使用传统的卡尔曼滤波，协方差矩阵的更新将是一个~10e22量级的计算操作，因此传统的卡尔曼滤波并不适用。集合卡尔曼滤波（Ensemble Kalman filter）用sample covariance模拟原本的协方差矩阵，用一个小的多的量级的矩阵运算代替原本的协方差矩阵更新。集合卡尔曼滤波与粒子滤波有相通之处，本文将通过一个应用EnKF进行定位的python实例来初探集合卡尔曼滤波的概念。
EKF SLAM学习笔记01
hanmoge的博客
02-03 1万+
ekf是扩展卡尔曼滤波的缩写：Extended Kalman Filter 本文将从概率论中的相关概念说起，逐步讲解到贝叶斯滤波、卡尔曼滤波、和扩展卡尔曼滤波。
Python版msckf算法使用测试
hanmoge的博客
01-29 1万+
从KF到EKF到EKF slam都有相应的python程序可以学习演示，没想到到了msckf这一步仍然有人写了python版本，还是双目的：stereo_msckf。 uoip的stereo_msckf直接翻译自Kumar版的msckf，且剥离了ros，所以单独用Pangolin做了显示界面，README中写的是基于python 3.6+，以下是我在ubuntu 16.04，ros kinetic（意味着我系统里有一大堆python 2.7），python 3.5.2环境下的使用测试。
pythonvmd滤波
最新发布
01-21
Python vmd (Variational Mode Decomposition) 是一种常用于信号处理的滤波方法。VMD是一种时间频率分解方法，可以对信号中的不同频率成分进行分解和滤波。它通过将信号分解成不同的模态分量，并根据这些分量的频率和幅度特性进行滤波，从而实现对信号的滤波处理。 Python vmd 利用VMD算法对信号进行时间-频率分解，并提取各个频率成分的模态分量。通过对这些模态分量进行滤波处理，可以去除信号中的噪音和干扰成分，从而得到更加清晰和准确的信号。 Python vmd 滤波具有以下特点： 1. 高效性：VMD算法在时间-频率分解方面具有很高的效率和准确性，可以对信号进行精细的分解和滤波处理。 2. 可定制性：Python vmd 提供了丰富的参数设置和自定义选项，可以根据用户的需求对滤波处理进行调整和优化。 3. 广泛应用：Python vmd 滤波方法可以应用于各种类型的信号处理，例如音频信号、生物医学信号、通信信号等，具有很强的通用性和适用性。 总之，Python vmd 滤波是一种强大而有效的信号处理方法，可以通过VMD算法对信号进行时间-频率分解和滤波处理，从而得到更加清晰和准确的信号。它可以满足不同领域和应用场景对信号处理的要求，是一种值得推荐和应用的滤波技术。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

寒墨阁

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值