diff --git a/sorb/README.md b/sorb/README.md new file mode 100644 index 000000000000..3127376a4a5c --- /dev/null +++ b/sorb/README.md @@ -0,0 +1,8 @@ +## Search on the Replay Buffer: Bridging Planning and Reinforcement Learning + +This directory contains a Colab with demonstration/reference code for: +"Search on the Replay Buffer: Bridging Planning and Reinforcement Learning." Benjamin Eysenbach, Ruslan Salakhutdinov and Sergey Levine. 2019 +[https://arxiv.org/pdf/1906.05253.pdf](https://arxiv.org/pdf/1906.05253.pdf) + + +To launch the Colab, [click here](https://colab.research.google.com/github/google-research/google-research/blob/master/sorb/SoRB.ipynb). diff --git a/sorb/SoRB.ipynb b/sorb/SoRB.ipynb new file mode 100644 index 000000000000..87b12e25552d --- /dev/null +++ b/sorb/SoRB.ipynb @@ -0,0 +1,2379 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "SoRB.ipynb", + "version": "0.3.2", + "provenance": [], + "collapsed_sections": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "YJhveYqWn-tA", + "colab_type": "text" + }, + "source": [ + "##### Copyright 2019 Google LLC.\n", + "\n", + "Licensed under the Apache License, Version 2.0 (the \"License\");" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "pKe5zvMRoAB7", + "colab_type": "code", + "cellView": "form", + "colab": {} + }, + "source": [ + "#@title License\n", + "# Licensed under the Apache License, Version 2.0 (the \"License\");\n", + "# you may not use this file except in compliance with the License.\n", + "# You may obtain a copy of the License at\n", + "#\n", + "# https://www.apache.org/licenses/LICENSE-2.0\n", + "#\n", + "# Unless required by applicable law or agreed to in writing, software\n", + "# distributed under the License is distributed on an \"AS IS\" BASIS,\n", + "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", + "# See the License for the specific language governing permissions and\n", + "# limitations under the License." + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Dc1snEt7qwn6", + "colab_type": "text" + }, + "source": [ + "# [_Search on the Replay Buffer_: Bridging Planning and Reinforcement Learning](https://arxiv.org/abs/1906.05253)\n", + "\n", + "*Benjamin Eysenbach, Ruslan Salakhutdinov, and Sergey Levine*\n", + "\n", + "\n", + "What is *SoRB*? *SoRB* is a machine learning algorithm that learns to make decisions to reach goals. Typically, these sorts of control algorithms either rely on planning methods or reinforcement learning methods, both of which have limitations. Planning algorithms can reason over long horizons, but cannot deal with high-dimensional observations. Reinforcement learning algorithms fail to plan over long distances. *SoRB* attempts to combine the best of both algorithms.\n", + "\n", + "\n", + "
\n", + "The figure above highlights the basic idea.\n", + "\n", + "* (a) Goal-conditioned RL often fails to reach distant goals, but can successfully reach nearby goals (indicated in green).\n", + "* (b) Our goal is to use observations in our replay buffer (yellow squares) as waypoints leading to the goal.\n", + "* (c) We automatically find these waypoints by using the agent's value function to predict when two states are nearby, and building the corresponding graph.\n", + "* (d) We run graph search to find the sequence of waypoints (blue arrows), and then use our goal-conditioned policy to reach each waypoint.\n", + "\n", + "
\n", + "In our paper, we show how this algorithm can be used to solve complex visual navigation tasks, like the one shown above. In this colab notebook, we implement a basic version of *SoRB* on a simple navigation task. Interactive visualizations below allow you to explore the effect of various hyperparameters, as well as train your own agents.\n", + "\n", + "### Related Work\n", + "A number of prior works have proposed methods for learning goal-conditioned policies and combining planning with RL. We encourage you to check out these related works:\n", + "* Kaelbling, Leslie Pack. \"Learning to achieve goals.\" IJCAI. 1993.\n", + "* Schaul, Tom, et al. \"Universal value function approximators.\" International conference on machine learning. 2015.\n", + "* Pong, Vitchyr, et al. \"Temporal difference models: Model-free deep rl for model-based control.\" arXiv preprint arXiv:1802.09081 (2018).\n", + "* Francis, Anthony, et al. \"Long-Range Indoor Navigation with PRM-RL.\" arXiv preprint arXiv:1902.09458 (2019).\n", + "* Savinov, Nikolay, Alexey Dosovitskiy, and Vladlen Koltun. \"Semi-parametric topological memory for navigation.\" arXiv preprint arXiv:1803.00653 (2018).\n", + "\n", + "\n", + "If you find this code useful, please consider citing our paper: [https://arxiv.org/abs/1906.05253](https://arxiv.org/abs/1906.05253)\n", + "```\n", + "@misc{eysenbach2019,\n", + "Author = {Benjamin Eysenbach and Ruslan Salakhutdinov and Sergey Levine},\n", + "Title = {Search on the Replay Buffer: Bridging Planning and Reinforcement Learning},\n", + "Year = {2019},\n", + "Eprint = {arXiv:1906.05253},\n", + "}\n", + "```\n", + "\n", + "### Getting Started\n", + "To get started, click the \"Connect\" button in the top right corner of the screen. You should see a green checkmark next to some stats about RAM and Disk. Run each of the cells below, either by clicking the \"run cell\" button on the left of each cell, or by pressing [ctrl]+[enter]. **Double click on any cell to see the code.**\n", + "\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "JpFNoJBc7zur", + "colab_type": "code", + "outputId": "dedb5256-e0a9-46aa-8c41-3b2592a3fdc5", + "cellView": "form", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 701 + } + }, + "source": [ + "#@title Install Dependencies\n", + "!pip install tf-nightly\n", + "!pip install tf-agents-nightly" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Collecting tf-nightly\n", + "\u001b[?25l Downloading https://files.pythonhosted.org/packages/5a/3e/b6f8c0719908a27f542fa22d9073398f4943e2ff3cf518a53f6b029daf5f/tf_nightly-1.14.1.dev20190611-cp36-cp36m-manylinux1_x86_64.whl (102.1MB)\n", + "\u001b[K |████████████████████████████████| 102.1MB 1.3MB/s \n", + "\u001b[?25hRequirement already satisfied: google-pasta>=0.1.6 in /usr/local/lib/python3.6/dist-packages (from tf-nightly) (0.1.7)\n", + "Requirement already satisfied: six>=1.10.0 in /usr/local/lib/python3.6/dist-packages (from tf-nightly) (1.12.0)\n", + "Requirement already satisfied: keras-applications>=1.0.8 in /usr/local/lib/python3.6/dist-packages (from tf-nightly) (1.0.8)\n", + "Requirement already satisfied: keras-preprocessing>=1.0.5 in /usr/local/lib/python3.6/dist-packages (from tf-nightly) (1.1.0)\n", + "Requirement already satisfied: protobuf>=3.6.1 in /usr/local/lib/python3.6/dist-packages (from tf-nightly) (3.7.1)\n", + "Requirement already satisfied: grpcio>=1.8.6 in /usr/local/lib/python3.6/dist-packages (from tf-nightly) (1.15.0)\n", + "Requirement already satisfied: gast>=0.2.0 in /usr/local/lib/python3.6/dist-packages (from tf-nightly) (0.2.2)\n", + "Requirement already satisfied: wrapt>=1.11.1 in /usr/local/lib/python3.6/dist-packages (from tf-nightly) (1.11.1)\n", + "Requirement already satisfied: termcolor>=1.1.0 in /usr/local/lib/python3.6/dist-packages (from tf-nightly) (1.1.0)\n", + "Requirement already satisfied: absl-py>=0.7.0 in /usr/local/lib/python3.6/dist-packages (from tf-nightly) (0.7.1)\n", + "Requirement already satisfied: tb-nightly<1.15.0a0,>=1.14.0a0 in /usr/local/lib/python3.6/dist-packages (from tf-nightly) (1.14.0a20190603)\n", + "Requirement already satisfied: wheel>=0.26 in /usr/local/lib/python3.6/dist-packages (from tf-nightly) (0.33.4)\n", + "Requirement already satisfied: numpy<2.0,>=1.14.5 in /usr/local/lib/python3.6/dist-packages (from tf-nightly) (1.16.4)\n", + "Requirement already satisfied: tf-estimator-nightly in /usr/local/lib/python3.6/dist-packages (from tf-nightly) (1.14.0.dev2019060501)\n", + "Requirement already satisfied: astor>=0.6.0 in /usr/local/lib/python3.6/dist-packages (from tf-nightly) (0.8.0)\n", + "Requirement already satisfied: h5py in /usr/local/lib/python3.6/dist-packages (from keras-applications>=1.0.8->tf-nightly) (2.8.0)\n", + "Requirement already satisfied: setuptools in /usr/local/lib/python3.6/dist-packages (from protobuf>=3.6.1->tf-nightly) (41.0.1)\n", + "Requirement already satisfied: werkzeug>=0.11.15 in /usr/local/lib/python3.6/dist-packages (from tb-nightly<1.15.0a0,>=1.14.0a0->tf-nightly) (0.15.4)\n", + "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.6/dist-packages (from tb-nightly<1.15.0a0,>=1.14.0a0->tf-nightly) (3.1.1)\n", + "Installing collected packages: tf-nightly\n", + "Successfully installed tf-nightly-1.14.1.dev20190611\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "application/vnd.colab-display-data+json": { + "pip_warning": { + "packages": [ + "tensorflow" + ] + } + } + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "Requirement already satisfied: tf-agents-nightly in /usr/local/lib/python3.6/dist-packages (0.2.0.dev20190528)\n", + "Requirement already satisfied: numpy>=1.13.3 in /usr/local/lib/python3.6/dist-packages (from tf-agents-nightly) (1.16.4)\n", + "Requirement already satisfied: gin-config==0.1.3 in /usr/local/lib/python3.6/dist-packages (from tf-agents-nightly) (0.1.3)\n", + "Requirement already satisfied: six>=1.10.0 in /usr/local/lib/python3.6/dist-packages (from tf-agents-nightly) (1.12.0)\n", + "Requirement already satisfied: absl-py>=0.6.1 in /usr/local/lib/python3.6/dist-packages (from tf-agents-nightly) (0.7.1)\n", + "Requirement already satisfied: tfp-nightly in /usr/local/lib/python3.6/dist-packages (from tf-agents-nightly) (0.8.0.dev20190611)\n", + "Requirement already satisfied: decorator in /usr/local/lib/python3.6/dist-packages (from tfp-nightly->tf-agents-nightly) (4.4.0)\n", + "Requirement already satisfied: cloudpickle==1.1.1 in /usr/local/lib/python3.6/dist-packages (from tfp-nightly->tf-agents-nightly) (1.1.1)\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "bbiO8OnH8Bk7", + "colab_type": "code", + "cellView": "form", + "colab": {} + }, + "source": [ + "#@title Import dependencies.\n", + "from __future__ import absolute_import\n", + "from __future__ import division\n", + "from __future__ import print_function\n", + "\n", + "import collections\n", + "import random\n", + "import time\n", + "import tqdm\n", + "\n", + "import gym\n", + "import gym.spaces\n", + "import matplotlib.pyplot as plt\n", + "import networkx as nx\n", + "import numpy as np\n", + "import scipy.sparse.csgraph\n", + "import tensorflow as tf\n", + "\n", + "from tf_agents.agents import tf_agent\n", + "from tf_agents.agents.ddpg import actor_network\n", + "from tf_agents.agents.ddpg import critic_network\n", + "from tf_agents.drivers import dynamic_step_driver\n", + "from tf_agents.environments import gym_wrapper\n", + "from tf_agents.environments import tf_py_environment\n", + "from tf_agents.environments import wrappers\n", + "from tf_agents.eval import metric_utils\n", + "from tf_agents.metrics import tf_metrics\n", + "from tf_agents.networks import utils\n", + "from tf_agents.policies import actor_policy\n", + "from tf_agents.policies import ou_noise_policy\n", + "from tf_agents.policies import tf_policy\n", + "from tf_agents.replay_buffers import tf_uniform_replay_buffer\n", + "from tf_agents.trajectories import time_step\n", + "from tf_agents.trajectories import trajectory\n", + "from tf_agents.utils import common\n", + "\n", + "tf.compat.v1.enable_v2_behavior()\n", + "tf.enable_eager_execution()\n", + "tf.logging.set_verbosity(tf.logging.INFO)" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "esd_jQgISaff", + "colab_type": "code", + "cellView": "form", + "outputId": "b7d942bd-7d85-4c4c-91e7-1ce3e7bd64bb", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 465 + } + }, + "source": [ + "#@title Implement the 2D navigation environment and helper functions.\n", + "WALLS = {\n", + " 'Small':\n", + " np.array([[0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0]]),\n", + " 'Cross':\n", + " np.array([[0, 0, 0, 0, 0, 0, 0],\n", + " [0, 0, 0, 1, 0, 0, 0],\n", + " [0, 0, 0, 1, 0, 0, 0],\n", + " [0, 1, 1, 1, 1, 1, 0],\n", + " [0, 0, 0, 1, 0, 0, 0],\n", + " [0, 0, 0, 1, 0, 0, 0],\n", + " [0, 0, 0, 0, 0, 0, 0]]),\n", + " 'FourRooms':\n", + " np.array([[0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],\n", + " [1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1],\n", + " [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]]),\n", + " 'Spiral5x5':\n", + " np.array([[0, 0, 0, 0, 0],\n", + " [0, 1, 1, 1, 1],\n", + " [0, 1, 0, 0, 1],\n", + " [0, 1, 1, 0, 1],\n", + " [0, 0, 0, 0, 1]]),\n", + " 'Spiral7x7':\n", + " np.array([[1, 1, 1, 1, 1, 1, 1],\n", + " [1, 0, 0, 0, 0, 0, 0],\n", + " [1, 0, 1, 1, 1, 1, 0],\n", + " [1, 0, 1, 0, 0, 1, 0],\n", + " [1, 0, 1, 1, 0, 1, 0],\n", + " [1, 0, 0, 0, 0, 1, 0],\n", + " [1, 1, 1, 1, 1, 1, 0]]),\n", + " 'Spiral9x9':\n", + " np.array([[0, 0, 0, 0, 0, 0, 0, 0, 0],\n", + " [0, 1, 1, 1, 1, 1, 1, 1, 1],\n", + " [0, 1, 0, 0, 0, 0, 0, 0, 1],\n", + " [0, 1, 0, 1, 1, 1, 1, 0, 1],\n", + " [0, 1, 0, 1, 0, 0, 1, 0, 1],\n", + " [0, 1, 0, 1, 1, 0, 1, 0, 1],\n", + " [0, 1, 0, 0, 0, 0, 1, 0, 1],\n", + " [0, 1, 1, 1, 1, 1, 1, 0, 1],\n", + " [0, 0, 0, 0, 0, 0, 0, 0, 1]]),\n", + " 'Spiral11x11':\n", + " np.array([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],\n", + " [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", + " [1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0],\n", + " [1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0],\n", + " [1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0],\n", + " [1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0],\n", + " [1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0],\n", + " [1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0],\n", + " [1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0],\n", + " [1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],\n", + " [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0]]),\n", + " 'Maze3x3':\n", + " np.array([[0, 0, 0],\n", + " [1, 1, 0],\n", + " [0, 0, 0]]),\n", + " 'Maze6x6':\n", + " np.array([[0, 0, 1, 0, 0, 0],\n", + " [1, 0, 1, 0, 1, 0],\n", + " [0, 0, 1, 0, 1, 1],\n", + " [0, 1, 1, 0, 0, 1],\n", + " [0, 0, 1, 1, 0, 1],\n", + " [1, 0, 0, 0, 0, 1]]),\n", + " 'Maze11x11':\n", + " np.array([[0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0],\n", + " [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0],\n", + " [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0],\n", + " [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0],\n", + " [0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0],\n", + " [1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0],\n", + " [1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0],\n", + " [1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0],\n", + " [0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0],\n", + " [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0],\n", + " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]),\n", + " 'Tunnel':\n", + " np.array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0],\n", + " [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0],\n", + " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0],\n", + " [0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0],\n", + " [0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0],\n", + " [0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],\n", + " [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0],\n", + " [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0],\n", + " [0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0],\n", + " [0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],\n", + " [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0],\n", + " [0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0],\n", + " [0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0],\n", + " [0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0],\n", + " [0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", + " [0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0],\n", + " [0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0],\n", + " [0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", + " [0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0],\n", + " [0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0],\n", + " [0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0],\n", + " [0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]]),\n", + " 'U':\n", + " np.array([[0, 0, 0],\n", + " [0, 1, 0],\n", + " [0, 1, 0],\n", + " [0, 1, 0],\n", + " [1, 1, 0],\n", + " [0, 1, 0],\n", + " [0, 1, 0],\n", + " [0, 1, 0],\n", + " [0, 0, 0]]),\n", + " 'Tree':\n", + " np.array([\n", + " [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],\n", + " [1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1],\n", + " [1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1],\n", + " [1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1],\n", + " [1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1],\n", + " [0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0],\n", + " [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0],\n", + " [0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0],\n", + " [0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0],\n", + " [0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0],\n", + " [0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0],\n", + " [0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0],\n", + " [0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0],\n", + " ]),\n", + " 'UMulti':\n", + " np.array([\n", + " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", + " [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0],\n", + " [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],\n", + " [0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0],\n", + " [0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0],\n", + " [0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0],\n", + " [0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0],\n", + " [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0],\n", + " [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0],\n", + " [0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0],\n", + " [1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0],\n", + " [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0],\n", + " [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0],\n", + " [0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0],\n", + " [0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0],\n", + " [0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0],\n", + " [0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0],\n", + " [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],\n", + " [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0],\n", + " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", + " ]),\n", + " 'FlyTrapSmall':\n", + " np.array([\n", + " [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1],\n", + " [1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1],\n", + " [0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0],\n", + " [0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0],\n", + " [0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0],\n", + " [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],\n", + " [0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0],\n", + " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", + " [0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0],\n", + " [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],\n", + " [0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0],\n", + " [0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0],\n", + " [0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0],\n", + " [1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1],\n", + " [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1],\n", + " ]),\n", + " 'FlyTrapBig':\n", + " np.array([\n", + " [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1],\n", + " [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],\n", + " [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],\n", + " [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],\n", + " [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],\n", + " [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],\n", + " [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],\n", + " [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],\n", + " [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],\n", + " [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],\n", + " [0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0],\n", + " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", + " [0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0],\n", + " [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],\n", + " [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],\n", + " [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],\n", + " [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],\n", + " [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],\n", + " [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],\n", + " [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],\n", + " [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],\n", + " [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],\n", + " [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1],\n", + " ]),\n", + " 'Galton':\n", + " np.array([\n", + " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", + " [0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0],\n", + " [0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0],\n", + " [0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0],\n", + " [0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0],\n", + " ]),\n", + "}\n", + "\n", + "def resize_walls(walls, factor):\n", + " \"\"\"Increase the environment by rescaling.\n", + " \n", + " Args:\n", + " walls: 0/1 array indicating obstacle locations.\n", + " factor: (int) factor by which to rescale the environment.\"\"\"\n", + " (height, width) = walls.shape\n", + " row_indices = np.array([i for i in range(height) for _ in range(factor)])\n", + " col_indices = np.array([i for i in range(width) for _ in range(factor)])\n", + " walls = walls[row_indices]\n", + " walls = walls[:, col_indices]\n", + " assert walls.shape == (factor * height, factor * width)\n", + " return walls\n", + "\n", + "\n", + "\n", + "class PointEnv(gym.Env):\n", + " \"\"\"Abstract class for 2D navigation environments.\"\"\"\n", + "\n", + " def __init__(self, walls=None, resize_factor=1,\n", + " action_noise=1.0):\n", + " \"\"\"Initialize the point environment.\n", + "\n", + " Args:\n", + " walls: (str) name of one of the maps defined above.\n", + " resize_factor: (int) Scale the map by this factor.\n", + " action_noise: (float) Standard deviation of noise to add to actions. Use 0\n", + " to add no noise.\n", + " \"\"\"\n", + " if resize_factor > 1:\n", + " self._walls = resize_walls(WALLS[walls], resize_factor)\n", + " else:\n", + " self._walls = WALLS[walls]\n", + " self._apsp = self._compute_apsp(self._walls)\n", + " (height, width) = self._walls.shape\n", + " self._height = height\n", + " self._width = width\n", + " self._action_noise = action_noise\n", + " self.action_space = gym.spaces.Box(\n", + " low=np.array([-1.0, -1.0]),\n", + " high=np.array([1.0, 1.0]),\n", + " dtype=np.float32)\n", + " self.observation_space = gym.spaces.Box(\n", + " low=np.array([0.0, 0.0]),\n", + " high=np.array([self._height, self._width]),\n", + " dtype=np.float32)\n", + " self.reset()\n", + "\n", + " def _sample_empty_state(self):\n", + " candidate_states = np.where(self._walls == 0)\n", + " num_candidate_states = len(candidate_states[0])\n", + " state_index = np.random.choice(num_candidate_states)\n", + " state = np.array([candidate_states[0][state_index],\n", + " candidate_states[1][state_index]],\n", + " dtype=np.float)\n", + " state += np.random.uniform(size=2)\n", + " assert not self._is_blocked(state)\n", + " return state\n", + " \n", + " def reset(self):\n", + " self.state = self._sample_empty_state()\n", + " return self.state.copy()\n", + " \n", + " def _get_distance(self, obs, goal):\n", + " \"\"\"Compute the shortest path distance.\n", + " \n", + " Note: This distance is *not* used for training.\"\"\"\n", + " (i1, j1) = self._discretize_state(obs)\n", + " (i2, j2) = self._discretize_state(goal)\n", + " return self._apsp[i1, j1, i2, j2]\n", + "\n", + " def _discretize_state(self, state, resolution=1.0):\n", + " (i, j) = np.floor(resolution * state).astype(np.int)\n", + " # Round down to the nearest cell if at the boundary.\n", + " if i == self._height:\n", + " i -= 1\n", + " if j == self._width:\n", + " j -= 1\n", + " return (i, j)\n", + " \n", + " def _is_blocked(self, state):\n", + " if not self.observation_space.contains(state):\n", + " return True\n", + " (i, j) = self._discretize_state(state)\n", + " return (self._walls[i, j] == 1)\n", + "\n", + " def step(self, action):\n", + " if self._action_noise > 0:\n", + " action += np.random.normal(0, self._action_noise)\n", + " action = np.clip(action, self.action_space.low, self.action_space.high)\n", + " assert self.action_space.contains(action)\n", + " num_substeps = 10\n", + " dt = 1.0 / num_substeps\n", + " num_axis = len(action)\n", + " for _ in np.linspace(0, 1, num_substeps):\n", + " for axis in range(num_axis):\n", + " new_state = self.state.copy()\n", + " new_state[axis] += dt * action[axis]\n", + " if not self._is_blocked(new_state):\n", + " self.state = new_state\n", + "\n", + " done = False\n", + " rew = -1.0 * np.linalg.norm(self.state)\n", + " return self.state.copy(), rew, done, {}\n", + "\n", + " @property\n", + " def walls(self):\n", + " return self._walls\n", + "\n", + " def _compute_apsp(self, walls):\n", + " (height, width) = walls.shape\n", + " g = nx.Graph()\n", + " # Add all the nodes\n", + " for i in range(height):\n", + " for j in range(width):\n", + " if walls[i, j] == 0:\n", + " g.add_node((i, j))\n", + "\n", + " # Add all the edges\n", + " for i in range(height):\n", + " for j in range(width):\n", + " for di in [-1, 0, 1]:\n", + " for dj in [-1, 0, 1]:\n", + " if di == dj == 0: continue # Don't add self loops\n", + " if i + di < 0 or i + di > height - 1: continue # No cell here\n", + " if j + dj < 0 or j + dj > width - 1: continue # No cell here\n", + " if walls[i, j] == 1: continue # Don't add edges to walls\n", + " if walls[i + di, j + dj] == 1: continue # Don't add edges to walls\n", + " g.add_edge((i, j), (i + di, j + dj))\n", + "\n", + " # dist[i, j, k, l] is path from (i, j) -> (k, l)\n", + " dist = np.full((height, width, height, width), np.float('inf'))\n", + " for ((i1, j1), dist_dict) in nx.shortest_path_length(g):\n", + " for ((i2, j2), d) in dist_dict.items():\n", + " dist[i1, j1, i2, j2] = d\n", + " return dist\n", + "\n", + "class GoalConditionedPointWrapper(gym.Wrapper):\n", + " \"\"\"Wrapper that appends goal to state produced by environment.\"\"\"\n", + "\n", + " \n", + " def __init__(self, env, prob_constraint=0.8, min_dist=0, max_dist=4,\n", + " threshold_distance=1.0):\n", + " \"\"\"Initialize the environment.\n", + "\n", + " Args:\n", + " env: an environment.\n", + " prob_constraint: (float) Probability that the distance constraint is\n", + " followed after resetting.\n", + " min_dist: (float) When the constraint is enforced, ensure the goal is at\n", + " least this far from the initial state.\n", + " max_dist: (float) When the constraint is enforced, ensure the goal is at\n", + " most this far from the initial state.\n", + " threshold_distance: (float) States are considered equivalent if they are\n", + " at most this far away from one another.\n", + " \"\"\"\n", + " self._threshold_distance = threshold_distance\n", + " self._prob_constraint = prob_constraint\n", + " self._min_dist = min_dist\n", + " self._max_dist = max_dist\n", + " super(GoalConditionedPointWrapper, self).__init__(env)\n", + " self.observation_space = gym.spaces.Dict({\n", + " 'observation': env.observation_space,\n", + " 'goal': env.observation_space,\n", + " })\n", + " \n", + " def _normalize_obs(self, obs):\n", + " return np.array([\n", + " obs[0] / float(self.env._height),\n", + " obs[1] / float(self.env._width)\n", + " ])\n", + "\n", + " def reset(self):\n", + " goal = None\n", + " count = 0\n", + " while goal is None:\n", + " obs = self.env.reset()\n", + " (obs, goal) = self._sample_goal(obs)\n", + " count += 1\n", + " if count > 1000:\n", + " print('WARNING: Unable to find goal within constraints.')\n", + " self._goal = goal\n", + " return {'observation': self._normalize_obs(obs),\n", + " 'goal': self._normalize_obs(self._goal)}\n", + "\n", + " def step(self, action):\n", + " obs, _, _, _ = self.env.step(action)\n", + " rew = -1.0\n", + " done = self._is_done(obs, self._goal)\n", + " return {'observation': self._normalize_obs(obs),\n", + " 'goal': self._normalize_obs(self._goal)}, rew, done, {}\n", + "\n", + " def set_sample_goal_args(self, prob_constraint=None,\n", + " min_dist=None, max_dist=None):\n", + " assert prob_constraint is not None\n", + " assert min_dist is not None\n", + " assert max_dist is not None\n", + " assert min_dist >= 0\n", + " assert max_dist >= min_dist\n", + " self._prob_constraint = prob_constraint\n", + " self._min_dist = min_dist\n", + " self._max_dist = max_dist\n", + "\n", + " def _is_done(self, obs, goal):\n", + " \"\"\"Determines whether observation equals goal.\"\"\"\n", + " return np.linalg.norm(obs - goal) < self._threshold_distance\n", + "\n", + " def _sample_goal(self, obs):\n", + " \"\"\"Sampled a goal state.\"\"\"\n", + " if np.random.random() < self._prob_constraint:\n", + " return self._sample_goal_constrained(obs, self._min_dist, self._max_dist)\n", + " else:\n", + " return self._sample_goal_unconstrained(obs)\n", + "\n", + " def _sample_goal_constrained(self, obs, min_dist, max_dist):\n", + " \"\"\"Samples a goal with dist min_dist <= d(obs, goal) <= max_dist.\n", + "\n", + " Args:\n", + " obs: observation (without goal).\n", + " min_dist: (int) minimum distance to goal.\n", + " max_dist: (int) maximum distance to goal.\n", + " Returns:\n", + " obs: observation (without goal).\n", + " goal: a goal state.\n", + " \"\"\"\n", + " (i, j) = self.env._discretize_state(obs)\n", + " mask = np.logical_and(self.env._apsp[i, j] >= min_dist,\n", + " self.env._apsp[i, j] <= max_dist)\n", + " mask = np.logical_and(mask, self.env._walls == 0)\n", + " candidate_states = np.where(mask)\n", + " num_candidate_states = len(candidate_states[0])\n", + " if num_candidate_states == 0:\n", + " return (obs, None)\n", + " goal_index = np.random.choice(num_candidate_states)\n", + " goal = np.array([candidate_states[0][goal_index],\n", + " candidate_states[1][goal_index]],\n", + " dtype=np.float)\n", + " goal += np.random.uniform(size=2)\n", + " dist_to_goal = self.env._get_distance(obs, goal)\n", + " assert min_dist <= dist_to_goal <= max_dist\n", + " assert not self.env._is_blocked(goal)\n", + " return (obs, goal)\n", + " \n", + " def _sample_goal_unconstrained(self, obs):\n", + " \"\"\"Samples a goal without any constraints.\n", + "\n", + " Args:\n", + " obs: observation (without goal).\n", + " Returns:\n", + " obs: observation (without goal).\n", + " goal: a goal state.\n", + " \"\"\"\n", + " return (obs, self.env._sample_empty_state())\n", + " \n", + " @property\n", + " def max_goal_dist(self):\n", + " apsp = self.env._apsp\n", + " return np.max(apsp[np.isfinite(apsp)])\n", + " \n", + "\n", + "class NonTerminatingTimeLimit(wrappers.PyEnvironmentBaseWrapper):\n", + " \"\"\"Resets the environment without setting done = True.\n", + "\n", + " Resets the environment if either these conditions holds:\n", + " 1. The base environment returns done = True\n", + " 2. The time limit is exceeded.\n", + " \"\"\"\n", + "\n", + " def __init__(self, env, duration):\n", + " super(NonTerminatingTimeLimit, self).__init__(env)\n", + " self._duration = duration\n", + " self._step_count = None\n", + "\n", + " def _reset(self):\n", + " self._step_count = 0\n", + " return self._env.reset()\n", + "\n", + " @property\n", + " def duration(self):\n", + " return self._duration\n", + "\n", + " def _step(self, action):\n", + " if self._step_count is None:\n", + " return self.reset()\n", + "\n", + " ts = self._env.step(action)\n", + "\n", + " self._step_count += 1\n", + " if self._step_count >= self._duration or ts.is_last():\n", + " self._step_count = None\n", + "\n", + " return ts\n", + " \n", + "def env_load_fn(environment_name,\n", + " max_episode_steps=None,\n", + " resize_factor=1,\n", + " gym_env_wrappers=(GoalConditionedPointWrapper,),\n", + " terminate_on_timeout=False):\n", + " \"\"\"Loads the selected environment and wraps it with the specified wrappers.\n", + "\n", + " Args:\n", + " environment_name: Name for the environment to load.\n", + " max_episode_steps: If None the max_episode_steps will be set to the default\n", + " step limit defined in the environment's spec. No limit is applied if set\n", + " to 0 or if there is no timestep_limit set in the environment's spec.\n", + " gym_env_wrappers: Iterable with references to wrapper classes to use\n", + " directly on the gym environment.\n", + " terminate_on_timeout: Whether to set done = True when the max episode\n", + " steps is reached.\n", + "\n", + " Returns:\n", + " A PyEnvironmentBase instance.\n", + " \"\"\"\n", + " gym_env = PointEnv(walls=environment_name,\n", + " resize_factor=resize_factor)\n", + " \n", + " for wrapper in gym_env_wrappers:\n", + " gym_env = wrapper(gym_env)\n", + " env = gym_wrapper.GymWrapper(\n", + " gym_env,\n", + " discount=1.0,\n", + " auto_reset=True,\n", + " )\n", + "\n", + " if max_episode_steps > 0:\n", + " if terminate_on_timeout:\n", + " env = wrappers.TimeLimit(env, max_episode_steps)\n", + " else:\n", + " env = NonTerminatingTimeLimit(env, max_episode_steps)\n", + "\n", + " return tf_py_environment.TFPyEnvironment(env)\n", + "\n", + "def plot_walls(walls):\n", + " walls = walls.T\n", + " (height, width) = walls.shape\n", + " for (i, j) in zip(*np.where(walls)):\n", + " x = np.array([j, j+1]) / float(width)\n", + " y0 = np.array([i, i]) / float(height)\n", + " y1 = np.array([i+1, i+1]) / float(height)\n", + " plt.fill_between(x, y0, y1, color='grey')\n", + " plt.xlim([0, 1])\n", + " plt.ylim([0, 1])\n", + " plt.xticks([])\n", + " plt.yticks([])\n", + " \n", + "plt.figure(figsize=(12, 7))\n", + "for index, (name, walls) in enumerate(WALLS.items()):\n", + " plt.subplot(3, 6, index + 1)\n", + " plt.title(name)\n", + " plot_walls(walls)\n", + "plt.subplots_adjust(wspace=0.1, hspace=0.2)\n", + "plt.suptitle('Navigation Environments', fontsize=20)\n", + "plt.show()" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAArMAAAHACAYAAACxueDpAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n7vHEdZYAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "3nLaKviAXrq9", + "colab_type": "code", + "cellView": "form", + "colab": {} + }, + "source": [ + "#@title Implement the goal-conditioned actor and critic.\n", + "\n", + "def set_goal(traj, goal):\n", + " \"\"\"Sets the goal of a Trajectory or TimeStep.\"\"\"\n", + " for obs_field in ['observation', 'goal']:\n", + " assert obs_field in traj.observation.keys()\n", + " obs = traj.observation['observation']\n", + " tf.nest.assert_same_structure(obs, goal)\n", + " modified_traj = traj._replace(\n", + " observation={'observation': obs, 'goal': goal})\n", + " return modified_traj\n", + "\n", + "def merge_obs_goal(observations):\n", + " \"\"\"Merge the observation and goal fields into a single tensor.\n", + "\n", + " If both are 1D, we concatenate the observation and goal together. If both are\n", + " 3D, we stack along the third axis, so the resulting tensor has\n", + " shape (H x W x 2 * D).\n", + "\n", + " Args:\n", + " observations: Dictionary-type observations.\n", + " Returns:\n", + " a merged observation\n", + " \"\"\"\n", + " obs = observations['observation']\n", + " goal = observations['goal']\n", + "\n", + " assert obs.shape == goal.shape\n", + " # For 1D observations, simply concatenate them together.\n", + " assert len(obs.shape) == 2\n", + " modified_observations = tf.concat([obs, goal], axis=-1)\n", + " assert obs.shape[0] == modified_observations.shape[0]\n", + " assert modified_observations.shape[1] == obs.shape[1] + goal.shape[1]\n", + " return modified_observations\n", + "\n", + "\n", + "class GoalConditionedActorNetwork(actor_network.ActorNetwork):\n", + " \"\"\"Actor network that takes observations and goals as inputs.\"\"\"\n", + "\n", + " def __init__(self,\n", + " input_tensor_spec,\n", + " output_tensor_spec,\n", + " **kwargs):\n", + " modified_tensor_spec = None\n", + " super(GoalConditionedActorNetwork, self).__init__(\n", + " modified_tensor_spec, output_tensor_spec,\n", + " fc_layer_params=(256, 256),\n", + " **kwargs)\n", + " self._input_tensor_spec = input_tensor_spec\n", + "\n", + " def call(self, observations, step_type=(), network_state=()):\n", + " modified_observations = merge_obs_goal(observations)\n", + " return super(GoalConditionedActorNetwork, self).call(\n", + " modified_observations, step_type=step_type, network_state=network_state)\n", + "\n", + "\n", + "class GoalConditionedCriticNetwork(critic_network.CriticNetwork):\n", + " \"\"\"Actor network that takes observations and goals as inputs.\n", + "\n", + " Further modified so it can make multiple predictions.\n", + " \"\"\"\n", + "\n", + " def __init__(self,\n", + " input_tensor_spec,\n", + " observation_conv_layer_params=None,\n", + " observation_fc_layer_params=(256,),\n", + " action_fc_layer_params=None,\n", + " joint_fc_layer_params=(256,),\n", + " activation_fn=tf.nn.relu,\n", + " name='CriticNetwork',\n", + " output_dim=None):\n", + " \"\"\"Creates an instance of `CriticNetwork`.\n", + "\n", + " Args:\n", + " input_tensor_spec: A tuple of (observation, action) each a nest of\n", + " `tensor_spec.TensorSpec` representing the inputs.\n", + " observation_conv_layer_params: Optional list of convolution layer\n", + " parameters for observations, where each item is a length-three tuple\n", + " indicating (num_units, kernel_size, stride).\n", + " observation_fc_layer_params: Optional list of fully connected parameters\n", + " for observations, where each item is the number of units in the layer.\n", + " action_fc_layer_params: Optional list of fully connected parameters for\n", + " actions, where each item is the number of units in the layer.\n", + " joint_fc_layer_params: Optional list of fully connected parameters after\n", + " merging observations and actions, where each item is the number of units\n", + " in the layer.\n", + " activation_fn: Activation function, e.g. tf.nn.relu, slim.leaky_relu, ...\n", + " name: A string representing name of the network.\n", + " output_dim: An integer specifying the number of outputs. If None, output\n", + " will be flattened.\n", + "\n", + " \"\"\"\n", + " self._output_dim = output_dim\n", + " (_, action_spec) = input_tensor_spec\n", + " modified_obs_spec = None\n", + " modified_tensor_spec = (modified_obs_spec, action_spec)\n", + "\n", + " super(critic_network.CriticNetwork, self).__init__(\n", + " input_tensor_spec=modified_tensor_spec,\n", + " state_spec=(),\n", + " name=name)\n", + " self._input_tensor_spec = input_tensor_spec\n", + "\n", + " flat_action_spec = tf.nest.flatten(action_spec)\n", + " if len(flat_action_spec) > 1:\n", + " raise ValueError('Only a single action is supported by this network')\n", + " self._single_action_spec = flat_action_spec[0]\n", + "\n", + " self._observation_layers = utils.mlp_layers(\n", + " observation_conv_layer_params,\n", + " observation_fc_layer_params,\n", + " activation_fn=activation_fn,\n", + " kernel_initializer=tf.keras.initializers.VarianceScaling(\n", + " scale=1. / 3., mode='fan_in', distribution='uniform'),\n", + " name='observation_encoding')\n", + "\n", + " self._action_layers = utils.mlp_layers(\n", + " None,\n", + " action_fc_layer_params,\n", + " activation_fn=activation_fn,\n", + " kernel_initializer=tf.keras.initializers.VarianceScaling(\n", + " scale=1. / 3., mode='fan_in', distribution='uniform'),\n", + " name='action_encoding')\n", + "\n", + " self._joint_layers = utils.mlp_layers(\n", + " None,\n", + " joint_fc_layer_params,\n", + " activation_fn=activation_fn,\n", + " kernel_initializer=tf.keras.initializers.VarianceScaling(\n", + " scale=1. / 3., mode='fan_in', distribution='uniform'),\n", + " name='joint_mlp')\n", + "\n", + " self._joint_layers.append(\n", + " tf.keras.layers.Dense(\n", + " self._output_dim if self._output_dim is not None else 1,\n", + " activation=None,\n", + " kernel_initializer=tf.keras.initializers.RandomUniform(\n", + " minval=-0.003, maxval=0.003),\n", + " name='value'))\n", + "\n", + " def call(self, inputs, step_type=(), network_state=()):\n", + " observations, actions = inputs\n", + " modified_observations = merge_obs_goal(observations)\n", + " modified_inputs = (modified_observations, actions)\n", + " output = super(GoalConditionedCriticNetwork, self).call(\n", + " modified_inputs, step_type=step_type, network_state=network_state)\n", + " (predictions, network_state) = output\n", + "\n", + " # We have to reshape the output, which is flattened by default\n", + " if self._output_dim is not None:\n", + " predictions = tf.reshape(predictions, [-1, self._output_dim])\n", + "\n", + " return predictions, network_state" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "66Rh9rum8qNh", + "colab_type": "code", + "cellView": "form", + "colab": {} + }, + "source": [ + "#@title Implement the goal-conditioned agent.\n", + "\n", + "class UvfAgent(tf_agent.TFAgent):\n", + " \"\"\"A UVF Agent.\"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " time_step_spec,\n", + " action_spec,\n", + " ou_stddev=1.0,\n", + " ou_damping=1.0,\n", + " target_update_tau=0.05,\n", + " target_update_period=5,\n", + " max_episode_steps=None,\n", + " ensemble_size=3,\n", + " combine_ensemble_method='min',\n", + " use_distributional_rl=True):\n", + " \"\"\"Creates a Uvf Agent.\n", + "\n", + " Args:\n", + " time_step_spec: A `TimeStep` spec of the expected time_steps.\n", + " action_spec: A nest of BoundedTensorSpec representing the actions.\n", + " ou_stddev: Standard deviation for the Ornstein-Uhlenbeck (OU) noise added\n", + " in the default collect policy.\n", + " ou_damping: Damping factor for the OU noise added in the default collect\n", + " policy.\n", + " target_update_tau: Factor for soft update of the target networks.\n", + " target_update_period: Period for soft update of the target networks.\n", + " max_episode_steps: Int indicating number of steps in an episode. Used for\n", + " determining the number of bins for distributional RL.\n", + " ensemble_size: (int) Number of models in ensemble of critics.\n", + " combine_ensemble_method: (str) At test time, how to combine the distances\n", + " predicted by each member of the ensemble. Options are 'mean', 'min',\n", + " and 'td3'. The 'td3' option is pessimistic w.r.t. the pdf, and then\n", + " takes computes the corresponding distance. The 'min' option takes the\n", + " minimum q values, corresponding to taking the maximum predicted\n", + " distance. Note that we never aggregate predictions during training.\n", + " use_distributional_rl: (bool) Whether to use distributional RL.\n", + " \"\"\"\n", + " tf.Module.__init__(self, name='UvfAgent')\n", + "\n", + " assert max_episode_steps is not None\n", + " self._max_episode_steps = max_episode_steps\n", + " self._ensemble_size = ensemble_size\n", + " self._use_distributional_rl = use_distributional_rl\n", + "\n", + " # Create the actor\n", + " self._actor_network = GoalConditionedActorNetwork(\n", + " time_step_spec.observation, action_spec)\n", + " self._target_actor_network = self._actor_network.copy(\n", + " name='TargetActorNetwork')\n", + "\n", + " # Create a prototypical critic, which we will copy to create the ensemble.\n", + " critic_net_input_specs = (time_step_spec.observation, action_spec)\n", + " critic_network = GoalConditionedCriticNetwork(\n", + " critic_net_input_specs,\n", + " output_dim=max_episode_steps if use_distributional_rl else None,\n", + " )\n", + " self._critic_network_list = []\n", + " self._target_critic_network_list = []\n", + " for ensemble_index in range(self._ensemble_size):\n", + " self._critic_network_list.append(\n", + " critic_network.copy(name='CriticNetwork%d' % ensemble_index))\n", + " self._target_critic_network_list.append(\n", + " critic_network.copy(name='TargetCriticNetwork%d' % ensemble_index))\n", + "\n", + " self._actor_optimizer = tf.train.AdamOptimizer(learning_rate=3e-4)\n", + " self._critic_optimizer = tf.train.AdamOptimizer(learning_rate=3e-4)\n", + " \n", + " self._ou_stddev = ou_stddev\n", + " self._ou_damping = ou_damping\n", + " self._target_update_tau = target_update_tau\n", + " self._target_update_period = target_update_period\n", + " \n", + " self._update_target = self._get_target_updater(\n", + " target_update_tau, target_update_period)\n", + "\n", + " policy = actor_policy.ActorPolicy(\n", + " time_step_spec=time_step_spec, action_spec=action_spec,\n", + " actor_network=self._actor_network, clip=True)\n", + " collect_policy = actor_policy.ActorPolicy(\n", + " time_step_spec=time_step_spec, action_spec=action_spec,\n", + " actor_network=self._actor_network, clip=False)\n", + " collect_policy = ou_noise_policy.OUNoisePolicy(\n", + " collect_policy,\n", + " ou_stddev=self._ou_stddev,\n", + " ou_damping=self._ou_damping,\n", + " clip=True)\n", + "\n", + " super(UvfAgent, self).__init__(\n", + " time_step_spec,\n", + " action_spec,\n", + " policy,\n", + " collect_policy,\n", + " train_sequence_length=2)\n", + "\n", + " def initialize_search(self, active_set, max_search_steps=3,\n", + " combine_ensemble_method='min'):\n", + " self._combine_ensemble_method = combine_ensemble_method\n", + " self._max_search_steps = max_search_steps\n", + " self._active_set_tensor = tf.convert_to_tensor(active_set)\n", + " pdist = self._get_pairwise_dist(self._active_set_tensor, masked=True,\n", + " aggregate=combine_ensemble_method) \n", + " distances = scipy.sparse.csgraph.floyd_warshall(pdist, directed=True)\n", + " self._distances_tensor = tf.convert_to_tensor(distances, dtype=tf.float32)\n", + "\n", + " def _get_pairwise_dist(self, obs_tensor, goal_tensor=None, masked=False,\n", + " aggregate='mean'):\n", + " \"\"\"Estimates the pairwise distances.\n", + " \n", + " Args:\n", + " obs_tensor: Tensor containing observations\n", + " goal_tensor: (optional) Tensor containing a second set of observations. If\n", + " not specified, computes the pairwise distances between obs_tensor and\n", + " itself.\n", + " masked: (bool) Whether to ignore edges that are too long, as defined by\n", + " max_search_steps.\n", + " aggregate: (str) How to combine the predictions from the ensemble. Options\n", + " are to take the minimum predicted q value (i.e., the maximum distance),\n", + " the mean, or to simply return all the predictions.\n", + " \"\"\"\n", + " if goal_tensor is None:\n", + " goal_tensor = obs_tensor\n", + " dist_matrix = []\n", + " for obs_index in range(obs_tensor.shape[0]):\n", + " obs = obs_tensor[obs_index]\n", + " obs_repeat_tensor = tf.ones_like(goal_tensor) * tf.expand_dims(obs, 0)\n", + " obs_goal_tensor = {'observation': obs_repeat_tensor,\n", + " 'goal': goal_tensor}\n", + " pseudo_next_time_steps = time_step.transition(obs_goal_tensor,\n", + " reward=0.0, # Ignored\n", + " discount=1.0)\n", + " dist = self._get_dist_to_goal(pseudo_next_time_steps, aggregate=aggregate)\n", + " dist_matrix.append(dist)\n", + "\n", + " pairwise_dist = tf.stack(dist_matrix)\n", + " if aggregate is None:\n", + " pairwise_dist = tf.transpose(pairwise_dist, perm=[1, 0, 2])\n", + "\n", + " if masked:\n", + " mask = (pairwise_dist > self._max_search_steps)\n", + " return tf.where(mask, tf.fill(pairwise_dist.shape, np.inf), \n", + " pairwise_dist)\n", + " else:\n", + " return pairwise_dist\n", + "\n", + " def _get_critic_output(self, critic_net_list, next_time_steps,\n", + " actions=None):\n", + " \"\"\"Calls the critic net.\n", + "\n", + " Args:\n", + " critic_net_list: (list) List of critic networks.\n", + " next_time_steps: time_steps holding the observations and step types\n", + " actions: (optional) actions to compute the Q values for. If None, returns\n", + " the Q values for the best action.\n", + " Returns:\n", + " q_values_list: (list) List containing a tensor of q values for each member\n", + " of the ensemble. For distributional RL, computes the expectation over the\n", + " distribution.\n", + " \"\"\"\n", + " q_values_list = []\n", + " critic_net_input = (next_time_steps.observation, actions)\n", + " for critic_index in range(self._ensemble_size):\n", + " critic_net = critic_net_list[critic_index]\n", + " q_values, _ = critic_net(critic_net_input, next_time_steps.step_type)\n", + " q_values_list.append(q_values)\n", + " return q_values_list\n", + " \n", + " def _get_expected_q_values(self, next_time_steps, actions=None):\n", + " if actions is None:\n", + " actions, _ = self._actor_network(next_time_steps.observation,\n", + " next_time_steps.step_type)\n", + "\n", + " q_values_list = self._get_critic_output(self._critic_network_list,\n", + " next_time_steps, actions)\n", + "\n", + " expected_q_values_list = []\n", + " for q_values in q_values_list:\n", + " if self._use_distributional_rl:\n", + " q_probs = tf.nn.softmax(q_values, axis=1)\n", + " batch_size = q_probs.shape[0]\n", + " bin_range = tf.range(1, self._max_episode_steps + 1, dtype=tf.float32)\n", + " ### NOTE: We want to compute the value of each bin, which is the\n", + " # negative distance. Without properly negating this, the actor is\n", + " # optimized to take the *worst* actions.\n", + " neg_bin_range = -1.0 * bin_range\n", + " tiled_bin_range = tf.tile(tf.expand_dims(neg_bin_range, 0),\n", + " [batch_size, 1])\n", + " assert q_probs.shape == tiled_bin_range.shape\n", + "\n", + " ### Take the inner produce between these two tensors\n", + " expected_q_values = tf.reduce_sum(q_probs * tiled_bin_range, axis=1)\n", + " expected_q_values_list.append(expected_q_values)\n", + " else:\n", + " expected_q_values_list.append(q_values)\n", + " return tf.stack(expected_q_values_list)\n", + "\n", + " def _get_state_values(self, next_time_steps, actions=None, aggregate='mean'):\n", + " \"\"\"Computes the value function, averaging across bins (for distributional RL)\n", + " and the ensemble (for bootstrap RL).\n", + "\n", + " Args:\n", + " next_time_steps: time_steps holding the observations and step types\n", + " actions: actions for which to compute the Q values. If None, uses the\n", + " best actions (i.e., returns the value function).\n", + " Returns:\n", + " state_values: Tensor storing the state values for each sample in the\n", + " batch. These values should all be negative.\n", + " \"\"\"\n", + " with tf.name_scope('state_values'):\n", + " expected_q_values = self._get_expected_q_values(next_time_steps, actions)\n", + " if aggregate is not None:\n", + " if aggregate == 'mean':\n", + " expected_q_values = tf.reduce_mean(expected_q_values, axis=0)\n", + " elif aggregate == 'min':\n", + " expected_q_values = tf.reduce_min(expected_q_values, axis=0)\n", + " else:\n", + " raise ValueError('Unknown method for combining ensemble: %s' %\n", + " aggregate)\n", + "\n", + " # Clip the q values if not using distributional RL. If using\n", + " # distributional RL, the q values are implicitly clipped.\n", + " if not self._use_distributional_rl:\n", + " min_q_val = -1.0 * self._max_episode_steps\n", + " max_q_val = 0.0\n", + " expected_q_values = tf.maximum(expected_q_values, min_q_val)\n", + " expected_q_values = tf.minimum(expected_q_values, max_q_val)\n", + " return expected_q_values\n", + "\n", + " def _get_dist_to_goal(self, next_time_step, aggregate='mean'):\n", + " q_values = self._get_state_values(next_time_step, aggregate=aggregate)\n", + " return -1.0 * q_values\n", + "\n", + " def _get_waypoint(self, next_time_steps):\n", + " obs_tensor = next_time_steps.observation['observation']\n", + " goal_tensor = next_time_steps.observation['goal']\n", + " obs_to_active_set_dist = self._get_pairwise_dist(\n", + " obs_tensor, self._active_set_tensor, masked=True,\n", + " aggregate=self._combine_ensemble_method) # B x A\n", + " active_set_to_goal_dist = self._get_pairwise_dist(\n", + " self._active_set_tensor, goal_tensor, masked=True,\n", + " aggregate=self._combine_ensemble_method) # A x B\n", + "\n", + " # The search_dist tensor should be (B x A x A)\n", + " search_dist = sum([\n", + " tf.expand_dims(obs_to_active_set_dist, 2),\n", + " tf.expand_dims(self._distances_tensor, 0),\n", + " tf.expand_dims(tf.transpose(active_set_to_goal_dist), axis=1)\n", + " ])\n", + "\n", + " # We assume a batch size of 1.\n", + " assert obs_tensor.shape[0] == 1\n", + " min_search_dist = tf.reduce_min(search_dist, axis=[1, 2])[0]\n", + " waypoint_index = tf.argmin(tf.reduce_min(search_dist, axis=[2]), axis=1)[0]\n", + " waypoint = self._active_set_tensor[waypoint_index]\n", + "\n", + " return waypoint, min_search_dist\n", + "\n", + " def _initialize(self):\n", + " for ensemble_index in range(self._ensemble_size):\n", + " common.soft_variables_update(\n", + " self._critic_network_list[ensemble_index].variables,\n", + " self._target_critic_network_list[ensemble_index].variables,\n", + " tau=1.0)\n", + " # Caution: actor should only be updated once.\n", + " common.soft_variables_update(\n", + " self._actor_network.variables,\n", + " self._target_actor_network.variables,\n", + " tau=1.0)\n", + "\n", + " def _get_target_updater(self, tau=1.0, period=1):\n", + " \"\"\"Performs a soft update of the target network parameters.\n", + "\n", + " For each weight w_s in the original network, and its corresponding\n", + " weight w_t in the target network, a soft update is:\n", + " w_t = (1- tau) x w_t + tau x ws\n", + "\n", + " Args:\n", + " tau: A float scalar in [0, 1]. Default `tau=1.0` means hard update.\n", + " period: Step interval at which the target networks are updated.\n", + " Returns:\n", + " An operation that performs a soft update of the target network parameters.\n", + " \"\"\"\n", + " with tf.name_scope('get_target_updater'):\n", + " def update(): # pylint: disable=missing-docstring\n", + " critic_update_list = []\n", + " for ensemble_index in range(self._ensemble_size):\n", + " critic_update = common.soft_variables_update(\n", + " self._critic_network_list[ensemble_index].variables,\n", + " self._target_critic_network_list[ensemble_index].variables, tau)\n", + " critic_update_list.append(critic_update)\n", + " actor_update = common.soft_variables_update(\n", + " self._actor_network.variables,\n", + " self._target_actor_network.variables, tau)\n", + " return tf.group(critic_update_list + [actor_update])\n", + "\n", + " return common.Periodically(update, period, 'periodic_update_targets')\n", + "\n", + " def _experience_to_transitions(self, experience):\n", + " transitions = trajectory.to_transition(experience)\n", + " transitions = tf.nest.map_structure(lambda x: tf.squeeze(x, [1]),\n", + " transitions)\n", + "\n", + " time_steps, policy_steps, next_time_steps = transitions\n", + " actions = policy_steps.action\n", + " return time_steps, actions, next_time_steps\n", + "\n", + " def _train(self, experience, weights=None):\n", + " del weights\n", + " time_steps, actions, next_time_steps = self._experience_to_transitions(\n", + " experience)\n", + "\n", + " # Update the critic\n", + " critic_vars = []\n", + " for ensemble_index in range(self._ensemble_size):\n", + " critic_net = self._critic_network_list[ensemble_index]\n", + " critic_vars.extend(critic_net.variables)\n", + "\n", + " with tf.GradientTape(watch_accessed_variables=False) as tape:\n", + " assert critic_vars\n", + " tape.watch(critic_vars)\n", + " critic_loss = self.critic_loss(time_steps, actions, next_time_steps)\n", + " tf.debugging.check_numerics(critic_loss, 'Critic loss is inf or nan.')\n", + " critic_grads = tape.gradient(critic_loss, critic_vars)\n", + " self._apply_gradients(critic_grads, critic_vars,\n", + " self._critic_optimizer)\n", + "\n", + " # Update the actor\n", + " actor_vars = self._actor_network.variables\n", + " with tf.GradientTape(watch_accessed_variables=False) as tape:\n", + " assert actor_vars, 'No actor variables to optimize.'\n", + " tape.watch(actor_vars)\n", + " actor_loss = self.actor_loss(time_steps)\n", + " tf.debugging.check_numerics(actor_loss, 'Actor loss is inf or nan.')\n", + " actor_grads = tape.gradient(actor_loss, actor_vars)\n", + " self._apply_gradients(actor_grads, actor_vars, self._actor_optimizer)\n", + "\n", + " self.train_step_counter.assign_add(1)\n", + " self._update_target()\n", + " total_loss = actor_loss + critic_loss\n", + " return tf_agent.LossInfo(total_loss, (actor_loss, critic_loss))\n", + "\n", + " def _apply_gradients(self, gradients, variables, optimizer):\n", + " # Tuple is used for py3, where zip is a generator producing values once.\n", + " grads_and_vars = tuple(zip(gradients, variables))\n", + " optimizer.apply_gradients(grads_and_vars)\n", + "\n", + " def critic_loss(self,\n", + " time_steps,\n", + " actions,\n", + " next_time_steps):\n", + " \"\"\"Computes the critic loss for UvfAgent training.\n", + "\n", + " Args:\n", + " time_steps: A batch of timesteps.\n", + " actions: A batch of actions.\n", + " next_time_steps: A batch of next timesteps.\n", + " Returns:\n", + " critic_loss: A scalar critic loss.\n", + " \"\"\"\n", + " with tf.name_scope('critic_loss'):\n", + " # We compute the target actions once for all critics.\n", + " target_actions, _ = self._target_actor_network(\n", + " next_time_steps.observation, next_time_steps.step_type)\n", + "\n", + " critic_loss_list = []\n", + " q_values_list = self._get_critic_output(self._critic_network_list,\n", + " time_steps, actions)\n", + " target_q_values_list = self._get_critic_output(\n", + " self._target_critic_network_list, next_time_steps, target_actions)\n", + " assert len(target_q_values_list) == self._ensemble_size\n", + " for ensemble_index in range(self._ensemble_size):\n", + " # The target_q_values should be a Batch x ensemble_size tensor.\n", + " target_q_values = target_q_values_list[ensemble_index]\n", + "\n", + " if self._use_distributional_rl:\n", + " target_q_probs = tf.nn.softmax(target_q_values, axis=1)\n", + " batch_size = target_q_probs.shape[0]\n", + " one_hot = tf.one_hot(tf.zeros(batch_size, dtype=tf.int32),\n", + " self._max_episode_steps)\n", + " ### Calculate the shifted probabilities\n", + " # Fist column: Since episode didn't terminate, probability that the\n", + " # distance is 1 equals 0.\n", + " col_1 = tf.zeros((batch_size, 1))\n", + " # Middle columns: Simply the shifted probabilities.\n", + " col_middle = target_q_probs[:, :-2]\n", + " # Last column: Probability of taking at least n steps is sum of\n", + " # last two columns in unshifted predictions:\n", + " col_last = tf.reduce_sum(target_q_probs[:, -2:], axis=1,\n", + " keepdims=True)\n", + "\n", + " shifted_target_q_probs = tf.concat([col_1, col_middle, col_last],\n", + " axis=1)\n", + " assert one_hot.shape == shifted_target_q_probs.shape\n", + " td_targets = tf.where(next_time_steps.is_last(),\n", + " one_hot,\n", + " shifted_target_q_probs)\n", + " td_targets = tf.stop_gradient(td_targets)\n", + " else:\n", + " td_targets = tf.stop_gradient(\n", + " next_time_steps.reward +\n", + " next_time_steps.discount * target_q_values)\n", + "\n", + " q_values = q_values_list[ensemble_index]\n", + " if self._use_distributional_rl:\n", + " critic_loss = tf.nn.softmax_cross_entropy_with_logits_v2(\n", + " labels=td_targets,\n", + " logits=q_values\n", + " )\n", + " else:\n", + " critic_loss = common.element_wise_huber_loss(td_targets, q_values)\n", + " critic_loss = tf.reduce_mean(critic_loss)\n", + " critic_loss_list.append(critic_loss)\n", + "\n", + " critic_loss = tf.reduce_mean(critic_loss_list)\n", + "\n", + " return critic_loss\n", + "\n", + " def actor_loss(self, time_steps):\n", + " \"\"\"Computes the actor_loss for UvfAgent training.\n", + "\n", + " Args:\n", + " time_steps: A batch of timesteps.\n", + " Returns:\n", + " actor_loss: A scalar actor loss.\n", + " \"\"\"\n", + " with tf.name_scope('actor_loss'):\n", + " actions, _ = self._actor_network(time_steps.observation,\n", + " time_steps.step_type)\n", + " with tf.GradientTape(watch_accessed_variables=False) as tape:\n", + " tape.watch(actions)\n", + " avg_expected_q_values = self._get_state_values(time_steps, actions,\n", + " aggregate='mean')\n", + " actions = tf.nest.flatten(actions)\n", + " dqdas = tape.gradient([avg_expected_q_values], actions)\n", + "\n", + " actor_losses = []\n", + " for dqda, action in zip(dqdas, actions):\n", + " loss = common.element_wise_squared_loss(\n", + " tf.stop_gradient(dqda + action), action)\n", + " loss = tf.reduce_sum(loss, axis=1)\n", + " loss = tf.reduce_mean(loss)\n", + " actor_losses.append(loss)\n", + "\n", + " actor_loss = tf.add_n(actor_losses)\n", + "\n", + " with tf.name_scope('Losses/'):\n", + " tf.compat.v2.summary.scalar(\n", + " name='actor_loss', data=actor_loss, step=self.train_step_counter)\n", + "\n", + " return actor_loss" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "MbGXO1TURVf-", + "colab_type": "code", + "cellView": "form", + "colab": {} + }, + "source": [ + "#@title Training script.\n", + "def train_eval(\n", + " tf_agent,\n", + " tf_env,\n", + " eval_tf_env,\n", + " num_iterations=2000000,\n", + " # Params for collect\n", + " initial_collect_steps=1000,\n", + " batch_size=64,\n", + " # Params for eval\n", + " num_eval_episodes=100,\n", + " eval_interval=10000,\n", + " # Params for checkpoints, summaries, and logging\n", + " log_interval=1000,\n", + " random_seed=0):\n", + " \"\"\"A simple train and eval for UVF. \"\"\"\n", + " tf.logging.info('random_seed = %d' % random_seed)\n", + " np.random.seed(random_seed)\n", + " random.seed(random_seed)\n", + " tf.set_random_seed(random_seed)\n", + " \n", + " max_episode_steps = tf_env.pyenv.envs[0]._duration\n", + " global_step = tf.compat.v1.train.get_or_create_global_step()\n", + " replay_buffer = tf_uniform_replay_buffer.TFUniformReplayBuffer(\n", + " tf_agent.collect_data_spec,\n", + " batch_size=tf_env.batch_size)\n", + "\n", + " eval_metrics = [\n", + " tf_metrics.AverageReturnMetric(buffer_size=num_eval_episodes),\n", + " ]\n", + " \n", + " eval_policy = tf_agent.policy\n", + " collect_policy = tf_agent.collect_policy\n", + " initial_collect_driver = dynamic_step_driver.DynamicStepDriver(\n", + " tf_env,\n", + " collect_policy,\n", + " observers=[replay_buffer.add_batch],\n", + " num_steps=initial_collect_steps)\n", + " \n", + " collect_driver = dynamic_step_driver.DynamicStepDriver(\n", + " tf_env,\n", + " collect_policy,\n", + " observers=[replay_buffer.add_batch],\n", + " num_steps=1)\n", + " \n", + " initial_collect_driver.run = common.function(initial_collect_driver.run)\n", + " collect_driver.run = common.function(collect_driver.run)\n", + " tf_agent.train = common.function(tf_agent.train)\n", + " \n", + " initial_collect_driver.run()\n", + " \n", + " time_step = None\n", + " policy_state = collect_policy.get_initial_state(tf_env.batch_size)\n", + "\n", + " timed_at_step = global_step.numpy()\n", + " time_acc = 0\n", + "\n", + " # Dataset generates trajectories with shape [Bx2x...]\n", + " dataset = replay_buffer.as_dataset(\n", + " num_parallel_calls=3,\n", + " sample_batch_size=batch_size,\n", + " num_steps=2).prefetch(3)\n", + " iterator = iter(dataset)\n", + " \n", + " for _ in tqdm.tnrange(num_iterations):\n", + " start_time = time.time()\n", + " time_step, policy_state = collect_driver.run(\n", + " time_step=time_step,\n", + " policy_state=policy_state,\n", + " )\n", + " \n", + " experience, _ = next(iterator)\n", + " train_loss = tf_agent.train(experience)\n", + " time_acc += time.time() - start_time\n", + "\n", + " if global_step.numpy() % log_interval == 0:\n", + " tf.logging.info('step = %d, loss = %f', global_step.numpy(),\n", + " train_loss.loss)\n", + " steps_per_sec = log_interval / time_acc\n", + " tf.logging.info('%.3f steps/sec', steps_per_sec)\n", + " time_acc = 0\n", + "\n", + " if global_step.numpy() % eval_interval == 0:\n", + " start = time.time()\n", + " tf.logging.info('step = %d' % global_step.numpy())\n", + " for dist in [2, 5, 10]:\n", + " tf.logging.info('\\t dist = %d' % dist)\n", + " eval_tf_env.pyenv.envs[0].gym.set_sample_goal_args(\n", + " prob_constraint=1.0, min_dist=dist-1, max_dist=dist+1)\n", + "\n", + " results = metric_utils.eager_compute(\n", + " eval_metrics,\n", + " eval_tf_env,\n", + " eval_policy,\n", + " num_episodes=num_eval_episodes,\n", + " train_step=global_step,\n", + " summary_prefix='Metrics',\n", + " )\n", + " for (key, value) in results.items():\n", + " tf.logging.info('\\t\\t %s = %.2f', key, value.numpy())\n", + " # For debugging, it's helpful to check the predicted distances for\n", + " # goals of known distance.\n", + " pred_dist = []\n", + " for _ in range(num_eval_episodes):\n", + " ts = eval_tf_env.reset()\n", + " dist_to_goal = agent._get_dist_to_goal(ts)[0]\n", + " pred_dist.append(dist_to_goal.numpy())\n", + " tf.logging.info('\\t\\t predicted_dist = %.1f (%.1f)' %\n", + " (np.mean(pred_dist), np.std(pred_dist)))\n", + " tf.logging.info('\\t eval_time = %.2f' % (time.time() - start))\n", + " \n", + " return train_loss" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zxW1bAAPeOH6", + "colab_type": "text" + }, + "source": [ + "----------------\n", + "## Train the Agent!\n", + "Now we're going to train the goal-conditioned RL agent. The first cell resets the weights, and the second cell does the actual training. If you want to continue training for longer, simply run the second cell again. Expect training to take about 10 minutes. For some of the complex environments, you may need to increase the `num_iterations` to 100,000." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "lEBCYVpqU07z", + "colab_type": "code", + "colab": {} + }, + "source": [ + "# Run this cell before training on a new environment!\n", + "tf.reset_default_graph()" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "4mmoO3zoSGVE", + "colab_type": "code", + "outputId": "1eb7820f-759c-4376-d0ac-6a62b84e4c7d", + "colab": { + "resources": { + "http://localhost:8080/nbextensions/google.colab/colabwidgets/controls.css": { + "data": "/* Copyright (c) Jupyter Development Team.
 * Distributed under the terms of the Modified BSD License.
 */

 /* We import all of these together in a single css file because the Webpack
loader sees only one file at a time. This allows postcss to see the variable
definitions when they are used. */

 /*-----------------------------------------------------------------------------
| Copyright (c) Jupyter Development Team.
| Distributed under the terms of the Modified BSD License.
|----------------------------------------------------------------------------*/

 /*
This file is copied from the JupyterLab project to define default styling for
when the widget styling is compiled down to eliminate CSS variables. We make one
change - we comment out the font import below.
*/

 /**
 * The material design colors are adapted from google-material-color v1.2.6
 * https://github.com/danlevan/google-material-color
 * https://github.com/danlevan/google-material-color/blob/f67ca5f4028b2f1b34862f64b0ca67323f91b088/dist/palette.var.css
 *
 * The license for the material design color CSS variables is as follows (see
 * https://github.com/danlevan/google-material-color/blob/f67ca5f4028b2f1b34862f64b0ca67323f91b088/LICENSE)
 *
 * The MIT License (MIT)
 *
 * Copyright (c) 2014 Dan Le Van
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

 /*
The following CSS variables define the main, public API for styling JupyterLab.
These variables should be used by all plugins wherever possible. In other
words, plugins should not define custom colors, sizes, etc unless absolutely
necessary. This enables users to change the visual theme of JupyterLab
by changing these variables.

Many variables appear in an ordered sequence (0,1,2,3). These sequences
are designed to work well together, so for example, `--jp-border-color1` should
be used with `--jp-layout-color1`. The numbers have the following meanings:

* 0: super-primary, reserved for special emphasis
* 1: primary, most important under normal situations
* 2: secondary, next most important under normal situations
* 3: tertiary, next most important under normal situations

Throughout JupyterLab, we are mostly following principles from Google's
Material Design when selecting colors. We are not, however, following
all of MD as it is not optimized for dense, information rich UIs.
*/

 /*
 * Optional monospace font for input/output prompt.
 */

 /* Commented out in ipywidgets since we don't need it. */

 /* @import url('https://fonts.googleapis.com/css?family=Roboto+Mono'); */

 /*
 * Added for compabitility with output area
 */

 :root {

  /* Borders

  The following variables, specify the visual styling of borders in JupyterLab.
   */

  /* UI Fonts

  The UI font CSS variables are used for the typography all of the JupyterLab
  user interface elements that are not directly user generated content.
  */ /* Base font size */ /* Ensures px perfect FontAwesome icons */

  /* Use these font colors against the corresponding main layout colors.
     In a light theme, these go from dark to light.
  */

  /* Use these against the brand/accent/warn/error colors.
     These will typically go from light to darker, in both a dark and light theme
   */

  /* Content Fonts

  Content font variables are used for typography of user generated content.
  */ /* Base font size */


  /* Layout

  The following are the main layout colors use in JupyterLab. In a light
  theme these would go from light to dark.
  */

  /* Brand/accent */

  /* State colors (warn, error, success, info) */

  /* Cell specific styles */
  /* A custom blend of MD grey and blue 600
   * See https://meyerweb.com/eric/tools/color-blend/#546E7A:1E88E5:5:hex */
  /* A custom blend of MD grey and orange 600
   * https://meyerweb.com/eric/tools/color-blend/#546E7A:F4511E:5:hex */

  /* Notebook specific styles */

  /* Console specific styles */

  /* Toolbar specific styles */
}

 /* Copyright (c) Jupyter Development Team.
 * Distributed under the terms of the Modified BSD License.
 */

 /*
 * We assume that the CSS variables in
 * https://github.com/jupyterlab/jupyterlab/blob/master/src/default-theme/variables.css
 * have been defined.
 */

 /* This file has code derived from PhosphorJS CSS files, as noted below. The license for this PhosphorJS code is:

Copyright (c) 2014-2017, PhosphorJS Contributors
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice, this
  list of conditions and the following disclaimer.

* Redistributions in binary form must reproduce the above copyright notice,
  this list of conditions and the following disclaimer in the documentation
  and/or other materials provided with the distribution.

* Neither the name of the copyright holder nor the names of its
  contributors may be used to endorse or promote products derived from
  this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

 /*
 * The following section is derived from https://github.com/phosphorjs/phosphor/blob/23b9d075ebc5b73ab148b6ebfc20af97f85714c4/packages/widgets/style/tabbar.css 
 * We've scoped the rules so that they are consistent with exactly our code.
 */

 .jupyter-widgets.widget-tab > .p-TabBar {
  display: -webkit-box;
  display: -ms-flexbox;
  display: flex;
  -webkit-user-select: none;
  -moz-user-select: none;
  -ms-user-select: none;
  user-select: none;
}

 .jupyter-widgets.widget-tab > .p-TabBar[data-orientation='horizontal'] {
  -webkit-box-orient: horizontal;
  -webkit-box-direction: normal;
      -ms-flex-direction: row;
          flex-direction: row;
}

 .jupyter-widgets.widget-tab > .p-TabBar[data-orientation='vertical'] {
  -webkit-box-orient: vertical;
  -webkit-box-direction: normal;
      -ms-flex-direction: column;
          flex-direction: column;
}

 .jupyter-widgets.widget-tab > .p-TabBar > .p-TabBar-content {
  margin: 0;
  padding: 0;
  display: -webkit-box;
  display: -ms-flexbox;
  display: flex;
  -webkit-box-flex: 1;
      -ms-flex: 1 1 auto;
          flex: 1 1 auto;
  list-style-type: none;
}

 .jupyter-widgets.widget-tab > .p-TabBar[data-orientation='horizontal'] > .p-TabBar-content {
  -webkit-box-orient: horizontal;
  -webkit-box-direction: normal;
      -ms-flex-direction: row;
          flex-direction: row;
}

 .jupyter-widgets.widget-tab > .p-TabBar[data-orientation='vertical'] > .p-TabBar-content {
  -webkit-box-orient: vertical;
  -webkit-box-direction: normal;
      -ms-flex-direction: column;
          flex-direction: column;
}

 .jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tab {
  display: -webkit-box;
  display: -ms-flexbox;
  display: flex;
  -webkit-box-orient: horizontal;
  -webkit-box-direction: normal;
      -ms-flex-direction: row;
          flex-direction: row;
  -webkit-box-sizing: border-box;
          box-sizing: border-box;
  overflow: hidden;
}

 .jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tabIcon,
.jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tabCloseIcon {
  -webkit-box-flex: 0;
      -ms-flex: 0 0 auto;
          flex: 0 0 auto;
}

 .jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tabLabel {
  -webkit-box-flex: 1;
      -ms-flex: 1 1 auto;
          flex: 1 1 auto;
  overflow: hidden;
  white-space: nowrap;
}

 .jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tab.p-mod-hidden {
  display: none !important;
}

 .jupyter-widgets.widget-tab > .p-TabBar.p-mod-dragging .p-TabBar-tab {
  position: relative;
}

 .jupyter-widgets.widget-tab > .p-TabBar.p-mod-dragging[data-orientation='horizontal'] .p-TabBar-tab {
  left: 0;
  -webkit-transition: left 150ms ease;
  transition: left 150ms ease;
}

 .jupyter-widgets.widget-tab > .p-TabBar.p-mod-dragging[data-orientation='vertical'] .p-TabBar-tab {
  top: 0;
  -webkit-transition: top 150ms ease;
  transition: top 150ms ease;
}

 .jupyter-widgets.widget-tab > .p-TabBar.p-mod-dragging .p-TabBar-tab.p-mod-dragging {
  -webkit-transition: none;
  transition: none;
}

 /* End tabbar.css */

 :root { /* margin between inline elements */

    /* From Material Design Lite */
}

 .jupyter-widgets {
    margin: 2px;
    -webkit-box-sizing: border-box;
            box-sizing: border-box;
    color: black;
    overflow: visible;
}

 .jupyter-widgets.jupyter-widgets-disconnected::before {
    line-height: 28px;
    height: 28px;
}

 .jp-Output-result > .jupyter-widgets {
    margin-left: 0;
    margin-right: 0;
}

 /* vbox and hbox */

 .widget-inline-hbox {
    /* Horizontal widgets */
    -webkit-box-sizing: border-box;
            box-sizing: border-box;
    display: -webkit-box;
    display: -ms-flexbox;
    display: flex;
    -webkit-box-orient: horizontal;
    -webkit-box-direction: normal;
        -ms-flex-direction: row;
            flex-direction: row;
    -webkit-box-align: baseline;
        -ms-flex-align: baseline;
            align-items: baseline;
}

 .widget-inline-vbox {
    /* Vertical Widgets */
    -webkit-box-sizing: border-box;
            box-sizing: border-box;
    display: -webkit-box;
    display: -ms-flexbox;
    display: flex;
    -webkit-box-orient: vertical;
    -webkit-box-direction: normal;
        -ms-flex-direction: column;
            flex-direction: column;
    -webkit-box-align: center;
        -ms-flex-align: center;
            align-items: center;
}

 .widget-box {
    -webkit-box-sizing: border-box;
            box-sizing: border-box;
    display: -webkit-box;
    display: -ms-flexbox;
    display: flex;
    margin: 0;
    overflow: auto;
}

 .widget-gridbox {
    -webkit-box-sizing: border-box;
            box-sizing: border-box;
    display: grid;
    margin: 0;
    overflow: auto;
}

 .widget-hbox {
    -webkit-box-orient: horizontal;
    -webkit-box-direction: normal;
        -ms-flex-direction: row;
            flex-direction: row;
}

 .widget-vbox {
    -webkit-box-orient: vertical;
    -webkit-box-direction: normal;
        -ms-flex-direction: column;
            flex-direction: column;
}

 /* General Button Styling */

 .jupyter-button {
    padding-left: 10px;
    padding-right: 10px;
    padding-top: 0px;
    padding-bottom: 0px;
    display: inline-block;
    white-space: nowrap;
    overflow: hidden;
    text-overflow: ellipsis;
    text-align: center;
    font-size: 13px;
    cursor: pointer;

    height: 28px;
    border: 0px solid;
    line-height: 28px;
    -webkit-box-shadow: none;
            box-shadow: none;

    color: rgba(0, 0, 0, .8);
    background-color: #EEEEEE;
    border-color: #E0E0E0;
    border: none;
}

 .jupyter-button i.fa {
    margin-right: 4px;
    pointer-events: none;
}

 .jupyter-button:empty:before {
    content: "\200b"; /* zero-width space */
}

 .jupyter-widgets.jupyter-button:disabled {
    opacity: 0.6;
}

 .jupyter-button i.fa.center {
    margin-right: 0;
}

 .jupyter-button:hover:enabled, .jupyter-button:focus:enabled {
    /* MD Lite 2dp shadow */
    -webkit-box-shadow: 0 2px 2px 0 rgba(0, 0, 0, .14),
                0 3px 1px -2px rgba(0, 0, 0, .2),
                0 1px 5px 0 rgba(0, 0, 0, .12);
            box-shadow: 0 2px 2px 0 rgba(0, 0, 0, .14),
                0 3px 1px -2px rgba(0, 0, 0, .2),
                0 1px 5px 0 rgba(0, 0, 0, .12);
}

 .jupyter-button:active, .jupyter-button.mod-active {
    /* MD Lite 4dp shadow */
    -webkit-box-shadow: 0 4px 5px 0 rgba(0, 0, 0, .14),
                0 1px 10px 0 rgba(0, 0, 0, .12),
                0 2px 4px -1px rgba(0, 0, 0, .2);
            box-shadow: 0 4px 5px 0 rgba(0, 0, 0, .14),
                0 1px 10px 0 rgba(0, 0, 0, .12),
                0 2px 4px -1px rgba(0, 0, 0, .2);
    color: rgba(0, 0, 0, .8);
    background-color: #BDBDBD;
}

 .jupyter-button:focus:enabled {
    outline: 1px solid #64B5F6;
}

 /* Button "Primary" Styling */

 .jupyter-button.mod-primary {
    color: rgba(255, 255, 255, 1.0);
    background-color: #2196F3;
}

 .jupyter-button.mod-primary.mod-active {
    color: rgba(255, 255, 255, 1);
    background-color: #1976D2;
}

 .jupyter-button.mod-primary:active {
    color: rgba(255, 255, 255, 1);
    background-color: #1976D2;
}

 /* Button "Success" Styling */

 .jupyter-button.mod-success {
    color: rgba(255, 255, 255, 1.0);
    background-color: #4CAF50;
}

 .jupyter-button.mod-success.mod-active {
    color: rgba(255, 255, 255, 1);
    background-color: #388E3C;
 }

 .jupyter-button.mod-success:active {
    color: rgba(255, 255, 255, 1);
    background-color: #388E3C;
 }

 /* Button "Info" Styling */

 .jupyter-button.mod-info {
    color: rgba(255, 255, 255, 1.0);
    background-color: #00BCD4;
}

 .jupyter-button.mod-info.mod-active {
    color: rgba(255, 255, 255, 1);
    background-color: #0097A7;
}

 .jupyter-button.mod-info:active {
    color: rgba(255, 255, 255, 1);
    background-color: #0097A7;
}

 /* Button "Warning" Styling */

 .jupyter-button.mod-warning {
    color: rgba(255, 255, 255, 1.0);
    background-color: #FF9800;
}

 .jupyter-button.mod-warning.mod-active {
    color: rgba(255, 255, 255, 1);
    background-color: #F57C00;
}

 .jupyter-button.mod-warning:active {
    color: rgba(255, 255, 255, 1);
    background-color: #F57C00;
}

 /* Button "Danger" Styling */

 .jupyter-button.mod-danger {
    color: rgba(255, 255, 255, 1.0);
    background-color: #F44336;
}

 .jupyter-button.mod-danger.mod-active {
    color: rgba(255, 255, 255, 1);
    background-color: #D32F2F;
}

 .jupyter-button.mod-danger:active {
    color: rgba(255, 255, 255, 1);
    background-color: #D32F2F;
}

 /* Widget Button*/

 .widget-button, .widget-toggle-button {
    width: 148px;
}

 /* Widget Label Styling */

 /* Override Bootstrap label css */

 .jupyter-widgets label {
    margin-bottom: 0;
    margin-bottom: initial;
}

 .widget-label-basic {
    /* Basic Label */
    color: black;
    font-size: 13px;
    overflow: hidden;
    text-overflow: ellipsis;
    white-space: nowrap;
    line-height: 28px;
}

 .widget-label {
    /* Label */
    color: black;
    font-size: 13px;
    overflow: hidden;
    text-overflow: ellipsis;
    white-space: nowrap;
    line-height: 28px;
}

 .widget-inline-hbox .widget-label {
    /* Horizontal Widget Label */
    color: black;
    text-align: right;
    margin-right: 8px;
    width: 80px;
    -ms-flex-negative: 0;
        flex-shrink: 0;
}

 .widget-inline-vbox .widget-label {
    /* Vertical Widget Label */
    color: black;
    text-align: center;
    line-height: 28px;
}

 /* Widget Readout Styling */

 .widget-readout {
    color: black;
    font-size: 13px;
    height: 28px;
    line-height: 28px;
    overflow: hidden;
    white-space: nowrap;
    text-align: center;
}

 .widget-readout.overflow {
    /* Overflowing Readout */

    /* From Material Design Lite
        shadow-key-umbra-opacity: 0.2;
        shadow-key-penumbra-opacity: 0.14;
        shadow-ambient-shadow-opacity: 0.12;
     */
    -webkit-box-shadow: 0 2px 2px 0 rgba(0, 0, 0, .2),
                        0 3px 1px -2px rgba(0, 0, 0, .14),
                        0 1px 5px 0 rgba(0, 0, 0, .12);

    box-shadow: 0 2px 2px 0 rgba(0, 0, 0, .2),
                0 3px 1px -2px rgba(0, 0, 0, .14),
                0 1px 5px 0 rgba(0, 0, 0, .12);
}

 .widget-inline-hbox .widget-readout {
    /* Horizontal Readout */
    text-align: center;
    max-width: 148px;
    min-width: 72px;
    margin-left: 4px;
}

 .widget-inline-vbox .widget-readout {
    /* Vertical Readout */
    margin-top: 4px;
    /* as wide as the widget */
    width: inherit;
}

 /* Widget Checkbox Styling */

 .widget-checkbox {
    width: 300px;
    height: 28px;
    line-height: 28px;
}

 .widget-checkbox input[type="checkbox"] {
    margin: 0px 8px 0px 0px;
    line-height: 28px;
    font-size: large;
    -webkit-box-flex: 1;
        -ms-flex-positive: 1;
            flex-grow: 1;
    -ms-flex-negative: 0;
        flex-shrink: 0;
    -ms-flex-item-align: center;
        align-self: center;
}

 /* Widget Valid Styling */

 .widget-valid {
    height: 28px;
    line-height: 28px;
    width: 148px;
    font-size: 13px;
}

 .widget-valid i:before {
    line-height: 28px;
    margin-right: 4px;
    margin-left: 4px;

    /* from the fa class in FontAwesome: https://github.com/FortAwesome/Font-Awesome/blob/49100c7c3a7b58d50baa71efef11af41a66b03d3/css/font-awesome.css#L14 */
    display: inline-block;
    font: normal normal normal 14px/1 FontAwesome;
    font-size: inherit;
    text-rendering: auto;
    -webkit-font-smoothing: antialiased;
    -moz-osx-font-smoothing: grayscale;
}

 .widget-valid.mod-valid i:before {
    content: "\f00c";
    color: green;
}

 .widget-valid.mod-invalid i:before {
    content: "\f00d";
    color: red;
}

 .widget-valid.mod-valid .widget-valid-readout {
    display: none;
}

 /* Widget Text and TextArea Stying */

 .widget-textarea, .widget-text {
    width: 300px;
}

 .widget-text input[type="text"], .widget-text input[type="number"]{
    height: 28px;
    line-height: 28px;
}

 .widget-text input[type="text"]:disabled, .widget-text input[type="number"]:disabled, .widget-textarea textarea:disabled {
    opacity: 0.6;
}

 .widget-text input[type="text"], .widget-text input[type="number"], .widget-textarea textarea {
    -webkit-box-sizing: border-box;
            box-sizing: border-box;
    border: 1px solid #9E9E9E;
    background-color: white;
    color: rgba(0, 0, 0, .8);
    font-size: 13px;
    padding: 4px 8px;
    -webkit-box-flex: 1;
        -ms-flex-positive: 1;
            flex-grow: 1;
    min-width: 0; /* This makes it possible for the flexbox to shrink this input */
    -ms-flex-negative: 1;
        flex-shrink: 1;
    outline: none !important;
}

 .widget-textarea textarea {
    height: inherit;
    width: inherit;
}

 .widget-text input:focus, .widget-textarea textarea:focus {
    border-color: #64B5F6;
}

 /* Widget Slider */

 .widget-slider .ui-slider {
    /* Slider Track */
    border: 1px solid #BDBDBD;
    background: #BDBDBD;
    -webkit-box-sizing: border-box;
            box-sizing: border-box;
    position: relative;
    border-radius: 0px;
}

 .widget-slider .ui-slider .ui-slider-handle {
    /* Slider Handle */
    outline: none !important; /* focused slider handles are colored - see below */
    position: absolute;
    background-color: white;
    border: 1px solid #9E9E9E;
    -webkit-box-sizing: border-box;
            box-sizing: border-box;
    z-index: 1;
    background-image: none; /* Override jquery-ui */
}

 /* Override jquery-ui */

 .widget-slider .ui-slider .ui-slider-handle:hover, .widget-slider .ui-slider .ui-slider-handle:focus {
    background-color: #2196F3;
    border: 1px solid #2196F3;
}

 .widget-slider .ui-slider .ui-slider-handle:active {
    background-color: #2196F3;
    border-color: #2196F3;
    z-index: 2;
    -webkit-transform: scale(1.2);
            transform: scale(1.2);
}

 .widget-slider  .ui-slider .ui-slider-range {
    /* Interval between the two specified value of a double slider */
    position: absolute;
    background: #2196F3;
    z-index: 0;
}

 /* Shapes of Slider Handles */

 .widget-hslider .ui-slider .ui-slider-handle {
    width: 16px;
    height: 16px;
    margin-top: -7px;
    margin-left: -7px;
    border-radius: 50%;
    top: 0;
}

 .widget-vslider .ui-slider .ui-slider-handle {
    width: 16px;
    height: 16px;
    margin-bottom: -7px;
    margin-left: -7px;
    border-radius: 50%;
    left: 0;
}

 .widget-hslider .ui-slider .ui-slider-range {
    height: 8px;
    margin-top: -3px;
}

 .widget-vslider .ui-slider .ui-slider-range {
    width: 8px;
    margin-left: -3px;
}

 /* Horizontal Slider */

 .widget-hslider {
    width: 300px;
    height: 28px;
    line-height: 28px;

    /* Override the align-items baseline. This way, the description and readout
    still seem to align their baseline properly, and we don't have to have
    align-self: stretch in the .slider-container. */
    -webkit-box-align: center;
        -ms-flex-align: center;
            align-items: center;
}

 .widgets-slider .slider-container {
    overflow: visible;
}

 .widget-hslider .slider-container {
    height: 28px;
    margin-left: 6px;
    margin-right: 6px;
    -webkit-box-flex: 1;
        -ms-flex: 1 1 148px;
            flex: 1 1 148px;
}

 .widget-hslider .ui-slider {
    /* Inner, invisible slide div */
    height: 4px;
    margin-top: 12px;
    width: 100%;
}

 /* Vertical Slider */

 .widget-vbox .widget-label {
    height: 28px;
    line-height: 28px;
}

 .widget-vslider {
    /* Vertical Slider */
    height: 200px;
    width: 72px;
}

 .widget-vslider .slider-container {
    -webkit-box-flex: 1;
        -ms-flex: 1 1 148px;
            flex: 1 1 148px;
    margin-left: auto;
    margin-right: auto;
    margin-bottom: 6px;
    margin-top: 6px;
    display: -webkit-box;
    display: -ms-flexbox;
    display: flex;
    -webkit-box-orient: vertical;
    -webkit-box-direction: normal;
        -ms-flex-direction: column;
            flex-direction: column;
}

 .widget-vslider .ui-slider-vertical {
    /* Inner, invisible slide div */
    width: 4px;
    -webkit-box-flex: 1;
        -ms-flex-positive: 1;
            flex-grow: 1;
    margin-left: auto;
    margin-right: auto;
}

 /* Widget Progress Styling */

 .progress-bar {
    -webkit-transition: none;
    transition: none;
}

 .progress-bar {
    height: 28px;
}

 .progress-bar {
    background-color: #2196F3;
}

 .progress-bar-success {
    background-color: #4CAF50;
}

 .progress-bar-info {
    background-color: #00BCD4;
}

 .progress-bar-warning {
    background-color: #FF9800;
}

 .progress-bar-danger {
    background-color: #F44336;
}

 .progress {
    background-color: #EEEEEE;
    border: none;
    -webkit-box-shadow: none;
            box-shadow: none;
}

 /* Horisontal Progress */

 .widget-hprogress {
    /* Progress Bar */
    height: 28px;
    line-height: 28px;
    width: 300px;
    -webkit-box-align: center;
        -ms-flex-align: center;
            align-items: center;

}

 .widget-hprogress .progress {
    -webkit-box-flex: 1;
        -ms-flex-positive: 1;
            flex-grow: 1;
    margin-top: 4px;
    margin-bottom: 4px;
    -ms-flex-item-align: stretch;
        align-self: stretch;
    /* Override bootstrap style */
    height: auto;
    height: initial;
}

 /* Vertical Progress */

 .widget-vprogress {
    height: 200px;
    width: 72px;
}

 .widget-vprogress .progress {
    -webkit-box-flex: 1;
        -ms-flex-positive: 1;
            flex-grow: 1;
    width: 20px;
    margin-left: auto;
    margin-right: auto;
    margin-bottom: 0;
}

 /* Select Widget Styling */

 .widget-dropdown {
    height: 28px;
    width: 300px;
    line-height: 28px;
}

 .widget-dropdown > select {
    padding-right: 20px;
    border: 1px solid #9E9E9E;
    border-radius: 0;
    height: inherit;
    -webkit-box-flex: 1;
        -ms-flex: 1 1 148px;
            flex: 1 1 148px;
    min-width: 0; /* This makes it possible for the flexbox to shrink this input */
    -webkit-box-sizing: border-box;
            box-sizing: border-box;
    outline: none !important;
    -webkit-box-shadow: none;
            box-shadow: none;
    background-color: white;
    color: rgba(0, 0, 0, .8);
    font-size: 13px;
    vertical-align: top;
    padding-left: 8px;
	appearance: none;
	-webkit-appearance: none;
	-moz-appearance: none;
    background-repeat: no-repeat;
	background-size: 20px;
	background-position: right center;
    background-image: url("data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0idXRmLTgiPz4KPCEtLSBHZW5lcmF0b3I6IEFkb2JlIElsbHVzdHJhdG9yIDE5LjIuMSwgU1ZHIEV4cG9ydCBQbHVnLUluIC4gU1ZHIFZlcnNpb246IDYuMDAgQnVpbGQgMCkgIC0tPgo8c3ZnIHZlcnNpb249IjEuMSIgaWQ9IkxheWVyXzEiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgeG1sbnM6eGxpbms9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGxpbmsiIHg9IjBweCIgeT0iMHB4IgoJIHZpZXdCb3g9IjAgMCAxOCAxOCIgc3R5bGU9ImVuYWJsZS1iYWNrZ3JvdW5kOm5ldyAwIDAgMTggMTg7IiB4bWw6c3BhY2U9InByZXNlcnZlIj4KPHN0eWxlIHR5cGU9InRleHQvY3NzIj4KCS5zdDB7ZmlsbDpub25lO30KPC9zdHlsZT4KPHBhdGggZD0iTTUuMiw1LjlMOSw5LjdsMy44LTMuOGwxLjIsMS4ybC00LjksNWwtNC45LTVMNS4yLDUuOXoiLz4KPHBhdGggY2xhc3M9InN0MCIgZD0iTTAtMC42aDE4djE4SDBWLTAuNnoiLz4KPC9zdmc+Cg");
}

 .widget-dropdown > select:focus {
    border-color: #64B5F6;
}

 .widget-dropdown > select:disabled {
    opacity: 0.6;
}

 /* To disable the dotted border in Firefox around select controls.
   See http://stackoverflow.com/a/18853002 */

 .widget-dropdown > select:-moz-focusring {
    color: transparent;
    text-shadow: 0 0 0 #000;
}

 /* Select and SelectMultiple */

 .widget-select {
    width: 300px;
    line-height: 28px;

    /* Because Firefox defines the baseline of a select as the bottom of the
    control, we align the entire control to the top and add padding to the
    select to get an approximate first line baseline alignment. */
    -webkit-box-align: start;
        -ms-flex-align: start;
            align-items: flex-start;
}

 .widget-select > select {
    border: 1px solid #9E9E9E;
    background-color: white;
    color: rgba(0, 0, 0, .8);
    font-size: 13px;
    -webkit-box-flex: 1;
        -ms-flex: 1 1 148px;
            flex: 1 1 148px;
    outline: none !important;
    overflow: auto;
    height: inherit;

    /* Because Firefox defines the baseline of a select as the bottom of the
    control, we align the entire control to the top and add padding to the
    select to get an approximate first line baseline alignment. */
    padding-top: 5px;
}

 .widget-select > select:focus {
    border-color: #64B5F6;
}

 .wiget-select > select > option {
    padding-left: 4px;
    line-height: 28px;
    /* line-height doesn't work on some browsers for select options */
    padding-top: calc(28px - var(--jp-widgets-font-size) / 2);
    padding-bottom: calc(28px - var(--jp-widgets-font-size) / 2);
}

 /* Toggle Buttons Styling */

 .widget-toggle-buttons {
    line-height: 28px;
}

 .widget-toggle-buttons .widget-toggle-button {
    margin-left: 2px;
    margin-right: 2px;
}

 .widget-toggle-buttons .jupyter-button:disabled {
    opacity: 0.6;
}

 /* Radio Buttons Styling */

 .widget-radio {
    width: 300px;
    line-height: 28px;
}

 .widget-radio-box {
    display: -webkit-box;
    display: -ms-flexbox;
    display: flex;
    -webkit-box-orient: vertical;
    -webkit-box-direction: normal;
        -ms-flex-direction: column;
            flex-direction: column;
    -webkit-box-align: stretch;
        -ms-flex-align: stretch;
            align-items: stretch;
    -webkit-box-sizing: border-box;
            box-sizing: border-box;
    -webkit-box-flex: 1;
        -ms-flex-positive: 1;
            flex-grow: 1;
    margin-bottom: 8px;
}

 .widget-radio-box label {
    height: 20px;
    line-height: 20px;
    font-size: 13px;
}

 .widget-radio-box input {
    height: 20px;
    line-height: 20px;
    margin: 0 8px 0 1px;
    float: left;
}

 /* Color Picker Styling */

 .widget-colorpicker {
    width: 300px;
    height: 28px;
    line-height: 28px;
}

 .widget-colorpicker > .widget-colorpicker-input {
    -webkit-box-flex: 1;
        -ms-flex-positive: 1;
            flex-grow: 1;
    -ms-flex-negative: 1;
        flex-shrink: 1;
    min-width: 72px;
}

 .widget-colorpicker input[type="color"] {
    width: 28px;
    height: 28px;
    padding: 0 2px; /* make the color square actually square on Chrome on OS X */
    background: white;
    color: rgba(0, 0, 0, .8);
    border: 1px solid #9E9E9E;
    border-left: none;
    -webkit-box-flex: 0;
        -ms-flex-positive: 0;
            flex-grow: 0;
    -ms-flex-negative: 0;
        flex-shrink: 0;
    -webkit-box-sizing: border-box;
            box-sizing: border-box;
    -ms-flex-item-align: stretch;
        align-self: stretch;
    outline: none !important;
}

 .widget-colorpicker.concise input[type="color"] {
    border-left: 1px solid #9E9E9E;
}

 .widget-colorpicker input[type="color"]:focus, .widget-colorpicker input[type="text"]:focus {
    border-color: #64B5F6;
}

 .widget-colorpicker input[type="text"] {
    -webkit-box-flex: 1;
        -ms-flex-positive: 1;
            flex-grow: 1;
    outline: none !important;
    height: 28px;
    line-height: 28px;
    background: white;
    color: rgba(0, 0, 0, .8);
    border: 1px solid #9E9E9E;
    font-size: 13px;
    padding: 4px 8px;
    min-width: 0; /* This makes it possible for the flexbox to shrink this input */
    -ms-flex-negative: 1;
        flex-shrink: 1;
    -webkit-box-sizing: border-box;
            box-sizing: border-box;
}

 .widget-colorpicker input[type="text"]:disabled {
    opacity: 0.6;
}

 /* Date Picker Styling */

 .widget-datepicker {
    width: 300px;
    height: 28px;
    line-height: 28px;
}

 .widget-datepicker input[type="date"] {
    -webkit-box-flex: 1;
        -ms-flex-positive: 1;
            flex-grow: 1;
    -ms-flex-negative: 1;
        flex-shrink: 1;
    min-width: 0; /* This makes it possible for the flexbox to shrink this input */
    outline: none !important;
    height: 28px;
    border: 1px solid #9E9E9E;
    background-color: white;
    color: rgba(0, 0, 0, .8);
    font-size: 13px;
    padding: 4px 8px;
    -webkit-box-sizing: border-box;
            box-sizing: border-box;
}

 .widget-datepicker input[type="date"]:focus {
    border-color: #64B5F6;
}

 .widget-datepicker input[type="date"]:invalid {
    border-color: #FF9800;
}

 .widget-datepicker input[type="date"]:disabled {
    opacity: 0.6;
}

 /* Play Widget */

 .widget-play {
    width: 148px;
    display: -webkit-box;
    display: -ms-flexbox;
    display: flex;
    -webkit-box-align: stretch;
        -ms-flex-align: stretch;
            align-items: stretch;
}

 .widget-play .jupyter-button {
    -webkit-box-flex: 1;
        -ms-flex-positive: 1;
            flex-grow: 1;
    height: auto;
}

 .widget-play .jupyter-button:disabled {
    opacity: 0.6;
}

 /* Tab Widget */

 .jupyter-widgets.widget-tab {
    display: -webkit-box;
    display: -ms-flexbox;
    display: flex;
    -webkit-box-orient: vertical;
    -webkit-box-direction: normal;
        -ms-flex-direction: column;
            flex-direction: column;
}

 .jupyter-widgets.widget-tab > .p-TabBar {
    /* Necessary so that a tab can be shifted down to overlay the border of the box below. */
    overflow-x: visible;
    overflow-y: visible;
}

 .jupyter-widgets.widget-tab > .p-TabBar > .p-TabBar-content {
    /* Make sure that the tab grows from bottom up */
    -webkit-box-align: end;
        -ms-flex-align: end;
            align-items: flex-end;
    min-width: 0;
    min-height: 0;
}

 .jupyter-widgets.widget-tab > .widget-tab-contents {
    width: 100%;
    -webkit-box-sizing: border-box;
            box-sizing: border-box;
    margin: 0;
    background: white;
    color: rgba(0, 0, 0, .8);
    border: 1px solid #9E9E9E;
    padding: 15px;
    -webkit-box-flex: 1;
        -ms-flex-positive: 1;
            flex-grow: 1;
    overflow: auto;
}

 .jupyter-widgets.widget-tab > .p-TabBar {
    font: 13px Helvetica, Arial, sans-serif;
    min-height: 25px;
}

 .jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tab {
    -webkit-box-flex: 0;
        -ms-flex: 0 1 144px;
            flex: 0 1 144px;
    min-width: 35px;
    min-height: 25px;
    line-height: 24px;
    margin-left: -1px;
    padding: 0px 10px;
    background: #EEEEEE;
    color: rgba(0, 0, 0, .5);
    border: 1px solid #9E9E9E;
    border-bottom: none;
    position: relative;
}

 .jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tab.p-mod-current {
    color: rgba(0, 0, 0, 1.0);
    /* We want the background to match the tab content background */
    background: white;
    min-height: 26px;
    -webkit-transform: translateY(1px);
            transform: translateY(1px);
    overflow: visible;
}

 .jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tab.p-mod-current:before {
    position: absolute;
    top: -1px;
    left: -1px;
    content: '';
    height: 2px;
    width: calc(100% + 2px);
    background: #2196F3;
}

 .jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tab:first-child {
    margin-left: 0;
}

 .jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tab:hover:not(.p-mod-current) {
    background: white;
    color: rgba(0, 0, 0, .8);
}

 .jupyter-widgets.widget-tab > .p-TabBar .p-mod-closable > .p-TabBar-tabCloseIcon {
    margin-left: 4px;
}

 .jupyter-widgets.widget-tab > .p-TabBar .p-mod-closable > .p-TabBar-tabCloseIcon:before {
    font-family: FontAwesome;
    content: '\f00d'; /* close */
}

 .jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tabIcon,
.jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tabLabel,
.jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tabCloseIcon {
    line-height: 24px;
}

 /* Accordion Widget */

 .p-Collapse {
    display: -webkit-box;
    display: -ms-flexbox;
    display: flex;
    -webkit-box-orient: vertical;
    -webkit-box-direction: normal;
        -ms-flex-direction: column;
            flex-direction: column;
    -webkit-box-align: stretch;
        -ms-flex-align: stretch;
            align-items: stretch;
}

 .p-Collapse-header {
    padding: 4px;
    cursor: pointer;
    color: rgba(0, 0, 0, .5);
    background-color: #EEEEEE;
    border: 1px solid #9E9E9E;
    padding: 10px 15px;
    font-weight: bold;
}

 .p-Collapse-header:hover {
    background-color: white;
    color: rgba(0, 0, 0, .8);
}

 .p-Collapse-open > .p-Collapse-header {
    background-color: white;
    color: rgba(0, 0, 0, 1.0);
    cursor: default;
    border-bottom: none;
}

 .p-Collapse .p-Collapse-header::before {
    content: '\f0da\00A0';  /* caret-right, non-breaking space */
    display: inline-block;
    font: normal normal normal 14px/1 FontAwesome;
    font-size: inherit;
    text-rendering: auto;
    -webkit-font-smoothing: antialiased;
    -moz-osx-font-smoothing: grayscale;
}

 .p-Collapse-open > .p-Collapse-header::before {
    content: '\f0d7\00A0'; /* caret-down, non-breaking space */
}

 .p-Collapse-contents {
    padding: 15px;
    background-color: white;
    color: rgba(0, 0, 0, .8);
    border-left: 1px solid #9E9E9E;
    border-right: 1px solid #9E9E9E;
    border-bottom: 1px solid #9E9E9E;
    overflow: auto;
}

 .p-Accordion {
    display: -webkit-box;
    display: -ms-flexbox;
    display: flex;
    -webkit-box-orient: vertical;
    -webkit-box-direction: normal;
        -ms-flex-direction: column;
            flex-direction: column;
    -webkit-box-align: stretch;
        -ms-flex-align: stretch;
            align-items: stretch;
}

 .p-Accordion .p-Collapse {
    margin-bottom: 0;
}

 .p-Accordion .p-Collapse + .p-Collapse {
    margin-top: 4px;
}

 /* HTML widget */

 .widget-html, .widget-htmlmath {
    font-size: 13px;
}

 .widget-html > .widget-html-content, .widget-htmlmath > .widget-html-content {
    /* Fill out the area in the HTML widget */
    -ms-flex-item-align: stretch;
        align-self: stretch;
    -webkit-box-flex: 1;
        -ms-flex-positive: 1;
            flex-grow: 1;
    -ms-flex-negative: 1;
        flex-shrink: 1;
    /* Makes sure the baseline is still aligned with other elements */
    line-height: 28px;
    /* Make it possible to have absolutely-positioned elements in the html */
    position: relative;
}

/*# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../node_modules/@jupyter-widgets/controls/css/widgets.css","../node_modules/@jupyter-widgets/controls/css/labvariables.css","../node_modules/@jupyter-widgets/controls/css/materialcolors.css","../node_modules/@jupyter-widgets/controls/css/widgets-base.css","../node_modules/@jupyter-widgets/controls/css/phosphor.css"],"names":[],"mappings":"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","file":"controls.css","sourcesContent":["/* Copyright (c) Jupyter Development Team.\n * Distributed under the terms of the Modified BSD License.\n */\n\n /* We import all of these together in a single css file because the Webpack\nloader sees only one file at a time. This allows postcss to see the variable\ndefinitions when they are used. */\n\n@import \"./labvariables.css\";\n@import \"./widgets-base.css\";\n","/*-----------------------------------------------------------------------------\n| Copyright (c) Jupyter Development Team.\n| Distributed under the terms of the Modified BSD License.\n|----------------------------------------------------------------------------*/\n\n/*\nThis file is copied from the JupyterLab project to define default styling for\nwhen the widget styling is compiled down to eliminate CSS variables. We make one\nchange - we comment out the font import below.\n*/\n\n@import \"./materialcolors.css\";\n\n/*\nThe following CSS variables define the main, public API for styling JupyterLab.\nThese variables should be used by all plugins wherever possible. In other\nwords, plugins should not define custom colors, sizes, etc unless absolutely\nnecessary. This enables users to change the visual theme of JupyterLab\nby changing these variables.\n\nMany variables appear in an ordered sequence (0,1,2,3). These sequences\nare designed to work well together, so for example, `--jp-border-color1` should\nbe used with `--jp-layout-color1`. The numbers have the following meanings:\n\n* 0: super-primary, reserved for special emphasis\n* 1: primary, most important under normal situations\n* 2: secondary, next most important under normal situations\n* 3: tertiary, next most important under normal situations\n\nThroughout JupyterLab, we are mostly following principles from Google's\nMaterial Design when selecting colors. We are not, however, following\nall of MD as it is not optimized for dense, information rich UIs.\n*/\n\n\n/*\n * Optional monospace font for input/output prompt.\n */\n /* Commented out in ipywidgets since we don't need it. */\n/* @import url('https://fonts.googleapis.com/css?family=Roboto+Mono'); */\n\n/*\n * Added for compabitility with output area\n */\n:root {\n  --jp-icon-search: none;\n  --jp-ui-select-caret: none;\n}\n\n\n:root {\n\n  /* Borders\n\n  The following variables, specify the visual styling of borders in JupyterLab.\n   */\n\n  --jp-border-width: 1px;\n  --jp-border-color0: var(--md-grey-700);\n  --jp-border-color1: var(--md-grey-500);\n  --jp-border-color2: var(--md-grey-300);\n  --jp-border-color3: var(--md-grey-100);\n\n  /* UI Fonts\n\n  The UI font CSS variables are used for the typography all of the JupyterLab\n  user interface elements that are not directly user generated content.\n  */\n\n  --jp-ui-font-scale-factor: 1.2;\n  --jp-ui-font-size0: calc(var(--jp-ui-font-size1)/var(--jp-ui-font-scale-factor));\n  --jp-ui-font-size1: 13px; /* Base font size */\n  --jp-ui-font-size2: calc(var(--jp-ui-font-size1)*var(--jp-ui-font-scale-factor));\n  --jp-ui-font-size3: calc(var(--jp-ui-font-size2)*var(--jp-ui-font-scale-factor));\n  --jp-ui-icon-font-size: 14px; /* Ensures px perfect FontAwesome icons */\n  --jp-ui-font-family: \"Helvetica Neue\", Helvetica, Arial, sans-serif;\n\n  /* Use these font colors against the corresponding main layout colors.\n     In a light theme, these go from dark to light.\n  */\n\n  --jp-ui-font-color0: rgba(0,0,0,1.0);\n  --jp-ui-font-color1: rgba(0,0,0,0.8);\n  --jp-ui-font-color2: rgba(0,0,0,0.5);\n  --jp-ui-font-color3: rgba(0,0,0,0.3);\n\n  /* Use these against the brand/accent/warn/error colors.\n     These will typically go from light to darker, in both a dark and light theme\n   */\n\n  --jp-inverse-ui-font-color0: rgba(255,255,255,1);\n  --jp-inverse-ui-font-color1: rgba(255,255,255,1.0);\n  --jp-inverse-ui-font-color2: rgba(255,255,255,0.7);\n  --jp-inverse-ui-font-color3: rgba(255,255,255,0.5);\n\n  /* Content Fonts\n\n  Content font variables are used for typography of user generated content.\n  */\n\n  --jp-content-font-size: 13px;\n  --jp-content-line-height: 1.5;\n  --jp-content-font-color0: black;\n  --jp-content-font-color1: black;\n  --jp-content-font-color2: var(--md-grey-700);\n  --jp-content-font-color3: var(--md-grey-500);\n\n  --jp-ui-font-scale-factor: 1.2;\n  --jp-ui-font-size0: calc(var(--jp-ui-font-size1)/var(--jp-ui-font-scale-factor));\n  --jp-ui-font-size1: 13px; /* Base font size */\n  --jp-ui-font-size2: calc(var(--jp-ui-font-size1)*var(--jp-ui-font-scale-factor));\n  --jp-ui-font-size3: calc(var(--jp-ui-font-size2)*var(--jp-ui-font-scale-factor));\n\n  --jp-code-font-size: 13px;\n  --jp-code-line-height: 1.307;\n  --jp-code-padding: 5px;\n  --jp-code-font-family: monospace;\n\n\n  /* Layout\n\n  The following are the main layout colors use in JupyterLab. In a light\n  theme these would go from light to dark.\n  */\n\n  --jp-layout-color0: white;\n  --jp-layout-color1: white;\n  --jp-layout-color2: var(--md-grey-200);\n  --jp-layout-color3: var(--md-grey-400);\n\n  /* Brand/accent */\n\n  --jp-brand-color0: var(--md-blue-700);\n  --jp-brand-color1: var(--md-blue-500);\n  --jp-brand-color2: var(--md-blue-300);\n  --jp-brand-color3: var(--md-blue-100);\n\n  --jp-accent-color0: var(--md-green-700);\n  --jp-accent-color1: var(--md-green-500);\n  --jp-accent-color2: var(--md-green-300);\n  --jp-accent-color3: var(--md-green-100);\n\n  /* State colors (warn, error, success, info) */\n\n  --jp-warn-color0: var(--md-orange-700);\n  --jp-warn-color1: var(--md-orange-500);\n  --jp-warn-color2: var(--md-orange-300);\n  --jp-warn-color3: var(--md-orange-100);\n\n  --jp-error-color0: var(--md-red-700);\n  --jp-error-color1: var(--md-red-500);\n  --jp-error-color2: var(--md-red-300);\n  --jp-error-color3: var(--md-red-100);\n\n  --jp-success-color0: var(--md-green-700);\n  --jp-success-color1: var(--md-green-500);\n  --jp-success-color2: var(--md-green-300);\n  --jp-success-color3: var(--md-green-100);\n\n  --jp-info-color0: var(--md-cyan-700);\n  --jp-info-color1: var(--md-cyan-500);\n  --jp-info-color2: var(--md-cyan-300);\n  --jp-info-color3: var(--md-cyan-100);\n\n  /* Cell specific styles */\n\n  --jp-cell-padding: 5px;\n  --jp-cell-editor-background: #f7f7f7;\n  --jp-cell-editor-border-color: #cfcfcf;\n  --jp-cell-editor-background-edit: var(--jp-ui-layout-color1);\n  --jp-cell-editor-border-color-edit: var(--jp-brand-color1);\n  --jp-cell-prompt-width: 100px;\n  --jp-cell-prompt-font-family: 'Roboto Mono', monospace;\n  --jp-cell-prompt-letter-spacing: 0px;\n  --jp-cell-prompt-opacity: 1.0;\n  --jp-cell-prompt-opacity-not-active: 0.4;\n  --jp-cell-prompt-font-color-not-active: var(--md-grey-700);\n  /* A custom blend of MD grey and blue 600\n   * See https://meyerweb.com/eric/tools/color-blend/#546E7A:1E88E5:5:hex */\n  --jp-cell-inprompt-font-color: #307FC1;\n  /* A custom blend of MD grey and orange 600\n   * https://meyerweb.com/eric/tools/color-blend/#546E7A:F4511E:5:hex */\n  --jp-cell-outprompt-font-color: #BF5B3D;\n\n  /* Notebook specific styles */\n\n  --jp-notebook-padding: 10px;\n  --jp-notebook-scroll-padding: 100px;\n\n  /* Console specific styles */\n\n  --jp-console-background: var(--md-grey-100);\n\n  /* Toolbar specific styles */\n\n  --jp-toolbar-border-color: var(--md-grey-400);\n  --jp-toolbar-micro-height: 8px;\n  --jp-toolbar-background: var(--jp-layout-color0);\n  --jp-toolbar-box-shadow: 0px 0px 2px 0px rgba(0,0,0,0.24);\n  --jp-toolbar-header-margin: 4px 4px 0px 4px;\n  --jp-toolbar-active-background: var(--md-grey-300);\n}\n","/**\n * The material design colors are adapted from google-material-color v1.2.6\n * https://github.com/danlevan/google-material-color\n * https://github.com/danlevan/google-material-color/blob/f67ca5f4028b2f1b34862f64b0ca67323f91b088/dist/palette.var.css\n *\n * The license for the material design color CSS variables is as follows (see\n * https://github.com/danlevan/google-material-color/blob/f67ca5f4028b2f1b34862f64b0ca67323f91b088/LICENSE)\n *\n * The MIT License (MIT)\n *\n * Copyright (c) 2014 Dan Le Van\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n:root {\n  --md-red-50: #FFEBEE;\n  --md-red-100: #FFCDD2;\n  --md-red-200: #EF9A9A;\n  --md-red-300: #E57373;\n  --md-red-400: #EF5350;\n  --md-red-500: #F44336;\n  --md-red-600: #E53935;\n  --md-red-700: #D32F2F;\n  --md-red-800: #C62828;\n  --md-red-900: #B71C1C;\n  --md-red-A100: #FF8A80;\n  --md-red-A200: #FF5252;\n  --md-red-A400: #FF1744;\n  --md-red-A700: #D50000;\n\n  --md-pink-50: #FCE4EC;\n  --md-pink-100: #F8BBD0;\n  --md-pink-200: #F48FB1;\n  --md-pink-300: #F06292;\n  --md-pink-400: #EC407A;\n  --md-pink-500: #E91E63;\n  --md-pink-600: #D81B60;\n  --md-pink-700: #C2185B;\n  --md-pink-800: #AD1457;\n  --md-pink-900: #880E4F;\n  --md-pink-A100: #FF80AB;\n  --md-pink-A200: #FF4081;\n  --md-pink-A400: #F50057;\n  --md-pink-A700: #C51162;\n\n  --md-purple-50: #F3E5F5;\n  --md-purple-100: #E1BEE7;\n  --md-purple-200: #CE93D8;\n  --md-purple-300: #BA68C8;\n  --md-purple-400: #AB47BC;\n  --md-purple-500: #9C27B0;\n  --md-purple-600: #8E24AA;\n  --md-purple-700: #7B1FA2;\n  --md-purple-800: #6A1B9A;\n  --md-purple-900: #4A148C;\n  --md-purple-A100: #EA80FC;\n  --md-purple-A200: #E040FB;\n  --md-purple-A400: #D500F9;\n  --md-purple-A700: #AA00FF;\n\n  --md-deep-purple-50: #EDE7F6;\n  --md-deep-purple-100: #D1C4E9;\n  --md-deep-purple-200: #B39DDB;\n  --md-deep-purple-300: #9575CD;\n  --md-deep-purple-400: #7E57C2;\n  --md-deep-purple-500: #673AB7;\n  --md-deep-purple-600: #5E35B1;\n  --md-deep-purple-700: #512DA8;\n  --md-deep-purple-800: #4527A0;\n  --md-deep-purple-900: #311B92;\n  --md-deep-purple-A100: #B388FF;\n  --md-deep-purple-A200: #7C4DFF;\n  --md-deep-purple-A400: #651FFF;\n  --md-deep-purple-A700: #6200EA;\n\n  --md-indigo-50: #E8EAF6;\n  --md-indigo-100: #C5CAE9;\n  --md-indigo-200: #9FA8DA;\n  --md-indigo-300: #7986CB;\n  --md-indigo-400: #5C6BC0;\n  --md-indigo-500: #3F51B5;\n  --md-indigo-600: #3949AB;\n  --md-indigo-700: #303F9F;\n  --md-indigo-800: #283593;\n  --md-indigo-900: #1A237E;\n  --md-indigo-A100: #8C9EFF;\n  --md-indigo-A200: #536DFE;\n  --md-indigo-A400: #3D5AFE;\n  --md-indigo-A700: #304FFE;\n\n  --md-blue-50: #E3F2FD;\n  --md-blue-100: #BBDEFB;\n  --md-blue-200: #90CAF9;\n  --md-blue-300: #64B5F6;\n  --md-blue-400: #42A5F5;\n  --md-blue-500: #2196F3;\n  --md-blue-600: #1E88E5;\n  --md-blue-700: #1976D2;\n  --md-blue-800: #1565C0;\n  --md-blue-900: #0D47A1;\n  --md-blue-A100: #82B1FF;\n  --md-blue-A200: #448AFF;\n  --md-blue-A400: #2979FF;\n  --md-blue-A700: #2962FF;\n\n  --md-light-blue-50: #E1F5FE;\n  --md-light-blue-100: #B3E5FC;\n  --md-light-blue-200: #81D4FA;\n  --md-light-blue-300: #4FC3F7;\n  --md-light-blue-400: #29B6F6;\n  --md-light-blue-500: #03A9F4;\n  --md-light-blue-600: #039BE5;\n  --md-light-blue-700: #0288D1;\n  --md-light-blue-800: #0277BD;\n  --md-light-blue-900: #01579B;\n  --md-light-blue-A100: #80D8FF;\n  --md-light-blue-A200: #40C4FF;\n  --md-light-blue-A400: #00B0FF;\n  --md-light-blue-A700: #0091EA;\n\n  --md-cyan-50: #E0F7FA;\n  --md-cyan-100: #B2EBF2;\n  --md-cyan-200: #80DEEA;\n  --md-cyan-300: #4DD0E1;\n  --md-cyan-400: #26C6DA;\n  --md-cyan-500: #00BCD4;\n  --md-cyan-600: #00ACC1;\n  --md-cyan-700: #0097A7;\n  --md-cyan-800: #00838F;\n  --md-cyan-900: #006064;\n  --md-cyan-A100: #84FFFF;\n  --md-cyan-A200: #18FFFF;\n  --md-cyan-A400: #00E5FF;\n  --md-cyan-A700: #00B8D4;\n\n  --md-teal-50: #E0F2F1;\n  --md-teal-100: #B2DFDB;\n  --md-teal-200: #80CBC4;\n  --md-teal-300: #4DB6AC;\n  --md-teal-400: #26A69A;\n  --md-teal-500: #009688;\n  --md-teal-600: #00897B;\n  --md-teal-700: #00796B;\n  --md-teal-800: #00695C;\n  --md-teal-900: #004D40;\n  --md-teal-A100: #A7FFEB;\n  --md-teal-A200: #64FFDA;\n  --md-teal-A400: #1DE9B6;\n  --md-teal-A700: #00BFA5;\n\n  --md-green-50: #E8F5E9;\n  --md-green-100: #C8E6C9;\n  --md-green-200: #A5D6A7;\n  --md-green-300: #81C784;\n  --md-green-400: #66BB6A;\n  --md-green-500: #4CAF50;\n  --md-green-600: #43A047;\n  --md-green-700: #388E3C;\n  --md-green-800: #2E7D32;\n  --md-green-900: #1B5E20;\n  --md-green-A100: #B9F6CA;\n  --md-green-A200: #69F0AE;\n  --md-green-A400: #00E676;\n  --md-green-A700: #00C853;\n\n  --md-light-green-50: #F1F8E9;\n  --md-light-green-100: #DCEDC8;\n  --md-light-green-200: #C5E1A5;\n  --md-light-green-300: #AED581;\n  --md-light-green-400: #9CCC65;\n  --md-light-green-500: #8BC34A;\n  --md-light-green-600: #7CB342;\n  --md-light-green-700: #689F38;\n  --md-light-green-800: #558B2F;\n  --md-light-green-900: #33691E;\n  --md-light-green-A100: #CCFF90;\n  --md-light-green-A200: #B2FF59;\n  --md-light-green-A400: #76FF03;\n  --md-light-green-A700: #64DD17;\n\n  --md-lime-50: #F9FBE7;\n  --md-lime-100: #F0F4C3;\n  --md-lime-200: #E6EE9C;\n  --md-lime-300: #DCE775;\n  --md-lime-400: #D4E157;\n  --md-lime-500: #CDDC39;\n  --md-lime-600: #C0CA33;\n  --md-lime-700: #AFB42B;\n  --md-lime-800: #9E9D24;\n  --md-lime-900: #827717;\n  --md-lime-A100: #F4FF81;\n  --md-lime-A200: #EEFF41;\n  --md-lime-A400: #C6FF00;\n  --md-lime-A700: #AEEA00;\n\n  --md-yellow-50: #FFFDE7;\n  --md-yellow-100: #FFF9C4;\n  --md-yellow-200: #FFF59D;\n  --md-yellow-300: #FFF176;\n  --md-yellow-400: #FFEE58;\n  --md-yellow-500: #FFEB3B;\n  --md-yellow-600: #FDD835;\n  --md-yellow-700: #FBC02D;\n  --md-yellow-800: #F9A825;\n  --md-yellow-900: #F57F17;\n  --md-yellow-A100: #FFFF8D;\n  --md-yellow-A200: #FFFF00;\n  --md-yellow-A400: #FFEA00;\n  --md-yellow-A700: #FFD600;\n\n  --md-amber-50: #FFF8E1;\n  --md-amber-100: #FFECB3;\n  --md-amber-200: #FFE082;\n  --md-amber-300: #FFD54F;\n  --md-amber-400: #FFCA28;\n  --md-amber-500: #FFC107;\n  --md-amber-600: #FFB300;\n  --md-amber-700: #FFA000;\n  --md-amber-800: #FF8F00;\n  --md-amber-900: #FF6F00;\n  --md-amber-A100: #FFE57F;\n  --md-amber-A200: #FFD740;\n  --md-amber-A400: #FFC400;\n  --md-amber-A700: #FFAB00;\n\n  --md-orange-50: #FFF3E0;\n  --md-orange-100: #FFE0B2;\n  --md-orange-200: #FFCC80;\n  --md-orange-300: #FFB74D;\n  --md-orange-400: #FFA726;\n  --md-orange-500: #FF9800;\n  --md-orange-600: #FB8C00;\n  --md-orange-700: #F57C00;\n  --md-orange-800: #EF6C00;\n  --md-orange-900: #E65100;\n  --md-orange-A100: #FFD180;\n  --md-orange-A200: #FFAB40;\n  --md-orange-A400: #FF9100;\n  --md-orange-A700: #FF6D00;\n\n  --md-deep-orange-50: #FBE9E7;\n  --md-deep-orange-100: #FFCCBC;\n  --md-deep-orange-200: #FFAB91;\n  --md-deep-orange-300: #FF8A65;\n  --md-deep-orange-400: #FF7043;\n  --md-deep-orange-500: #FF5722;\n  --md-deep-orange-600: #F4511E;\n  --md-deep-orange-700: #E64A19;\n  --md-deep-orange-800: #D84315;\n  --md-deep-orange-900: #BF360C;\n  --md-deep-orange-A100: #FF9E80;\n  --md-deep-orange-A200: #FF6E40;\n  --md-deep-orange-A400: #FF3D00;\n  --md-deep-orange-A700: #DD2C00;\n\n  --md-brown-50: #EFEBE9;\n  --md-brown-100: #D7CCC8;\n  --md-brown-200: #BCAAA4;\n  --md-brown-300: #A1887F;\n  --md-brown-400: #8D6E63;\n  --md-brown-500: #795548;\n  --md-brown-600: #6D4C41;\n  --md-brown-700: #5D4037;\n  --md-brown-800: #4E342E;\n  --md-brown-900: #3E2723;\n\n  --md-grey-50: #FAFAFA;\n  --md-grey-100: #F5F5F5;\n  --md-grey-200: #EEEEEE;\n  --md-grey-300: #E0E0E0;\n  --md-grey-400: #BDBDBD;\n  --md-grey-500: #9E9E9E;\n  --md-grey-600: #757575;\n  --md-grey-700: #616161;\n  --md-grey-800: #424242;\n  --md-grey-900: #212121;\n\n  --md-blue-grey-50: #ECEFF1;\n  --md-blue-grey-100: #CFD8DC;\n  --md-blue-grey-200: #B0BEC5;\n  --md-blue-grey-300: #90A4AE;\n  --md-blue-grey-400: #78909C;\n  --md-blue-grey-500: #607D8B;\n  --md-blue-grey-600: #546E7A;\n  --md-blue-grey-700: #455A64;\n  --md-blue-grey-800: #37474F;\n  --md-blue-grey-900: #263238;\n}","/* Copyright (c) Jupyter Development Team.\n * Distributed under the terms of the Modified BSD License.\n */\n\n/*\n * We assume that the CSS variables in\n * https://github.com/jupyterlab/jupyterlab/blob/master/src/default-theme/variables.css\n * have been defined.\n */\n\n@import \"./phosphor.css\";\n\n:root {\n    --jp-widgets-color: var(--jp-content-font-color1);\n    --jp-widgets-label-color: var(--jp-widgets-color);\n    --jp-widgets-readout-color: var(--jp-widgets-color);\n    --jp-widgets-font-size: var(--jp-ui-font-size1);\n    --jp-widgets-margin: 2px;\n    --jp-widgets-inline-height: 28px;\n    --jp-widgets-inline-width: 300px;\n    --jp-widgets-inline-width-short: calc(var(--jp-widgets-inline-width) / 2 - var(--jp-widgets-margin));\n    --jp-widgets-inline-width-tiny: calc(var(--jp-widgets-inline-width-short) / 2 - var(--jp-widgets-margin));\n    --jp-widgets-inline-margin: 4px; /* margin between inline elements */\n    --jp-widgets-inline-label-width: 80px;\n    --jp-widgets-border-width: var(--jp-border-width);\n    --jp-widgets-vertical-height: 200px;\n    --jp-widgets-horizontal-tab-height: 24px;\n    --jp-widgets-horizontal-tab-width: 144px;\n    --jp-widgets-horizontal-tab-top-border: 2px;\n    --jp-widgets-progress-thickness: 20px;\n    --jp-widgets-container-padding: 15px;\n    --jp-widgets-input-padding: 4px;\n    --jp-widgets-radio-item-height-adjustment: 8px;\n    --jp-widgets-radio-item-height: calc(var(--jp-widgets-inline-height) - var(--jp-widgets-radio-item-height-adjustment));\n    --jp-widgets-slider-track-thickness: 4px;\n    --jp-widgets-slider-border-width: var(--jp-widgets-border-width);\n    --jp-widgets-slider-handle-size: 16px;\n    --jp-widgets-slider-handle-border-color: var(--jp-border-color1);\n    --jp-widgets-slider-handle-background-color: var(--jp-layout-color1);\n    --jp-widgets-slider-active-handle-color: var(--jp-brand-color1);\n    --jp-widgets-menu-item-height: 24px;\n    --jp-widgets-dropdown-arrow: url(\"data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0idXRmLTgiPz4KPCEtLSBHZW5lcmF0b3I6IEFkb2JlIElsbHVzdHJhdG9yIDE5LjIuMSwgU1ZHIEV4cG9ydCBQbHVnLUluIC4gU1ZHIFZlcnNpb246IDYuMDAgQnVpbGQgMCkgIC0tPgo8c3ZnIHZlcnNpb249IjEuMSIgaWQ9IkxheWVyXzEiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgeG1sbnM6eGxpbms9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGxpbmsiIHg9IjBweCIgeT0iMHB4IgoJIHZpZXdCb3g9IjAgMCAxOCAxOCIgc3R5bGU9ImVuYWJsZS1iYWNrZ3JvdW5kOm5ldyAwIDAgMTggMTg7IiB4bWw6c3BhY2U9InByZXNlcnZlIj4KPHN0eWxlIHR5cGU9InRleHQvY3NzIj4KCS5zdDB7ZmlsbDpub25lO30KPC9zdHlsZT4KPHBhdGggZD0iTTUuMiw1LjlMOSw5LjdsMy44LTMuOGwxLjIsMS4ybC00LjksNWwtNC45LTVMNS4yLDUuOXoiLz4KPHBhdGggY2xhc3M9InN0MCIgZD0iTTAtMC42aDE4djE4SDBWLTAuNnoiLz4KPC9zdmc+Cg\");\n    --jp-widgets-input-color: var(--jp-ui-font-color1);\n    --jp-widgets-input-background-color: var(--jp-layout-color1);\n    --jp-widgets-input-border-color: var(--jp-border-color1);\n    --jp-widgets-input-focus-border-color: var(--jp-brand-color2);\n    --jp-widgets-input-border-width: var(--jp-widgets-border-width);\n    --jp-widgets-disabled-opacity: 0.6;\n\n    /* From Material Design Lite */\n    --md-shadow-key-umbra-opacity: 0.2;\n    --md-shadow-key-penumbra-opacity: 0.14;\n    --md-shadow-ambient-shadow-opacity: 0.12;\n}\n\n.jupyter-widgets {\n    margin: var(--jp-widgets-margin);\n    box-sizing: border-box;\n    color: var(--jp-widgets-color);\n    overflow: visible;\n}\n\n.jupyter-widgets.jupyter-widgets-disconnected::before {\n    line-height: var(--jp-widgets-inline-height);\n    height: var(--jp-widgets-inline-height);\n}\n\n.jp-Output-result > .jupyter-widgets {\n    margin-left: 0;\n    margin-right: 0;\n}\n\n/* vbox and hbox */\n\n.widget-inline-hbox {\n    /* Horizontal widgets */\n    box-sizing: border-box;\n    display: flex;\n    flex-direction: row;\n    align-items: baseline;\n}\n\n.widget-inline-vbox {\n    /* Vertical Widgets */\n    box-sizing: border-box;\n    display: flex;\n    flex-direction: column;\n    align-items: center;\n}\n\n.widget-box {\n    box-sizing: border-box;\n    display: flex;\n    margin: 0;\n    overflow: auto;\n}\n\n.widget-gridbox {\n    box-sizing: border-box;\n    display: grid;\n    margin: 0;\n    overflow: auto;\n}\n\n.widget-hbox {\n    flex-direction: row;\n}\n\n.widget-vbox {\n    flex-direction: column;\n}\n\n/* General Button Styling */\n\n.jupyter-button {\n    padding-left: 10px;\n    padding-right: 10px;\n    padding-top: 0px;\n    padding-bottom: 0px;\n    display: inline-block;\n    white-space: nowrap;\n    overflow: hidden;\n    text-overflow: ellipsis;\n    text-align: center;\n    font-size: var(--jp-widgets-font-size);\n    cursor: pointer;\n\n    height: var(--jp-widgets-inline-height);\n    border: 0px solid;\n    line-height: var(--jp-widgets-inline-height);\n    box-shadow: none;\n\n    color: var(--jp-ui-font-color1);\n    background-color: var(--jp-layout-color2);\n    border-color: var(--jp-border-color2);\n    border: none;\n}\n\n.jupyter-button i.fa {\n    margin-right: var(--jp-widgets-inline-margin);\n    pointer-events: none;\n}\n\n.jupyter-button:empty:before {\n    content: \"\\200b\"; /* zero-width space */\n}\n\n.jupyter-widgets.jupyter-button:disabled {\n    opacity: var(--jp-widgets-disabled-opacity);\n}\n\n.jupyter-button i.fa.center {\n    margin-right: 0;\n}\n\n.jupyter-button:hover:enabled, .jupyter-button:focus:enabled {\n    /* MD Lite 2dp shadow */\n    box-shadow: 0 2px 2px 0 rgba(0, 0, 0, var(--md-shadow-key-penumbra-opacity)),\n                0 3px 1px -2px rgba(0, 0, 0, var(--md-shadow-key-umbra-opacity)),\n                0 1px 5px 0 rgba(0, 0, 0, var(--md-shadow-ambient-shadow-opacity));\n}\n\n.jupyter-button:active, .jupyter-button.mod-active {\n    /* MD Lite 4dp shadow */\n    box-shadow: 0 4px 5px 0 rgba(0, 0, 0, var(--md-shadow-key-penumbra-opacity)),\n                0 1px 10px 0 rgba(0, 0, 0, var(--md-shadow-ambient-shadow-opacity)),\n                0 2px 4px -1px rgba(0, 0, 0, var(--md-shadow-key-umbra-opacity));\n    color: var(--jp-ui-font-color1);\n    background-color: var(--jp-layout-color3);\n}\n\n.jupyter-button:focus:enabled {\n    outline: 1px solid var(--jp-widgets-input-focus-border-color);\n}\n\n/* Button \"Primary\" Styling */\n\n.jupyter-button.mod-primary {\n    color: var(--jp-inverse-ui-font-color1);\n    background-color: var(--jp-brand-color1);\n}\n\n.jupyter-button.mod-primary.mod-active {\n    color: var(--jp-inverse-ui-font-color0);\n    background-color: var(--jp-brand-color0);\n}\n\n.jupyter-button.mod-primary:active {\n    color: var(--jp-inverse-ui-font-color0);\n    background-color: var(--jp-brand-color0);\n}\n\n/* Button \"Success\" Styling */\n\n.jupyter-button.mod-success {\n    color: var(--jp-inverse-ui-font-color1);\n    background-color: var(--jp-success-color1);\n}\n\n.jupyter-button.mod-success.mod-active {\n    color: var(--jp-inverse-ui-font-color0);\n    background-color: var(--jp-success-color0);\n }\n\n.jupyter-button.mod-success:active {\n    color: var(--jp-inverse-ui-font-color0);\n    background-color: var(--jp-success-color0);\n }\n\n /* Button \"Info\" Styling */\n\n.jupyter-button.mod-info {\n    color: var(--jp-inverse-ui-font-color1);\n    background-color: var(--jp-info-color1);\n}\n\n.jupyter-button.mod-info.mod-active {\n    color: var(--jp-inverse-ui-font-color0);\n    background-color: var(--jp-info-color0);\n}\n\n.jupyter-button.mod-info:active {\n    color: var(--jp-inverse-ui-font-color0);\n    background-color: var(--jp-info-color0);\n}\n\n/* Button \"Warning\" Styling */\n\n.jupyter-button.mod-warning {\n    color: var(--jp-inverse-ui-font-color1);\n    background-color: var(--jp-warn-color1);\n}\n\n.jupyter-button.mod-warning.mod-active {\n    color: var(--jp-inverse-ui-font-color0);\n    background-color: var(--jp-warn-color0);\n}\n\n.jupyter-button.mod-warning:active {\n    color: var(--jp-inverse-ui-font-color0);\n    background-color: var(--jp-warn-color0);\n}\n\n/* Button \"Danger\" Styling */\n\n.jupyter-button.mod-danger {\n    color: var(--jp-inverse-ui-font-color1);\n    background-color: var(--jp-error-color1);\n}\n\n.jupyter-button.mod-danger.mod-active {\n    color: var(--jp-inverse-ui-font-color0);\n    background-color: var(--jp-error-color0);\n}\n\n.jupyter-button.mod-danger:active {\n    color: var(--jp-inverse-ui-font-color0);\n    background-color: var(--jp-error-color0);\n}\n\n/* Widget Button*/\n\n.widget-button, .widget-toggle-button {\n    width: var(--jp-widgets-inline-width-short);\n}\n\n/* Widget Label Styling */\n\n/* Override Bootstrap label css */\n.jupyter-widgets label {\n    margin-bottom: initial;\n}\n\n.widget-label-basic {\n    /* Basic Label */\n    color: var(--jp-widgets-label-color);\n    font-size: var(--jp-widgets-font-size);\n    overflow: hidden;\n    text-overflow: ellipsis;\n    white-space: nowrap;\n    line-height: var(--jp-widgets-inline-height);\n}\n\n.widget-label {\n    /* Label */\n    color: var(--jp-widgets-label-color);\n    font-size: var(--jp-widgets-font-size);\n    overflow: hidden;\n    text-overflow: ellipsis;\n    white-space: nowrap;\n    line-height: var(--jp-widgets-inline-height);\n}\n\n.widget-inline-hbox .widget-label {\n    /* Horizontal Widget Label */\n    color: var(--jp-widgets-label-color);\n    text-align: right;\n    margin-right: calc( var(--jp-widgets-inline-margin) * 2 );\n    width: var(--jp-widgets-inline-label-width);\n    flex-shrink: 0;\n}\n\n.widget-inline-vbox .widget-label {\n    /* Vertical Widget Label */\n    color: var(--jp-widgets-label-color);\n    text-align: center;\n    line-height: var(--jp-widgets-inline-height);\n}\n\n/* Widget Readout Styling */\n\n.widget-readout {\n    color: var(--jp-widgets-readout-color);\n    font-size: var(--jp-widgets-font-size);\n    height: var(--jp-widgets-inline-height);\n    line-height: var(--jp-widgets-inline-height);\n    overflow: hidden;\n    white-space: nowrap;\n    text-align: center;\n}\n\n.widget-readout.overflow {\n    /* Overflowing Readout */\n\n    /* From Material Design Lite\n        shadow-key-umbra-opacity: 0.2;\n        shadow-key-penumbra-opacity: 0.14;\n        shadow-ambient-shadow-opacity: 0.12;\n     */\n    -webkit-box-shadow: 0 2px 2px 0 rgba(0, 0, 0, 0.2),\n                        0 3px 1px -2px rgba(0, 0, 0, 0.14),\n                        0 1px 5px 0 rgba(0, 0, 0, 0.12);\n\n    -moz-box-shadow: 0 2px 2px 0 rgba(0, 0, 0, 0.2),\n                     0 3px 1px -2px rgba(0, 0, 0, 0.14),\n                     0 1px 5px 0 rgba(0, 0, 0, 0.12);\n\n    box-shadow: 0 2px 2px 0 rgba(0, 0, 0, 0.2),\n                0 3px 1px -2px rgba(0, 0, 0, 0.14),\n                0 1px 5px 0 rgba(0, 0, 0, 0.12);\n}\n\n.widget-inline-hbox .widget-readout {\n    /* Horizontal Readout */\n    text-align: center;\n    max-width: var(--jp-widgets-inline-width-short);\n    min-width: var(--jp-widgets-inline-width-tiny);\n    margin-left: var(--jp-widgets-inline-margin);\n}\n\n.widget-inline-vbox .widget-readout {\n    /* Vertical Readout */\n    margin-top: var(--jp-widgets-inline-margin);\n    /* as wide as the widget */\n    width: inherit;\n}\n\n/* Widget Checkbox Styling */\n\n.widget-checkbox {\n    width: var(--jp-widgets-inline-width);\n    height: var(--jp-widgets-inline-height);\n    line-height: var(--jp-widgets-inline-height);\n}\n\n.widget-checkbox input[type=\"checkbox\"] {\n    margin: 0px calc( var(--jp-widgets-inline-margin) * 2 ) 0px 0px;\n    line-height: var(--jp-widgets-inline-height);\n    font-size: large;\n    flex-grow: 1;\n    flex-shrink: 0;\n    align-self: center;\n}\n\n/* Widget Valid Styling */\n\n.widget-valid {\n    height: var(--jp-widgets-inline-height);\n    line-height: var(--jp-widgets-inline-height);\n    width: var(--jp-widgets-inline-width-short);\n    font-size: var(--jp-widgets-font-size);\n}\n\n.widget-valid i:before {\n    line-height: var(--jp-widgets-inline-height);\n    margin-right: var(--jp-widgets-inline-margin);\n    margin-left: var(--jp-widgets-inline-margin);\n\n    /* from the fa class in FontAwesome: https://github.com/FortAwesome/Font-Awesome/blob/49100c7c3a7b58d50baa71efef11af41a66b03d3/css/font-awesome.css#L14 */\n    display: inline-block;\n    font: normal normal normal 14px/1 FontAwesome;\n    font-size: inherit;\n    text-rendering: auto;\n    -webkit-font-smoothing: antialiased;\n    -moz-osx-font-smoothing: grayscale;\n}\n\n.widget-valid.mod-valid i:before {\n    content: \"\\f00c\";\n    color: green;\n}\n\n.widget-valid.mod-invalid i:before {\n    content: \"\\f00d\";\n    color: red;\n}\n\n.widget-valid.mod-valid .widget-valid-readout {\n    display: none;\n}\n\n/* Widget Text and TextArea Stying */\n\n.widget-textarea, .widget-text {\n    width: var(--jp-widgets-inline-width);\n}\n\n.widget-text input[type=\"text\"], .widget-text input[type=\"number\"]{\n    height: var(--jp-widgets-inline-height);\n    line-height: var(--jp-widgets-inline-height);\n}\n\n.widget-text input[type=\"text\"]:disabled, .widget-text input[type=\"number\"]:disabled, .widget-textarea textarea:disabled {\n    opacity: var(--jp-widgets-disabled-opacity);\n}\n\n.widget-text input[type=\"text\"], .widget-text input[type=\"number\"], .widget-textarea textarea {\n    box-sizing: border-box;\n    border: var(--jp-widgets-input-border-width) solid var(--jp-widgets-input-border-color);\n    background-color: var(--jp-widgets-input-background-color);\n    color: var(--jp-widgets-input-color);\n    font-size: var(--jp-widgets-font-size);\n    padding: var(--jp-widgets-input-padding) calc( var(--jp-widgets-input-padding) *  2 );\n    flex-grow: 1;\n    min-width: 0; /* This makes it possible for the flexbox to shrink this input */\n    flex-shrink: 1;\n    outline: none !important;\n}\n\n.widget-textarea textarea {\n    height: inherit;\n    width: inherit;\n}\n\n.widget-text input:focus, .widget-textarea textarea:focus {\n    border-color: var(--jp-widgets-input-focus-border-color);\n}\n\n/* Widget Slider */\n\n.widget-slider .ui-slider {\n    /* Slider Track */\n    border: var(--jp-widgets-slider-border-width) solid var(--jp-layout-color3);\n    background: var(--jp-layout-color3);\n    box-sizing: border-box;\n    position: relative;\n    border-radius: 0px;\n}\n\n.widget-slider .ui-slider .ui-slider-handle {\n    /* Slider Handle */\n    outline: none !important; /* focused slider handles are colored - see below */\n    position: absolute;\n    background-color: var(--jp-widgets-slider-handle-background-color);\n    border: var(--jp-widgets-slider-border-width) solid var(--jp-widgets-slider-handle-border-color);\n    box-sizing: border-box;\n    z-index: 1;\n    background-image: none; /* Override jquery-ui */\n}\n\n/* Override jquery-ui */\n.widget-slider .ui-slider .ui-slider-handle:hover, .widget-slider .ui-slider .ui-slider-handle:focus {\n    background-color: var(--jp-widgets-slider-active-handle-color);\n    border: var(--jp-widgets-slider-border-width) solid var(--jp-widgets-slider-active-handle-color);\n}\n\n.widget-slider .ui-slider .ui-slider-handle:active {\n    background-color: var(--jp-widgets-slider-active-handle-color);\n    border-color: var(--jp-widgets-slider-active-handle-color);\n    z-index: 2;\n    transform: scale(1.2);\n}\n\n.widget-slider  .ui-slider .ui-slider-range {\n    /* Interval between the two specified value of a double slider */\n    position: absolute;\n    background: var(--jp-widgets-slider-active-handle-color);\n    z-index: 0;\n}\n\n/* Shapes of Slider Handles */\n\n.widget-hslider .ui-slider .ui-slider-handle {\n    width: var(--jp-widgets-slider-handle-size);\n    height: var(--jp-widgets-slider-handle-size);\n    margin-top: calc((var(--jp-widgets-slider-track-thickness) - var(--jp-widgets-slider-handle-size)) / 2 - var(--jp-widgets-slider-border-width));\n    margin-left: calc(var(--jp-widgets-slider-handle-size) / -2 + var(--jp-widgets-slider-border-width));\n    border-radius: 50%;\n    top: 0;\n}\n\n.widget-vslider .ui-slider .ui-slider-handle {\n    width: var(--jp-widgets-slider-handle-size);\n    height: var(--jp-widgets-slider-handle-size);\n    margin-bottom: calc(var(--jp-widgets-slider-handle-size) / -2 + var(--jp-widgets-slider-border-width));\n    margin-left: calc((var(--jp-widgets-slider-track-thickness) - var(--jp-widgets-slider-handle-size)) / 2 - var(--jp-widgets-slider-border-width));\n    border-radius: 50%;\n    left: 0;\n}\n\n.widget-hslider .ui-slider .ui-slider-range {\n    height: calc( var(--jp-widgets-slider-track-thickness) * 2 );\n    margin-top: calc((var(--jp-widgets-slider-track-thickness) - var(--jp-widgets-slider-track-thickness) * 2 ) / 2 - var(--jp-widgets-slider-border-width));\n}\n\n.widget-vslider .ui-slider .ui-slider-range {\n    width: calc( var(--jp-widgets-slider-track-thickness) * 2 );\n    margin-left: calc((var(--jp-widgets-slider-track-thickness) - var(--jp-widgets-slider-track-thickness) * 2 ) / 2 - var(--jp-widgets-slider-border-width));\n}\n\n/* Horizontal Slider */\n\n.widget-hslider {\n    width: var(--jp-widgets-inline-width);\n    height: var(--jp-widgets-inline-height);\n    line-height: var(--jp-widgets-inline-height);\n\n    /* Override the align-items baseline. This way, the description and readout\n    still seem to align their baseline properly, and we don't have to have\n    align-self: stretch in the .slider-container. */\n    align-items: center;\n}\n\n.widgets-slider .slider-container {\n    overflow: visible;\n}\n\n.widget-hslider .slider-container {\n    height: var(--jp-widgets-inline-height);\n    margin-left: calc(var(--jp-widgets-slider-handle-size) / 2 - 2 * var(--jp-widgets-slider-border-width));\n    margin-right: calc(var(--jp-widgets-slider-handle-size) / 2 - 2 * var(--jp-widgets-slider-border-width));\n    flex: 1 1 var(--jp-widgets-inline-width-short);\n}\n\n.widget-hslider .ui-slider {\n    /* Inner, invisible slide div */\n    height: var(--jp-widgets-slider-track-thickness);\n    margin-top: calc((var(--jp-widgets-inline-height) - var(--jp-widgets-slider-track-thickness)) / 2);\n    width: 100%;\n}\n\n/* Vertical Slider */\n\n.widget-vbox .widget-label {\n    height: var(--jp-widgets-inline-height);\n    line-height: var(--jp-widgets-inline-height);\n}\n\n.widget-vslider {\n    /* Vertical Slider */\n    height: var(--jp-widgets-vertical-height);\n    width: var(--jp-widgets-inline-width-tiny);\n}\n\n.widget-vslider .slider-container {\n    flex: 1 1 var(--jp-widgets-inline-width-short);\n    margin-left: auto;\n    margin-right: auto;\n    margin-bottom: calc(var(--jp-widgets-slider-handle-size) / 2 - 2 * var(--jp-widgets-slider-border-width));\n    margin-top: calc(var(--jp-widgets-slider-handle-size) / 2 - 2 * var(--jp-widgets-slider-border-width));\n    display: flex;\n    flex-direction: column;\n}\n\n.widget-vslider .ui-slider-vertical {\n    /* Inner, invisible slide div */\n    width: var(--jp-widgets-slider-track-thickness);\n    flex-grow: 1;\n    margin-left: auto;\n    margin-right: auto;\n}\n\n/* Widget Progress Styling */\n\n.progress-bar {\n    -webkit-transition: none;\n    -moz-transition: none;\n    -ms-transition: none;\n    -o-transition: none;\n    transition: none;\n}\n\n.progress-bar {\n    height: var(--jp-widgets-inline-height);\n}\n\n.progress-bar {\n    background-color: var(--jp-brand-color1);\n}\n\n.progress-bar-success {\n    background-color: var(--jp-success-color1);\n}\n\n.progress-bar-info {\n    background-color: var(--jp-info-color1);\n}\n\n.progress-bar-warning {\n    background-color: var(--jp-warn-color1);\n}\n\n.progress-bar-danger {\n    background-color: var(--jp-error-color1);\n}\n\n.progress {\n    background-color: var(--jp-layout-color2);\n    border: none;\n    box-shadow: none;\n}\n\n/* Horisontal Progress */\n\n.widget-hprogress {\n    /* Progress Bar */\n    height: var(--jp-widgets-inline-height);\n    line-height: var(--jp-widgets-inline-height);\n    width: var(--jp-widgets-inline-width);\n    align-items: center;\n\n}\n\n.widget-hprogress .progress {\n    flex-grow: 1;\n    margin-top: var(--jp-widgets-input-padding);\n    margin-bottom: var(--jp-widgets-input-padding);\n    align-self: stretch;\n    /* Override bootstrap style */\n    height: initial;\n}\n\n/* Vertical Progress */\n\n.widget-vprogress {\n    height: var(--jp-widgets-vertical-height);\n    width: var(--jp-widgets-inline-width-tiny);\n}\n\n.widget-vprogress .progress {\n    flex-grow: 1;\n    width: var(--jp-widgets-progress-thickness);\n    margin-left: auto;\n    margin-right: auto;\n    margin-bottom: 0;\n}\n\n/* Select Widget Styling */\n\n.widget-dropdown {\n    height: var(--jp-widgets-inline-height);\n    width: var(--jp-widgets-inline-width);\n    line-height: var(--jp-widgets-inline-height);\n}\n\n.widget-dropdown > select {\n    padding-right: 20px;\n    border: var(--jp-widgets-input-border-width) solid var(--jp-widgets-input-border-color);\n    border-radius: 0;\n    height: inherit;\n    flex: 1 1 var(--jp-widgets-inline-width-short);\n    min-width: 0; /* This makes it possible for the flexbox to shrink this input */\n    box-sizing: border-box;\n    outline: none !important;\n    box-shadow: none;\n    background-color: var(--jp-widgets-input-background-color);\n    color: var(--jp-widgets-input-color);\n    font-size: var(--jp-widgets-font-size);\n    vertical-align: top;\n    padding-left: calc( var(--jp-widgets-input-padding) * 2);\n\tappearance: none;\n\t-webkit-appearance: none;\n\t-moz-appearance: none;\n    background-repeat: no-repeat;\n\tbackground-size: 20px;\n\tbackground-position: right center;\n    background-image: var(--jp-widgets-dropdown-arrow);\n}\n.widget-dropdown > select:focus {\n    border-color: var(--jp-widgets-input-focus-border-color);\n}\n\n.widget-dropdown > select:disabled {\n    opacity: var(--jp-widgets-disabled-opacity);\n}\n\n/* To disable the dotted border in Firefox around select controls.\n   See http://stackoverflow.com/a/18853002 */\n.widget-dropdown > select:-moz-focusring {\n    color: transparent;\n    text-shadow: 0 0 0 #000;\n}\n\n/* Select and SelectMultiple */\n\n.widget-select {\n    width: var(--jp-widgets-inline-width);\n    line-height: var(--jp-widgets-inline-height);\n\n    /* Because Firefox defines the baseline of a select as the bottom of the\n    control, we align the entire control to the top and add padding to the\n    select to get an approximate first line baseline alignment. */\n    align-items: flex-start;\n}\n\n.widget-select > select {\n    border: var(--jp-widgets-input-border-width) solid var(--jp-widgets-input-border-color);\n    background-color: var(--jp-widgets-input-background-color);\n    color: var(--jp-widgets-input-color);\n    font-size: var(--jp-widgets-font-size);\n    flex: 1 1 var(--jp-widgets-inline-width-short);\n    outline: none !important;\n    overflow: auto;\n    height: inherit;\n\n    /* Because Firefox defines the baseline of a select as the bottom of the\n    control, we align the entire control to the top and add padding to the\n    select to get an approximate first line baseline alignment. */\n    padding-top: 5px;\n}\n\n.widget-select > select:focus {\n    border-color: var(--jp-widgets-input-focus-border-color);\n}\n\n.wiget-select > select > option {\n    padding-left: var(--jp-widgets-input-padding);\n    line-height: var(--jp-widgets-inline-height);\n    /* line-height doesn't work on some browsers for select options */\n    padding-top: calc(var(--jp-widgets-inline-height)-var(--jp-widgets-font-size)/2);\n    padding-bottom: calc(var(--jp-widgets-inline-height)-var(--jp-widgets-font-size)/2);\n}\n\n\n\n/* Toggle Buttons Styling */\n\n.widget-toggle-buttons {\n    line-height: var(--jp-widgets-inline-height);\n}\n\n.widget-toggle-buttons .widget-toggle-button {\n    margin-left: var(--jp-widgets-margin);\n    margin-right: var(--jp-widgets-margin);\n}\n\n.widget-toggle-buttons .jupyter-button:disabled {\n    opacity: var(--jp-widgets-disabled-opacity);\n}\n\n/* Radio Buttons Styling */\n\n.widget-radio {\n    width: var(--jp-widgets-inline-width);\n    line-height: var(--jp-widgets-inline-height);\n}\n\n.widget-radio-box {\n    display: flex;\n    flex-direction: column;\n    align-items: stretch;\n    box-sizing: border-box;\n    flex-grow: 1;\n    margin-bottom: var(--jp-widgets-radio-item-height-adjustment);\n}\n\n.widget-radio-box label {\n    height: var(--jp-widgets-radio-item-height);\n    line-height: var(--jp-widgets-radio-item-height);\n    font-size: var(--jp-widgets-font-size);\n}\n\n.widget-radio-box input {\n    height: var(--jp-widgets-radio-item-height);\n    line-height: var(--jp-widgets-radio-item-height);\n    margin: 0 calc( var(--jp-widgets-input-padding) * 2 ) 0 1px;\n    float: left;\n}\n\n/* Color Picker Styling */\n\n.widget-colorpicker {\n    width: var(--jp-widgets-inline-width);\n    height: var(--jp-widgets-inline-height);\n    line-height: var(--jp-widgets-inline-height);\n}\n\n.widget-colorpicker > .widget-colorpicker-input {\n    flex-grow: 1;\n    flex-shrink: 1;\n    min-width: var(--jp-widgets-inline-width-tiny);\n}\n\n.widget-colorpicker input[type=\"color\"] {\n    width: var(--jp-widgets-inline-height);\n    height: var(--jp-widgets-inline-height);\n    padding: 0 2px; /* make the color square actually square on Chrome on OS X */\n    background: var(--jp-widgets-input-background-color);\n    color: var(--jp-widgets-input-color);\n    border: var(--jp-widgets-input-border-width) solid var(--jp-widgets-input-border-color);\n    border-left: none;\n    flex-grow: 0;\n    flex-shrink: 0;\n    box-sizing: border-box;\n    align-self: stretch;\n    outline: none !important;\n}\n\n.widget-colorpicker.concise input[type=\"color\"] {\n    border-left: var(--jp-widgets-input-border-width) solid var(--jp-widgets-input-border-color);\n}\n\n.widget-colorpicker input[type=\"color\"]:focus, .widget-colorpicker input[type=\"text\"]:focus {\n    border-color: var(--jp-widgets-input-focus-border-color);\n}\n\n.widget-colorpicker input[type=\"text\"] {\n    flex-grow: 1;\n    outline: none !important;\n    height: var(--jp-widgets-inline-height);\n    line-height: var(--jp-widgets-inline-height);\n    background: var(--jp-widgets-input-background-color);\n    color: var(--jp-widgets-input-color);\n    border: var(--jp-widgets-input-border-width) solid var(--jp-widgets-input-border-color);\n    font-size: var(--jp-widgets-font-size);\n    padding: var(--jp-widgets-input-padding) calc( var(--jp-widgets-input-padding) *  2 );\n    min-width: 0; /* This makes it possible for the flexbox to shrink this input */\n    flex-shrink: 1;\n    box-sizing: border-box;\n}\n\n.widget-colorpicker input[type=\"text\"]:disabled {\n    opacity: var(--jp-widgets-disabled-opacity);\n}\n\n/* Date Picker Styling */\n\n.widget-datepicker {\n    width: var(--jp-widgets-inline-width);\n    height: var(--jp-widgets-inline-height);\n    line-height: var(--jp-widgets-inline-height);\n}\n\n.widget-datepicker input[type=\"date\"] {\n    flex-grow: 1;\n    flex-shrink: 1;\n    min-width: 0; /* This makes it possible for the flexbox to shrink this input */\n    outline: none !important;\n    height: var(--jp-widgets-inline-height);\n    border: var(--jp-widgets-input-border-width) solid var(--jp-widgets-input-border-color);\n    background-color: var(--jp-widgets-input-background-color);\n    color: var(--jp-widgets-input-color);\n    font-size: var(--jp-widgets-font-size);\n    padding: var(--jp-widgets-input-padding) calc( var(--jp-widgets-input-padding) *  2 );\n    box-sizing: border-box;\n}\n\n.widget-datepicker input[type=\"date\"]:focus {\n    border-color: var(--jp-widgets-input-focus-border-color);\n}\n\n.widget-datepicker input[type=\"date\"]:invalid {\n    border-color: var(--jp-warn-color1);\n}\n\n.widget-datepicker input[type=\"date\"]:disabled {\n    opacity: var(--jp-widgets-disabled-opacity);\n}\n\n/* Play Widget */\n\n.widget-play {\n    width: var(--jp-widgets-inline-width-short);\n    display: flex;\n    align-items: stretch;\n}\n\n.widget-play .jupyter-button {\n    flex-grow: 1;\n    height: auto;\n}\n\n.widget-play .jupyter-button:disabled {\n    opacity: var(--jp-widgets-disabled-opacity);\n}\n\n/* Tab Widget */\n\n.jupyter-widgets.widget-tab {\n    display: flex;\n    flex-direction: column;\n}\n\n.jupyter-widgets.widget-tab > .p-TabBar {\n    /* Necessary so that a tab can be shifted down to overlay the border of the box below. */\n    overflow-x: visible;\n    overflow-y: visible;\n}\n\n.jupyter-widgets.widget-tab > .p-TabBar > .p-TabBar-content {\n    /* Make sure that the tab grows from bottom up */\n    align-items: flex-end;\n    min-width: 0;\n    min-height: 0;\n}\n\n.jupyter-widgets.widget-tab > .widget-tab-contents {\n    width: 100%;\n    box-sizing: border-box;\n    margin: 0;\n    background: var(--jp-layout-color1);\n    color: var(--jp-ui-font-color1);\n    border: var(--jp-border-width) solid var(--jp-border-color1);\n    padding: var(--jp-widgets-container-padding);\n    flex-grow: 1;\n    overflow: auto;\n}\n\n.jupyter-widgets.widget-tab > .p-TabBar {\n    font: var(--jp-widgets-font-size) Helvetica, Arial, sans-serif;\n    min-height: calc(var(--jp-widgets-horizontal-tab-height) + var(--jp-border-width));\n}\n\n.jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tab {\n    flex: 0 1 var(--jp-widgets-horizontal-tab-width);\n    min-width: 35px;\n    min-height: calc(var(--jp-widgets-horizontal-tab-height) + var(--jp-border-width));\n    line-height: var(--jp-widgets-horizontal-tab-height);\n    margin-left: calc(-1 * var(--jp-border-width));\n    padding: 0px 10px;\n    background: var(--jp-layout-color2);\n    color: var(--jp-ui-font-color2);\n    border: var(--jp-border-width) solid var(--jp-border-color1);\n    border-bottom: none;\n    position: relative;\n}\n\n.jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tab.p-mod-current {\n    color: var(--jp-ui-font-color0);\n    /* We want the background to match the tab content background */\n    background: var(--jp-layout-color1);\n    min-height: calc(var(--jp-widgets-horizontal-tab-height) + 2 * var(--jp-border-width));\n    transform: translateY(var(--jp-border-width));\n    overflow: visible;\n}\n\n.jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tab.p-mod-current:before {\n    position: absolute;\n    top: calc(-1 * var(--jp-border-width));\n    left: calc(-1 * var(--jp-border-width));\n    content: '';\n    height: var(--jp-widgets-horizontal-tab-top-border);\n    width: calc(100% + 2 * var(--jp-border-width));\n    background: var(--jp-brand-color1);\n}\n\n.jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tab:first-child {\n    margin-left: 0;\n}\n\n.jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tab:hover:not(.p-mod-current) {\n    background: var(--jp-layout-color1);\n    color: var(--jp-ui-font-color1);\n}\n\n.jupyter-widgets.widget-tab > .p-TabBar .p-mod-closable > .p-TabBar-tabCloseIcon {\n    margin-left: 4px;\n}\n\n.jupyter-widgets.widget-tab > .p-TabBar .p-mod-closable > .p-TabBar-tabCloseIcon:before {\n    font-family: FontAwesome;\n    content: '\\f00d'; /* close */\n}\n\n.jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tabIcon,\n.jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tabLabel,\n.jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tabCloseIcon {\n    line-height: var(--jp-widgets-horizontal-tab-height);\n}\n\n/* Accordion Widget */\n\n.p-Collapse {\n    display: flex;\n    flex-direction: column;\n    align-items: stretch;\n}\n\n.p-Collapse-header {\n    padding: var(--jp-widgets-input-padding);\n    cursor: pointer;\n    color: var(--jp-ui-font-color2);\n    background-color: var(--jp-layout-color2);\n    border: var(--jp-widgets-border-width) solid var(--jp-border-color1);\n    padding: calc(var(--jp-widgets-container-padding) * 2 / 3) var(--jp-widgets-container-padding);\n    font-weight: bold;\n}\n\n.p-Collapse-header:hover {\n    background-color: var(--jp-layout-color1);\n    color: var(--jp-ui-font-color1);\n}\n\n.p-Collapse-open > .p-Collapse-header {\n    background-color: var(--jp-layout-color1);\n    color: var(--jp-ui-font-color0);\n    cursor: default;\n    border-bottom: none;\n}\n\n.p-Collapse .p-Collapse-header::before {\n    content: '\\f0da\\00A0';  /* caret-right, non-breaking space */\n    display: inline-block;\n    font: normal normal normal 14px/1 FontAwesome;\n    font-size: inherit;\n    text-rendering: auto;\n    -webkit-font-smoothing: antialiased;\n    -moz-osx-font-smoothing: grayscale;\n}\n\n.p-Collapse-open > .p-Collapse-header::before {\n    content: '\\f0d7\\00A0'; /* caret-down, non-breaking space */\n}\n\n.p-Collapse-contents {\n    padding: var(--jp-widgets-container-padding);\n    background-color: var(--jp-layout-color1);\n    color: var(--jp-ui-font-color1);\n    border-left: var(--jp-widgets-border-width) solid var(--jp-border-color1);\n    border-right: var(--jp-widgets-border-width) solid var(--jp-border-color1);\n    border-bottom: var(--jp-widgets-border-width) solid var(--jp-border-color1);\n    overflow: auto;\n}\n\n.p-Accordion {\n    display: flex;\n    flex-direction: column;\n    align-items: stretch;\n}\n\n.p-Accordion .p-Collapse {\n    margin-bottom: 0;\n}\n\n.p-Accordion .p-Collapse + .p-Collapse {\n    margin-top: 4px;\n}\n\n\n\n/* HTML widget */\n\n.widget-html, .widget-htmlmath {\n    font-size: var(--jp-widgets-font-size);\n}\n\n.widget-html > .widget-html-content, .widget-htmlmath > .widget-html-content {\n    /* Fill out the area in the HTML widget */\n    align-self: stretch;\n    flex-grow: 1;\n    flex-shrink: 1;\n    /* Makes sure the baseline is still aligned with other elements */\n    line-height: var(--jp-widgets-inline-height);\n    /* Make it possible to have absolutely-positioned elements in the html */\n    position: relative;\n}\n","/* This file has code derived from PhosphorJS CSS files, as noted below. The license for this PhosphorJS code is:\n\nCopyright (c) 2014-2017, PhosphorJS Contributors\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n\n* Redistributions of source code must retain the above copyright notice, this\n  list of conditions and the following disclaimer.\n\n* Redistributions in binary form must reproduce the above copyright notice,\n  this list of conditions and the following disclaimer in the documentation\n  and/or other materials provided with the distribution.\n\n* Neither the name of the copyright holder nor the names of its\n  contributors may be used to endorse or promote products derived from\n  this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\nAND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\nIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\nFOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\nDAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\nSERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\nCAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\nOR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n*/\n\n/*\n * The following section is derived from https://github.com/phosphorjs/phosphor/blob/23b9d075ebc5b73ab148b6ebfc20af97f85714c4/packages/widgets/style/tabbar.css \n * We've scoped the rules so that they are consistent with exactly our code.\n */\n\n.jupyter-widgets.widget-tab > .p-TabBar {\n  display: flex;\n  -webkit-user-select: none;\n  -moz-user-select: none;\n  -ms-user-select: none;\n  user-select: none;\n}\n\n\n.jupyter-widgets.widget-tab > .p-TabBar[data-orientation='horizontal'] {\n  flex-direction: row;\n}\n\n\n.jupyter-widgets.widget-tab > .p-TabBar[data-orientation='vertical'] {\n  flex-direction: column;\n}\n\n\n.jupyter-widgets.widget-tab > .p-TabBar > .p-TabBar-content {\n  margin: 0;\n  padding: 0;\n  display: flex;\n  flex: 1 1 auto;\n  list-style-type: none;\n}\n\n\n.jupyter-widgets.widget-tab > .p-TabBar[data-orientation='horizontal'] > .p-TabBar-content {\n  flex-direction: row;\n}\n\n\n.jupyter-widgets.widget-tab > .p-TabBar[data-orientation='vertical'] > .p-TabBar-content {\n  flex-direction: column;\n}\n\n\n.jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tab {\n  display: flex;\n  flex-direction: row;\n  box-sizing: border-box;\n  overflow: hidden;\n}\n\n\n.jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tabIcon,\n.jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tabCloseIcon {\n  flex: 0 0 auto;\n}\n\n\n.jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tabLabel {\n  flex: 1 1 auto;\n  overflow: hidden;\n  white-space: nowrap;\n}\n\n\n.jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tab.p-mod-hidden {\n  display: none !important;\n}\n\n\n.jupyter-widgets.widget-tab > .p-TabBar.p-mod-dragging .p-TabBar-tab {\n  position: relative;\n}\n\n\n.jupyter-widgets.widget-tab > .p-TabBar.p-mod-dragging[data-orientation='horizontal'] .p-TabBar-tab {\n  left: 0;\n  transition: left 150ms ease;\n}\n\n\n.jupyter-widgets.widget-tab > .p-TabBar.p-mod-dragging[data-orientation='vertical'] .p-TabBar-tab {\n  top: 0;\n  transition: top 150ms ease;\n}\n\n\n.jupyter-widgets.widget-tab > .p-TabBar.p-mod-dragging .p-TabBar-tab.p-mod-dragging {\n  transition: none;\n}\n\n/* End tabbar.css */\n"]} */", + "ok": true, + "headers": [ + [ + "content-type", + "text/css" + ] + ], + "status": 200, + "status_text": "" + } + }, + "base_uri": "https://localhost:8080/", + "height": 2999 + } + }, + "source": [ + "# If you change the environment parameters below, make sure to run\n", + "# tf.reset_default_graph() in the cell above before training.\n", + "max_episode_steps = 20\n", + "env_name = 'FourRooms' # Choose one of the environments shown above. \n", + "resize_factor = 5 # Inflate the environment to increase the difficulty.\n", + "\n", + "tf_env = env_load_fn(env_name, max_episode_steps,\n", + " resize_factor=resize_factor,\n", + " terminate_on_timeout=False)\n", + "eval_tf_env = env_load_fn(env_name, max_episode_steps,\n", + " resize_factor=resize_factor,\n", + " terminate_on_timeout=True)\n", + "agent = UvfAgent(\n", + " tf_env.time_step_spec(),\n", + " tf_env.action_spec(),\n", + " max_episode_steps=max_episode_steps,\n", + " use_distributional_rl=True,\n", + " ensemble_size=3)\n", + "\n", + "train_eval(\n", + " agent,\n", + " tf_env,\n", + " eval_tf_env,\n", + " initial_collect_steps=1000,\n", + " eval_interval=1000,\n", + " num_eval_episodes=10,\n", + " num_iterations=30000,\n", + ")" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "stream", + "text": [ + "W0611 22:35:57.023485 140471116654464 deprecation_wrapper.py:118] From /usr/local/lib/python3.6/dist-packages/tf_agents/agents/ddpg/actor_network.py:101: The name tf.keras.initializers.RandomUniform is deprecated. Please use tf.compat.v1.keras.initializers.RandomUniform instead.\n", + "\n", + "I0611 22:35:57.074419 140471116654464 :16] random_seed = 0\n", + "W0611 22:35:58.664024 140471116654464 deprecation_wrapper.py:118] From /usr/local/lib/python3.6/dist-packages/tensorflow_estimator/python/estimator/api/_v1/estimator/__init__.py:10: The name tf.estimator.inputs is deprecated. Please use tf.compat.v1.estimator.inputs instead.\n", + "\n" + ], + "name": "stderr" + }, + { + "output_type": "display_data", + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9c3afc4507984a70b6e35d7531c5b319", + "version_minor": 0, + "version_major": 2 + }, + "text/plain": [ + "HBox(children=(IntProgress(value=0, max=30000), HTML(value='')))" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "W0611 22:36:02.695541 140471116654464 deprecation.py:323] From :396: add_dispatch_support..wrapper (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Use tf.where in 2.0, which has the same broadcast rule as np.where\n", + "I0611 22:36:24.093817 140471116654464 :77] step = 1000, loss = 2.260376\n", + "I0611 22:36:24.095108 140471116654464 :79] 44.775 steps/sec\n", + "I0611 22:36:24.100284 140471116654464 :84] step = 1000\n", + "I0611 22:36:24.103057 140471116654464 :86] \t dist = 2\n", + "W0611 22:36:24.353013 140470012053248 backprop.py:842] The dtype of the watched tensor must be floating (e.g. tf.float32), got tf.int32\n", + "W0611 22:36:24.354712 140470012053248 backprop.py:842] The dtype of the watched tensor must be floating (e.g. tf.float32), got tf.int32\n", + "W0611 22:36:24.366807 140470012053248 backprop.py:842] The dtype of the watched tensor must be floating (e.g. tf.float32), got tf.int32\n", + "W0611 22:36:24.368909 140470012053248 backprop.py:842] The dtype of the watched tensor must be floating (e.g. tf.float32), got tf.int32\n", + "W0611 22:36:24.378787 140470003660544 backprop.py:842] The dtype of the watched tensor must be floating (e.g. tf.float32), got tf.int32\n", + "I0611 22:36:24.668997 140471116654464 :99] \t\t AverageReturn = -20.00\n", + "I0611 22:36:24.774785 140471116654464 :108] \t\t predicted_dist = 15.4 (0.8)\n", + "I0611 22:36:24.776108 140471116654464 :86] \t dist = 5\n", + "I0611 22:36:25.476270 140471116654464 :99] \t\t AverageReturn = -15.90\n", + "I0611 22:36:25.575147 140471116654464 :108] \t\t predicted_dist = 15.5 (0.6)\n", + "I0611 22:36:25.577681 140471116654464 :86] \t dist = 10\n", + "I0611 22:36:26.090784 140471116654464 :99] \t\t AverageReturn = -19.40\n", + "I0611 22:36:26.191654 140471116654464 :108] \t\t predicted_dist = 15.9 (0.4)\n", + "I0611 22:36:26.193068 140471116654464 :109] \t eval_time = 2.09\n", + "I0611 22:36:44.153315 140471116654464 :77] step = 2000, loss = 1.263498\n", + "I0611 22:36:44.154876 140471116654464 :79] 57.775 steps/sec\n", + "I0611 22:36:44.156327 140471116654464 :84] step = 2000\n", + "I0611 22:36:44.158494 140471116654464 :86] \t dist = 2\n", + "I0611 22:36:44.582741 140471116654464 :99] \t\t AverageReturn = -13.50\n", + "I0611 22:36:44.686585 140471116654464 :108] \t\t predicted_dist = 17.1 (0.6)\n", + "I0611 22:36:44.687794 140471116654464 :86] \t dist = 5\n", + "I0611 22:36:45.182734 140471116654464 :99] \t\t AverageReturn = -18.70\n", + "I0611 22:36:45.283914 140471116654464 :108] \t\t predicted_dist = 16.8 (1.0)\n", + "I0611 22:36:45.285140 140471116654464 :86] \t dist = 10\n", + "I0611 22:36:45.801105 140471116654464 :99] \t\t AverageReturn = -20.00\n", + "I0611 22:36:45.902588 140471116654464 :108] \t\t predicted_dist = 16.6 (0.9)\n", + "I0611 22:36:45.903809 140471116654464 :109] \t eval_time = 1.75\n", + "I0611 22:37:03.738629 140471116654464 :77] step = 3000, loss = 1.051601\n", + "I0611 22:37:03.739933 140471116654464 :79] 58.187 steps/sec\n", + "I0611 22:37:03.742173 140471116654464 :84] step = 3000\n", + "I0611 22:37:03.745504 140471116654464 :86] \t dist = 2\n", + "I0611 22:37:04.248533 140471116654464 :99] \t\t AverageReturn = -18.30\n", + "I0611 22:37:04.349548 140471116654464 :108] \t\t predicted_dist = 17.5 (0.8)\n", + "I0611 22:37:04.350810 140471116654464 :86] \t dist = 5\n", + "I0611 22:37:04.860777 140471116654464 :99] \t\t AverageReturn = -19.20\n", + "I0611 22:37:04.968060 140471116654464 :108] \t\t predicted_dist = 18.0 (0.5)\n", + "I0611 22:37:04.969405 140471116654464 :86] \t dist = 10\n", + "I0611 22:37:05.479490 140471116654464 :99] \t\t AverageReturn = -20.00\n", + "I0611 22:37:05.583407 140471116654464 :108] \t\t predicted_dist = 18.3 (0.5)\n", + "I0611 22:37:05.584728 140471116654464 :109] \t eval_time = 1.84\n", + "I0611 22:37:23.297819 140471116654464 :77] step = 4000, loss = 0.965337\n", + "I0611 22:37:23.299276 140471116654464 :79] 58.599 steps/sec\n", + "I0611 22:37:23.300727 140471116654464 :84] step = 4000\n", + "I0611 22:37:23.302978 140471116654464 :86] \t dist = 2\n", + "I0611 22:37:23.781123 140471116654464 :99] \t\t AverageReturn = -16.60\n", + "I0611 22:37:23.883188 140471116654464 :108] \t\t predicted_dist = 17.4 (1.2)\n", + "I0611 22:37:23.884575 140471116654464 :86] \t dist = 5\n", + "I0611 22:37:24.409528 140471116654464 :99] \t\t AverageReturn = -20.00\n", + "I0611 22:37:24.515282 140471116654464 :108] \t\t predicted_dist = 16.8 (1.2)\n", + "I0611 22:37:24.516741 140471116654464 :86] \t dist = 10\n", + "I0611 22:37:25.034799 140471116654464 :99] \t\t AverageReturn = -20.00\n", + "I0611 22:37:25.138434 140471116654464 :108] \t\t predicted_dist = 18.7 (0.5)\n", + "I0611 22:37:25.139777 140471116654464 :109] \t eval_time = 1.84\n", + "I0611 22:37:43.304026 140471116654464 :77] step = 5000, loss = 1.183079\n", + "I0611 22:37:43.305558 140471116654464 :79] 57.069 steps/sec\n", + "I0611 22:37:43.310534 140471116654464 :84] step = 5000\n", + "I0611 22:37:43.313866 140471116654464 :86] \t dist = 2\n", + "I0611 22:37:43.797940 140471116654464 :99] \t\t AverageReturn = -16.40\n", + "I0611 22:37:43.909072 140471116654464 :108] \t\t predicted_dist = 15.7 (1.8)\n", + "I0611 22:37:43.910273 140471116654464 :86] \t dist = 5\n", + "I0611 22:37:44.428559 140471116654464 :99] \t\t AverageReturn = -17.90\n", + "I0611 22:37:44.533429 140471116654464 :108] \t\t predicted_dist = 16.9 (1.5)\n", + "I0611 22:37:44.534733 140471116654464 :86] \t dist = 10\n", + "I0611 22:37:45.049628 140471116654464 :99] \t\t AverageReturn = -18.60\n", + "I0611 22:37:45.152913 140471116654464 :108] \t\t predicted_dist = 17.9 (0.6)\n", + "I0611 22:37:45.154124 140471116654464 :109] \t eval_time = 1.84\n", + "I0611 22:38:03.352842 140471116654464 :77] step = 6000, loss = 1.341717\n", + "I0611 22:38:03.354142 140471116654464 :79] 56.977 steps/sec\n", + "I0611 22:38:03.356843 140471116654464 :84] step = 6000\n", + "I0611 22:38:03.358886 140471116654464 :86] \t dist = 2\n", + "I0611 22:38:03.857435 140471116654464 :99] \t\t AverageReturn = -18.10\n", + "I0611 22:38:03.958976 140471116654464 :108] \t\t predicted_dist = 16.3 (0.8)\n", + "I0611 22:38:03.960211 140471116654464 :86] \t dist = 5\n", + "I0611 22:38:04.432836 140471116654464 :99] \t\t AverageReturn = -16.50\n", + "I0611 22:38:04.533875 140471116654464 :108] \t\t predicted_dist = 16.9 (0.5)\n", + "I0611 22:38:04.535069 140471116654464 :86] \t dist = 10\n", + "I0611 22:38:05.061924 140471116654464 :99] \t\t AverageReturn = -20.00\n", + "I0611 22:38:05.163789 140471116654464 :108] \t\t predicted_dist = 17.9 (0.3)\n", + "I0611 22:38:05.165022 140471116654464 :109] \t eval_time = 1.81\n", + "I0611 22:38:22.991029 140471116654464 :77] step = 7000, loss = 1.304365\n", + "I0611 22:38:22.992439 140471116654464 :79] 58.187 steps/sec\n", + "I0611 22:38:22.995518 140471116654464 :84] step = 7000\n", + "I0611 22:38:22.998531 140471116654464 :86] \t dist = 2\n", + "I0611 22:38:23.701087 140471116654464 :99] \t\t AverageReturn = -9.70\n", + "I0611 22:38:23.803755 140471116654464 :108] \t\t predicted_dist = 16.1 (1.1)\n", + "I0611 22:38:23.805214 140471116654464 :86] \t dist = 5\n", + "I0611 22:38:24.326574 140471116654464 :99] \t\t AverageReturn = -18.70\n", + "I0611 22:38:24.433809 140471116654464 :108] \t\t predicted_dist = 17.7 (0.8)\n", + "I0611 22:38:24.435206 140471116654464 :86] \t dist = 10\n", + "I0611 22:38:24.951014 140471116654464 :99] \t\t AverageReturn = -19.30\n", + "I0611 22:38:25.051789 140471116654464 :108] \t\t predicted_dist = 18.4 (0.5)\n", + "I0611 22:38:25.053037 140471116654464 :109] \t eval_time = 2.06\n", + "I0611 22:38:42.862435 140471116654464 :77] step = 8000, loss = 1.110342\n", + "I0611 22:38:42.863954 140471116654464 :79] 58.237 steps/sec\n", + "I0611 22:38:42.870434 140471116654464 :84] step = 8000\n", + "I0611 22:38:42.871988 140471116654464 :86] \t dist = 2\n", + "I0611 22:38:43.275768 140471116654464 :99] \t\t AverageReturn = -11.00\n", + "I0611 22:38:43.378757 140471116654464 :108] \t\t predicted_dist = 13.9 (2.6)\n", + "I0611 22:38:43.380006 140471116654464 :86] \t dist = 5\n", + "I0611 22:38:43.872709 140471116654464 :99] \t\t AverageReturn = -17.80\n", + "I0611 22:38:43.975603 140471116654464 :108] \t\t predicted_dist = 17.0 (0.6)\n", + "I0611 22:38:43.976997 140471116654464 :86] \t dist = 10\n", + "I0611 22:38:44.483586 140471116654464 :99] \t\t AverageReturn = -18.40\n", + "I0611 22:38:44.586949 140471116654464 :108] \t\t predicted_dist = 17.9 (0.8)\n", + "I0611 22:38:44.588145 140471116654464 :109] \t eval_time = 1.72\n", + "I0611 22:39:02.638187 140471116654464 :77] step = 9000, loss = 1.755655\n", + "I0611 22:39:02.639679 140471116654464 :79] 57.455 steps/sec\n", + "I0611 22:39:02.640980 140471116654464 :84] step = 9000\n", + "I0611 22:39:02.642668 140471116654464 :86] \t dist = 2\n", + "I0611 22:39:03.141210 140471116654464 :99] \t\t AverageReturn = -18.20\n", + "I0611 22:39:03.244522 140471116654464 :108] \t\t predicted_dist = 12.8 (2.0)\n", + "I0611 22:39:03.245683 140471116654464 :86] \t dist = 5\n", + "I0611 22:39:03.779590 140471116654464 :99] \t\t AverageReturn = -20.00\n", + "I0611 22:39:03.880433 140471116654464 :108] \t\t predicted_dist = 15.8 (1.2)\n", + "I0611 22:39:03.881791 140471116654464 :86] \t dist = 10\n", + "I0611 22:39:04.393404 140471116654464 :99] \t\t AverageReturn = -19.20\n", + "I0611 22:39:04.496054 140471116654464 :108] \t\t predicted_dist = 17.0 (0.9)\n", + "I0611 22:39:04.497223 140471116654464 :109] \t eval_time = 1.86\n", + "I0611 22:39:22.787264 140471116654464 :77] step = 10000, loss = 2.258784\n", + "I0611 22:39:22.788775 140471116654464 :79] 56.655 steps/sec\n", + "I0611 22:39:22.791156 140471116654464 :84] step = 10000\n", + "I0611 22:39:22.792632 140471116654464 :86] \t dist = 2\n", + "I0611 22:39:23.235420 140471116654464 :99] \t\t AverageReturn = -13.00\n", + "I0611 22:39:23.336935 140471116654464 :108] \t\t predicted_dist = 11.7 (2.0)\n", + "I0611 22:39:23.338124 140471116654464 :86] \t dist = 5\n", + "I0611 22:39:23.757310 140471116654464 :99] \t\t AverageReturn = -12.20\n", + "I0611 22:39:23.860221 140471116654464 :108] \t\t predicted_dist = 15.4 (1.0)\n", + "I0611 22:39:23.861335 140471116654464 :86] \t dist = 10\n", + "I0611 22:39:24.373666 140471116654464 :99] \t\t AverageReturn = -19.20\n", + "I0611 22:39:24.479248 140471116654464 :108] \t\t predicted_dist = 16.0 (0.6)\n", + "I0611 22:39:24.480437 140471116654464 :109] \t eval_time = 1.69\n" + ], + "name": "stderr" + }, + { + "output_type": "error", + "ename": "KeyboardInterrupt", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 23\u001b[0m \u001b[0meval_interval\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1000\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 24\u001b[0m \u001b[0mnum_eval_episodes\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 25\u001b[0;31m \u001b[0mnum_iterations\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m30000\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 26\u001b[0m )\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mtrain_eval\u001b[0;34m(tf_agent, tf_env, eval_tf_env, num_iterations, initial_collect_steps, batch_size, num_eval_episodes, eval_interval, log_interval, random_seed)\u001b[0m\n\u001b[1;32m 70\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 71\u001b[0m \u001b[0mexperience\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0miterator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 72\u001b[0;31m \u001b[0mtrain_loss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf_agent\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexperience\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 73\u001b[0m \u001b[0mtime_acc\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mtime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mstart_time\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 74\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_core/python/eager/def_function.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 401\u001b[0m \u001b[0;31m# In this case we have created variables on the first call, so we run the\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 402\u001b[0m \u001b[0;31m# defunned version which is guaranteed to never create variables.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 403\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_stateless_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# pylint: disable=not-callable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 404\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_stateful_fn\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 405\u001b[0m \u001b[0;31m# In this case we have not created variables on the first call. So we can\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_core/python/eager/function.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1384\u001b[0m \u001b[0;34m\"\"\"Calls a graph function specialized to the inputs.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1385\u001b[0m \u001b[0mgraph_function\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_maybe_define_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1386\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mgraph_function\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_filtered_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1387\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1388\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_core/python/eager/function.py\u001b[0m in \u001b[0;36m_filtered_call\u001b[0;34m(self, args, kwargs)\u001b[0m\n\u001b[1;32m 600\u001b[0m if isinstance(t, (ops.Tensor,\n\u001b[1;32m 601\u001b[0m resource_variable_ops.ResourceVariable))),\n\u001b[0;32m--> 602\u001b[0;31m self.captured_inputs)\n\u001b[0m\u001b[1;32m 603\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 604\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_call_flat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcaptured_inputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_core/python/eager/function.py\u001b[0m in \u001b[0;36m_call_flat\u001b[0;34m(self, args, captured_inputs)\u001b[0m\n\u001b[1;32m 682\u001b[0m \u001b[0;31m# Only need to override the gradient in graph mode and when we have outputs.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 683\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mcontext\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexecuting_eagerly\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moutputs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 684\u001b[0;31m \u001b[0moutputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_inference_function\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mctx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 685\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 686\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_register_gradient\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_core/python/eager/function.py\u001b[0m in \u001b[0;36mcall\u001b[0;34m(self, ctx, args)\u001b[0m\n\u001b[1;32m 451\u001b[0m attrs=(\"executor_type\", executor_type,\n\u001b[1;32m 452\u001b[0m \"config_proto\", config),\n\u001b[0;32m--> 453\u001b[0;31m ctx=ctx)\n\u001b[0m\u001b[1;32m 454\u001b[0m \u001b[0;31m# Replace empty list with None\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 455\u001b[0m \u001b[0moutputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0moutputs\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_core/python/eager/execute.py\u001b[0m in \u001b[0;36mquick_execute\u001b[0;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[1;32m 59\u001b[0m tensors = pywrap_tensorflow.TFE_Py_Execute(ctx._handle, device_name,\n\u001b[1;32m 60\u001b[0m \u001b[0mop_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mattrs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 61\u001b[0;31m num_outputs)\n\u001b[0m\u001b[1;32m 62\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_NotOkStatusException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 63\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mname\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "KxFFTj3Ynv03", + "colab_type": "text" + }, + "source": [ + "-------\n", + "## Visualization\n", + "Now, let's visualize some rollouts from the learned policy. Below, you can change the difficulty of the task, which moves the goals closer or further from the starting location. You can change the distance to the goal using the slider below. Notice that, if the goals are nearby, the agent can always reach them. If the goals are far away, the agent rarely reaches them. If only we could lay down a set of \"breadcrumbs\" that led the agent to the goal..." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "ZVmiN6xpvNaL", + "colab_type": "code", + "cellView": "form", + "colab": {} + }, + "source": [ + "#@title Visualize rollouts. {run: \"auto\" }\n", + "eval_tf_env.pyenv.envs[0]._duration = 100 # We'll give the agent lots of time to try to find the goal.\n", + "difficulty = 0.7 #@param {min:0, max: 1, step: 0.1, type:\"slider\"}\n", + "max_goal_dist = eval_tf_env.pyenv.envs[0].gym.max_goal_dist\n", + "eval_tf_env.pyenv.envs[0].gym.set_sample_goal_args(\n", + " prob_constraint=1.0,\n", + " min_dist=max(0, max_goal_dist * (difficulty - 0.05)),\n", + " max_dist=max_goal_dist * (difficulty + 0.05))\n", + "\n", + "\n", + "def get_rollout(tf_env, policy, seed=None):\n", + " np.random.seed(seed) # Use the same task for both policies.\n", + " obs_vec = []\n", + " waypoint_vec = []\n", + " ts = tf_env.reset()\n", + " goal = ts.observation['goal'].numpy()[0]\n", + " for _ in tqdm.tnrange(tf_env.pyenv.envs[0]._duration):\n", + " obs_vec.append(ts.observation['observation'].numpy()[0])\n", + " action = policy.action(ts)\n", + " waypoint_vec.append(ts.observation['goal'].numpy()[0])\n", + " ts = tf_env.step(action)\n", + " if ts.is_last():\n", + " break\n", + " obs_vec.append(ts.observation['observation'].numpy()[0])\n", + " obs_vec = np.array(obs_vec)\n", + " waypoint_vec = np.array(waypoint_vec)\n", + " return obs_vec, goal, waypoint_vec\n", + "\n", + "plt.figure(figsize=(8, 4))\n", + "for col_index in range(2):\n", + " plt.subplot(1, 2, col_index + 1)\n", + " plot_walls(eval_tf_env.pyenv.envs[0].env.walls)\n", + " obs_vec, goal, _ = get_rollout(eval_tf_env, agent.policy)\n", + "\n", + " plt.plot(obs_vec[:, 0], obs_vec[:, 1], 'b-o', alpha=0.3)\n", + " plt.scatter([obs_vec[0, 0]], [obs_vec[0, 1]], marker='+',\n", + " color='red', s=200, label='start')\n", + " plt.scatter([obs_vec[-1, 0]], [obs_vec[-1, 1]], marker='+',\n", + " color='green', s=200, label='end')\n", + " plt.scatter([goal[0]], [goal[1]], marker='*',\n", + " color='green', s=200, label='goal')\n", + " if col_index == 0:\n", + " plt.legend(loc='lower left', bbox_to_anchor=(0.3, 1), ncol=3, fontsize=16)\n", + "plt.show()" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "llYSSGRVoIDj", + "colab_type": "text" + }, + "source": [ + "We now will implement the search policy, which automatically finds these waypoints via graph search. The first step is to fill the replay buffer with random data." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "6-TCcL5Q9Kn_", + "colab_type": "code", + "cellView": "form", + "colab": {} + }, + "source": [ + "#@title Fill the replay buffer with random data {vertical-output: true, run: \"auto\" }\n", + "replay_buffer_size = 1000 #@param {min:100, max: 1000, step: 100, type:\"slider\"}\n", + "\n", + "eval_tf_env.pyenv.envs[0].gym.set_sample_goal_args(\n", + " prob_constraint=0.0,\n", + " min_dist=0,\n", + " max_dist=np.inf)\n", + "rb_vec = []\n", + "for _ in tqdm.tnrange(replay_buffer_size):\n", + " ts = eval_tf_env.reset()\n", + " rb_vec.append(ts.observation['observation'].numpy()[0])\n", + "rb_vec = np.array(rb_vec)\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "plt.scatter(*rb_vec.T)\n", + "plot_walls(eval_tf_env.pyenv.envs[0].env.walls)\n", + "plt.show()" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "yhW1jzfNoR4w", + "colab_type": "text" + }, + "source": [ + "As a sanity check, we'll plot the pairwise distances between all observations in the replay buffer. We expect to see a range of values from 1 to 20. Distributional RL implicitly caps the maximum predicted distance by the largest bin. We've used 20 bins, so the critic predicts 20 for all states that are at least 20 steps away from one another." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "gIo_CYsZu6Qy", + "colab_type": "code", + "cellView": "form", + "colab": {} + }, + "source": [ + "#@title Compute the pairwise distances { vertical-output: true}\n", + "pdist = agent._get_pairwise_dist(rb_vec, aggregate=None).numpy()\n", + "plt.figure(figsize=(6, 3))\n", + "plt.hist(pdist.flatten(), bins=range(20))\n", + "plt.xlabel('predicted distance')\n", + "plt.ylabel('number of (s, g) pairs')\n", + "plt.show()" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bWVW45bzozca", + "colab_type": "text" + }, + "source": [ + "With these distances, we can construct a graph. Nodes in the graph are observations in our replay buffer. We connect observations with edges whose lengths are equal to the predicted distance between those observations. Since it is hard to visualize the edge lengths, we included a slider that allows you to only show edges whose predicted length is less than some threshold.\n", + "\n", + "Our method learns a collection of critics, each of which makes an independent prediction for the distance between two states. Because each network may make bad predictions for pairs of states it hasn't seen before, we act in a *risk-averse* manner by using the maximum predicted distance across our ensemble. That is, we act pessimistically, only adding an edge if *all* critics think that this pair of states is nearby. " + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "30X6CutHy_9W", + "colab_type": "code", + "cellView": "form", + "colab": {} + }, + "source": [ + "#@title Graph Construction { vertical-output: true, run: \"auto\" }\n", + "cutoff = 5 #@param {min:0, max: 20, type:\"slider\"}\n", + "# To make visualization easier, we only display the shortest edges for each\n", + "# node. We will use all edges for planning.\n", + "edges_to_display = 8\n", + "plt.figure(figsize=(6, 6))\n", + "\n", + "plot_walls(eval_tf_env.pyenv.envs[0].env.walls)\n", + "pdist_combined = np.max(pdist, axis=0)\n", + "plt.scatter(*rb_vec.T)\n", + "for i, s_i in enumerate(tqdm.tqdm_notebook(rb_vec)):\n", + " for count, j in enumerate(np.argsort(pdist_combined[i])):\n", + " if count < edges_to_display and pdist_combined[i, j] < cutoff:\n", + " s_j = rb_vec[j]\n", + " plt.plot([s_i[0], s_j[0]], [s_i[1], s_j[1]], c='k', alpha=0.5)\n", + " \n", + "plt.show()" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ZAfUMydwp16_", + "colab_type": "text" + }, + "source": [ + "We can also visualize the predictions from each critic. Note that while each critic may make incorrect decisions for distant states, their predictions in aggregate are correct." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "x_yH1vFNcuRj", + "colab_type": "code", + "cellView": "form", + "colab": {} + }, + "source": [ + "#@title Ensemble of Critics { vertical-output: true, run: \"auto\" }\n", + "cutoff = 5 #@param {min:0, max: 20, type:\"slider\"}\n", + "edges_to_display = 8\n", + "plt.figure(figsize=(15, 4))\n", + "\n", + "for col_index in range(agent._ensemble_size):\n", + " plt.subplot(1, agent._ensemble_size, col_index + 1)\n", + " plot_walls(eval_tf_env.pyenv.envs[0].env.walls)\n", + " plt.title('critic %d' % (col_index + 1))\n", + "\n", + " plt.scatter(*rb_vec.T)\n", + " desc='critic %d / %d' % (col_index + 1, agent._ensemble_size)\n", + " for i, s_i in enumerate(tqdm.tqdm_notebook(rb_vec, desc=desc)):\n", + " for count, j in enumerate(np.argsort(pdist[col_index, i])):\n", + " if count < edges_to_display and pdist[col_index, i, j] < cutoff:\n", + " s_j = rb_vec[j]\n", + " plt.plot([s_i[0], s_j[0]], [s_i[1], s_j[1]], c='k', alpha=0.5)\n", + " \n", + "plt.show()" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "NHCpUMJmSDzq", + "colab_type": "text" + }, + "source": [ + "### Search Policy\n", + "Now, we will combine the goal-conditioned policy and the distance estimates to form a search policy. Internally, this policy performs search over the replay buffer to find a set of waypoints leading to the goal. It then takes actions to reach each waypoint in turn. Because the search happens internally, this policy is a drop-in replacement for any other goal-conditioned policy.\n", + "\n", + "We used a *closed loop* policy in our paper, recomputing the search path after each step. Below, we implement both the original closed loop version as well as an *open loop* version, which only performs search once at the start of the episode. The open loop version is much faster, but may perform worse in stochastic environments where replanning is important." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "tXFDgreyOodM", + "colab_type": "code", + "cellView": "form", + "colab": {} + }, + "source": [ + "#@title Implement the search policy\n", + "class SearchPolicy(tf_policy.Base):\n", + " \n", + " def __init__(self, agent, open_loop=False):\n", + " self._agent = agent\n", + " self._open_loop = open_loop\n", + " self._g = self._build_graph()\n", + " super(SearchPolicy, self).__init__(agent.policy.time_step_spec,\n", + " agent.policy.action_spec)\n", + " \n", + " def _build_graph(self):\n", + " g = nx.DiGraph()\n", + " pdist_combined = np.max(pdist, axis=0)\n", + " for i, s_i in enumerate(rb_vec):\n", + " for j, s_j in enumerate(rb_vec):\n", + " length = pdist_combined[i, j]\n", + " if length < self._agent._max_search_steps:\n", + " g.add_edge(i, j, weight=length)\n", + " return g\n", + " \n", + " def _get_path(self, time_step):\n", + " start_to_rb = agent._get_pairwise_dist(ts.observation['observation'],\n", + " rb_vec,\n", + " aggregate='min',\n", + " masked=True).numpy().flatten()\n", + " rb_to_goal = agent._get_pairwise_dist(rb_vec,\n", + " ts.observation['goal'],\n", + " aggregate='min',\n", + " masked=True).numpy().flatten()\n", + "\n", + " g2 = self._g.copy()\n", + " for i, (dist_from_start, dist_to_goal) in enumerate(zip(start_to_rb, rb_to_goal)):\n", + " if dist_from_start < self._agent._max_search_steps:\n", + " g2.add_edge('start', i, weight=dist_from_start)\n", + " if dist_to_goal < self._agent._max_search_steps:\n", + " g2.add_edge(i, 'goal', weight=dist_to_goal)\n", + " path = nx.shortest_path(g2, 'start', 'goal')\n", + " edge_lengths = []\n", + " for (i, j) in zip(path[:-1], path[1:]):\n", + " edge_lengths.append(g2[i][j]['weight'])\n", + " wypt_to_goal_dist = np.cumsum(edge_lengths[::-1])[::-1] # Reverse CumSum\n", + " waypoint_vec = list(path)[1:-1]\n", + " return waypoint_vec, wypt_to_goal_dist[1:]\n", + " \n", + " def _action(self, time_step, policy_state=(), seed=None):\n", + " goal = time_step.observation['goal']\n", + " dist_to_goal = self._agent._get_dist_to_goal(time_step)[0].numpy()\n", + " if self._open_loop:\n", + " if time_step.is_first():\n", + " self._waypoint_vec, self._wypt_to_goal_dist_vec = self._get_path(time_step)\n", + " self._waypoint_counter = 0\n", + " waypoint = rb_vec[self._waypoint_vec[self._waypoint_counter]]\n", + " time_step.observation['goal'] = waypoint[None]\n", + " dist_to_waypoint = self._agent._get_dist_to_goal(time_step)[0].numpy()\n", + " if dist_to_waypoint < self._agent._max_search_steps:\n", + " self._waypoint_counter = min(self._waypoint_counter + 1,\n", + " len(self._waypoint_vec) - 1)\n", + " waypoint = rb_vec[self._waypoint_vec[self._waypoint_counter]]\n", + " time_step.observation['goal'] = waypoint[None]\n", + " dist_to_waypoint = self._agent._get_dist_to_goal(time_step._replace())[0].numpy()\n", + " dist_to_goal_via_wypt = dist_to_waypoint + self._wypt_to_goal_dist_vec[self._waypoint_counter]\n", + " else:\n", + " (waypoint, dist_to_goal_via_wypt) = self._agent._get_waypoint(time_step)\n", + " dist_to_goal_via_wypt = dist_to_goal_via_wypt.numpy()\n", + " \n", + " if (dist_to_goal_via_wypt < dist_to_goal) or \\\n", + " (dist_to_goal > self._agent._max_search_steps):\n", + " time_step.observation['goal'] = tf.convert_to_tensor(waypoint[None])\n", + " else:\n", + " time_step.observation['goal'] = goal\n", + " return self._agent.policy.action(time_step, policy_state, seed)" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fc5_wBqF5QnD", + "colab_type": "text" + }, + "source": [ + "Let's initialize the search policy:" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "G5kWC2q4UujP", + "colab_type": "code", + "colab": {} + }, + "source": [ + "agent.initialize_search(rb_vec, max_search_steps=5)\n", + "search_policy = SearchPolicy(agent, open_loop=True)" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "RO6k_DbOzWig", + "colab_type": "text" + }, + "source": [ + "Now, let's plot the search path found by the search policy:" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "9OvZr9VIRmYA", + "colab_type": "code", + "cellView": "form", + "colab": {} + }, + "source": [ + "#@title Search Path. { vertical-output: false, run: \"auto\"}\n", + "\n", + "difficulty = 0.6 #@param {min:0, max: 1, step: 0.1, type:\"slider\"}\n", + "max_goal_dist = eval_tf_env.pyenv.envs[0].gym.max_goal_dist\n", + "eval_tf_env.pyenv.envs[0].gym.set_sample_goal_args(\n", + " prob_constraint=1.0,\n", + " min_dist=max(0, max_goal_dist * (difficulty - 0.05)),\n", + " max_dist=max_goal_dist * (difficulty + 0.05))\n", + "ts = eval_tf_env.reset()\n", + "start = ts.observation['observation'].numpy()[0]\n", + "goal = ts.observation['goal'].numpy()[0]\n", + "search_policy.action(ts)\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "plot_walls(eval_tf_env.pyenv.envs[0].env.walls)\n", + "\n", + "waypoint_vec = [start]\n", + "for waypoint_index in search_policy._waypoint_vec:\n", + " waypoint_vec.append(rb_vec[waypoint_index])\n", + "waypoint_vec.append(goal)\n", + "waypoint_vec = np.array(waypoint_vec)\n", + "\n", + "plt.scatter([start[0]], [start[1]], marker='+',\n", + " color='red', s=200, label='start')\n", + "plt.scatter([goal[0]], [goal[1]], marker='*',\n", + " color='green', s=200, label='goal')\n", + "plt.plot(waypoint_vec[:, 0], waypoint_vec[:, 1], 'y-s', alpha=0.3, label='waypoint')\n", + "plt.legend(loc='lower left', bbox_to_anchor=(-0.1, -0.15), ncol=4, fontsize=16)\n", + "plt.show()" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UIq3YzOeqYkW", + "colab_type": "text" + }, + "source": [ + "Now, we'll use that path to guide the agent towards the goal. On the left, we plot rollouts from the baseline goal-conditioned policy. On the right, we use that same policy to reach each of the waypoints leading to the goal. As before, the slider allows you to change the distance to the goal. Note that only the search policy is able to reach distant goals." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "cellView": "form", + "id": "IK4ukv7TDoWE", + "colab": {} + }, + "source": [ + "#@title Rollouts with Search. { vertical-output: true, run: \"auto\"}\n", + "eval_tf_env.pyenv.envs[0]._duration = 300\n", + "seed = np.random.randint(0, 1000000)\n", + "\n", + "difficulty = 0.8 #@param {min:0, max: 1, step: 0.1, type:\"slider\"}\n", + "max_goal_dist = eval_tf_env.pyenv.envs[0].gym.max_goal_dist\n", + "eval_tf_env.pyenv.envs[0].gym.set_sample_goal_args(\n", + " prob_constraint=1.0,\n", + " min_dist=max(0, max_goal_dist * (difficulty - 0.05)),\n", + " max_dist=max_goal_dist * (difficulty + 0.05))\n", + "\n", + "\n", + "plt.figure(figsize=(12, 5))\n", + "for col_index in range(2):\n", + " title = 'no search' if col_index == 0 else 'search'\n", + " plt.subplot(1, 2, col_index + 1)\n", + " plot_walls(eval_tf_env.pyenv.envs[0].env.walls)\n", + " use_search = (col_index == 1)\n", + " np.random.seed(seed)\n", + " ts = eval_tf_env.reset()\n", + " goal = ts.observation['goal'].numpy()[0]\n", + " start = ts.observation['observation'].numpy()[0]\n", + " obs_vec = []\n", + " for _ in tqdm.tnrange(eval_tf_env.pyenv.envs[0]._duration,\n", + " desc='rollout %d / 2' % (col_index + 1)):\n", + " if ts.is_last():\n", + " break\n", + " obs_vec.append(ts.observation['observation'].numpy()[0])\n", + " if use_search:\n", + " action = search_policy.action(ts)\n", + " else:\n", + " action = agent.policy.action(ts)\n", + "\n", + " ts = eval_tf_env.step(action)\n", + " \n", + " obs_vec = np.array(obs_vec)\n", + "\n", + " plt.plot(obs_vec[:, 0], obs_vec[:, 1], 'b-o', alpha=0.3)\n", + " plt.scatter([obs_vec[0, 0]], [obs_vec[0, 1]], marker='+',\n", + " color='red', s=200, label='start')\n", + " plt.scatter([obs_vec[-1, 0]], [obs_vec[-1, 1]], marker='+',\n", + " color='green', s=200, label='end')\n", + " plt.scatter([goal[0]], [goal[1]], marker='*',\n", + " color='green', s=200, label='goal')\n", + " \n", + " plt.title(title, fontsize=24)\n", + " if use_search:\n", + " waypoint_vec = [start]\n", + " for waypoint_index in search_policy._waypoint_vec:\n", + " waypoint_vec.append(rb_vec[waypoint_index])\n", + " waypoint_vec.append(goal)\n", + " waypoint_vec = np.array(waypoint_vec)\n", + "\n", + " plt.plot(waypoint_vec[:, 0], waypoint_vec[:, 1], 'y-s', alpha=0.3, label='waypoint')\n", + " plt.legend(loc='lower left', bbox_to_anchor=(-0.8, -0.15), ncol=4, fontsize=16)\n", + "plt.show()" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2JvMnn7X2mrf", + "colab_type": "text" + }, + "source": [ + "-----------------------------\n", + "## Next Steps and Open Problems\n", + "We encourage readers to play around with the experiments. To get started, here are a few questions:\n", + "1. What effect does distributional RL have on learning distances? (Hint: change `use_distributional_rl` when initializing the `UvfAgent`.)\n", + "2. What is the effect of using more critic networks in the ensemble? (Hint: change `ensemble_size` when initializing the `UvfAgent`)\n", + "3. While we applied planning *after* training a goal-conditioned policy, can planning be used to accelerate learning of the goal-conditioned policy? (Hint: Set `UvfAgent.collect_policy` to be the `SearchPolicy`)\n", + "4. Can you be smart about which observations to include in the replay buffer to make search faster? (Hint: Simple behavior cloning may be enough.)\n", + "7. Can the search policy be distilled into a single neural network policy?\n", + "5. What tricks are important for learning distances with RL?\n", + "6. How can more sophisticated planning algorithms be used in a similar framework?\n", + "8. Can the same idea by applied to other domains such, as manipulation?\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "r4FA69AqWJ4t", + "colab_type": "code", + "colab": {} + }, + "source": [ + "" + ], + "execution_count": 0, + "outputs": [] + } + ] +} \ No newline at end of file