{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "V6THckODUGu6"
   },
   "source": [
    "# Computational Essays on Artificial Intelligence\n",
    "## Evolving Robot Control\n",
    "\n",
    "In this essay, we explore the Genetic Algorithm to evolve a Robot control network.\n",
    "\n",
    "1. A `chromosome` will be composed of a series of `genes`, each representing a weight in a neural network\n",
    "2. A `population` of chromosomes is generated randomly\n",
    "3. For a number of generations the chromosomes are `mutated` by a small amount"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qu0oA5NWUGu-"
   },
   "source": [
    "## 1. Setup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![Open in Binder](https://img.shields.io/badge/-Open%20in%20Binder-579ACA.svg?logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAFkAAABZCAMAAABi1XidAAAB8lBMVEX///9XmsrmZYH1olJXmsr1olJXmsrmZYH1olJXmsr1olJXmsrmZYH1olL1olJXmsr1olJXmsrmZYH1olL1olJXmsrmZYH1olJXmsr1olL1olJXmsrmZYH1olL1olJXmsrmZYH1olL1olL0nFf1olJXmsrmZYH1olJXmsq8dZb1olJXmsrmZYH1olJXmspXmspXmsr1olL1olJXmsrmZYH1olJXmsr1olL1olJXmsrmZYH1olL1olLeaIVXmsrmZYH1olL1olL1olJXmsrmZYH1olLna31Xmsr1olJXmsr1olJXmsrmZYH1olLqoVr1olJXmsr1olJXmsrmZYH1olL1olKkfaPobXvviGabgadXmsqThKuofKHmZ4Dobnr1olJXmsr1olJXmspXmsr1olJXmsrfZ4TuhWn1olL1olJXmsqBi7X1olJXmspZmslbmMhbmsdemsVfl8ZgmsNim8Jpk8F0m7R4m7F5nLB6jbh7jbiDirOEibOGnKaMhq+PnaCVg6qWg6qegKaff6WhnpKofKGtnomxeZy3noG6dZi+n3vCcpPDcpPGn3bLb4/Mb47UbIrVa4rYoGjdaIbeaIXhoWHmZYHobXvpcHjqdHXreHLroVrsfG/uhGnuh2bwj2Hxk17yl1vzmljzm1j0nlX1olL3AJXWAAAAbXRSTlMAEBAQHx8gICAuLjAwMDw9PUBAQEpQUFBXV1hgYGBkcHBwcXl8gICAgoiIkJCQlJicnJ2goKCmqK+wsLC4usDAwMjP0NDQ1NbW3Nzg4ODi5+3v8PDw8/T09PX29vb39/f5+fr7+/z8/Pz9/v7+zczCxgAABC5JREFUeAHN1ul3k0UUBvCb1CTVpmpaitAGSLSpSuKCLWpbTKNJFGlcSMAFF63iUmRccNG6gLbuxkXU66JAUef/9LSpmXnyLr3T5AO/rzl5zj137p136BISy44fKJXuGN/d19PUfYeO67Znqtf2KH33Id1psXoFdW30sPZ1sMvs2D060AHqws4FHeJojLZqnw53cmfvg+XR8mC0OEjuxrXEkX5ydeVJLVIlV0e10PXk5k7dYeHu7Cj1j+49uKg7uLU61tGLw1lq27ugQYlclHC4bgv7VQ+TAyj5Zc/UjsPvs1sd5cWryWObtvWT2EPa4rtnWW3JkpjggEpbOsPr7F7EyNewtpBIslA7p43HCsnwooXTEc3UmPmCNn5lrqTJxy6nRmcavGZVt/3Da2pD5NHvsOHJCrdc1G2r3DITpU7yic7w/7Rxnjc0kt5GC4djiv2Sz3Fb2iEZg41/ddsFDoyuYrIkmFehz0HR2thPgQqMyQYb2OtB0WxsZ3BeG3+wpRb1vzl2UYBog8FfGhttFKjtAclnZYrRo9ryG9uG/FZQU4AEg8ZE9LjGMzTmqKXPLnlWVnIlQQTvxJf8ip7VgjZjyVPrjw1te5otM7RmP7xm+sK2Gv9I8Gi++BRbEkR9EBw8zRUcKxwp73xkaLiqQb+kGduJTNHG72zcW9LoJgqQxpP3/Tj//c3yB0tqzaml05/+orHLksVO+95kX7/7qgJvnjlrfr2Ggsyx0eoy9uPzN5SPd86aXggOsEKW2Prz7du3VID3/tzs/sSRs2w7ovVHKtjrX2pd7ZMlTxAYfBAL9jiDwfLkq55Tm7ifhMlTGPyCAs7RFRhn47JnlcB9RM5T97ASuZXIcVNuUDIndpDbdsfrqsOppeXl5Y+XVKdjFCTh+zGaVuj0d9zy05PPK3QzBamxdwtTCrzyg/2Rvf2EstUjordGwa/kx9mSJLr8mLLtCW8HHGJc2R5hS219IiF6PnTusOqcMl57gm0Z8kanKMAQg0qSyuZfn7zItsbGyO9QlnxY0eCuD1XL2ys/MsrQhltE7Ug0uFOzufJFE2PxBo/YAx8XPPdDwWN0MrDRYIZF0mSMKCNHgaIVFoBbNoLJ7tEQDKxGF0kcLQimojCZopv0OkNOyWCCg9XMVAi7ARJzQdM2QUh0gmBozjc3Skg6dSBRqDGYSUOu66Zg+I2fNZs/M3/f/Grl/XnyF1Gw3VKCez0PN5IUfFLqvgUN4C0qNqYs5YhPL+aVZYDE4IpUk57oSFnJm4FyCqqOE0jhY2SMyLFoo56zyo6becOS5UVDdj7Vih0zp+tcMhwRpBeLyqtIjlJKAIZSbI8SGSF3k0pA3mR5tHuwPFoa7N7reoq2bqCsAk1HqCu5uvI1n6JuRXI+S1Mco54YmYTwcn6Aeic+kssXi8XpXC4V3t7/ADuTNKaQJdScAAAAAElFTkSuQmCC)](https://mybinder.org/v2/gh/ArtificialIntelligenceToolkit/aitk/HEAD?filepath=notebooks%2FEvolvingRobotControl.ipynb) [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/ArtificialIntelligenceToolkit/aitk/blob/master/notebooks/EvolvingRobotControl.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <p><b>Note</b>: if running this notebook on Google Colab, you will need to install the required Python packages each time you start a session. You do not need to do this in Binder. Otherwise on your own computer, you only need to install the packages once.</p>\n",
    "    <p>To install the required Python packages:</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "baekK6oGUGu9",
    "outputId": "df8356cd-2624-4698-f439-051aed1c82d3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "%pip install aitk --upgrade --quiet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1X8RdoEyUGu-"
   },
   "source": [
    "For this demonstration, we will need:\n",
    "\n",
    "* `GeneticAlgorithm` defined in aitk.algorithms.ga\n",
    "* `World`, `Scribbler`, `RangeSensor` from aitk.robots \n",
    "* `SimpleNetwork` from aitk.networks\n",
    "* a few other support functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Fd1XrIsHUGu_"
   },
   "source": [
    "We import everything need in this cell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "AIR4jwkRUGu_"
   },
   "outputs": [],
   "source": [
    "from aitk.algorithms.ga import GeneticAlgorithm\n",
    "from aitk.robots import World, Scribbler, RangeSensor\n",
    "from aitk.networks import SimpleNetwork\n",
    "from aitk.robots.utils import distance\n",
    "import random"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. The Genetic Algorithm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The [Genetic Algorithm](https://en.wikipedia.org/wiki/Genetic_algorithm) (GA) is an approach inside the category of machine learning systems called [Evolutionary Algorithms](https://en.wikipedia.org/wiki/Evolutionary_algorithm) (EA). For this essay, we will use the GA as follows:\n",
    "\n",
    "1. We will define a `gene` to be a floating-point number that represents the weight or bias of a Neural Network.\n",
    "2. We will define a `chromosome` as a sequence of genes. The chromosome (sometimes called a `geneotype`) will represent all of the weights and biases of a network.\n",
    "3. A `population` will be composed of a set of random chromosomes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "eyh7XntqUGvA"
   },
   "source": [
    "The length of the chromosome is determined by the size of the Neural Network. Therefore, we will call `self.build_model()` (defined below) and see how many weights it has. \n",
    "\n",
    "We'll use a ring of 16 laser sensors as senses. We create a small simulated world (100 x 100) to allow the robot to move around.\n",
    "\n",
    "The basic idea is that we will have a list of weights (the chromosome) that we load into the neural network. The sensors will be read, and propagated through the neural network. The output of the neural network will be interpreted as movement controls. We'll let the neural network \"drive\" the robot around the world starting from a few poses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "QEeYh6UwUGvA"
   },
   "outputs": [],
   "source": [
    "class NNGA(GeneticAlgorithm):\n",
    "    \"\"\"\n",
    "    An example of using the GeneticAlgorithm class to \n",
    "    evolve the weights of a neural network to control \n",
    "    a simulated robot.\n",
    "    \"\"\"\n",
    "    def __init__(self, popsize, sensors=16):\n",
    "        self.show = False\n",
    "        self.sensors = sensors\n",
    "        self.world = World(100, 100)\n",
    "        self.robot = Scribbler()\n",
    "        # We add a ring of RangeSensors, 8cm from\n",
    "        # the robot center, starting and ending \n",
    "        # at the back of the robot\n",
    "        # with 75cm max range, and sensor width 0\n",
    "        # which makes it a laser range finder\n",
    "        self.robot.add_device_ring(\n",
    "            RangeSensor, 8, -180, 180, \n",
    "            self.sensors, max=75, width=0)\n",
    "        self.world.add_robot(self.robot)\n",
    "        self.network = self.build_model()\n",
    "        # Starting poses to test from:\n",
    "        self.poses = [\n",
    "            (20, 20, 0), \n",
    "            (20, 20, 45), \n",
    "            (20, 20, 90), \n",
    "            (20, 20, 180), \n",
    "            (20, 20, -45),\n",
    "        ]\n",
    "        # Length of a chromosome:\n",
    "        length = len(self.network.get_weights(flat=True))\n",
    "        super().__init__(length, popsize)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HNvM7oeWUGvB"
   },
   "source": [
    "As mentioned, a chromosome will be a sequence of floating-point numbers, between -2 and +2. When we mutate such a gene, we will increase or decrease it a small amount. To define these two aspects of a gene, we define the following methods:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "61igCPUsUGvB"
   },
   "outputs": [],
   "source": [
    "class NNGA(NNGA):        \n",
    "    def make_random_gene(self):\n",
    "        \"\"\"\n",
    "        Generate a random weight for the neural network.\n",
    "        \"\"\"\n",
    "        # range of [-2, +2]\n",
    "        return 2 - random.random() * 4\n",
    "    \n",
    "    def mutate_gene(self, gene):\n",
    "        \"\"\"\n",
    "        Given a gene, mutate it a little.\n",
    "        \"\"\"\n",
    "        # range of [-0.5, +0.5]\n",
    "        return gene + (0.5 - random.random())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8zDTWbLNUGvC"
   },
   "source": [
    "### 2.1 The Fitness Function\n",
    "\n",
    "To use a GA we need to define a `fitness function`. A fitness function tests a chromosome in the simulated world, and returns a value that represents how \"apt\" (or fit) it is relative to the other chromosomes in the population at this generation.\n",
    "\n",
    "Finding a good fitness function is difficult. We don't want to be too prescriptive, or the system will evolve exactly what we have defined it to do. On the other hand, we don't want to be too open, as that can leave the system to evolve solutions that don't really \"solve a problem.\"\n",
    "\n",
    "For example, let's say that we want the robot to move around this world and not bump into walls. We could define a fitness that is the total number of steps where the robot did not hit a wall (e.g., `robot.stalled` is not True).\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\">\n",
    "    <b>Warning</b>: the implementation of a GA that we use here requires that the fitness function return a number greater or equal to zero.\n",
    "</div>\n",
    "\n",
    "However, you would very quickly evolve a robot that doesn't move. No movement, no crashing into walls! Well, ok, then. How about we define a fitness function that rewards the robot when it keeps moving. The evolutionary system could \"solve that problem\" by simply spinning the robot in circles. Foiled again!\n",
    "\n",
    "You could then define a fitness function that rewards the robot when it has forward movement, thereby circumventing the solution for the robot to spin in circles. However, the system could then just drive the robot in small circles, and we inadvently didn't reward a robot for moving backwards (which should be fine).\n",
    "\n",
    "The search the human performs in attempting to find a good fitness function that will drive the robot into interesting control patterns while not settling on simplistic solutions is quite common. However, if you can train yourself to think more like nature, you can end up with some very clever robots.\n",
    "\n",
    "To that end, we will define the fitness function to be the distance between where the robot started, and where it ended up after a given number of seconds. Plus, we will add all of the distances traveled on each individual step. However, if it ends up against a wall, it will get a score of zero.\n",
    "\n",
    "This is a fairly easy fitness function to compute (the sum of all distance traveled, plus distance from where it started) and should bypass some of the solutions defined above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "TN_laHoPUGvC"
   },
   "outputs": [],
   "source": [
    "class NNGA(NNGA):        \n",
    "    def fitness(self, chromosome, index=None, poses=None, seconds=None, interrupt=True, real_time=False,\n",
    "                show=False, show_progress=False, quiet=True):\n",
    "        \"\"\"\n",
    "        Fitness is based on the distance the robot travels \n",
    "        from starting pose to ending pose.\n",
    "        \n",
    "        Args:\n",
    "            poses: default None, all of the poses; \n",
    "                otherwise list of poses (x, y, a).\n",
    "            seconds: default 10\n",
    "            interrupt: default True\n",
    "            real_time: default False\n",
    "            show: default True\n",
    "            show_progress: default False\n",
    "            quiet: default True\n",
    "        \"\"\"\n",
    "        if seconds is None:\n",
    "            seconds = min(self.generation / 10, 10)\n",
    "        self.show = show\n",
    "        self.network.set_weights(chromosome)\n",
    "        score = 0\n",
    "        poses = poses if poses is not None else self.poses\n",
    "        for pose in poses:\n",
    "            self.robot.set_pose(*pose, show=self.show)\n",
    "            self.world.seconds(\n",
    "                seconds, self.controller, \n",
    "                interrupt=interrupt, \n",
    "                real_time=real_time, show=show,\n",
    "                show_progress=show_progress, quiet=quiet)\n",
    "            if not self.robot.stalled:\n",
    "                end_pose = self.robot.get_pose()\n",
    "                score += distance(pose[0], pose[1], end_pose[0], end_pose[1])\n",
    "        return score   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hGDuszABUGvD"
   },
   "source": [
    "We can now add some methods for the specific problem:\n",
    "\n",
    "* build_model - creates the neural network and takes in the number of sensors, and outputs the movement commands (one for translate, one for rotate)\n",
    "* controller - the method to drive the robot\n",
    "* get_sensors - a convenience method to get the sensor readings from the range sensors as a list\n",
    "* get_move - a method that takes the input to the network (the sensor readings) and propagates them through the network to get the output values, which are scaled to [-1, +1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "gv41Bn_QUGvD"
   },
   "outputs": [],
   "source": [
    "class NNGA(NNGA):        \n",
    "    def build_model(self):\n",
    "        \"\"\"\n",
    "        We build a simple network. \n",
    "        \"\"\"\n",
    "        return SimpleNetwork(\n",
    "            self.sensors,\n",
    "            4,\n",
    "            2,\n",
    "            activation=\"sigmoid\"\n",
    "        )\n",
    "        \n",
    "    def controller(self, world):\n",
    "        \"\"\"\n",
    "        The controller for the robot.\n",
    "        \"\"\"\n",
    "        sensors = self.get_sensors()\n",
    "        output = self.get_move(sensors)\n",
    "        self.robot.move(output[0], output[1])\n",
    "        \n",
    "    def get_sensors(self):\n",
    "        \"\"\"\n",
    "        We return the sensors from the robot.\n",
    "        \"\"\"\n",
    "        return [sensor.get_reading() \n",
    "                for sensor in self.robot]\n",
    "    \n",
    "    def get_move(self, sensors):\n",
    "        \"\"\"\n",
    "        Given the dataset (a single )\n",
    "        \"\"\"\n",
    "        # Propagate takes a single pattern:\n",
    "        output = self.network.propagate(\n",
    "            sensors, show=self.show)\n",
    "        # Scale the output in [-1, 1]\n",
    "        return 1 - output * 2\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we are ready to create a GA. We'll define the population size to be 30, which isn't too small, but big enough to evolve a solution in a few minutes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "IyVFhghhUGvE",
    "outputId": "2988c304-fc9b-45d8-e793-e180625de46d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Random seed set to: 5594309\n",
      "Genetic algorithm\n",
      "  Chromosome length: 78\n",
      "  Population size: 30\n"
     ]
    }
   ],
   "source": [
    "ga = NNGA(popsize=30)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can get a snapshot of the world with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=300x342 at 0x7FF2DDEDE0D0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ga.world.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But we can do better than just a snapshot. We can actually dynamically \"watch\" the world update.\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\">\n",
    "    <b>Warning</b>: unfortunately the dynamic update may not work on all Jupyter Notebook systems. But it should work in: Jupyter Lab, Jupyter Notebook, Google Colab, and many others.\n",
    "</div>\n",
    "\n",
    "We'll create two watch windows: one for the world, and one for the network. This will update dynamically when `show=True`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "    <b>Idea</b>: when running in Jupyter Lab, you can right-click on the two watch cells (after running them) and select \"Create New View for Output\" for each. You can then drag the panels over so that you can see them along side the notebook.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 382,
     "referenced_widgets": [
      "686027ec8d104a65a28c531cff802a49",
      "edfd80f163844472afcad4ac980bb73b"
     ]
    },
    "id": "npHXLuo8UGvF",
    "outputId": "e48d4e46-5ea4-4899-947e-c6c85e4d3b4b",
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4b6c8d8866cd415fba3eea13999e369d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Image(value=b'\\xff\\xd8\\xff\\xe0\\x00\\x10JFIF\\x00\\x01\\x01\\x00\\x00\\x01\\x00\\x01\\x00\\x00\\xff\\xdb\\x00C\\x00\\x08\\x06\\x0…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ga.world.watch()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Likewise, we can get a snapshot of the network architecture:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<svg id='keras-network' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' image-rendering=\"pixelated\" width=\"400px\" height=\"324px\" style=\"background-color: #B0C4DE\">\n",
       " <g >\n",
       "  <svg viewBox=\"0 0 350 284\" width=\"400px\" height=\"324px\">\n",
       "    <defs>\n",
       "        <marker id=\"arrow\" markerWidth=\"10\" markerHeight=\"10\" refX=\"9\" refY=\"3\" orient=\"auto\" markerUnits=\"strokeWidth\">\n",
       "          <path d=\"M0,0 L0,6 L9,3 z\" fill=\"black\" />\n",
       "        </marker>\n",
       "    </defs><rect x=\"112.0\" y=\"24\" width=\"126\" height=\"64\" style=\"fill:none;stroke:black;stroke-width:2\"/><image id=\"keras-network_output\" class=\"keras-network\" x=\"113.0\" y=\"25\" height=\"62\" width=\"124\" preserveAspectRatio=\"none\" image-rendering=\"optimizeSpeed\" xlink:href=\"data:image/gif;base64,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\"><title>Layer: output 'Dense'\n",
       "Act function: sigmoid\n",
       "Act output range: (0, 1)\n",
       "Shape = (None, 2)</title></image><text x=\"242.0\" y=\"58.0\" font-family=\"monospace\" font-size=\"12\" text-anchor=\"start\" fill=\"blue\" alignment-baseline=\"central\" >output</text><path d=\"M 175.0 116 L 175.0 89 \" stroke=\"black\" stroke-width=\"2\" marker-end=\"url(#arrow)\" fill=\"none\" /><rect x=\"74.0\" y=\"116\" width=\"202\" height=\"64\" style=\"fill:none;stroke:black;stroke-width:2\"/><image id=\"keras-network_hidden\" class=\"keras-network\" x=\"75.0\" y=\"117\" height=\"62\" width=\"200\" preserveAspectRatio=\"none\" image-rendering=\"optimizeSpeed\" xlink:href=\"data:image/gif;base64,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\"><title>Layer: hidden 'Dense'\n",
       "Act function: sigmoid\n",
       "Act output range: (0, 1)\n",
       "Shape = (None, 4)</title></image><text x=\"280.0\" y=\"150.0\" font-family=\"monospace\" font-size=\"12\" text-anchor=\"start\" fill=\"blue\" alignment-baseline=\"central\" >hidden</text><path d=\"M 175.0 208 L 175.0 181 \" stroke=\"black\" stroke-width=\"2\" marker-end=\"url(#arrow)\" fill=\"none\" /><rect x=\"74.0\" y=\"208\" width=\"202\" height=\"52\" style=\"fill:none;stroke:black;stroke-width:2\"/><image id=\"keras-network_input\" class=\"keras-network\" x=\"75.0\" y=\"209\" height=\"50\" width=\"200\" preserveAspectRatio=\"none\" image-rendering=\"optimizeSpeed\" xlink:href=\"data:image/gif;base64,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\"><title>Layer: input 'InputLayer'\n",
       "Shape = [(None, 16)]</title></image><text x=\"280.0\" y=\"236.0\" font-family=\"monospace\" font-size=\"12\" text-anchor=\"start\" fill=\"blue\" alignment-baseline=\"central\" >input</text><text x=\"175.0\" y=\"12.5\" font-family=\"monospace\" font-size=\"15\" text-anchor=\"middle\" fill=\"black\" alignment-baseline=\"central\" >Activations for SimpleNetwork</text></svg></g></svg>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ga.network.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But, again we can do even better by creating a dynamically updating view:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 345,
     "referenced_widgets": [
      "85948e04362d4b658808951c4635bf00",
      "dc52a3313d1f45bd9e8e9d10dd2bfcd7",
      "6203182779304d9c88d259968b51864b"
     ]
    },
    "id": "9dE6sMacUGvF",
    "outputId": "4c9b57c0-acb5-42ae-f841-c5a3fc8910fa",
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7153bb00bfae40128e51f2a74d9942d3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HTML(value='<div style=\"outline: 5px solid #1976D2FF; width: 400px; height: 324px;\"><svg id=\\'keras-network\\' …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ga.network.watch()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 Testing\n",
    "\n",
    "Let's test everything to make sure it is working.\n",
    "\n",
    "Let's see what a chromosome looks like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "78"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(ga.make_random_chromosome())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Therefore a chromome will be a length of 78 \"genes\". Each gene is an individual weight or bias in the neural network.\n",
    "\n",
    "Let's see what the sensor readings look like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.9499536896755313,\n",
       " 1.0,\n",
       " 0.4552718584361414,\n",
       " 0.311920559388813,\n",
       " 0.2801289369189201,\n",
       " 0.3216590893285552,\n",
       " 0.2616706002237469,\n",
       " 0.18539009021787406,\n",
       " 0.17573611964604702,\n",
       " 0.22165291555883745,\n",
       " 0.3874202432787764,\n",
       " 0.8561860810940988,\n",
       " 0.8668159170532664,\n",
       " 1.0,\n",
       " 1.0,\n",
       " 0.9499536896755313]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sensors = ga.get_sensors()\n",
    "sensors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And let's see what movements the sensors give when propagated through the network and scaled:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.18124181, 0.00042856], dtype=float32)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ga.get_move(sensors)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should see the activations in the network display change. The robot won't actually move in the simulator until we update it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ocq9cHWvUGvG"
   },
   "source": [
    "Ok, let's put all of this together and move the robot around the simulated world. We can test out a random chromosome to see what this does.\n",
    "\n",
    "We pass in:\n",
    "\n",
    "1. a random chromosome (like one from the initial population)\n",
    "2. A list of poses (x, y, angle) to test\n",
    "3. number of seconds to run the simulation\n",
    "4. Whether we should show the robot and network updates\n",
    "5. Whether the simulation should run in real_time (setting to False will run as fast as possible)\n",
    "\n",
    "Let's go!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 85,
     "referenced_widgets": [
      "24370d9d5e054008af5d1547ae1e06ad",
      "d50d56b63cfc44278489faee93999b82",
      "a038bba8c4514aadb3ef388bb80578fb",
      "2112fa546d854613ab9ce5a0cbb31e05",
      "7c0ae88a94904d5e8f06937e44eee86c",
      "780648e92fc645a9b8dd73254f252c2e",
      "a9c3ad6214a04c33baad9842454be573",
      "4c02aaa7d86348a08cdaab1e0b2758e3"
     ]
    },
    "id": "Xv19whtMUGvG",
    "outputId": "4929a03e-1d0e-4eca-9733-91e97f36e37c"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.92026006976214"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ga.fitness(\n",
    "    ga.make_random_chromosome(), \n",
    "    poses=[(50, 50, 0)], \n",
    "    seconds=5,\n",
    "    show=True, \n",
    "    real_time=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Interesting! You can try that cell over and over again to see many possible behaviors of these random weights.\n",
    "\n",
    "Some questions you might be interested in answering at this point?\n",
    "\n",
    "1. What percentage of random genes spin in circles?\n",
    "2. What percentage of random genes change movement during the 5 seconds of training?\n",
    "3. What percentage of gense actually make it to a wall?\n",
    "4. What is the range of \"fitness\" values returned for these random chromosomes?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aoo2YGEVUGvK"
   },
   "source": [
    "## 3. Evolve!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kEUDFqS-UGvG"
   },
   "source": [
    "To run 10 generations (plus one to test initial population) for a population of size 30, in the 5 test poses for 3 seconds each will take 1 hour, 22 minutes, and 30 seconds of simulated time."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "omwTjbx-UGvK"
   },
   "source": [
    "Often, 10 simulated generations can performed in a few actual clock minutes on a typical computer. One can get about a 50 x speed-up over real time when not watching the network, and about 10 x speed-up when watching the network."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7Xy3jw6EUGvL"
   },
   "source": [
    "You can run without watching by setting `show=False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "NqqfhTNoUGvL",
    "outputId": "15deae95-61be-4af3-b741-8acfd2e8c135"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using random seed: 5594309\n",
      "  Maximum number of generations: 10\n",
      "  Crossover rate: 0.0\n",
      "  Mutation rate: 0.6\n",
      "  Elite percentage 0.05\n",
      "  Elite count: 1\n",
      "Generation    0 Best fitness 125.27\n",
      "Generation    1 Best fitness 125.27\n",
      "Generation    2 Best fitness 125.27\n",
      "Generation    3 Best fitness 151.33\n",
      "Generation    4 Best fitness 152.44\n",
      "Generation    5 Best fitness 154.87\n",
      "Generation    6 Best fitness 169.32\n",
      "Generation    7 Best fitness 169.32\n",
      "Generation    8 Best fitness 169.32\n",
      "Generation    9 Best fitness 170.97\n",
      "Generation   10 Best fitness 171.21\n",
      "Max generations reached\n",
      "CPU times: user 1min 3s, sys: 293 ms, total: 1min 3s\n",
      "Wall time: 1min 4s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "ga.reset()\n",
    "ga.world.reset()\n",
    "bestFound = ga.evolve(\n",
    "    generations=10, \n",
    "    crossover_rate=0.0, \n",
    "    mutation_rate=0.6, \n",
    "    elite_percent=0.05, \n",
    "    seconds=3,\n",
    "    show=False,\n",
    ") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CbCDQPkJUGvL"
   },
   "source": [
    "## 4. Analysis\n",
    "\n",
    "Here's a summary of how the best and average fitness for the population changed over time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 295
    },
    "id": "NxX8912mUGvM",
    "outputId": "c7550553-df7f-4b87-c730-a4ddd8e35387"
   },
   "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"
    }
   ],
   "source": [
    "ga.plot_stats(\"NNGA\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IPm0T3vOUGvM"
   },
   "source": [
    "Let's see the results by trying the best ever over the poses, for 5 seconds each:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 285,
     "referenced_widgets": [
      "8ad2ce156ec745d187f0b182345b655f",
      "75b5f1165faf4949a9065abec1c2532b",
      "d9c797c19dd5465ba5e4576f460f11fa",
      "4bc107b0fdfe431c845e58cf143ac15d",
      "8e68efa968d849e6b52b408f2cf6785c",
      "d72ff6dce2f4474caa50979834bba248",
      "84bb4ccf6acc42d9a48141295b7127f3",
      "0706330888c84838970071882bb77045",
      "f01ce7d4998f4cd18793c55b977cd44c",
      "e0f6d576022b4c3f8731377f4c16b2b2",
      "c57c8a5a7cf046babd6a571dea10425d",
      "b700450539e24b3f958ab82cb4c61ba7",
      "f7880b7cb8234171973ae8fe3d885c5a",
      "adee9b75ac91429bbda90174d6040d80",
      "11b25aefe3464744b0363f568b70ff7a",
      "b19a2c494a144ace9d3abb736fee833f",
      "9c4c52242d064e90b5da368e1a469632",
      "14fb98746a0141b3a19d4ddc2f8bfbf7",
      "6fddbded18e9420ab53fa31b562d97bd",
      "469f3917098844d0af203e6b977eed1b",
      "035bbb9735a34758bae96160426f7d9a",
      "f3e7c40d8aad4e30a33f6f4bc05bd140",
      "0975fa7125874869bb1ed29c7aea16d1",
      "8f378d82408e41d287b655a59c952c9a",
      "ebcfb91f4b434d6ab43cd99e345ce5ec",
      "3bc9276ac4974a03be28b2833b3c01c4",
      "b9e7ada87a93489fa6dec933a4d0c569",
      "29cd109ab212478aa65e835c2817d681",
      "72c0466433c344be8cd1ca5e2318c683",
      "bd16fcf2b7c64c468196e8e943597a72",
      "45ffbc451cc74c828c122c7278667a74",
      "5ea147a8f055448c8c9db986bb3a4bde",
      "471f0b80f59e43a39333e263102dc92d",
      "83f09a58fcd4407684012f5fa19382f2",
      "ac274c57aaab4939b6c912bcfa37682f",
      "cf3e41e28e0e40fd84f8ee99a94e16dd",
      "256452ae51354eaea44d4714edfb8bde",
      "19497de06b24405fb512395602693b79",
      "315ee295b7604620b68534d662a5b6d6",
      "2f3513979be0412c8be18ccae97f113b"
     ]
    },
    "id": "WmajpIM1UGvM",
    "outputId": "7b928ca7-7275-4847-9f6b-39a47c5ab00e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "175.6739394939202"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ga.fitness(\n",
    "    ga.bestEver, \n",
    "    real_time=True, \n",
    "    show=True, \n",
    "    seconds=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evolution may have created lots of behaviors that crash into walls. \n",
    "\n",
    "What is the most interesting behavior that you observer after 10 generations?\n",
    "\n",
    "Let's run a few more generations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "h9hjrUWiUGvM"
   },
   "source": [
    "If you wish, you can increase the maximum generations, change any of the parameters, and continue to evolve:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "xYj9oS8NUGvN"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Maximum number of generations: 20\n",
      "  Crossover rate: 0.6\n",
      "  Mutation rate: 0.001\n",
      "  Elite percentage 0.1\n",
      "  Elite count: 3\n",
      "Generation   11 Best fitness 171.21\n"
     ]
    }
   ],
   "source": [
    "bestFound = ga.evolve(\n",
    "    generations=20, \n",
    "    crossover_rate=0.6, \n",
    "    mutation_rate=0.001, \n",
    "    elite_percent=0.1, \n",
    "    seconds=3,\n",
    "    show=False,\n",
    ") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ga.plot_stats(\"NNGA\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ga.fitness(\n",
    "    ga.bestEver, \n",
    "    real_time=True, \n",
    "    show=True, \n",
    "    seconds=5,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Was the best from the second 10 generations significantly different from the best from the first 10 generations?\n",
    "\n",
    "Did the fitness change dramatically during the second 10 generations? \n",
    "\n",
    "Do you think there will be a point where the fitness won't get any higher?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Further Exploration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is one additional aspect added to the fitness measure: if you don't specify the number of seconds to use explicitly, it will compute the number of seconds based on the generation. This allows the GA to focus on initial movements first, and longer control as the generations increase. You can test this effect by running without explicitly setting seconds. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>Tip</b>: the best fitness measure will increase with the increased simulation time. So you can't really compare the fitness in the begining generations with following generations when seconds is `None`. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some ideas to try:\n",
    "\n",
    "1. Try evolving with seconds=None. How does this compare with a fixed number of seconds?\n",
    "2. What happens if you try with a larger, fixed number of seconds, such as 10?\n",
    "3. The above experiments used 0.0 crossover with a high mutation rate. What happens if you try with a higher crossover rate (say 30%) and with a much smaller mutation rate?\n",
    "4. Anything that you can represent with a list of numbers and create a fitness function for, you could conceivably evole. What else could you try? What are the limitations of the GA?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. References\n",
    "\n",
    "1. Turing\n",
    "2. Holland"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "NNGA.ipynb",
   "provenance": []
  },
  "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.8.2"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {
     "01627eb63e9f48bcaeb16d42ec509165": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "border": "10px solid rgb(0 177 255)",
       "margin": "auto"
      }
     },
     "426932e8f1684d55add824790758e912": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "4b6c8d8866cd415fba3eea13999e369d": {
      "buffers": [
       {
        "data": "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",
        "encoding": "base64",
        "path": [
         "value"
        ]
       }
      ],
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ImageModel",
      "state": {
       "layout": "IPY_MODEL_01627eb63e9f48bcaeb16d42ec509165"
      }
     },
     "7153bb00bfae40128e51f2a74d9942d3": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HTMLModel",
      "state": {
       "layout": "IPY_MODEL_426932e8f1684d55add824790758e912",
       "style": "IPY_MODEL_950cd68e8a634b6ebe100015434163f7",
       "value": "<div style=\"outline: 5px solid #1976D2FF; width: 400px; height: 324px;\"><svg id='keras-network' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' image-rendering=\"pixelated\" width=\"400px\" height=\"324px\" style=\"background-color: #B0C4DE\">\n <g >\n  <svg viewBox=\"0 0 350 284\" width=\"400px\" height=\"324px\">\n    <defs>\n        <marker id=\"arrow\" markerWidth=\"10\" markerHeight=\"10\" refX=\"9\" refY=\"3\" orient=\"auto\" markerUnits=\"strokeWidth\">\n          <path d=\"M0,0 L0,6 L9,3 z\" fill=\"black\" />\n        </marker>\n    </defs><rect x=\"112.0\" y=\"24\" width=\"126\" height=\"64\" style=\"fill:none;stroke:black;stroke-width:2\"/><image id=\"keras-network_output\" class=\"keras-network\" x=\"113.0\" y=\"25\" height=\"62\" width=\"124\" preserveAspectRatio=\"none\" image-rendering=\"optimizeSpeed\" xlink:href=\"data:image/gif;base64,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\"><title>Layer: output 'Dense'\nAct function: sigmoid\nAct output range: (0, 1)\nShape = (None, 2)</title></image><text x=\"242.0\" y=\"58.0\" font-family=\"monospace\" font-size=\"12\" text-anchor=\"start\" fill=\"blue\" alignment-baseline=\"central\" >output</text><path d=\"M 175.0 116 L 175.0 89 \" stroke=\"black\" stroke-width=\"2\" marker-end=\"url(#arrow)\" fill=\"none\" /><rect x=\"74.0\" y=\"116\" width=\"202\" height=\"64\" style=\"fill:none;stroke:black;stroke-width:2\"/><image id=\"keras-network_hidden\" class=\"keras-network\" x=\"75.0\" y=\"117\" height=\"62\" width=\"200\" preserveAspectRatio=\"none\" image-rendering=\"optimizeSpeed\" xlink:href=\"data:image/gif;base64,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\"><title>Layer: hidden 'Dense'\nAct function: sigmoid\nAct output range: (0, 1)\nShape = (None, 4)</title></image><text x=\"280.0\" y=\"150.0\" font-family=\"monospace\" font-size=\"12\" text-anchor=\"start\" fill=\"blue\" alignment-baseline=\"central\" >hidden</text><path d=\"M 175.0 208 L 175.0 181 \" stroke=\"black\" stroke-width=\"2\" marker-end=\"url(#arrow)\" fill=\"none\" /><rect x=\"74.0\" y=\"208\" width=\"202\" height=\"52\" style=\"fill:none;stroke:black;stroke-width:2\"/><image id=\"keras-network_input\" class=\"keras-network\" x=\"75.0\" y=\"209\" height=\"50\" width=\"200\" preserveAspectRatio=\"none\" image-rendering=\"optimizeSpeed\" xlink:href=\"data:image/gif;base64,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\"><title>Layer: input 'InputLayer'\nShape = [(None, 16)]</title></image><text x=\"280.0\" y=\"236.0\" font-family=\"monospace\" font-size=\"12\" text-anchor=\"start\" fill=\"blue\" alignment-baseline=\"central\" >input</text><text x=\"175.0\" y=\"12.5\" font-family=\"monospace\" font-size=\"15\" text-anchor=\"middle\" fill=\"black\" alignment-baseline=\"central\" >Activations for SimpleNetwork</text></svg></g></svg></div>"
      }
     },
     "950cd68e8a634b6ebe100015434163f7": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "description_width": ""
      }
     }
    },
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}