diff --git a/examples/kalman_filter.ipynb b/examples/kalman_filter.ipynb new file mode 100644 index 00000000..5ed8e5f7 --- /dev/null +++ b/examples/kalman_filter.ipynb @@ -0,0 +1,487 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Kalman Filter" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This example optimizes the parameters of a [Kalman-Filter](https://en.wikipedia.org/wiki/Kalman_filter).\n", + "\n", + "This example is available as a Jupyter notebook [here](https://github.com/patrick-kidger/diffrax/blob/main/examples/kalman_filter.ipynb)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import functools as ft\n", + "from types import SimpleNamespace\n", + "from typing import Optional\n", + "\n", + "import diffrax as dfx\n", + "import equinox as eqx # https://github.com/patrick-kidger/equinox\n", + "import jax.numpy as jnp\n", + "import jax.random as jr\n", + "import jax.tree_util as jtu\n", + "import matplotlib.pyplot as plt\n", + "import optax # https://github.com/deepmind/optax" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We use [Equinox](https://github.com/patrick-kidger/equinox) to build the Kalman-Filter implementation and to represent linear, time-invariant systems (LTI systems). \n", + "\n", + "We use [Optax](https://github.com/deepmind/optax) for optimisers (Adam etc.)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Problem Formulation\n", + "\n", + "Assume that there exists some *unknown* dynamical system of the form\n", + "\n", + "$\\frac{dx}{dt}(t)= f(x(t), u(t), t)$\n", + "\n", + "$y(t) = g(x(t)) + \\epsilon(t)$ \n", + "\n", + "where \n", + "- $u(t)$ denotes the time-dependent input to the system\n", + "- $y(t)$ denotes the time-dependent output / measurement to the system\n", + "- $x(t)$ denotes the time-dependent state of the system (which is not directly measureable in general)\n", + "- $f,g$ denote the time-dependent dynamics- and measurement-function, respectively\n", + "- $\\epsilon$ denotes random measurement uncertainty\n", + "\n", + "*The goal is to infer $x$ from $y$ even though $f,g,\\epsilon$ are unkown.*\n", + "\n", + "*A Kalman-Filter represents a possible solution.*\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "!!! info\n", + "\n", + " From [Wikipedia](https://en.wikipedia.org/wiki/Kalman_filter): \n", + " \n", + " Kalman filtering, also known as linear quadratic estimation (LQE), is an algorithm that uses a series of measurements observed over time, including statistical noise and other inaccuracies, and produces estimates of unknown variables that tend to be more accurate than those based on a single measurement alone, by estimating a joint probability distribution over the variables for each timeframe. The filter is named after Rudolf E. Kálmán, who was one of the primary developers of its theory.\n", + "\n", + " The algorithm works by a two-phase process. For the prediction phase, the Kalman filter produces estimates of the current state variables, along with their uncertainties. Once the outcome of the next measurement (necessarily corrupted with some error, including random noise) is observed, these estimates are updated using a weighted average, with more weight being given to estimates with greater certainty. The algorithm is recursive. It can operate in real time, using only the present input measurements and the state calculated previously and its uncertainty matrix; no additional past information is required.\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For the sake of simplicity, here we assume that the dynamical system takes the form\n", + "\n", + "$\\frac{dx}{dt}(t) = Ax(t) + Bu(t)$\n", + "\n", + "$y(t) = Cx(t) + \\epsilon(t)$ \n", + "\n", + "where $A,B,C$ are constant matrices, i.e. the system is linear in its state $x(t)$ and its input $u(t)$. Further, the dynamics- and measurement-functions do not depend on time.\n", + "\n", + "Hence, the above represents the general form of (physical) *linear, time-invariant systems* (LTI systems)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we define a container object for LTI systems." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "class LTISystem(eqx.Module):\n", + " A: jnp.ndarray\n", + " B: jnp.ndarray\n", + " C: jnp.ndarray" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "An harmonic oscillator is an LTI system, this function returns such an LTI system." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def harmonic_oscillator(damping: float = 0.0, time_scaling: float = 1.0) -> LTISystem:\n", + " A = jnp.array([[0.0, time_scaling], [-time_scaling, -2 * damping]])\n", + " B = jnp.array([[0.0], [1.0]])\n", + " C = jnp.array([[0.0, 1.0]])\n", + " return LTISystem(A, B, C)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we define some utility functions that allow us to simulate LTI systems." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:absl:No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)\n" + ] + } + ], + "source": [ + "def interpolate_us(ts, us, B):\n", + " if us is None:\n", + " m = B.shape[-1]\n", + " u_t = SimpleNamespace(evaluate=lambda t: jnp.zeros((m,)))\n", + " else:\n", + " u_t = dfx.LinearInterpolation(ts=ts, ys=us)\n", + " return u_t\n", + "\n", + "\n", + "def diffeqsolve(\n", + " rhs,\n", + " ts: jnp.ndarray,\n", + " y0: jnp.ndarray,\n", + " solver: dfx.AbstractSolver = dfx.Dopri5(),\n", + " stepsize_controller: dfx.AbstractStepSizeController = dfx.ConstantStepSize(),\n", + " dt0: float = 0.01,\n", + ") -> jnp.ndarray:\n", + " return dfx.diffeqsolve(\n", + " dfx.ODETerm(rhs),\n", + " solver=solver,\n", + " stepsize_controller=stepsize_controller,\n", + " t0=ts[0],\n", + " t1=ts[-1],\n", + " y0=y0,\n", + " dt0=dt0,\n", + " saveat=dfx.SaveAt(ts=ts),\n", + " ).ys\n", + "\n", + "\n", + "def simulate_lti_system(\n", + " sys: LTISystem,\n", + " y0: jnp.ndarray,\n", + " ts: jnp.ndarray,\n", + " us: Optional[jnp.ndarray] = None,\n", + " std_measurement_noise: float = 0.0,\n", + " key=jr.PRNGKey(\n", + " 1,\n", + " ),\n", + "):\n", + " u_t = interpolate_us(ts, us, sys.B)\n", + "\n", + " def rhs(t, y, args):\n", + " return sys.A @ y + sys.B @ u_t.evaluate(t)\n", + "\n", + " xs = diffeqsolve(rhs, ts, y0)\n", + " # noisy measurements\n", + " ys = xs @ sys.C.transpose()\n", + " ys = ys + jr.normal(key, shape=ys.shape) * std_measurement_noise\n", + " return xs, ys" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we define the Kalman-Filter.\n", + "\n", + "Note how we use `equinox` to combine the Kalman-Filter logic in `__call__` and the Kalman-Filter parameters `Q` , `R` in one object." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "class KalmanFilter(eqx.Module):\n", + " \"\"\"Continuous-time Kalman Filter\n", + "\n", + " Ref:\n", + " [1] Optimal and robust estimation. 2nd edition. Page 154.\n", + " https://lewisgroup.uta.edu/ee5322/lectures/CTKalmanFilterNew.pdf\n", + " \"\"\"\n", + "\n", + " sys: LTISystem\n", + " x0: jnp.ndarray\n", + " P0: jnp.ndarray\n", + " Q: jnp.ndarray\n", + " R: jnp.ndarray\n", + "\n", + " def __call__(self, ts, ys, us: Optional[jnp.ndarray] = None):\n", + "\n", + " A, B, C = self.sys.A, self.sys.B, self.sys.C\n", + "\n", + " y_t = dfx.LinearInterpolation(ts=ts, ys=ys)\n", + " u_t = interpolate_us(ts, us, B)\n", + "\n", + " y0 = (self.x0, self.P0)\n", + "\n", + " def rhs(t, y, args):\n", + " x, P = y\n", + "\n", + " # eq 3.22 of Ref [1]\n", + " K = P @ C.transpose() @ jnp.linalg.inv(self.R)\n", + "\n", + " # eq 3.21 of Ref [1]\n", + " dPdt = (\n", + " A @ P\n", + " + P @ A.transpose()\n", + " + self.Q\n", + " - P @ C.transpose() @ jnp.linalg.inv(self.R) @ C @ P\n", + " )\n", + "\n", + " # eq 3.23 of Ref [1]\n", + " dxdt = A @ x + B @ u_t.evaluate(t) + K @ (y_t.evaluate(t) - C @ x)\n", + "\n", + " return (dxdt, dPdt)\n", + "\n", + " return diffeqsolve(rhs, ts, y0)[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Main entry point. Try runnning `main()`." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def main(\n", + " # evaluate at these timepoints\n", + " ts=jnp.arange(0, 5.0, 0.01),\n", + " # system that generates data\n", + " sys_true=harmonic_oscillator(0.3),\n", + " # initial state of our data generating system\n", + " sys_true_x0=jnp.array([1.0, 0.0]),\n", + " # standard deviation of measurement noise\n", + " sys_true_std_measurement_noise=1.0,\n", + " # our model for system `true`, it's not perfect\n", + " sys_model=harmonic_oscillator(0.7),\n", + " # initial state guess, it's not perfect\n", + " sys_model_x0=jnp.array([0.0, 0.0]),\n", + " # weighs how much we trust our model of the system\n", + " Q=jnp.diag(jnp.ones((2,))) * 0.1,\n", + " # weighs how much we trust in the measurements of the system\n", + " R=jnp.diag(jnp.ones((1,))),\n", + " # weighs how much we trust our initial guess\n", + " P0=jnp.diag(jnp.ones((2,))) * 10.0,\n", + " plot=True,\n", + " n_gradient_steps=0,\n", + " print_every=10,\n", + "):\n", + "\n", + " xs, ys = simulate_lti_system(\n", + " sys_true, sys_true_x0, ts, std_measurement_noise=sys_true_std_measurement_noise\n", + " )\n", + "\n", + " kmf = KalmanFilter(sys_model, sys_model_x0, P0, Q, R)\n", + "\n", + " print(f\"Initial Q: \\n{kmf.Q}\\n Initial R: \\n{kmf.R}\")\n", + "\n", + " # gradients should only be able to change Q/R parameters\n", + " # *not* the model (well at least not in this example :)\n", + " filter_spec = jtu.tree_map(lambda arr: False, kmf)\n", + " filter_spec = eqx.tree_at(\n", + " lambda tree: (tree.Q, tree.R), filter_spec, replace=(True, True)\n", + " )\n", + "\n", + " @eqx.filter_jit\n", + " @ft.partial(eqx.filter_value_and_grad, arg=filter_spec)\n", + " def loss_fn(kmf, ts, ys, xs):\n", + " xhats = kmf(ts, ys)\n", + " return jnp.mean((xs - xhats) ** 2)\n", + "\n", + " opt = optax.adam(1e-2)\n", + " opt_state = opt.init(kmf)\n", + "\n", + " for step in range(n_gradient_steps):\n", + " value, grads = loss_fn(kmf, ts, ys, xs)\n", + " if step % print_every == 0:\n", + " print(\"Current MSE: \", value)\n", + " updates, opt_state = opt.update(grads, opt_state)\n", + " kmf = eqx.apply_updates(kmf, updates)\n", + "\n", + " print(f\"Final Q: \\n{kmf.Q}\\n Final R: \\n{kmf.R}\")\n", + "\n", + " if plot:\n", + " xhats = kmf(ts, ys)\n", + " plt.plot(ts, xs[:, 0], label=\"true position\", color=\"orange\")\n", + " plt.plot(\n", + " ts,\n", + " xhats[:, 0],\n", + " label=\"estimated position\",\n", + " color=\"orange\",\n", + " linestyle=\"dashed\",\n", + " )\n", + " plt.plot(ts, xs[:, 1], label=\"true velocity\", color=\"blue\")\n", + " plt.plot(\n", + " ts,\n", + " xhats[:, 1],\n", + " label=\"estimated velocity\",\n", + " color=\"blue\",\n", + " linestyle=\"dashed\",\n", + " )\n", + " plt.xlabel(\"time\")\n", + " plt.ylabel(\"position / velocity\")\n", + " plt.grid()\n", + " plt.legend()\n", + " plt.title(\"Kalman-Filter optimization w.r.t Q/R\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial Q: \n", + "[[0.1 0. ]\n", + " [0. 0.1]]\n", + " Initial R: \n", + "[[1.]]\n", + "Final Q: \n", + "[[0.1 0. ]\n", + " [0. 0.1]]\n", + " Final R: \n", + "[[1.]]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "main(n_gradient_steps=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial Q: \n", + "[[0.1 0. ]\n", + " [0. 0.1]]\n", + " Initial R: \n", + "[[1.]]\n", + "Current MSE: 0.10257154\n", + "Current MSE: 0.09800266\n", + "Current MSE: 0.09304534\n", + "Current MSE: 0.087538235\n", + "Current MSE: 0.08122826\n", + "Current MSE: 0.07371251\n", + "Current MSE: 0.06441843\n", + "Current MSE: 0.05347546\n", + "Current MSE: 0.046111725\n", + "Current MSE: 0.03786327\n", + "Final Q: \n", + "[[-0.44275677 1.3142775 ]\n", + " [-1.1867669 0.9120258 ]]\n", + " Final R: \n", + "[[0.14836916]]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "main(n_gradient_steps=100)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see that the MSE is smaller after optimization. \n", + "\n", + "After optimization we trust the measurements more as there is a significant modeling error.\n", + "\n", + "We can observe this nicely through the added noise in our state estimate. Recall that the measurements are noisy after all." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.9.13 ('ode_control')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "9bce93e623406d1c11f9dd3ce02c7f824470b99b3bb3335b56643c76e124d379" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/mkdocs.yml b/mkdocs.yml index ea7612d2..df3dbf67 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -106,6 +106,7 @@ nav: - Symbolic Regression: 'examples/symbolic_regression.ipynb' - Stiff ODE: 'examples/stiff_ode.ipynb' - Steady State: 'examples/steady_state.ipynb' + - Kalman Filter: 'examples/kalman_filter.ipynb' - Basic API: - 'api/type_terminology.md' - 'api/diffeqsolve.md'