O_MMMM_O
O_MMMM_O

卡尔曼滤波理论讲解与应用（matlab和python）

文章目录

        • 理论讲解
          • 使用前提
          • 理论概括
          • 公式推导
            • 1. 用均值和方差描述物体状态
            • 2. 状态转移矩阵 F F F表示系统预测
            • 3. 引入外部控制变量 u k u_k uk​
            • 4. 引入外部干扰 Q k Q_k Qk​
            • 5. 用测量值( z k ⃗ ， R k \vec {z_k}，R_k zk​ ​，Rk​)来修正预测值
            • 6. 融合高斯分布公式
            • 7. 将所有公式整合起来
          • 调整参数
        • 应用CA模型
          • 代码例程（matlab）
          • 代码例程1（python）
          • 代码例程2（python）
        • 应用CV模型
          • matlab代码
          • python代码
        • 参考链接

理论讲解

使用前提

卡尔曼滤波属于线性滤波器，它可以将多元不确定信息进行融合从而得到一种最优的状态估计。卡尔曼滤波在连续变化的线性系统中表现是非常出色的，因为它考虑了系统过程中存在的一些干扰，比如模型预测干扰 Q Q Q和测量过程干扰 R R R，因此，即使系统中伴随着一些干扰，卡尔曼滤波器也可以比较准确的计算出实际的状态，并且可以对系统未来的运动状态做出合理的预测。卡尔曼滤波器的前提条件是系统是线性高斯系统，线性高斯系统需要从两个方面的理解：

  1. 线性：运动方程、观测方程是线性的
  1. 高斯：系统噪声服从零均值的高斯分布

综合来说也就是说高斯分布的噪声在经过状态转移之后仍然保持高斯分布。如果不满足这个线性这个前提条件，就需要使用扩展卡尔曼滤波（extended kalman filter ，EKF）（参见我的另一篇文章：扩展卡尔曼滤波（EKF）理论讲解与实例（matlab、python和C++代码））和无迹（损）卡尔曼滤波（参见我的另一篇文章：无迹（损）卡尔曼滤波（EKF）理论讲解与实例）了（Unscented Kalman Filter ，UKF）来代替了。

理论概括

如下图2.15所示，卡尔曼滤波器的信息源一方面来自传感器检测出的车辆状态信息 z k ^ \hat{z_k} zk​^​，另一方面来自数学模型预测出的车辆状态信息 x k ^ \hat{x_k} xk​^​，但这两方面信息源都只是间接的预测，并且伴随着一些不确定和不准确性，如果使用上所有可用的信息源，那么就能得到一个比单一的任何信息源估计更好的结果 x k ^ ′ \hat{x_k}' xk​^​′。卡尔曼滤波通过两个高斯分布相乘，就可以把多个不确定信息源融合在一起。传感器检测的车辆状态信息 z k ^ \hat{z_k} zk​^​在某种情况下符合一个高斯正太分布，预测模型计算出的车辆状态信息也 x k ^ \hat{x_k} xk​^​符合一个高斯正太分布，而后将这两个独立的高斯分布相乘就会得到一个新的高斯分布 x k ^ ′ \hat{x_k}' xk​^​′。新的高斯分布就是原来两个高斯分布重叠的区域，其均值就代表着最优的状态估计。

卡尔曼滤波理论讲解与应用（matlab和python）_第1张图片

卡尔曼滤波的实质是预测的车辆状态 x k ^ \hat{x_k} xk​^​和测量的车辆状态 z k ^ \hat{z_k} zk​^​两个高斯分布相乘的到新的高斯分布 x k ^ ′ \hat{x_k}' xk​^​′， 该过程最后可以凝练成五个核心公式：

预测公式：

x ^ k = F k x ^ k − 1 + B k u ⃗ k P k = F k P k − 1 F k T + Q k \hat x_k=F_k \hat x_{k-1} + B_k \vec u_k\\ P_k=F_kP_{k-1}F^T_k+Q_k x^k​=Fk​x^k−1​+Bk​u k​Pk​=Fk​Pk−1​FkT​+Qk​
更新公式：

K ′ = P k H k T ( H k P k H k T + R k ) − 1 x ^ k ′ = x ^ k + K ′ ( z k ⃗ − H k x ^ k ) P k ′ = P k − K ′ H k P k K' = P_kH^T_k(H_kP_kH^T_k+R_k)^{-1}\\ \hat x'_k = \hat x_k+K'(\vec {z_k}-H_k\hat x_k)\\ P'_k=P_k-K'H_kP_k K′=Pk​HkT​(Hk​Pk​HkT​+Rk​)−1x^k′​=x^k​+K′(zk​ ​−Hk​x^k​)Pk′​=Pk​−K′Hk​Pk​
其中

x k ^ \hat{x_k} xk​^​为 k k k时刻的状态向量。
F k F_k Fk​为状态转移矩阵，表示将 k − 1 k-1 k−1时刻的状态向量转移至t时刻的状态向量。
B k B_k Bk​是输入控制矩阵，代表着将控制向量 u k ^ \hat{u_k} uk​^​映射到状态向量上，统一控制向量 u k ^ \hat{u_k} uk​^​和状态向量之间 x k ^ \hat{x_k} xk​^​的关系。
u k ^ \hat{u_k} uk​^​代表着控制向量，如加速度，角加速度等。
P k P_k Pk​为状态向量的协方差矩阵，代表着状态向量每个元素之间的关系。
Q k Q_k Qk​表示预测状态的高斯噪声的协方差阵，它用来衡量模型的准确度，模型越准确其值越小。
z k ⃗ \vec {z_k} zk​ ​为传感器测量值的状态向量，也就是传感器的测量结果。
H k H_k Hk​ 为转换矩阵，他将状态向量 x k ^ \hat{x_k} xk​^​映射到测量值所在的向量空间 z k ⃗ \vec {z_k} zk​ ​。
R k R_k Rk​为测量值的高斯噪声的协方差阵，代表着传感器测量的误差。

公式推导

那卡尔曼滤波公式的五个公式是如何推导的呢？

1. 用均值和方差描述物体状态

怎么去描述某一时刻物体的状态呢? 状态 x k ^ \hat{x_k} xk​^​可以包含多个变量，代表任何你想表示的信息， 我们用均值和方差来表示某一时刻的状态，为啥是这两个呢? 均值就是我们定义要知道的一些变量状态，例如位置，速度，体积，温度等等。它表示随机分布的中心，即最可能的状态。方差表示一种偏离均值的程度，他可以告诉我们更多信息，利用其中一个变量值告诉我们其它变量可能的值。例如，位置和速度的关系。我们基于旧的位置来估计新位置。如果速度过高，我们可能已经移动很远了。如果缓慢移动，则距离不会很远。跟踪这种关系是非常重要的，因为它带我们更多的信息：其中一个测量值告诉了我们其它变量可能的值，这就是卡尔曼滤波的目的，尽可能地在包含不确定性的测量数据中提取更多信息！这种相关性用协方差矩阵来表示。矩阵中的每个元素 Σ i j \Sigma_{ij} Σij​ 表示第 i i i个和第 j j j个状态变量之间的相关度。（协方差矩阵是一个对称矩阵，这意味着可以任意交换 i i i 和 j j j）。协方差矩阵通常用“ Σ \Sigma Σ”来表示，其中的元素则表示为“ Σ i j \Sigma_{ij} Σij​ ”。

所以在时刻 k k k 物体的状态为 ：均值 x k ^ \hat{x_k} xk​^​和协方差矩阵 P k P_k Pk​ 。
x k ^ = [ p o s i t i o n v e l o c i t y ] P k = [ Σ p p Σ p v Σ v p Σ v v ] \hat{x_k}=\left[ \begin{matrix} position \\ velocity \\ \end{matrix} \right] \quad\quad\quad P_k=\left[ \begin{matrix} \Sigma_{pp}&\Sigma_{pv} \\ \Sigma_{vp}&\Sigma_{vv} \\ \end{matrix} \right] xk​^​=[positionvelocity​]Pk​=[Σpp​Σvp​​Σpv​Σvv​​]

2. 状态转移矩阵 F F F表示系统预测

接下来，我们需要根据当前状态（ k − 1 k-1 k−1 时刻）来预测下一状态（ k k k 时刻），怎么去预测呢?

卡尔曼滤波理论讲解与应用（matlab和python）_第2张图片
我们可以用矩阵 F k F_k Fk​来表示这个预测过程。这个 F k F_k Fk​就是根据运动学或者动力学等物理公式得到的内在关系或者规律。卡尔曼滤波理论讲解与应用（matlab和python）_第3张图片

它将我们原始估计中的每个点都移动到了一个新的预测位置，如果原始估计是正确的话，这个新的预测位置就是系统下一步会移动到的位置。那我们又如何用矩阵来预测下一个时刻的位置和速度呢？下面用一个基本的运动学公式来表示：矩阵表示
p k = p k − 1 + Δ t v k − 1 v k = v k − 1 p_k=p_{k-1}+\Delta tv_{k-1}\\ v_k=\quad\quad \quad\quad v_{k-1} pk​=pk−1​+Δtvk−1​vk​=vk−1​
或者表示为
x ^ k = [ 1 Δ t 0 1 ] x ^ k − 1 = F k x ^ k − 1 \hat x_k=\left[ \begin{matrix} 1&\Delta t \\ 0&1 \\ \end{matrix} \right] \hat x_{k-1}\\ =F_k \hat x_{k-1} \quad \quad x^k​=[10​Δt1​]x^k−1​=Fk​x^k−1​
卡尔曼滤波理论讲解与应用（matlab和python）_第4张图片
现在，我们有了一个预测矩阵来表示下一时刻的状态，但是，我们仍然不知道怎么更新协方差矩阵。此时，我们需要引入另一个公式，如果我们将分布中的每个点都乘以矩阵 A A A，那么它的协方差矩阵会 Σ \Sigma Σ怎样变化呢？很简单，下面给出公式：
C o v ( x ) = Σ C o v ( A x ) = A Σ A T Cov(x)=\Sigma\\ Cov(Ax)=A\Sigma A^T Cov(x)=ΣCov(Ax)=AΣAT
　　结合上面两个方程得到：
x ^ k = F k x ^ k − 1 P k = F k P k − 1 F k T \hat x_k=F_k \hat x_{k-1}\\ P_k = F_k P_{k-1} F^T_k x^k​=Fk​x^k−1​Pk​=Fk​Pk−1​FkT​

3. 引入外部控制变量 u k u_k uk​

有时候，我们并没有捕捉到一切信息，可能存在外部因素会对系统进行控制，带来一些与系统自身状态没有相关性的改变。以火车的运动状态模型为例，火车司机可能会操纵油门，让火车加速。相同地，在我们机器人这个例子中，导航软件可能会发出一个指令让轮子转向或者停止。如果知道这些额外的信息，我们可以用一个向量 u k ⃗ \vec{u_k} uk​ ​来表示，将它加到我们的预测方程中做修正。
　　假设由于油门的设置或控制命令，我们知道了期望的加速度 a a a根据基本的运动学方程可以得到：
p k = p k − 1 + Δ t v k − 1 + 1 2 a ( Δ t ) 2 v k = v k − 1 + a Δ t p_k = p_{k-1} + \Delta t v_{k-1} + \frac1 2 a (\Delta t)^2\\ v_k = \quad \quad \quad \quad \quad v_{k-1} + a \Delta t\\ pk​=pk−1​+Δtvk−1​+21​a(Δt)2vk​=vk−1​+aΔt
以矩阵的形式表示就是：
x ^ k = F k x ^ k − 1 + [ Δ t 2 2 Δ t ] a = F k x ^ k − 1 + B k u ⃗ k \hat x_k = F_k \hat x_{k-1}+\left[ \begin{matrix} \frac{\Delta t^2} {2}\\ \Delta t \\ \end{matrix} \right] a \\ =F_k \hat x_{k-1} + B_k \vec u_k x^k​=Fk​x^k−1​+[2Δt2​Δt​]a=Fk​x^k−1​+Bk​u k​
B k B_k Bk​称为控制矩阵， u k ⃗ \vec{u_k} uk​ ​称为控制向量（对于没有外部控制的简单系统来说，这部分可以忽略）。让我们再思考一下，如果我们的预测并不是100%准确的，该怎么办呢？

4. 引入外部干扰 Q k Q_k Qk​

如果这些状态量是基于系统自身的属性或者已知的外部控制作用来变化的，则不会出现什么问题。 但是，如果存在未知的干扰呢？例如，假设我们跟踪一个四旋翼飞行器，它可能会受到风的干扰，如果我们跟踪一个轮式机器人，轮子可能会打滑，或者路面上的小坡会让它减速。这样的话我们就不能继续对这些状态进行跟踪，如果没有把这些外部干扰考虑在内，我们的预测就会出现偏差。在每次预测之后，我们可以添加一些新的不确定性来建立这种与“外界”（即我们没有跟踪的干扰）之间的不确定性模型：原始估计中的每个状态变量更新到新的状态后，仍然服从高斯分布。我们可以说 x ^ k − 1 \hat{x}_{k-1} x^k−1​每个状态变量移动到了一个新的服从高斯分布的区域 x ^ k \hat{x}_{k} x^k​，协方差为 Q k Q_k Qk​。换句话说就是，我们将这些没有被跟踪的干扰当作协方差为的噪声 Q k Q_k Qk​来处理。这产生了具有不同协方差（但是具有相同的均值）的新的高斯分布。

我们通过简单地添加 Q k Q_k Qk​得到扩展的协方差，下面给出预测步骤的完整表达式：
x ^ k = F k x ^ k − 1 + B k u ⃗ k P k = F k P k − 1 F k T + Q k \hat x_k=F_k \hat x_{k-1} + B_k \vec u_k\\ P_k=F_kP_{k-1}F^T_k+Q_k x^k​=Fk​x^k−1​+Bk​u k​Pk​=Fk​Pk−1​FkT​+Qk​
由上式可知，新的最优估计 x ^ k \hat x_{k} x^k​是根据上一最优估计 x ^ k − 1 \hat x_{k-1} x^k−1​预测得到的，并加上已知外部控制量 u ⃗ k \vec u_k u k​的修正。而新的不确定性 P k P_k Pk​由上一不确定 P k − 1 P_{k-1} Pk−1​性预测得到，并加上外部环境的干扰 Q k Q_k Qk​。

这里，我们对系统可能的动向有了一个模糊的估计，用均值 x k ^ \hat{x_k} xk​^​和协方差矩阵 P k P_k Pk​来表示。如果再结合传感器的数据会怎样呢？

5. 用测量值( z k ⃗ ， R k \vec {z_k}，R_k zk​ ​，Rk​)来修正预测值

我们可能会有多个传感器来测量系统当前的状态，哪个传感器具体测量的是哪个状态变量并不重要，也许一个是测量位置，一个是测量速度，每个传感器间接地告诉了我们一些状态信息。注意，传感器读取的数据的单位和尺度有可能与我们要跟踪的状态的单位和尺度不一样，我们用矩阵 H k H_k Hk​ 来转换传感器的数据，使它的单位和尺度和我们的状态 x k x_k xk​一致

我们可以计算出传感器读数的分布，即均值和误差，用之前的表示方法如下式所示：
u ⃗ e x p e c t e d = H k x ^ k Σ e x p e c t e d = H k P k H k T \vec u_{expected}=H_k \hat x_k\\ \Sigma_{expected}=H_k P_k H^T_k u expected​=Hk​x^k​Σexpected​=Hk​Pk​HkT​
卡尔曼滤波的一大优点就是能处理传感器噪声，换句话说，我们的传感器或多或少都有点不可靠，并且原始估计中的每个状态可以和一定范围内的传感器读数对应起来。从测量到的传感器数据中，我们大致能猜到系统当前处于什么状态。但是由于存在不确定性，某些状态可能比我们得到的读数更接近真实状态。我们将这种不确定性（例如：传感器噪声）用协方差 R K R_K RK​表示，该分布的均值就是我们读取到的传感器数据，称之为 z k ⃗ \vec{z_k} zk​ ​。
现在我们有了两个高斯分布，一个是在预测值附近，一个是在传感器读数附近。

卡尔曼滤波理论讲解与应用（matlab和python）_第5张图片

我们必须在预测值（粉红色）和传感器测量值（绿色）之间找到最优解。那么，我们最有可能的状态是什么呢？如果我们想知道这两种情况都可能发生的概率，将这两个高斯分布相乘就可以了。

6. 融合高斯分布公式

先以一维高斯分布来分析，具有方差 σ 2 \sigma^2 σ2 和 u u u 的高斯曲线可以用下式表示：

这里写图片描述

如果把两个服从高斯分布的函数相乘会得到什么呢？

这里写图片描述

将式（9）代入到式（10）中（注意重新归一化，使总概率为1）可以得到：

这里写图片描述

将式（11）中的两个式子相同的部分用 K K K 表示：

这里写图片描述

下面进一步将式（12）和（13）写成矩阵的形式，如果 Σ \Sigma Σ 表示高斯分布的协方差， u ⃗ \vec u u 表示每个维度的均值，则：

这里写图片描述

矩阵 K K K 称为卡尔曼增益，下面将会用到。

7. 将所有公式整合起来

我们有两个高斯分布，预测部分 ( u 0 , Σ 0 ) = ( H k x k ^ , H k P k H k T ) (u_0,\Sigma_0)=(H_k\hat{x_k},H_kP_kH^T_k) (u0​,Σ0​)=(Hk​xk​^​,Hk​Pk​HkT​) ，和测量部分 ( u 1 , Σ 1 ) = ( z k ⃗ , R k ) (u_1,\Sigma_1)=(\vec{z_k},R_k) (u1​,Σ1​)=(zk​ ​,Rk​)，将它们放到式（15）中算出它们之间的重叠部分：

这里写图片描述

由式（14）可得卡尔曼增益为：

这里写图片描述

将式（16）和式（17）的两边同时左乘矩阵的逆（注意 K K K里面包含了 H k H_k Hk​ ）将其约掉，再将式（16）的第二个等式两边同时右乘矩阵 H k T H^T_k HkT​ 的逆得到以下等式：

这里写图片描述

上式给出了完整的更新步骤方程。 x k ^ ′ \hat{x_k}' xk​^​′ 就是新的最优估计，我们可以将它和放 P k ′ P^{'}_k Pk′​到下一个预测和更新方程中不断迭代。

卡尔曼滤波理论讲解与应用（matlab和python）_第6张图片

卡哇伊~~~

卡尔曼滤波理论讲解与应用（matlab和python）_第7张图片

调整参数

卡尔曼滤波的核心代码虽然就短短的几行，但参数的确定却不是那么容易 。在很多工业控制领域，比如飞船的控制、卫星的控制等都有专门的负责调参的工程师甚至是一个团队，可见卡尔曼滤波参数整定的重要程度。从某种意义上说，调参更像是一门艺术。针对于同一套工程模型，这些参数理论上应该可以统一，但是不同环境下系统的过程噪声以及测量噪声有可能不同，因此还是需要实际测试，以便于找到参数的最优值。可以参考这篇文章参数调整

其中大部分参数需要根据实际应用情况做调整，例如 Q k Q_k Qk​值、 R k R_k Rk​值和 P k P_k Pk​的值，下面逐一进行介绍。 Q k Q_k Qk​值为过程噪声，用来衡量预测模型计算的误差大小，如果其值越小系统对预测模型的信任度也就越高，系统也越发容易收敛，说明模型设计的较为合理。 具体的，如果 Q k Q_k Qk​设置为零，说明系统非常相信预测模型不相信测量值，随着 Q k Q_k Qk​值越来越大，系统对预测模型的信任度就越来越低，对测量值的信任度就越来越高，更甚者，如果 Q k Q_k Qk​值无穷大，那么系统只信任测量值不相信预测值。 R k R_k Rk​值为测量噪声，代表着传感器测量误差，其值用来衡量测量误差的大小。 如果 R k R_k Rk​太大，整个系统的响应时间就会变的比较慢，原因是系统对新的传感器测量的值不是那么相信，从而导致新来的值对整个系统影响不大。如果越小系统收敛越快，但如果 R k R_k Rk​越小，系统反应就越快，收敛速度也会越快，更甚者，如果 R k R_k Rk​过小就有可能导致系统出现震荡。 R k R_k Rk​的确定一般有如下两种方法，其一通过对传感器进行大量测试，记录出每个数据的输出，那么这些大量输出数据近似符合正态分布，根据 3 σ 3σ 3σ原则，取该正态分布的 ( 3 σ ) 2 (3σ)^2 (3σ)2作为 R R R的初始化值。其二可以查看说明书，传感器出厂时，厂家一般都会给出传感器测量误差值。最后一个关键参数是 P k P_k Pk​，它是状态向量 x ^ k \hat x_k x^k​之间元素误差的协方差初始值，表示卡尔曼滤波系统对当前预测状态向量的置信度，其值越小说明系统就越相信当前预测状态。 P k P_k Pk​的大小决定了初始收敛速度。 P k P_k Pk​值的大小只是影响系统的初始收敛速度，在调试的时候，一般设一个较小的 P k P_k Pk​值，这样可以得到一个比较快的收敛速度，随着卡尔曼滤波的迭代， P k P_k Pk​的值会随着系统的迭代不断的改变，当系统进入到一个稳态的状态之后， P k P_k Pk​的值也会收敛成一个最小的协方差矩阵。对于 Q k Q_k Qk​值和 R k R_k Rk​值，可以先将 Q k Q_k Qk​值从小往大调整，将 R k R_k Rk​从大往小调整，这样系统可以较快的得到收敛，然后根据系统的收敛速度，固定一个值再去调整另外一个值。

应用CA模型

卡尔曼滤波理论讲解与应用（matlab和python）_第8张图片
卡尔曼滤波理论讲解与应用（matlab和python）_第9张图片
卡尔曼滤波理论讲解与应用（matlab和python）_第10张图片
卡尔曼滤波理论讲解与应用（matlab和python）_第11张图片

​ matlab和python例程1的转换矩阵只考虑了位置这个量测值（python例程2考虑了速度的量测值）。 参数设置 p _ v a r p\_var p_var的值为0.1 ， q _ v a r q\_var q_var的值为0.01 ， σ γ \sigma_{\gamma} σγ​的值为0.1

代码例程（matlab）
clear;
clc;
close all;

%% 构建数据集
dt=0.1;
t=[0:dt:10];
N=length(t);
v_0=10;
a_0=2;
theta=pi/3;
px=v_0*cos(theta)*t+0.5*a_0*t.^2;
py=v_0*sin(theta)*t+0.5*a_0*t.^2;
%% 添加噪声
noise=1.5*randn(1,length(px));%均值为0 方差为2.25的正态分布
noise_px=px+noise; 
noise=1.5*randn(1,length(py));%均值为0 方差为2.25的正态分布
noise_py=py+noise; 

dataset=[px;py];
noise_dateset=[noise_px;noise_py];

% plot(dataset(1,:),dataset(2,:));
% hold on ;
% plot(noise_dateset(1,:),noise_dateset(2,:));
% legend('origin','noise')% ,' estimate'

%% 设置卡尔曼滤波矩阵的参数
%CA模型
X=[noise_dateset(1,1);noise_dateset(2,1);0;0;0;0]; %初始状态 X=[位置px;位置py]
p_var=0.1;
P=diag(ones(1,6))*p_var; %状态协方差矩阵
rank=length(P);%矩阵的秩
F=[   1 0 dt 0 dt^2/2 0;
      0 1 0 dt 0 dt^2/2;
      0 0 1 0 dt 0;
      0 0 0 1 0 dt;
      0 0 0 0 1 0;
      0 0 0 0 0 1 ]; %状态转移矩阵 
  
H=[1 0 0 0 0 0;
   0 1 0 0 0 0];%传感器提供的观测矩阵

r_var=0.1;
R=diag(ones(1,2))*r_var;%传感器的观测噪声协方差矩阵

q_var=0.01;
Q=diag(ones(1,6))*q_var; %状态转移协方差矩阵

%% 卡尔曼滤波
for i = 2:N 
  X_ = F*X(:,i-1); %基于上一状态预测当前状态  X_为t时刻状态预测(这里没有控制)
  P_ = F*P(:,rank*(i-1)-5:rank*(i-1))*F'+Q;%更新协方差  Q系统过程的协方差
  %% 计算卡尔曼增益
  K = P_*H'/(H*P_*H'+R);
  %% 更新
  X(:,i) = X_+K*(noise_dateset(:,i)-H*X_);% 得到当前状态的最优化估算值  增益乘以残差
  P(:,rank*i-5:rank*i) = (eye(rank)-K*H)*P_;%更新K状态的协方差 
end

%% 绘图
figure;
plot(dataset(1,:),dataset(2,:),'r-','LineWidth',1)
hold on;
plot(X(1,:),X(2,:),'g-','LineWidth',1.5); 
hold on;
plot(noise_dateset(1,:),noise_dateset(2,:),'b-','LineWidth',1)
xlabel('时间/s'),ylabel('运动距离 m')
legend('measure','kalman','noise measure')
title('CV模型卡尔曼滤波')
grid on %显示网格

卡尔曼滤波理论讲解与应用（matlab和python）_第12张图片

代码例程1（python）
#!/usr/bin/python
# -*- coding: utf-8 -*-
'''
this file can single run main function
'''
from numpy.linalg import inv
from numpy import identity
from numpy import matrix, diag, random
import numpy as np
import matplotlib.pyplot as plt
import random

class CVKalmanFilter:
    """
    Simple Kalman filter
    Control term has been omitted for now
    """
    def __init__(self, X, P, F, Q, Z, H, R):
        """
        Initialise the filter
        Args:
            X: State estimate
            P: Estimate covaConfigureriance
            F: State transition model
            Q: Process noise covariance
            Z: Measurement of the state X
            H: Observation model
            R: Observation noise covariance
        """
        self.X = X
        self.P = P
        self.F = F
        self.Q = Q
        self.Z = Z
        self.H = H
        self.R = R


    def predict(self, X, P, w=0):
        """
        Predict the future state
        Args:
            X: State estimate
            P: Estimate covariance
            w: Process noise
        Returns:
            updated (X, P)
        """
        # Project the state ahead
        X = np.dot(self.F ,X) + w
        P = np.dot(np.dot(self.F , P) , self.F.T) + self.Q

        return(X, P)

    def update(self, X, P, Z):
        """
        Update the Kalman Filter from a measurement
        Args:
            X: State estimate
            P: Estimate covariance
            Z: State measurement
        Returns:
            updated (X, P)
        """
        S = np.dot(np.dot(self.H, P), self.H.T) + self.R
        K = np.dot(np.dot(P, self.H.T), np.linalg.inv(S))
        
        y = Z - np.dot(self.H, X)
        X = X + np.dot(K, y)
        P = np.dot((identity(P.shape[1]) - np.dot(K, self.H)), P)
        return (X, P)


# Testing
if __name__ == "__main__":

    # data set
    # own set,The format is  dataset=[time px py];
    dataset=[]
    # Time step size
    dt = 0.1
    # constuct dataset
    t=np.arange(0, 10, dt)
    v_0=10
    a_0=2
    theta=np.pi/3
    px=v_0*np.cos(theta)*t+0.5*a_0*t*t
    py=v_0*np.sin(theta)*t+0.5*a_0*t*t
  

    # add gauss noise
    mu = 0
    sigma = 1.5
    noise_px=np.zeros(np.array(px).shape)
    noise_py=np.zeros(np.array(py).shape)
    for i in range(len(px)):
        noise_px[i] = px[i] + random.gauss(mu,sigma)
        noise_py[i] = py[i] + random.gauss(mu,sigma)
    
    # plt.plot(px,py,noise_px,noise_py)
    # plt.show()

    for i in range(len(t)):
        c=[]
        c.append(t[i])
        c.append(noise_px[i])
        c.append(noise_py[i])
        dataset.append(c)
   
    
    
    # Standard deviation of random accelerations
    sigma_a = 0.2
    # Standard deviation of observations
    sigma_z = 0.2

    # State vector: [[Position_x],[Position_x] [velocity_x]  [velocity_y]
    # [acc_x]  [acc_y]]
    X = np.zeros(6).reshape(6,1)
 
    # State transition model 6*6
    F = np.diag([1.0, 1.0, 1.0, 1.0, 1.0, 1.0])
   
    # Initial state covariance 6*6
    p_var = 0.1
    P = np.diag([1.0, 1.0, 1.0, 1.0, 1.0, 1.0])
    P = P * p_var
   
    # Observation vector
    Z = np.zeros(2).reshape(2,1)
  
    # Observation model
    H = np.array([[ 1.,  0.,  0.,  0.,  0.,  0.],
            [ 0.,  1.,  0.,  0.,  0.,  0.]])
   
    # Observation covariance
    r_var=0.25
    R = np.diag([1.0, 1.0])
    R = R * r_var
   
    # Process noise covariance matrix
    q_var = 0.01
    Q = np.diag([1.0, 1.0, 1.0, 1.0, 1.0, 1.0])
    Q = Q * q_var
 
    # Initialise the filter
    kf = CVKalmanFilter(X, P, F, Q, Z, H, R)


    # initial the first value
    
    pre_time=dataset[0][0]
    X[0,0]=dataset[0][1]
    X[1,0]=dataset[0][2]
    
    # initial result value
    kf_result = []
    kf_result.append(X)

    # Number of measurement_step
    measurement_step = len(dataset)

    for i in range(1, measurement_step):
        
        t_measurement = dataset[i]
        delta_ts = (t_measurement[0] - pre_time)
        pre_time = t_measurement[0]
        # print(delta_ts,kf.F)
        kf.F[0, 2] = delta_ts
        kf.F[0, 4] = 0.5 * delta_ts * delta_ts
        kf.F[1, 3] = delta_ts
        kf.F[1, 5] = 0.5 * delta_ts * delta_ts
        kf.F[2, 4] = delta_ts
        kf.F[3, 5] = delta_ts

        # Predict
        (X, P) = kf.predict(X, P)
        # Update
        m_x = t_measurement[1]
        m_y = t_measurement[2]
        Z = np.array([[m_x], [m_y]])
        (X, P) = kf.update(X, P, Z)
        # save the filter position
        kf_result.append(X)
    
    # plot
    print(len(kf_result),len(t))
    kf_global_x_list = []
    kf_global_y_list = []
    kf_velocity_x_list = []
    kf_velocity_y_list = []
    kf_acc_x_list = []
    kf_acc_y_list = []
    
    for i in range(len(kf_result)):
        # print kf_result[i], kf_result[i][0],kf_result[i][1]   
        kf_global_x_list.append(kf_result[i][0])
        kf_global_y_list.append(kf_result[i][1])
        kf_velocity_x_list.append(kf_result[i][2])
        kf_velocity_y_list.append(kf_result[i][3])
        kf_acc_x_list.append(kf_result[i][4])
        kf_acc_y_list.append(kf_result[i][5])
        
    # 测试
    plt.figure
    plt.plot(px,py, 'r-',  label='measure') 
    plt.plot(noise_px,noise_py, 'b-',  label='noise') 
    plt.plot(kf_global_x_list,kf_global_y_list, 'g-',  label='kf estimate') 
    plt.title("Position") 
    plt.xlabel("time") 
    plt.ylabel("d(m)") 
    plt.legend()
    plt.grid(color="k", linestyle=":")
    plt.show()

卡尔曼滤波理论讲解与应用（matlab和python）_第13张图片

代码例程2（python）

当转换矩阵H为
H = [ [ 1 , 0 , 0 , 0 , 0 , 0 ] , [ 0 , 1 , 0 , 0 , 0 , 0 ] , [ 0 , 0 , 1 , 0 , 0 , 0 ] , [ 0 , 0 , 0 , 1 , 0 , 0 ] ] H=[[ 1, 0, 0, 0, 0, 0],\\ \quad \quad [ 0, 1, 0, 0, 0, 0],\\ \quad \quad [ 0, 0, 1, 0, 0, 0],\\ \quad \quad [ 0, 0, 0, 1, 0, 0]] H=[[1,0,0,0,0,0],[0,1,0,0,0,0],[0,0,1,0,0,0],[0,0,0,1,0,0]]

声明：该代码需要自己完善才能运行。

from numpy.linalg import inv
from numpy import identity
from numpy import matrix, diag, random
import numpy as np

class CVKalmanFilter:
    """
    Simple Kalman filter
    Control term has been omitted for now
    """
    def __init__(self, X, P, F, Q, Z, H, R):
        """
        Initialise the filter
        Args:
            X: State estimate
            P: Estimate covaConfigureriance
            F: State transition model
            Q: Process noise covariance
            Z: Measurement of the state X
            H: Observation model
            R: Observation noise covariance
        """
        self.X = X
        self.P = P
        self.F = F
        self.Q = Q
        self.Z = Z
        self.H = H
        self.R = R


    def predict(self, X, P, w=0):
        """
        Predict the future state
        Args:
            X: State estimate
            P: Estimate covariance
            w: Process noise
        Returns:
            updated (X, P)
        """
        # Project the state ahead
        X = np.dot(self.F ,X) + w
        P = np.dot(np.dot(self.F , P) , self.F.T) + self.Q

        return(X, P)

    def update(self, X, P, Z):
        """
        Update the Kalman Filter from a measurement
        Args:
            X: State estimate
            P: Estimate covariance
            Z: State measurement
        Returns:
            updated (X, P)
        """
        S = np.dot(np.dot(self.H, P), self.H.T) + self.R
        K = np.dot(np.dot(P, self.H.T), np.linalg.inv(S))
        
        y = Z - np.dot(self.H, X)
        X = X + np.dot(K, y)
        P = np.dot((identity(P.shape[1]) - np.dot(K, self.H)), P)
        return (X, P)


# Testing
if __name__ == "__main__":

    # data set 
    # own set,The format is  dataset=[time px py vx vy ax ay];
    dataset=[]
    # Time step size
    # dt = 0.1
    # Standard deviation of random accelerations
    sigma_a = 0.2
    # Standard deviation of observations
    sigma_z = 0.2

    # State vector: [[Position_x],[Position_x] [velocity_x]  [velocity_y]
    # [acc_x]  [acc_y]]
    X = np.zeros(6).reshape(6,1)
  
    # State transition model 6*6
    F = np.diag([1.0, 1.0, 1.0, 1.0, 1.0, 1.0])
    
    # Initial state covariance 6*6
    p_var = 0.1
    P = np.diag([1.0, 1.0, 1.0, 1.0, 1.0, 1.0])
    P = P * p_var
    
    # Observation vector
    Z = np.zeros(4).reshape(4,1)
    
    # Observation model
    H = np.array([[ 1.,  0.,  0.,  0.,  0.,  0.],
                [ 0.,  1.,  0.,  0.,  0.,  0.],
                [ 0.,  0.,  1.,  0.,  0.,  0.],
                [ 0.,  0.,  0.,  1.,  0.,  0.]])
    
    # Observation covariance
    r_var=0.25
    R = np.diag([1.0, 1.0])
    R = R * r_var
    
    # Process noise covariance matrix
    q_var = 0.01
    Q = np.diag([1.0, 1.0, 1.0, 1.0, 1.0, 1.0])
    Q = Q * q_var
    
    # Initialise the filter
    kf = CVKalmanFilter(X, P, F, Q, Z, H, R)
	
    # initial the first value
    pre_time=dataset[0][0]
    X[0,0]=dataset[0][1]
    X[1,0]=dataset[0][2]
    X[2,0]=dataset[0][3]
    X[3,0]=dataset[0][4]
    X[4,0]=dataset[0][5]
    X[5,0]=dataset[0][6]
    
    # initial result value
    kf_result = []
    kf_result.append(X)
    # Number of measurement_step
    measurement_step = len(dataset)
    
    for i in range(1, measurement_step):
       
        t_measurement = dataset[i]
        
        delta_ts = (t_measurement[0] - pre_time) 
        pre_time = t_measurement[0]
        F[0, 2] = delta_ts;
        F[0, 4] = 0.5 * delta_ts * delta_ts;
        F[1, 3] = delta_ts;
        F[1, 5] = 0.5 * delta_ts * delta_ts;
        F[2, 4] = delta_ts;
        F[3, 5] = delta_ts;

        # Predict
        (X, P) = kf.predict(X, P)
        # Update
        m_x = t_measurement[1]
        m_y = t_measurement[2]
        m_Vx = t_measurement[3]
        m_Vy = t_measurement[4]
        Z = np.array([[m_x], [m_y],[m_Vx],[m_Vy]])
        (X, P) = kf.update(X, P, Z)
        kf_result.append(X)
        # Update the actual position

应用CV模型

x k ^ = [ p o s i t i o n v e l o c i t y ] P k = [ Σ p p Σ p v Σ v p Σ v v ] p k = p k − 1 + Δ t v k − 1 v k = v k − 1 x ^ k = [ 1 Δ t 0 1 ] x ^ k − 1 = F k x ^ k − 1 \hat{x_k}=\left[ \begin{matrix} position \\ velocity \\ \end{matrix} \right] \quad\quad\quad P_k=\left[ \begin{matrix} \Sigma_{pp}&\Sigma_{pv} \\ \Sigma_{vp}&\Sigma_{vv} \\ \end{matrix} \right] \\ p_k=p_{k-1}+\Delta tv_{k-1}\\v_k=\quad\quad \quad\quad v_{k-1}\\\hat x_k=\left[ \begin{matrix} 1&\Delta t \\ 0&1 \\ \end{matrix} \right] \hat x_{k-1}\\ =F_k \hat x_{k-1} \quad \quad xk​^​=[positionvelocity​]Pk​=[Σpp​Σvp​​Σpv​Σvv​​]pk​=pk−1​+Δtvk−1​vk​=vk−1​x^k​=[10​Δt1​]x^k−1​=Fk​x^k−1​

matlab代码
Z=(1:2:200); %观测值 
noise=5*randn(1,100); %均值为0 方差为25的正态分布
moise_Z=Z+noise;%模拟的实际观测值

%CV模型
X=[moise_Z(1);0]; %初始状态 X=[位置;速度]
P=[1 0;0 1]; %状态协方差矩阵
rank=length(P);%矩阵的秩
T=1;
F=[1 T;0 1]; %状态转移矩阵 
Q=[0.0001,0;0 , 0.0001]; %状态转移协方差矩阵
H=[1,0];%传感器提供的观测矩阵
R=1;%传感器的观测噪声协方差矩阵

%% 卡尔曼滤波
for i = 2:100 
  X_ = F*X(:,i-1); %基于上一状态预测当前状态  X_为t时刻状态预测(这里没有控制)
  P_ = F*P(:,rank*(i-1)-1:rank*(i-1))*F'+Q;%更新协方差  Q系统过程的协方差
  %% 计算卡尔曼增益
  K = P_*H'/(H*P_*H'+R);
  %% 更新
  X(:,i) = X_+K*(moise_Z(i)-H*X_);% 得到当前状态的最优化估算值  增益乘以残差
  P(:,rank*i-1:rank*i) = (eye(rank)-K*H)*P_;%更新K状态的协方差 
end

%% 绘图
figure;
plot(Z,'r-','LineWidth',1)
hold on;
plot(X(1,:),'g-','LineWidth',1.5); 
hold on;
plot(moise_Z,'b-','LineWidth',1)
xlabel('时间/s'),ylabel('运动距离 m')
legend('measure','kalman','noise measure')
title('CV模型卡尔曼滤波')
grid on %显示网格

卡尔曼滤波理论讲解与应用（matlab和python）_第14张图片

python代码

声明：该代码需要自己完善才能运行。

import numpy as np
import pandas as pd

def kalman_filter(zk, xk, A=np.matrix(1), B=np.matrix(0), Pk=1, 
                    uk=np.array(0), wk=0, Q=0.1, R=1, H=np.matrix(1)):
    """Performs Kalman Filtering on pandas timeseries data.
    :param: zk (pandas timeseries): input data
    :param: xk (np.array): a priori state estimate vector
    :param: A (np.matrix): state transition coefficient matrix
    :param: B (np.matrix): control coefficient matrix
    :param: Pk (np.matrix): prediction covariance matrix
    :param: uk (np.array): control signal vector
    :param: wk (float): process noise (has covariance Q)
    :param: Q (float): process covariance
    :param: R (float): measurement covariance
    :param: H (np.matrix):  transformation matrix
    :return: output (np.array): kalman filtered data
    """
    output = np.zeros(len(zk))
    for k, t in enumerate(zk.index):
        # time update (prediction)
        xk = A*xk + B*uk + wk # Predict state
        zk_pred = H*xk # Predict measurement
        Pk = A*Pk*A.T + Q # Predict error covariance
        # measurement update (correction)
        vk = zk[t] - zk_pred # Measurement residual
        S = (H*Pk*H.T) + R # Prediction covariance
        Kk = (Pk*H.T) / S # Compute Kalman Gain
        xk = xk + (Kk * vk) # Update estimate with gain * residual
        Pk = (1 - Kk*H)*Pk # Update error covariance
        output[k] = xk.item()
    return output

参考链接

  1. 常用的运动模型

你可能感兴趣的:(matlab实例应用,数学,python,matlab,python,卡尔曼滤波算法,算法)

  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • element实现动态路由+面包屑 软件技术NINI vue案例vue.js前端
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
  • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
  • swagger访问路径 igotyback swagger
    Swagger2.x版本访问地址：http://{ip}:{port}/{context-path}/swagger-ui.html{ip}是你的服务器IP地址。{port}是你的应用服务端口，通常为8080。{context-path}是你的应用上下文路径，如果应用部署在根路径下，则为空。Swagger3.x版本对于Swagger3.x版本（也称为OpenAPI3）访问地址：http://{ip
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码 说私域 人工智能小程序
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • python os.environ 江湖偌大 python深度学习
    os.environ['TF_CPP_MIN_LOG_LEVEL']='0'#默认值，输出所有信息os.environ['TF_CPP_MIN_LOG_LEVEL']='1'#屏蔽通知信息（INFO）os.environ['TF_CPP_MIN_LOG_LEVEL']='2'#屏蔽通知信息和警告信息（INFO\WARNING）os.environ['TF_CPP_MIN_LOG_LEVEL']='
  • Python中os.environ基本介绍及使用方法 鹤冲天Pro #Pythonpython服务器开发语言
    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
  • 腾讯云技术深度探索：构建高效云原生微服务架构 我的运维人生 云原生架构腾讯云运维开发技术共享
    腾讯云技术深度探索：构建高效云原生微服务架构在当今快速发展的技术环境中，云原生技术已成为企业数字化转型的关键驱动力。腾讯云作为行业领先的云服务提供商，不断推出创新的产品和技术，助力企业构建高效、可扩展的云原生微服务架构。本文将深入探讨腾讯云在微服务领域的最新进展，并通过一个实际案例展示如何在腾讯云平台上构建云原生应用。腾讯云微服务架构概览腾讯云微服务架构基于云原生理念，旨在帮助企业快速实现应用的容
  • Pyecharts数据可视化大屏：打造沉浸式数据分析体验 我的运维人生 信息可视化数据分析数据挖掘运维开发技术共享
    Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
  • Goolge earth studio 进阶4——路径修改与平滑 陟彼高冈yu Googleearthstudio进阶教程旅游
    如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
  • Python教程：一文了解使用Python处理XPath 旦莫 Python进阶python开发语言
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
  • python os.environ_python os.environ 读取和设置环境变量 weixin_39605414 pythonos.environ
    >>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
  • 基于社交网络算法优化的二维最大熵图像分割 智能算法研学社（Jack旭） 智能优化算法应用图像分割算法php开发语言
    智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
  • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器） 编程经验分享 开发工具服务器sshlinux
    目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
  • 四章-32-点要素的聚合 彩云飘过
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
  • 2020-04-12每天三百字之连接与替代 冷眼看潮
    不知道是不是好为人师，有时候还真想和别人分享一下我对某些现象的看法或者解释。人类社会不断发展进步的过程，就是不断连接与替代的过程。人类发现了火并应用火以后，告别了茹毛饮血的野兽般的原始生活（火烧、烹饪替代了生食）人类用石器代替了完全手工，工具的使用使人类进步一大步。类似这样的替代还有很多，随着科技的发展，有更多的原始的事物被替代，代之以更高效、更先进的技术。在近现代，汽车替代了马车，高速公路和铁路
  • 398顺境，逆境 戴骁勇
    2018.11.27周二雾霾最近儿子进入了一段顺境期，今天表现尤其不错。今天的数学测试成绩喜人，没有出现以往的计算错误，整个卷面书写工整，附加题也在规定时间内完成且做对。为迎接体育测试的锻炼有了质的飞跃。坐位体前屈成绩突飞猛进，估测成绩能达到12cm，这和上次测试的零分来比，简直是逆袭。儿子还在不断锻炼和提升，唯恐到时候掉链子。跑步姿势在我的调教下，逐渐正规起来，速度随之也有了提升。今晚测试的50
  • 【加密社】Solidity 中的事件机制及其应用 加密社 闲侃区块链智能合约区块链
    加密社引言在Solidity合约开发过程中，事件（Events）是一种非常重要的机制。它们不仅能够让开发者记录智能合约的重要状态变更，还能够让外部系统（如前端应用）监听这些状态的变化。本文将详细介绍Solidity中的事件机制以及如何利用不同的手段来触发、监听和获取这些事件。事件存储的地方当我们在Solidity合约中使用emit关键字触发事件时，该事件会被记录在区块链的交易收据中。具体而言，事件
  • 使用Faiss进行高效相似度搜索 llzwxh888 faisspython
    在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
  • python是什么意思中文-在python中%是什么意思 编程大乐趣
    Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
  • 使用Apify加载Twitter消息以进行微调的完整指南 nseejrukjhad twittereasyui前端python
    #使用Apify加载Twitter消息以进行微调的完整指南##引言在自然语言处理领域，微调模型以适应特定任务是提升模型性能的常见方法。本文将介绍如何使用Apify从Twitter导出聊天信息，以便进一步进行微调。##主要内容###使用Apify导出推文首先，我们需要从Twitter导出推文。Apify可以帮助我们做到这一点。通过Apify的强大功能，我们可以批量抓取和导出数据，适用于各类应用场景。
  • 深入理解 MultiQueryRetriever：提升向量数据库检索效果的强大工具 nseejrukjhad 数据库python
    深入理解MultiQueryRetriever：提升向量数据库检索效果的强大工具引言在人工智能和自然语言处理领域，高效准确的信息检索一直是一个关键挑战。传统的基于距离的向量数据库检索方法虽然广泛应用，但仍存在一些局限性。本文将介绍一种创新的解决方案：MultiQueryRetriever，它通过自动生成多个查询视角来增强检索效果，提高结果的相关性和多样性。MultiQueryRetriever的工
  • 利用LangChain的StackExchange组件实现智能问答系统 nseejrukjhad langchainmicrosoft数据库python
    利用LangChain的StackExchange组件实现智能问答系统引言在当今的软件开发世界中，StackOverflow已经成为程序员解决问题的首选平台之一。而LangChain作为一个强大的AI应用开发框架，提供了StackExchange组件，使我们能够轻松地将StackOverflow的海量知识库集成到我们的应用中。本文将详细介绍如何使用LangChain的StackExchange组件
  • 在一台Ubuntu计算机上构建Hyperledger Fabric网络 落叶无声9 区块链超级账本Hyperledgerfabric区块链ubuntu构建hyperledgerfabric
    在一台Ubuntu计算机上构建HyperledgerFabric网络Hyperledgerfabric是一个开源的区块链应用程序平台，为开发基于区块链的应用程序提供了一个起点。当我们提到HyperledgerFabric网络时，我们指的是使用HyperledgerFabric的正在运行的系统。即使只使用最少数量的组件，部署Fabric网络也不是一件容易的事。Fabric社区创建了一个名为Cello
  • Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Pythonpython开发语言大数据数据分析数据挖掘
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
  • python八股文面试题分享及解析(1) Shawn________ python
    #1.'''a=1b=2不用中间变量交换a和b'''#1.a=1b=2a,b=b,aprint(a)print(b)结果：21#2.ll=[]foriinrange(3):ll.append({'num':i})print(11)结果:#[{'num':0},{'num':1},{'num':2}]#3.kk=[]a={'num':0}foriinrange(3):#0,12#可变类型，不仅仅改变
  • 121. 买卖股票的最佳时机 薄荷糖的味道_fb40
    给定一个数组，它的第i个元素是一支给定股票第i天的价格。如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。注意你不能在买入股票前卖出股票。示例1:输入:[7,1,5,3,6,4]输出:5解释:在第2天（股票价格=1）的时候买入，在第5天（股票价格=6）的时候卖出，最大利润=6-1=5。注意利润不能是7-1=6,因为卖出价格需要大于买入价格。示例2:输入:
  • 每日算法&面试题，大厂特训二十八天——第二十天（树） 肥学 ⚡算法题⚡面试题每日精进java算法数据结构
    目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
  • Python快速入门 —— 第三节：类与对象 孤华暗香 Python快速入门python开发语言
    第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
  • JAVA中的Enum 周凡杨 javaenum枚举
    Enum是计算机编程语言中的一种数据类型---枚举类型。 在实际问题中，有些变量的取值被限定在一个有限的范围内。     例如，一个星期内只有七天 我们通常这样实现上面的定义： public String monday; public String tuesday; public String wensday; public String thursday
  • 赶集网mysql开发36条军规 Bill_chen mysql业务架构设计mysql调优mysql性能优化
    (一)核心军规 (1)不在数据库做运算    cpu计算务必移至业务层； (2)控制单表数据量    int型不超过1000w，含char则不超过500w；    合理分表；    限制单库表数量在300以内； (3)控制列数量    字段少而精，字段数建议在20以内
  • Shell test命令 daizj shell字符串test数字文件比较
    Shell test命令 Shell中的 test 命令用于检查某个条件是否成立，它可以进行数值、字符和文件三个方面的测试。 数值测试 参数 说明 -eq 等于则为真 -ne 不等于则为真 -gt 大于则为真 -ge 大于等于则为真 -lt 小于则为真 -le 小于等于则为真 实例演示： num1=100 num2=100if test $[num1]
  • XFire框架实现WebService(二) 周凡杨 javawebservice
       有了XFire框架实现WebService(一)，就可以继续开发WebService的简单应用。 Webservice的服务端(WEB工程)： 两个java bean类： Course.java    package cn.com.bean; public class Course {     private
  • 重绘之画图板 朱辉辉33 画图板
           上次博客讲的五子棋重绘比较简单，因为只要在重写系统重绘方法paint（）时加入棋盘和棋子的绘制。这次我想说说画图板的重绘。        画图板重绘难在需要重绘的类型很多，比如说里面有矩形，园，直线之类的，所以我们要想办法将里面的图形加入一个队列中，这样在重绘时就
  • Java的IO流 西蜀石兰 java
    刚学Java的IO流时，被各种inputStream流弄的很迷糊，看老罗视频时说想象成插在文件上的一根管道，当初听时觉得自己很明白，可到自己用时，有不知道怎么代码了。。。 每当遇到这种问题时，我习惯性的从头开始理逻辑，会问自己一些很简单的问题，把这些简单的问题想明白了，再看代码时才不会迷糊。 IO流作用是什么？ 答：实现对文件的读写，这里的文件是广义的； Java如何实现程序到文件
  • No matching PlatformTransactionManager bean found for qualifier 'add' - neither 林鹤霄
    java.lang.IllegalStateException: No matching PlatformTransactionManager bean found for qualifier 'add' - neither qualifier match nor bean name match!   网上找了好多的资料没能解决，后来发现：项目中使用的是xml配置的方式配置事务，但是
  • Row size too large (> 8126). Changing some columns to TEXT or BLOB aigo column
    原文：http://stackoverflow.com/questions/15585602/change-limit-for-mysql-row-size-too-large   异常信息： Row size too large (> 8126). Changing some columns to TEXT or BLOB or using ROW_FORMAT=DYNAM
  • JS 格式化时间 alxw4616 JavaScript
    /** * 格式化时间 2013/6/13 by 半仙 [email protected] * 需要 pad 函数 * 接收可用的时间值. * 返回替换时间占位符后的字符串 * * 时间占位符:年 Y 月 M 日 D 小时 h 分 m 秒 s 重复次数表示占位数 * 如 YYYY 4占4位 YY 占2位<p></p> * MM DD hh mm
  • 队列中数据的移除问题 百合不是茶 队列移除
         队列的移除一般都是使用的remov();都可以移除的,但是在昨天做线程移除的时候出现了点问题,没有将遍历出来的全部移除,  代码如下;      // package com.Thread0715.com; import java.util.ArrayList; public class Threa
  • Runnable接口使用实例 bijian1013 javathreadRunnablejava多线程
    Runnable接口 a.       该接口只有一个方法：public void run(); b.       实现该接口的类必须覆盖该run方法 c.       实现了Runnable接口的类并不具有任何天
  • oracle里的extend详解 bijian1013 oracle数据库extend
    扩展已知的数组空间，例： DECLARE TYPE CourseList IS TABLE OF VARCHAR2(10); courses CourseList; BEGIN -- 初始化数组元素，大小为3 courses := CourseList('Biol 4412 ', 'Psyc 3112 ', 'Anth 3001 '); --
  • 【httpclient】httpclient发送表单POST请求 bit1129 httpclient
    浏览器Form Post请求 浏览器可以通过提交表单的方式向服务器发起POST请求，这种形式的POST请求不同于一般的POST请求 1. 一般的POST请求，将请求数据放置于请求体中，服务器端以二进制流的方式读取数据，HttpServletRequest.getInputStream()。这种方式的请求可以处理任意数据形式的POST请求，比如请求数据是字符串或者是二进制数据 2. Form
  • 【Hive十三】Hive读写Avro格式的数据 bit1129 hive
     1. 原始数据 hive> select * from word; OK 1 MSN 10 QQ 100 Gtalk 1000 Skype      2. 创建avro格式的数据表   hive> CREATE TABLE avro_table(age INT, name STRING)STORE
  • nginx+lua+redis自动识别封解禁频繁访问IP ronin47
    在站点遇到攻击且无明显攻击特征，造成站点访问慢，nginx不断返回502等错误时，可利用nginx+lua+redis实现在指定的时间段 内，若单IP的请求量达到指定的数量后对该IP进行封禁，nginx返回403禁止访问。利用redis的expire命令设置封禁IP的过期时间达到在 指定的封禁时间后实行自动解封的目的。 一、安装环境： CentOS x64 release 6.4(Fin
  • java-二叉树的遍历-先序、中序、后序（递归和非递归）、层次遍历 bylijinnan java
    import java.util.LinkedList; import java.util.List; import java.util.Stack; public class BinTreeTraverse { //private int[] array={ 1, 2, 3, 4, 5, 6, 7, 8, 9 }; private int[] array={ 10,6,
  • Spring源码学习-XML 配置方式的IoC容器启动过程分析 bylijinnan javaspringIOC
    以FileSystemXmlApplicationContext为例，把Spring IoC容器的初始化流程走一遍： ApplicationContext context = new FileSystemXmlApplicationContext ("C:/Users/ZARA/workspace/HelloSpring/src/Beans.xml&q
  • [科研与项目]民营企业请慎重参与军事科技工程 comsci 企业
         军事科研工程和项目 并非要用最先进，最时髦的技术，而是要做到“万无一失”    而民营科技企业在搞科技创新工程的时候，往往考虑的是技术的先进性，而对先进技术带来的风险考虑得不够，在今天提倡军民融合发展的大环境下，这种“万无一失”和“时髦性”的矛盾会日益凸显。。。。。。所以请大家在参与任何重大的军事和政府项目之前，对
  • spring 定时器-两种方式 cuityang springquartz定时器
    方式一： 间隔一定时间 运行 <bean id="updateSessionIdTask" class="com.yang.iprms.common.UpdateSessionTask" autowire="byName" /> <bean id="updateSessionIdSchedule
  • 简述一下关于BroadView站点的相关设计 damoqiongqiu view
    终于弄上线了，累趴，戳这里http://www.broadview.com.cn   简述一下相关的技术点   前端：jQuery+BootStrap3.2+HandleBars，全站Ajax（貌似对SEO的影响很大啊！怎么破？），用Grunt对全部JS做了压缩处理，对部分JS和CSS做了合并（模块间存在很多依赖，全部合并比较繁琐，待完善）。   后端：U
  • 运维 PHP问题汇总 dcj3sjt126com windows2003
    1、Dede(织梦)发表文章时,内容自动添加关键字显示空白页 解决方法： 后台>系统>系统基本参数>核心设置>关键字替换（是/否），这里选择“是”。 后台>系统>系统基本参数>其他选项>自动提取关键字，这里选择“是”。   2、解决PHP168超级管理员上传图片提示你的空间不足 网站是用PHP168做的，反映使用管理员在后台无法
  • mac 下 安装php扩展 - mcrypt dcj3sjt126com PHP
    MCrypt是一个功能强大的加密算法扩展库，它包括有22种算法，phpMyAdmin依赖这个PHP扩展，具体如下： 下载并解压libmcrypt-2.5.8.tar.gz。 在终端执行如下命令： tar zxvf libmcrypt-2.5.8.tar.gz cd libmcrypt-2.5.8/ ./configure --disable-posix-threads --
  • MongoDB更新文档 [四] eksliang mongodbMongodb更新文档
    MongoDB更新文档 转载请出自出处：http://eksliang.iteye.com/blog/2174104 MongoDB对文档的CURD，前面的博客简单介绍了，但是对文档更新篇幅比较大，所以这里单独拿出来。 语法结构如下： db.collection.update( criteria, objNew, upsert, multi) 参数含义 参数   
  • Linux下的解压，移除，复制，查看tomcat命令 y806839048 tomcat
    重复myeclipse生成webservice有问题删除以前的，干净 1、先切换到：cd usr/local/tomcat5/logs 2、tail -f catalina.out 3、这样运行时就可以实时查看运行日志了 Ctrl+c 是退出tail命令。 有问题不明的先注掉   cp /opt/tomcat-6.0.44/webapps/g
  • Spring之使用事务缘由(3-XML实现) ihuning spring
      用事务通知声明式地管理事务   事务管理是一种横切关注点。为了在 Spring 2.x 中启用声明式事务管理，可以通过 tx Schema 中定义的 <tx:advice> 元素声明事务通知，为此必须事先将这个 Schema 定义添加到 <beans> 根元素中去。声明了事务通知后，就需要将它与切入点关联起来。由于事务通知是在 <aop:
  • GCD使用经验与技巧浅谈 啸笑天 GC
    前言 GCD(Grand Central Dispatch)可以说是Mac、iOS开发中的一大“利器”，本文就总结一些有关使用GCD的经验与技巧。 dispatch_once_t必须是全局或static变量 这一条算是“老生常谈”了，但我认为还是有必要强调一次，毕竟非全局或非static的dispatch_once_t变量在使用时会导致非常不好排查的bug，正确的如下： 1
  • linux（Ubuntu）下常用命令备忘录1 macroli linux工作ubuntu
    在使用下面的命令是可以通过--help来获取更多的信息1,查询当前目录文件列表：ls ls命令默认状态下将按首字母升序列出你当前文件夹下面的所有内容，但这样直接运行所得到的信息也是比较少的，通常它可以结合以下这些参数运行以查询更多的信息：  ls / 显示/.下的所有文件和目录  ls -l 给出文件或者文件夹的详细信息 ls -a 显示所有文件，包括隐藏文
  • nodejs同步操作mysql qiaolevip 学习永无止境每天进步一点点mysqlnodejs
    // db-util.js var mysql = require('mysql'); var pool = mysql.createPool({ connectionLimit : 10, host: 'localhost', user: 'root', password: '', database: 'test', port: 3306 });
  • 一起学Hive系列文章 superlxw1234 hiveHive入门
      [一起学Hive]系列文章 目录贴，入门Hive，持续更新中。   [一起学Hive]之一—Hive概述，Hive是什么 [一起学Hive]之二—Hive函数大全-完整版 [一起学Hive]之三—Hive中的数据库(Database)和表(Table) [一起学Hive]之四-Hive的安装配置 [一起学Hive]之五-Hive的视图和分区 [一起学Hive
  • Spring开发利器：Spring Tool Suite 3.7.0 发布 wiselyman spring
    Spring Tool Suite(简称STS)是基于Eclipse，专门针对Spring开发者提供大量的便捷功能的优秀开发工具。   在3.7.0版本主要做了如下的更新：   将eclipse版本更新至Eclipse Mars 4.5 GA Spring Boot(JavaEE开发的颠覆者集大成者，推荐大家学习)的配置语言YAML编辑器的支持(包含自动提示，
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他