1. 1D Kalman Filter, exercise.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1D Kalman Filter\n",
    "\n",
    "Now, you're ready to implement a 1D Kalman Filter by putting all these steps together. Let's take the case of a robot that moves through the world. As a robot moves through the world it locates itself by performing a cycle of:\n",
    "1. sensing and performing a measurement update and\n",
    "2. moving and performing a motion update\n",
    "\n",
    "You've programmed each of these steps individually, so now let's combine them in a cycle!\n",
    "\n",
    "After implementing this filter, you should see that you can go from a very uncertain location Gaussian to a more and more certain Gaussian, as pictured below. The code in this notebooks is really just a simplified version of the Kalman filter that runs in the Google self-driving car that is used to track surrounding vehicles and other objects.\n",
    "\n",
    "<img src='images/gaussian_updates.png' height=70% width=70% />\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below is our usual Gaussian equation and imports."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import math functions\n",
    "from math import *\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "# gaussian function\n",
    "def f(mu, sigma2, x):\n",
    "    ''' f takes in a mean and squared variance, and an input x\n",
    "       and returns the gaussian value.'''\n",
    "    coefficient = 1.0 / sqrt(2.0 * pi *sigma2)\n",
    "    exponential = exp(-0.5 * (x-mu) ** 2 / sigma2)\n",
    "    return coefficient * exponential\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You've also been given the complete `update` code that performs a parameter update when an initial belief and new measurement information are merged. And the complete `predict` code that performs an update to a Gasuuain after a motion is incorporated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the update function\n",
    "def update(mean1, var1, mean2, var2):\n",
    "    ''' This function takes in two means and two squared variance terms,\n",
    "        and returns updated gaussian parameters.'''\n",
    "    # Calculate the new parameters\n",
    "    new_mean = (var2*mean1 + var1*mean2)/(var2+var1)\n",
    "    new_var = 1/(1/var2 + 1/var1)\n",
    "    \n",
    "    return [new_mean, new_var]\n",
    "\n",
    "\n",
    "# the motion update/predict function\n",
    "def predict(mean1, var1, mean2, var2):\n",
    "    ''' This function takes in two means and two squared variance terms,\n",
    "        and returns updated gaussian parameters, after motion.'''\n",
    "    # Calculate the new parameters\n",
    "    new_mean = mean1 + mean2\n",
    "    new_var = var1 + var2\n",
    "    \n",
    "    return [new_mean, new_var]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### QUIZ: For the given measurements and motions, write complete 1D Kalman filter code that loops through all of these in order.\n",
    "\n",
    "Your complete code should look at sensor measurements then motions in that sequence until all updates are done!\n",
    "\n",
    "### Initial Uncertainty\n",
    "\n",
    "You'll see that you are given initial parameters below, and this includes and nitial location estimation, `mu` and squared variance, `sig`. Note that the initial estimate is set to the location 0, and the variance is extremely large; this is a state of high confusion much like the *uniform* distribution we used in the histogram filter. There are also values given for the squared variance associated with the sensor measurements and the motion, since neither of those readings are perfect, either.\n",
    "\n",
    "You should see that even though the initial estimate for location (the initial `mu`) is far from the first measurement, it should catch up fairly quickly as you cycle through measurements and motions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Update: [1.24999999996875e-10, 9.99999999975e-11]\n",
      "Predict: [1.000000000125, 2.0000000001]\n",
      "Update: [2.6666666668055554, 1.3333333333777777]\n",
      "Predict: [3.6666666668055554, 3.3333333333777775]\n",
      "Update: [5.1818181819049585, 1.8181818181950413]\n",
      "Predict: [7.1818181819049585, 3.8181818181950415]\n",
      "Update: [8.069767441906436, 1.9534883720964848]\n",
      "Predict: [9.069767441906436, 3.953488372096485]\n",
      "Update: [9.532163742713381, 1.9883040935681267]\n",
      "Predict: [10.532163742713381, 3.988304093568127]\n",
      "\n",
      "\n",
      "Final result: [10.532163742713381, 3.988304093568127]\n"
     ]
    }
   ],
   "source": [
    "# measurements for mu and motions, U\n",
    "measurements = [5., 6., 7., 9., 10.]\n",
    "motions = [1., 1., 2., 1., 1.]\n",
    "\n",
    "# initial parameters\n",
    "measurement_sig = 4.\n",
    "motion_sig = 2.\n",
    "mu = 0.\n",
    "sig = 0.0000000001  \n",
    "\n",
    "## TODO: Loop through all measurements/motions\n",
    "## Print out and display the resulting Gaussian \n",
    "\n",
    "# your code here\n",
    "for i in range(len(measurements)):\n",
    "    # measurement update, with uncertainty\n",
    "    mu, sig = update(mu, sig, measurements[i], measurement_sig)\n",
    "    print('Update: [{}, {}]'.format(mu, sig))\n",
    "    # motion update, with uncertainty\n",
    "    mu, sig = predict(mu, sig, motions[i], motion_sig)\n",
    "    print('Predict: [{}, {}]'.format(mu, sig))\n",
    "\n",
    "    \n",
    "# print the final, resultant mu, sig\n",
    "print('\\n')\n",
    "print('Final result: [{}, {}]'.format(mu, sig))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot a Gaussian\n",
    "\n",
    "Plot a Gaussian by looping through a range of x values and creating a resulting list of Gaussian values, `g`, as shown below. You're encouraged to see what happens if you change the values of `mu` and `sigma2`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f7f05f674e0>]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f7f07f8f320>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# display the *initial* gaussian over a range of x values\n",
    "# define the parameters\n",
    "mu = mu\n",
    "sigma2 = sig\n",
    "\n",
    "# define a range of x values\n",
    "x_axis = np.arange(-20, 20, 0.1)\n",
    "\n",
    "# create a corresponding list of gaussian values\n",
    "g = []\n",
    "for x in x_axis:\n",
    "    g.append(f(mu, sigma2, x))\n",
    "\n",
    "# plot the result \n",
    "plt.plot(x_axis, g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}