sync

04-One-Dimensional-Kalman-Filters.ipynb

@@ -1,4 +1,4 @@
-to {
+{
  "cells": [
   {
    "cell_type": "markdown",
@@ -2450,4 +2450,630 @@ to {
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiIAAAC+CAYAAAAIj2Q7AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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 truncated
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiIAAAC+CAYAAAAIj2Q7AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4wLCBo\ndHRwOi8vbWF0cGxvdGxpYi5vcmcvpW3flQAAIABJREFUeJzsXXdcFMf7fu6OKtWGgApiRVDssZcY\nUbH3FuxGY+8RjTUae4s99i72HhsWJGoUS2KLilhRVBRFAan3/P44d3LLHYiKwu/rPp/PfMS53ZnZ\nnd19n3nnLSqSUKBAgQIFChQoyAyoM3sAChQoUKBAgYKvFwoRUaBAgQIFChRkGhQiokCBAgUKFCjI\nNChERIECBQoUKFCQaTDJ7AEYQ1RUlGJBq0CBAgUKFPyPwc7OTpWyTtGIKFCgQIECBQoyDQoRUaBA\ngQIFChRkGrLk1ow+7OzsMnsIXz3Onz8PAChfvnwmj0SBBGVOshaU+chaUOYjfTh48CAaNGgAksiX\nLx8AICwsDCqVCocOHYK3t3eG9BMVFZXm74pGRIECBQoUKPgKUb9+fWzevBkuLi4ICwtDWFgYXF1d\nsWXLlgwjIelBlteIKFCgQIECBQo+D1q3bo0WLVrg6tWrUKlU8PT0hEaj+aJjUIiIAgUKFChQ8BVD\no9GgVKlSmda/sjWjQIECBQoUKMg0KEREgQIFChQoUJBpUIiIAgUKFChQoABarRaHDh3CgAED0L9/\nfxw8eBBarfaD23n48CF69eoFR0dH5MyZ873HKzYiChQoUKBAwVeO+Ph4tGzZEvv37xd1CxYsgI+P\nD3bs2AELC4t0tRMWFoZKlSrh8ePH6e5b0YgoUKBAgQIFnwGvX7/G8ePH8ddffyE5Ofmj29Fqtbh9\n+zYePHgA8vNkQJk2bRr279+P7NmzY9y4cRg3bhxy5MiBAwcOYOrUqelu59dff8Xjx49RuXJlXL58\nGSEhIe89RyEiChQoUKDgfwJJSUmfTVB/CEhi4sSJcHZ2Ru3atVG5cmUULFgQBw4c+OC2Nm/ejMKF\nC6NIkSJwdXVFuXLlEBQUlOFjXrFiBQDA398f48ePx/jx47FlyxYAwPLly9Pdzt69ewEAixYtQsmS\nJVG4cOH3nqMQEQUKFChQ8P8a27dvR7ly5WBqago7OztMnToVr169yrTxzJ49G2PHjkVMTAzKlSuH\nAgUK4MGDB2jatCkuXbqU7nZ27NiBdu3a4e7du3BwcICdnR0uXbqEunXr4u+//87QMUtbKVWrVhV1\n0t+PHz9ON8GTND9mZmbp7lshIgoUKFCg4P8tli9fjlatWuHixYsAgDdv3mD79u348ccfERMT88XH\nk5SUhBkzZgAANm3ahPPnzyM0NBRdu3ZFYmIiZs+ena52SGLcuHEAgHHjxuHx48d48uQJ2rRpg7i4\nOHTu3Bm7du1CYmJihozb09MTALBu3TpRJ/3t6ekJlcogaa5R1KtXDwAwdOhQPH36NH2EkGSWK69e\nvaJUFGQ+goODGRwcnNnDUKAHZU6yFrLKfBw4cIANGzZk0aJF6e3tze3bt1Or1X5wO//++y+3b9/O\ns2fPftT5XwpxcXHMlSsXAXDy5Ml8+/Ytr1y5QhcXFwLg/Pnzv/iY7t69SwDMkyeP7N5duHCBAOju\n7p6udl6+fEkAtLCwYHx8PEkyMDCQ9vb2BCBKwYIF+e+//37yuFevXi3a9Pb2Zt26dcX/V65cme52\nbt26JRujSqViCpluIPPTTQ4ArATwDMBVvbrxAB4B+PtdaaD320gAtwHcBFBPr77+u7rbAPyM9aUQ\nkayFrPKRVfAflDnJWsgK8zFr1iyZgJLKqFGj0t1GREQE69WrJzvfy8uL169f/4wj/3icOnWKAFis\nWDGZ0J8wYQIBsGHDhl98TJGRkVSpVDQxMWF4eLioX79+PQGwSpUq6WonNjaWGo2GarWajx8/ZmRk\nJO3s7MS82Nvbs0iRIgTAokWLMikp6ZPGrdVqOXHiRJqZmYk+zMzMOGHChA8mo9evX2fTpk2p0WjS\nRUQ+ZGtm9TsSkRJzSJZ+V/4AAJVK5QGgHQDPd+csUqlUGpVKpQGwEIAPAA8A7d8dq0CBAgUKPhLh\n4eEYMWIEAGDChAm4fPkyZs2aBY1Gg8mTJ+PmzZvvbYMkWrdujUOHDsHa2hoNGjRAnjx5cPnyZXh7\neyM6OvpzX8YHQ63WibCkpCRZvfT/9G4nZCSyZ8+Oxo0bIykpCT4+PtiwYQPmzp2L/v37AwA6duyY\nrnYsLS3RuHFjaLVatG7dGmPHjkVUVJRwo+3bty/+/vtvFChQALdu3UJAQMAnjVulUmH06NEICwvD\nxo0bsWHDBjx8+BBjx4794PtYvHhx7Nq1C3FxcYiPj3/v8emOI0LypEqlKpDOw5sC8CcZD+CuSqW6\nDeCbd7/dJnkHAFQqlf+7Y6+n1pCUzllB5kOZi6wHZU6yFjJrPnbs2IGkpCRUr14dDRo0QHx8PGrU\nqAEfHx/s27cP8+bNQ9euXdNs49q1azhx4gRsbW2xadMmODg4IC4uDt26dUNISAimTp2KZs2afaEr\nSj9y5syJ0NBQdOnSBb6+vrh3757w8vDy8sqUOenRowfOnz+Pv//+G76+vqK+Ro0aKF26dLrH1Llz\nZwQFBeHUqVM4deoUACAuLg5FihRBnTp1cP36dZQqVQr37t3DsWPH0hU8LD0oUqQIAODBgwd48OBB\nhrWXGjIioFk/lUrVCcB5AENJvgSQF8BfeseEvasDgIcp6itmwBgUKFCg4KtFXFwcAN1qXB/S/6Xf\n08KtW7cA6DwlHBwcAAAWFhbw8fFBSEiI+D0rwcTEBIMHD8aYMWOwdu1arF27Vvzm6emJBg0aZMq4\nnJycsH79euzZswcXLlyAubk56tSpg4IFC2LKlCm4cOECzMzMULt2bXz//fewsbEx2k6+fPmwfv16\nbNq0CQcPHsSzZ8+QN29e/P7777C2tkZ8fLwgNc7Ozp/lWhISEhAYGIiwsDA4OzujZs2a6Q5ulm4Y\n269JrQAoALmNSB4AGui8b34FsPJd/UIAvnrHrQDQEkBrAMv16jsCmJ+yH8VGJGshK+x/K5BDmZOs\nhcyej0uXLhEAra2tefbsWZLklStXhCFnQEDAe9vYtWsXAbBEiRJMTk4W9R06dCAATpgw4bON/1Nx\n+PBhfvvtt7SysmK+fPnYuXNnnjhxIrOHJcPFixdpY2NjYMNTokSJdMm658+fi/OrVKnCkSNH0tPT\nUxisJiYmZviYL126xHz58snG6+joKJ6x9CLDjFVphIik9ht0hqoj9X47BKDyu3JIr152HBUikiWR\n2R9ZBYZQ5iRrISvMR8uWLYWwcHJyEn/XqlUrXcaGcXFxzJMnDwHQx8eHq1evZvfu3QmAGo2GoaGh\nX+AqMgZZYT5SombNmgTAxo0b89KlSwwICGCxYsUIgOPHj09XG0eOHJEZrAJgvnz5eOXKlQwfb1xc\nnCAhnp6eHDp0KEuVKkUAdHBwYHR0dJrnh4eH888//+S9e/c+LxEB4KT392Do7EIAnZHqPwDMAbgB\nuPNOc2Ly7m83AGbvjvFM2Y9CRLIWsuJL/bVDmZOshawwH2/fvuWgQYNobW0t3D579uzJ169fp7uN\nY8eOifOlolKp+Pvvv3/GkWc8ssJ86OPFixcEQHNzc0ZFRYn6Q4cOCc+k9OLVq1dctmwZx44dy40b\nN/Lt27efY8jcunUrAdDDw0O4DycmJrJs2bIEwDVr1qQ6vnbt2lGtVotn6H1EJN02IiqVahOAWgBy\nqVSqMADjANRSqVSl33V2D0AvACB5TaVSbYHOCDUJQF+Sye/a6fdOQ6KBbivnWnrHoECBAgUKjMPC\nwgJz5szB5MmT8fTpU+TOnRtWVlYf1Ma3336LmzdvYsWKFbh+/Try5s2Lbt26wcNDcW78FEieI+bm\n5rC0tBT19vb2ANJnwyPBzs4OPXr0yNgBGkFoaCgAXYAyKUqqiYkJ6tevj4sXL4rf9UESbdq0weHD\nh2FiYoKyZcvi2rX3i/gP8Zppb6R6RRrH/wqd3UjK+j8A/JHefhUoUKBAQfphaWmJAgUKfPT5zs7O\nGDNmTMYN6CtEcnIyAgMD8fTpUyQnJ+P48eOwtrbG69evMXToUMycORPR0dEYO3YsAOC7777L5BEb\nws3NDQAQEBCAxMREmJqaIjk5GUeOHJH9ro/z58/j8OHDsLe3R3BwMAoXLoynT5++t6+M8JpRoECB\nAgUKFAA4d+6cyA9jDPPnz8fy5cuRlJSExMRE2NvbY9iwYV94lO9HkyZN4OTkhCtXruCbb76Bj48P\njhw5gvPnzyNnzpxo1aoVAODVq1eYN28e9uzZgydPngAA6tevL5Ld5cmTB1FRUWn2pRARBQoUKPhI\nkMyUoFkKsiaeP38OHx8fREZGwtnZWSSSA4AyZcrAxMQEwcHBePv2LQDA29sbs2fPRsGCBTNryKnC\nwsICe/bsQaNGjfD333+LJHu5cuXC2rVrMX36dOzcuRMhISEGQct27NiB+/fvw9XVNV19KUnvFChQ\noOADkJCQgIkTJyJ//vzQaDTw9PTEzp07JaP9LIHQ0FD4+vrC1tYWVlZWaNGiBS5fvpzZw/qfx6pV\nqxAZGYkaNWqgbdu2AIBOnTrB2toaly5dwsqVK1G0aFEAOmF9+PBhlChRIjOHnCbKly+PO3fuYO3a\ntRg3bhxWrVqFc+fOYcCAAZg4cSKuXr0qSEiOHDmwfPlyqNVqJCQkoFq1aqhXrx6yZcv23n4UjYgC\nBQr+J/D48WMsWLAAQUFBsLKyQps2bdCxY0eYmppmWB98FwZ9z549ou769eu4fv06wLine truncated
+      "text/plain": [
+       "<matplotlib.figure.Figure at 0x2998260ca20>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sensor_var = 300**2\n",
+    "process_var = 2\n",
+    "process_model = (1, process_var)\n",
+    "pos = (0,500)\n",
+    "N = 1000\n",
+    "dog = DogSimulation(pos[0], 1, sensor_var, process_var)\n",
+    "zs = [dog.move_and_sense() for _ in range(N)]\n",
+    "ps = []\n",
+    "\n",
+    "for i in range(N):\n",
+    "    prior = predict(pos, process_model)    \n",
+    "    pos = update(prior, (zs[i], sensor_var))\n",
+    "    ps.append(pos[0])\n",
+    "\n",
+    "book_plots.plot_measurements(zs, lw=1)\n",
+    "book_plots.plot_filter(ps)\n",
+    "plt.legend(loc=4);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In this example the noise is extreme yet the filter still outputs a nearly straight line! This is an astonishing result! What do you think might be the cause of this performance? \n",
+    "\n",
+    "We get a nearly straight line because our process error is small. A small process error tells the filter that the prediction is very trustworthy, and the prediction is a straight line, so the filter outputs a nearly straight line. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Example: Incorrect Process Variance\n",
+    "\n",
+    "That last filter looks fantastic! Why wouldn't we set the process variance very low, as it guarantees the result will be straight and smooth?\n",
+    "\n",
+    "The process variance tells the filter how much the system is changing over time. If you lie to the filter by setting this number artificially low the filter will not be able to react to changes that are happening. Let's have the dog increase his velocity by a small amount at each time step and see how the filter performs with a process variance of 0.001 m$^2$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhoAAAC+CAYAAABzq6b3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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 truncated
+      "text/plain": [
+       "<matplotlib.figure.Figure at 0x299825a77f0>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sensor_var = 20\n",
+    "process_var = .001\n",
+    "process_model = (1, process_var)\n",
+    "pos = (0,500)\n",
+    "N = 100\n",
+    "dog = DogSimulation(pos[0], 1, sensor_var, process_var*10000)\n",
+    "zs, ps = [], []\n",
+    "for _ in range(N):\n",
+    "    dog.velocity += 0.04\n",
+    "    zs.append(dog.move_and_sense())\n",
+    "\n",
+    "for z in zs:\n",
+    "    prior = predict(pos, process_model)    \n",
+    "    pos = update(prior, (z, sensor_var))\n",
+    "    ps.append(pos[0])\n",
+    "\n",
+    "book_plots.plot_measurements(zs, lw=1)\n",
+    "book_plots.plot_filter(ps)\n",
+    "plt.legend(loc=4);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "It is easy to see that the filter is not correctly responding to the measurements. The measurements  clearly indicate that the dog is changing speed but the filter has been told that it's predictions are nearly perfect so it almost entirely ignores them. I encourage you to adjust the amount of movement in the dog vs process variance. We will also be studying this topic much more in the later chapters. The key point is to recognize that math requires that the variances correctly describe your system. The filter does not 'notice' that it is diverging from the measurements and correct itself. It computes the Kalman gain from the variance of the prior and the measurement, and forms the estimate depending on which is more accurate."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Example: Bad Initial Estimate\n",
+    "\n",
+    "\n",
+    "Now let's look at the results when we make a bad initial estimate of position. To avoid obscuring the results I'll reduce the sensor variance to 30, but set the initial position to 1000 meters. Can the filter recover from a 1000 meter error?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhkAAAC+CAYAAACYnB30AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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 truncated
+      "text/plain": [
+       "<matplotlib.figure.Figure at 0x299824696a0>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sensor_var = 5**2\n",
+    "process_var = 2\n",
+    "pos = (1000, 500)\n",
+    "process_model = (1, process_var)\n",
+    "N = 100\n",
+    "dog = DogSimulation(0, 1, sensor_var, process_var)\n",
+    "zs = [dog.move_and_sense() for _ in range(N)]\n",
+    "ps = []\n",
+    "\n",
+    "for z in zs:\n",
+    "    prior = predict(pos, process_model)    \n",
+    "    pos = update(prior, (z, sensor_var))\n",
+    "    ps.append(pos[0])\n",
+    "\n",
+    "book_plots.plot_measurements(zs, lw=1)\n",
+    "book_plots.plot_filter(ps)\n",
+    "plt.legend(loc=4);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Again the answer is yes! Because we are relatively sure about our belief in the sensor ($\\sigma^2=5^2$) after only the first step we have changed our position estimate from 1000 m to roughly 50 m. After another 5-10 measurements we have converged to the correct value. This is how we get around the chicken and egg problem of initial guesses. In practice we would likely assign the first measurement from the sensor as the initial value, but you can see it doesn't matter much if we wildly guess at the initial conditions - the Kalman filter still converges so long as the filter variances are chosen to match the actual process and measurement variances."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Example: Large Noise and Bad Initial Estimate\n",
+    "\n",
+    "What about the worst of both worlds, large noise and a bad initial estimate?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiIAAAC+CAYAAAAIj2Q7AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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 truncated
+      "text/plain": [
+       "<matplotlib.figure.Figure at 0x2998277c048>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sensor_var = 30000\n",
+    "process_var = 2\n",
+    "pos = (1000, 500)\n",
+    "process_model = (1, process_var)\n",
+    "\n",
+    "N = 1000\n",
+    "dog = DogSimulation(0, 1, sensor_var, process_var)\n",
+    "zs = [dog.move_and_sense() for _ in range(N)]\n",
+    "ps = []\n",
+    "\n",
+    "for z in zs:\n",
+    "    prior = predict(pos, process_model) \n",
+    "    pos = update(prior, (z, sensor_var))\n",
+    "    ps.append(pos[0])\n",
+    "\n",
+    "book_plots.plot_measurements(zs, lw=1)\n",
+    "book_plots.plot_filter(ps)\n",
+    "plt.legend(loc=4);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This time the filter struggles. Notice that the previous example only computed 100 updates, whereas this example uses 1000. By my eye it takes the filter 400 or so iterations to become reasonable accurate, but maybe over 600 before the results are good. Kalman filters are good, but we cannot expect miracles. If we have extremely noisy data and extremely bad initial conditions, this is as good as it gets.\n",
+    "\n",
+    "Finally, let's implement the suggestion of using the first measurement as the initial position."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiAAAAC+CAYAAAAMerQGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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 truncated
+      "text/plain": [
+       "<matplotlib.figure.Figure at 0x299825a9550>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sensor_var = 30000\n",
+    "process_var = 2\n",
+    "process_model = (1, process_var)\n",
+    "N = 1000\n",
+    "dog = DogSimulation(0, 1, sensor_var, process_var)\n",
+    "zs = [dog.move_and_sense() for _ in range(N)]\n",
+    "\n",
+    "pos = (zs[0], 500)\n",
+    "ps = []\n",
+    "for z in zs:\n",
+    "    prior = predict(pos, process_model) \n",
+    "    pos = update(prior, (z, sensor_var))\n",
+    "    ps.append(pos[0])\n",
+    "\n",
+    "book_plots.plot_measurements(zs, lw=1)\n",
+    "book_plots.plot_filter(ps)\n",
+    "plt.legend(loc='best');"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This simple change significantly improves the results. On some runs it takes 200 iterations or so to settle to a good solution, but other runs it converges very rapidly. This all depends on the amount of noise in the first measurement. A large amount of noise causes the initial estimate to be far from the dog's position.\n",
+    "\n",
+    "200 iterations may seem like a lot, but the amount of noise we are injecting is truly huge. In the real world we use sensors like thermometers,  laser range finders, GPS satellites, computer vision, and so on. None have the enormous errors in these examples. A reasonable variance for a cheap thermometer might be 0.2 C$^{\\circ 2}$, and our code is using 30,000 C$^{\\circ 2}$."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Exercise: Interactive Plots\n",
+    "\n",
+    "Implement the Kalman filter using Jupyter Notebook's animation features to allow you to modify the various constants in real time using sliders. Refer to the section **Interactive Gaussians** in the **Gaussians** chapter to see how to do this. You will use the `interact()` function to call a calculation and plotting function. Each parameter passed into `interact()` automatically gets a slider created for it. I have written the boilerplate for this; you fill in the required code."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "7cdc56e40a90494cbaca4f5fb4d145e7",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "A Jupyter Widget"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from ipywidgets import interact, FloatSlider\n",
+    "\n",
+    "def plot_kalman_filter(start_pos, \n",
+    "                       sensor_noise, \n",
+    "                       velocity, \n",
+    "                       process_noise):\n",
+    "    plt.figure()\n",
+    "    # your code goes here\n",
+    "    pass;\n",
+    "\n",
+    "interact(plot_kalman_filter,\n",
+    "         start_pos=(-10, 10), \n",
+    "         sensor_noise=FloatSlider(value=5, min=0, max=100), \n",
+    "         velocity=FloatSlider(value=1, min=-2., max=2.), \n",
+    "         process_noise=FloatSlider(value=5, min=0, max=100.));"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Solution\n",
+    "\n",
+    "One possible solution follows. We have sliders for the start position, the amount of noise in the sensor, the amount we move in each time step, and how much movement error there is. Process noise is perhaps the least clear - it models how much the dog wanders off course at each time step, so we add that into the dog's position at each step. I set the random number generator seed so that each redraw uses the same random numbers, allowing us to compare the graphs as we move the sliders."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c60f71af532746729d0fc85ce753d6c3",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "A Jupyter Widget"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from numpy.random import seed \n",
+    "from ipywidgets import interact, FloatSlider\n",
+    "\n",
+    "def plot_kalman_filter(start_pos, \n",
+    "                       sensor_noise, \n",
+    "                       velocity,\n",
+    "                       process_noise):\n",
+    "    N = 20\n",
+    "    zs, ps = [], []   \n",
+    "    seed(303)\n",
+    "    dog = DogSimulation(start_pos, velocity, sensor_noise, process_noise)\n",
+    "    zs = [dog.move_and_sense() for _ in range(N)]\n",
+    "    pos = (0., 1000.) # mean and variance\n",
+    "    process_model = (velocity, process_noise)\n",
+    "    \n",
+    "    for z in zs:    \n",
+    "        pos = predict(pos, process_model)\n",
+    "        pos = update(pos, (z, sensor_noise))\n",
+    "        ps.append(pos[0])\n",
+    "\n",
+    "    plt.figure()\n",
+    "    plt.plot(zs, c='k', marker='o', linestyle='', label='measurement')\n",
+    "    plt.plot(ps, c='#004080', alpha=0.7, label='filter')\n",
+    "    plt.legend(loc=4);\n",
+    "\n",
+    "interact(plot_kalman_filter,\n",
+    "         start_pos=(-10, 10), \n",
+    "         sensor_noise=FloatSlider(value=5, min=0., max=100, continuous_update=False), \n",
+    "         velocity=FloatSlider(value=1, min=-2., max=2., continuous_update=False), \n",
+    "         process_noise=FloatSlider(value=.1, min=0, max=40, continuous_update=False));"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Exercise - Nonlinear Systems\n",
+    "\n",
+    "Our equations for the Kalman filter are linear:\n",
+    "\n",
+    "$$\\begin{aligned}\n",
+    "\\mathcal{N}(\\bar\\mu,\\, \\bar\\sigma^2) &= \\mathcal{N}(\\mu,\\, \\sigma^2) + \\mathcal{N}(\\mu_\\mathtt{move},\\, \\sigma^2_\\mathtt{move})\\\\\n",
+    "\\mathcal{N}(\\mu,\\, \\sigma^2) &= \\mathcal{N}(\\bar\\mu,\\, \\bar\\sigma^2)  \\times \\mathcal{N}(\\mu_\\mathtt{z},\\, \\sigma^2_\\mathtt{z})\n",
+    "\\end{aligned}$$\n",
+    "\n",
+    "Do you suppose that this filter works well or poorly with nonlinear systems?\n",
+    "\n",
+    "Implement a Kalman filter that uses the following equation to generate the measurement value\n",
+    "\n",
+    "```python\n",
+    "for i in range(100):\n",
+    "    z = math.sin(i/3.) * 2\n",
+    "```\n",
+    "    \n",
+    "Adjust the variance and initial positions to see the effect. What is, for example, the result of a very bad initial guess?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "#enter your code here."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Solution"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhUAAAC+CAYAAACCoP16AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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 truncated
+      "text/plain": [
+       "<matplotlib.figure.Figure at 0x2998264ea58>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import math\n",
+    "\n",
+    "sensor_var = 30\n",
+    "process_var = 2\n",
+    "pos = (100,500)\n",
+    "process_model = (1, process_var)\n",
+    "\n",
+    "zs, ps = [], []\n",
+    "\n",
+    "for i in range(100):\n",
+    "    pos = predict(pos, process_model)\n",
+    "\n",
+    "    z = math.sin(i/3.)*2 + randn()*1.2\n",
+    "    zs.append(z)\n",
+    "    \n",
+    "    pos = update(pos, (z, sensor_var))\n",
+    "    ps.append(pos[0])\n",
+    "\n",
+    "plt.plot(zs, c='r', linestyle='dashed', label='measurement')\n",
+    "plt.plot(ps, c='#004080', label='filter')\n",
+    "plt.legend(loc='best');"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Discussion\n",
+    "\n",
+    "This is terrible! The output is not at all like a sin wave, except in the grossest way. With linear systems we could add extreme amounts of noise to our signal and still extract a very accurate result, but here even modest noise creates a very bad result.\n",
+    "\n",
+    "If we recall the **g-h Filter** chapter we can understand what is happening here. The structure of the g-h filter requires that the filter output chooses a value part way between the prediction and measurement. A varying signal like this one is always accelerating, whereas our process model assumes constant velocity, so the filter is mathematically guaranteed to always lag the input signal. \n",
+    "\n",
+    "Very shortly after practitioners began implementing Kalman filters they recognized the poor performance of them for nonlinear systems and began devising ways of dealing with it. Later chapters are devoted to this problem."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Fixed Gain Filters\n",
+    "\n",
+    "Embedded computers usually have extremely limited processors. Many do not have floating point circuitry. These simple equations can impose a heavy burden on the chip. This is less true as technology advances, but do not underestimate the value of spending one dollar less on a processor when you will be buying millions of them.\n",
+    "\n",
+    "In the example above the variance of the filter converged to a fixed value. This will always happen if the variance of the measurement and process is a constant. You can take advantage of this fact by running simulations to determine what the variance converges to. Then you can hard code this value into your filter. So long as you initialize the filter to a good starting guess (I recommend using the first measurement as your initial value) the filter will perform very well. For example, the dog tracking filter can be reduced to this:\n",
+    "\n",
+    "```python\n",
+    "def update(x, z):\n",
+    "    K = .13232  # experimentally derived Kalman gain\n",
+    "    y = z - x   # residual\n",
+    "    x = x + K*y # posterior\n",
+    "    return x\n",
+    "    \n",
+    "def predict(x):\n",
+    "    return x + vel*dt\n",
+    "```\n",
+    "\n",
+    "I used the Kalman gain form of the update function to emphasize that we do not need to consider the variances at all. If the variances converge to a single value so does the Kalman gain. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## FilterPy's Implementation\n",
+    "\n",
+    "FilterPy implements `predict()` and `update()`.  They work not only for the univariate case developed in this chapter, but the more general multivariate case that we learn in subsequent chapters. Because of this their interface is slightly different. They do not take Gaussians as tuples, but as two separately named variables.\n",
+    "\n",
+    "`predict()` takes several arguments, but we will only need to use these four:\n",
+    "\n",
+    "```python\n",
+    "predict(x, P, u, Q)\n",
+    "```\n",
+    "\n",
+    "`x` is the state of the system. `P` is the variance of the system. `u` is the movement due to the process, and `Q` is the noise in the process. You will need to used named arguments when you call `predict()` because most of the arguments are optional. The third argument to `predict()` is **not** `u`.\n",
+    "\n",
+    "These may strike you as terrible names. They are! As I already mentioned they come from a long history of control theory, and every paper or book you read will use these names. So, we just have to get used to it. Refusing to memorize them means you will never be able to read the literature.\n",
+    "\n",
+    "Let's try it for the state $\\mathcal N(10, 3)$ and the movement $\\mathcal N(1, 4)$. We'd expect a final position of 11 (10+1) with a variance of 7 (3+4)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(11, 7.000)"
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import filterpy.kalman as kf\n",
+    "kf.predict(x=10, P=3., u=1, Q=4)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`update` also takes several arguments, but for now you will be interested in these four:\n",
+    " \n",
+    "```python\n",
+    "update(x, P, z, R)\n",
+    "```\n",
+    " \n",
+    "As before, `x` and `P` are the state and variance of the system. `z` is the measurement, and `R` is the measurement variance. Let's perform the last predict statement to get our prior, and then perform an update:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(11.364, 4.455)"
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "x, P = kf.predict(x=10, P=3., u=1, Q=2**2)\n",
+    "x, P = kf.update(x=x, P=P, z=12, R=3.5**2)\n",
+    "x, P"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "I gave it a noisy measurement with a big variance, so the estimate remained close to the prior of 11.\n",
+    "\n",
+    "One final point. I did not use the variable name `prior` for the output of the predict step. I will not use that variable name in the rest of the book. The Kalman filter equations just use $\\mathbf x$. Both the prior and the posterior are the estimated state of the system, the former is the estimate before the measurement is incorporated, and the latter is after the measurement has been incorporated."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Summary\n",
+    "\n",
+    "The Kalman filter that we describe in this chapter is a special, restricted case of the more general filter we will learn next. Most texts do not discuss this one dimensional form. However, I think it is a vital stepping stone. We started the book with the g-h filter, then implemented the discrete Bayes filter, and now implemented the one dimensional Kalman filter. I have tried to show you that each of these filters use the same algorithm and reasoning. The mathematics of the Kalman filter that we will learn shortly is fairly sophisticated, and it can be difficult to understand the underlying simplicity of the filter. That sophistication comes with significant benefits: the generalized filter will markedly outperform the filters in this chapter.\n",
+    "\n",
+    "This chapter takes time to assimilate. To truly understand it you will probably have to work through this chapter several times. I encourage you to change the various constants in the code and observe the results. Convince yourself that Gaussians are a good representation of a unimodal belief of  the position of a dog in a hallway, the position of an aircraft in the sky, or the temperature of a chemical reaction chamber. Then convince yourself that multiplying Gaussians truly does compute a new belief from your prior belief and the new measurement. Finally, convince yourself that if you are measuring movement, that adding the Gaussians together updates your belief. \n",
+    "\n",
+    "Most of all, spend enough time with the **Full Description of the Algorithm** section to ensure you understand the algorithm and how it relates to the g-h filter and discrete Bayes filter. There is just one 'trick' here - selecting a value somewhere between a prediction and a measurement. Each algorithm performs that trick with different math, but all use the same logic."
+   ]
+  }
+ ],
+ "metadata": {
+  "anaconda-cloud": {},
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.6.3"
+  },
+  "widgets": {
+   "state": {
+    "58ed37dc23fe44cc9a0e20ffc9c47414": {
+     "views": [
+      {
+       "cell_index": 79
+      }
+     ]
+    },
+    "8b8fb12fbc4048a0af7d29dfc57d5fb9": {
+     "views": [
+      {
+       "cell_index": 29
+      }
+     ]
+    },
+    "ec6802d3ecf14e67bbcf34b40aa0e3c4": {
+     "views": [
+      {
+       "cell_index": 77
+      }
+     ]
+    }
+   },
+   "version": "1.2.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}