14_assg_learner..ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "-----\n",
    "\n",
    "In this assignment you will recursively estimate the position of a vehicle along a trajectory using available measurements and a motion model. \n",
    "\n",
    "The vehicle is equipped with a very simple type of LIDAR sensor, which returns range and bearing measurements corresponding to individual landmarks in the environment. The global positions of the landmarks are assumed to be known beforehand. We will also assume known data association, that is, which measurment belong to which landmark.\n",
    "\n",
    "## Motion and Measurement Models\n",
    "-----\n",
    "\n",
    "### Motion Model\n",
    "\n",
    "The vehicle motion model recieves linear and angular velocity odometry readings as inputs, and outputs the state (i.e., the 2D pose) of the vehicle:\n",
    "\n",
    "\\begin{align}\n",
    "\\mathbf{x}_{k} &= \\mathbf{x}_{k-1} + T\n",
    "\\begin{bmatrix}\n",
    "\\cos\\theta_{k-1} &0 \\\\\n",
    "\\sin\\theta_{k-1} &0 \\\\\n",
    "0 &1\n",
    "\\end{bmatrix}\n",
    "\\left(\n",
    "\\begin{bmatrix}\n",
    "v_k \\\\\n",
    "\\omega_k\n",
    "\\end{bmatrix}\n",
    "+ \\mathbf{w}_k\n",
    "\\right)\n",
    "\\, , \\, \\, \\, \\, \\, \\mathbf{w}_k = \\mathcal{N}\\left(\\mathbf{0}, \\mathbf{Q}\\right)\n",
    "\\end{align}\n",
    "\n",
    "- $\\mathbf{x}_k = \\left[ x \\, y \\, \\theta \\right]^T$ is the current 2D pose of the vehicle\n",
    "- $v_k$ and $\\omega_k$ are the linear and angular velocity odometry readings, which we use as inputs to the model\n",
    "\n",
    "The process noise $\\mathbf{w}_k$ has a (zero mean) normal distribution with a constant covariance $\\mathbf{Q}$.\n",
    "\n",
    "### Measurement Model\n",
    "\n",
    "The measurement model relates the current pose of the vehicle to the LIDAR range and bearing measurements $\\mathbf{y}^l_k = \\left[r \\, \\phi \\right]^T$.\n",
    "\n",
    "\\begin{align}\n",
    "\\mathbf{y}^l_k =\n",
    "\\begin{bmatrix}\n",
    "\\sqrt{(x_l - x_k - d\\cos\\theta_{k})^2 + (y_l - y_k - d\\sin\\theta_{k})^2} \\\\\n",
    "atan2\\left(y_l - y_k - d\\sin\\theta_{k},x_l - x_k - d\\cos\\theta_{k}\\right) - \\theta_k\n",
    "\\end{bmatrix}\n",
    "+\n",
    "\\mathbf{n}^l_k\n",
    "\\, , \\, \\, \\, \\, \\, \\mathbf{n}^l_k = \\mathcal{N}\\left(\\mathbf{0}, \\mathbf{R}\\right)\n",
    "\\end{align}\n",
    "\n",
    "- $x_l$ and $y_l$ are the ground truth coordinates of the landmark $l$\n",
    "- $x_k$ and $y_k$ and $\\theta_{k}$ represent the current pose of the vehicle\n",
    "- $d$ is the known distance between robot center and laser rangefinder (LIDAR)\n",
    "\n",
    "The landmark measurement noise $\\mathbf{n}^l_k$ has a (zero mean) normal distribution with a constant covariance $\\mathbf{R}$.\n",
    "\n",
    "## Getting Started\n",
    "-----\n",
    "\n",
    "Since the models above are nonlinear, we recommend using the extended Kalman filter (EKF) as the state estimator.\n",
    "Specifically, you will need to provide code implementing the following steps:\n",
    "- the prediction step, which uses odometry measurements and the motion model to produce a state and covariance estimate at a given timestep, and\n",
    "- the correction step, which uses the range and bearing measurements provided by the LIDAR to correct the pose and pose covariance estimates\n",
    "\n",
    "### Unpack the Data\n",
    "First, let's unpack the available data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "with open('data/data.pickle', 'rb') as f:\n",
    "    data = pickle.load(f)\n",
    "\n",
    "t = data['t']  # timestamps [s]\n",
    "\n",
    "x_init  = data['x_init'] # initial x position [m]\n",
    "y_init  = data['y_init'] # initial y position [m]\n",
    "th_init = data['th_init'] # initial theta position [rad]\n",
    "\n",
    "# input signal\n",
    "v  = data['v']  # translational velocity input [m/s]\n",
    "om = data['om']  # rotational velocity input [rad/s]\n",
    "\n",
    "# bearing and range measurements, LIDAR constants\n",
    "b = data['b']  # bearing to each landmarks center in the frame attached to the laser [rad]\n",
    "r = data['r']  # range measurements [m]\n",
    "l = data['l']  # x,y positions of landmarks [m]\n",
    "d = data['d']  # distance between robot center and laser rangefinder [m]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_init.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_init.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "th_init.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(501,)\n",
      "501\n"
     ]
    }
   ],
   "source": [
    "print(v.shape)\n",
    "print(len(v))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(501,)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "om.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(501, 8)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(501, 8)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8, 2)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1,)\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "print(d.shape)\n",
    "print(d[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that distance from the LIDAR frame to the robot center is provided and loaded as an array into the `d` variable.\n",
    "\n",
    "### Ground Truth\n",
    "If available, it is useful to plot the ground truth position and orientation before starting the assignment.\n",
    "\n",
    "<table><tr>\n",
    "<td> <img src=\"data/gtruth.png\" alt=\"Ground Truth\" width=\"350\"/> </td>\n",
    "<td> <img src=\"data/gtruth2.png\" alt=\"Ground Truth\" width=\"350\"/> </td>\n",
    "</tr></table>\n",
    "\n",
    "Notice that the orientation values are wrapped to the $\\left[-\\pi,\\pi\\right]$ range in radians."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initializing Parameters\n",
    "\n",
    "Now that our data is loaded, we can begin getting things set up for our solver. One of the\n",
    "most important aspects of designing a filter is determining the input and measurement noise covariance matrices, as well as the initial state and covariance values. We set the values here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "v_var = 0.01  # translation velocity variance  \n",
    "om_var = 0.01  # rotational velocity variance \n",
    "# allowed to tune these values\n",
    "# r_var = 0.1  # range measurements variance\n",
    "r_var = 0.01\n",
    "# b_var = 0.1  # bearing measurement variance\n",
    "b_var = 10\n",
    "\n",
    "Q_km = np.diag([v_var, om_var]) # input noise covariance \n",
    "cov_y = np.diag([r_var, b_var])  # measurement noise covariance \n",
    "\n",
    "x_est = np.zeros([len(v), 3])  # estimated states, x, y, and theta\n",
    "P_est = np.zeros([len(v), 3, 3])  # state covariance matrices\n",
    "\n",
    "x_est[0] = np.array([x_init, y_init, th_init]) # initial state\n",
    "P_est[0] = np.diag([1, 1, 0.1]) # initial state covariance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 2)\n",
      "[[0.01 0.  ]\n",
      " [0.   0.01]]\n"
     ]
    }
   ],
   "source": [
    "print(Q_km.shape)\n",
    "print(Q_km)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 2)\n",
      "[[ 0.01  0.  ]\n",
      " [ 0.   10.  ]]\n"
     ]
    }
   ],
   "source": [
    "print(cov_y.shape)\n",
    "print(cov_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(501, 3)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_est.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(501, 3, 3)\n",
      "[[1.  0.  0. ]\n",
      " [0.  1.  0. ]\n",
      " [0.  0.  0.1]]\n",
      "[[0. 0. 0.]\n",
      " [0. 0. 0.]\n",
      " [0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "print(P_est.shape)\n",
    "print(P_est[0])\n",
    "print(P_est[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Wraps angle to (-pi,pi] range\n",
    "def wraptopi(x):\n",
    "#     x = ((x / np.pi + 1) % 2 - 1) * np.pi\n",
    "    if x > np.pi:\n",
    "        x = x - (np.floor(x / (2 * np.pi)) + 1) * 2 * np.pi\n",
    "    elif x < -np.pi:\n",
    "        x = x + (np.floor(x / (-2 * np.pi)) + 1) * 2 * np.pi\n",
    "    return np.array(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Correction Step\n",
    "-----\n",
    "First, let's implement the measurement update function, which takes an available landmark measurement $l$ and updates the current state estimate $\\mathbf{\\check{x}}_k$.\n",
    "For each landmark measurement received at a given timestep $k$, you should implement the following steps:\n",
    "\n",
    "- Compute the measurement model Jacobians at $\\mathbf{\\check{x}}_{k}$\n",
    "\\begin{align}\n",
    "\\mathbf{y}^l_k = &\\mathbf{h}(\\mathbf{x}_{k}, \\mathbf{n}^l_k) \\\\\\\\\n",
    "\\mathbf{H}_{k} = \\frac{\\partial \\mathbf{h}}{\\partial \\mathbf{x}_{k}}\\bigg|_{\\mathbf{\\check{x}}_{k},0}& \\, , \\, \\, \\, \\,\n",
    "\\mathbf{M}_{k} = \\frac{\\partial \\mathbf{h}}{\\partial \\mathbf{n}_{k}}\\bigg|_{\\mathbf{\\check{x}}_{k},0} \\, .\n",
    "\\end{align}\n",
    "- Compute the Kalman Gain\n",
    "\\begin{align}\n",
    "\\mathbf{K}_k &= \\mathbf{\\check{P}}_k \\mathbf{H}_k^T \\left(\\mathbf{H}_k \\mathbf{\\check{P}}_k \\mathbf{H}_k^T + \\mathbf{M}_k \\mathbf{R}_k \\mathbf{M}_k^T \\right)^{-1} \n",
    "\\end{align}\n",
    "- Correct the predicted state\n",
    "\\begin{align}\n",
    "\\mathbf{\\check{y}}^l_k &= \\mathbf{h}\\left(\\mathbf{\\check{x}}_k, \\mathbf{0}\\right) \\\\\n",
    "\\mathbf{\\hat{x}}_k &= \\mathbf{\\check{x}}_k + \\mathbf{K}_k \\left(\\mathbf{y}^l_k - \\mathbf{\\check{y}}^l_k\\right)\n",
    "\\end{align}\n",
    "- Correct the covariance\n",
    "\\begin{align}\n",
    "\\mathbf{\\hat{P}}_k &= \\left(\\mathbf{I} - \\mathbf{K}_k \\mathbf{H}_k \\right)\\mathbf{\\check{P}}_k\n",
    "\\end{align}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def measurement_update(lk, rk, bk, P_check, x_check):\n",
    "\n",
    "    x_k = x_check[0]\n",
    "    y_k = x_check[1]\n",
    "    theta_k = wraptopi(x_check[2])\n",
    "    \n",
    "    x_l = lk[0]\n",
    "    y_l = lk[1]\n",
    "    \n",
    "    d_x = x_l - x_k - d*np.cos(theta_k)\n",
    "    d_y = y_l - y_k - d*np.sin(theta_k)\n",
    "    \n",
    "    r = np.sqrt(d_x**2 + d_y**2)\n",
    "    phi = np.arctan2(d_y, d_x) - theta_k\n",
    "    \n",
    "    # 1. Compute measurement Jacobian\n",
    "    H_k = np.zeros((2,3))\n",
    "    H_k[0,0] = -d_x/r\n",
    "    H_k[0,1] = -d_y/r\n",
    "    H_k[0,2] = d*(d_x*np.sin(theta_k) - d_y*np.cos(theta_k))/r\n",
    "    H_k[1,0] = d_y/r**2\n",
    "    H_k[1,1] = -d_x/r**2\n",
    "    H_k[1,2] = -1-d*(d_y*np.sin(theta_k) + d_x*np.cos(theta_k))/r**2\n",
    "    \n",
    "    M_k = np.identity(2)\n",
    "    \n",
    "    y_out = np.vstack([r, wraptopi(phi)])\n",
    "    y_mes = np.vstack([rk, wraptopi(bk)])\n",
    "\n",
    "    # 2. Compute Kalman Gain\n",
    "    K_k = P_check.dot(H_k.T).dot(np.linalg.inv(H_k.dot(P_check).dot(H_k.T) + M_k.dot(cov_y).dot(M_k.T)))\n",
    "\n",
    "    # 3. Correct predicted state (remember to wrap the angles to [-pi,pi])\n",
    "    x_check = x_check + K_k.dot(y_mes - y_out)\n",
    "    x_check[2] = wraptopi(x_check[2])\n",
    "\n",
    "    # 4. Correct covariance\n",
    "    P_check = (np.identity(3) - K_k.dot(H_k)).dot(P_check)\n",
    "\n",
    "    return x_check, P_check"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prediction Step\n",
    "-----\n",
    "Now, implement the main filter loop, defining the prediction step of the EKF using the motion model provided:\n",
    "\n",
    "\\begin{align}\n",
    "\\mathbf{\\check{x}}_k &= \\mathbf{f}\\left(\\mathbf{\\hat{x}}_{k-1}, \\mathbf{u}_{k-1}, \\mathbf{0} \\right) \\\\\n",
    "\\mathbf{\\check{P}}_k &= \\mathbf{F}_{k-1}\\mathbf{\\hat{P}}_{k-1}\\mathbf{F}_{k-1}^T + \\mathbf{L}_{k-1}\\mathbf{Q}_{k-1}\\mathbf{L}_{k-1}^T \\, .\n",
    "\\end{align}\n",
    "\n",
    "Where\n",
    "\n",
    "\\begin{align}\n",
    "\\mathbf{F}_{k-1} = \\frac{\\partial \\mathbf{f}}{\\partial \\mathbf{x}_{k-1}}\\bigg|_{\\mathbf{\\hat{x}}_{k-1},\\mathbf{u}_{k},0}  \\, , \\, \\, \\, \\,\n",
    "\\mathbf{L}_{k-1} = \\frac{\\partial \\mathbf{f}}{\\partial \\mathbf{w}_{k}}\\bigg|_{\\mathbf{\\hat{x}}_{k-1},\\mathbf{u}_{k},0} \\, .\n",
    "\\end{align}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### 5. Main Filter Loop #######################################################################\n",
    "# set the initial values\n",
    "P_check = P_est[0]\n",
    "x_check = x_est[0, :].reshape(3,1)\n",
    "for k in range(1, len(t)):  # start at 1 because we've set the initial prediciton\n",
    "\n",
    "    delta_t = t[k] - t[k - 1]  # time step (difference between timestamps)\n",
    "    theta = wraptopi(x_check[2])\n",
    "\n",
    "    # 1. Update state with odometry readings (remember to wrap the angles to [-pi,pi])\n",
    "#     x_check = np.zeros(3)\n",
    "    F = np.array([[np.cos(theta), 0],\n",
    "                  [np.sin(theta), 0],\n",
    "                  [0, 1]], dtype='float')\n",
    "    inp = np.array([[v[k-1]], [om[k-1]]])\n",
    "\n",
    "    x_check = x_check + F.dot(inp).dot(delta_t)\n",
    "    x_check[2] = wraptopi(x_check[2])\n",
    "\n",
    "    # 2. Motion model jacobian with respect to last state\n",
    "    F_km = np.zeros([3, 3])\n",
    "    F_km = np.array([[1, 0, -np.sin(theta)*delta_t*v[k-1]],\n",
    "                     [0, 1, np.cos(theta)*delta_t*v[k-1]],\n",
    "                     [0, 0, 1]], dtype='float')\n",
    "    # dtype='float'\n",
    "    # 3. Motion model jacobian with respect to noise\n",
    "    L_km = np.zeros([3, 2])\n",
    "    L_km = np.array([[np.cos(theta)*delta_t, 0], \n",
    "                    [np.sin(theta)*delta_t, 0],\n",
    "                    [0,1]], dtype='float')\n",
    "\n",
    "    # 4. Propagate uncertainty\n",
    "    P_check = F_km.dot(P_check.dot(F_km.T)) + L_km.dot(Q_km.dot(L_km.T)) \n",
    "\n",
    "    # 5. Update state estimate using available landmark measurements\n",
    "    for i in range(len(r[k])):\n",
    "        x_check, P_check = measurement_update(l[i], r[k, i], b[k, i], P_check, x_check)\n",
    "\n",
    "    # Set final state predictions for timestep\n",
    "    x_est[k, 0] = x_check[0]\n",
    "    x_est[k, 1] = x_check[1]\n",
    "    x_est[k, 2] = x_check[2]\n",
    "    P_est[k, :, :] = P_check"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's plot the resulting state estimates:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "e_fig = plt.figure()\n",
    "ax = e_fig.add_subplot(111)\n",
    "ax.plot(x_est[:, 0], x_est[:, 1])\n",
    "ax.set_xlabel('x [m]')\n",
    "ax.set_ylabel('y [m]')\n",
    "ax.set_title('Estimated trajectory')\n",
    "plt.show()\n",
    "\n",
    "e_fig = plt.figure()\n",
    "ax = e_fig.add_subplot(111)\n",
    "ax.plot(t[:], x_est[:, 2])\n",
    "ax.set_xlabel('Time [s]')\n",
    "ax.set_ylabel('theta [rad]')\n",
    "ax.set_title('Estimated trajectory')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Are you satisfied wth your results? The resulting trajectory should closely resemble the ground truth, with minor \"jumps\" in the orientation estimate due to angle wrapping. If this is the case, run the code below to produce your solution file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "with open('submission.pkl', 'wb') as f:\n",
    "    pickle.dump(x_est, f, pickle.HIGHEST_PROTOCOL)"
   ]
  }
 ],
 "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}