pykalman | Kalman Filter , Smoother , and EM Algorithm for Python | Widget library

Based on your model your state vector is the following: [x, y, v_x, v_y] and you are observing (measuring) only [x, y]. So you need to properly define also measurement matrix H, which maps the true state space into the observed space: z=Hx + noise. So in your case, it is very simple:

I cannot reproduce your error, check if the following code works for you:

You can use a Kalman Filter in this case, but your position estimation will strongly depend on the precision of your acceleration signal. The Kalman Filter is actually useful for a fusion of several signals. So error of one signal can be compensated by another signal. Ideally you need to use sensors based on different physical effects (for example an IMU for acceleration, GPS for position, odometry for velocity).

In this answer I'm going to use readings from two acceleration sensors (both in X direction). One of these sensors is an expansive and precise. The second one is much cheaper. So you will see the sensor precision influence on the position and velocity estimations.

You already mentioned the ZUPT scheme. I just want to add some notes: it is very important to have a good estimation of the pitch angle, to get rid of the gravitation component in your X-acceleration. If you use Y- and Z-acceleration you need both pitch and roll angles.

Let's start with modelling. Assume you have only acceleration readings in X-direction. So your observation will look like

Now you need to define the smallest data set, which completely describes your system in each point of time. It will be the system state.

The mapping between the measurement and state domains is defined by the observation matrix:

Now you need to describe the system dynamics. According to this information the Filter will predict a new state based on the previous one.

In my case dt=0.01s. Using this matrix the Filter will integrate the acceleration signal to estimate the velocity and position.

The observation covariance R can be described by the variance of your sensor readings. In my case I have only one signal in my observation, so the observation covariance is equal to the variance of the X-acceleration (the value can be calculated based on your sensors datasheet).

Through the transition covariance Q you describe the system noise. The smaller the matrix values, the smaller the system noise. The Filter will become stiffer and the estimation will be delayed. The weight of the system's past will be higher compared to new measurement. Otherwise the filter will be more flexible and will react strongly on each new measurement.

Now everything is ready to configure the Pykalman. In order to use it in real time, you have to use the filter_update function.

There is no show method on plots in Bokeh, and never has been. There is a show function that you can pass plots (or layouts of plots and widgets) to.

I figured it out! Data['y'].values is a numpy array with dtype=object. All I had to do is to change the type of the array to float using .astype(float). This has to be done with everything that goes into the kalman filter object of pykalman, so I also had to change the type of the H matrix.

Hope this helps somebody in the future!

Here is what the final working code looks like:

Let's see:

transition_matrices = [[1, 1], [0, 1]]

means

So your state vector consists of 2 elements, for example:

observation_matrices = [[0.1, 0.5], [-0.3, 0.0]]

means

The dimension of an observation matrix should be [n_dim_obs, n_dim_state]. So your measurement vector also consists of 2 elements.

Conclusion: the code has 3 observations of two variables measured at 3 different points in time.

You can change the given code so it can process each measurement at a time step. You use kf.filter_update() for each measurement instead of kf.filter() for all measurements at once:

If you need to change either the transition covariance (matrix Q) or the measurement covariance (matrix R) during the estimation you can still use the pykalman library you've mentioned in your question.

Have a look at the function filter_update(). It is useful if you want to change some filter parameters (especially the covariance matrices) from one call to another.

The function call looks like this:

filter_update(filtered_state_mean, filtered_state_covariance, observation=None, transition_matrix=None, transition_offset=None, transition_covariance=None, observation_matrix=None, observation_offset=None, observation_covariance=None)

to modify the covariance matrices you just need to put the customized values into transition_covariance and observation_covariance

Have a look at my post here: Kalman filter with varying timesteps

In this example I modified the observation covariance on the fly depending on the sensor the measurement came from:

Answer edited to reflect my revised understanding of the question.

If I understand correctly you wish to model an observable output variable Y = ETF, as a linear combination of two observable values; ASSET_1, ASSET_2.

The coefficients of this regression are to be treated as the system states, i.e. ETF = x1*ASSET_1 + x2*ASSET_2 + x3, where x1 and x2 are the coefficients assets 1 and 2 respectively, and x3 is the intercept. These coefficients are assumed to evolve slowly.

Code implementing this is given below, note that this is just extending the existing example to have one more regressor.

Note also that you can get quite different results by playing with the delta parameter. If this is set large (far from zero), then the coefficients will change more rapidly, and the reconstruction of the regressand will be near-perfect. If it is set small (very close to zero) then the coefficients will evolve more slowly and the reconstruction of the regressand will be less perfect. You might want to look into the Expectation Maximisation algorithm - supported by pykalman.

CODE:

For a Kalman filter it is useful to represent the input data with a constant time step. Your sensors send data randomly, so you can define the smallest significant time step for your system and discretize the time axis with this step.

For example one of your sensors sends data approximately each 0.2 seconds and the second one each 0.5 seconds. So the smallest time step could be 0.01 seconds (here you need to find a trade-off between computational time and desired precision).

Your data would look like this: