BBP_w_alexfrom0815.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simple 2D packing example with simple boxes\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Redoing. Cite for new attempt.\n",
    "\n",
    "@inproceedings{\n",
    "zhao2022learning,\n",
    "title={Learning Efficient Online 3D Bin Packing on Packing Configuration Trees},\n",
    "author={Hang Zhao and Yang Yu and Kai Xu},\n",
    "booktitle={International Conference on Learning Representations},\n",
    "year={2022},\n",
    "url={https://openreview.net/forum?id=bfuGjlCwAq}\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Working one piece at a time:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bounding Box\n",
    "\n",
    "Reference: [Computing bounding box for a list of coordinates in Python](https://techoverflow.net/2017/02/23/computing-bounding-box-for-a-list-of-coordinates-in-python/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "libraries for bounding box"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/bin/bash: /home/cim/anaconda3/envs/packing_env/lib/libtinfo.so.6: no version information available (required by /bin/bash)\n",
      "Collecting git+https://github.com/ulikoehler/UliEngineering.git\n",
      "  Cloning https://github.com/ulikoehler/UliEngineering.git to /tmp/pip-req-build-jeaatqex\n",
      "  Running command git clone -q https://github.com/ulikoehler/UliEngineering.git /tmp/pip-req-build-jeaatqex\n",
      "  Resolved https://github.com/ulikoehler/UliEngineering.git to commit f4d25d3f76925a0fc4f64aacf908db3f639baa64\n",
      "Requirement already satisfied: numpy>=1.5 in /home/cim/anaconda3/envs/packing_env/lib/python3.7/site-packages (from UliEngineering==0.3.8) (1.21.4)\n",
      "Collecting toolz>=0.5\n",
      "  Downloading toolz-0.12.0-py3-none-any.whl (55 kB)\n",
      "\u001b[K     |████████████████████████████████| 55 kB 3.7 MB/s eta 0:00:01\n",
      "\u001b[?25hBuilding wheels for collected packages: UliEngineering\n",
      "  Building wheel for UliEngineering (setup.py) ... \u001b[?25ldone\n",
      "\u001b[?25h  Created wheel for UliEngineering: filename=UliEngineering-0.3.8-py3-none-any.whl size=96069 sha256=d81f6d5cfe22580b0e6d294ab12ed24f4747d7cf05ae254c7ecda9939154549d\n",
      "  Stored in directory: /tmp/pip-ephem-wheel-cache-a2g1b1e4/wheels/fc/5d/63/5f11d6e16f564c28980f18ccf9c7ac74e07acf515a2148c202\n",
      "Successfully built UliEngineering\n",
      "Installing collected packages: toolz, UliEngineering\n",
      "Successfully installed UliEngineering-0.3.8 toolz-0.12.0\n"
     ]
    }
   ],
   "source": [
    "!pip install git+https://github.com/ulikoehler/UliEngineering.git"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from UliEngineering.Math.Coordinates import BoundingBox"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the BoundingBox function:\n",
    "Feed a list of coordinate pairs: `coords = np.asarray(coords)`\n",
    "\n",
    "\n",
    "Where \n",
    "\n",
    "\n",
    "          coords = [(6.74219, -53.57835),\n",
    "                    (6.74952, -53.57241),\n",
    "                    (6.75652, -53.56289),\n",
    "                    (6.74756, -53.56598),\n",
    "                    (6.73462, -53.57518)]\n",
    "\n",
    "for example\n",
    "\n",
    "Then use the function:\n",
    "            `BoundingBox(coords)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Empty Maximal Spaces\n",
    "\n",
    "Representation of free space in the bin.\n",
    "\n",
    "One reference [Simulated Annealing](https://github.com/setarehabhari/Simulated-Annealing/blob/main/SA-CSP.ipynb), but I don't understand temperature"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment\n",
    "\n",
    "### Wrapper on gym.env for a Discrete class (our bin in 1 cm squares). Reference [Gym Wrappers](https://alexandervandekleut.github.io/gym-wrappers/)\n",
    "\n",
    "                    class DiscreteToBoxWrapper(gym.ObservationWrapper):\n",
    "                        def __init__(self, env):\n",
    "                            super().__init__(env)\n",
    "                            assert isinstance(env.observation_space, gym.spaces.Discrete), \\\n",
    "                                \"Should only be used to wrap Discrete envs.\"\n",
    "                            self.n = self.observation_space.n\n",
    "                            self.observation_space = gym.spaces.Box(0, 1, (self.n,))\n",
    "\n",
    "                        def observation(self, obs):\n",
    "                            new_obs = np.zeros(self.n)\n",
    "                            new_obs[obs] = 1\n",
    "                            return new_obs\n",
    "\n",
    "### Reshape 2D array to 1D to feed through neural network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ray"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example hyperparameters for neural network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "Bin_x, Bin_y = 600, 600\n",
    "\n",
    "H = 200  # The number of hidden layer neurons.\n",
    "gamma = 0.99  # The discount factor for reward. <- Not sure on this one\n",
    "decay_rate = 0.99  # The decay factor for RMSProp leaky sum of grad^2.\n",
    "D = Bin_x * Bin_y  # The input dimensionality: 600x600 grid.\n",
    "learning_rate = 1e-4  # Magnitude of the update."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Neural Network from [Ray Ping Pong example](https://docs.ray.io/en/latest/ray-core/examples/plot_pong_example.html#neural-network) and [Karpathy pg-pong.py GitHub](https://gist.github.com/karpathy/a4166c7fe253700972fcbc77e4ea32c5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model(object):\n",
    "    \"\"\"This class holds the neural network weights.\"\"\"\n",
    "\n",
    "    def __init__(self):\n",
    "        self.weights = {}\n",
    "        self.weights[\"W1\"] = np.random.randn(H, D) / np.sqrt(D)\n",
    "        self.weights[\"W2\"] = np.random.randn(H) / np.sqrt(H)\n",
    "\n",
    "    def policy_forward(self, x):\n",
    "        h = np.dot(self.weights[\"W1\"], x)\n",
    "        h[h < 0] = 0  # ReLU nonlinearity.\n",
    "        logp = np.dot(self.weights[\"W2\"], h)\n",
    "        # Softmax\n",
    "        p = 1.0 / (1.0 + np.exp(-logp))\n",
    "        # Return probability of taking action 2, and hidden state.\n",
    "        return p, h\n",
    "\n",
    "    def policy_backward(self, eph, epx, epdlogp):\n",
    "        \"\"\"Backward pass to calculate gradients.\n",
    "\n",
    "        Arguments:\n",
    "            eph: Array of intermediate hidden states.\n",
    "            epx: Array of experiences (observations.\n",
    "            epdlogp: Array of logps (output of last layer before softmax/\n",
    "\n",
    "        \"\"\"\n",
    "        dW2 = np.dot(eph.T, epdlogp).ravel()\n",
    "        dh = np.outer(epdlogp, self.weights[\"W2\"])\n",
    "        # Backprop relu.\n",
    "        dh[eph <= 0] = 0\n",
    "        dW1 = np.dot(dh.T, epx)\n",
    "        return {\"W1\": dW1, \"W2\": dW2}\n",
    "\n",
    "    def update(self, grad_buffer, rmsprop_cache, lr, decay):\n",
    "        \"\"\"Applies the gradients to the model parameters with RMSProp.\"\"\"\n",
    "        for k, v in self.weights.items():\n",
    "            g = grad_buffer[k]\n",
    "            rmsprop_cache[k] = decay * rmsprop_cache[k] + (1 - decay) * g ** 2\n",
    "            self.weights[k] += lr * g / (np.sqrt(rmsprop_cache[k]) + 1e-5)\n",
    "\n",
    "\n",
    "def zero_grads(grad_buffer):\n",
    "    \"\"\"Reset the batch gradient buffer.\"\"\"\n",
    "    for k, v in grad_buffer.items():\n",
    "        grad_buffer[k] = np.zeros_like(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Previous attempt below\n",
    "(May want to have for later)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/cim/anaconda3/envs/packing_env/lib/python3.7/site-packages/ale_py/roms/__init__.py:89: DeprecationWarning: Automatic importing of atari-py roms won't be supported in future releases of ale-py. Please migrate over to using `ale-import-roms` OR an ALE-supported ROM package. To make this warning disappear you can run `ale-import-roms --import-from-pkg atari_py.atari_roms`.For more information see: https://github.com/mgbellemare/Arcade-Learning-Environment#rom-management\n",
      "  ROMS = resolve_roms()\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "import cv2 \n",
    "import matplotlib.pyplot as plt\n",
    "import PIL.Image as Image\n",
    "import gym\n",
    "import random\n",
    "\n",
    "from gym import Env, spaces\n",
    "import time\n",
    "\n",
    "font = cv2.FONT_HERSHEY_COMPLEX_SMALL "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this environment an agent places 2D boxes in a 2D container.\n",
    "1. The agent needs to pack as many boxes as possible without overlapping them.\n",
    "2. The episode terminates when the container is full or no more boxes can be placed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ContainerLevel Class\n",
    "Creating a class to model the bottom level of a shipping container.\n",
    "* Define in the `__init__` function the observation and the action spaces.\n",
    "* Implement attribute `canvas` \n",
    "* Implement screen area `x_min, y_min, x_max, y_max`\n",
    "* Implement `elements` - this stores elements in the screen (the already packed box)\n",
    "* helper function `draw_elements_on_canvas` that places the boxes icons in the container at their respective positions\n",
    "* `reset` : resets the environment to its initial state and returns the initial observation.\n",
    "* `step`: Executes a step by placing a box in the environment\n",
    "    * returns the new observation\n",
    "    * reward\n",
    "    * completion status\n",
    "    * and other information"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ContainerLevel(Env):\n",
    "    def __init__(self, obs_x=600, obs_y=600, box_len=200, box_wid=200):\n",
    "        super(ContainerLevel, self).__init__()\n",
    "\n",
    "        # Define 2D packing space\n",
    "        self.observation_shape = (obs_x, obs_y, 3) # **Need to have dimensions passed\n",
    "        self.observation_space = spaces.Box(low = np.zeros(self.observation_space),\n",
    "                                            high = np.ones(self.observation_space),\n",
    "                                            dtype = np.float64)\n",
    "\n",
    "        # Define an action space\n",
    "        self.action_space = spaces.Discrete(6, ) # what is the 6?\n",
    "\n",
    "        # Creating a canvas for rendering\n",
    "        self.canvas = np.ones(self.observation_shape) * 1\n",
    "\n",
    "        # Define elements present in the environment\n",
    "        self.elements = []\n",
    "\n",
    "        # Permissible area where the boxes can be located in container\n",
    "        # **need to adjust this to be smaller when there are other boxes\n",
    "        # Pass information back to space with 2D grid of heights.\n",
    "        self.y_min = int(self.observation_shape[0] * 0.1)\n",
    "        self.x_min = 0\n",
    "        self.y_max = int(self.observation_shape[0] * 0.9)\n",
    "        self.x_max = self.observation_shape[1]\n",
    "        self.box_len = box_len\n",
    "        self.box_wid = box_wid\n",
    "\n",
    "    def draw_elements_on_canvas(self):\n",
    "        # Initialize the canvas\n",
    "        self.canvas = np.ones(self.observation_shape)* 1\n",
    "\n",
    "        # Draw the boxes on the canvas\n",
    "        for elem in self.elements:\n",
    "            elem_shape = elem.boxes.shape\n",
    "            x, y = elem.x, elem.y\n",
    "            self.canvas[y : y + elem_shape[1],\n",
    "                        x : x + elem_shape[0]] = elem.boxes\n",
    "\n",
    "    def overlapping(self, elem1, elem2):\n",
    "        # NEED TO LOOP OVER ALL BOXES IN CONTAINER\n",
    "        # returns True if elem1 & elem2 overlap\n",
    "        # defining boolean for whether there is overlap\n",
    "        x_overlap = False\n",
    "        y_overlab = False\n",
    "\n",
    "        elem1_x, elem1_y = elem1.get_position()\n",
    "        elem2_x, elem2_y = elem2.get_position()\n",
    "\n",
    "        # absolute distance between each dimension\n",
    "        dist_x = abs(elem1_x - elem2_x)\n",
    "        dist_y = abs(elem1_y - elem2_y)\n",
    "\n",
    "        # minimum distance is 1/2 of each boxes' length or width\n",
    "        elem_y_min = 0.5 * (elem1.box_wid + elem2.box_wid)\n",
    "        elem_x_min = 0.5 * (elem1.box_len + elem2.box_len)\n",
    "\n",
    "        if (dist_x < elem_x_min):\n",
    "            x_overlap = True\n",
    "        if (dist_y < elem_y_min):\n",
    "            y_overlap = True\n",
    "\n",
    "        if x_overlap and y_overlab:\n",
    "            return True\n",
    "\n",
    "        return False\n",
    "    \n",
    "    def reset(self):\n",
    "        # Reset the reward\n",
    "        self.ep_return = 0\n",
    "\n",
    "        # Number of boxes\n",
    "        self.boxes_count = 1\n",
    "\n",
    "        # Determine a random place to initialize the first box\n",
    "        # along one side of the container\n",
    "        x = random.randrange(int(self.observation_shape[0] * 0.05),\n",
    "                             int(self.observation_shape[0] * 1.0))\n",
    "        y = random.randrange(int(self.observation_shape[1] * 0.05),\n",
    "                             int(self.observation_shape[1] * \n",
    "                             1.0 )) # Would like to change this to box_len/observation_shape[1]\n",
    "        self.boxes = Boxes('boxes', self.x_max, self.x_min, self.y_max, self.y_min, self.box_len, self.box_wid)\n",
    "        self.boxes.set_position(x, y)          \n",
    "\n",
    "        # Intialize the elements\n",
    "        self.elements = [self.boxes]\n",
    "\n",
    "        # Reset the canvas\n",
    "        self.canvas = np.ones(self.observation_shape) * 1\n",
    "\n",
    "        # Draw elements on the canvas\n",
    "        self.draw_elements_on_canvas()\n",
    "\n",
    "        # return the observation of the state of the container\n",
    "        return self.canvas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Elements of the Environment - Boxes\n",
    "* Starting with a `Point` base class to define any arbitrary point in the observation image.\n",
    "* It has the following attribures:\n",
    "    * `(x, y)`: position of the point on the image.\n",
    "    * `(x_min, x_max, y_min, y_max)`: the permissible coordicates for the points - keeps the position values clamped to these limits.\n",
    "    * `name` : name of the point\n",
    "* Member functions are defined as:\n",
    "    * `get_position` : get the coordinate of the point.\n",
    "    * `set_position` : set the coordinate of the point to a certain value\n",
    "    * `move` ?  - maybe we can call it `rotate` when we need it?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Point(object):\n",
    "    def __init__(self, name, x_max, x_min, y_max, y_min, box_len, box_wid):\n",
    "        self.x = 0\n",
    "        self.y = 0\n",
    "        self.x_min = x_min\n",
    "        self.x_max = x_max\n",
    "        self.y_min = y_min\n",
    "        self.y_max = y_max\n",
    "        self.box_len = box_len\n",
    "        self.box_wid = box_wid\n",
    "\n",
    "    def set_position(self, x, y):\n",
    "        # use box width (box_wid) and length (box_len)\n",
    "        # Dimensions will be (x, y, z) so box is (box_len, box_wid, box_high)\n",
    "        self.x = self.clamp(x, self.x_min, self.x_max - self.box_len)\n",
    "        self.y = self.clamp(y, self.y_min, self.y_max - self.box_wid)\n",
    "\n",
    "    def get_position(self):\n",
    "        return (self.x, self.y)\n",
    "\n",
    "    # rot_ang is the rotational angle in radians - for 2D: pi/2\n",
    "    def rotate_xy(self, rot_ang):\n",
    "        self.x += np.cos(rot_ang)\n",
    "        self.y += np.sin(rot_ang)\n",
    "\n",
    "        self.x = self.clamp(self.x, self.x_min, self.x_max - self.box_len)\n",
    "        self.y = self.clamp(self.y, self.y_min, self.y_max - self.box_wid)\n",
    "\n",
    "    # Here's the much needed part - clamp - to be sure boxes are in the container\n",
    "    def clamp(self, n, minn, maxn):\n",
    "        return (max(min(maxn, n), minn))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The objects are boxes and need to have the attributes:\n",
    "* `boxes` - the 2D footprint of a box \n",
    "* `(box_len, box_wid)` - the dimensions of the footprint of the box."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Boxes(Point):\n",
    "    def __init__(self, name, x_max, x_min, y_max, y_min, box_len, box_wid):\n",
    "        super(Boxes, self).__init__(name, x_max, x_min, y_max, y_min, box_len, box_wid)\n",
    "        # self.boxes = cv2.imread('./images/4072102_box_delivery_package_parcel_shipping_icon.png') / 255.0\n",
    "        self.boxes = cv2.imread('./images/Smiley_Square.png') / 255.0\n",
    "        self.box_len = box_len\n",
    "        self.box_wid = box_wid\n",
    "        self.boxes = cv2.resize(self.boxes, (self.box_len, self.box_wid))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Observing initial container"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original numbers 200 200\n",
      "len, wid 200 200\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/cim/anaconda3/envs/packing_env/lib/python3.7/site-packages/ipykernel_launcher.py:7: DeprecationWarning: Passing None into shape arguments as an alias for () is deprecated.\n",
      "  import sys\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f763c477d90>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "env = ContainerLevel()\n",
    "obs = env.reset()\n",
    "plt.imshow(obs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since our agent will be placing boxes, we need a function to determine whether any newly placed `Point` objects have overlapped any existing objects."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now working on an agent. Our agent will be placing boxes into the container. Adding a definition of possible actions: *place*, *rotate right*, and *rotate left*. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Currently unclear on how to add that functionality. Continuing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%add_to ContainerLevel\n",
    "\n",
    "def action_meanings(self):\n",
    "    return{0: 'PlaceBox', 1: 'PickUpBox',\n",
    "            2: 'MoveBoxRight', 3: 'MoveBoxLeft',\n",
    "            4: 'MoveBoxUp', 5: 'MoveBoxDown',\n",
    "            6:'RotateRight', 7: 'RotateLeft'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How to see if the action is valid."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assert that is is a valid action\n",
    "assert self.action_space.contains(action), \"Invalid Action\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How to determine if there is overlap. If the centers of the two boxes are closer than the length for the x coordinates or the width for the y coordinates, there is overlap.\n",
    "\n",
    "Also, the overlap will need to be checked with all boxes in the container, so this will need to be looped over for the number of boxes already in the container.\n",
    "\n",
    "\n",
    "```\n",
    "def overlapping(self, elem1, elem2):\n",
    "    # returns True if elem1 & elem2 overlap\n",
    "    # defining boolean for whether there is overlap\n",
    "    x_overlap = False\n",
    "    y_overlap = False\n",
    "\n",
    "    elem1_x, elem1_y = elem1.get_position()\n",
    "    elem2_x, elem2_y = elem2.get_position()\n",
    "\n",
    "    # absolute distance between each dimension\n",
    "    dist_x = abs(elem1_x - elem2_x)\n",
    "    dist_y = abs(elem1_y - elem2_y)\n",
    "\n",
    "    # minimum distance is 1/2 of each boxes' length or width\n",
    "    elem_y_min = 0.5 * (elem1.box_wid + elem2.box_wid)\n",
    "    elem_x_min = 0.5 * (elem1.box_len + elem2.box_len)\n",
    "\n",
    "    if (dist_x < elem_x_min):\n",
    "        x_overlap = True\n",
    "    if (dist_y < elem_y_min):\n",
    "        y_overlap = True\n",
    "\n",
    "    if x_overlap and y_overlap:\n",
    "        return(True)\n",
    "\n",
    "    return(False)\n",
    "```"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7.12 ('packing_env')",
   "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.12"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "986c4ab826e36f7fd70b540b62968821342fb0d06b7e0f483712ca6583018ee4"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}