3. Landmark Detection and Tracking using Offline GraphSLAM.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Implementing SLAM \n",
    "\n",
    "---\n",
    "\n",
    "## Overview\n",
    "\n",
    "In this project, I'll implement SLAM for robot that moves and senses in a 2 dimensional, grid world!\n",
    "\n",
    "SLAM gives us a way to both localize a robot and build up a map of its environment as a robot moves and senses in real-time. This is an active area of research in the fields of robotics and autonomous systems. Since this localization and map-building relies on the visual sensing of landmarks, this is a computer vision problem. \n",
    "\n",
    "Using knowledge of robot motion, representations of uncertainty in motion and sensing, and localization techniques, we will be tasked with defining a function, `slam`, which **takes in six parameters as input** and **returns the vector `mu`**. \n",
    "> `mu` contains the (x,y) coordinate locations of the robot as it moves, and the positions of landmarks that it senses in the world\n",
    "\n",
    "The vector, `mu`, has (x, y) coordinates interlaced, for example, if there were 2 poses and 2 landmarks, `mu` will look like the following, where `P` is the robot position and `L` the landmark position:\n",
    "```\n",
    "mu =  matrix([[Px0],\n",
    "              [Py0],\n",
    "              [Px1],\n",
    "              [Py1],\n",
    "              [Lx0],\n",
    "              [Ly0],\n",
    "              [Lx1],\n",
    "              [Ly1]])\n",
    "```\n",
    "\n",
    "`mu` holds the poses first `(x0, y0), (x1, y1), ...,` then the landmark locations at the end of the matrix; we consider a `nx1` matrix to be a vector.\n",
    "\n",
    "## Generating an environment\n",
    "\n",
    "In a real-world SLAM problem, we may be given a map that contains information about landmark locations, and in this example, we will make our own data using the `make_data` function, which generates a world grid with landmarks in it and then generates data by placing a robot in that world and moving and sensing over some number of time steps. The data is collected as an instantiated robot moves and senses in a world. The slam function will take in this data as input. So, let's first create this data and explore how it represents the movement and sensor measurements that our robot takes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create the world\n",
    "\n",
    "Run code below to generate a world of a specified size with randomly generated landmark locations. We can change these parameters and see how the implementation of SLAM responds! \n",
    "\n",
    "`data` **holds the sensors measurements and motion of the robot over time**. It stores the measurements as `data[i][0]` and the motion as `data[i][1]`.\n",
    "\n",
    "#### Helper functions\n",
    "\n",
    "We will be working with the `robot` class that we coded first notebook. In the `helpers.py` file, you can read the details of how data is made with the `make_data` function. It should look very similar to the robot move/sense cycle we've coded in the first notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " \n",
      "Landmarks:  [[4, 3], [46, 32], [38, 89], [53, 56], [24, 2]]\n",
      "Robot: [x=32.52361 y=10.32569]\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "from helpers import make_data\n",
    "\n",
    "np.random.seed(2)\n",
    "random.seed(2)\n",
    "# the implementation of slam should work with the following inputs\n",
    "# feel free to change these input values and see how it responds!\n",
    "\n",
    "# world parameters\n",
    "num_landmarks = 5  # number of landmarks\n",
    "N = 20  # time steps\n",
    "world_size = 100.0  # size of world (square)\n",
    "\n",
    "# robot parameters\n",
    "measurement_range = 50.0  # range at which we can sense landmarks\n",
    "motion_noise = 2.0  # noise in robot motion\n",
    "measurement_noise = 2.0  # noise in the measurements\n",
    "\n",
    "# distance by which robot (intends to) move each iteratation\n",
    "distance = 20.0\n",
    "\n",
    "# make_data instantiates a robot, AND generates random landmarks for a given world size and number of landmarks\n",
    "data = make_data(\n",
    "    N,\n",
    "    num_landmarks,\n",
    "    world_size,\n",
    "    measurement_range,\n",
    "    motion_noise,\n",
    "    measurement_noise,\n",
    "    distance,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A note on `make_data`\n",
    "\n",
    "The function above, `make_data`, takes in so many world and robot motion/sensor parameters because it is responsible for:\n",
    "1. Instantiating a robot (using the robot class)\n",
    "2. Creating a grid world with landmarks in it\n",
    "\n",
    "**This function also prints out the true location of landmarks and the *final* robot location, which we will refer back to when we test our implementation of SLAM.**\n",
    "\n",
    "The `data` this returns is an array that holds information about **robot sensor measurements** and **robot motion** `(dx, dy)` that is collected over a number of time steps, `N`. We will use ***only* these readings about motion and measurements to track a robot over time and find the determine the location of the landmarks using SLAM**. We only print out the true landmark locations for comparison, later.\n",
    "\n",
    "\n",
    "In `data` the measurement and motion data can be accessed from the first and second index in the columns of the data array. See the following code for an example, where `i` is the time step:\n",
    "```\n",
    "measurement = data[i][0]\n",
    "motion = data[i][1]\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Example measurements: \n",
      " [[0, 44.546789571945865, 47.040895383348804], [1, 5.9947342727702075, 18.69791878938348], [2, 10.727373987292577, 37.42571385366804], [3, 1.8129603143134418, 5.062393232424089], [4, 27.626374599590243, 49.05154193533228]]\n",
      "\n",
      "\n",
      "Example motion: \n",
      " [-9.095809661869826, 17.811969194758774]\n"
     ]
    }
   ],
   "source": [
    "# print out some stats about the data\n",
    "time_step = 0\n",
    "\n",
    "print(\"Example measurements: \\n\", data[time_step][0])\n",
    "print(\"\\n\")\n",
    "print(\"Example motion: \\n\", data[time_step][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try changing the value of `time_step`, we can see that the list of measurements varies based on what in the world the robot sees after it moves. As we saw in the first notebook, the robot can only sense so far and with a certain amount of accuracy in the measure of distance between its location and the location of landmarks. **The motion of the robot always is a vector with two values: one for x and one for y displacement**. This structure will be useful to keep in mind as we traverse this data when implementing the slam."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize Constraints\n",
    "\n",
    "One of the most challenging tasks here will be to create and modify the constraint matrix and vector: `omega` and `xi`. In the second notebook, we saw an example of how `omega` and `xi` could hold all the values the define the relationships between robot poses `xi` and landmark positions `Li` in a 1D world, as seen below, where omega is the blue matrix and xi is the pink vector.\n",
    "\n",
    "<img src='images/motion_constraint.png' width=50% height=50% />\n",
    "\n",
    "\n",
    "In this section, we will implement constraints for a 2D world. We are referring to robot poses as `Px, Py` and landmark positions as `Lx, Ly`, and one way to approach this challenge is to add *both* x and y locations in the constraint matrices.\n",
    "\n",
    "<img src='images/constraints2D.png' width=50% height=50% />\n",
    "\n",
    "Another approach to choose is to create two of each omega and xi (one for x and one for y positions)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Writing a function that initializes omega and xi\n",
    "\n",
    "Complete the function `initialize_constraints` so that it returns `omega` and `xi` constraints for the starting position of the robot. Any values that we do not yet know should be initialized with the value `0`. We assume that our robot starts out in exactly the middle of the world ($x_0 =50, y_0=50$) with 100% confidence (no motion or measurement noise at this point). The inputs `N` time steps, `num_landmarks`, and `world_size` gives all the information is needed to construct initial constraints of the correct size and starting values.\n",
    "\n",
    "*Depending on the approach we may choose to return one `omega` and one `xi` that hold all (x,y) positions *or* two of each (one for x values and one for y)*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_constraints(N, num_landmarks, world_size):\n",
    "    \"\"\"This function takes in a number of time steps N, number of landmarks, and a world_size,\n",
    "    and returns initialized constraint matrices, omega and xi.\"\"\"\n",
    "\n",
    "    # Recommended: Define and store the size (rows/cols) of the constraint matrix in a variable\n",
    "    rows = (N + num_landmarks) * 2\n",
    "    cols = (N + num_landmarks) * 2\n",
    "\n",
    "    # Define the constraint matrix, Omega, with two initial \"strength\" values\n",
    "    # for the initial x, y location of our robot\n",
    "    omega = np.zeros((rows, cols))\n",
    "\n",
    "    strength = 1\n",
    "\n",
    "    omega[0, 0], omega[1, 1] = strength, strength\n",
    "\n",
    "    # Define the constraint *vector*, xi\n",
    "    # we can assume that the robot starts out in the middle of the world with 100% confidence\n",
    "    xi = np.zeros((rows, 1))\n",
    "    xi[0] = world_size // 2  # x_0\n",
    "    xi[1] = world_size // 2  # y_0\n",
    "\n",
    "    return omega, xi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test as we go\n",
    "\n",
    "It's good practice to test out our code, as we go. Since `slam` relies on creating and updating constraint matrices, `omega` and `xi` to account for robot sensor measurements and motion, let's check that they initialize as expected for any given parameters.\n",
    "\n",
    "Below, there is some test code that allows us to visualize the results of the function `initialize_constraints`. We are using the [seaborn](https://seaborn.pydata.org/) library for visualization.\n",
    "\n",
    "**Change the test values of N, landmarks, and world_size and see the results**.\n",
    "\n",
    "This code assumes that we have created one of each constraint: `omega` and `xi`, but we can change and add to this code, accordingly. The constraints should vary in size with the number of time steps and landmarks as these values affect the number of poses a robot will take `(Px0,Py0,...Pxn,Pyn)` and landmark locations `(Lx0,Ly0,...Lxn,Lyn)` whose relationships should be tracked in the constraint matrices. Recall that `omega` holds the weights of each variable and `xi` holds the value of the sum of these variables, as seen in the second notebook. We need the `world_size` to determine the starting pose of the robot in the world and fill in the initial values for `xi`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import data viz resources\n",
    "import matplotlib.pyplot as plt\n",
    "from pandas import DataFrame\n",
    "import seaborn as sns\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define a small N and world_size (small for ease of visualization)\n",
    "N_test = 5\n",
    "num_landmarks_test = 2\n",
    "small_world = 10\n",
    "\n",
    "# initialize the constraints\n",
    "initial_omega, initial_xi = initialize_constraints(\n",
    "    N_test, num_landmarks_test, small_world\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1d536554c88>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# define figure size\n",
    "plt.rcParams[\"figure.figsize\"] = (10, 7)\n",
    "\n",
    "# display omega\n",
    "sns.heatmap(DataFrame(initial_omega), cmap=\"Blues\", annot=True, linewidths=0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1d538a19048>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 72x504 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# define  figure size\n",
    "plt.rcParams[\"figure.figsize\"] = (1, 7)\n",
    "\n",
    "# display xi\n",
    "sns.heatmap(DataFrame(initial_xi), cmap=\"Oranges\", annot=True, linewidths=0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "19"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SLAM inputs \n",
    "\n",
    "In addition to `data`, the `slam()` function will also take in:\n",
    "* N -   The number of time steps that a robot will be moving and sensing\n",
    "* num_landmarks - The number of landmarks in the world\n",
    "* world_size - The size (w/h) of the world\n",
    "* motion_noise - The noise associated with motion; **the update confidence for motion should be `1.0/motion_noise`**\n",
    "* measurement_noise - The noise associated with measurement/sensing; **the update weight for measurement should be `1.0/measurement_noise`**\n",
    "\n",
    "#### A note on noise\n",
    "\n",
    "The `omega` holds the **relative \"strengths\"** or weights for each position variable, and we can update these weights by accessing the correct index in omega `omega[row][col]` and **adding/subtracting** `1.0/noise` where `noise` is measurement or motion noise. `xi` holds actual position values, and so to update `xi` we do a similar addition process only using the actual value of a motion or measurement. So for a vector index `xi[row][0]` we will end up adding/subtracting one measurement or motion divided by their respective `noise`.\n",
    "\n",
    "### Implement Graph SLAM\n",
    "\n",
    "\n",
    "#### Updating with motion and measurements\n",
    "\n",
    "With a 2D `omega` and `xi` structure as shown above (in earlier cells), we have to be mindful about how we update the values in these constraint matrices to account for motion and measurement constraints in the x and y directions. Recall that the solution to these matrices (which holds all values for robot poses `P` and landmark locations `L`) is the vector, `mu`, which can be computed at the end of the construction of omega and xi as the inverse of omega times xi: $\\mu = \\Omega^{-1}\\xi$\n",
    "\n",
    "**We can also return the values of `omega` and `xi` if we want to visualize their final state!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def slam(data, N, num_landmarks, world_size, motion_noise, measurement_noise):\n",
    "    \"\"\"\n",
    "    slam takes in 6 arguments and returns mu,\n",
    "    mu is the entire path traversed by a robot (all x,y poses) *and* all landmarks locations\n",
    "    \"\"\"\n",
    "\n",
    "    # Use initilization to create constraint matrices, omega and xi\n",
    "    # N: number of timesteps that robots sense/move\n",
    "    landmark_start_index = N * 2\n",
    "\n",
    "    omega, xi = initialize_constraints(N, num_landmarks, world_size)\n",
    "\n",
    "    # Iterate through each time step in the data\n",
    "    # get all the motion and measurement data as we iterate\n",
    "    for time_step, time_data in enumerate(data):\n",
    "        measurements_t = data[time_step][0]  # (landmark, dl_x, dl_y)\n",
    "        motion_t = data[time_step][1]  # (dx, dy)\n",
    "\n",
    "        #         print(time_step)\n",
    "\n",
    "        # update the constraint matrix/vector to account for all *measurements*\n",
    "        # this should be a series of additions that take into account the measurement noise\n",
    "\n",
    "        # (x_0, L_0) find index of x_t\n",
    "        current_pos_index_x = time_step * 2\n",
    "        current_pos_index_y = time_step * 2 + 1\n",
    "\n",
    "        next_pos_x = current_pos_index_x + 2\n",
    "        next_pos_y = current_pos_index_y + 2\n",
    "\n",
    "        # Update OMEGA with measurements\n",
    "        for measure in measurements_t:\n",
    "\n",
    "            # (x_0, L_0) find index of landmark\n",
    "            landmark_id, dl_x, dl_y = measure\n",
    "\n",
    "            landmark_row_col_index_x = landmark_start_index + landmark_id * 2\n",
    "            landmark_row_col_index_y = landmark_row_col_index_x + 1\n",
    "\n",
    "            measure_strength_conf = 1.0 / measurement_noise\n",
    "\n",
    "            # UPDATE OMEGA ----------------\n",
    "            # Update Omega for X\n",
    "            omega[current_pos_index_x, current_pos_index_x] += measure_strength_conf\n",
    "            omega[\n",
    "                landmark_row_col_index_x, landmark_row_col_index_x\n",
    "            ] += measure_strength_conf\n",
    "\n",
    "            omega[\n",
    "                current_pos_index_x, landmark_row_col_index_x\n",
    "            ] += -measure_strength_conf\n",
    "            omega[\n",
    "                landmark_row_col_index_x, current_pos_index_x\n",
    "            ] += -measure_strength_conf\n",
    "\n",
    "            # Update Omega for y\n",
    "            omega[current_pos_index_y, current_pos_index_y] += measure_strength_conf\n",
    "            omega[\n",
    "                landmark_row_col_index_y, landmark_row_col_index_y\n",
    "            ] += measure_strength_conf\n",
    "\n",
    "            omega[\n",
    "                current_pos_index_y, landmark_row_col_index_y\n",
    "            ] += -measure_strength_conf\n",
    "            omega[\n",
    "                landmark_row_col_index_y, current_pos_index_y\n",
    "            ] += -measure_strength_conf\n",
    "\n",
    "            # ----------------\n",
    "            # Update Xi\n",
    "            xi[current_pos_index_x] += -dl_x * measure_strength_conf\n",
    "            xi[landmark_row_col_index_x] += dl_x * measure_strength_conf\n",
    "\n",
    "            xi[current_pos_index_y] += -dl_y * measure_strength_conf\n",
    "            xi[landmark_row_col_index_y] += dl_y * measure_strength_conf\n",
    "\n",
    "        # Update OMEGA with Motions\n",
    "        # update the constraint matrix/vector to account for all *motion* and motion noise\n",
    "        dx, dy = motion_t\n",
    "        motion_conf = 1.0 / motion_noise\n",
    "\n",
    "        # UPDATE OMEGA ----------------\n",
    "        # Update Omega for X\n",
    "        omega[current_pos_index_x, current_pos_index_x] += motion_conf\n",
    "        omega[next_pos_x, next_pos_x] += motion_conf\n",
    "\n",
    "        omega[current_pos_index_x, next_pos_x] += -motion_conf\n",
    "        omega[next_pos_x, current_pos_index_x] += -motion_conf\n",
    "\n",
    "        # Update Omega for y\n",
    "        omega[current_pos_index_y, current_pos_index_y] += motion_conf\n",
    "        omega[next_pos_y, next_pos_y] += motion_conf\n",
    "\n",
    "        omega[current_pos_index_y, next_pos_y] += -motion_conf\n",
    "        omega[next_pos_y, current_pos_index_y] += -motion_conf\n",
    "\n",
    "        # ----------------\n",
    "        # Update Xi\n",
    "        xi[current_pos_index_x] += -dx * motion_conf\n",
    "        xi[next_pos_x] += dx * motion_conf\n",
    "\n",
    "        xi[current_pos_index_y] += -dy * motion_conf\n",
    "        xi[next_pos_y] += dy * motion_conf\n",
    "\n",
    "    # After iterating through all the data\n",
    "    # Compute the best estimate of poses and landmark positions\n",
    "    # using the formula, omega_inverse * Xi\n",
    "    # calculate the inverse of omega\n",
    "    mu = np.linalg.inv(np.matrix(omega)) * xi\n",
    "\n",
    "    return mu, omega, xi  # return `mu`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Helper functions\n",
    "\n",
    "To check that our implementation of SLAM works for various inputs, I have provided two helper functions that will help display the estimated pose and landmark locations that the function has produced. First, given a result `mu` and number of time steps, `N`, we define a function that extracts the poses and landmarks locations and returns those as their own, separate lists. \n",
    "\n",
    "Then, we define a function that nicely print out these lists; both of these we will call, in the next step."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_poses_landmarks(mu, N):\n",
    "    \"\"\"\n",
    "    a helper function that creates a list of poses and of landmarks for ease of printing\n",
    "    this only works for the suggested constraint architecture of interlaced x,y poses\n",
    "    \"\"\"\n",
    "    # create a list of poses\n",
    "    poses = []\n",
    "    for i in range(N):\n",
    "        poses.append((mu[2 * i].item(), mu[2 * i + 1].item()))\n",
    "\n",
    "    # create a list of landmarks\n",
    "    landmarks = []\n",
    "    for i in range(num_landmarks):\n",
    "        landmarks.append((mu[2 * (N + i)].item(), mu[2 * (N + i) + 1].item()))\n",
    "\n",
    "    # return completed lists\n",
    "    return poses, landmarks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_all(poses, landmarks):\n",
    "    print(\"\\n\")\n",
    "    print(\"Estimated Poses:\")\n",
    "    for i in range(len(poses)):\n",
    "        print(\"[\" + \", \".join(\"%.3f\" % p for p in poses[i]) + \"]\")\n",
    "    print(\"\\n\")\n",
    "    print(\"Estimated Landmarks:\")\n",
    "    for i in range(len(landmarks)):\n",
    "        print(\"[\" + \", \".join(\"%.3f\" % l for l in landmarks[i]) + \"]\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run SLAM\n",
    "\n",
    "Now we can see what `mu` the `slam()` function returns for different world sizes and different landmarks!\n",
    "\n",
    "### What to Expect\n",
    "\n",
    "The `data` that is generated is random, but we did specify the number, `N`, or time steps that the robot was expected to move and the `num_landmarks` in the world. The robot should also start with an estimated pose in the very center of the square world, whose size is defined by `world_size`.\n",
    "\n",
    "With these values in mind, we should expect to see a result that displays two lists:\n",
    "1. **Estimated poses**, a list of (x, y) pairs that is exactly `N` in length since this is how many motions the robot has taken. The very first pose should be the center of the world, i.e. `[50.000, 50.000]` for a world that is 100.0 in square size.\n",
    "2. **Estimated landmarks**, a list of landmark positions (x, y) that is exactly `num_landmarks` in length. \n",
    "\n",
    "#### Landmark Locations\n",
    "\n",
    "If we refer back to the print out of *exact* landmark locations when this data was created, we can see values that are very similar to those coordinates, but not quite (since `slam` must account for noise in motion and measurement)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20 5 100.0 2.0 2.0\n"
     ]
    }
   ],
   "source": [
    "print(N, num_landmarks, world_size, motion_noise, measurement_noise)\n",
    "# call slam, passing in the necessary parameters\n",
    "mu, omega, xi = slam(\n",
    "    data, N, num_landmarks, world_size, motion_noise, measurement_noise\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1d538706648>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x1224 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# define figure size\n",
    "plt.rcParams[\"figure.figsize\"] = (20, 17)\n",
    "\n",
    "# display omega\n",
    "sns.heatmap(DataFrame(omega), cmap=\"Blues\", annot=True, linewidths=0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1d538aced88>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 72x1224 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# define  figure size\n",
    "plt.rcParams[\"figure.figsize\"] = (1, 17)\n",
    "\n",
    "# display xi\n",
    "sns.heatmap(DataFrame(xi), cmap=\"Oranges\", annot=True, linewidths=0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Estimated Poses:\n",
      "[50.000, 50.000]\n",
      "[47.156, 56.520]\n",
      "[37.810, 65.075]\n",
      "[41.832, 55.055]\n",
      "[29.485, 53.187]\n",
      "[22.210, 50.643]\n",
      "[16.937, 64.833]\n",
      "[13.483, 58.818]\n",
      "[13.087, 62.197]\n",
      "[14.726, 56.361]\n",
      "[14.471, 39.047]\n",
      "[14.225, 56.134]\n",
      "[14.444, 62.042]\n",
      "[15.185, 60.389]\n",
      "[20.513, 67.513]\n",
      "[20.667, 58.082]\n",
      "[30.646, 58.818]\n",
      "[40.543, 56.175]\n",
      "[46.796, 59.655]\n",
      "[34.144, 44.166]\n",
      "\n",
      "\n",
      "Estimated Landmarks:\n",
      "[90.690, 89.666]\n",
      "[57.580, 80.268]\n",
      "[58.304, 80.467]\n",
      "[53.116, 76.146]\n",
      "[74.767, 92.023]\n"
     ]
    }
   ],
   "source": [
    "# print out the resulting landmarks and poses\n",
    "if mu is not None:\n",
    "    # get the lists of poses and landmarks\n",
    "    # and print them out\n",
    "    poses, landmarks = get_poses_landmarks(mu, N)\n",
    "    print_all(poses, landmarks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualize the constructed world\n",
    "\n",
    "Finally, using the `display_world` code from the `helpers.py` file (which was also used in the first notebook), we can actually visualize what we have coded with `slam`: the final position of the robot and the position of landmarks, created from only motion and measurement data!\n",
    "\n",
    "**Note that these are very similar to the printed *true* landmark locations and final pose from our call to `make_data` early in this notebook.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Last pose:  (34.144271927541205, 44.16591728538147)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x1440 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# import the helper function\n",
    "from helpers import display_world\n",
    "\n",
    "# Display the final world!\n",
    "\n",
    "# define figure size\n",
    "plt.rcParams[\"figure.figsize\"] = (20, 20)\n",
    "\n",
    "# check if poses has been created\n",
    "if \"poses\" in locals():\n",
    "    # print out the last pose\n",
    "    print(\"Last pose: \", poses[-1])\n",
    "    # display the last position of the robot *and* the landmark positions\n",
    "    display_world(int(world_size), poses[-1], landmarks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How far away is the final pose (as estimated by `slam`) compared to the *true* final pose? What would happen if we moved and sensed more (increased N)? Or if we had lower/higher noise parameters?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can find the true value of the final pose in one of the first cells where `make_data` was called. We may also want to look at the true landmark locations and compare them to those that were estimated by `slam`. \n",
    "\n",
    "Estimated last pose: ($x_1, y_1$)=(16.57562398727231, 8.768048368239292), True last pose: ($x_2,y_2$)=(18.28922, 10.59034). The distance between the two points: $D=\\sqrt{(x_2-_x1)^2+(y_2-y_1)^2}=\\sqrt{(18.28922-16.57562)^2+(10.59034-8.768048)^2}\\approx 2.5$\n",
    "\n",
    "The poses are different because of the movement and measurement noise, so the estimate will have some uncertainty. With better sensors and less noise in the measurements, we can get a better estimate. They are different because of the uncertainties in motion and measurement. If N were increased, the absolute error would go down because it generally depends inversely on N. Obviously if the noise were larger, the error would be worse, and conversely, smaller noise leads to less error."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing\n",
    "\n",
    "To confirm that the slam code works, I have provided two test data and cases in the cells below. Uncomment the test cases in the next cells. The output should be **close-to or exactly** identical to the given results. If there are minor discrepancies it could be a matter of floating point accuracy or in the calculation of the inverse matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Estimated Poses:\n",
      "[50.000, 50.000]\n",
      "[37.973, 33.652]\n",
      "[26.185, 18.155]\n",
      "[13.745, 2.116]\n",
      "[28.097, 16.783]\n",
      "[42.384, 30.902]\n",
      "[55.831, 44.497]\n",
      "[70.857, 59.699]\n",
      "[85.697, 75.543]\n",
      "[74.011, 92.434]\n",
      "[53.544, 96.454]\n",
      "[34.525, 100.080]\n",
      "[48.623, 83.953]\n",
      "[60.197, 68.107]\n",
      "[73.778, 52.935]\n",
      "[87.132, 38.538]\n",
      "[80.303, 20.508]\n",
      "[72.798, 2.945]\n",
      "[55.245, 13.255]\n",
      "[37.416, 22.317]\n",
      "\n",
      "\n",
      "Estimated Landmarks:\n",
      "[82.956, 13.539]\n",
      "[70.495, 74.141]\n",
      "[36.740, 61.281]\n",
      "[18.698, 66.060]\n",
      "[20.635, 16.875]\n"
     ]
    }
   ],
   "source": [
    "# Here is the data and estimated outputs for test case 1\n",
    "\n",
    "test_data1 = [\n",
    "    [\n",
    "        [\n",
    "            [1, 19.457599255548065, 23.8387362100849],\n",
    "            [2, -13.195807561967236, 11.708840328458608],\n",
    "            [3, -30.0954905279171, 15.387879242505843],\n",
    "        ],\n",
    "        [-12.2607279422326, -15.801093326936487],\n",
    "    ],\n",
    "    [\n",
    "        [\n",
    "            [2, -0.4659930049620491, 28.088559771215664],\n",
    "            [4, -17.866382374890936, -16.384904503932],\n",
    "        ],\n",
    "        [-12.2607279422326, -15.801093326936487],\n",
    "    ],\n",
    "    [\n",
    "        [[4, -6.202512900833806, -1.823403210274639]],\n",
    "        [-12.2607279422326, -15.801093326936487],\n",
    "    ],\n",
    "    [\n",
    "        [[4, 7.412136480918645, 15.388585962142429]],\n",
    "        [14.008259661173426, 14.274756084260822],\n",
    "    ],\n",
    "    [\n",
    "        [[4, -7.526138813444998, -0.4563942429717849]],\n",
    "        [14.008259661173426, 14.274756084260822],\n",
    "    ],\n",
    "    [\n",
    "        [\n",
    "            [2, -6.299793150150058, 29.047830407717623],\n",
    "            [4, -21.93551130411791, -13.21956810989039],\n",
    "        ],\n",
    "        [14.008259661173426, 14.274756084260822],\n",
    "    ],\n",
    "    [\n",
    "        [\n",
    "            [1, 15.796300959032276, 30.65769689694247],\n",
    "            [2, -18.64370821983482, 17.380022987031367],\n",
    "        ],\n",
    "        [14.008259661173426, 14.274756084260822],\n",
    "    ],\n",
    "    [\n",
    "        [\n",
    "            [1, 0.40311325410337906, 14.169429532679855],\n",
    "            [2, -35.069349468466235, 2.4945558982439957],\n",
    "        ],\n",
    "        [14.008259661173426, 14.274756084260822],\n",
    "    ],\n",
    "    [\n",
    "        [[1, -16.71340983241936, -2.777000269543834]],\n",
    "        [-11.006096015782283, 16.699276945166858],\n",
    "    ],\n",
    "    [\n",
    "        [[1, -3.611096830835776, -17.954019226763958]],\n",
    "        [-19.693482634035977, 3.488085684573048],\n",
    "    ],\n",
    "    [\n",
    "        [[1, 18.398273354362416, -22.705102332550947]],\n",
    "        [-19.693482634035977, 3.488085684573048],\n",
    "    ],\n",
    "    [\n",
    "        [[2, 2.789312482883833, -39.73720193121324]],\n",
    "        [12.849049222879723, -15.326510824972983],\n",
    "    ],\n",
    "    [\n",
    "        [\n",
    "            [1, 21.26897046581808, -10.121029799040915],\n",
    "            [2, -11.917698965880655, -23.17711662602097],\n",
    "            [3, -31.81167947898398, -16.7985673023331],\n",
    "        ],\n",
    "        [12.849049222879723, -15.326510824972983],\n",
    "    ],\n",
    "    [\n",
    "        [\n",
    "            [1, 10.48157743234859, 5.692957082575485],\n",
    "            [2, -22.31488473554935, -5.389184118551409],\n",
    "            [3, -40.81803984305378, -2.4703329790238118],\n",
    "        ],\n",
    "        [12.849049222879723, -15.326510824972983],\n",
    "    ],\n",
    "    [\n",
    "        [\n",
    "            [0, 10.591050242096598, -39.2051798967113],\n",
    "            [1, -3.5675572049297553, 22.849456408289125],\n",
    "            [2, -38.39251065320351, 7.288990306029511],\n",
    "        ],\n",
    "        [12.849049222879723, -15.326510824972983],\n",
    "    ],\n",
    "    [\n",
    "        [[0, -3.6225556479370766, -25.58006865235512]],\n",
    "        [-7.8874682868419965, -18.379005523261092],\n",
    "    ],\n",
    "    [\n",
    "        [[0, 1.9784503557879374, -6.5025974151499]],\n",
    "        [-7.8874682868419965, -18.379005523261092],\n",
    "    ],\n",
    "    [\n",
    "        [[0, 10.050665232782423, 11.026385307998742]],\n",
    "        [-17.82919359778298, 9.062000642947142],\n",
    "    ],\n",
    "    [\n",
    "        [\n",
    "            [0, 26.526838150174818, -0.22563393232425621],\n",
    "            [4, -33.70303936886652, 2.880339841013677],\n",
    "        ],\n",
    "        [-17.82919359778298, 9.062000642947142],\n",
    "    ],\n",
    "]\n",
    "\n",
    "##  Test Case 1\n",
    "##\n",
    "# Estimated Pose(s):\n",
    "#     [50.000, 50.000]\n",
    "#     [37.858, 33.921]\n",
    "#     [25.905, 18.268]\n",
    "#     [13.524, 2.224]\n",
    "#     [27.912, 16.886]\n",
    "#     [42.250, 30.994]\n",
    "#     [55.992, 44.886]\n",
    "#     [70.749, 59.867]\n",
    "#     [85.371, 75.230]\n",
    "#     [73.831, 92.354]\n",
    "#     [53.406, 96.465]\n",
    "#     [34.370, 100.134]\n",
    "#     [48.346, 83.952]\n",
    "#     [60.494, 68.338]\n",
    "#     [73.648, 53.082]\n",
    "#     [86.733, 38.197]\n",
    "#     [79.983, 20.324]\n",
    "#     [72.515, 2.837]\n",
    "#     [54.993, 13.221]\n",
    "#     [37.164, 22.283]\n",
    "\n",
    "\n",
    "# Estimated Landmarks:\n",
    "#     [82.679, 13.435]\n",
    "#     [70.417, 74.203]\n",
    "#     [36.688, 61.431]\n",
    "#     [18.705, 66.136]\n",
    "#     [20.437, 16.983]\n",
    "\n",
    "\n",
    "### Uncomment the following three lines for test case 1 and compare the output to the values above ###\n",
    "\n",
    "mu_1, _, _ = slam(test_data1, 20, 5, 100.0, 2.0, 2.0)\n",
    "poses, landmarks = get_poses_landmarks(mu_1, 20)\n",
    "print_all(poses, landmarks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Estimated Poses:\n",
      "[50.000, 50.000]\n",
      "[69.181, 45.665]\n",
      "[87.743, 39.703]\n",
      "[76.270, 56.311]\n",
      "[64.317, 72.176]\n",
      "[52.257, 88.154]\n",
      "[44.059, 69.401]\n",
      "[37.002, 49.918]\n",
      "[30.924, 30.955]\n",
      "[23.508, 11.419]\n",
      "[34.180, 27.133]\n",
      "[44.155, 43.846]\n",
      "[54.806, 60.920]\n",
      "[65.698, 78.546]\n",
      "[77.468, 95.626]\n",
      "[96.802, 98.821]\n",
      "[75.957, 99.971]\n",
      "[70.200, 81.181]\n",
      "[64.054, 61.723]\n",
      "[58.107, 42.628]\n",
      "\n",
      "\n",
      "Estimated Landmarks:\n",
      "[76.779, 42.887]\n",
      "[85.065, 77.438]\n",
      "[13.548, 95.652]\n",
      "[59.449, 39.595]\n",
      "[69.263, 94.240]\n"
     ]
    }
   ],
   "source": [
    "# Here is the data and estimated outputs for test case 2\n",
    "\n",
    "test_data2 = [\n",
    "    [\n",
    "        [\n",
    "            [0, 26.543274387283322, -6.262538160312672],\n",
    "            [3, 9.937396825799755, -9.128540360867689],\n",
    "        ],\n",
    "        [18.92765331253674, -6.460955043986683],\n",
    "    ],\n",
    "    [\n",
    "        [\n",
    "            [0, 7.706544739722961, -3.758467215445748],\n",
    "            [1, 17.03954411948937, 31.705489938553438],\n",
    "            [3, -11.61731288777497, -6.64964096716416],\n",
    "        ],\n",
    "        [18.92765331253674, -6.460955043986683],\n",
    "    ],\n",
    "    [\n",
    "        [\n",
    "            [0, -12.35130507136378, 2.585119104239249],\n",
    "            [1, -2.563534536165313, 38.22159657838369],\n",
    "            [3, -26.961236804740935, -0.4802312626141525],\n",
    "        ],\n",
    "        [-11.167066095509824, 16.592065417497455],\n",
    "    ],\n",
    "    [\n",
    "        [\n",
    "            [0, 1.4138633151721272, -13.912454837810632],\n",
    "            [1, 8.087721200818589, 20.51845934354381],\n",
    "            [3, -17.091723454402302, -16.521500551709707],\n",
    "            [4, -7.414211721400232, 38.09191602674439],\n",
    "        ],\n",
    "        [-11.167066095509824, 16.592065417497455],\n",
    "    ],\n",
    "    [\n",
    "        [\n",
    "            [0, 12.886743222179561, -28.703968411636318],\n",
    "            [1, 21.660953298391387, 3.4912891084614914],\n",
    "            [3, -6.401401414569506, -32.321583037341625],\n",
    "            [4, 5.034079343639034, 23.102207946092893],\n",
    "        ],\n",
    "        [-11.167066095509824, 16.592065417497455],\n",
    "    ],\n",
    "    [\n",
    "        [\n",
    "            [1, 31.126317672358578, -10.036784369535214],\n",
    "            [2, -38.70878528420893, 7.4987265861424595],\n",
    "            [4, 17.977218575473767, 6.150889254289742],\n",
    "        ],\n",
    "        [-6.595520680493778, -18.88118393939265],\n",
    "    ],\n",
    "    [\n",
    "        [\n",
    "            [1, 41.82460922922086, 7.847527392202475],\n",
    "            [3, 15.711709540417502, -30.34633659912818],\n",
    "        ],\n",
    "        [-6.595520680493778, -18.88118393939265],\n",
    "    ],\n",
    "    [\n",
    "        [\n",
    "            [0, 40.18454208294434, -6.710999804403755],\n",
    "            [3, 23.019508919299156, -10.12110867290604],\n",
    "        ],\n",
    "        [-6.595520680493778, -18.88118393939265],\n",
    "    ],\n",
    "    [\n",
    "        [[3, 27.18579315312821, 8.067219022708391]],\n",
    "        [-6.595520680493778, -18.88118393939265],\n",
    "    ],\n",
    "    [[], [11.492663265706092, 16.36822198838621]],\n",
    "    [\n",
    "        [[3, 24.57154567653098, 13.461499960708197]],\n",
    "        [11.492663265706092, 16.36822198838621],\n",
    "    ],\n",
    "    [\n",
    "        [\n",
    "            [0, 31.61945290413707, 0.4272295085799329],\n",
    "            [3, 16.97392299158991, -5.274596836133088],\n",
    "        ],\n",
    "        [11.492663265706092, 16.36822198838621],\n",
    "    ],\n",
    "    [\n",
    "        [\n",
    "            [0, 22.407381798735177, -18.03500068379259],\n",
    "            [1, 29.642444125196995, 17.3794951934614],\n",
    "            [3, 4.7969752441371645, -21.07505361639969],\n",
    "            [4, 14.726069092569372, 32.75999422300078],\n",
    "        ],\n",
    "        [11.492663265706092, 16.36822198838621],\n",
    "    ],\n",
    "    [\n",
    "        [\n",
    "            [0, 10.705527984670137, -34.589764174299596],\n",
    "            [1, 18.58772336795603, -0.20109708164787765],\n",
    "            [3, -4.839806195049413, -39.92208742305105],\n",
    "            [4, 4.18824810165454, 14.146847823548889],\n",
    "        ],\n",
    "        [11.492663265706092, 16.36822198838621],\n",
    "    ],\n",
    "    [\n",
    "        [\n",
    "            [1, 5.878492140223764, -19.955352450942357],\n",
    "            [4, -7.059505455306587, -0.9740849280550585],\n",
    "        ],\n",
    "        [19.628527845173146, 3.83678180657467],\n",
    "    ],\n",
    "    [\n",
    "        [\n",
    "            [1, -11.150789592446378, -22.736641053247872],\n",
    "            [4, -28.832815721158255, -3.9462962046291388],\n",
    "        ],\n",
    "        [-19.841703647091965, 2.5113335861604362],\n",
    "    ],\n",
    "    [\n",
    "        [\n",
    "            [1, 8.64427397916182, -20.286336970889053],\n",
    "            [4, -5.036917727942285, -6.311739993868336],\n",
    "        ],\n",
    "        [-5.946642674882207, -19.09548221169787],\n",
    "    ],\n",
    "    [\n",
    "        [\n",
    "            [0, 7.151866679283043, -39.56103232616369],\n",
    "            [1, 16.01535401373368, -3.780995345194027],\n",
    "            [4, -3.04801331832137, 13.697362774960865],\n",
    "        ],\n",
    "        [-5.946642674882207, -19.09548221169787],\n",
    "    ],\n",
    "    [\n",
    "        [\n",
    "            [0, 12.872879480504395, -19.707592098123207],\n",
    "            [1, 22.236710716903136, 16.331770792606406],\n",
    "            [3, -4.841206109583004, -21.24604435851242],\n",
    "            [4, 4.27111163223552, 32.25309748614184],\n",
    "        ],\n",
    "        [-5.946642674882207, -19.09548221169787],\n",
    "    ],\n",
    "]\n",
    "\n",
    "\n",
    "# Test Case 2\n",
    "##\n",
    "# Estimated Pose(s):\n",
    "#     [50.000, 50.000]\n",
    "#     [69.035, 45.061]\n",
    "#     [87.655, 38.971]\n",
    "#     [76.084, 55.541]\n",
    "#     [64.283, 71.684]\n",
    "#     [52.396, 87.887]\n",
    "#     [44.674, 68.948]\n",
    "#     [37.532, 49.680]\n",
    "#     [31.392, 30.893]\n",
    "#     [24.796, 12.012]\n",
    "#     [33.641, 26.440]\n",
    "#     [43.858, 43.560]\n",
    "#     [54.735, 60.659]\n",
    "#     [65.884, 77.791]\n",
    "#     [77.413, 94.554]\n",
    "#     [96.740, 98.020]\n",
    "#     [76.149, 99.586]\n",
    "#     [70.211, 80.580]\n",
    "#     [64.130, 61.270]\n",
    "#     [58.183, 42.175]\n",
    "\n",
    "\n",
    "# Estimated Landmarks:\n",
    "#     [76.777, 42.415]\n",
    "#     [85.109, 76.850]\n",
    "#     [13.687, 95.386]\n",
    "#     [59.488, 39.149]\n",
    "#     [69.283, 93.654]\n",
    "\n",
    "\n",
    "### Uncomment the following three lines for test case 2 and compare to the values above ###\n",
    "\n",
    "mu_2, _, _ = slam(test_data2, 20, 5, 100.0, 2.0, 2.0)\n",
    "poses, landmarks = get_poses_landmarks(mu_2, 20)\n",
    "print_all(poses, landmarks)"
   ]
  }
 ],
 "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.4"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}