EKF_v2.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": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sympy import *\n",
    "from math import cos,sin\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": "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": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "v_var = 0.01  # translation velocity variance  \n",
    "om_var = 0.01  # rotational velocity variance \n",
    "r_var = 0.1  # range measurements variance\n",
    "b_var = 0.1  # bearing measurement variance\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": "markdown",
   "metadata": {},
   "source": [
    "**Remember:** that it is neccessary to tune the measurement noise variances `r_var`, `b_var` in order for the filter to perform well!\n",
    "\n",
    "In order for the orientation estimates to coincide with the bearing measurements, it is also neccessary to wrap all estimated $\\theta$ values to the $(-\\pi , \\pi]$ range."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Wraps angle to (-pi,pi] range\n",
    "def wraptopi(x):\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 x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.1, 0. ],\n",
       "       [0. , 0.1]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cov_y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEgAAAAVCAYAAADl/ahuAAAABHNCSVQICAgIfAhkiAAAAlpJREFUWIXt2MtvTVEUBvCfEqlUUq9QJkTEIyGeaTrwGHhOTPgHJGJoIiZiwIR4jBkYiTFBDCQVkQhCJCoiTHQgTRCPUgZFUIN1yslpz+09p729Df2Sm32z9l5rfXvdtdbe+zKOUriAt2iqN5FRwFr0YW+1CuvwCwcy8pO4iS70ohsdOIKZI8F0BFGU62W8xtTsxIRBFrejFXMT4/34jkd45m92tYmAvkq+d5XZTQ1QlGsrHuAwjlcyvFhkz7lB5hpzdI6JFD1bNf3aowzX53iJiZUMn0gMbC5AZmWic6OATr1QieuRZG57WtiQWbQFP3G/gNOdyfikgE69UInr3WTcmhame1ATekSqrajg5KBoZs2iptcnDrfgXWHKtUURrs34hIeiJw3AYpFi7UM4fZOs6/9cx5xS9GuPolx7E50/SJdY//H3cQinLSLzWrALC8URuqZa1qOIoly7MSvP2CoR5asFSczHNzwtqFcPDMW1G1/ylOeJAN0p4bgj0c2N/hhCHtcGccXpzAr78Vo0riUlnM5Lxp8ldEcbeVyXiHJ8nBamA9SH2yKyizLKS0UdZ9EgLl+zcc/A/nU+sbunGuYjhLJc25LxVlo4KbPoEnaLy9KLlHwHTosAduKDOA02icb3BvtySMGPvN3UAGW5bhNZVbEHT04MPMjIl+OMSL/3YsM94s5wFDNy7HXgM6ZX3NLIogzXZnHEX6nGwSFRFquHSXSa+EVODdPOaGC/2POGahY3ikfbtWE63YmvBu8HYwlTxAv/YhGljeLx9j/8YbZMlN6C+tIYx7+J39odm8PeUogfAAAAAElFTkSuQmCC\n",
      "text/latex": [
       "$$\\left ( 3, \\quad 3\\right )$$"
      ],
      "text/plain": [
       "(3, 3)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#from sympy import diff, symbols\n",
    "from sympy import *\n",
    "init_printing(use_unicode=True)\n",
    "x, y, z =symbols('x y z')\n",
    "f= x*cos(y)\n",
    "f_dash=diff(f,y)\n",
    "f_dash\n",
    "\n",
    "P_est[0,:,:].shape\n",
    "\n"
   ]
  },
  {
   "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,k):\n",
    "    #from sympy import *\n",
    "    #xl, yl, xk, yk, theta_k = symbols('xl yl xk yk theta_k')\n",
    "    from math import atan2,sin,cos\n",
    "    xl, yl = lk\n",
    "    #print(x_check.shape)\n",
    "    xk, yk, theta_k = x_check\n",
    "    D = d[0]\n",
    "    theta_k = wraptopi(theta_k)\n",
    "    #print(x_check)\n",
    "#   print(k)\n",
    "    del_x = xl-xk-D*cos(theta_k)\n",
    "    del_y = yl-yk-D*sin(theta_k)\n",
    "     \n",
    "    y_lk = np.array([[rk],[bk]])\n",
    "    \n",
    "    # 1. Compute measurement Jacobian\n",
    "    \n",
    "    root_q = ((del_x)**2 + (del_y)**2)**0.5\n",
    "    q = (del_x)**2 + (del_y)**2\n",
    "    phi = atan2(del_y,del_x)-theta_k\n",
    "    \n",
    "    H_k = np.array([[-root_q*del_x/q, -root_q*del_y/q, D*(del_x*sin(theta_k) - del_y*cos(theta_k))/root_q],\n",
    "                    [ del_y/q, -del_x/q, -1-D*(del_y*sin(theta_k) + del_x*cos(theta_k))/1]])\n",
    "    \n",
    "    # 2. Compute Kalman Gain\n",
    "    \n",
    "    G = np.dot(np.dot(H_k,P_check), H_k.T) + cov_y\n",
    "    G_inv = np.linalg.inv(G)\n",
    "    K_k = np.dot(np.dot(P_check, H_k.T), G_inv)\n",
    "    \n",
    "    # 3. Correct predicted state (remember to wrap the angles to [-pi,pi])\n",
    "    \n",
    "    y_lk_cap = np.array([[root_q],[wraptopi(phi)]])\n",
    "    delta = y_lk-y_lk_cap\n",
    "    x_check = x_check + (np.dot(K_k, delta)).reshape(3)\n",
    "    x_check[2]= wraptopi(x_check[2])\n",
    "    #print(x_check)\n",
    "    # 4. Correct covariance\n",
    "    \n",
    "    I = np.identity(3)\n",
    "    P_check = np.dot((I-np.dot(K_k,H_k)),P_check)\n",
    "\n",
    "    return x_check, P_check\n"
   ]
  },
  {
   "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": [
    {
     "ename": "TypeError",
     "evalue": "Object arrays are not currently supported",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-18-a70fc1e51ba9>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     23\u001b[0m     \u001b[0;31m# 4. Propagate uncertainty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     24\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 25\u001b[0;31m     \u001b[0mP_check\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mF_km\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mP_est\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mF_km\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mT\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mL_km\u001b[0m \u001b[0;34m@\u001b[0m \u001b[0mQ_km\u001b[0m \u001b[0;34m@\u001b[0m \u001b[0mL_km\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mT\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     26\u001b[0m \u001b[0;31m#     print(x_check)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     27\u001b[0m     \u001b[0;31m# 5. Update state estimate using available landmark measurements\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: Object arrays are not currently supported"
     ]
    }
   ],
   "source": [
    "#### 5. Main Filter Loop #######################################################################\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",
    "\n",
    "    # 1. Update state with odometry readings (remember to wrap the angles to [-pi,pi])\n",
    "    x_check = np.zeros(3)\n",
    "    \n",
    "    th = wraptopi(x_est[k-1,2])\n",
    "    state = delta_t*np.array([v[k]*cos(th),v[k]*sin(th),om[k]])\n",
    "    x_check = x_est[k-1] + state\n",
    "#     print(x_check)\n",
    "    # 2. Motion model jacobian with respect to last state\n",
    "    \n",
    "    F_km = np.zeros([3, 3])\n",
    "    F_km = np.array([[1,0, -v[k]*sin(th)], [0,1,v[k]*cos(th)], [0,0,1]])\n",
    "\n",
    "    # 3. Motion model jacobian with respect to noise\n",
    "    \n",
    "    L_km = np.zeros([3, 2])\n",
    "    L_km = np.array([[cos(th),0],[sin(th),0],[0,1]])\n",
    "    \n",
    "    # 4. Propagate uncertainty\n",
    "    \n",
    "    P_check = np.dot(np.dot(F_km,P_est[0]),F_km.T) + L_km @ Q_km @ L_km.T\n",
    "#     print(x_check)\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,k)\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] = wraptopi(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": null,
   "metadata": {},
   "outputs": [],
   "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": {},
   "outputs": [],
   "source": [
    "with open('submission.pkl', 'wb') as f:\n",
    "    pickle.dump(x_est, f, pickle.HIGHEST_PROTOCOL)"
   ]
  },
  {
   "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}