Hey, I was testing some of the filters to figure out if I am doing something wrong in my own implementation. Namely, I am interested in the covariance in both filters. From my understanding, this should be equal in a linear problem with a linear measurement.

The example (https://gist.github.com/vhartman/4e25e5521f0940e370e6019dcc6b5ea1) demonstrates that there is a difference between the two, i.e. P is larger in the UKF Is there a different meaning of P in the two filters? (The error in the position tends to zero in the trivial problem)

Thanks!

first, thanks $1M for such an incredible book and set of tools - I had despaired of using Kalman filtering until I discovered them. Second, I am a lapsed C programmer, last active 10 years ago, and have been recently learning Python so as to use this library. Sorry if my inexperience is the cause of my issue.

I am trying to implement the following KF: dim x = 3 (pos, vel, acc), dim z = 2 (pos, acc) - (PS- tried to attach file but it failed):

x dim 3- spot, vel and acc,

z dim = 2, spot and acc

f = KalmanFilter (dim_x=3, dim_z=2) f.x = np.array([[1.58], # init position [0.01], # init velocity [0.0]]) # init acceleration f.F = np.array([[1.,1., 0.5], # 1, delta T, delta T^2/2 timestep = 1 [0.,1., 1.], # 0, 1, delta T [0.,0., 1.]]) # 0, 0, 1 f.H = np.array([[1.,0., 0.], # dim_z by dim_x, i.e. 2 x 3 [0.,0., 1.]]) # measure position, and acc, but not vel f.P = np.array([[1.,0., 0.], # covariance dim_x dim_x, i.e. 3 x 3 [0.,1., 0.], [0.,0., 1.]]) f.R = np.array([[1.,0.], # measurement noise dim_z dim_z, i.e 2 x 2 [0.,1.]])
f.B = 0 # no control inputs f.Q = Q_discrete_white_noise(dim=3, dt=1, var=0.5)

my measurements are stored in a .csv file as follows: pos1, acc1, pos 2, acc2, etc

it actually runs for one cycle, then gives a dimensional error. the first estimate is quite incorrect Thanks for any guidance

I am on a Mac version 10.11.6 . This is the output of running your conda command:

[email protected]~/anaconda/envs $ conda install -c rabbi filterpy
Fetching package metadata: ......
Solving package specifications: .
Error:  Package missing in current osx-64 channels: 
  - filterpy

You can search for this package on anaconda.org with

    anaconda search -t condo filterpy

It looks like something is wrong with the code below. self.n should not be incremented 'cos for relatively large amount of data (more than several thousand elements) there is a tendency for increasing divergence between source data and filter's output.

     def update(self, z):
         """ Update filter with new measurement `z` """
 
         self.n += 1

For example:

import numpy as np
from filterpy.kalman import MerweScaledSigmaPoints as SigmaPoints

sigma_points = SigmaPoints(n=9, alpha=0.001, beta=2, kappa=-6)
Wm, Wc = sigma_points.weights()
print np.sum(Wm)
print np.sum(Wc)

Which returns

1.0000000005238689
3.9999990007490851

While Wm is small enough to be rounding error, Wc seems to go against notes in the documentation. Now, I'm not saying MerweScaledSigmaPoints is set wrong -- as far as I can tell all the equations are right. However, the book and documentation both say that Wc "must sum to 1".

So what's the deal?

Hi,

I am using the UKF to estimate a series of shocks in some time series data using a nonlinear model with a large state space. To become familiar with the tool, I was playing around with a small linear state model with an exogenous AR(1) shock where the state of the AR(1) process is unknown to the observer. For testing I set the observation cov to near-zero. While both filters and the KF-smother gave correct estimates of both the system state and the hidden AR(1) state, the UKF-smoother is only relatively close.

Is this a bug or did I do something wrong?

I uploaded a stylized testing file here: https://github.com/gboehl/zlb_fg_qe/blob/master/test_ukf.py

Thanks for the great work!

I'm really loving your book and library 👍

I just wanted to comment that I'm having some trouble making the jump from the examples given in the book to applying tools from the filterpy library. Specifically, I've been reading the chapter on adaptive filtering and tracking, and I'm finding that it's not always easy for me to follow what's going on in the examples. There is a lot of copy/pasted code and functions that are either redefined a lot or not used from one cell to the next... then, suddenly they're used again.

Don't get me wrong, I'm learning a lot from this chapter! But I tried lifting in my own data by adapting the generate_data function to spit out data formatted in the exact same way as the sample data, and it just didn't work out very well. The initialize_filter function makes the assumption that the first data point is going to be 0, which wasn't the case for my data, and my data was a time series, which is technically two dimensional, but it didn't fit well with the way that the filters are being applied.

I think the main thing is that at the moment is that the book is the best documentation for some of the more adaptive filtering tools in the filterpy library, and it'd be nice to have some more generic working examples for how to use the IMM and MMAE tools.

Thanks a lot for doing this... It's really helpful!

Hi, I have created a dictionary of Kalman Filters. I'm having an issue in the update function. AssertionError: shape of z should be (), but it is (1,) I have a 1D Kalman Filter, here it is the declaration.

K = KalmanFilter (dim_x=1, dim_z=1)
#State space model used
K.F= np.array([1.])
 #Initial State
K.x=np.array([-60.])                          
#Measurement Matrix                         
K.H=np.array([1.])
#Covariance Matrix
K.P=np.array([10.])
#Process Noise          
K.Q=np.array([20.])                              
#Measurement Noise
K.R=np.array([0.002])
#Add KF to the dictionary when a new UUID is detected
KF_dict.update({data:K})

Hope you can help me, thanks.

Hi,

I'd like to use filterpy's UKF for sensor fusion. However I have two different measurement sources with different sizes, how can I setup the filter to make this work?

Thanks, Carlos

git clone https://github.com/rlabbe/filterpy.git cd filterpy sudo python setup.py install (same with python3)

Traceback (most recent call last): File "setup.py", line 4, in import filterpy ImportError: No module named filterpy

Currently it looks like test_matrix_dimensions only checks x, P, and Q. The docs indicate it checks the size of everything, which is misleading since it doesn't check F, H, R, or a sample input. I would prefer it to check all of those in such a way that the state of the filter is not altered. Running down mismatched sizes is one of my least favorite things to debug and it could be streamlined.

Said slightly differently, in order to fully check the size of inputs, you need to run it, but in order to run it you need to have (mostly) correct inputs, which results in some awkward circular logic.

I think the signature could be test_matrix_dimensions(sample_input=None), where if sample_input is supplied it is additionally checked. That would not change the previous api.

Thank you

Does anyone have an example of using a gyroscope (or other rotation sensor) to drive the estimation of a quaternion in the state? I understand that a quaternion has issues with the covariance due to the overparameterization of 3 dimensions in 4 values. Also that we cannot simply add quaternions for averaging.

Any example of a quaternion with filterpy (UKF) would be great. Thanks.

Hi! It seems the last release of Filterpy was 4 years ago. There are many changes after that including bug fixes. Is there any plan to release them?

Hi,

It seems that there is an bug in the Cubature Kalman Filter : the constructor's argument residual_x is not used, and must be used here :

https://github.com/rlabbe/filterpy/blob/3b51149ebcff0401ff1e10bf08ffca7b6bbc4a33/filterpy/kalman/CubatureKalmanFilter.py#L378

Two minor changes to UnscentedKalmanFilter:

1. Allow passing Q to predict step, for consistency with R in update step. It's also pretty much required if you have uneven dt.
2. Fix a bug in the RTS smoother where passed-in Qs were not used at all.

Thanks for the useful repository.

It seems there is an error in the RTS smoother equations which causes errors for systems with varying state transition matrices (i.e. EKF).

Replacing it with the formulation using a-priori state and covariance estimates produces the correct solution. I.e., minimal example:

def rts_smoother(x_s, P_s, x_prs, P_prs, F_s):                                                                                                                                                                                                                                                                                                     
    x_rts = [None]*n                                                                                                                                                                                                         
    P_rts = [None]*n                                                                                                                                                                                                         
    x_rts[-1] = x_s[-1]                                                                                                                                                                                                       
    P_rts[-1] = P_s[-1]                                                                                                                                                                                                       
    for k in range(n-2, -1, -1):                                                                                                                                                                                                                                                                                                                                                                                                                         
        C = P_s[k]@(F_s[k+1].T)@np.linalg.inv(P_prs[k+1])                                                                                                                                                                      
        x_rts[k] = x_s[k] + C@(x_rts[k+1] - x_prs[k+1])                                                                                                                                                                       
        P_rts[k] = P_s[k] + C@(P_rts[k+1] - P_prs[k+1])@(C.T)                                                                                                                                                                                                                                                                                                                                                                                                return x_rts, P_rts    

where for an EKF the state transition $F_k( \hat{x}_{k/k-1})$ is calculated for timestep $k$ using the a-priori state estimate of that timestep. This produces the expected RTS smoothing result for me.

Source: Wikipedia