diff --git a/examples/01_rl_hello_world_cartpole.ipynb b/examples/01_rl_hello_world_cartpole.ipynb new file mode 100644 index 0000000..80c0e49 --- /dev/null +++ b/examples/01_rl_hello_world_cartpole.ipynb @@ -0,0 +1,588 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Reinforcement Learning \"Hello World\"\n", + "\n", + "## Copyright\n", + "\n", + "*Copyright Geoscience DS&ML Special Interest Group, 2022.*\n", + "*License: [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/)*\n", + "*Author(s): [Altay Sansal](https://github.com/tasansal)*\n", + "\n", + "## Prerequisites\n", + "\n", + "NOTE: This notebook requires wildcatter installed with the `hello_world` extra. To do this install wildcatter via:\n", + "```shell\n", + "pip install wildcatter[hello_world]\n", + "```\n", + "\n", + "This notebook assumes familiarity with Reinforcement Learning concepts (agents, spaces, actions, ...) and knowledge of [OpenAI's Gym](https://www.gymlibrary.ml/) APIs and environments. If you are not familiar with RL or Gym at all, we refer the reader to the following resources:\n", + "1. [OpenAI Gym Introduction](https://www.gymlibrary.ml/content/api/)\n", + "2. [OpenAI Gym Introduction](https://www.gymlibrary.ml/content/api/)\n", + "3. [OpenAI Spinning Up in Deep RL](https://spinningup.openai.com/en/latest/)\n", + " * [Part 1: Key Concepts in RL](https://spinningup.openai.com/en/latest/spinningup/rl_intro.html)\n", + " * [Part 2: Kinds of RL Algorithms](https://spinningup.openai.com/en/latest/spinningup/rl_intro2.html)\n", + " * [Part 3: Intro to Policy Optimization](https://spinningup.openai.com/en/latest/spinningup/rl_intro3.html)\n", + " * [Key Papers](https://spinningup.openai.com/en/latest/spinningup/keypapers.html)\n", + " * [RL Algorithms](https://spinningup.openai.com/en/latest/user/algorithms.html)\n", + "4. [David Silver's RL Course](https://www.davidsilver.uk/teaching/)\n", + "5. [Berkeley's Deep RL Bootcamp](https://sites.google.com/view/deep-rl-bootcamp/lectures)\n", + "6. [PyTorch DQN from Scratch](https://pytorch.org/tutorials/intermediate/reinforcement_q_learning.html)\n", + "7. [OpenAI Gym Tutorials](https://www.gymlibrary.ml/content/tutorials/)\n", + "8. [More Resources](https://github.com/dennybritz/reinforcement-learning#resources)\n", + "9. [If you like MATLAB...](https://www.mathworks.com/products/reinforcement-learning.html)\n", + "\n", + "First two resources are bare-minimum, but for the curious minded, we included more detailed resources!\n", + "\n", + "## Introduction\n", + "\n", + "Here we will be using an environment from `Gym`. The environment we choose is the `CartPole-v1`, which is a part of the classic control system environments.\n", + "\n", + "The problem we are trying to solve is trying to keep a pole upright, which is attached to a frictionless cart with an un-actuated joint. The goal is to balance the pole by moving the cart to the left or to the right.\n", + "\n", + "Untrained environment looks like this:\n", + "\n", + "\n", + "More information about the environment can be found [here](https://www.gymlibrary.ml/environments/classic_control/cart_pole/) and the source code for the environment can be found [here](https://github.com/openai/gym/blob/master/gym/envs/classic_control/cartpole.py).\n", + "\n", + "The environment has the following action and observation spaces:\n", + "\n", + "| Property | Details |\n", + "|-------------------|---------------------|\n", + "| Action Space | `Discrete(2)` |\n", + "| Observation Space | `Box(4, 'float32')` |\n", + "\n", + "Action Space:\n", + "\n", + "| Num | Action |\n", + "|:---:|------------------------|\n", + "| 0 | Push cart to the left |\n", + "| 1 | Push cart to the right |\n", + "\n", + "Observation Space:\n", + "\n", + "| Num | Action | Min | Max |\n", + "|:---:|-----------------------|:------------:|:-----------:|\n", + "| 0 | Cart Position | `-4.8` | `4.8` |\n", + "| 1 | Cart Velocity | `-inf` | `inf` |\n", + "| 2 | Pole Angle | `-0.418 rad` | `0.418 rad` |\n", + "| 3 | Pole Angular Velocity | `-inf` | `inf` |\n", + "\n", + "The environment will terminate automatically (send a `done` signal) if the pole's angle is more than 12 degrees (0.20944 rad) or if the position of the cart is +/- 2.4, meaning cart reaches the end of the display.\n", + "\n", + "Let's take a more detailed look!\n", + "\n", + "We first import `gym` and make the environment. Then we will look at its pre-configured action space and observation space using built in attributes." + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "import gym\n", + "\n", + "env_id = \"CartPole-v1\"\n", + "env = gym.make(env_id)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "outputs": [ + { + "data": { + "text/plain": "Discrete(2)" + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "env.action_space" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 3, + "outputs": [ + { + "data": { + "text/plain": "Box([-4.8000002e+00 -3.4028235e+38 -4.1887903e-01 -3.4028235e+38], [4.8000002e+00 3.4028235e+38 4.1887903e-01 3.4028235e+38], (4,), float32)" + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "env.observation_space" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Here let's see what the observation state looks like if we reset the environment five times." + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 4, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "reset 1 [0.01656609 0.02576861 0.0039965 0.01861649]\n", + "reset 2 [-0.03452398 -0.04903302 -0.0241876 0.03794585]\n", + "reset 3 [-0.02339839 0.01897064 0.00293178 -0.03030473]\n", + "reset 4 [ 0.0366796 -0.00294616 0.00407595 -0.00959057]\n", + "reset 5 [-0.00534603 0.04765269 -0.00063244 0.04559017]\n" + ] + } + ], + "source": [ + "for idx in range(5):\n", + " print(f\"reset {idx + 1}\", env.reset())" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "As expected, we can see the cart and pole parameters are all different once we reset the environment.\n", + "\n", + "Reminder: Values are `[cart_position, cart_velocity, pole_angle(rad), pole_angular_velocity]`.\n", + "\n", + "Now let's reset the environment and take up to 100 steps. Since there is no trained model, the actions we sample are going to be randomly selected from the action space. The expectation here is to fail after ~20 time steps.\n", + "\n", + "The boilerplate code is to visualize in Jupyter Notebook. Normally this would pop up a window using Pyglet and will visualize the current state of the system when the `.render()` method is called.\n", + "\n", + "Here, the returned variables are **observation** which is the current state, the **reward** is the current reward for the action we have taken (not cumulative), **done** states if the environment finished, or failed etc., and finally **info** is a diagnostic variable (if we included things in the `step` implementation). In the cartpole environment, the info is empty." + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 5, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from IPython import display\n", + "import matplotlib.pyplot as plt\n", + "\n", + "%matplotlib inline\n", + "\n", + "obs = env.reset()\n", + "\n", + "fig, ax = plt.subplots(figsize=(10, 10))\n", + "img = ax.imshow(env.render(mode=\"rgb_array\"), interpolation=\"none\")\n", + "fig.tight_layout()\n", + "\n", + "done = False\n", + "for idx in range(100):\n", + " img.set_data(env.render(mode=\"rgb_array\"))\n", + " display.display(plt.gcf())\n", + " display.clear_output(wait=True)\n", + "\n", + " action = env.action_space.sample()\n", + " obs, reward, done, info = env.step(action)\n", + "\n", + " if done:\n", + " plt.text(100, 100, f\"Failed at step {idx}\", fontsize=20)\n", + " break\n", + "\n", + "if not done:\n", + " plt.text(100, 100, f\"Stable until step {idx + 1}\", fontsize=20)\n", + "\n", + "env.close()" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "# Training An Agent\n", + "\n", + "We chose to use the Proximal Policy Optimization (PPO) algorithm with a Multi-Layer Perceptron (MLP, also known as Feedforward Fully-Connected Neural Network) policy to make our agent learn how to balance a stick! Some other popular algorithms are Deep Q-Network (DQN), Advantage Actor Critic (A2C), and more. A very extensive list of RL algorithms can be found [here](https://docs.ray.io/en/latest/rllib/rllib-algorithms.html).\n", + "\n", + "However, keep in mind, this is a very simple RL problem. Typically, RL algorithms require a lot of hyperparameter tuning.\n", + "\n", + "In this example, due to its simplicity, we are using the [Stable Baselines3](https://stable-baselines3.readthedocs.io/en/master/) library. This does allow many configuration options. However, for production scale RL and high performance training, the industry standard is [Ray](https://docs.ray.io/en/latest/index.html)'s [RLlib](https://docs.ray.io/en/latest/rllib/index.html).\n", + "\n", + "For tunable parameters of PPO, we recommend checking out the Stable Baselines3 documentation (below). The PPO explained article is also helpful in understanding the parameters and their meanings.\n", + "\n", + "More information about PPO:\n", + "* [PPO Paper](https://arxiv.org/abs/1707.06347)\n", + "* [OpenAI Spinning Up PPO](https://spinningup.openai.com/en/latest/algorithms/ppo.html)\n", + "* [PPO Stable Baselines3](https://stable-baselines3.readthedocs.io/en/master/modules/ppo.html)\n", + "* [PPO Explained - Article](https://jonathan-hui.medium.com/rl-proximal-policy-optimization-ppo-explained-77f014ec3f12)\n", + "* [PPO Keras from Scratch](https://keras.io/examples/rl/ppo_cartpole/)\n", + "\n", + "We will first let it train for 10,000 time-steps. We will also evaluate it on 10 episodes to and get its average score." + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 6, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using cpu device\n", + "Wrapping the env with a `Monitor` wrapper\n", + "Wrapping the env in a DummyVecEnv.\n", + "------------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 63.2 |\n", + "| ep_rew_mean | 63.2 |\n", + "| time/ | |\n", + "| fps | 1657 |\n", + "| iterations | 5 |\n", + "| time_elapsed | 6 |\n", + "| total_timesteps | 10240 |\n", + "| train/ | |\n", + "| approx_kl | 0.0070142997 |\n", + "| clip_fraction | 0.0708 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.601 |\n", + "| explained_variance | 0.254 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 22.6 |\n", + "| n_updates | 40 |\n", + "| policy_gradient_loss | -0.0167 |\n", + "| value_loss | 70.3 |\n", + "------------------------------------------\n", + "10 evaluation runs mean reward = 436.3\n" + ] + } + ], + "source": [ + "from stable_baselines3 import PPO\n", + "from stable_baselines3.common.evaluation import evaluate_policy\n", + "\n", + "model = PPO(\"MlpPolicy\", env, verbose=1)\n", + "model.learn(total_timesteps=10_000, log_interval=5)\n", + "\n", + "mean_reward, std_reward = evaluate_policy(model, model.get_env(), n_eval_episodes=10)\n", + "print(f\"10 evaluation runs mean reward = {mean_reward}\")" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Now let's visualize the trained agent.\n", + "\n", + "Note that now the action is being predicted by the model, instead of sampling randomly from the action space." + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 7, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from IPython import display\n", + "import matplotlib.pyplot as plt\n", + "\n", + "%matplotlib inline\n", + "\n", + "obs = env.reset()\n", + "\n", + "fig, ax = plt.subplots(figsize=(10, 10))\n", + "img = ax.imshow(env.render(mode=\"rgb_array\"), interpolation=\"none\")\n", + "fig.tight_layout()\n", + "\n", + "done = False\n", + "for idx in range(100):\n", + " img.set_data(env.render(mode=\"rgb_array\"))\n", + " display.display(plt.gcf())\n", + " display.clear_output(wait=True)\n", + "\n", + " action, _states = model.predict(obs)\n", + " obs, reward, done, info = env.step(action)\n", + "\n", + " if done:\n", + " plt.text(100, 100, f\"Failed at step {idx}\", fontsize=20)\n", + " break\n", + "\n", + "if not done:\n", + " plt.text(100, 100, f\"Stable until step {idx + 1}\", fontsize=20)\n", + "\n", + "env.close()" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Let's train for more time." + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 8, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using cpu device\n", + "Wrapping the env with a `Monitor` wrapper\n", + "Wrapping the env in a DummyVecEnv.\n", + "------------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 236 |\n", + "| ep_rew_mean | 236 |\n", + "| time/ | |\n", + "| fps | 1526 |\n", + "| iterations | 15 |\n", + "| time_elapsed | 20 |\n", + "| total_timesteps | 30720 |\n", + "| train/ | |\n", + "| approx_kl | 0.0048547667 |\n", + "| clip_fraction | 0.0299 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.523 |\n", + "| explained_variance | 0.052 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 0.0786 |\n", + "| n_updates | 140 |\n", + "| policy_gradient_loss | -0.000506 |\n", + "| value_loss | 1.98 |\n", + "------------------------------------------\n", + "------------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 465 |\n", + "| ep_rew_mean | 465 |\n", + "| time/ | |\n", + "| fps | 1508 |\n", + "| iterations | 30 |\n", + "| time_elapsed | 40 |\n", + "| total_timesteps | 61440 |\n", + "| train/ | |\n", + "| approx_kl | 0.0048740814 |\n", + "| clip_fraction | 0.024 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.48 |\n", + "| explained_variance | 0.00551 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 0.00102 |\n", + "| n_updates | 290 |\n", + "| policy_gradient_loss | -0.00275 |\n", + "| value_loss | 0.00221 |\n", + "------------------------------------------\n", + "10 evaluation runs mean reward = 500.0\n" + ] + } + ], + "source": [ + "model = PPO(\"MlpPolicy\", env, verbose=1)\n", + "model.learn(total_timesteps=60_000, log_interval=15)\n", + "\n", + "mean_reward, std_reward = evaluate_policy(model, model.get_env(), n_eval_episodes=10)\n", + "print(f\"10 evaluation runs mean reward = {mean_reward}\")" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 9, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from IPython import display\n", + "import matplotlib.pyplot as plt\n", + "\n", + "%matplotlib inline\n", + "\n", + "obs = env.reset()\n", + "\n", + "fig, ax = plt.subplots(figsize=(10, 10))\n", + "img = ax.imshow(env.render(mode=\"rgb_array\"), interpolation=\"none\")\n", + "fig.tight_layout()\n", + "\n", + "done = False\n", + "for idx in range(100):\n", + " img.set_data(env.render(mode=\"rgb_array\"))\n", + " display.display(plt.gcf())\n", + " display.clear_output(wait=True)\n", + "\n", + " action, _states = model.predict(obs)\n", + " obs, reward, done, info = env.step(action)\n", + "\n", + " if done:\n", + " plt.text(100, 100, f\"Failed at step {idx}\", fontsize=20)\n", + " break\n", + "\n", + "if not done:\n", + " plt.text(100, 100, f\"Stable until step {idx + 1}\", fontsize=20)\n", + "\n", + "env.close()" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "The new agent is much better at balancing the pole. If we increased the training steps to above 100,000 it is hard to see that the pole is even moving!\n", + "\n", + "# Conclusions\n", + "* We learned about the CartPole environment.\n", + "* We trained a simple RL environment using PPO algorithm.\n", + "\n", + "# Next Steps\n", + "If you want to improve your RL skills from here, we recommend:\n", + "1. Use different OpenAI Gym environments to practice.\n", + "2. Try different RL algorithms (links above).\n", + "3. Try hyperparameter tuning with Ray RLlib (links above).\n", + "4. Implement your own environment for wildcatter!\n", + "5. Check out Stable Baselines3 or RLlib TensorBoard integration [here](https://stable-baselines3.readthedocs.io/en/master/guide/tensorboard.html) and [here](https://docs.ray.io/en/latest/rllib/rllib-training.html)." + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/examples/GITCDRILLER.ipynb b/examples/GITCDRILLER.ipynb index c0466a4..0501b1d 100644 --- a/examples/GITCDRILLER.ipynb +++ b/examples/GITCDRILLER.ipynb @@ -81,15 +81,15 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 9, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Beginning Drill Campaign: 1\n", - "Final Trajectory:[[1, 79], [1, 78], [2, 78], [2, 77], [3, 77], [4, 77], [4, 78], [4, 79], [3, 79], [3, 78]]\n", - "Campaign:1 Score:0.0\n", + "Final Trajectory:[[1, 20], [1, 19], [1, 18], [1, 17], [1, 16], [1, 15], [1, 14], [2, 14], [2, 13], [3, 13], [4, 13], [4, 14], [3, 14], [3, 15], [2, 15], [2, 16], [3, 16], [4, 16], [4, 15], [5, 15], [5, 16], [6, 16], [7, 16], [8, 16], [8, 15], [7, 15], [6, 15], [6, 14], [5, 14], [5, 13], [5, 12], [5, 11], [6, 11], [7, 11], [7, 12], [7, 13], [8, 13], [9, 13], [10, 13], [10, 14], [11, 14], [11, 15], [11, 16], [10, 16], [10, 15], [9, 15], [9, 14], [8, 14], [7, 14]]\n", + "Campaign:1 Score:6.0\n", "------------------------------------------\n" ] } @@ -139,20 +139,20 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 10, "outputs": [ { "data": { - "text/plain": "[]" + "text/plain": "[]" }, - "execution_count": 4, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/plain": "
", - "image/png": "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\n" + "image/png": "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\n" }, "metadata": { "needs_background": "light" @@ -191,370 +191,1049 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 29, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "2022-06-26 22:39:46,341\tWARNING trainer.py:2540 -- You have specified 1 evaluation workers, but your `evaluation_interval` is None! Therefore, evaluation will not occur automatically with each call to `Trainer.train()`. Instead, you will have to call `Trainer.evaluate()` manually in order to trigger an evaluation run.\n", - "\u001B[2m\u001B[36m(RolloutWorker pid=26440)\u001B[0m 2022-06-26 22:39:47,530\tWARNING env.py:135 -- Your env doesn't have a .spec.max_episode_steps attribute. This is fine if you have set 'horizon' in your config dictionary, or `soft_horizon`. However, if you haven't, 'horizon' will default to infinity, and your environment will not be reset.\n", - "2022-06-26 22:39:47,558\tWARNING deprecation.py:46 -- DeprecationWarning: `simple_optimizer` has been deprecated. This will raise an error in the future!\n", - "2022-06-26 22:39:47,559\tWARNING trainer.py:2540 -- You have specified 1 evaluation workers, but your `evaluation_interval` is None! Therefore, evaluation will not occur automatically with each call to `Trainer.train()`. Instead, you will have to call `Trainer.evaluate()` manually in order to trigger an evaluation run.\n", - "2022-06-26 22:39:47,583\tWARNING util.py:65 -- Install gputil for GPU system monitoring.\n" + "Using cpu device\n", + "Wrapping the env with a `Monitor` wrapper\n", + "Wrapping the env in a DummyVecEnv.\n", + "---------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 37.2 |\n", + "| ep_rew_mean | 5.53 |\n", + "| time/ | |\n", + "| fps | 2515 |\n", + "| iterations | 1 |\n", + "| time_elapsed | 0 |\n", + "| total_timesteps | 2048 |\n", + "---------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 36.8 |\n", + "| ep_rew_mean | 8.55 |\n", + "| time/ | |\n", + "| fps | 1430 |\n", + "| iterations | 2 |\n", + "| time_elapsed | 2 |\n", + "| total_timesteps | 4096 |\n", + "| train/ | |\n", + "| approx_kl | 0.013634276 |\n", + "| clip_fraction | 0.0814 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -1.38 |\n", + "| explained_variance | 0.00258 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 2.78 |\n", + "| n_updates | 10 |\n", + "| policy_gradient_loss | -0.0182 |\n", + "| value_loss | 10.3 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 37.8 |\n", + "| ep_rew_mean | 11.4 |\n", + "| time/ | |\n", + "| fps | 1193 |\n", + "| iterations | 3 |\n", + "| time_elapsed | 5 |\n", + "| total_timesteps | 6144 |\n", + "| train/ | |\n", + "| approx_kl | 0.013353095 |\n", + "| clip_fraction | 0.103 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -1.37 |\n", + "| explained_variance | -0.236 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 6.1 |\n", + "| n_updates | 20 |\n", + "| policy_gradient_loss | -0.0231 |\n", + "| value_loss | 19.8 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 37.9 |\n", + "| ep_rew_mean | 16.2 |\n", + "| time/ | |\n", + "| fps | 1144 |\n", + "| iterations | 4 |\n", + "| time_elapsed | 7 |\n", + "| total_timesteps | 8192 |\n", + "| train/ | |\n", + "| approx_kl | 0.012107523 |\n", + "| clip_fraction | 0.104 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -1.35 |\n", + "| explained_variance | -0.517 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 6.79 |\n", + "| n_updates | 30 |\n", + "| policy_gradient_loss | -0.0225 |\n", + "| value_loss | 19.9 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 38.7 |\n", + "| ep_rew_mean | 19.6 |\n", + "| time/ | |\n", + "| fps | 1106 |\n", + "| iterations | 5 |\n", + "| time_elapsed | 9 |\n", + "| total_timesteps | 10240 |\n", + "| train/ | |\n", + "| approx_kl | 0.012206594 |\n", + "| clip_fraction | 0.106 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -1.33 |\n", + "| explained_variance | 0.159 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 7.96 |\n", + "| n_updates | 40 |\n", + "| policy_gradient_loss | -0.0222 |\n", + "| value_loss | 29.4 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 40.4 |\n", + "| ep_rew_mean | 24.4 |\n", + "| time/ | |\n", + "| fps | 1090 |\n", + "| iterations | 6 |\n", + "| time_elapsed | 11 |\n", + "| total_timesteps | 12288 |\n", + "| train/ | |\n", + "| approx_kl | 0.012887731 |\n", + "| clip_fraction | 0.118 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -1.31 |\n", + "| explained_variance | -0.197 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 4.93 |\n", + "| n_updates | 50 |\n", + "| policy_gradient_loss | -0.0237 |\n", + "| value_loss | 21.3 |\n", + "-----------------------------------------\n", + "----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 41.5 |\n", + "| ep_rew_mean | 29.8 |\n", + "| time/ | |\n", + "| fps | 1077 |\n", + "| iterations | 7 |\n", + "| time_elapsed | 13 |\n", + "| total_timesteps | 14336 |\n", + "| train/ | |\n", + "| approx_kl | 0.01786647 |\n", + "| clip_fraction | 0.171 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -1.28 |\n", + "| explained_variance | 0.171 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 7.79 |\n", + "| n_updates | 60 |\n", + "| policy_gradient_loss | -0.0311 |\n", + "| value_loss | 23.2 |\n", + "----------------------------------------\n", + "----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 40.8 |\n", + "| ep_rew_mean | 32 |\n", + "| time/ | |\n", + "| fps | 1071 |\n", + "| iterations | 8 |\n", + "| time_elapsed | 15 |\n", + "| total_timesteps | 16384 |\n", + "| train/ | |\n", + "| approx_kl | 0.01916794 |\n", + "| clip_fraction | 0.204 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -1.24 |\n", + "| explained_variance | -0.139 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 2.64 |\n", + "| n_updates | 70 |\n", + "| policy_gradient_loss | -0.0329 |\n", + "| value_loss | 23.1 |\n", + "----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 41.3 |\n", + "| ep_rew_mean | 35 |\n", + "| time/ | |\n", + "| fps | 1066 |\n", + "| iterations | 9 |\n", + "| time_elapsed | 17 |\n", + "| total_timesteps | 18432 |\n", + "| train/ | |\n", + "| approx_kl | 0.015325593 |\n", + "| clip_fraction | 0.166 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -1.18 |\n", + "| explained_variance | 0.112 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 11.8 |\n", + "| n_updates | 80 |\n", + "| policy_gradient_loss | -0.0305 |\n", + "| value_loss | 45.5 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 43.8 |\n", + "| ep_rew_mean | 38.7 |\n", + "| time/ | |\n", + "| fps | 1062 |\n", + "| iterations | 10 |\n", + "| time_elapsed | 19 |\n", + "| total_timesteps | 20480 |\n", + "| train/ | |\n", + "| approx_kl | 0.017579105 |\n", + "| clip_fraction | 0.179 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -1.17 |\n", + "| explained_variance | 0.279 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 6.79 |\n", + "| n_updates | 90 |\n", + "| policy_gradient_loss | -0.0343 |\n", + "| value_loss | 29.1 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 44.4 |\n", + "| ep_rew_mean | 41.5 |\n", + "| time/ | |\n", + "| fps | 1057 |\n", + "| iterations | 11 |\n", + "| time_elapsed | 21 |\n", + "| total_timesteps | 22528 |\n", + "| train/ | |\n", + "| approx_kl | 0.022615077 |\n", + "| clip_fraction | 0.211 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -1.15 |\n", + "| explained_variance | 0.286 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 1.93 |\n", + "| n_updates | 100 |\n", + "| policy_gradient_loss | -0.0349 |\n", + "| value_loss | 26.8 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 44 |\n", + "| ep_rew_mean | 43.1 |\n", + "| time/ | |\n", + "| fps | 1056 |\n", + "| iterations | 12 |\n", + "| time_elapsed | 23 |\n", + "| total_timesteps | 24576 |\n", + "| train/ | |\n", + "| approx_kl | 0.019501587 |\n", + "| clip_fraction | 0.187 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -1.11 |\n", + "| explained_variance | 0.0308 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 2.83 |\n", + "| n_updates | 110 |\n", + "| policy_gradient_loss | -0.0263 |\n", + "| value_loss | 24.9 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 44.6 |\n", + "| ep_rew_mean | 43 |\n", + "| time/ | |\n", + "| fps | 1054 |\n", + "| iterations | 13 |\n", + "| time_elapsed | 25 |\n", + "| total_timesteps | 26624 |\n", + "| train/ | |\n", + "| approx_kl | 0.020266306 |\n", + "| clip_fraction | 0.177 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -1.1 |\n", + "| explained_variance | 0.197 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 6.29 |\n", + "| n_updates | 120 |\n", + "| policy_gradient_loss | -0.0302 |\n", + "| value_loss | 27.6 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 44.4 |\n", + "| ep_rew_mean | 43 |\n", + "| time/ | |\n", + "| fps | 1050 |\n", + "| iterations | 14 |\n", + "| time_elapsed | 27 |\n", + "| total_timesteps | 28672 |\n", + "| train/ | |\n", + "| approx_kl | 0.021240473 |\n", + "| clip_fraction | 0.196 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -1.09 |\n", + "| explained_variance | 0.402 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 2.38 |\n", + "| n_updates | 130 |\n", + "| policy_gradient_loss | -0.0312 |\n", + "| value_loss | 22.6 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 45.7 |\n", + "| ep_rew_mean | 44.9 |\n", + "| time/ | |\n", + "| fps | 1047 |\n", + "| iterations | 15 |\n", + "| time_elapsed | 29 |\n", + "| total_timesteps | 30720 |\n", + "| train/ | |\n", + "| approx_kl | 0.022564664 |\n", + "| clip_fraction | 0.21 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -1.03 |\n", + "| explained_variance | 0.456 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 4.64 |\n", + "| n_updates | 140 |\n", + "| policy_gradient_loss | -0.0311 |\n", + "| value_loss | 21.3 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 46.7 |\n", + "| ep_rew_mean | 52.2 |\n", + "| time/ | |\n", + "| fps | 1046 |\n", + "| iterations | 16 |\n", + "| time_elapsed | 31 |\n", + "| total_timesteps | 32768 |\n", + "| train/ | |\n", + "| approx_kl | 0.025807586 |\n", + "| clip_fraction | 0.214 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -1.02 |\n", + "| explained_variance | 0.456 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 2.31 |\n", + "| n_updates | 150 |\n", + "| policy_gradient_loss | -0.0366 |\n", + "| value_loss | 23.4 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 46.5 |\n", + "| ep_rew_mean | 55.6 |\n", + "| time/ | |\n", + "| fps | 1046 |\n", + "| iterations | 17 |\n", + "| time_elapsed | 33 |\n", + "| total_timesteps | 34816 |\n", + "| train/ | |\n", + "| approx_kl | 0.030747198 |\n", + "| clip_fraction | 0.218 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.967 |\n", + "| explained_variance | 0.523 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 1.17 |\n", + "| n_updates | 160 |\n", + "| policy_gradient_loss | -0.0352 |\n", + "| value_loss | 18.7 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 47.4 |\n", + "| ep_rew_mean | 55 |\n", + "| time/ | |\n", + "| fps | 1044 |\n", + "| iterations | 18 |\n", + "| time_elapsed | 35 |\n", + "| total_timesteps | 36864 |\n", + "| train/ | |\n", + "| approx_kl | 0.021806555 |\n", + "| clip_fraction | 0.174 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.923 |\n", + "| explained_variance | 0.551 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 2.33 |\n", + "| n_updates | 170 |\n", + "| policy_gradient_loss | -0.0253 |\n", + "| value_loss | 20.3 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 47.3 |\n", + "| ep_rew_mean | 56.3 |\n", + "| time/ | |\n", + "| fps | 1043 |\n", + "| iterations | 19 |\n", + "| time_elapsed | 37 |\n", + "| total_timesteps | 38912 |\n", + "| train/ | |\n", + "| approx_kl | 0.024414975 |\n", + "| clip_fraction | 0.199 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.851 |\n", + "| explained_variance | 0.647 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 1.53 |\n", + "| n_updates | 180 |\n", + "| policy_gradient_loss | -0.0342 |\n", + "| value_loss | 14.2 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 48 |\n", + "| ep_rew_mean | 58.3 |\n", + "| time/ | |\n", + "| fps | 1043 |\n", + "| iterations | 20 |\n", + "| time_elapsed | 39 |\n", + "| total_timesteps | 40960 |\n", + "| train/ | |\n", + "| approx_kl | 0.027630093 |\n", + "| clip_fraction | 0.187 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.883 |\n", + "| explained_variance | 0.623 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 1.64 |\n", + "| n_updates | 190 |\n", + "| policy_gradient_loss | -0.0303 |\n", + "| value_loss | 16.9 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 47.5 |\n", + "| ep_rew_mean | 55.3 |\n", + "| time/ | |\n", + "| fps | 1043 |\n", + "| iterations | 21 |\n", + "| time_elapsed | 41 |\n", + "| total_timesteps | 43008 |\n", + "| train/ | |\n", + "| approx_kl | 0.029191367 |\n", + "| clip_fraction | 0.212 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.912 |\n", + "| explained_variance | 0.697 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 1.33 |\n", + "| n_updates | 200 |\n", + "| policy_gradient_loss | -0.0311 |\n", + "| value_loss | 13.2 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 46.2 |\n", + "| ep_rew_mean | 55.2 |\n", + "| time/ | |\n", + "| fps | 1042 |\n", + "| iterations | 22 |\n", + "| time_elapsed | 43 |\n", + "| total_timesteps | 45056 |\n", + "| train/ | |\n", + "| approx_kl | 0.024926957 |\n", + "| clip_fraction | 0.217 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.978 |\n", + "| explained_variance | 0.757 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 3.37 |\n", + "| n_updates | 210 |\n", + "| policy_gradient_loss | -0.0296 |\n", + "| value_loss | 13.8 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 45.9 |\n", + "| ep_rew_mean | 54.2 |\n", + "| time/ | |\n", + "| fps | 1040 |\n", + "| iterations | 23 |\n", + "| time_elapsed | 45 |\n", + "| total_timesteps | 47104 |\n", + "| train/ | |\n", + "| approx_kl | 0.018353421 |\n", + "| clip_fraction | 0.157 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.913 |\n", + "| explained_variance | 0.516 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 6.13 |\n", + "| n_updates | 220 |\n", + "| policy_gradient_loss | -0.0252 |\n", + "| value_loss | 21.4 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 46 |\n", + "| ep_rew_mean | 54.1 |\n", + "| time/ | |\n", + "| fps | 1040 |\n", + "| iterations | 24 |\n", + "| time_elapsed | 47 |\n", + "| total_timesteps | 49152 |\n", + "| train/ | |\n", + "| approx_kl | 0.023231193 |\n", + "| clip_fraction | 0.195 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.896 |\n", + "| explained_variance | 0.553 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 1.56 |\n", + "| n_updates | 230 |\n", + "| policy_gradient_loss | -0.0255 |\n", + "| value_loss | 18.6 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 46.4 |\n", + "| ep_rew_mean | 54.3 |\n", + "| time/ | |\n", + "| fps | 1039 |\n", + "| iterations | 25 |\n", + "| time_elapsed | 49 |\n", + "| total_timesteps | 51200 |\n", + "| train/ | |\n", + "| approx_kl | 0.036347933 |\n", + "| clip_fraction | 0.202 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.86 |\n", + "| explained_variance | 0.718 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 0.997 |\n", + "| n_updates | 240 |\n", + "| policy_gradient_loss | -0.0301 |\n", + "| value_loss | 12.7 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 47.7 |\n", + "| ep_rew_mean | 59.2 |\n", + "| time/ | |\n", + "| fps | 1037 |\n", + "| iterations | 26 |\n", + "| time_elapsed | 51 |\n", + "| total_timesteps | 53248 |\n", + "| train/ | |\n", + "| approx_kl | 0.035032943 |\n", + "| clip_fraction | 0.222 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.849 |\n", + "| explained_variance | 0.688 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 0.585 |\n", + "| n_updates | 250 |\n", + "| policy_gradient_loss | -0.0367 |\n", + "| value_loss | 15.5 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 47.6 |\n", + "| ep_rew_mean | 63.6 |\n", + "| time/ | |\n", + "| fps | 1033 |\n", + "| iterations | 27 |\n", + "| time_elapsed | 53 |\n", + "| total_timesteps | 55296 |\n", + "| train/ | |\n", + "| approx_kl | 0.030332688 |\n", + "| clip_fraction | 0.221 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.849 |\n", + "| explained_variance | 0.714 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 5.26 |\n", + "| n_updates | 260 |\n", + "| policy_gradient_loss | -0.0269 |\n", + "| value_loss | 12.4 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 48.3 |\n", + "| ep_rew_mean | 67.8 |\n", + "| time/ | |\n", + "| fps | 1033 |\n", + "| iterations | 28 |\n", + "| time_elapsed | 55 |\n", + "| total_timesteps | 57344 |\n", + "| train/ | |\n", + "| approx_kl | 0.022188712 |\n", + "| clip_fraction | 0.187 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.818 |\n", + "| explained_variance | 0.757 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 0.429 |\n", + "| n_updates | 270 |\n", + "| policy_gradient_loss | -0.0195 |\n", + "| value_loss | 13.5 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 47.9 |\n", + "| ep_rew_mean | 64.8 |\n", + "| time/ | |\n", + "| fps | 1032 |\n", + "| iterations | 29 |\n", + "| time_elapsed | 57 |\n", + "| total_timesteps | 59392 |\n", + "| train/ | |\n", + "| approx_kl | 0.032070115 |\n", + "| clip_fraction | 0.189 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.85 |\n", + "| explained_variance | 0.68 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 1.34 |\n", + "| n_updates | 280 |\n", + "| policy_gradient_loss | -0.0267 |\n", + "| value_loss | 13.1 |\n", + "-----------------------------------------\n", + "----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 48.2 |\n", + "| ep_rew_mean | 68.2 |\n", + "| time/ | |\n", + "| fps | 1031 |\n", + "| iterations | 30 |\n", + "| time_elapsed | 59 |\n", + "| total_timesteps | 61440 |\n", + "| train/ | |\n", + "| approx_kl | 0.02034546 |\n", + "| clip_fraction | 0.166 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.843 |\n", + "| explained_variance | 0.723 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 6.54 |\n", + "| n_updates | 290 |\n", + "| policy_gradient_loss | -0.0272 |\n", + "| value_loss | 13.8 |\n", + "----------------------------------------\n", + "----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 48.5 |\n", + "| ep_rew_mean | 68.2 |\n", + "| time/ | |\n", + "| fps | 1031 |\n", + "| iterations | 31 |\n", + "| time_elapsed | 61 |\n", + "| total_timesteps | 63488 |\n", + "| train/ | |\n", + "| approx_kl | 0.02899862 |\n", + "| clip_fraction | 0.172 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.832 |\n", + "| explained_variance | 0.754 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 0.529 |\n", + "| n_updates | 300 |\n", + "| policy_gradient_loss | -0.0231 |\n", + "| value_loss | 11.8 |\n", + "----------------------------------------\n", + "----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 48.9 |\n", + "| ep_rew_mean | 69.4 |\n", + "| time/ | |\n", + "| fps | 1031 |\n", + "| iterations | 32 |\n", + "| time_elapsed | 63 |\n", + "| total_timesteps | 65536 |\n", + "| train/ | |\n", + "| approx_kl | 0.02797267 |\n", + "| clip_fraction | 0.203 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.785 |\n", + "| explained_variance | 0.735 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 1.52 |\n", + "| n_updates | 310 |\n", + "| policy_gradient_loss | -0.0298 |\n", + "| value_loss | 12.1 |\n", + "----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 48.2 |\n", + "| ep_rew_mean | 69.4 |\n", + "| time/ | |\n", + "| fps | 1032 |\n", + "| iterations | 33 |\n", + "| time_elapsed | 65 |\n", + "| total_timesteps | 67584 |\n", + "| train/ | |\n", + "| approx_kl | 0.026359558 |\n", + "| clip_fraction | 0.197 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.821 |\n", + "| explained_variance | 0.677 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 1.94 |\n", + "| n_updates | 320 |\n", + "| policy_gradient_loss | -0.0186 |\n", + "| value_loss | 10.1 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 47.5 |\n", + "| ep_rew_mean | 64.6 |\n", + "| time/ | |\n", + "| fps | 1032 |\n", + "| iterations | 34 |\n", + "| time_elapsed | 67 |\n", + "| total_timesteps | 69632 |\n", + "| train/ | |\n", + "| approx_kl | 0.022267094 |\n", + "| clip_fraction | 0.16 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.84 |\n", + "| explained_variance | 0.626 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 0.636 |\n", + "| n_updates | 330 |\n", + "| policy_gradient_loss | -0.0252 |\n", + "| value_loss | 17 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 48.3 |\n", + "| ep_rew_mean | 62.4 |\n", + "| time/ | |\n", + "| fps | 1032 |\n", + "| iterations | 35 |\n", + "| time_elapsed | 69 |\n", + "| total_timesteps | 71680 |\n", + "| train/ | |\n", + "| approx_kl | 0.020569442 |\n", + "| clip_fraction | 0.164 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.774 |\n", + "| explained_variance | 0.616 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 1.72 |\n", + "| n_updates | 340 |\n", + "| policy_gradient_loss | -0.0254 |\n", + "| value_loss | 22.2 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 48 |\n", + "| ep_rew_mean | 60.9 |\n", + "| time/ | |\n", + "| fps | 1032 |\n", + "| iterations | 36 |\n", + "| time_elapsed | 71 |\n", + "| total_timesteps | 73728 |\n", + "| train/ | |\n", + "| approx_kl | 0.024448898 |\n", + "| clip_fraction | 0.193 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.803 |\n", + "| explained_variance | 0.733 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 0.261 |\n", + "| n_updates | 350 |\n", + "| policy_gradient_loss | -0.0194 |\n", + "| value_loss | 9.33 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 47.7 |\n", + "| ep_rew_mean | 60.2 |\n", + "| time/ | |\n", + "| fps | 1032 |\n", + "| iterations | 37 |\n", + "| time_elapsed | 73 |\n", + "| total_timesteps | 75776 |\n", + "| train/ | |\n", + "| approx_kl | 0.018581904 |\n", + "| clip_fraction | 0.146 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.815 |\n", + "| explained_variance | 0.579 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 0.554 |\n", + "| n_updates | 360 |\n", + "| policy_gradient_loss | -0.0206 |\n", + "| value_loss | 15.9 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 47.4 |\n", + "| ep_rew_mean | 64.3 |\n", + "| time/ | |\n", + "| fps | 1032 |\n", + "| iterations | 38 |\n", + "| time_elapsed | 75 |\n", + "| total_timesteps | 77824 |\n", + "| train/ | |\n", + "| approx_kl | 0.032826275 |\n", + "| clip_fraction | 0.208 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.84 |\n", + "| explained_variance | 0.73 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 1.56 |\n", + "| n_updates | 370 |\n", + "| policy_gradient_loss | -0.0271 |\n", + "| value_loss | 9.75 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 47.9 |\n", + "| ep_rew_mean | 68.2 |\n", + "| time/ | |\n", + "| fps | 1033 |\n", + "| iterations | 39 |\n", + "| time_elapsed | 77 |\n", + "| total_timesteps | 79872 |\n", + "| train/ | |\n", + "| approx_kl | 0.025048047 |\n", + "| clip_fraction | 0.167 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.806 |\n", + "| explained_variance | 0.667 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 0.948 |\n", + "| n_updates | 380 |\n", + "| policy_gradient_loss | -0.0278 |\n", + "| value_loss | 16.7 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 48.1 |\n", + "| ep_rew_mean | 69.3 |\n", + "| time/ | |\n", + "| fps | 1033 |\n", + "| iterations | 40 |\n", + "| time_elapsed | 79 |\n", + "| total_timesteps | 81920 |\n", + "| train/ | |\n", + "| approx_kl | 0.029102538 |\n", + "| clip_fraction | 0.181 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.802 |\n", + "| explained_variance | 0.688 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 4.84 |\n", + "| n_updates | 390 |\n", + "| policy_gradient_loss | -0.0268 |\n", + "| value_loss | 12.5 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 48.1 |\n", + "| ep_rew_mean | 70.5 |\n", + "| time/ | |\n", + "| fps | 1033 |\n", + "| iterations | 41 |\n", + "| time_elapsed | 81 |\n", + "| total_timesteps | 83968 |\n", + "| train/ | |\n", + "| approx_kl | 0.025559815 |\n", + "| clip_fraction | 0.183 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.755 |\n", + "| explained_variance | 0.586 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 10.1 |\n", + "| n_updates | 400 |\n", + "| policy_gradient_loss | -0.0222 |\n", + "| value_loss | 17.9 |\n", + "-----------------------------------------\n", + "----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 47.5 |\n", + "| ep_rew_mean | 70.5 |\n", + "| time/ | |\n", + "| fps | 1033 |\n", + "| iterations | 42 |\n", + "| time_elapsed | 83 |\n", + "| total_timesteps | 86016 |\n", + "| train/ | |\n", + "| approx_kl | 0.02624162 |\n", + "| clip_fraction | 0.196 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.757 |\n", + "| explained_variance | 0.695 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 1.03 |\n", + "| n_updates | 410 |\n", + "| policy_gradient_loss | -0.0318 |\n", + "| value_loss | 16.3 |\n", + "----------------------------------------\n", + "----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 47.3 |\n", + "| ep_rew_mean | 68 |\n", + "| time/ | |\n", + "| fps | 1033 |\n", + "| iterations | 43 |\n", + "| time_elapsed | 85 |\n", + "| total_timesteps | 88064 |\n", + "| train/ | |\n", + "| approx_kl | 0.02397079 |\n", + "| clip_fraction | 0.179 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.752 |\n", + "| explained_variance | 0.741 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 0.84 |\n", + "| n_updates | 420 |\n", + "| policy_gradient_loss | -0.0246 |\n", + "| value_loss | 14.4 |\n", + "----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 47.3 |\n", + "| ep_rew_mean | 71.2 |\n", + "| time/ | |\n", + "| fps | 1034 |\n", + "| iterations | 44 |\n", + "| time_elapsed | 87 |\n", + "| total_timesteps | 90112 |\n", + "| train/ | |\n", + "| approx_kl | 0.027211327 |\n", + "| clip_fraction | 0.178 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.715 |\n", + "| explained_variance | 0.701 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 0.853 |\n", + "| n_updates | 430 |\n", + "| policy_gradient_loss | -0.0285 |\n", + "| value_loss | 15.1 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 48 |\n", + "| ep_rew_mean | 73.1 |\n", + "| time/ | |\n", + "| fps | 1033 |\n", + "| iterations | 45 |\n", + "| time_elapsed | 89 |\n", + "| total_timesteps | 92160 |\n", + "| train/ | |\n", + "| approx_kl | 0.030918961 |\n", + "| clip_fraction | 0.199 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.706 |\n", + "| explained_variance | 0.743 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 0.408 |\n", + "| n_updates | 440 |\n", + "| policy_gradient_loss | -0.0314 |\n", + "| value_loss | 12.1 |\n", + "-----------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 48 |\n", + "| ep_rew_mean | 67.7 |\n", + "| time/ | |\n", + "| fps | 1034 |\n", + "| iterations | 46 |\n", + "| time_elapsed | 91 |\n", + "| total_timesteps | 94208 |\n", + "| train/ | |\n", + "| approx_kl | 0.031077448 |\n", + "| clip_fraction | 0.19 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.74 |\n", + "| explained_variance | 0.725 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 0.939 |\n", + "| n_updates | 450 |\n", + "| policy_gradient_loss | -0.0251 |\n", + "| value_loss | 16.3 |\n", + "-----------------------------------------\n", + "----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 47.5 |\n", + "| ep_rew_mean | 66.8 |\n", + "| time/ | |\n", + "| fps | 1034 |\n", + "| iterations | 47 |\n", + "| time_elapsed | 93 |\n", + "| total_timesteps | 96256 |\n", + "| train/ | |\n", + "| approx_kl | 0.04024612 |\n", + "| clip_fraction | 0.216 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.763 |\n", + "| explained_variance | 0.778 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 8.65 |\n", + "| n_updates | 460 |\n", + "| policy_gradient_loss | -0.023 |\n", + "| value_loss | 12.8 |\n", + "----------------------------------------\n", + "---------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 47.8 |\n", + "| ep_rew_mean | 71.1 |\n", + "| time/ | |\n", + "| fps | 1034 |\n", + "| iterations | 48 |\n", + "| time_elapsed | 95 |\n", + "| total_timesteps | 98304 |\n", + "| train/ | |\n", + "| approx_kl | 0.0291792 |\n", + "| clip_fraction | 0.164 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.713 |\n", + "| explained_variance | 0.67 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 0.508 |\n", + "| n_updates | 470 |\n", + "| policy_gradient_loss | -0.0251 |\n", + "| value_loss | 18.4 |\n", + "---------------------------------------\n", + "-----------------------------------------\n", + "| rollout/ | |\n", + "| ep_len_mean | 47.9 |\n", + "| ep_rew_mean | 70.7 |\n", + "| time/ | |\n", + "| fps | 1034 |\n", + "| iterations | 49 |\n", + "| time_elapsed | 97 |\n", + "| total_timesteps | 100352 |\n", + "| train/ | |\n", + "| approx_kl | 0.023564141 |\n", + "| clip_fraction | 0.17 |\n", + "| clip_range | 0.2 |\n", + "| entropy_loss | -0.711 |\n", + "| explained_variance | 0.747 |\n", + "| learning_rate | 0.0003 |\n", + "| loss | 3.71 |\n", + "| n_updates | 480 |\n", + "| policy_gradient_loss | -0.0262 |\n", + "| value_loss | 16.8 |\n", + "-----------------------------------------\n" ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "agent_timesteps_total: 400000\n", - "counters:\n", - " num_agent_steps_sampled: 400000\n", - " num_agent_steps_trained: 400000\n", - " num_env_steps_sampled: 400000\n", - " num_env_steps_trained: 400000\n", - "custom_metrics: {}\n", - "date: 2022-06-26_22-36-03\n", - "done: false\n", - "episode_len_mean: 46.07\n", - "episode_media: {}\n", - "episode_reward_max: 105.0\n", - "episode_reward_mean: 51.58\n", - "episode_reward_min: 0.0\n", - "episodes_this_iter: 87\n", - "episodes_total: 9151\n", - "experiment_id: 5c8a0ce325bb43fdbfc48ff86af365ed\n", - "hostname: Tunas-MBP\n", - "info:\n", - " learner:\n", - " default_policy:\n", - " custom_metrics: {}\n", - " learner_stats:\n", - " allreduce_latency: 0.0\n", - " cur_kl_coeff: 0.1351524353027344\n", - " cur_lr: 5.0000000000000016e-05\n", - " entropy: 0.9303349953184845\n", - " entropy_coeff: 0.0\n", - " kl: 0.01656992954417302\n", - " policy_loss: -0.023239906389586708\n", - " total_loss: 8.470313142961071\n", - " vf_explained_var: 0.0020984554162589452\n", - " vf_loss: 8.491313570289202\n", - " model: {}\n", - " num_agent_steps_trained: 128.0\n", - " num_agent_steps_sampled: 400000\n", - " num_agent_steps_trained: 400000\n", - " num_env_steps_sampled: 400000\n", - " num_env_steps_trained: 400000\n", - "iterations_since_restore: 100\n", - "node_ip: 127.0.0.1\n", - "num_agent_steps_sampled: 400000\n", - "num_agent_steps_trained: 400000\n", - "num_env_steps_sampled: 400000\n", - "num_env_steps_sampled_this_iter: 4000\n", - "num_env_steps_trained: 400000\n", - "num_env_steps_trained_this_iter: 4000\n", - "num_healthy_workers: 1\n", - "off_policy_estimator: {}\n", - "perf:\n", - " cpu_util_percent: 20.3\n", - " ram_util_percent: 49.95\n", - "pid: 26353\n", - "policy_reward_max: {}\n", - "policy_reward_mean: {}\n", - "policy_reward_min: {}\n", - "sampler_perf:\n", - " mean_action_processing_ms: 0.015232992197203539\n", - " mean_env_render_ms: 0.0\n", - " mean_env_wait_ms: 0.02046124757879715\n", - " mean_inference_ms: 0.23212124637428544\n", - " mean_raw_obs_processing_ms: 0.03181764830420682\n", - "sampler_results:\n", - " custom_metrics: {}\n", - " episode_len_mean: 46.07\n", - " episode_media: {}\n", - " episode_reward_max: 105.0\n", - " episode_reward_mean: 51.58\n", - " episode_reward_min: 0.0\n", - " episodes_this_iter: 87\n", - " hist_stats:\n", - " episode_lengths:\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 18\n", - " - 50\n", - " - 50\n", - " - 41\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 34\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 22\n", - " - 11\n", - " - 10\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 34\n", - " - 50\n", - " - 50\n", - " - 14\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 13\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 45\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 48\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 23\n", - " - 50\n", - " - 50\n", - " - 33\n", - " - 50\n", - " - 50\n", - " - 48\n", - " - 50\n", - " - 8\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 50\n", - " - 34\n", - " - 21\n", - " episode_reward:\n", - " - 62.0\n", - " - 66.0\n", - " - 48.0\n", - " - 105.0\n", - " - 62.0\n", - " - 54.0\n", - " - 78.0\n", - " - 0.0\n", - " - 63.0\n", - " - 86.0\n", - " - 56.0\n", - " - 56.0\n", - " - 57.0\n", - " - 44.0\n", - " - 59.0\n", - " - 83.0\n", - " - 73.0\n", - " - 58.0\n", - " - 0.0\n", - " - 52.0\n", - " - 73.0\n", - " - 82.0\n", - " - 46.0\n", - " - 29.0\n", - " - 71.0\n", - " - 87.0\n", - " - 64.0\n", - " - 45.0\n", - " - 73.0\n", - " - 23.0\n", - " - 47.0\n", - " - 62.0\n", - " - 0.0\n", - " - 0.0\n", - " - 0.0\n", - " - 49.0\n", - " - 30.0\n", - " - 76.0\n", - " - 80.0\n", - " - 49.0\n", - " - 48.0\n", - " - 35.0\n", - " - 68.0\n", - " - 1.0\n", - " - 1.0\n", - " - 40.0\n", - " - 0.0\n", - " - 32.0\n", - " - 86.0\n", - " - 68.0\n", - " - 73.0\n", - " - 56.0\n", - " - 45.0\n", - " - 58.0\n", - " - 49.0\n", - " - 56.0\n", - " - 0.0\n", - " - 36.0\n", - " - 58.0\n", - " - 59.0\n", - " - 41.0\n", - " - 34.0\n", - " - 47.0\n", - " - 26.0\n", - " - 57.0\n", - " - 64.0\n", - " - 67.0\n", - " - 58.0\n", - " - 76.0\n", - " - 35.0\n", - " - 59.0\n", - " - 90.0\n", - " - 84.0\n", - " - 50.0\n", - " - 89.0\n", - " - 71.0\n", - " - 63.0\n", - " - 10.0\n", - " - 57.0\n", - " - 35.0\n", - " - 29.0\n", - " - 67.0\n", - " - 68.0\n", - " - 0.0\n", - " - 74.0\n", - " - 0.0\n", - " - 76.0\n", - " - 94.0\n", - " - 59.0\n", - " - 50.0\n", - " - 88.0\n", - " - 44.0\n", - " - 56.0\n", - " - 61.0\n", - " - 40.0\n", - " - 64.0\n", - " - 75.0\n", - " - 72.0\n", - " - 9.0\n", - " - 2.0\n", - " off_policy_estimator: {}\n", - " policy_reward_max: {}\n", - " policy_reward_mean: {}\n", - " policy_reward_min: {}\n", - " sampler_perf:\n", - " mean_action_processing_ms: 0.015232992197203539\n", - " mean_env_render_ms: 0.0\n", - " mean_env_wait_ms: 0.02046124757879715\n", - " mean_inference_ms: 0.23212124637428544\n", - " mean_raw_obs_processing_ms: 0.03181764830420682\n", - "time_since_restore: 266.8785560131073\n", - "time_this_iter_s: 2.6532857418060303\n", - "time_total_s: 266.8785560131073\n", - "timers:\n", - " learn_throughput: 2774.856\n", - " learn_time_ms: 1441.516\n", - " load_throughput: 22468482.657\n", - " load_time_ms: 0.178\n", - " training_iteration_time_ms: 2665.617\n", - " update_time_ms: 0.753\n", - "timestamp: 1656300963\n", - "timesteps_since_restore: 0\n", - "timesteps_total: 400000\n", - "training_iteration: 100\n", - "trial_id: default\n", - "warmup_time: 1.2377862930297852\n", - "\n" - ] + "data": { + "text/plain": "" + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "from ray.tune.logger import pretty_print\n", - "from ray.rllib.agents.ppo import PPOTrainer\n", - "import ray\n", - "\n", - "# Configure the algorithm.\n", - "config = {\n", - " \"num_workers\": 1,\n", - " \"framework\": \"torch\",\n", - " \"model\": {\n", - " \"fcnet_hiddens\": [64, 64],\n", - " \"fcnet_activation\": \"relu\",\n", - " },\n", - " \"evaluation_num_workers\": 1,\n", - " \"evaluation_config\": {\n", - " \"render_env\": False,\n", - " },\n", - "}\n", + "from stable_baselines3 import PPO\n", "\n", - "env_config = {\n", - " \"model_path\": r\"data/2d_stacked.csv\",\n", - " \"available_pipe\": 50,\n", - " \"delim\": \",\",\n", - "}\n", - "\n", - "config[\"env_config\"] = env_config\n", - "\n", - "try:\n", - " ray.init()\n", - "except RuntimeError:\n", - " ray.shutdown()\n", - " ray.init()\n", - "\n", - "agent = PPOTrainer(config=config, env=SimpleDriller)\n", - "\n", - "for i in range(100):\n", - " # Perform one iteration of training the policy with PPO\n", - " result = agent.train()\n", - "\n", - " if i % 25 == 0:\n", - " checkpoint = agent.save()\n", - " print(\"checkpoint saved at\", checkpoint)\n", - "\n", - "print(pretty_print(result))" + "model = PPO(\"MlpPolicy\", env, verbose=1)\n", + "model.learn(total_timesteps=100_000)" ], "metadata": { "collapsed": false, @@ -585,20 +1264,13 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 46, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2022-06-26 22:36:03,088\tWARNING deprecation.py:46 -- DeprecationWarning: `compute_action` has been deprecated. Use `Trainer.compute_single_action()` instead. This will raise an error in the future!\n" - ] - }, { "name": "stdout", "output_type": "stream", "text": [ - "65.0\n" + "53.0\n" ] } ], @@ -611,7 +1283,7 @@ "done = False\n", "obs = env.reset()\n", "while not done:\n", - " action = agent.compute_action(obs)\n", + " action, _states = model.predict(obs)\n", " obs, reward, done, info = env.step(action)\n", " episode_reward += reward\n", "\n", @@ -627,20 +1299,20 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 47, "outputs": [ { "data": { - "text/plain": "[]" + "text/plain": "[]" }, - "execution_count": 7, + "execution_count": 47, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/plain": "
", - "image/png": "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\n" + "image/png": "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\n" }, "metadata": { "needs_background": "light" diff --git a/poetry.lock b/poetry.lock index 11c29a9..20db3c3 100644 --- a/poetry.lock +++ b/poetry.lock @@ -1,14 +1,3 @@ -[[package]] -name = "aiosignal" -version = "1.2.0" -description = "aiosignal: a list of registered asynchronous callbacks" -category = "main" -optional = false -python-versions = ">=3.6" - -[package.dependencies] -frozenlist = ">=1.1.0" - [[package]] name = "alabaster" version = "0.7.12" @@ -99,7 +88,7 @@ python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" name = "attrs" version = "22.1.0" description = "Classes Without Boilerplate" -category = "main" +category = "dev" optional = false python-versions = ">=3.5" @@ -206,7 +195,7 @@ dev = ["build (==0.8.0)", "flake8 (==4.0.1)", "hashin (==0.17.0)", "pip-tools (= name = "certifi" version = "2022.6.15" description = "Python package for providing Mozilla's CA Bundle." -category = "main" +category = "dev" optional = false python-versions = ">=3.6" @@ -233,7 +222,7 @@ python-versions = ">=3.6.1" name = "charset-normalizer" version = "2.1.0" description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." -category = "main" +category = "dev" optional = false python-versions = ">=3.6.0" @@ -242,11 +231,11 @@ unicode_backport = ["unicodedata2"] [[package]] name = "click" -version = "8.0.4" +version = "8.1.3" description = "Composable command line interface toolkit" category = "main" optional = false -python-versions = ">=3.6" +python-versions = ">=3.7" [package.dependencies] colorama = {version = "*", markers = "platform_system == \"Windows\""} @@ -325,15 +314,7 @@ python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" name = "distlib" version = "0.3.5" description = "Distribution utilities" -category = "main" -optional = false -python-versions = "*" - -[[package]] -name = "dm-tree" -version = "0.1.7" -description = "Tree is a library for working with nested data structures." -category = "main" +category = "dev" optional = false python-versions = "*" @@ -392,7 +373,7 @@ devel = ["colorama", "jsonschema", "json-spec", "pylint", "pytest", "pytest-benc name = "filelock" version = "3.7.1" description = "A platform independent file lock." -category = "main" +category = "dev" optional = false python-versions = ">=3.7" @@ -500,14 +481,6 @@ ufo = ["fs (>=2.2.0,<3)"] unicode = ["unicodedata2 (>=14.0.0)"] woff = ["zopfli (>=0.1.4)", "brotlicffi (>=0.8.0)", "brotli (>=1.0.1)"] -[[package]] -name = "frozenlist" -version = "1.3.1" -description = "A list-like structure which implements collections.abc.MutableSequence" -category = "main" -optional = false -python-versions = ">=3.7" - [[package]] name = "furo" version = "2022.6.21" @@ -544,20 +517,6 @@ python-versions = ">=3.7" [package.dependencies] gitdb = ">=4.0.1,<5" -[[package]] -name = "grpcio" -version = "1.43.0" -description = "HTTP/2-based RPC framework" -category = "main" -optional = false -python-versions = ">=3.6" - -[package.dependencies] -six = ">=1.5.2" - -[package.extras] -protobuf = ["grpcio-tools (>=1.43.0)"] - [[package]] name = "gym" version = "0.21.0" @@ -597,39 +556,10 @@ license = ["ukkonen"] name = "idna" version = "3.3" description = "Internationalized Domain Names in Applications (IDNA)" -category = "main" +category = "dev" optional = false python-versions = ">=3.5" -[[package]] -name = "imageio" -version = "2.21.0" -description = "Library for reading and writing a wide range of image, video, scientific, and volumetric data formats." -category = "main" -optional = false -python-versions = ">=3.7" - -[package.dependencies] -numpy = "*" -pillow = ">=8.3.2" - -[package.extras] -all-plugins = ["astropy", "av", "imageio-ffmpeg", "opencv-python", "psutil", "tifffile"] -all-plugins-pypy = ["av", "imageio-ffmpeg", "psutil", "tifffile"] -build = ["wheel"] -dev = ["invoke", "pytest", "pytest-cov", "fsspec", "black", "flake8"] -docs = ["sphinx", "numpydoc", "pydata-sphinx-theme"] -ffmpeg = ["imageio-ffmpeg", "psutil"] -fits = ["astropy"] -full = ["astropy", "av", "black", "flake8", "fsspec", "gdal", "imageio-ffmpeg", "invoke", "itk", "numpydoc", "opencv-python", "psutil", "pydata-sphinx-theme", "pytest", "pytest-cov", "sphinx", "tifffile", "wheel"] -gdal = ["gdal"] -itk = ["itk"] -linting = ["black", "flake8"] -opencv = ["opencv-python"] -pyav = ["av"] -test = ["invoke", "pytest", "pytest-cov", "fsspec"] -tifffile = ["tifffile"] - [[package]] name = "imagesize" version = "1.4.1" @@ -658,7 +588,7 @@ testing = ["pytest (>=6)", "pytest-checkdocs (>=2.4)", "pytest-flake8", "pytest- name = "importlib-resources" version = "5.9.0" description = "Read resources from Python packages" -category = "main" +category = "dev" optional = false python-versions = ">=3.7" @@ -803,7 +733,7 @@ dev = ["hypothesis"] name = "jsonschema" version = "4.9.1" description = "An implementation of JSON Schema validation for Python" -category = "main" +category = "dev" optional = false python-versions = ">=3.7" @@ -955,19 +885,6 @@ python-versions = "*" six = "*" tornado = {version = "*", markers = "python_version > \"2.7\""} -[[package]] -name = "lz4" -version = "4.0.2" -description = "LZ4 Bindings for Python" -category = "main" -optional = false -python-versions = ">=3.7" - -[package.extras] -docs = ["sphinx (>=1.6.0)", "sphinx-bootstrap-theme"] -flake8 = ["flake8"] -tests = ["pytest (!=3.3.0)", "psutil", "pytest-cov"] - [[package]] name = "markdown-it-py" version = "2.1.0" @@ -1067,14 +984,6 @@ category = "dev" optional = false python-versions = "*" -[[package]] -name = "msgpack" -version = "1.0.4" -description = "MessagePack serializer" -category = "main" -optional = false -python-versions = "*" - [[package]] name = "mypy" version = "0.971" @@ -1232,21 +1141,6 @@ category = "dev" optional = false python-versions = ">=3.5" -[[package]] -name = "networkx" -version = "2.8.5" -description = "Python package for creating and manipulating graphs and networks" -category = "main" -optional = false -python-versions = ">=3.8" - -[package.extras] -default = ["numpy (>=1.19)", "scipy (>=1.8)", "matplotlib (>=3.4)", "pandas (>=1.3)"] -developer = ["pre-commit (>=2.19)", "mypy (>=0.960)"] -doc = ["sphinx (>=5)", "pydata-sphinx-theme (>=0.9)", "sphinx-gallery (>=0.10)", "numpydoc (>=1.4)", "pillow (>=9.1)", "nb2plots (>=0.6)", "texext (>=0.6.6)"] -extra = ["lxml (>=4.6)", "pygraphviz (>=1.9)", "pydot (>=1.4.2)", "sympy (>=1.10)"] -test = ["pytest (>=7.1)", "pytest-cov (>=3.0)", "codecov (>=2.1)"] - [[package]] name = "nodeenv" version = "1.7.0" @@ -1423,7 +1317,7 @@ tests = ["check-manifest", "coverage", "defusedxml", "markdown2", "olefile", "pa name = "pkgutil-resolve-name" version = "1.3.10" description = "Resolve a name to an object." -category = "main" +category = "dev" optional = false python-versions = ">=3.6" @@ -1431,7 +1325,7 @@ python-versions = ">=3.6" name = "platformdirs" version = "2.5.2" description = "A small Python module for determining appropriate platform-specific dirs, e.g. a \"user data dir\"." -category = "main" +category = "dev" optional = false python-versions = ">=3.7" @@ -1501,14 +1395,6 @@ python-versions = ">=3.6.2" [package.dependencies] wcwidth = "*" -[[package]] -name = "protobuf" -version = "3.20.1" -description = "Protocol Buffers" -category = "main" -optional = false -python-versions = ">=3.7" - [[package]] name = "psutil" version = "5.9.1" @@ -1587,10 +1473,10 @@ python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" [[package]] name = "pygame" -version = "2.1.2" +version = "2.1.0" description = "Python Game Development" category = "main" -optional = false +optional = true python-versions = ">=3.6" [[package]] @@ -1605,6 +1491,14 @@ python-versions = ">=3.8" numpy = "*" websockify = "*" +[[package]] +name = "pyglet" +version = "1.5.26" +description = "Cross-platform windowing and multimedia library" +category = "main" +optional = true +python-versions = "*" + [[package]] name = "pygments" version = "2.12.0" @@ -1628,7 +1522,7 @@ diagrams = ["railroad-diagrams", "jinja2"] name = "pyrsistent" version = "0.18.1" description = "Persistent/Functional/Immutable data structures" -category = "main" +category = "dev" optional = false python-versions = ">=3.7" @@ -1683,17 +1577,6 @@ python-versions = ">=3.7" [package.dependencies] tokenize-rt = ">=3.2.0" -[[package]] -name = "pywavelets" -version = "1.3.0" -description = "PyWavelets, wavelet transform module" -category = "main" -optional = false -python-versions = ">=3.7" - -[package.dependencies] -numpy = ">=1.17.3" - [[package]] name = "pywin32" version = "304" @@ -1714,7 +1597,7 @@ python-versions = ">=3.7" name = "pyyaml" version = "6.0" description = "YAML parser and emitter for Python" -category = "main" +category = "dev" optional = false python-versions = ">=3.6" @@ -1730,57 +1613,11 @@ python-versions = ">=3.6" cffi = {version = "*", markers = "implementation_name == \"pypy\""} py = {version = "*", markers = "implementation_name == \"pypy\""} -[[package]] -name = "ray" -version = "1.13.0" -description = "Ray provides a simple, universal API for building distributed applications." -category = "main" -optional = false -python-versions = "*" - -[package.dependencies] -aiosignal = "*" -attrs = "*" -click = ">=7.0,<=8.0.4" -dm-tree = {version = "*", optional = true, markers = "extra == \"rllib\""} -filelock = "*" -frozenlist = "*" -grpcio = ">=1.28.1,<=1.43.0" -gym = {version = "<0.22", optional = true, markers = "extra == \"rllib\""} -jsonschema = "*" -lz4 = {version = "*", optional = true, markers = "extra == \"rllib\""} -matplotlib = {version = "!=3.4.3", optional = true, markers = "extra == \"rllib\""} -msgpack = ">=1.0.0,<2.0.0" -numpy = [ - {version = ">=1.16", markers = "python_version < \"3.9\""}, - {version = ">=1.19.3", markers = "python_version >= \"3.9\""}, -] -pandas = {version = "*", optional = true, markers = "extra == \"rllib\""} -protobuf = ">=3.15.3,<4.0.0" -pyyaml = "*" -requests = "*" -scikit-image = {version = "*", optional = true, markers = "extra == \"rllib\""} -scipy = {version = "*", optional = true, markers = "extra == \"rllib\""} -tabulate = {version = "*", optional = true, markers = "extra == \"rllib\""} -tensorboardX = {version = ">=1.9", optional = true, markers = "extra == \"rllib\""} -virtualenv = "*" - -[package.extras] -all = ["aiohttp-cors", "opentelemetry-api (==1.1.0)", "scikit-image", "pyyaml", "aiorwlock", "kubernetes", "requests", "fastapi", "kopf", "dm-tree", "ray-cpp (==1.13.0)", "tensorboardX (>=1.9)", "prometheus-client (>=0.7.1,<0.14.0)", "pyarrow (>=6.0.1,<7.0.0)", "colorful", "starlette", "opentelemetry-sdk (==1.1.0)", "py-spy (>=0.2.0)", "scipy", "lz4", "aiohttp (>=3.7)", "smart-open", "tabulate", "gpustat (>=1.0.0b1)", "gym (<0.22)", "opentelemetry-exporter-otlp (==1.1.0)", "fsspec", "opencensus", "urllib3", "numpy (>=1.20)", "pandas", "uvicorn (==0.16.0)", "matplotlib (!=3.4.3)"] -cpp = ["ray-cpp (==1.13.0)"] -data = ["pandas", "pyarrow (>=6.0.1,<7.0.0)", "fsspec", "numpy (>=1.20)"] -default = ["aiohttp (>=3.7)", "aiohttp-cors", "colorful", "py-spy (>=0.2.0)", "requests", "gpustat (>=1.0.0b1)", "opencensus", "prometheus-client (>=0.7.1,<0.14.0)", "smart-open"] -k8s = ["kubernetes", "urllib3", "kopf"] -observability = ["opentelemetry-api (==1.1.0)", "opentelemetry-sdk (==1.1.0)", "opentelemetry-exporter-otlp (==1.1.0)"] -rllib = ["pandas", "tabulate", "tensorboardX (>=1.9)", "requests", "dm-tree", "gym (<0.22)", "lz4", "matplotlib (!=3.4.3)", "scikit-image", "pyyaml", "scipy"] -serve = ["opencensus", "aiohttp-cors", "prometheus-client (>=0.7.1,<0.14.0)", "aiohttp (>=3.7)", "aiorwlock", "colorful", "uvicorn (==0.16.0)", "requests", "fastapi", "starlette", "smart-open", "py-spy (>=0.2.0)", "gpustat (>=1.0.0b1)"] -tune = ["pandas", "tabulate", "tensorboardX (>=1.9)", "requests"] - [[package]] name = "requests" version = "2.28.1" description = "Python HTTP for Humans." -category = "main" +category = "dev" optional = false python-versions = ">=3.7, <4" @@ -1844,41 +1681,6 @@ requests = "*" "ruamel.yaml" = ">=0.17.21" setuptools = ">=19.3" -[[package]] -name = "scikit-image" -version = "0.19.3" -description = "Image processing in Python" -category = "main" -optional = false -python-versions = ">=3.7" - -[package.dependencies] -imageio = ">=2.4.1" -networkx = ">=2.2" -numpy = ">=1.17.0" -packaging = ">=20.0" -pillow = ">=6.1.0,<7.1.0 || >7.1.0,<7.1.1 || >7.1.1,<8.3.0 || >8.3.0" -PyWavelets = ">=1.1.1" -scipy = ">=1.4.1" -tifffile = ">=2019.7.26" - -[package.extras] -data = ["pooch (>=1.3.0)"] -docs = ["sphinx (>=1.8)", "sphinx-gallery (>=0.10.1)", "numpydoc (>=1.0)", "sphinx-copybutton", "pytest-runner", "scikit-learn", "matplotlib (>=3.3)", "dask[array] (>=0.15.0,!=2.17.0)", "cloudpickle (>=0.2.1)", "pandas (>=0.23.0)", "seaborn (>=0.7.1)", "pooch (>=1.3.0)", "tifffile (>=2020.5.30)", "myst-parser", "ipywidgets", "plotly (>=4.14.0)", "kaleido"] -optional = ["simpleitk", "astropy (>=3.1.2)", "cloudpickle (>=0.2.1)", "dask[array] (>=1.0.0,!=2.17.0)", "matplotlib (>=3.0.3)", "pooch (>=1.3.0)", "pyamg", "qtpy"] -test = ["asv", "codecov", "flake8", "matplotlib (>=3.0.3)", "pooch (>=1.3.0)", "pytest (>=5.2.0)", "pytest-cov (>=2.7.0)", "pytest-localserver", "pytest-faulthandler"] - -[[package]] -name = "scipy" -version = "1.9.0" -description = "SciPy: Scientific Library for Python" -category = "main" -optional = false -python-versions = ">=3.8,<3.12" - -[package.dependencies] -numpy = ">=1.18.5,<1.25.0" - [[package]] name = "send2trash" version = "1.8.0" @@ -2109,6 +1911,27 @@ python-versions = ">=3.5" lint = ["flake8", "mypy", "docutils-stubs"] test = ["pytest"] +[[package]] +name = "stable-baselines3" +version = "1.6.0" +description = "Pytorch version of Stable Baselines, implementations of reinforcement learning algorithms." +category = "main" +optional = false +python-versions = ">=3.7" + +[package.dependencies] +cloudpickle = "*" +gym = "0.21" +matplotlib = "*" +numpy = "*" +pandas = "*" +torch = ">=1.11" + +[package.extras] +tests = ["scipy (>=1.4.1)", "black", "isort (>=5.0)", "flake8-bugbear", "flake8 (>=3.8)", "pytype", "pytest-xdist", "pytest-env", "pytest-cov", "pytest"] +extra = ["psutil", "protobuf (>=3.19.0,<3.20.0)", "tensorboard (>=2.2.0)", "pillow", "autorom[accept-rom-license] (>=0.4.2,<0.5.0)", "ale-py (==0.7.4)", "opencv-python"] +docs = ["sphinx-copybutton", "sphinx-autodoc-typehints", "sphinxcontrib-spelling", "sphinx-rtd-theme", "sphinx-autobuild", "sphinx"] + [[package]] name = "stack-data" version = "0.3.0" @@ -2136,29 +1959,6 @@ python-versions = ">=3.8" [package.dependencies] pbr = ">=2.0.0,<2.1.0 || >2.1.0" -[[package]] -name = "tabulate" -version = "0.8.10" -description = "Pretty-print tabular data" -category = "main" -optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" - -[package.extras] -widechars = ["wcwidth"] - -[[package]] -name = "tensorboardx" -version = "2.5.1" -description = "TensorBoardX lets you watch Tensors Flow without Tensorflow" -category = "main" -optional = false -python-versions = "*" - -[package.dependencies] -numpy = "*" -protobuf = ">=3.8.0,<=3.20.1" - [[package]] name = "terminado" version = "0.15.0" @@ -2175,20 +1975,6 @@ tornado = ">=6.1.0" [package.extras] test = ["pre-commit", "pytest-timeout", "pytest (>=6.0)"] -[[package]] -name = "tifffile" -version = "2022.8.3" -description = "Read and write TIFF files" -category = "main" -optional = false -python-versions = ">=3.8" - -[package.dependencies] -numpy = ">=1.19.2" - -[package.extras] -all = ["imagecodecs (>=2022.2.22)", "matplotlib (>=3.3)", "lxml"] - [[package]] name = "tinycss2" version = "1.1.1" @@ -2282,7 +2068,7 @@ python-versions = ">=3.7" name = "urllib3" version = "1.26.11" description = "HTTP library with thread-safe connection pooling, file post, and more." -category = "main" +category = "dev" optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, <4" @@ -2295,7 +2081,7 @@ socks = ["PySocks (>=1.5.6,!=1.5.7,<2.0)"] name = "virtualenv" version = "20.16.3" description = "Virtual Python Environment builder" -category = "main" +category = "dev" optional = false python-versions = ">=3.6" @@ -2376,7 +2162,7 @@ all-strict = ["ipykernel (==6.0.0)", "IPython (==7.23.1)", "jupyter-client (==7. name = "zipp" version = "3.8.1" description = "Backport of pathlib-compatible object wrapper for zip files" -category = "main" +category = "dev" optional = false python-versions = ">=3.7" @@ -2384,16 +2170,15 @@ python-versions = ">=3.7" docs = ["sphinx", "jaraco.packaging (>=9)", "rst.linker (>=1.9)", "jaraco.tidelift (>=1.4)"] testing = ["pytest (>=6)", "pytest-checkdocs (>=2.4)", "pytest-flake8", "pytest-cov", "pytest-enabler (>=1.3)", "jaraco-itertools", "func-timeout", "pytest-black (>=0.3.7)", "pytest-mypy (>=0.9.1)"] +[extras] +hello_world = ["pygame", "pyglet"] + [metadata] lock-version = "1.1" python-versions = ">=3.8 <3.10" -content-hash = "3651c8bf4539172cff26552221604cf8b982ce3f76147e650b045d62b4cbd275" +content-hash = "56cab032a57860cd176950971e248c5b2e05ba45d9a2098d0618e8da4c34e877" [metadata.files] -aiosignal = [ - {file = "aiosignal-1.2.0-py3-none-any.whl", hash = "sha256:26e62109036cd181df6e6ad646f91f0dcfd05fe16d0cb924138ff2ab75d64e3a"}, - {file = "aiosignal-1.2.0.tar.gz", hash = "sha256:78ed67db6c7b7ced4f98e495e572106d5c432a93e1ddd1bf475e1dc05f5b7df2"}, -] alabaster = [ {file = "alabaster-0.7.12-py2.py3-none-any.whl", hash = "sha256:446438bdcca0e05bd45ea2de1668c1d9b032e1a9154c2c259092d77031ddd359"}, {file = "alabaster-0.7.12.tar.gz", hash = "sha256:a661d72d58e6ea8a57f7a86e37d86716863ee5e92788398526d58b26a4e4dc02"}, @@ -2553,10 +2338,7 @@ charset-normalizer = [ {file = "charset-normalizer-2.1.0.tar.gz", hash = "sha256:575e708016ff3a5e3681541cb9d79312c416835686d054a23accb873b254f413"}, {file = "charset_normalizer-2.1.0-py3-none-any.whl", hash = "sha256:5189b6f22b01957427f35b6a08d9a0bc45b46d3788ef5a92e978433c7a35f8a5"}, ] -click = [ - {file = "click-8.0.4-py3-none-any.whl", hash = "sha256:6a7a62563bbfabfda3a38f3023a1db4a35978c0abd76f6c9605ecd6554d6d9b1"}, - {file = "click-8.0.4.tar.gz", hash = "sha256:8458d7b1287c5fb128c90e23381cf99dcde74beaf6c7ff6384ce84d6fe090adb"}, -] +click = [] cloudpickle = [ {file = "cloudpickle-2.1.0-py3-none-any.whl", hash = "sha256:b5c434f75c34624eedad3a14f2be5ac3b5384774d5b0e3caf905c21479e6c4b1"}, {file = "cloudpickle-2.1.0.tar.gz", hash = "sha256:bb233e876a58491d9590a676f93c7a5473a08f747d5ab9df7f9ce564b3e7938e"}, @@ -2581,30 +2363,6 @@ defusedxml = [ {file = "defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69"}, ] distlib = [] -dm-tree = [ - {file = "dm-tree-0.1.7.tar.gz", hash = "sha256:30fec8aca5b92823c0e796a2f33b875b4dccd470b57e91e6c542405c5f77fd2a"}, - {file = "dm_tree-0.1.7-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:3fae437135b6cbbdd51e96488a35e78c3617defa0b65265e7e8752d506f933fd"}, - {file = "dm_tree-0.1.7-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d377bd621b485db42c4aeea0eabbd8f6274b89a9c338c2c1bf69a40c3b86a1fd"}, - {file = "dm_tree-0.1.7-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1410fa2f2cc8dc7c01386f4e93ddeeb56765574ffafb632a9b6bd96496195b10"}, - {file = "dm_tree-0.1.7-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:57edb6fbd88fcdd9908547cbf21045a9d663c0d9e5983dca7e6f9cf8b6584bb5"}, - {file = "dm_tree-0.1.7-cp310-cp310-win_amd64.whl", hash = "sha256:9edc1783a08d87c4e130781f55cbd904d6a564f7cce7dfb63f9ef3bee8e38209"}, - {file = "dm_tree-0.1.7-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:98fce150ceebb0a818f0eace1616004031cfa5e3375f50599ad790ff52414ba9"}, - {file = "dm_tree-0.1.7-cp36-cp36m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:b4364fc9a5721a2b840ac8ea75b8f58b430bec9fdc8b99304d2aecb3cfe46b1b"}, - {file = "dm_tree-0.1.7-cp36-cp36m-win_amd64.whl", hash = "sha256:a085f500b295a6bf439c538e9058c7798ecb8c7d0dc916291f3d8d79d6124d17"}, - {file = "dm_tree-0.1.7-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:f3e2bd9b9c05d1a0039f7c128d8b055c8a05708ef569cdbbeec0a2946e425bd4"}, - {file = "dm_tree-0.1.7-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:91c6240e47c9d80dbd7de5a29a2ca663143717a72c613130ba8ac4354fa741a9"}, - {file = "dm_tree-0.1.7-cp37-cp37m-win_amd64.whl", hash = "sha256:0f01743cc2247170e64798c6b4b31853717054bf9ceec47a1b1b8c2a4baf5792"}, - {file = "dm_tree-0.1.7-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:4992ac5c42af1d73042cd2d3af4e7892d3750e6c1bb8e5a4f81534aa6515f350"}, - {file = "dm_tree-0.1.7-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:20f24cad4decbf4c1f176a959d16e877c73df33b07d7d1f078a5b8abe72f79f8"}, - {file = "dm_tree-0.1.7-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:3166304411d14c50a5da1c583e24d6069b44de0c9e06479cb36cdf048a466945"}, - {file = "dm_tree-0.1.7-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:3b00885c21267934a3d3c68660811d3f891c9539fd53712f5b2423c6d74bf1e6"}, - {file = "dm_tree-0.1.7-cp38-cp38-win_amd64.whl", hash = "sha256:7f1f3dca9d669f3c09654ff6d69cfafd86a7f967c3095405b2692ee8d8ef3cfd"}, - {file = "dm_tree-0.1.7-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:51b9bdf1109b47cc22884b1919e6fe38edf28b5aa02e7c661bb760a0e7cf0157"}, - {file = "dm_tree-0.1.7-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:2a843608e078d1622ebb5e50962a8c718d3fa1ab9461b95a12395a803545b2f5"}, - {file = "dm_tree-0.1.7-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:7fa0740b7fbae2c3a43a3114a514891b5d6c383050828f36aa1816cf40f73a6a"}, - {file = "dm_tree-0.1.7-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:1379a02df36e2bbff9819ceafa55ccd436b15af398803f781f372f8ead7ed871"}, - {file = "dm_tree-0.1.7-cp39-cp39-win_amd64.whl", hash = "sha256:3ca0a58e219b7b0bc201fea4679971188d0a9028a2543c16803a84e8f8c7eb2c"}, -] docutils = [ {file = "docutils-0.18.1-py2.py3-none-any.whl", hash = "sha256:23010f129180089fbcd3bc08cfefccb3b890b0050e1ca00c867036e9d161b98c"}, {file = "docutils-0.18.1.tar.gz", hash = "sha256:679987caf361a7539d76e584cbeddc311e3aee937877c87346f31debc63e9d06"}, @@ -2642,7 +2400,6 @@ flake8-polyfill = [ ] flake8-rst-docstrings = [] fonttools = [] -frozenlist = [] furo = [ {file = "furo-2022.6.21-py3-none-any.whl", hash = "sha256:061b68e323345e27fcba024cf33a1e77f3dfd8d9987410be822749a706e2add6"}, {file = "furo-2022.6.21.tar.gz", hash = "sha256:9aa983b7488a4601d13113884bfb7254502c8729942e073a0acb87a5512af223"}, @@ -2652,52 +2409,6 @@ gitdb = [ {file = "gitdb-4.0.9.tar.gz", hash = "sha256:bac2fd45c0a1c9cf619e63a90d62bdc63892ef92387424b855792a6cabe789aa"}, ] gitpython = [] -grpcio = [ - {file = "grpcio-1.43.0-cp310-cp310-linux_armv7l.whl", hash = "sha256:a4e786a8ee8b30b25d70ee52cda6d1dbba2a8ca2f1208d8e20ed8280774f15c8"}, - {file = "grpcio-1.43.0-cp310-cp310-macosx_10_10_universal2.whl", hash = "sha256:af9c3742f6c13575c0d4147a8454da0ff5308c4d9469462ff18402c6416942fe"}, - {file = "grpcio-1.43.0-cp310-cp310-manylinux_2_17_aarch64.whl", hash = "sha256:fdac966699707b5554b815acc272d81e619dd0999f187cd52a61aef075f870ee"}, - {file = "grpcio-1.43.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6e463b4aa0a6b31cf2e57c4abc1a1b53531a18a570baeed39d8d7b65deb16b7e"}, - {file = "grpcio-1.43.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f11d05402e0ac3a284443d8a432d3dfc76a6bd3f7b5858cddd75617af2d7bd9b"}, - {file = "grpcio-1.43.0-cp310-cp310-win32.whl", hash = "sha256:c36f418c925a41fccada8f7ae9a3d3e227bfa837ddbfddd3d8b0ac252d12dda9"}, - {file = "grpcio-1.43.0-cp310-cp310-win_amd64.whl", hash = "sha256:772b943f34374744f70236bbbe0afe413ed80f9ae6303503f85e2b421d4bca92"}, - {file = "grpcio-1.43.0-cp36-cp36m-linux_armv7l.whl", hash = "sha256:cbc9b83211d905859dcf234ad39d7193ff0f05bfc3269c364fb0d114ee71de59"}, - {file = "grpcio-1.43.0-cp36-cp36m-macosx_10_10_x86_64.whl", hash = "sha256:fb7229fa2a201a0c377ff3283174ec966da8f9fd7ffcc9a92f162d2e7fc9025b"}, - {file = "grpcio-1.43.0-cp36-cp36m-manylinux2010_i686.whl", hash = "sha256:17b75f220ee6923338155b4fcef4c38802b9a57bc57d112c9599a13a03e99f8d"}, - {file = "grpcio-1.43.0-cp36-cp36m-manylinux2010_x86_64.whl", hash = "sha256:6620a5b751b099b3b25553cfc03dfcd873cda06f9bb2ff7e9948ac7090e20f05"}, - {file = "grpcio-1.43.0-cp36-cp36m-manylinux_2_17_aarch64.whl", hash = "sha256:1898f999383baac5fcdbdef8ea5b1ef204f38dc211014eb6977ac6e55944d738"}, - {file = "grpcio-1.43.0-cp36-cp36m-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:47b6821238d8978014d23b1132713dac6c2d72cbb561cf257608b1673894f90a"}, - {file = "grpcio-1.43.0-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80398e9fb598060fa41050d1220f5a2440fe74ff082c36dda41ac3215ebb5ddd"}, - {file = "grpcio-1.43.0-cp36-cp36m-win32.whl", hash = "sha256:0110310eff07bb69782f53b7a947490268c4645de559034c43c0a635612e250f"}, - {file = "grpcio-1.43.0-cp36-cp36m-win_amd64.whl", hash = "sha256:45401d00f2ee46bde75618bf33e9df960daa7980e6e0e7328047191918c98504"}, - {file = "grpcio-1.43.0-cp37-cp37m-linux_armv7l.whl", hash = "sha256:af78ac55933811e6a25141336b1f2d5e0659c2f568d44d20539b273792563ca7"}, - {file = "grpcio-1.43.0-cp37-cp37m-macosx_10_10_x86_64.whl", hash = "sha256:8b2b9dc4d7897566723b77422e11c009a0ebd397966b165b21b89a62891a9fdf"}, - {file = "grpcio-1.43.0-cp37-cp37m-manylinux2010_i686.whl", hash = "sha256:77ef653f966934b3bfdd00e4f2064b68880eb40cf09b0b99edfa5ee22a44f559"}, - {file = "grpcio-1.43.0-cp37-cp37m-manylinux2010_x86_64.whl", hash = "sha256:e95b5d62ec26d0cd0b90c202d73e7cb927c369c3358e027225239a4e354967dc"}, - {file = "grpcio-1.43.0-cp37-cp37m-manylinux_2_17_aarch64.whl", hash = "sha256:04239e8f71db832c26bbbedb4537b37550a39d77681d748ab4678e58dd6455d6"}, - {file = "grpcio-1.43.0-cp37-cp37m-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4b4a7152187a49767a47d1413edde2304c96f41f7bc92cc512e230dfd0fba095"}, - {file = "grpcio-1.43.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b8cc936a29c65ab39714e1ba67a694c41218f98b6e2a64efb83f04d9abc4386b"}, - {file = "grpcio-1.43.0-cp37-cp37m-win32.whl", hash = "sha256:577e024c8dd5f27cd98ba850bc4e890f07d4b5942e5bc059a3d88843a2f48f66"}, - {file = "grpcio-1.43.0-cp37-cp37m-win_amd64.whl", hash = "sha256:138f57e3445d4a48d9a8a5af1538fdaafaa50a0a3c243f281d8df0edf221dc02"}, - {file = "grpcio-1.43.0-cp38-cp38-linux_armv7l.whl", hash = "sha256:08cf25f2936629db062aeddbb594bd76b3383ab0ede75ef0461a3b0bc3a2c150"}, - {file = "grpcio-1.43.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:01f4b887ed703fe82ebe613e1d2dadea517891725e17e7a6134dcd00352bd28c"}, - {file = "grpcio-1.43.0-cp38-cp38-manylinux2010_i686.whl", hash = "sha256:0aa8285f284338eb68962fe1a830291db06f366ea12f213399b520c062b01f65"}, - {file = "grpcio-1.43.0-cp38-cp38-manylinux2010_x86_64.whl", hash = "sha256:0edbfeb6729aa9da33ce7e28fb7703b3754934115454ae45e8cc1db601756fd3"}, - {file = "grpcio-1.43.0-cp38-cp38-manylinux_2_17_aarch64.whl", hash = "sha256:c354017819201053d65212befd1dcb65c2d91b704d8977e696bae79c47cd2f82"}, - {file = "grpcio-1.43.0-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:50cfb7e1067ee5e00b8ab100a6b7ea322d37ec6672c0455106520b5891c4b5f5"}, - {file = "grpcio-1.43.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:57f1aeb65ed17dfb2f6cd717cc109910fe395133af7257a9c729c0b9604eac10"}, - {file = "grpcio-1.43.0-cp38-cp38-win32.whl", hash = "sha256:fa26a8bbb3fe57845acb1329ff700d5c7eaf06414c3e15f4cb8923f3a466ef64"}, - {file = "grpcio-1.43.0-cp38-cp38-win_amd64.whl", hash = "sha256:ade8b79a6b6aea68adb9d4bfeba5d647667d842202c5d8f3ba37ac1dc8e5c09c"}, - {file = "grpcio-1.43.0-cp39-cp39-linux_armv7l.whl", hash = "sha256:124e718faf96fe44c98b05f3f475076be8b5198bb4c52a13208acf88a8548ba9"}, - {file = "grpcio-1.43.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:2f96142d0abc91290a63ba203f01649e498302b1b6007c67bad17f823ecde0cf"}, - {file = "grpcio-1.43.0-cp39-cp39-manylinux2010_i686.whl", hash = "sha256:31e6e489ccd8f08884b9349a39610982df48535881ec34f05a11c6e6b6ebf9d0"}, - {file = "grpcio-1.43.0-cp39-cp39-manylinux2010_x86_64.whl", hash = "sha256:0e731f660e1e68238f56f4ce11156f02fd06dc58bc7834778d42c0081d4ef5ad"}, - {file = "grpcio-1.43.0-cp39-cp39-manylinux_2_17_aarch64.whl", hash = "sha256:1f16725a320460435a8a5339d8b06c4e00d307ab5ad56746af2e22b5f9c50932"}, - {file = "grpcio-1.43.0-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a4b4543e13acb4806917d883d0f70f21ba93b29672ea81f4aaba14821aaf9bb0"}, - {file = "grpcio-1.43.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:594aaa0469f4fca7773e80d8c27bf1298e7bbce5f6da0f084b07489a708f16ab"}, - {file = "grpcio-1.43.0-cp39-cp39-win32.whl", hash = "sha256:5449ae564349e7a738b8c38583c0aad954b0d5d1dd3cea68953bfc32eaee11e3"}, - {file = "grpcio-1.43.0-cp39-cp39-win_amd64.whl", hash = "sha256:bdf41550815a831384d21a498b20597417fd31bd084deb17d31ceb39ad9acc79"}, - {file = "grpcio-1.43.0.tar.gz", hash = "sha256:735d9a437c262ab039d02defddcb9f8f545d7009ae61c0114e19dda3843febe5"}, -] gym = [ {file = "gym-0.21.0.tar.gz", hash = "sha256:0fd1ce165c754b4017e37a617b097c032b8c3feb8a0394ccc8777c7c50dddff3"}, ] @@ -2706,7 +2417,6 @@ idna = [ {file = "idna-3.3-py3-none-any.whl", hash = "sha256:84d9dd047ffa80596e0f246e2eab0b391788b0503584e8945f2368256d2735ff"}, {file = "idna-3.3.tar.gz", hash = "sha256:9d643ff0a55b762d5cdb124b8eaa99c66322e2157b69160bc32796e824360e6d"}, ] -imageio = [] imagesize = [ {file = "imagesize-1.4.1-py2.py3-none-any.whl", hash = "sha256:0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b"}, {file = "imagesize-1.4.1.tar.gz", hash = "sha256:69150444affb9cb0d5cc5a92b3676f0b2fb7cd9ae39e947a5e11a36b4497cd4a"}, @@ -2757,7 +2467,6 @@ jupyterlab-server = [ ] kiwisolver = [] livereload = [] -lz4 = [] markdown-it-py = [ {file = "markdown-it-py-2.1.0.tar.gz", hash = "sha256:cf7e59fed14b5ae17c0006eff14a2d9a00ed5f3a846148153899a0224e2c07da"}, {file = "markdown_it_py-2.1.0-py3-none-any.whl", hash = "sha256:93de681e5c021a432c63147656fe21790bc01231e0cd2da73626f1aa3ac0fe27"}, @@ -2858,60 +2567,6 @@ mistune = [ {file = "mistune-0.8.4-py2.py3-none-any.whl", hash = "sha256:88a1051873018da288eee8538d476dffe1262495144b33ecb586c4ab266bb8d4"}, {file = "mistune-0.8.4.tar.gz", hash = "sha256:59a3429db53c50b5c6bcc8a07f8848cb00d7dc8bdb431a4ab41920d201d4756e"}, ] -msgpack = [ - {file = "msgpack-1.0.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:4ab251d229d10498e9a2f3b1e68ef64cb393394ec477e3370c457f9430ce9250"}, - {file = "msgpack-1.0.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:112b0f93202d7c0fef0b7810d465fde23c746a2d482e1e2de2aafd2ce1492c88"}, - {file = "msgpack-1.0.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:002b5c72b6cd9b4bafd790f364b8480e859b4712e91f43014fe01e4f957b8467"}, - {file = "msgpack-1.0.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:35bc0faa494b0f1d851fd29129b2575b2e26d41d177caacd4206d81502d4c6a6"}, - {file = "msgpack-1.0.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4733359808c56d5d7756628736061c432ded018e7a1dff2d35a02439043321aa"}, - {file = "msgpack-1.0.4-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eb514ad14edf07a1dbe63761fd30f89ae79b42625731e1ccf5e1f1092950eaa6"}, - {file = "msgpack-1.0.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:c23080fdeec4716aede32b4e0ef7e213c7b1093eede9ee010949f2a418ced6ba"}, - {file = "msgpack-1.0.4-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:49565b0e3d7896d9ea71d9095df15b7f75a035c49be733051c34762ca95bbf7e"}, - {file = "msgpack-1.0.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:aca0f1644d6b5a73eb3e74d4d64d5d8c6c3d577e753a04c9e9c87d07692c58db"}, - {file = "msgpack-1.0.4-cp310-cp310-win32.whl", hash = "sha256:0dfe3947db5fb9ce52aaea6ca28112a170db9eae75adf9339a1aec434dc954ef"}, - {file = "msgpack-1.0.4-cp310-cp310-win_amd64.whl", hash = "sha256:4dea20515f660aa6b7e964433b1808d098dcfcabbebeaaad240d11f909298075"}, - {file = "msgpack-1.0.4-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:e83f80a7fec1a62cf4e6c9a660e39c7f878f603737a0cdac8c13131d11d97f52"}, - {file = "msgpack-1.0.4-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3c11a48cf5e59026ad7cb0dc29e29a01b5a66a3e333dc11c04f7e991fc5510a9"}, - {file = "msgpack-1.0.4-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1276e8f34e139aeff1c77a3cefb295598b504ac5314d32c8c3d54d24fadb94c9"}, - {file = "msgpack-1.0.4-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6c9566f2c39ccced0a38d37c26cc3570983b97833c365a6044edef3574a00c08"}, - {file = "msgpack-1.0.4-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:fcb8a47f43acc113e24e910399376f7277cf8508b27e5b88499f053de6b115a8"}, - {file = "msgpack-1.0.4-cp36-cp36m-musllinux_1_1_i686.whl", hash = "sha256:76ee788122de3a68a02ed6f3a16bbcd97bc7c2e39bd4d94be2f1821e7c4a64e6"}, - {file = "msgpack-1.0.4-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:0a68d3ac0104e2d3510de90a1091720157c319ceeb90d74f7b5295a6bee51bae"}, - {file = "msgpack-1.0.4-cp36-cp36m-win32.whl", hash = "sha256:85f279d88d8e833ec015650fd15ae5eddce0791e1e8a59165318f371158efec6"}, - {file = "msgpack-1.0.4-cp36-cp36m-win_amd64.whl", hash = "sha256:c1683841cd4fa45ac427c18854c3ec3cd9b681694caf5bff04edb9387602d661"}, - {file = "msgpack-1.0.4-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:a75dfb03f8b06f4ab093dafe3ddcc2d633259e6c3f74bb1b01996f5d8aa5868c"}, - {file = "msgpack-1.0.4-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9667bdfdf523c40d2511f0e98a6c9d3603be6b371ae9a238b7ef2dc4e7a427b0"}, - {file = "msgpack-1.0.4-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:11184bc7e56fd74c00ead4f9cc9a3091d62ecb96e97653add7a879a14b003227"}, - {file = "msgpack-1.0.4-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ac5bd7901487c4a1dd51a8c58f2632b15d838d07ceedaa5e4c080f7190925bff"}, - {file = "msgpack-1.0.4-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:1e91d641d2bfe91ba4c52039adc5bccf27c335356055825c7f88742c8bb900dd"}, - {file = "msgpack-1.0.4-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:2a2df1b55a78eb5f5b7d2a4bb221cd8363913830145fad05374a80bf0877cb1e"}, - {file = "msgpack-1.0.4-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:545e3cf0cf74f3e48b470f68ed19551ae6f9722814ea969305794645da091236"}, - {file = "msgpack-1.0.4-cp37-cp37m-win32.whl", hash = "sha256:2cc5ca2712ac0003bcb625c96368fd08a0f86bbc1a5578802512d87bc592fe44"}, - {file = "msgpack-1.0.4-cp37-cp37m-win_amd64.whl", hash = "sha256:eba96145051ccec0ec86611fe9cf693ce55f2a3ce89c06ed307de0e085730ec1"}, - {file = "msgpack-1.0.4-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:7760f85956c415578c17edb39eed99f9181a48375b0d4a94076d84148cf67b2d"}, - {file = "msgpack-1.0.4-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:449e57cc1ff18d3b444eb554e44613cffcccb32805d16726a5494038c3b93dab"}, - {file = "msgpack-1.0.4-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:d603de2b8d2ea3f3bcb2efe286849aa7a81531abc52d8454da12f46235092bcb"}, - {file = "msgpack-1.0.4-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:48f5d88c99f64c456413d74a975bd605a9b0526293218a3b77220a2c15458ba9"}, - {file = "msgpack-1.0.4-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6916c78f33602ecf0509cc40379271ba0f9ab572b066bd4bdafd7434dee4bc6e"}, - {file = "msgpack-1.0.4-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:81fc7ba725464651190b196f3cd848e8553d4d510114a954681fd0b9c479d7e1"}, - {file = "msgpack-1.0.4-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:d5b5b962221fa2c5d3a7f8133f9abffc114fe218eb4365e40f17732ade576c8e"}, - {file = "msgpack-1.0.4-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:77ccd2af37f3db0ea59fb280fa2165bf1b096510ba9fe0cc2bf8fa92a22fdb43"}, - {file = "msgpack-1.0.4-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:b17be2478b622939e39b816e0aa8242611cc8d3583d1cd8ec31b249f04623243"}, - {file = "msgpack-1.0.4-cp38-cp38-win32.whl", hash = "sha256:2bb8cdf50dd623392fa75525cce44a65a12a00c98e1e37bf0fb08ddce2ff60d2"}, - {file = "msgpack-1.0.4-cp38-cp38-win_amd64.whl", hash = "sha256:26b8feaca40a90cbe031b03d82b2898bf560027160d3eae1423f4a67654ec5d6"}, - {file = "msgpack-1.0.4-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:462497af5fd4e0edbb1559c352ad84f6c577ffbbb708566a0abaaa84acd9f3ae"}, - {file = "msgpack-1.0.4-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:2999623886c5c02deefe156e8f869c3b0aaeba14bfc50aa2486a0415178fce55"}, - {file = "msgpack-1.0.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f0029245c51fd9473dc1aede1160b0a29f4a912e6b1dd353fa6d317085b219da"}, - {file = "msgpack-1.0.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ed6f7b854a823ea44cf94919ba3f727e230da29feb4a99711433f25800cf747f"}, - {file = "msgpack-1.0.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0df96d6eaf45ceca04b3f3b4b111b86b33785683d682c655063ef8057d61fd92"}, - {file = "msgpack-1.0.4-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6a4192b1ab40f8dca3f2877b70e63799d95c62c068c84dc028b40a6cb03ccd0f"}, - {file = "msgpack-1.0.4-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:0e3590f9fb9f7fbc36df366267870e77269c03172d086fa76bb4eba8b2b46624"}, - {file = "msgpack-1.0.4-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:1576bd97527a93c44fa856770197dec00d223b0b9f36ef03f65bac60197cedf8"}, - {file = "msgpack-1.0.4-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:63e29d6e8c9ca22b21846234913c3466b7e4ee6e422f205a2988083de3b08cae"}, - {file = "msgpack-1.0.4-cp39-cp39-win32.whl", hash = "sha256:fb62ea4b62bfcb0b380d5680f9a4b3f9a2d166d9394e9bbd9666c0ee09a3645c"}, - {file = "msgpack-1.0.4-cp39-cp39-win_amd64.whl", hash = "sha256:4d5834a2a48965a349da1c5a79760d94a1a0172fbb5ab6b5b33cbf8447e109ce"}, - {file = "msgpack-1.0.4.tar.gz", hash = "sha256:f5d869c18f030202eb412f08b28d2afeea553d6613aee89e200d7aca7ef01f5f"}, -] mypy = [] mypy-extensions = [ {file = "mypy_extensions-0.4.3-py2.py3-none-any.whl", hash = "sha256:090fedd75945a69ae91ce1303b5824f428daf5a028d2f6ab8a299250a846f15d"}, @@ -2938,7 +2593,6 @@ nest-asyncio = [ {file = "nest_asyncio-1.5.5-py3-none-any.whl", hash = "sha256:b98e3ec1b246135e4642eceffa5a6c23a3ab12c82ff816a92c612d68205813b2"}, {file = "nest_asyncio-1.5.5.tar.gz", hash = "sha256:e442291cd942698be619823a17a86a5759eabe1f8613084790de189fe9e16d65"}, ] -networkx = [] nodeenv = [ {file = "nodeenv-1.7.0-py2.py3-none-any.whl", hash = "sha256:27083a7b96a25f2f5e1d8cb4b6317ee8aeda3bdd121394e5ac54e498028a042e"}, {file = "nodeenv-1.7.0.tar.gz", hash = "sha256:e0e7f7dfb85fc5394c6fe1e8fa98131a2473e04311a45afb6508f7cf1836fa2b"}, @@ -3018,7 +2672,6 @@ prometheus-client = [ {file = "prometheus_client-0.14.1.tar.gz", hash = "sha256:5459c427624961076277fdc6dc50540e2bacb98eebde99886e59ec55ed92093a"}, ] prompt-toolkit = [] -protobuf = [] psutil = [ {file = "psutil-5.9.1-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:799759d809c31aab5fe4579e50addf84565e71c1dc9f1c31258f159ff70d3f87"}, {file = "psutil-5.9.1-cp27-cp27m-manylinux2010_x86_64.whl", hash = "sha256:9272167b5f5fbfe16945be3db475b3ce8d792386907e673a209da686176552af"}, @@ -3079,66 +2732,67 @@ pydocstyle = [ ] pyflakes = [] pygame = [ - {file = "pygame-2.1.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:f149e182d0eeef15d8a9b4c9dad1b87dc6eba3a99bd3c44a777a3a2b053a3dca"}, - {file = "pygame-2.1.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:dc4444d61d48c5546df5137cdf81554887ddb6e2ef1be7f51eb77ea3b6bdd56f"}, - {file = "pygame-2.1.2-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:a0ccf8e3dce7ca67d523a6020b7e3dbf4b26797a9a8db5cc4c7b5ef20fb64701"}, - {file = "pygame-2.1.2-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:7889dce887ec83c9a0bef8d9eb3669d8863fdaf37c45bacec707d8ad90b24a38"}, - {file = "pygame-2.1.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:db2f40d5a75fd9cdda473c58b0d8b294da6e0179f00bb3b1fc2f7f29cac09bea"}, - {file = "pygame-2.1.2-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e4b4cd440d50a9f8551b8989e856aab175593af07eb825cad22fd2f8f6f2ffce"}, - {file = "pygame-2.1.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:754c2906f2ef47173a14493e1de116b2a56a2c8e1764f1202ba844d080248a5b"}, - {file = "pygame-2.1.2-cp310-cp310-win32.whl", hash = "sha256:c99b95e62cdda29c2e60235d7763447c168a6a877403e6f9ca5b2e2bb297c2ce"}, - {file = "pygame-2.1.2-cp310-cp310-win_amd64.whl", hash = "sha256:9649419254d3282dae41f23837de4108b17bc62187c3acd8af2ae3801b765cbd"}, - {file = "pygame-2.1.2-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:dcc285ee1f1d0e2672cc52f880fd3f564b1505de710e817f692fbf64a72ca657"}, - {file = "pygame-2.1.2-cp36-cp36m-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:e1bb25986db77a48f632469c6bc61baf7508ce945aa6161c02180d4ee5ac5b8d"}, - {file = "pygame-2.1.2-cp36-cp36m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:e7a8e18677e0064b7a422f6653a622652d932826a27e50f279d55a8b122a1a83"}, - {file = "pygame-2.1.2-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dd528dbb91eca16f7522c975d0f9e94b95f6b5024c82c3247dc0383d242d33c6"}, - {file = "pygame-2.1.2-cp36-cp36m-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fcc9586e17875c0cdf8764597955f9daa979098fd4f80be07ed68276ac225480"}, - {file = "pygame-2.1.2-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c9ce7f3d8af14d7e04eb7eb41c5e5313c43508c252bb2b9eb53e51fc87ada9fd"}, - {file = "pygame-2.1.2-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e09044e9e1aa8512d6a9c7ce5f94b881824bcfc401105f3c24f546dfc3bb4aa5"}, - {file = "pygame-2.1.2-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:40e4d8d65985bb467d9c5a1305fb53fd6820c61d764979600becab973339676f"}, - {file = "pygame-2.1.2-cp36-cp36m-win32.whl", hash = "sha256:50d9a21edd551669862c27c9272747401b20b1939abaacb842c08ea1cdd1c04d"}, - {file = "pygame-2.1.2-cp36-cp36m-win_amd64.whl", hash = "sha256:e18c9466131378421d00fc40b637425229238d506a073d9c537b230b355a25d6"}, - {file = "pygame-2.1.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:07ca9f683075aea9bd977af9f09a720ebf747343d3ea8103e4f1735283b02330"}, - {file = "pygame-2.1.2-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:3c8d6637ff75351e581327efefa9d04eeb0f257b533392b6cc6b15ceca4f7c5e"}, - {file = "pygame-2.1.2-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:5ebbefb8b576572c8fc97a3321d37dc2b4afea6b6e3877a67f7158d8c2c4cefe"}, - {file = "pygame-2.1.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9d6452419e01a0f848aed0597f69fd10a4c2a7750c15d1b0607f86090a39dcf3"}, - {file = "pygame-2.1.2-cp37-cp37m-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e627300a66a90651fb39e41601d447b1fdbbfffca3f08ef0278d6cc0436b2160"}, - {file = "pygame-2.1.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a56a811d8821f7b9a594e3d0e0dd8bd39b25e3eea8963d5963263b90fd2ea5c2"}, - {file = "pygame-2.1.2-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:24b4f7f30fa2b3d092b60be6fcc725fb91d569fc87a9bcc91614ee8b0c005726"}, - {file = "pygame-2.1.2-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:8e87716114e97322fb177e223d889a4be369a0f73212f4f8507fe0cd43253b23"}, - {file = "pygame-2.1.2-cp37-cp37m-win32.whl", hash = "sha256:20676da24e3e3e6b9fc4eecc7ba09d77ef46c3a83a028763ba1d222476c2e3fb"}, - {file = "pygame-2.1.2-cp37-cp37m-win_amd64.whl", hash = "sha256:93c4cbfc942dd00410eaa9e84252129f9f9993f37f683006d7b49ab245342254"}, - {file = "pygame-2.1.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:2405414d8c572668e04739875661e030a0c588e197fa95463fe301c3d0a0510b"}, - {file = "pygame-2.1.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:e8632f6b2ddb90f6f3950744bd65d5ef15af615e3034057fa30ff836f48a7179"}, - {file = "pygame-2.1.2-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:ca5ef1315fa67c241a657ab077be44f230c05740c95f0b46409457dceefdc7e5"}, - {file = "pygame-2.1.2-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:1219a963941bd53aa754e8449364c142004fe706c33a9c22ff2a76521a82d078"}, - {file = "pygame-2.1.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3bb0674aa789848ddc264bfc60c54965bf3bb659c141de4f600e379acc9b944c"}, - {file = "pygame-2.1.2-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:24254c4244f0d9bdc904f5d3f38e86757ca4c6aa0e44a6d55ef5e016bc7274d6"}, - {file = "pygame-2.1.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:97a74ba186deee68318a52637012ef6abf5be6282c659e1d1ba6ad08cf35ec85"}, - {file = "pygame-2.1.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:0e97d38308c441942577fea7fcd1326308bc56d6be6c024218e94d075d322e0f"}, - {file = "pygame-2.1.2-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:ea36f4f93524554a35cac2359df63b50af6556ed866830aa1f07f0d8580280ea"}, - {file = "pygame-2.1.2-cp38-cp38-win32.whl", hash = "sha256:4aa3ae32320cc704d63e185864e44f6265c2a6e52c9384afe152cc3d51b3a2ef"}, - {file = "pygame-2.1.2-cp38-cp38-win_amd64.whl", hash = "sha256:9d7b021b8dde5d528363e474bc18bd6f79a9666eef89fb4859bcb8f0a536c9de"}, - {file = "pygame-2.1.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:660c80c0b2e80f1f801715583b759fb4c7bc0c11eb3b534e89c9fc4bfbc38acd"}, - {file = "pygame-2.1.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:dad6bf3fdd3752d7519422f3732be779b98fe7c87d32c3efe2fdffdcbeebb6ca"}, - {file = "pygame-2.1.2-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:119dee20c372c85dc47b717119534d15a60c64ceab8b0eb09278866d10486afe"}, - {file = "pygame-2.1.2-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:fc2e5db54491e8f27785fc5204c96f540d3557dcf5b0a9a857b6594d6b32561b"}, - {file = "pygame-2.1.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d2d3c50ee9847b743db6cd7b1bb17a94c2c2abc16679d70f5e745cabdf19e655"}, - {file = "pygame-2.1.2-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6ecda8dd4583982bb65f9c682f244a5e94524dcf628379766227e9ed97201a49"}, - {file = "pygame-2.1.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0e06ae8e1c830f1b9c36a2bc6bb11de840232e95b78e2c349c6ed803a303be19"}, - {file = "pygame-2.1.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c5ea87da5fe4b6164c3854f3b0c9146811dbad0dd7fa74297683dfacc485ae1c"}, - {file = "pygame-2.1.2-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:0427c103f741234336e5606d2fad86f5403c1a3d1dc55c309fbff3c984f0c9ae"}, - {file = "pygame-2.1.2-cp39-cp39-win32.whl", hash = "sha256:5e88b0d4338b94960686f59396f23f7f684fed4859fcc3b9f40286d72c1c61af"}, - {file = "pygame-2.1.2-cp39-cp39-win_amd64.whl", hash = "sha256:5d0c14152d0ca8ef5fbcc5ed9981462bdf59a9ae85a291e62d8a8d0b7e5cbe43"}, - {file = "pygame-2.1.2-pp36-pypy36_pp73-win32.whl", hash = "sha256:636f51f56615d67459b11918206bb4da30cd7d7042027bf997c218ccd6c77902"}, - {file = "pygame-2.1.2-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:ff961c3280d6ee5f4163f4772f963d7a4dbe42e36c6dd54b79ad436c1f046e5d"}, - {file = "pygame-2.1.2-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:fc30e834f65b893d1b4c230070183bf98e6b70c41c1511687e8436a33d5ce49d"}, - {file = "pygame-2.1.2-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:5c7600bf307de1ca1dca0cc7840e34604d5b0b0a5a5dad345c3fa62b054b886d"}, - {file = "pygame-2.1.2-pp37-pypy37_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7fdb93b4282962c9a2ebf1af994ee698be823dd913218ed97a5f2fb372b10b66"}, - {file = "pygame-2.1.2-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1fddec8829e96424800c806582d73a5173b7d48946cccf7d035839ca09850db8"}, - {file = "pygame-2.1.2.tar.gz", hash = "sha256:d6d0eca28f886f0477cd0721ac688189155a587f2bb8eae740e52ca56c3ad23c"}, + {file = "pygame-2.1.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c84a93e6d33dafce9e25080ac557342333e15ef7e378ba84cb6181c52a8fd663"}, + {file = "pygame-2.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a0842458b49257ab539b7b6622a242cabcddcb61178b8ae074aaceb890be75b6"}, + {file = "pygame-2.1.0-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:6efa3fa472acb97c784224b59a89e80da6231f0dbf54df8442ffa3352c0534d6"}, + {file = "pygame-2.1.0-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:02a26b3be6cc478f18f4efa506ee5a585f68350857ac5e68e187301e943e3d6d"}, + {file = "pygame-2.1.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d5c62fbdb30082f7e1dcfa253da48e7b4be7342d275b34b2efa51f6cffc5942b"}, + {file = "pygame-2.1.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7a305dcf44f03a8dd7baefb97dc24949d7e719fd686cd3211121639aec4ce464"}, + {file = "pygame-2.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:847b4bc22edb1d77c992b5d56b19e1ab52e14687adb8bc3ed12a8a98fbd7e1ff"}, + {file = "pygame-2.1.0-cp310-cp310-win32.whl", hash = "sha256:e9368c105a8bccc8adfe7fd7fa5220d2b6c03979a3a57a8178c42f6fa9914ebc"}, + {file = "pygame-2.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:9a81d057a7dea95850e44118f141a892fde93c938ccb08fbc5dd7f1a26c2f1fe"}, + {file = "pygame-2.1.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:ada3d33e7e6907d5c3bf771dc58c47ee6994a1e28fed55e4f8f8b817367beb8f"}, + {file = "pygame-2.1.0-cp36-cp36m-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:5a3edc8211d0cf39d1e4d7ded1a0727c53aeb21205963f184199521708bbb05c"}, + {file = "pygame-2.1.0-cp36-cp36m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:53c6fa767e3eef52d403eda5d032e48b6040ccce03fbd64af2f71843168118da"}, + {file = "pygame-2.1.0-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c28c6f764aa03a0245db12346f1da327c6f49bcc20e53aefec6eed57e4fbe1ce"}, + {file = "pygame-2.1.0-cp36-cp36m-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5d36d530a8994c5bb8889816981f82b7942d8ec7651ca1d922d01302c1feecd2"}, + {file = "pygame-2.1.0-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fdd488daa4ad33748d5ea806e311bfe01b9cc506def5288400072fcd66d226cf"}, + {file = "pygame-2.1.0-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:9284e76923777c21b8bea19d8528be9cd62d0915139ed3c3cde6c43f849466f5"}, + {file = "pygame-2.1.0-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:49e5fb589a86169aa95b83d3429ee034799792374e13dbc0da83091d86365a4b"}, + {file = "pygame-2.1.0-cp36-cp36m-win32.whl", hash = "sha256:c6ee571995527e779b46cafee7ebef2dceb1a9c375143828e019293ff0efa167"}, + {file = "pygame-2.1.0-cp36-cp36m-win_amd64.whl", hash = "sha256:b400edd7391972e75b4243113089d6ea10b032e1306e8721efabb36d33c2d0f2"}, + {file = "pygame-2.1.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:0d2f80b501aacd74a660d4422793ea1cd4e209bee385aac18d0a07bd671511ee"}, + {file = "pygame-2.1.0-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:32cb64627c2eb5c4c067ffe614e08ccb8987d096100d225e070dddce05725b63"}, + {file = "pygame-2.1.0-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:38b5a43ab02c162501e62b857ff2cb128076b0786dd4e1d8bea63db8326f9da1"}, + {file = "pygame-2.1.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ba5bf655c892bbf4a9bafb4fcbc4c71023cc9a65f0cae0f3eba09a11018a858e"}, + {file = "pygame-2.1.0-cp37-cp37m-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:add546fcbf8954f00647f5e7d595ab9389f6a7542a99fc5dca514e14fd799773"}, + {file = "pygame-2.1.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:987c0d5fcd7737c31b35df06f78932c48eeff2c97473001e224fdebd3292b2db"}, + {file = "pygame-2.1.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:594234050b50b57c538842155dc3095c9d4f994266325adb4dd008aee526157f"}, + {file = "pygame-2.1.0-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:59a5461ef317e4d233d1bb5ce63311ccad3e911a652bda159d3922351050158c"}, + {file = "pygame-2.1.0-cp37-cp37m-win32.whl", hash = "sha256:9b2ad10ffaa226ca40ae229143b0a118426aff42e2459b626d355846c59a765d"}, + {file = "pygame-2.1.0-cp37-cp37m-win_amd64.whl", hash = "sha256:4f73058569573af12c8181e032745f11d85f0799510965d938b1f16c7f13afcb"}, + {file = "pygame-2.1.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:85844714f82a5379100825473b1a7b24192b4a944aed3128da9386e26adc3bed"}, + {file = "pygame-2.1.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:b0e96c0f68f6bb88da216765920c6dbc55ae83e70435d8ebac87d271fc058646"}, + {file = "pygame-2.1.0-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:3d5a76fa826202182d989e8399fca0c3c163fbb4f8ece773e77955a7a62cbed3"}, + {file = "pygame-2.1.0-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:2bfefabe78bda7a1bfba253cbe2131038402ce2b32e4218feeba6431fe429abb"}, + {file = "pygame-2.1.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3804476fab6ec7230aa817ee5c3b378ba956321fdd5f91f51c97452c588869d2"}, + {file = "pygame-2.1.0-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:70a11eec9bae6e8970c5bc4b3d0908eb2c42d4bd4ed488e41e49774b7cb41f57"}, + {file = "pygame-2.1.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4eff1db92d53dc2e49ed832dd6c76530e1e2b5954eef091f6af41b41d2d5c3ac"}, + {file = "pygame-2.1.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c1eb91198fc47c2e4fdc19c544b5d94534a70fd877f5c342228feb05e9fc4bef"}, + {file = "pygame-2.1.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:15d4e42214f93d8c60120e16b690ad03da7f0b3b66f75db8966bccf8c66c4690"}, + {file = "pygame-2.1.0-cp38-cp38-win32.whl", hash = "sha256:e533f4bf9dc1a91cfd608b9bfb028c6a92383e731c502660933f0f9b812045a6"}, + {file = "pygame-2.1.0-cp38-cp38-win_amd64.whl", hash = "sha256:692fe4498c353d663d45d05354fb47c9f6bf324d10b53844b9ed7f60e6c8cefa"}, + {file = "pygame-2.1.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:472b81ba6b61ffe5879ac3d0da2e5cb235e0e4da471ad4038f013a7710ab53ab"}, + {file = "pygame-2.1.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:bb55368d455ab9518b97febd33a8d417988397b019c9408993be034e0b5a7db6"}, + {file = "pygame-2.1.0-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:f8379052cfbc278b11e31bc97f2e7f5998959c50837c4d54f4e424a541e0c5d9"}, + {file = "pygame-2.1.0-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:b545634f96132af1d31dcb873cf03a9c4a5654ae39d9ee126db0b2eba2806788"}, + {file = "pygame-2.1.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5eb3dede55d005adea8504f8c9230b9dc2c84c1c728efe93a9718fa1af824dc8"}, + {file = "pygame-2.1.0-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f628f9f26c8dadf72fabc9ae0ce5fe7f60d76be71a3407abc756b4d1fd030fa0"}, + {file = "pygame-2.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d4061ac4e81bb36ec8f0a7027582c1c4dd32a939882e008165627103cb0b3985"}, + {file = "pygame-2.1.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fad7b5351931cb68d19d7ecc0b21021fe23237d8fba8c455b5af4a79e1c7c536"}, + {file = "pygame-2.1.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:a0ab3e4763e0cebf08c55154f4167cdae3683674604a71e1437123225f2a9b36"}, + {file = "pygame-2.1.0-cp39-cp39-win32.whl", hash = "sha256:64ec45215c2cfc4051bb0f58d26aee3b50a39b1b0a2e6fe8417bb352a6443aad"}, + {file = "pygame-2.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:86c66b917afc6330a91ac8c7169c36c77ec536578d1d7724644d41f904e2d146"}, + {file = "pygame-2.1.0-pp36-pypy36_pp73-win32.whl", hash = "sha256:b0e405fdde643f14d60c2dd140f110a5a38f588396a8b61a1a86374f25cba589"}, + {file = "pygame-2.1.0-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:646e871ff5ab7f933cde5ea2bff7b6cd74d7369f43e84a291baebe00bb9a8f6f"}, + {file = "pygame-2.1.0-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:88a2dabe617e6173003b65762c636947719da3e2d881a4ea47298e8d70886386"}, + {file = "pygame-2.1.0-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:7281366b4ebd7f16eac8ec6a6e2adb4c729beda178ea82637d9981e93dd40c9b"}, + {file = "pygame-2.1.0-pp37-pypy37_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0227728f2ef751fac43b89f4bcc5c65ce39c855b2a3391ddf2e6024dd667e6bd"}, + {file = "pygame-2.1.0-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4ab5aba8677d135b94c4714e8256efdfffefc164f354a4d05b846588caf43b99"}, + {file = "pygame-2.1.0.tar.gz", hash = "sha256:232e51104db0e573221660d172af8e6fc2c0fda183c5dbf2aa52170f29aa9ec9"}, ] pygbag = [] +pyglet = [] pygments = [ {file = "Pygments-2.12.0-py3-none-any.whl", hash = "sha256:dc9c10fb40944260f6ed4c688ece0cd2048414940f1cea51b8b226318411c519"}, {file = "Pygments-2.12.0.tar.gz", hash = "sha256:5eb116118f9612ff1ee89ac96437bb6b49e8f04d8a13b514ba26f620208e26eb"}, @@ -3183,38 +2837,6 @@ pytz = [ {file = "pytz-2022.1.tar.gz", hash = "sha256:1e760e2fe6a8163bc0b3d9a19c4f84342afa0a2affebfaa84b01b978a02ecaa7"}, ] pyupgrade = [] -pywavelets = [ - {file = "PyWavelets-1.3.0-cp310-cp310-macosx_10_13_universal2.whl", hash = "sha256:eebaa9c28600da336743fefd650332460c132792660e70eb09abf343b0664b87"}, - {file = "PyWavelets-1.3.0-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:3eeffcf2f7eebae5cc27cb11a7d0d96118e2e9f75ac38ff1a05373d5fe75accb"}, - {file = "PyWavelets-1.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:35a945bea9da6db9755e42e06e871846514ae91bde3ae24a08a1d090b003a23b"}, - {file = "PyWavelets-1.3.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8876764e349673ee8d48bc3cd0afd2f9f7b65378998e2665af12c277c8a56de"}, - {file = "PyWavelets-1.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c98ac1cee6276db05768e450dc3002033be6c2819c906103a974e0fb0d436f41"}, - {file = "PyWavelets-1.3.0-cp310-cp310-win32.whl", hash = "sha256:6ecfe051ccb097c2dcdcb0977e0a684e76144d6694a202badf0780143d8536f0"}, - {file = "PyWavelets-1.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:437806465cfa5f2d91809ec13154be050b84a11025784a6b6ce04ac452872b36"}, - {file = "PyWavelets-1.3.0-cp37-cp37m-macosx_10_13_x86_64.whl", hash = "sha256:3c4ebe7ff2c9092f6bdd1f8bf98ce2745f5d43a9936d6e342ee83fbcae548116"}, - {file = "PyWavelets-1.3.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d4f9ed4f175c66c9b8646a93fd54c588fd8f4b2517f53c59aea5cdf370f9c9ba"}, - {file = "PyWavelets-1.3.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:41e4f0a3a6a088e955006513fe72f863cea3ce293033131cacb8a1a3068ed228"}, - {file = "PyWavelets-1.3.0-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:5b76731d2077242611b32f2e11c72adbf126b432ceae92e2ce8d0f693974c96d"}, - {file = "PyWavelets-1.3.0-cp37-cp37m-win32.whl", hash = "sha256:3d3ecc2ee87be94fb2dc8c2d35bcae3f24708677196e80028d24ba0fd2f6a70a"}, - {file = "PyWavelets-1.3.0-cp37-cp37m-win_amd64.whl", hash = "sha256:91e1b220f0ddd4c127bab718363c2c4a07dbcd95b9c4bfed09a3cdae47dbba43"}, - {file = "PyWavelets-1.3.0-cp38-cp38-macosx_10_13_universal2.whl", hash = "sha256:8a5941d1f4eb1bc9569c655b63ecb31aa15b3ef0fc9b57df275892c39bccc59e"}, - {file = "PyWavelets-1.3.0-cp38-cp38-macosx_10_13_x86_64.whl", hash = "sha256:a555a7a85da01357d8258cb45f751881f69013f8920f8738718c60cf8a47b755"}, - {file = "PyWavelets-1.3.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:69e9a46facf89b51e5700d10f6d831f29745471c1ab42917f2f849a257b9fd77"}, - {file = "PyWavelets-1.3.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a51225d24811ba7ef5184c03bb7072db0aa9651c4370a115d4069dedfb8d2f7a"}, - {file = "PyWavelets-1.3.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d7369597e1b1d125eb4b458a36cef052beed188444e55ed21445c1196008e200"}, - {file = "PyWavelets-1.3.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:307ab8a4c3e5c2b8f7d3d371de4a5f019cf4b030b897c3394a4a7ad157369367"}, - {file = "PyWavelets-1.3.0-cp38-cp38-win32.whl", hash = "sha256:27e99818d3c26481de3c68dbe880a7fcafe661cc031b22eff4a64237fe17a7ff"}, - {file = "PyWavelets-1.3.0-cp38-cp38-win_amd64.whl", hash = "sha256:3383d106fa8da0c2df30401ad056cd7a11b76d885f4bfa16ca7bcc6b4ca2831c"}, - {file = "PyWavelets-1.3.0-cp39-cp39-macosx_10_13_universal2.whl", hash = "sha256:84c58a179bdb9fc71039b1f68bcd0718a7d9814b5e3741d7681d3e027bb81b52"}, - {file = "PyWavelets-1.3.0-cp39-cp39-macosx_10_13_x86_64.whl", hash = "sha256:fccf468c55427828a3c534b651311f2759210836491c1112e1548e1babe368a5"}, - {file = "PyWavelets-1.3.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:0ed3afbda88498b3ea3c861bf5b55e4feca41747730a71a22102ed5a74d1e453"}, - {file = "PyWavelets-1.3.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:38cc635c08a050e175a492e66c9b63a8e1f42254e6879e614b6c9d8d69e0887f"}, - {file = "PyWavelets-1.3.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a486160f83efd8517cd748796adbab7c445ee8a3e1d168b4b8b60ed0f5aee3a0"}, - {file = "PyWavelets-1.3.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:f6e7d969a6ef64ae8be1766b0b0e32debb13424543d331911b8d7e967d60dd42"}, - {file = "PyWavelets-1.3.0-cp39-cp39-win32.whl", hash = "sha256:de67deb275474094e160900ab7e07f2a721b9cd351cf3826c4a3ab89bb71d4b3"}, - {file = "PyWavelets-1.3.0-cp39-cp39-win_amd64.whl", hash = "sha256:a354979e2ee8cd71a8952ded381f3d9f981692b73c6842bcc6c9f64047e0a5be"}, - {file = "PyWavelets-1.3.0.tar.gz", hash = "sha256:cbaa9d62052d9daf8da765fc8e7c30c38ea2b8e9e1c18841913dfb4aec671ee5"}, -] pywin32 = [ {file = "pywin32-304-cp310-cp310-win32.whl", hash = "sha256:3c7bacf5e24298c86314f03fa20e16558a4e4138fc34615d7de4070c23e65af3"}, {file = "pywin32-304-cp310-cp310-win_amd64.whl", hash = "sha256:4f32145913a2447736dad62495199a8e280a77a0ca662daa2332acf849f0be48"}, @@ -3326,24 +2948,6 @@ pyzmq = [ {file = "pyzmq-23.2.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:ce4f71e17fa849de41a06109030d3f6815fcc33338bf98dd0dde6d456d33c929"}, {file = "pyzmq-23.2.0.tar.gz", hash = "sha256:a51f12a8719aad9dcfb55d456022f16b90abc8dde7d3ca93ce3120b40e3fa169"}, ] -ray = [ - {file = "ray-1.13.0-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:4e2bb8cf0de825f120c53b3b762f76688eba47e87e0f59b5038d2721e670c38c"}, - {file = "ray-1.13.0-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:a7c0a60a84f5755994e2f3585430858971fe80c59a4b48a8d69150df44d27466"}, - {file = "ray-1.13.0-cp310-cp310-manylinux2014_x86_64.whl", hash = "sha256:57a38df76f00fdb19fd210223feb15f7246beda1a3121f14dafbc28d2dba2159"}, - {file = "ray-1.13.0-cp36-cp36m-macosx_10_15_intel.whl", hash = "sha256:9df2e037e220180cf4e1a2e0d0ec9b6a22acb7e28c790fc07f49ec9707f4ba87"}, - {file = "ray-1.13.0-cp36-cp36m-manylinux2014_x86_64.whl", hash = "sha256:aeb35708214f9dd29010576ae594c364dc868d061fc01fb969966c60708f72d6"}, - {file = "ray-1.13.0-cp37-cp37m-macosx_10_15_intel.whl", hash = "sha256:4e70829395fa471f013d5008d827ad9226cfb4f3a9689dad30bb54967f6601b6"}, - {file = "ray-1.13.0-cp37-cp37m-manylinux2014_x86_64.whl", hash = "sha256:df7394a860a2e81e7017e4e8ade6dc6eecf4d8effa26d0e9ca74eb1a1354d0c4"}, - {file = "ray-1.13.0-cp37-cp37m-win_amd64.whl", hash = "sha256:4c2568b3600d8246964ad21e90b3dfee31074b5ba534759cdc42dbd783f40476"}, - {file = "ray-1.13.0-cp38-cp38-macosx_10_15_x86_64.whl", hash = "sha256:7a82ef0e439c043f9de96415304867716f2ea5207ecf3b5ae5cdb1c4b6dbb596"}, - {file = "ray-1.13.0-cp38-cp38-macosx_12_0_arm64.whl", hash = "sha256:da8f488de5cb107769b1f57653a31dc558de3fe56d279a0020bc7c02fb957a89"}, - {file = "ray-1.13.0-cp38-cp38-manylinux2014_x86_64.whl", hash = "sha256:a7edf2cb0f2d6b1a4f82fa86caf524280ed505959599831e88d94cbd5c0109c3"}, - {file = "ray-1.13.0-cp38-cp38-win_amd64.whl", hash = "sha256:6618d815bf80219cfe687e3b27a974a224506d65ea8f38ad03e8687a869d6e00"}, - {file = "ray-1.13.0-cp39-cp39-macosx_10_15_x86_64.whl", hash = "sha256:dabe8f5af7f83d80b3f10fe78f6e3cd061d38cc0c384cd3bef275849e57bad6b"}, - {file = "ray-1.13.0-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:6d39a744e1e4179bd718ee8c1b21a399178601c06e301d209448793e8fcacdc8"}, - {file = "ray-1.13.0-cp39-cp39-manylinux2014_x86_64.whl", hash = "sha256:ba0829d495dec0bc90a72169f93e4cb004962a37df4d9b0df23004ebefb6d221"}, - {file = "ray-1.13.0-cp39-cp39-win_amd64.whl", hash = "sha256:6586fd313e0665f1d0e1fc6deca910421d1a963c56711383f89931e0521942fd"}, -] requests = [ {file = "requests-2.28.1-py3-none-any.whl", hash = "sha256:8fefa2a1a1365bf5520aac41836fbee479da67864514bdb821f31ce07ce65349"}, {file = "requests-2.28.1.tar.gz", hash = "sha256:7c5599b102feddaa661c826c56ab4fee28bfd17f5abca1ebbe3e7f19d7c97983"}, @@ -3357,8 +2961,6 @@ ruamel-yaml = [ ] ruamel-yaml-clib = [] safety = [] -scikit-image = [] -scipy = [] send2trash = [ {file = "Send2Trash-1.8.0-py3-none-any.whl", hash = "sha256:f20eaadfdb517eaca5ce077640cb261c7d2698385a6a0f072a4a5447fd49fa08"}, {file = "Send2Trash-1.8.0.tar.gz", hash = "sha256:d2c24762fd3759860a0aff155e45871447ea58d2be6bdd39b5c8f966a0c99c2d"}, @@ -3416,18 +3018,13 @@ sphinxcontrib-serializinghtml = [ {file = "sphinxcontrib-serializinghtml-1.1.5.tar.gz", hash = "sha256:aa5f6de5dfdf809ef505c4895e51ef5c9eac17d0f287933eb49ec495280b6952"}, {file = "sphinxcontrib_serializinghtml-1.1.5-py2.py3-none-any.whl", hash = "sha256:352a9a00ae864471d3a7ead8d7d79f5fc0b57e8b3f95e9867eb9eb28999b92fd"}, ] +stable-baselines3 = [] stack-data = [] stevedore = [] -tabulate = [] -tensorboardx = [ - {file = "tensorboardX-2.5.1-py2.py3-none-any.whl", hash = "sha256:8808133ccca673cd04076f6f2a85cf2d39bb2d0393a0f20d0f9cbb06d472b57e"}, - {file = "tensorboardX-2.5.1.tar.gz", hash = "sha256:ea85a3446f22ce8a917fe4fa4d8a7a96222ef84ac835267d038c34bb99f6d61b"}, -] terminado = [ {file = "terminado-0.15.0-py3-none-any.whl", hash = "sha256:0d5f126fbfdb5887b25ae7d9d07b0d716b1cc0ccaacc71c1f3c14d228e065197"}, {file = "terminado-0.15.0.tar.gz", hash = "sha256:ab4eeedccfcc1e6134bfee86106af90852c69d602884ea3a1e8ca6d4486e9bfe"}, ] -tifffile = [] tinycss2 = [ {file = "tinycss2-1.1.1-py3-none-any.whl", hash = "sha256:fe794ceaadfe3cf3e686b22155d0da5780dd0e273471a51846d0a02bc204fec8"}, {file = "tinycss2-1.1.1.tar.gz", hash = "sha256:b2e44dd8883c360c35dd0d1b5aad0b610e5156c2cb3b33434634e539ead9d8bf"}, diff --git a/pyproject.toml b/pyproject.toml index 038ea64..aa79825 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -21,10 +21,11 @@ Changelog = "https://github.com/GeoML-SIG/wildcatter/releases" [tool.poetry.dependencies] python = ">=3.8 <3.10" gym = "^0.21" -pygame = "^2.1.2" -ray = {version = "^1.13.0", extras = ["rllib"]} torch = "^1.12.0" click = ">=8.0.4" +stable-baselines3 = "^1.6.0" +pygame = { version = "2.1.0", optional = true } +pyglet = {version = "^1.5.26", optional = true} [tool.poetry.group.notebook] optional = true @@ -65,6 +66,9 @@ typeguard = ">=2.13.3" xdoctest = {extras = ["colors"], version = ">=0.15.10"} myst-parser = {version = ">=0.16.1"} +[tool.poetry.extras] +hello_world = ["pygame", "pyglet"] + [tool.poetry.scripts] wildcatter = "wildcatter.__main__:main"