In this video, we are going to look at some implementation notes, so we have covered the theory of
the common filter, but there's a few little things that we should know when we come to implementing
the common filter.
It is not always as straightforward as the theory makes us believe.
So we're going to cover a few things that we should consider when we're implementing the common filter
in a real world applications.
The equations used the covariance matrix after the update process assumes that the computational implementation
has a perfect numerical accuracy.
So computers do not have infinite precision or accuracy.
They represent floating point numbers only to a certain level of number of significant figures.
Numerical errors can cause a covariance matrix to lose its covariance matrix properties such as being
symmetrical and positive, positive, semi definite.
When this happens, it can cause the filter to fail or the calculations to crash because we're trying
to do the inverse of a non-convertible matrix.
So these issues become very critical.
When we start running the common Philidor for a long period of time, these numerical inaccuracies can
build up, which then can cause the filter to fail.
So numerical inadequacies can cause stability issues.
So the equations shown on the slide here is a covariance matrix update for the update step.
So this is only one way that we can represent this equation.
Another way is to use a Joseph stabilized version of the common Thawra update equation.
So this version shown on Slide now is more stable and more robust.
Yes, it does take more calculations, but it's less prone to numerical errors.
So when we're implementing the common filter and we come into stability issues, one potential solution
is to use this form of the covariance matrix update.
Theoretically, the common filter is an attractive choice for estimation and data fusion.
However, when the common filter is implemented in real systems, it may not always work, even though
the theory and equations are correct.
Now these issues can be caused by the finite position.
So the computational limits which we've covered in the previous slide and modelling errors which come
up from incorrect system modeling.
So we have incorrect matrixes or or we make the wrong assumptions inside the process model such as we
assuming the noise is Gaussian or it has some properties.
So potential solutions to these problems, if we encounter them first, we might increase the computational
precision.
So instead of using 32 bit numbers, we might bump it up to using 64 bit numbers so we can represent
more significant figures or more decimal places inside the calculations.
We also might use a form of square root, common filtering, so we didn't cover this in this course,
but basically we break down the covariance matrix into a multiplication of two matrices.
And when we're using this square root, common filtering form, it means the calculations are more stable.
We can also force the covariance matrix to be symmetrical after each update step.
There's a few different ways of doing this, but if we force it to be symmetrical after each step,
there's a greater chance the filter will stay stable for longer.
We also want to initialize the covariance matrix as best as possible to stop large jumps in the matrix
during operations.
So when we initialize a matrix, ideally we don't want to initialize if very large numbers sort of telling
the filter that we're really uncertain.
We want to set the uncertainty to be the correct level of uncertainty.
So we should have a reasonable estimate.
Well, that should be.
We can also use a form of a fading memory filter, so as the common thread runs, the covariance matrix
captures all these correlations.
For all the past historical measurements and properties of the system, we can use a form of fading
memory which causes the filter to forget some of the past information.
So this can help for issues.
When we have incorrect modelling, it can start to forget what it's done in the past to help it update
in the future.
And we've also already covered this one, we can also increase the price, this model, Nonoy, so increasing
the size of the values inside the key metrics to account for any modelling errors.
So these are some of the strategies you can use if you start to run in problems when you're implementing
the common filter in real life to solve real world problems.