diff --git a/lessons/6-Other/22-DeepRL/CartPole-RL-PyTorch.ipynb b/lessons/6-Other/22-DeepRL/CartPole-RL-PyTorch.ipynb new file mode 100644 index 00000000..f574cd45 --- /dev/null +++ b/lessons/6-Other/22-DeepRL/CartPole-RL-PyTorch.ipynb @@ -0,0 +1,490 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Training RL to do Cartpole Balancing\n", + "\n", + "This notebooks is part of [AI for Beginners Curriculum](http://aka.ms/ai-beginners). It has been inspired by [official PyTorch tutorial](https://pytorch.org/tutorials/intermediate/reinforcement_q_learning.html) and [this Cartpole Pytorch implementation](https://github.com/yc930401/Actor-Critic-pytorch).\n", + "\n", + "In this example, we will use RL to train a model to balance a pole on a cart that can move left and right on horizontal scale. We will use [OpenAI Gym](https://www.gymlibrary.ml/) environment to simulate the pole.\n", + "\n", + "> **Note**: You can run this lesson's code locally (eg. from Visual Studio Code), in which case the simulation will open in a new window. When running the code online, you may need to make some tweaks to the code, as described [here](https://towardsdatascience.com/rendering-openai-gym-envs-on-binder-and-google-colab-536f99391cc7).\n", + "\n", + "We will start by making sure Gym is installed:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "!{sys.executable} -m pip install gym" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's create the CartPole environment and see how to operate on it. An environment has the following properties:\n", + "\n", + "* **Action space** is the set of possible actions that we can perform at each step of the simulation\n", + "* **Observation space** is the space of observations that we can make" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import gym\n", + "\n", + "env = gym.make(\"CartPole-v1\")\n", + "\n", + "print(f\"Action space: {env.action_space}\")\n", + "print(f\"Observation space: {env.observation_space}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's see how the simulation works. The following loop runs the simulation, until `env.step` does not return the termination flag `done`. We will randomly chose actions using `env.action_space.sample()`, which means the experiment will probably fail very fast (CartPole environment terminates when the speed of CartPole, its position or angle are outside certain limits).\n", + "\n", + "> Simulation will open in the new window. You can run the code several times and see how it behaves." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "env.reset()\n", + "\n", + "done = False\n", + "total_reward = 0\n", + "while not done:\n", + " env.render()\n", + " obs, rew, done, info = env.step(env.action_space.sample())\n", + " total_reward += rew\n", + " print(f\"{obs} -> {rew}\")\n", + "print(f\"Total reward: {total_reward}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Youn can notice that observations contain 4 numbers. They are:\n", + "- Position of cart\n", + "- Velocity of cart\n", + "- Angle of pole\n", + "- Rotation rate of pole\n", + "\n", + "`rew` is the reward we receive at each step. You can see that in CartPole environment you are rewarded 1 point for each simulation step, and the goal is to maximize total reward, i.e. the time CartPole is able to balance without falling.\n", + "\n", + "During reinforcement learning, our goal is to train a **policy** $\\pi$, that for each state $s$ will tell us which action $a$ to take, so essentially $a = \\pi(s)$.\n", + "\n", + "If you want probabilistic solution, you can think of policy as returning a set of probabilities for each action, i.e. $\\pi(a|s)$ would mean a probability that we should take action $a$ at state $s$.\n", + "\n", + "## Policy Gradient Method\n", + "\n", + "In simplest RL algorithm, called **Policy Gradient**, we will train a neural network to predict the next action." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "\n", + "num_inputs = 4\n", + "num_actions = 2\n", + "\n", + "model = torch.nn.Sequential(\n", + " torch.nn.Linear(num_inputs, 128, bias=False, dtype=torch.float32),\n", + " torch.nn.ReLU(),\n", + " torch.nn.Linear(128, num_actions, bias = False, dtype=torch.float32),\n", + " torch.nn.Softmax(dim=1)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will train the network by running many experiments, and updating our network after each run. Let's define a function that will run the experiment and return the results (so-called **trace**) - all states, actions (and their recommended probabilities), and rewards:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def run_episode(max_steps_per_episode = 10000,render=False): \n", + " states, actions, probs, rewards = [],[],[],[]\n", + " state = env.reset()\n", + " for _ in range(max_steps_per_episode):\n", + " if render:\n", + " env.render()\n", + " action_probs = model(torch.from_numpy(np.expand_dims(state,0)))[0]\n", + " action = np.random.choice(num_actions, p=np.squeeze(action_probs.detach().numpy()))\n", + " nstate, reward, done, info = env.step(action)\n", + " if done:\n", + " break\n", + " states.append(state)\n", + " actions.append(action)\n", + " probs.append(action_probs.detach().numpy())\n", + " rewards.append(reward)\n", + " state = nstate\n", + " return np.vstack(states), np.vstack(actions), np.vstack(probs), np.vstack(rewards)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can run one episode with untrained network and observe that total reward (AKA length of episode) is very low:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "s, a, p, r = run_episode()\n", + "print(f\"Total reward: {np.sum(r)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One of the tricky aspects of policy gradient algorithm is to use **discounted rewards**. The idea is that we compute the vector of total rewards at each step of the game, and during this process we discount the early rewards using some coefficient $gamma$. We also normalize the resulting vector, because we will use it as weight to affect our training: " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "eps = 0.0001\n", + "\n", + "def discounted_rewards(rewards,gamma=0.99,normalize=True):\n", + " ret = []\n", + " s = 0\n", + " for r in rewards[::-1]:\n", + " s = r + gamma * s\n", + " ret.insert(0, s)\n", + " if normalize:\n", + " ret = (ret-np.mean(ret))/(np.std(ret)+eps)\n", + " return ret" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's do the actual training! We will run 300 episodes, and at each episode we will do the following:\n", + "\n", + "1. Run the experiment and collect the trace\n", + "1. Calculate the difference (`gradients`) between the actions taken, and by predicted probabilities. The less the difference is, the more we are sure that we have taken the right action.\n", + "1. Calculate discounted rewards and multiply gradients by discounted rewards - that will make sure that steps with higher rewards will make more effect on the final result than lower-rewarded ones\n", + "1. Expected target actions for our neural network would be partly taken from the predicted probabilities during the run, and partly from calculated gradients. We will use `alpha` parameter to determine to which extent gradients and rewards are taken into account - this is called *learning rate* of reinforcement algorithm.\n", + "1. Finally, we train our network on states and expected actions, and repeat the process " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "optimizer = torch.optim.Adam(model.parameters(), lr=0.01)\n", + "\n", + "def train_on_batch(x, y):\n", + " x = torch.from_numpy(x)\n", + " y = torch.from_numpy(y)\n", + " optimizer.zero_grad()\n", + " predictions = model(x)\n", + " loss = -torch.mean(torch.log(predictions) * y)\n", + " loss.backward()\n", + " optimizer.step()\n", + " return loss" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "alpha = 1e-4\n", + "\n", + "history = []\n", + "for epoch in range(300):\n", + " states, actions, probs, rewards = run_episode()\n", + " one_hot_actions = np.eye(2)[actions.T][0]\n", + " gradients = one_hot_actions-probs\n", + " dr = discounted_rewards(rewards)\n", + " gradients *= dr\n", + " target = alpha*np.vstack([gradients])+probs\n", + " train_on_batch(states,target)\n", + " history.append(np.sum(rewards))\n", + " if epoch%100==0:\n", + " print(f\"{epoch} -> {np.sum(rewards)}\")\n", + "\n", + "plt.plot(history)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's run the episode with rendering to see the result:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "_ = run_episode(render=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hopefully, you can see that pole can now balance pretty well!\n", + "\n", + "## Actor-Critic Model\n", + "\n", + "Actor-Critic model is the further development of policy gradients, in which we build a neural network to learn both the policy and estimated rewards. The network will have two outputs (or you can view it as two separate networks):\n", + "* **Actor** will recommend the action to take by giving us the state probability distribution, as in policy gradient model\n", + "* **Critic** would estimate what the reward would be from those actions. It returns total estimated rewards in the future at the given state.\n", + "\n", + "Let's define such a model: " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from itertools import count\n", + "import torch.nn.functional as F" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "env = gym.make(\"CartPole-v1\")\n", + "\n", + "state_size = env.observation_space.shape[0]\n", + "action_size = env.action_space.n\n", + "lr = 0.0001\n", + "\n", + "class Actor(torch.nn.Module):\n", + " def __init__(self, state_size, action_size):\n", + " super(Actor, self).__init__()\n", + " self.state_size = state_size\n", + " self.action_size = action_size\n", + " self.linear1 = torch.nn.Linear(self.state_size, 128)\n", + " self.linear2 = torch.nn.Linear(128, 256)\n", + " self.linear3 = torch.nn.Linear(256, self.action_size)\n", + "\n", + " def forward(self, state):\n", + " output = F.relu(self.linear1(state))\n", + " output = F.relu(self.linear2(output))\n", + " output = self.linear3(output)\n", + " distribution = torch.distributions.Categorical(F.softmax(output, dim=-1))\n", + " return distribution\n", + "\n", + "\n", + "class Critic(torch.nn.Module):\n", + " def __init__(self, state_size, action_size):\n", + " super(Critic, self).__init__()\n", + " self.state_size = state_size\n", + " self.action_size = action_size\n", + " self.linear1 = torch.nn.Linear(self.state_size, 128)\n", + " self.linear2 = torch.nn.Linear(128, 256)\n", + " self.linear3 = torch.nn.Linear(256, 1)\n", + "\n", + " def forward(self, state):\n", + " output = F.relu(self.linear1(state))\n", + " output = F.relu(self.linear2(output))\n", + " value = self.linear3(output)\n", + " return value" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We would need to slightly modify our `discounted_rewards` and `run_episode` functions:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def discounted_rewards(next_value, rewards, masks, gamma=0.99):\n", + " R = next_value\n", + " returns = []\n", + " for step in reversed(range(len(rewards))):\n", + " R = rewards[step] + gamma * R * masks[step]\n", + " returns.insert(0, R)\n", + " return returns\n", + "\n", + "def run_episode(actor, critic, n_iters):\n", + " optimizerA = torch.optim.Adam(actor.parameters())\n", + " optimizerC = torch.optim.Adam(critic.parameters())\n", + " for iter in range(n_iters):\n", + " state = env.reset()\n", + " log_probs = []\n", + " values = []\n", + " rewards = []\n", + " masks = []\n", + " entropy = 0\n", + " env.reset()\n", + "\n", + " for i in count():\n", + " env.render()\n", + " state = torch.FloatTensor(state).to(device)\n", + " dist, value = actor(state), critic(state)\n", + "\n", + " action = dist.sample()\n", + " next_state, reward, done, _ = env.step(action.cpu().numpy())\n", + "\n", + " log_prob = dist.log_prob(action).unsqueeze(0)\n", + " entropy += dist.entropy().mean()\n", + "\n", + " log_probs.append(log_prob)\n", + " values.append(value)\n", + " rewards.append(torch.tensor([reward], dtype=torch.float, device=device))\n", + " masks.append(torch.tensor([1-done], dtype=torch.float, device=device))\n", + "\n", + " state = next_state\n", + "\n", + " if done:\n", + " print('Iteration: {}, Score: {}'.format(iter, i))\n", + " break\n", + "\n", + "\n", + " next_state = torch.FloatTensor(next_state).to(device)\n", + " next_value = critic(next_state)\n", + " returns = discounted_rewards(next_value, rewards, masks)\n", + "\n", + " log_probs = torch.cat(log_probs)\n", + " returns = torch.cat(returns).detach()\n", + " values = torch.cat(values)\n", + "\n", + " advantage = returns - values\n", + "\n", + " actor_loss = -(log_probs * advantage.detach()).mean()\n", + " critic_loss = advantage.pow(2).mean()\n", + "\n", + " optimizerA.zero_grad()\n", + " optimizerC.zero_grad()\n", + " actor_loss.backward()\n", + " critic_loss.backward()\n", + " optimizerA.step()\n", + " optimizerC.step()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we will run the main training loop. We will use manual network training process by computing proper loss functions and updating network parameters:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "actor = Actor(state_size, action_size).to(device)\n", + "critic = Critic(state_size, action_size).to(device)\n", + "run_episode(actor, critic, n_iters=100)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, let's close the environment." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "env.close()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Takeaway\n", + "\n", + "We have seen two RL algorithms in this demo: simple policy gradient, and more sophisticated actor-critic. You can see that those algorithms operate with abstract notions of state, action and reward - thus they can be applied to very different environments.\n", + "\n", + "Reinforcement learning allows us to learn the best strategy to solve the problem just by looking at the final reward. The fact that we do not need labelled datasets allows us to repeat simulations many times to optimize our models. However, there are still many challenges in RL, which you may learn if you decide to focus more on this interesting area of AI. " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.4 64-bit", + "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.10.4" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/lessons/6-Other/22-DeepRL/CartPole-RL-TF.ipynb b/lessons/6-Other/22-DeepRL/CartPole-RL-TF.ipynb index 5afa5a35..6315a1ce 100644 --- a/lessons/6-Other/22-DeepRL/CartPole-RL-TF.ipynb +++ b/lessons/6-Other/22-DeepRL/CartPole-RL-TF.ipynb @@ -17,23 +17,19 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Requirement already satisfied: gym in c:\\winapp\\miniconda3\\envs\\py38\\lib\\site-packages (0.23.1)\n", - "Collecting pygame\n", - " Downloading pygame-2.1.2-cp38-cp38-win_amd64.whl (8.4 MB)\n", - "Requirement already satisfied: importlib-metadata>=4.10.0 in c:\\winapp\\miniconda3\\envs\\py38\\lib\\site-packages (from gym) (4.11.3)\n", - "Requirement already satisfied: cloudpickle>=1.2.0 in c:\\winapp\\miniconda3\\envs\\py38\\lib\\site-packages (from gym) (2.0.0)\n", - "Requirement already satisfied: gym-notices>=0.0.4 in c:\\winapp\\miniconda3\\envs\\py38\\lib\\site-packages (from gym) (0.0.6)\n", - "Requirement already satisfied: numpy>=1.18.0 in c:\\winapp\\miniconda3\\envs\\py38\\lib\\site-packages (from gym) (1.22.3)\n", - "Requirement already satisfied: zipp>=0.5 in c:\\winapp\\miniconda3\\envs\\py38\\lib\\site-packages (from importlib-metadata>=4.10.0->gym) (3.6.0)\n", - "Installing collected packages: pygame\n", - "Successfully installed pygame-2.1.2\n" + "Defaulting to user installation because normal site-packages is not writeable\n", + "Requirement already satisfied: gym in /home/leo/.local/lib/python3.10/site-packages (0.25.0)\n", + "Requirement already satisfied: pygame in /home/leo/.local/lib/python3.10/site-packages (2.1.2)\n", + "Requirement already satisfied: gym-notices>=0.0.4 in /home/leo/.local/lib/python3.10/site-packages (from gym) (0.0.7)\n", + "Requirement already satisfied: cloudpickle>=1.2.0 in /home/leo/.local/lib/python3.10/site-packages (from gym) (2.1.0)\n", + "Requirement already satisfied: numpy>=1.18.0 in /usr/lib/python3/dist-packages (from gym) (1.21.5)\n" ] } ], @@ -54,7 +50,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -64,10 +60,22 @@ "Action space: Discrete(2)\n", "Observation space: 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)\n" ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/leo/.local/lib/python3.10/site-packages/gym/core.py:329: DeprecationWarning: \u001b[33mWARN: Initializing wrapper in old step API which returns one bool instead of two. It is recommended to set `new_step_api=True` to use new step API. This will be the default behaviour in future.\u001b[0m\n", + " deprecation(\n", + "/home/leo/.local/lib/python3.10/site-packages/gym/wrappers/step_api_compatibility.py:39: DeprecationWarning: \u001b[33mWARN: Initializing environment in old step API which returns one bool instead of two. It is recommended to set `new_step_api=True` to use new step API. This will be the default behaviour in future.\u001b[0m\n", + " deprecation(\n" + ] } ], "source": [ "import gym\n", + "import pygame\n", + "import tqdm\n", "\n", "env = gym.make(\"CartPole-v1\")\n", "\n", @@ -86,33 +94,58 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 3, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/leo/.local/lib/python3.10/site-packages/gym/core.py:57: DeprecationWarning: \u001b[33mWARN: You are calling render method, but you didn't specified the argument render_mode at environment initialization. To maintain backward compatibility, the environment will render in human mode.\n", + "If you want to render in human mode, initialize the environment in this way: gym.make('EnvName', render_mode='human') and don't call the render method.\n", + "See here for more information: https://www.gymlibrary.ml/content/api/\u001b[0m\n", + " deprecation(\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - "[-0.04825775 -0.21918646 -0.00796685 0.27188525] -> 1.0\n", - "[-0.05264147 -0.4141938 -0.00252914 0.5620448 ] -> 1.0\n", - "[-0.06092535 -0.21903647 0.00871175 0.26856613] -> 1.0\n", - "[-0.06530608 -0.41428167 0.01408308 0.56398404] -> 1.0\n", - "[-0.07359171 -0.60959834 0.02536276 0.8610703 ] -> 1.0\n", - "[-0.08578368 -0.4148308 0.04258416 0.57646877] -> 1.0\n", - "[-0.09408029 -0.610523 0.05411354 0.88225687] -> 1.0\n", - "[-0.10629076 -0.4161761 0.07175867 0.6070649 ] -> 1.0\n", - "[-0.11461428 -0.22212696 0.08389997 0.33781925] -> 1.0\n", - "[-0.11905681 -0.0282929 0.09065636 0.07272854] -> 1.0\n", - "[-0.11962268 0.16542032 0.09211093 -0.19003159] -> 1.0\n", - "[-0.11631427 -0.03089041 0.08831029 0.13022853] -> 1.0\n", - "[-0.11693208 -0.22715913 0.09091487 0.44941387] -> 1.0\n", - "[-0.12147526 -0.42344147 0.09990314 0.76931363] -> 1.0\n", - "[-0.12994409 -0.61978614 0.11528942 1.0916848 ] -> 1.0\n", - "[-0.14233981 -0.81622297 0.13712311 1.4182041 ] -> 1.0\n", - "[-0.15866427 -1.01275 0.1654872 1.7504154 ] -> 1.0\n", - "[-0.17891927 -1.2093195 0.2004955 2.0896728 ] -> 1.0\n", - "[-0.20310566 -1.4058217 0.24228896 2.4370732 ] -> 1.0\n", - "Total reward: 19.0\n" + "[ 0.00425272 -0.19994313 0.00917169 0.34113726] -> 1.0\n", + "[ 0.00025386 -0.00495286 0.01599443 0.05136059] -> 1.0\n", + "[ 1.5480528e-04 1.8993615e-01 1.7021643e-02 -2.3623335e-01] -> 1.0\n", + "[ 0.00395353 0.38481084 0.01229698 -0.5234989 ] -> 1.0\n", + "[ 0.01164974 0.18951797 0.001827 -0.22696657] -> 1.0\n", + "[ 0.0154401 0.38461378 -0.00271233 -0.51907265] -> 1.0\n", + "[ 0.02313238 0.5797738 -0.01309379 -0.812609 ] -> 1.0\n", + "[ 0.03472786 0.38483363 -0.02934597 -0.5240733 ] -> 1.0\n", + "[ 0.04242453 0.580356 -0.03982743 -0.8258571 ] -> 1.0\n", + "[ 0.05403165 0.38580072 -0.05634458 -0.54596174] -> 1.0\n", + "[ 0.06174766 0.19151384 -0.06726381 -0.27155042] -> 1.0\n", + "[ 0.06557794 -0.00258703 -0.07269482 -0.00081817] -> 1.0\n", + "[ 0.0655262 -0.19659522 -0.07271118 0.26807207] -> 1.0\n", + "[ 0.0615943 -0.00051497 -0.06734974 -0.04662942] -> 1.0\n", + "[ 0.061584 0.19550486 -0.06828233 -0.3597784 ] -> 1.0\n", + "[ 0.06549409 0.00141663 -0.0754779 -0.08938391] -> 1.0\n", + "[ 0.06552242 -0.19254686 -0.07726558 0.17856352] -> 1.0\n", + "[ 0.06167149 0.00359088 -0.0736943 -0.1374588 ] -> 1.0\n", + "[ 0.0617433 0.19968675 -0.07644348 -0.45245075] -> 1.0\n", + "[ 0.06573704 0.3958018 -0.0854925 -0.7682167 ] -> 1.0\n", + "[ 0.07365308 0.20195423 -0.10085683 -0.50361156] -> 1.0\n", + "[ 0.07769216 0.0083876 -0.11092906 -0.24433874] -> 1.0\n", + "[ 0.07785992 -0.18498953 -0.11581583 0.01139782] -> 1.0\n", + "[ 0.07416012 0.01158649 -0.11558788 -0.31546465] -> 1.0\n", + "[ 0.07439185 0.20814891 -0.12189718 -0.64224803] -> 1.0\n", + "[ 0.07855483 0.01491799 -0.13474214 -0.3903015 ] -> 1.0\n", + "[ 0.07885319 -0.17806001 -0.14254816 -0.14295265] -> 1.0\n", + "[ 0.07529199 0.01878517 -0.14540721 -0.47699296] -> 1.0\n", + "[ 0.07566769 -0.17401667 -0.15494707 -0.23344138] -> 1.0\n", + "[ 0.07218736 0.0229406 -0.1596159 -0.57071024] -> 1.0\n", + "[ 0.07264617 0.21989843 -0.1710301 -0.9091196 ] -> 1.0\n", + "[ 0.07704414 0.02745241 -0.1892125 -0.6747003 ] -> 1.0\n", + "[ 0.07759319 -0.16460665 -0.20270652 -0.4470505 ] -> 1.0\n", + "[ 0.07430106 -0.35637102 -0.21164753 -0.22448184] -> 1.0\n", + "Total reward: 34.0\n" ] } ], @@ -126,7 +159,9 @@ " obs, rew, done, info = env.step(env.action_space.sample())\n", " total_reward += rew\n", " print(f\"{obs} -> {rew}\")\n", - "print(f\"Total reward: {total_reward}\")" + "print(f\"Total reward: {total_reward}\")\n", + "\n", + "env.close()" ] }, { @@ -152,9 +187,35 @@ }, { "cell_type": "code", - "execution_count": 100, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.10/dist-packages/tensorflow/__init__.py:29: DeprecationWarning: The distutils package is deprecated and slated for removal in Python 3.12. Use setuptools or check PEP 632 for potential alternatives\n", + " import distutils as _distutils\n", + "2022-07-24 16:50:47.597258: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory\n", + "2022-07-24 16:50:47.597280: I tensorflow/stream_executor/cuda/cudart_stub.cc:29] Ignore above cudart dlerror if you do not have a GPU set up on your machine.\n", + "/usr/local/lib/python3.10/dist-packages/flatbuffers/compat.py:19: DeprecationWarning: the imp module is deprecated in favour of importlib and slated for removal in Python 3.12; see the module's documentation for alternative uses\n", + " import imp\n", + "2022-07-24 16:50:49.838826: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:975] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n", + "2022-07-24 16:50:49.839078: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory\n", + "2022-07-24 16:50:49.839143: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcublas.so.11'; dlerror: libcublas.so.11: cannot open shared object file: No such file or directory\n", + "2022-07-24 16:50:49.839194: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcublasLt.so.11'; dlerror: libcublasLt.so.11: cannot open shared object file: No such file or directory\n", + "2022-07-24 16:50:49.839245: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcufft.so.10'; dlerror: libcufft.so.10: cannot open shared object file: No such file or directory\n", + "2022-07-24 16:50:49.839295: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcurand.so.10'; dlerror: libcurand.so.10: cannot open shared object file: No such file or directory\n", + "2022-07-24 16:50:49.839345: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcusolver.so.11'; dlerror: libcusolver.so.11: cannot open shared object file: No such file or directory\n", + "2022-07-24 16:50:49.839392: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcusparse.so.11'; dlerror: libcusparse.so.11: cannot open shared object file: No such file or directory\n", + "2022-07-24 16:50:49.839441: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudnn.so.8'; dlerror: libcudnn.so.8: cannot open shared object file: No such file or directory\n", + "2022-07-24 16:50:49.839449: W tensorflow/core/common_runtime/gpu/gpu_device.cc:1850] Cannot dlopen some GPU libraries. Please make sure the missing libraries mentioned above are installed properly if you would like to use GPU. Follow the guide at https://www.tensorflow.org/install/gpu for how to download and setup the required libraries for your platform.\n", + "Skipping registering GPU devices...\n", + "2022-07-24 16:50:49.839649: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations: AVX2 FMA\n", + "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" + ] + } + ], "source": [ "import numpy as np\n", "import tensorflow as tf\n", @@ -181,7 +242,7 @@ }, { "cell_type": "code", - "execution_count": 101, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -213,14 +274,14 @@ }, { "cell_type": "code", - "execution_count": 102, + "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Total reward: 13.0\n" + "Total reward: 27.0\n" ] } ], @@ -238,7 +299,7 @@ }, { "cell_type": "code", - "execution_count": 79, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -270,38 +331,56 @@ }, { "cell_type": "code", - "execution_count": 73, + "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "0 -> 44.0\n", - "100 -> 105.0\n", - "200 -> 145.0\n", - "300 -> 70.0\n", - "400 -> 190.0\n", - "500 -> 298.0\n", - "600 -> 289.0\n", - "700 -> 499.0\n", - "800 -> 499.0\n", - "900 -> 499.0\n" + "0 -> 29.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2022-07-24 16:50:51.475024: W tensorflow/core/data/root_dataset.cc:247] Optimization loop failed: CANCELLED: Operation was cancelled\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100 -> 135.0\n", + "200 -> 484.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2022-07-24 16:51:35.910774: W tensorflow/core/data/root_dataset.cc:247] Optimization loop failed: CANCELLED: Operation was cancelled\n", + "2022-07-24 16:51:37.151017: W tensorflow/core/data/root_dataset.cc:247] Optimization loop failed: CANCELLED: Operation was cancelled\n", + "2022-07-24 16:51:39.284311: W tensorflow/core/data/root_dataset.cc:247] Optimization loop failed: CANCELLED: Operation was cancelled\n", + "2022-07-24 16:51:42.235074: W tensorflow/core/data/root_dataset.cc:247] Optimization loop failed: CANCELLED: Operation was cancelled\n", + "2022-07-24 16:51:44.691458: W tensorflow/core/data/root_dataset.cc:247] Optimization loop failed: CANCELLED: Operation was cancelled\n", + "2022-07-24 16:51:48.381946: W tensorflow/core/data/root_dataset.cc:247] Optimization loop failed: CANCELLED: Operation was cancelled\n" ] }, { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 73, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD4CAYAAAAXUaZHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAABJLklEQVR4nO2deZgVxbn/v+/szDDDsAz7sMmOyuKICoiiRFBMMIkYk5iYq8bcBJOYxVzIdnNz471m3/WnWYm5RknUaGI0UaJGjQZxQUFlERAGEIZ9n2Fm6vfH6e7T3aequ6q7us+ZM/V5nnnmdHdtvb319ltvvUWMMRgMBoOhuCjJdwMMBoPBoB8j3A0Gg6EIMcLdYDAYihAj3A0Gg6EIMcLdYDAYipCyfDcAAPr168dGjBiR72YYDAZDl+KFF17Ywxhr4B0rCOE+YsQIrFq1Kt/NMBgMhi4FEb0lOmbMMgaDwVCEGOFuMBgMRYgR7gaDwVCEGOFuMBgMRYgR7gaDwVCESAl3ItpCRK8S0ctEtMra14eIHiWiDdb/3q70S4loIxGtI6J5STXeYDAYDHxUNPc5jLEpjLEma3sJgBWMsTEAVljbIKKJAK4EMAnAfAC3ElGpxjYbDAaDIYQ4fu4LAZxv/V4G4AkA/2Htv5sx1gpgMxFtBDAdwLMx6jKkwJrtB9HeyTClsR4A8LuVWzF2QC3OGJ75KGOM4Q8vNGPhlCGoKMvVC052dOL+l7bj8mlDUVJC2NRyBLc98SbePW0Idhw4gXdOHoTKslKs3LwP9dXlGDug1pP/dyu34tk39+L62aNw74vNuGjiQAzqVYVHX9uFD88YjsqyrI7w51d2YNehVpwxvDdefGs/ykoJdVXleG3nIZw42YHB9T3QNLw3nljXgiOt7Zg4qA5VFaV49s096F1dgR0HjqNXj3K8fegE+tRUYN/RNvSursDOgycwbmAtJg6qw8ot+3Dq4F44dOIkXt1+ECP71qCEABCho7MTNZVl2LLnKAbWVaGmsgz7jrVh75E2jOxXAwBobe9ER2cnyktLsGrLfvSqLkddVeaVO3GyE429ewAAdhw8gd7V5dh58ARG9qvB5j1HMbp/T8wZ1x87DhzH4dZ255r6+dPqHXhk7dsgAKP61WDTnqMAgOqKUtRWlaOmohQgAnyhvVs7OvHajkOY2ljvOd7WwbDr0Amc7OjEqIaezv7mA8dBIAyprwp+iDh1AcDxkx3Yf+wkBvfK5H/70An07VmJwydO4siJdgzrU+20q+VQK4Za12bTnqMYZV3PXYda0bOqLHNOAN5sOYpTGmo86TbvPYbhfapRQgARYUS/amxuOeo99/ZOtBxpxdD6Hp79e462obyE0KtHeU77Oxnw1r5jGNm3GgzAZle7AGDnwRMY1qca63cfcer3t7+yvBRnj+qDl7YeQL+eldjUcgQAMHZgLS49fXDwdY2ArHBnAP5GRAzA7YyxOwAMYIztBADG2E4i6m+lHQLgOVfeZmufByK6HsD1ADBs2LCIzTfo5NIfPw0A2HLLAhw8fhJL73sV1RWleO3r8wEAD695Gzf94RVs2XsUN80bn5P/jn9swrf/ug4EYFFTIy747pMAgN+/0AwA2LDrMJZeMgFX3P6sU4/NgWNtWHrfqwCAB1fvAAD86pktmDm6L57ZuBdThtXjzBF9AADN+4/hhrteSuAKZHhyfUtiZavwg8c2eLavaGrMSfPJ38lfB3L1Dbb8fWrDHs9xmeUdKLeP8ZTJSyNbrq50/jS8c3fv95cn235RW1TO5dLTB+dVuM9kjO2wBPijRPRGQFrerc85TauDuAMAmpqazIohBUZHZ+aWHGvrcPYdPH4SALDncBs3z76jbZ50flqOtArrO9nBfwRebT7oaQ+Q0byKgbs+ehbqqsqdTjWIQ4Jr6qaitARtHd5rc97YBjy5vgUXnzoQt111hrN/xJKHPOk+cNYw/M+7T8vZf9HEAZg3aSA+9/vVAIAfvX8q3jWZL4hu+v1q/P6FZkwe2gsP3DDLc8wu96FPzcKDq3fg9ic3eY7fee10nDumwUm3/GPn4OkNLfjR3zfig2cNw7/NHIm538soC5v/dwHufHYLvvLAWlx5ZiNG9++Jbzz0ulNWj/JSvP7f8zH2yw+jrb0Ts8c24DfXTM9py70fn+F8le450oqmbzwGAHjzfy5Bqe8raeJXH8Gxtg7c9sFp+N+H38DWfcfwnUWTcfkZQ3HbE2/im49kRWJtVRle/do8XHH7s1i5eR++9s6JeGX7Qdz34nZPmeMH1uKRG2dzr6UOpGzujLEd1v/dAO5Hxsyyi4gGAYD1f7eVvBmAW8UYCmCHrgYb0oG3Qpf9uLPcvtqXN4n26C9TlYF1ISaJCIi04Nx0Egk5Sco4phwVSnz1xivNLiO3lNKQ8/MfHtQrY1I5paGnc238aexNmWtAgt829vMne79kkLqnMQgV7kRUQ0S19m8AFwFYA+BBAFdbya4G8ID1+0EAVxJRJRGNBDAGwErdDTckC0+Whj2LyT6q+eXej8/A5WcM1VomgXKEpwgZGc1LY2ugUe9dSYk3b1A5cv0PP5F/PIEoWyBRbvsunNAfv/q3M3HNrJHOeed0RNamSLh7z4u4+3ln4P8l6lSyx4l73km/LzJmmQEA7rdOvgzAXYyxR4joeQDLiehaAFsBLAIAxthaIloO4DUA7QAWM8Y6+EUbCpUgTTlMiw7T7KO0w11mPjqRpJQsac1dIg1P+y0rlatA1A6/UBIJZ6nCAg75zSAEt5CkHC2XiDBnXGaYzxbqpUTo8Dwnmf3lpXwd1l1iiUDQB7U/7N7ZLSHipy1JeJZRqHBnjG0CMJmzfy+ACwV5bgZwc+zWGfIGT0DbL4tIdIsGp3STDwtNCZF2AU+Uq20K65cxLXDKKrUkSJhQFh33C6ZAzV1C8Ivy87RuT70BZTqaewkAlxpp5/d3HNnjbi1cshN0lev896XhfvVy9+XZLGPopsg+oe7DFCL8IzzMLOdHfkjiNXRrp6FpJToBXopySZt7kNB13zeZ0qJcq1wBnK1XpPk6KV2aO68doq8XEm4E1+XY3yN0CG5iDoeEUhDx3A2Fh1uWdnYyvPvWZzDAGlAUuoWFlqkuoYMGdtOEZ/fVVa5UuohlOUIzos09x56ckM09RzDnaO7iwu1zzLXbW2YZgf3DXb6soOVq4EKTVjYBt/0JD6ga4W7g0ukSqkfb2rG6+SCAgwDS9ZZhvv/5IolPaKJcW7IIGfMNz/xga61RW59rjopuegk65pe/7q8axoLLDBtQLRVq7q4vEsn7IGOictrt2s6H5m7MMgYukQS0bXMXiOKkbYxJQqI3NGaZ8mYZmTQ8m7us0BLb3GXbIeutac+AdiPbTn69xC3D3hKZpmRt+qI82bzROryk3wYj3A1cAmW70CwT5wUVVMW8//NFUl/QOl0heUnK7AHViCeQ6y0TrR3OMQLmnzowZ3+uWYaktGQgew1zNXdb6IeLOdn74G6XyL/e/6hmjueWL1tnVIxwN3Dh2bqdY6F5NbaD57WT8EvBQ2A1jVmmis1dRjvkmGViD6j6vEoCGyx/hYb44rrk2MshX6+d1e/xaGcpF5llJDsPf7uyA6qyefieVkk/xka4G7hEEdBJPqw6feejkJifu6zHhUQy7iQmSZu7cHIReY9Iae4SHYDfg4U3oJqbi49tjlH1lomCzGQn/26R+S3vM1QNBj8irZ5CjkerS1tRsUjKz122TN4nvP8689LE1dy129xtLduXONdeLm+WyZpH1Mwy7m5L2iwjlYqTz9jcDYWCW2745WvYJCat7eC0Jx8ko2TJdxg8+XT/S95AVHxXyBLhMRn8tm8ZIShjuPGbYXjhBzx+7gGlZs0y3jR2sDmpAVVZs4xnEJbfqWSPZ//z2m9s7oa8EMcMkm9BnASiFzQu8hpjbrrPLl8dWpYt2NxRNfnli9rnqztIgw6swUojmHDEC51g7wp3hSSnrW7scy4ThR+QOy1vHo/7JD+N331X9IVmbO6GvODR3Jn4mJtEXB2Z559Wbv/QGeGJLFRMKEmUqWLycGPb3EOFu6D8KFEhpcYHcjT34DKCigzT3IWBw+L6uUu0zZ/WjdHcDXkhSBSEessI9kd5lvkxbvRQz1lxR4z+F1Hla0BG+ATZ3MOFu9h04TVfiNsh6+cO5Hq2cDV34Ya/Xtu27hPuzNbcw80yUWaoSg+ogj9ZzWjuhrzAgozuAhL1lknA1iMTjMtJS8kMgMWZ9p6TJsDm3h7ZLCOvuTs26IBUkQdUg8r0tdVWCELNMp52Rb8RoVlFnYDR3A35gHl+ewVDuLeMxnYkaL/3C1YZjwydkMhHjoPMJzwvjXT/JRRActqqLLaQVhlQBSQncfkaF2qWiXAuMo6hOZOYBHUlrLgb4W7gE2hzF2XyaU5a2hFWZyx8AibI5IAEbO4hdbqRE27x2sMtU0WDljBCCzV3jp+7rDnIKaOE30axO6j6BfPGfZcvhe8to1y9Eka4GwQwzi/JnFo19+RU9xzNPSBtcpOYJNNF1NzlFXd+SpWvGxX8beWZZdx1ylQrWqpPuFhHFM3d5RpKrn2eNAF5/PuTxAh3Axev5i6nulPwYen6+AkiFBqCX8AEadGZSUx6X8aMdipXppQHSgwBIvSWKSG4xVWwzT08jQj+Yh3Wl2CIK6RThkAVFi7WodZEp13Z9VQlr62gLqO5G/ICE/wOIslJTEkgChGbJloHVGNYcYMMF57rEtfmLsjvN53kaL8SFYs1d303lncpwp4bscur0dwNeSDY5h62iGqERTkEZfLWUNVFji+1hK1Ya/3QG44saKJMmHlL6NaXY3IIsrlTYFm88mz4A6qeikMRfXmVCRfrUL/2Mln4i8sbm7uhQGAem7vfW4afJ3ydzsLC/74FDqgm4i0DkOQbKNO1JWVz92ircTX3nB8BaTmDl0GIIvuKF+uIgncsIKgct2bPS2P83A15gUWwyzhaYqQK5duT1KBesM09Ke1dH0FhyyPHc/eNC2gzD7nu503zxoWWIlOv6P7JLLMni0yH4x97IvClu5mhasgLgYHDwgZUu0hsmSgTdJJugwiZaxq0TmdUs0xOBxjTlsCrZ/Gc0dx08nHkvfi/NMULZEcwy/DyS7SNV5fR3A15wWOWUbS5y9rHO0NmTXrKTMRbxrsdZnPXLeDFA208wi8A11tGti2i/SSvQZOErJMOt+ArTyZXRVlGnF19zgjPfq2TmLxO/5J5ROMhyUp3s0C2gUsai3W0dXSiqqQ0U596dUq4Xdiy+/yDeJnt04b0wqvbD3qPIblBVRmkNPc4DRTk9e+NbXN3DNFh6bIJZF0hy0pKsPHmi3NcH0XhB6LA6+j8TeMOqEru04nR3A2hyA6oyh63aevoVGiDevlueG5yfoXO3uaZHhIZUAV/cgsPuQFVTh2y2qWwTH8bAwadrWPBmnu09sh2gmWlJTn3Sqfmzh20luioeGmMzd2QF6KEH1AVgG3tWeGetJ2eJ7BFA6oiz4YkXkVp4S5xffjeMpJmEKHNXd1rRQcqbqphiKNCRrC5e66F3NdOZp+xuRsKBK8rpGpeOdzCPbRMFr09gJxWa2/HsV2rQKQwoCpx1kF+7lHJuUYSaQM7lJQ6BzdCP/eY5WbNMsEliUx6RnM35IWg8ANCbxmSO25z0mWWSXoBbH7ERL7Nnf/pndAaqpJpI3vLyLZFkDczoEqebXEZ0esJSxdLc9c6oKqeX+jnrl69Eka4G7gE27hFIX/JOionqJU0d0971DsCGVupY3OPMRlIFZ22fK7mbv0Pu2KBrpCKDiJhXkcy5eR+MUS/TqLYMlHwdHQSYwxOOoHCkCRGuBty2H3oRLxojJJZWyPa3KO0jPca5fq5iyVPiU+D1QGBpKegy5wzT4jFH1CVL0+mLpUr6Jg9+LLRYUBdFQBg4qBa7nGRb77K/ZRx8wzMH1BmUhjhbshh+v+sCNTcZc0uYZxU8ZaJabWRsXkG2dyTUN39E3WCSDL0sd0W0X73oaQmc/HqdWL5s+DLP7mxHvd/YgY+PXcs97ioA1V5XrORIHPzy3yF8J8/+fqjIC3ciaiUiF4ioj9b232I6FEi2mD97+1Ku5SINhLROiKal0TDDcninaHqs7mH5ZWsw+MtI5kHiOqDz7O5C9IKPBvS8hSJCu+6xF2j1R/qOFhzD69LPgQxfzxExNRhvYXmF9HAZZTb6XZflc1PEDxTCXeUKpr7pwG87tpeAmAFY2wMgBXWNohoIoArAUwCMB/ArURUqqe5hvQQz1AVofqoqvi5x53mpKKN85wrkngNVcqUm8QUsxJumeoFyAy6htupg7fV2iNZiWRZzr0QmGr4USFz9wXFAtKBVPFENBTAAgA/d+1eCGCZ9XsZgMtc++9mjLUyxjYD2AhgupbWGlKj06O5ewkzEciaEDx1KKnjegZURRqdSto4KJkFIrpCxoXgM8sEae4y5Sl4mETJx0OsuUfouDj5Q10hSXRtCkNz/wGALwBwq1oDGGM7AcD639/aPwTANle6ZmufByK6nohWEdGqlpYW1XYbEibQFVKQJ8wVMreO9CKMxfUzzrdJJuqlkjYdiL5ifOYomWsWlCKqKSKOZ4lQuEfS3MNNVFwDTCHa3InoUgC7GWMvSJbJa3KuMx1jdzDGmhhjTQ0NDZJFG9IiyqShrCukZB2e+sLaI5+Wj7zNXTTTU7/rmt7yuDZ3WRu3oC28RTQCCtGGTnu0aIWmSDb3CKYv0cB50gqDTOCwmQDeRUSXAKgCUEdEvwWwi4gGMcZ2EtEgALut9M0AGl35hwLYobPRhuRJw1sm38guCg0EfVqnQ9IfOUFaKM+3O0pZToES5eh8lkQLokQaTxD8jkLeZ6gyxpYyxoYyxkYgM1D6d8bYVQAeBHC1lexqAA9Yvx8EcCURVRLRSABjAKzU3nJDoniFiaK3TBTVXSFpJD93nsBWeOkTsWcr2dyjlWfvCrsnwjFHgbsov4yYgl+iPVHQ6i3jMcvYNveQPAi+N0kRJ+TvLQCWE9G1ALYCWAQAjLG1RLQcwGsA2gEsZox1xG6pIVUC47l3ldU4XKh8TfNjy7hc4EiPJq3mLSMTz11/p+SPCik1aBrxWLSE4ejwc3fySOT/9TVe/xF/CAf3/iRREu6MsScAPGH93gvgQkG6mwHcHLNthnwS4C0TnlUuR1AHkpM2ps2dqzkp+Mj5BxU7Uu7gwmqb0liPgdZMTR6hrocBAlDaW6ZAbe46zR+8js79HN00bxymDevtzQPR86etWVzMDFUDlyjx0+2HXHYB7TTlI38SCR9RVEhy/dbSJo12mavOHi6ow8oeapaRHX+QMb2I0zimjIidTRT0ukIGe8vIe9AUgM3d0D1JQvAyMHzv0fXCY2F5ZdPyUHGFDPNz1/VSKpllIk7iih/P3au6x/Zzl2qNbpu7vkrCbOd8j6X82NyNcDdwCRKmIsFv24VF9uHdh1vxoxUbQstJAq7N3bXzz5+c5fzmzlB1u7MVoFeQ6NM/Lv6AaYH2dInLkw+PKp1+7r4SpMrJ9I8chSFhR3cj3A1c4vuVB5cJpOvnHmYCOXVIr2xwqJDBL13vpJJVRuGcG2orlesQXR9/vJa4g4DOXIgwM1FCdnJvW9RxC2R5zx/+JCajuRvyQqCfu8BEYKfrKr40qjFHsppp+uqnzDW1r/9Hzx2prV6/SSHYE0ZOk5WqN34R2bKEmnsUm3vu76jna+K5G/KCd4aqpFkm1G4eVEdIeyTqD0LG5m5vhtnUtWnuCiIsXNONVm42D5/SEm9pceWR251UJl2SRKnCc50VnPbzMUPVCHcDlyjCNGvWUK9DBV0DqireMu70ujQuNWeZaIHD5EPs8vcLFzQJLCP+9Unj6yianztHSIfNtoXIW0a9fhWMcDfwCZAlYs09RnWaIk2KUJlEEqa552NQUElzlzSjePIL9qvEc5eqJx/uMsIqInzhRLi2/nw2opg3ujDC3cAlcIaqovlFmC6ivNY2iUmUNqSQfDjLqNjcoyDu6MQdR04ZUmnifUnoRNcM1XATE3HvjfGWMeSFoJWYZPIo1xc9qxS810g8K1MwAGf91/VSpjGj05nEFLEtueMS6Zx7PjpQKSKMbQjHM4zmbsgHQa6HYQOqCsOEqs2KDH9AK1ggCsvS0SAXf1w8E7+5JmQ9G4meM6tJuswoMQVQSQnfQySoAYEeNQUrteUIm6HKzUP8J91o7oa8EBSFUSRmVDV3Fd/12AtkK6QNCzSlbYaqVc6UxnoMru8RmDaq5u0cV2iXt1y+R1FUpE3uKfQCkcwyEQeteWNGojVfdWGEu4GLx01R0ywmfeVEyKTwHqUVa1zFxVDlnHnlhmYPMEXJullK2dxlvXekUsVDp8toWD28+2fMMoa8EBg/PST8QJQ6wsRP1NgqNkqauyjOuzNJR/9LGVaizLXlxjWJWX/mK0Wjt4zzP/8eSVHqcH+1yUajIAI3imjSZpk48dwNRUygzT1khmqUOpTyRfJzl3+RwtImEX4grE6VM5b1bhHlCdqflj09FT933/ZfPnUuKsqC9d0ok8UIQCdPuCd8ikZzNwgI1N218P3H1qO9I7PmeleyuScheMI1d4kyYjRLHPLXFxclruYes7PRib9DnTi4DqP79wzOw/mKkWlrZ2fuDUz6FI1wN3CJEqhLVf5u3H0ED726UzGXPj93YdqQ1y6J8APxJwe5PWS8tQDhZp2g4Fpe2R5kcw8/iTQGSmWJ1JIIX0UgwNJhUsUIdwOXKHq7LT92H26Vr0cy2Fh8zV3FLCMqwz6uy1vGXXZ8s4wT/kHrjNJkhHEhyHht3jKh4QeIa5ZJGiPcDVzi+Lk/vOZtbGo5IlVPWan6GxbJWcZXzT3Xny1MGxo4LIG3Jtxbxh+8zbsdPqgXJoDE7YobnyYK+TDLSOXx/JbPb4S7oWDwhh9Qn6G6bf9xqTxlkpJS96sRvBRc8H5dNneZUuqry+XL49iA7Z9RzTKZxTok65dMJ1dWAaj2HKJ8FRHxhXvS4t4IdwOXIFkgeqjdWWQ1lfJS2yYs2TDo85cXkVbIXxn5lRXO3v3+bdVQCrn18NPly3xSCGYbHlHHlvNhczeukAYugTNUJaao8rwDePl2HWrFiCUPhbdHIfY7D1Hsdn5a/v4k/dzFbbE6P9dZX7fseTQHfBnFHSj0786Hh0uByvZIbqaM5ccsY4S7gYt3hqp6/g6OcOfx0tb96oVHQMlbJmREVd8MVRnvksx/xoAn17fgoVd24LHXdyvUES8dEeXFRFJIXjViFGzuku+DToxwN3CJFBXS9fuBl3fkHOdpL7IDqp4vCQ2ukIGTccLKUq8+BpnafvbUJuw50haQiq9SxveWUUmr78roKGnqsHq8tPWAhpLiIZqhmjRGuBu4eAS6rJ+7K13z/mOSNaUjKtVcIQX255DjqsgUY5uIggS7nrZITmJKCR113v+JmfELCUCljXmQ7WZA1ZAh19XO9Vu2DFdK3lco7wGXHhxlwg0pcjT3CDZ3p3ZNb6qMbIhi7ybB/iht6QrGkTQY1qcagC+2DCed6NngmSmTFvhGczcAyH3QvvnIG87vtw+eUC6DZ8rh7UtroElFSIV5nqSphamEF85OYsrui7vykb/+qvJwfVDH9Sk0m/tvrzsLL7y1H1Xlpc4+lTbmwyxjNHcDgFxdeNeh7CzTz/1+dWBa3v5OjuvXc5v25eyTHWcKWvYvGuIXM0yg6uqQZIRDWj7mQb797mO1VWK/+wKTx1ppqK3E/FMHevbxTld0T5N23+VhhLsBgJ6Hz12ErACU9SL4yeMbozQpi4aokPZeXY4PcmYZlXbb5QpsNIFtCfdzH9o7eEGRpDl3TD/cMGd0XtvghndreO8RY/LeYzoxZhkDAP2z5WT7CtlOYNu+rF93pPADGtPGjS2vgq746bJUlZfgxMnsZ5fSQHTCFvo7rz0r0fKTJA+y3Wjuhgw6vhq9A6qSmntKD71/kDR4taDg/T0r5UMCBCEjuFUGVHk2d9W2PPqZ8zx29ZKSZMwthWZTTxKi/Pi5hwp3IqoiopVEtJqI1hLRf1n7+xDRo0S0wfrf25VnKRFtJKJ1RDQvyRMw6EGLNhrBw0bVfn3Bd57Atx9Zp5QHUDRvhGigA+oq8fCnz1Vug2o9smkC8ysK0cY+1bhwwgBnu7KsNCC1vy6lqroVhTqg2grgAsbYZABTAMwnorMBLAGwgjE2BsAKaxtENBHAlQAmAZgP4FYikn9CDHkhSmyXlZv34dt/zXrVeAdU1Sc+ybBpz1Gs3JI7MKtKFDmUtWkDEwbVxW6DDPJxbMjTPlV4ncCccQ0Y2a8mUaFdW1X8luFM+IHsdm1l5pxt98qkCBXuLIMdv7Xc+mMAFgJYZu1fBuAy6/dCAHczxloZY5sBbAQwXWejDYXBFbc/i58+/qaz7R5MktXI0/Ii0OEKGUa/npWYNbqfQkUybUlrklcu75k21Dom6U4Zod4fvX9qhFyFgcqjO3dCf+f3VecMx/2fmIG5EwcE5IiPlM2diEqJ6GUAuwE8yhj7F4ABjLGdAGD9t1s/BMA2V/Zma5+/zOuJaBURrWppaYlxCgYdaLG5e7xl5PLwXCaTIHcSk1gUiSf0UGhe3YOtb+09KpVOFNBK2pVSQx+ittpV94EIWDhlCK4+ZzgAoKyEMHVY75Bc8ZES7oyxDsbYFABDAUwnolMDknMnbnHKvIMx1sQYa2poaJBqrCE5dAglbyRJ2QHVtDR3dZdCm1995Ezu/rB8KvUM7d0DH5kxAu+e6tWD8uFl4cfY0vmoXpdKawJUadIrY1soecswxg4AeAIZW/ouIhoEANZ/O1RdM4BGV7ahAHKjSBkKCt0yVlYjT014+TV3yWzjB9Zizvj+nn26Xk1vmADC1941KXSBZpmyouVX/5JRKcOQ9XUvKxThTkQNRFRv/e4BYC6ANwA8COBqK9nVAB6wfj8I4EoiqiSikQDGAFipud0GDbS2dzi/VWXs/S81O7/twVPv0nxd2eYe7eXryqLNaOfJYwv30iTWaeQgU8sgAI8T0SsAnkfG5v5nALcAeAcRbQDwDmsbjLG1AJYDeA3AIwAWM8Y6uCUb8sbf1r6NcV9+BGt3HASgJmTfPngCn7knG5JgyX2voLW9wxsiQLKs1MwyCn7usmX1KI/nBFZIvt5BLUl0sY4CMDulRdqae6gfEmPsFQA5Q9qMsb0ALhTkuRnAzbFbZ0iMR1/bBQBYu/0QJg3upfSOnWj32lyWr2rGrDENkcIPdKT0csexuWf3ew/86ZOzMPd7T3ryqfRVOl9xIoplWku7nymgfi01bF/3kkIxyxiKk5PWoo7lZZkHTUUw8AS3/3mVDgiWJ809MK3kch29Qxav1jHRSRfhlzlQd9fYkvzz2Gdn47YPTku93s5C09wNxcnJDvtBs/p3FeHOkdyrtx3w+rnLTmJKS3PPGVBVf8H8OfyavL/MnpXBr5fuNUd55aXt4ggUvqVldP9ajO5fm0jZQc9z1uZuNHdDgjiae2nmEVBxheQ9wD97arOnhL1H5VYOUrG5x9HydZhlZI93RfR0AuqFpBmELd/YZhkj3A2JYgv3Ck1mmaioFBUnbKrKgKpwEpNven+uJi9fRya/vpc8yeiRSYgiUZnnjS2+OS/2M27/L01JOzBmmW6KbZaxNXcVREGQosh8lY7iO39br15BBOK8e+7TCdNkC+kLIHDGrmRDdZzOz69uQqs1YD+wrgoAMLxvsjFYoqL6vNtfnmnddyPcuyltluZu29xVnlORAh3lE1vlBfn1Pzcrl2+jIypkNvwAPP+zx72k9PWdqTtBzT1NyktLHIXjHRMH4LfXnoUZp/TNc6viYd8b5mwbs4whQdot4W4LIBV7tiht0pp7nDg0Mq/TpMGZSI8y64SGseD0QaEDqoVEFDOVShkigm4/EWHWmH6puQ6qojzQbJ1rWqfTdZ4+g1Zss4z9bqnIZZHtO4pFXEW4x4mJLWMP/+GVU/H6zkOe9WN5eRwNPkDsfXD6sIIyy8QZuDSLdejBvgMqi57HwWju3RR7QNU/2COD0CwTSXOXTxtrQFUiTU1lGZpG9IkszIjII0TTFl9R7qWNFm+Z+EUUNWnb3I1wT5kVr+/CPkk3wSSxbe62MNLjkhbF5p7WJKZgn3TvsbCy5BKm6S0TRlhdwddDckBVQWqldd+ToK5HxuChqoGnbXM3ZpkUOdLajmuXrcLkob3wwA2z8toW5rfH5Olda08pLKSO10lGHun0p1eFN9Brtye08w6yuRuV3MPPP3wmHnp1JxoVV1KyO7S0bO5Gc0+RDsvOvXmP3AIMaWDLVi16e4RC4phaVFAKPyCpkfPSec0y+ZeKsl9kOlqqdo3zf22iMrBXFa6dNVI5X3ZA1djci45CnI3nmGU0r8QkS1rC3S++gt8v/sGw++cpk2TMMoVD4OpShffYFixBl8q+jmndd2OWyQOFoLXYn4jOIJyWlZjUy0hrVXitmrvjLVP4pGvXF/Pty0/Hi1sPpNWUgiRt5c4I9xQpRA3IMbkXueYeFirATYVg1m7Y+fnLDPv8LoRO3iYw/ICGZi5qasSipsbwhF2coEvlaO7GLFO8FNA77fiZ58dXpjBt7lVhi3A4NvfcQr3hB6SK0UbT8D4AEGmpPi3PZJTAYQWo8CRF1lsmnfqM5t7dcXyjNZhlClhz9xNkruhRwRfuYS11l0mg1AbObBY1DcXMMf0wpL6Hct60B3/fd2Yj/v7GbkwaUpdqvfnE2NwNqZD1gNQ3oBqF9Mwy8q9UWPgBGTd3BibvL68JIook2HW1RaWIeZMGYsstC+JXWmAED6jak5iMWcaQAjqFeqQB1TyZZYLeL9HaqP6XM6zMcJfKwrHPFU5LihfHLJNSfUa4p0ghmhfjTFnPLUw9S1reMiomkrgLXwOZL4VCEt6hl1mH5l44p1uQmPADRYxzc/PcDjfZAVUdrpDqpGZzDwnP66ZSqLl78/pNPYTC7MANhUHaA6pGuKdI2rElgsj6t3u345WpXojsWqtpoiPkb6GRRpybQpiRW0hUlmWeI/ur0bhCFjGF6PblF/KxyoqQJ7VJTAppK8tKcdmUweKyBOEHiApXvKn66Bvi891Fk3HDnNFoGt4bQPYr2djci5BCCj/AXP4yQP5cIeMswKFCTlTIkDfs+tmn5OyTuX+Fc4fVyJObe1HTv64Kn583LmexEaO5FyMF+ObrDBwWrf7C09x1lKXz/e3Xs0JfYQJ0CBwj24NJ28/dCPcUSdsVSgad3jIFbZbJuej6Z1MmdV/vvv6cyHlFMvtj542SSmfQh/3lZwZUFXlyfQv+uXFPvpsRSFo29yvveBaX3/ZPqbb4zTNxiGLaSeuaaNXcBX7uSZFEPZ84b7R0Wtl7ZDqIYLKau1msQ4mrf7kSAAp61ltaNvfnNu2TTptvzT0tVG3uPKR8xRO4CGmIAp11FKLjQCGQ9ZZJp76i0dy7Ap0p31wZtC7ElMBLPaCuUks5Sdjc4yzVp1RfCg9MUBWy1Reur1B6BHVsxixTxBTiupH+uO79ekYXpkl8mWgTGAqTmESoTPLUeSV0LMsW/ugZwZw0nSmbZYxwT5FCku1+c4wOrSKJ89Ol5Wh9oQR+7kmRhjDQE/JXQxndgILR3ImokYgeJ6LXiWgtEX3a2t+HiB4log3W/96uPEuJaCMRrSOieUmeQNekcN4Cf1TItBbvTRvehCNVwr683GXqNctoLExUR/JVGArQFbIdwOcYYxMAnA1gMRFNBLAEwArG2BgAK6xtWMeuBDAJwHwAtxJR/EhMXZyDx08WlOZu49fg48QgT0RzL6Bysq6sJCyzkCaqAekKbdNBBHfEzgzVQpnExBjbyRh70fp9GMDrAIYAWAhgmZVsGYDLrN8LAdzNGGtljG0GsBHAdM3t7lKs33UYk//rb7hn1dZ8NyUHv1kmjnDf2HJER5M8qLwIt7zntIByNDQmZEA8qVfWP8NRBVFXU1NZikG9qpztQoh3VAwED6hmKBizjBsiGgFgKoB/ARjAGNsJZDoAAP2tZEMAbHNla7b2+cu6nohWEdGqlpaWCE3vOmzYlRF6j79RGOe5de8xbD9wHEBGmzje1oGTHfE1zo279Qt3Fa6cPkx4jBfBMS5pCcQkaikrLcGzSy9E35oKbXWYDiKYtKPCSgt3IuoJ4F4ANzLGDgUl5ezLkRyMsTsYY02MsaaGhgbZZnRp0u65t+49xt1/6Y+fcn4zABO++ggu++kzAICSIhliv2neOM+2zmtOvv+8OqIKulH9anLri9F22axGLidP2lFhpV5lIipHRrD/H2PsPmv3LiIaZB0fBGC3tb8ZgHuZ86EAduhpbtcm6Z67rb0Tv3h6s7N90x9Wc9MdOtHu/F7+/DbPMb9Z5swRvZFPor4HUxrrA8uJNIkpBXv6xacNwgOLZ3r2pbEWa5BHTn11OQBg0RmNwjSZMgxBpD3PJXSGKmW6mV8AeJ0x9j3XoQcBXA3gFuv/A679dxHR9wAMBjAGwEqdje6qJD2g+rOnNuHbf13nbJ842RGaZ9Vb+z3bfkGiw1yTD3LfH31vlDDkr6Y6Jvs6piSR+ZqsrSrH+m9cjPJSI751kNZVlAk/MBPAhwC8SkQvW/u+iIxQX05E1wLYCmARADDG1hLRcgCvIeNps5gxFi5lugFJa34Hj5/0bB+XEO5+/A9ee1oxeQVE1nJCNPUogjhf3k56QkPEK6SiLPwj35h2QkjZWyZUuDPGnoa4s7lQkOdmADfHaFdRkrRw8K9qtH6X+gCn/7lr16C5f/O9p+E/7n01Ut6o2nASA6j+snnxamTv8bpvzNfYougU4qzpYiU7QzUdimT4rGuQ9GvEW7FO9eX1m2XaNSyD974zxV4sSRFmY49mc49ev5/KsnSnfoR1kjqUSaO5B2NiyxQxSax+/mbLERw8ljHH8D69VYVzrs09v2aZqLQcbvVs65zCL3P/dCrEehYv55fhn5gVBxM4LBgT8reICXtF2zs6wQCUl8r3uRd+90kMqe+BZ5ZcwBUobe2dSuUlYZaJQ9SO8LxxDThvbAOeXN8SWM43LjsVtVVyr0ExWzCM1p08JuRvEeJoTSHCYfa3Hsekr/5VuXz3hCQ/be1qmrffjpz3AdWI+eqqyvGD900JLeeqs4dj4ZScOXbBbZJolM4X2H1bT2nI9YPXgTHLJE9Bz1A1xCO7+jn/7u44eAJtMcwgXOGuWJ5/pnuHBpt7vtAxqchNmHmEiLSNq4jWTVX2eQ9JXsxfI/kg6BlhIe+/boxwLyJ4L2rrSVXh7n3wbNk+c3TfqM2KRVJuY/GKTf7lfGbJBc7vHuXZwddS1TgzskvkGXt5ahjNvQjJh7dMW4ear7tfdtjaxtwJA6I2KxZx3gO3wNLxQqW5QLbbm6Z3TQXGD6zN1KFZMvAG+c8bmwkHMnZArda6ujudCThUBGEGVFPAFjJJ31ye22Oros3d3zi7w1DWGAuMkb6YLZHiuTt5w9OKktx13VmRruWUxnq88fZh5Xj7fSzzzviBdYHp3MVe0dSIeZMGolePcqW6TOCwYNL2ljGae4okbd8UecuoINLc8/bixlPdHa46a7i2hUhExRAB9ZZAFHkozRjdD2eNUjdx2Zdf1eY+fmAdfv/v5+CLl0zgHhd1WKqC3RDOjz8wFZdNGZzYoLgfI9xTJPEZqhq8ZfzCwy6xrItr7iUlhBmn9HO2I52NxA38zqLJ+OqlE3H60F5RahBiD2z7/fdlOHNEH4nwATr83A1BjB9Yhx9cORVlCq7JcTDCvYjgiZ7W9k68vO0A1u44KFVGruae+V8aUXOfOCjYHJAkSX1sCBfroIx9/JpZI7V/6Ty3aR8A4O1DJwBkYr3cdd1ZmD22e4TLNqhjhHuKJB3yl6e5dzCGy376DBb86GmpMvz2QLvNUVcD+s21cotwyQSm0knS4Qd0w/tymjG6H2IHatQ4scaY3AsLI9xTwFmE2tpOyn7NtRooSiT/YB9z9kdqkvTsWFt4fevy06NVxCEpWSMaEEtyoCznOmruaYxcLj6McE+R5AdUcytQjUtS5lMF7a+BqAtGyGazzT5+r5ak6Eohf4Hkvmx0Khzd1VdeNOEs3xjhniJJx3Pn+bmrRg/wa4i2QEt6NSDb7OO3PsRylkl5AlSSl0h1oYyPnjsS3100WTp99xTLejhrVF9cM3MkgHQXWgnD+LmniJZFFxjDmy1HMbp/z5xjPJu7apV+227WLBM1rroc2fILV8zkM/Z5meLitl9aMFEpvV6be/eLafDVd07Ev58/Cv1rq/LdFAejuadAdhJT/LIeeHkH5n7vSTy+bnfOMZ7s4Qn8IHI190z+yMJdUmrYXwY6PS6Dikpj0WmdJPXVp7PDKtxuOR0KSbADRrinjPqL9JU/rsGIJQ8522u2Z1wa/+1Xz+P2J9/0lc7R3BWr9H/+y7hCBi2iLa+5W+kL2OUi7FIm2XL/fdQt7LurvbyYMcI9Jis373NC7oYhK2jd2tSdz73lOeaWfbf/Y5PnGM++/sMVG+QqtfBPsIhrlpGlVEJz/9VHzlQqM6ifKERbfj7QGYa2iC5LUWCEe0yuuP1ZzLzl71JpbRPJ9gPHMWLJQ3h6wx5BOrm6j7d5g4I9svbtnDSv7zwkV5iF3yzTGdPPXfaFzw6oijPMGd8fX7lUzZask9DOWbN0G9WvxonG2f2s2Ia4mAHVFPG/oH9ZsxOzxvTLSdfe2YnSkvA1Nk+0q0V8lEFklgmS7UFCT/Zz3/4yCJOPKjbiwLojyOHLpg7B/S9tx3XnjlTPHIG/f/5853dSg7k6VweyB311rLtriE9RaO6FvoK7cP1KQbNlF8hw5//jS9tVm8VF5JURZHMPaq2qn3tYZ6AyQKzbTNCnpgJ/+uQsDO1d7dk/bVh9pj691Xmwz/ojM0YkUr4OU1O55Yuf76UZDRmKRLjnuwVyyLYzyupHN97zsnIeHuVl/Jc8aZu7Y5bxPZF+oWMvLPWx2aNi1adrAHHLLQuU3Q7jcM4p+Vk0RQb7qy/OamIGfRSFcFd194vD/S8144W39uXsH7HkIew/2haYN/cLg9/ufC5tVy7S3FMaUA27ldmY+Mm2p6YyYxZTmTGbZJP8k8l0PfL2V6WOpleU2pq7Ee6FQFEI9zRF4WfuWY333vYs99hb+45x99uyWradJxSXxtOJKBaMf0D1TzfMkipPdUA1rKPO+t3LlSsirF3D+9bgVx85E9+WmuWZ/BMYN8ZPGDo6JvvZOWnMMgVBUQj3NDX3IEQxz22BlOOrLGj2joO5rpW2f/v+YyejN1ACf2wZG7/N/TRXvPKgMQ9Z84d96cLCJdhKoUw4hLgCa874/uhZKe9zkOi3REJfLDpXB8oKd6O5FwJFIdwLRLaHIjvwu43zBXDpjzMhe//wQnPk+j97z8t4/I3cma1uRDFMgoSp/6yuaBqak2bRGbn73Nhmn46Qa2QfTzrWjQppPH92FUmdtx7NPVOIEe6FQbcS7i9u3Y8HV+9IrB0iFzD7y8J/2N/uqvLM7TjWpt/FEQDue2k7PnX3S4FpxGYZ+Xq+dXnWlGELjTDhYQutsPEGUTiEIfU9hHl4X1RJiMg0JjeVW+fy8fNP0VqujpbbE+CMK2RhUBR+7rJmmffc+k8AwLsmD06kHe4l7fYdbcOmliNoGtFH2Pn4XSTDBJwOl89RDT2xetsB4XHREmCqgatsVAOH+e/lzFP6YuPuI852NgRxNs39n5iBqcMyIRBWfO48HDnRDiDbedYomFaiEHRXPn7+KTje1oFf/3NLvDrsAdUSwpZbFsQqy1Ou/UOLn3umEOMKWRh0K+GeNG7h/v47nsO6XYex5ZYFrgHV4Hba75ctxP1eB+O/8kjsNtaHLHzs1nKJXLFlIn7jyWqzpYKO7cuXTsSyZ7MhGOxL4i7Xbao4pSEbLbOqvBQ3zRuHeZMGRG6XCrwS/2P+eACIL9w1erUkhR1z3phlCoOiEO75Eu2dPkHU1pE1p6zbdRhARljJDqiST8B9/c+veY63Ki52zaMuRLi7O0oC39br1xxl+tawATv7w8DfUctEqQyS04vnjA5vXExSsbm7NHe9BWf+6RhQtRUDI9wLg1B9jIh+SUS7iWiNa18fInqUiDZY/3u7ji0loo1EtI6I5iXVcDcsD8/S0dZ2HLY+/23aOML3ZEen82KGebnbr5fdZzyyJjdWTFwqQlRwd3/l1m6DlssLnKHqlBXcLscsE3IveWaZKIOMydjcEyjUX0dS5eoYUDUzVAsKmY/tXwOY79u3BMAKxtgYACusbRDRRABXAphk5bmViMKDpMQkLbOMW1Of+t+PYvLX/+Y5ztOs2ztZ1hwT5gppuwMyhv/4wyvYfbg1bpNzuPfFYG8bkV0/6jJvygOqYd4yHFfIAnKcSYxsDBjNrpAJTGLS/nVhiEToG8sY+wcA/5TMhQCWWb+XAbjMtf9uxlgrY2wzgI0AputpqpgwgaALtxcAT0t378sOLnUKbe7+bfuVaOvoxD2rtmlocTDVFaU5S7FNGlzn/HYL+jCNX4S0zd3R3Pn30nal7OSYZSJp7hrlTxqxjewakurIdHQaVeWl+PxFY7H8Y+doaJEhLlFdIQcwxnYCgPW/v7V/CAC3VGq29iWKSCCEsXrbARw4FhwywE17iM3AjqmxZvtBpyNoc5llwpppv2CHjrcHJxQwdkDu0ntBXDC+P97r8j9/5WsXYXRDLTdt/AWag4XHGZa3S/+6Smff99+X6Xi23LLAmSnKW7C7UHzek1zwgnHOWye6Sr3hgjEYN5D/DBnSRbefO+8Z4Yo0IrqeiFYR0aqWlpZYlUb1q13402dwxe38UAJ+9hxpxc/+sTkwja25f8YVxKu9gzkCya/h3ffidmzZc9TZtt/bQyeizUJVffH92lopkUeIu1sbZHOXGVEMa9riOaPxt8/MxqTB2Zmv756aO/GpT01mpfn66uzAcBQrgE5BnKaFWbdoLxBHM0MCRBXuu4hoEABY/+1pj80AGl3phgLgzhpijN3BGGtijDU1NDREbEaGOIG21u86wt3/tQfX4tk39zrbX/jDK/j+Y+sDyxIOqFq/ec1810+edn7bL+6h49GEu2pwL3/qEp9wdyOauRq1rq/6Ft0oKSGMHRCu8X3i/NH41uWn452nZ+cqRFFmE1mTNIUPiEKeoWooLKIK9wcBXG39vhrAA679VxJRJRGNBDAGwMp4TQwniuZ+MCBGS0cnw6//uQXv/9lz2LznKO5/qRlHWsNNJbZwd3c2JztYoHp0yPK4WbP9oBM35u2DJ6TOwY+ycKfcbVEZQTbZKGJy9tjcRUpkqCgrwRVNjZ5Bu3wve5emK6TuU3Vs+QXtQW+IQqifOxH9DsD5APoRUTOA/wRwC4DlRHQtgK0AFgEAY2wtES0H8BqAdgCLGWPJzKV3oaq5v9p8EO90acx+bEFeQsCF330CnQyYPTb868K2uZ902ebbOzulls2zY8cAwKq39odn4KBDc3ejU2jlCiV9wiSKNpuEQE5SPDpeLYn5QiZUriFvhAp3xtj7BYcuFKS/GcDNcRqliqpwX7vjYOBx2yxSU1nm+LKLIj66cTR3l5/vNx9+A+dJdAw6iPt+JunB5tcM3XXd9sFpscqO0m6dsj0RE4+/DnsSk/aokAl3Goa8URSBw8K8WFSxBbo73OvfQ6IpAhk/9+b9x7DDZVZ5fF2L9ILXaeM3Z9iCw21fnzioDmFIzVDNMQFld1x82qDwAgKIprnruyn9azMePlMa67WVKSIxV8hkijXkkaIIP6B75SLbW0UlljeQMct8dvnqnP3+MAJJoXoV/C+0LTju/8RMx0x0z8fORksCk6kIwP+7alpkt8+46HxiRvevxUOfmoVxEgPCUUk65K+h+Og2wv2wy70wLLWtuatGE2xr78T2/bkLbYTRvJ+/gpMqysqoQJt2C5DaqnLUVonj0ZSQnFmC15HMPzWexu60IYJdRrfN3e3CmQSO+UR3udb/fA9KG/RTFGYZGeG+zBWVL+zFtm3uypp7eyeOtalrolsFy/Opoi7b+S+0bHTfp74wByu/NFeuLp/wCPPOOH+c/DhFd5jtnvgM1WSKNeSRotDc3a6QjDGPINm27xh++vhGDKirki7P1vLtRZJlOdnRGemz+d4Xtivn4aKojoqa6l9ST0Rjn2ql+mTqBoD137hYyfMnks09b7FE46J7QNUq1Uj3oqMohLtbcz/a1uFo3D98bIMz8WjW6KxfddiLbfueV5XLCffvLJqMX/9zM462dWDvUflwBjZhwbxkiWtzd/Yrvum8PqVHeSmOnxR7wQZVoRrqIIpgku3ACoaEhbDxcy8+is4s882H33B+u2eUujXBrz6wNrA8W3MPWrHITQkB1RVl+Mf6eGEU4qJqRxZq7hrsHH+9cbbHxTHIWyYuqoLpPVOHoG/PyvCEBUR2slEydLW+zhBOEWrufJu3O02QjX75qm342VOZGDJb9srZwktLCA21+RcWdtwVWYQ2d8GL/o+b5qCyXE4fGNa3GsP6Zs02/rp0yhLVvujd0xKPZaedNCJPGoqLotDc3Tb3mgp+f/X0xj3C/O7p/kvve1W5fiJCQ4gm+BVfLBUd+IXa9983RSm/ra3dNG8cBrrGJEQ27GF9q7ljF9H83KWbGUp3cA80Xi0GVYpCuLs18eqKjJ1cZamvs/93BQDgwLG2SD7zJQT06xmsNb/vzMbA434umpi77qcf/6LVypq7JScWzxmN576YnXCcxmILOgVytxDuznJ4ydANLmG3owiFe0Zz/8nfNyqXs+Reda0dyAiXoMFXIqCac/zTF45BrcDdskwiCmNSK1CpynaZVuT4uatVEVx2F3iKb//QGfjrjbMj5086towZUC0+usBrEY47/MDL2/Zj695jeKX5gFIZj722CweOq3u6ABlhWBkg3Bnja8PXnTsSc8b35+TI1cp5xBfu/Bc6CU+SnCK7mVlm3qSBWhax8Avhry88FZeePggzR0eLsumUW/iX0KBIUQh3t+b++LoWzP7245lQuwpc95tVypOWbIgIVRFWKiohEmroMoHKVD0+/EWKqkjCrjuiX423Do3SvTvIJVE/3tinGj/5wDRUlsVbqrg7XMPuRtEJdxsVm7uNjLbMg7FgzV1ECRF3gQ8g3CzTt6YCk4fWO9vffO9pAIBPXjBamMc/6Ugkw5XNMhJfEB+YPgx3ffQsxwxlBlTVMJONDKoUhXBv4wjyKMI96qzFliOtUpr7A4tneraJgF2H+AtzlIUsSP2vL16IirLcNz3IR112lq4OP3c/RIQZp/RzhJNOgWwEXnyMF07xURzCnbu8nbqgbhVo0WEca22X0twnN9Z7IgeWEKFN0M4ws0xZaQl3XdMge7l/0FdkGknyRU/CE6c7aO42JraMQZYuLdw3tRzBdcue58Zaj6K5P7Eu2gzTD58zwrN949wxwrQdLhNGCfE7JkDOROQW7ragLg0w5+w94g3dm8QM1Q+fMzzwuN356AzT3C0ChyU8iakb9Y/dhi4t3Ns7GR57fTee2pA7QYlnqkmCZ5ZcgB4VpWi14qjMnTAAN84dK0zf2ekW7iTshGybu1vQVleUYvrIPs42b9HqIM3dXnhjRN9qnDe2AYvn8O3zUYXlw58+F19feGpgGltz1+nG2R1MCklPYuoO17C70aWF+9gBtZgsWP1GpBGrMnN0X+GxAXWVGFLfAwBQX52ZQDQ+xN3NPZuWCGjnCPflHzvH+d3DZUphDLjz2ul45WsXAfBq7vZ3tUjrPm1IL2fafXVFGZZdM11og0/SzGF3PjqFe/fQ3DP/u8GpGjTRpYU7IA7utT9CdEYeQeYRt3yaPrIPll0znWuSGdwrK0TdsduJ4y2z+j8vwvSRfZz9fjt5ZVkp6qzFMyo4NneRrb6+uhyV1qBvmGBVFe52e2TcN2+7ahouPnUg+tfKh2AOoztpnd3oVA0x6fLCXcTRNnG4WRWC7M9+EXne2Aaul8sNF+QK/C8vmAAAngHV04b0Qq8eGUFpT8yqDPDCKeccE7W3vYM5mn6YvVtVE/7JB6biywsmYHT/nqFppw7rjduuOiMRj5wwTmnI+NrX91AL01AIjB+U+SKM68/u56Z547SWZygcurxw/8kHpiZavg4hxHOxvGbmSADA/FOzMWTcsWFOtmfy8OzqNt4B1Qw9BIHT2js7s8I9RHNXPef+dVW47txRBa9Bf3HBBNx57XScNjTZJfGS4Mfvn4q7rz9bOX5QGIvnjMaWWxZoLdNQGHT5kL/D+9SEJ4pBkHCNYza2Bxa/9s5J+NjsU3DP89twzayRznF7oNX9JeDvJCo4bZs7gR/OoL0zq7l3hmjuhS6ko1JZVopzx8gv31dI1FaV4+xR4vEfg8FPl9fcRfHFzx0TL9aGDc/mbptULpoUHrkxtPzSEjT2qcbn543zaGW2t49bO/d3Ju7B5DGW/3x9dYUzyOumo5M5HVW7pBviPA3nZzAY8kOX19xFNmkV22RtVRkOn8gu8vHoZ2bjHd//BwD+IOF1547Cu6YMRp/q5Gy3tubO085tzh3TgGeXXgAAGNQrV6C7ae9gjrklTHMHgFVfnusMlBoMhq5H19fcBUK8R4W8cH/HBK+GOsY1i1Rkf+5fWxUaIgAApg2rx4LTBkm3xcaeYeuuo5YjbAf16hEq2AHg3LH9nK+QMJs7APTrWam8lqnBYCgcuvzbK9LcVaI07j3aJvRnl4mrHsR9n5jp+MADGZfJMRJeJScds0ym/qryEvz+388JyhLIF+aNh21h0jk7NJ/Yg9IGgyGXri/cBTb3iYPrhHkevGEm3tfUiA+eNQwA0HK4FaUCf/Zpw3oDACYMEpenwvKPnYNHP3teaLovXjIBZwzvjTNHZGakfmTGSIzsF23wmCjzBWIvQXjh+OKwpX/1nRONp4fBIKDL29x5E3kWzzkFHzhrGHpWlqF3dQWu+80q59gF4/vj9KH1OP3yehxpbcf//WsrPnj2MKx4PTc+DQBcNnUIzh7VF419qvHImrelzT0NtZWhs1WDmDCoDvd+fAZufUJ9RalRDTXYfuC4sz22f6YdNZVleG7phegbsiSgwWDo+nR54V5WWoJ3TByARWcMxfV3vgAAuGneeADAoqZGZ6Zqrx7lWP2fF3ny9qwsczS/JwVBw8otbxYAmH/qQOl2Pf+luWonIiCKu+VPPzgNL761H+eP649/btzjWQFoYC99M0MNBkPh0uXNMgDwsw834aJJfMFbX12OG+eOwZ9umBVYhu1yaA9+zps0ALVV+e/7zhub8ct+x0S+/zqPuqpynD8uk37G6H7KKzYZDIauT/6ll0b+uHgmeld7PUqIKDBKo01NZcbcYmvnt3+oSX8DI3DqkF7GrmwwGJRJTLgT0XwAPwRQCuDnjLFbkqrLZoogQqQMX7pkInrXVCiZXgwGg6FQScQsQ0SlAH4K4GIAEwG8n4gmJlGXLnpVl2PpxRO4qxsZDAZDVyMpSTYdwEbG2CbGWBuAuwEsTKgug8FgMPhISrgPAbDNtd1s7XMgouuJaBURrWppiba8ncFgMBj4JCXcedM6PU59jLE7GGNNjLGmhoauGanPYDAYCpWkhHszgEbX9lAAOxKqy2AwGAw+khLuzwMYQ0QjiagCwJUAHkyoLoPBYDD4SMQVkjHWTkQ3APgrMq6Qv2SMrU2iLoPBYDDkkpifO2PsLwD+klT5BoPBYBBjnLoNBoOhCCEWZyFQXY0gagHwVowi+gHYo6k5XYHudr6AOefugjlnNYYzxrjuhgUh3ONCRKsYY4URDCYFutv5AuacuwvmnPVhzDIGg8FQhBjhbjAYDEVIsQj3O/LdgJTpbucLmHPuLphz1kRR2NwNBoPB4KVYNHeDwWAwuDDC3WAwGIqQLi3ciWg+Ea0joo1EtCTf7dEFETUS0eNE9DoRrSWiT1v7+xDRo0S0wfrf25VnqXUd1hHRvPy1PjpEVEpELxHRn63toj5fACCieiL6AxG9Yd3vc4r5vInoM9YzvYaIfkdEVcV4vkT0SyLaTURrXPuUz5OIziCiV61jPyIiXsRdPoyxLvmHTMyaNwGMAlABYDWAiflul6ZzGwRgmvW7FsB6ZFa0+haAJdb+JQC+af2eaJ1/JYCR1nUpzfd5RDjvzwK4C8Cfre2iPl/rXJYBuM76XQGgvljPG5k1HTYD6GFtLwfwkWI8XwCzAUwDsMa1T/k8AawEcA4yYdQfBnCxbBu6suZetKs9McZ2MsZetH4fBvA6Mi/GQmSEAaz/l1m/FwK4mzHWyhjbDGAjMteny0BEQwEsAPBz1+6iPV8AIKI6ZITALwCAMdbGGDuA4j7vMgA9iKgMQDUyocCL7nwZY/8AsM+3W+k8iWgQgDrG2LMsI+l/48oTSlcW7qGrPRUDRDQCwFQA/wIwgDG2E8h0AAD6W8mK4Vr8AMAXAHS69hXz+QKZr84WAL+yzFE/J6IaFOl5M8a2A/gOgK0AdgI4yBj7G4r0fDmonucQ67d/vxRdWbiHrvbU1SGingDuBXAjY+xQUFLOvi5zLYjoUgC7GWMvyGbh7Osy5+uiDJlP99sYY1MBHEXmc11Elz5vy8a8EBnTw2AANUR0VVAWzr4uc74KiM4z1vl3ZeFe1Ks9EVE5MoL9/xhj91m7d1mfarD+77b2d/VrMRPAu4hoCzLmtQuI6Lco3vO1aQbQzBj7l7X9B2SEfbGe91wAmxljLYyxkwDuAzADxXu+flTPs9n67d8vRVcW7kW72pM1Iv4LAK8zxr7nOvQggKut31cDeMC1/0oiqiSikQDGIDMQ0yVgjC1ljA1ljI1A5j7+nTF2FYr0fG0YY28D2EZE46xdFwJ4DcV73lsBnE1E1dYzfiEy40nFer5+lM7TMt0cJqKzrev1YVeecPI9qhxzRPoSZDxJ3gTwpXy3R+N5zULm8+sVAC9bf5cA6AtgBYAN1v8+rjxfsq7DOiiMqBfaH4DzkfWW6Q7nOwXAKute/xFA72I+bwD/BeANAGsA3ImMh0jRnS+A3yEzrnASGQ382ijnCaDJulZvAvgJrKgCMn8m/IDBYDAUIV3ZLGMwGAwGAUa4GwwGQxFihLvBYDAUIUa4GwwGQxFihLvBYDAUIUa4GwwGQxFihLvBYDAUIf8fYEwSgqJjBpAAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -340,9 +419,33 @@ }, { "cell_type": "code", - "execution_count": 82, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "error", + "evalue": "display Surface quit", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31merror\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_44248/1459719159.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0m_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrun_episode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrender\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/tmp/ipykernel_44248/3855001447.py\u001b[0m in \u001b[0;36mrun_episode\u001b[0;34m(max_steps_per_episode, render)\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0m_\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmax_steps_per_episode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mrender\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0menv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrender\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 7\u001b[0m \u001b[0maction_probs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexpand_dims\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstate\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0maction\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mchoice\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnum_actions\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mp\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqueeze\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maction_probs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/lib/python3.10/site-packages/gym/core.py\u001b[0m in \u001b[0;36mrender\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 64\u001b[0m )\n\u001b[1;32m 65\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 66\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mrender_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 67\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 68\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mrender\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/lib/python3.10/site-packages/gym/core.py\u001b[0m in \u001b[0;36mrender\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 429\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mrender\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 430\u001b[0m \u001b[0;34m\"\"\"Renders the environment.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 431\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0menv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrender\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 432\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 433\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mclose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/lib/python3.10/site-packages/gym/core.py\u001b[0m in \u001b[0;36mrender\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 64\u001b[0m )\n\u001b[1;32m 65\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 66\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mrender_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 67\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 68\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mrender\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/lib/python3.10/site-packages/gym/wrappers/order_enforcing.py\u001b[0m in \u001b[0;36mrender\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 49\u001b[0m \u001b[0;34m\"set `disable_render_order_enforcing=True` on the OrderEnforcer wrapper.\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 50\u001b[0m )\n\u001b[0;32m---> 51\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0menv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrender\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 52\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 53\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/lib/python3.10/site-packages/gym/core.py\u001b[0m in \u001b[0;36mrender\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 64\u001b[0m )\n\u001b[1;32m 65\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 66\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mrender_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 67\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 68\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mrender\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/lib/python3.10/site-packages/gym/core.py\u001b[0m in \u001b[0;36mrender\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 429\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mrender\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 430\u001b[0m \u001b[0;34m\"\"\"Renders the environment.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 431\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0menv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrender\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 432\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 433\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mclose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/lib/python3.10/site-packages/gym/core.py\u001b[0m in \u001b[0;36mrender\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 64\u001b[0m )\n\u001b[1;32m 65\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 66\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mrender_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 67\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 68\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mrender\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/lib/python3.10/site-packages/gym/wrappers/env_checker.py\u001b[0m in \u001b[0;36mrender\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 53\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0menv_render_passive_checker\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0menv\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 54\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0menv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrender\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m~/.local/lib/python3.10/site-packages/gym/core.py\u001b[0m in \u001b[0;36mrender\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 64\u001b[0m )\n\u001b[1;32m 65\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 66\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mrender_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 67\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 68\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mrender\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/lib/python3.10/site-packages/gym/envs/classic_control/cartpole.py\u001b[0m in \u001b[0;36mrender\u001b[0;34m(self, mode)\u001b[0m\n\u001b[1;32m 215\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_renders\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 216\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 217\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_render\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 218\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 219\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_render\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmode\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"human\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/lib/python3.10/site-packages/gym/envs/classic_control/cartpole.py\u001b[0m in \u001b[0;36m_render\u001b[0;34m(self, mode)\u001b[0m\n\u001b[1;32m 296\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 297\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msurf\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpygame\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mflip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msurf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 298\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscreen\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mblit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msurf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 299\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mmode\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"human\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 300\u001b[0m \u001b[0mpygame\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mevent\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpump\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31merror\u001b[0m: display Surface quit" + ] + } + ], "source": [ "_ = run_episode(render=True)" ] @@ -364,7 +467,7 @@ }, { "cell_type": "code", - "execution_count": 103, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -389,7 +492,7 @@ }, { "cell_type": "code", - "execution_count": 104, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -422,7 +525,7 @@ }, { "cell_type": "code", - "execution_count": 105, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -504,7 +607,7 @@ }, { "cell_type": "code", - "execution_count": 99, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -520,7 +623,7 @@ }, { "cell_type": "code", - "execution_count": 106, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -540,11 +643,8 @@ } ], "metadata": { - "interpreter": { - "hash": "16af2a8bbb083ea23e5e41c7f5787656b2ce26968575d8763f2c4b17f9cd711f" - }, "kernelspec": { - "display_name": "Python 3.8.12 ('py38')", + "display_name": "Python 3.10.4 64-bit", "language": "python", "name": "python3" }, @@ -558,9 +658,14 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.12" + "version": "3.10.4" }, - "orig_nbformat": 4 + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" + } + } }, "nbformat": 4, "nbformat_minor": 2 diff --git a/lessons/6-Other/22-DeepRL/README.md b/lessons/6-Other/22-DeepRL/README.md index f5c631d0..26e3f691 100644 --- a/lessons/6-Other/22-DeepRL/README.md +++ b/lessons/6-Other/22-DeepRL/README.md @@ -83,6 +83,7 @@ After running one of those algorithms, we can expect our CartPole to behave like Continue your learning in the following notebooks: * [RL in TensorFlow](CartPole-RL-TF.ipynb) +* [RL in PyTorch](CartPole-RL-PyTorch.ipynb) ## Other RL Tasks diff --git a/lessons/6-Other/22-DeepRL/notebook.ipynb b/lessons/6-Other/22-DeepRL/notebook.ipynb index b6338c89..50c2c33f 100644 --- a/lessons/6-Other/22-DeepRL/notebook.ipynb +++ b/lessons/6-Other/22-DeepRL/notebook.ipynb @@ -1,39 +1,15 @@ { - "metadata": { - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.0" - }, - "orig_nbformat": 4, - "kernelspec": { - "name": "python3", - "display_name": "Python 3.7.0 64-bit ('3.7')" - }, - "interpreter": { - "hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d" - } - }, - "nbformat": 4, - "nbformat_minor": 2, "cells": [ { + "cell_type": "markdown", + "metadata": {}, "source": [ "## CartPole Skating\n", "\n", "> **Problem**: If Peter wants to escape from the wolf, he needs to be able to move faster than him. We will see how Peter can learn to skate, in particular, to keep balance, using Q-Learning.\n", "\n", "First, let's install the gym and import required libraries:" - ], - "cell_type": "markdown", - "metadata": {} + ] }, { "cell_type": "code", @@ -41,23 +17,34 @@ "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ - "Requirement already satisfied: gym in /Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages (0.18.3)\n", - "Requirement already satisfied: Pillow<=8.2.0 in /Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages (from gym) (7.0.0)\n", - "Requirement already satisfied: scipy in /Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages (from gym) (1.4.1)\n", - "Requirement already satisfied: numpy>=1.10.4 in /Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages (from gym) (1.19.2)\n", - "Requirement already satisfied: cloudpickle<1.7.0,>=1.2.0 in /Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages (from gym) (1.6.0)\n", - "Requirement already satisfied: pyglet<=1.5.15,>=1.4.0 in /Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages (from gym) (1.5.15)\n", - "\u001b[33mWARNING: You are using pip version 20.2.3; however, version 21.1.2 is available.\n", - "You should consider upgrading via the '/Library/Frameworks/Python.framework/Versions/3.7/bin/python3.7 -m pip install --upgrade pip' command.\u001b[0m\n" + "Defaulting to user installation because normal site-packages is not writeable\n", + "Collecting gym\n", + " Downloading gym-0.25.0.tar.gz (720 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m720.4/720.4 KB\u001b[0m \u001b[31m3.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n", + "\u001b[?25h Installing build dependencies ... \u001b[?25ldone\n", + "\u001b[?25h Getting requirements to build wheel ... \u001b[?25ldone\n", + "\u001b[?25h Preparing metadata (pyproject.toml) ... \u001b[?25ldone\n", + "\u001b[?25hRequirement already satisfied: numpy>=1.18.0 in /usr/lib/python3/dist-packages (from gym) (1.21.5)\n", + "Collecting gym-notices>=0.0.4\n", + " Downloading gym_notices-0.0.7-py3-none-any.whl (2.7 kB)\n", + "Collecting cloudpickle>=1.2.0\n", + " Downloading cloudpickle-2.1.0-py3-none-any.whl (25 kB)\n", + "Building wheels for collected packages: gym\n", + " Building wheel for gym (pyproject.toml) ... \u001b[?25ldone\n", + "\u001b[?25h Created wheel for gym: filename=gym-0.25.0-py3-none-any.whl size=824430 sha256=3f4ed647f1d12814bb457f7d83a7ccd0f682d12a0259ca07b7fab0db5100fc6e\n", + " Stored in directory: /home/leo/.cache/pip/wheels/c0/3c/33/32d86254a5bd554f5f07759ae1794646e490dd5fa81ebdcda3\n", + "Successfully built gym\n", + "Installing collected packages: gym-notices, cloudpickle, gym\n", + "Successfully installed cloudpickle-2.1.0 gym-0.25.0 gym-notices-0.0.7\n" ] } ], "source": [ "import sys\n", - "!pip install gym \n", + "!pip install gym pygame\n", "\n", "import gym\n", "import matplotlib.pyplot as plt\n", @@ -66,86 +53,118 @@ ] }, { + "cell_type": "markdown", + "metadata": {}, "source": [ "## Create a cartpole environment" - ], - "cell_type": "markdown", - "metadata": {} + ] }, { - "source": [ - "env = gym.make(\"CartPole-v1\")\n", - "print(env.action_space)\n", - "print(env.observation_space)\n", - "print(env.action_space.sample())" - ], "cell_type": "code", - "metadata": {}, "execution_count": 2, + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", + "text": [ + "Discrete(2)\n", + "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)\n", + "1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", "text": [ - "Discrete(2)\nBox(-3.4028234663852886e+38, 3.4028234663852886e+38, (4,), float32)\n0\n" + "/home/leo/.local/lib/python3.10/site-packages/gym/core.py:329: DeprecationWarning: \u001b[33mWARN: Initializing wrapper in old step API which returns one bool instead of two. It is recommended to set `new_step_api=True` to use new step API. This will be the default behaviour in future.\u001b[0m\n", + " deprecation(\n", + "/home/leo/.local/lib/python3.10/site-packages/gym/wrappers/step_api_compatibility.py:39: DeprecationWarning: \u001b[33mWARN: Initializing environment in old step API which returns one bool instead of two. It is recommended to set `new_step_api=True` to use new step API. This will be the default behaviour in future.\u001b[0m\n", + " deprecation(\n" ] } + ], + "source": [ + "env = gym.make(\"CartPole-v1\")\n", + "print(env.action_space)\n", + "print(env.observation_space)\n", + "print(env.action_space.sample())" ] }, { + "cell_type": "markdown", + "metadata": {}, "source": [ "To see how the environment works, let's run a short simulation for 100 steps." - ], - "cell_type": "markdown", - "metadata": {} + ] }, { - "source": [ - "env.reset()\n", - "\n", - "for i in range(100):\n", - " env.render()\n", - " env.step(env.action_space.sample())\n", - "env.close()" - ], "cell_type": "code", - "metadata": {}, "execution_count": 3, + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stderr", + "output_type": "stream", "text": [ - "/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/gym/logger.py:30: UserWarning: \u001b[33mWARN: You are calling 'step()' even though this environment has already returned done = True. You should always call 'reset()' once you receive 'done = True' -- any further steps are undefined behavior.\u001b[0m\n warnings.warn(colorize('%s: %s'%('WARN', msg % args), 'yellow'))\n" + "/home/leo/.local/lib/python3.10/site-packages/gym/core.py:57: DeprecationWarning: \u001b[33mWARN: You are calling render method, but you didn't specified the argument render_mode at environment initialization. To maintain backward compatibility, the environment will render in human mode.\n", + "If you want to render in human mode, initialize the environment in this way: gym.make('EnvName', render_mode='human') and don't call the render method.\n", + "See here for more information: https://www.gymlibrary.ml/content/api/\u001b[0m\n", + " deprecation(\n" + ] + }, + { + "ename": "DependencyNotInstalled", + "evalue": "pygame is not installed, run `pip install gym[classic_control]`", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m~/.local/lib/python3.10/site-packages/gym/envs/classic_control/cartpole.py\u001b[0m in \u001b[0;36m_render\u001b[0;34m(self, mode)\u001b[0m\n\u001b[1;32m 221\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 222\u001b[0;31m \u001b[0;32mimport\u001b[0m \u001b[0mpygame\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 223\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mpygame\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mgfxdraw\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'pygame'", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[0;31mDependencyNotInstalled\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_32716/4123126963.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m100\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0menv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrender\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0menv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maction_space\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msample\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0menv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/lib/python3.10/site-packages/gym/core.py\u001b[0m in \u001b[0;36mrender\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 64\u001b[0m )\n\u001b[1;32m 65\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 66\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mrender_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 67\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 68\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mrender\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/lib/python3.10/site-packages/gym/core.py\u001b[0m in \u001b[0;36mrender\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 429\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mrender\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 430\u001b[0m \u001b[0;34m\"\"\"Renders the environment.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 431\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0menv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrender\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 432\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 433\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mclose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/lib/python3.10/site-packages/gym/core.py\u001b[0m in \u001b[0;36mrender\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 64\u001b[0m )\n\u001b[1;32m 65\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 66\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mrender_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 67\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 68\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mrender\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/lib/python3.10/site-packages/gym/wrappers/order_enforcing.py\u001b[0m in \u001b[0;36mrender\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 49\u001b[0m \u001b[0;34m\"set `disable_render_order_enforcing=True` on the OrderEnforcer wrapper.\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 50\u001b[0m )\n\u001b[0;32m---> 51\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0menv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrender\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 52\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 53\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/lib/python3.10/site-packages/gym/core.py\u001b[0m in \u001b[0;36mrender\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 64\u001b[0m )\n\u001b[1;32m 65\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 66\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mrender_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 67\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 68\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mrender\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/lib/python3.10/site-packages/gym/core.py\u001b[0m in \u001b[0;36mrender\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 429\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mrender\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 430\u001b[0m \u001b[0;34m\"\"\"Renders the environment.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 431\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0menv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrender\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 432\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 433\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mclose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/lib/python3.10/site-packages/gym/core.py\u001b[0m in \u001b[0;36mrender\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 64\u001b[0m )\n\u001b[1;32m 65\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 66\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mrender_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 67\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 68\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mrender\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/lib/python3.10/site-packages/gym/wrappers/env_checker.py\u001b[0m in \u001b[0;36mrender\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 51\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mchecked_render\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 52\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mchecked_render\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 53\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0menv_render_passive_checker\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0menv\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 54\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 55\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0menv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrender\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/lib/python3.10/site-packages/gym/utils/passive_env_checker.py\u001b[0m in \u001b[0;36menv_render_passive_checker\u001b[0;34m(env, *args, **kwargs)\u001b[0m\n\u001b[1;32m 322\u001b[0m )\n\u001b[1;32m 323\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 324\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0menv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrender\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 325\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 326\u001b[0m \u001b[0;31m# TODO: Check that the result is correct\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/lib/python3.10/site-packages/gym/core.py\u001b[0m in \u001b[0;36mrender\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 64\u001b[0m )\n\u001b[1;32m 65\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 66\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mrender_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 67\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 68\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mrender\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/lib/python3.10/site-packages/gym/envs/classic_control/cartpole.py\u001b[0m in \u001b[0;36mrender\u001b[0;34m(self, mode)\u001b[0m\n\u001b[1;32m 215\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_renders\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 216\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 217\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_render\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 218\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 219\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_render\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmode\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"human\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/lib/python3.10/site-packages/gym/envs/classic_control/cartpole.py\u001b[0m in \u001b[0;36m_render\u001b[0;34m(self, mode)\u001b[0m\n\u001b[1;32m 223\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mpygame\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mgfxdraw\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 224\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mImportError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 225\u001b[0;31m raise DependencyNotInstalled(\n\u001b[0m\u001b[1;32m 226\u001b[0m \u001b[0;34m\"pygame is not installed, run `pip install gym[classic_control]`\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 227\u001b[0m )\n", + "\u001b[0;31mDependencyNotInstalled\u001b[0m: pygame is not installed, run `pip install gym[classic_control]`" ] } + ], + "source": [ + "env.reset()\n", + "\n", + "for i in range(100):\n", + " env.render()\n", + " env.step(env.action_space.sample())\n", + "env.close()" ] }, { + "cell_type": "markdown", + "metadata": {}, "source": [ "During simulation, we need to get observations in order to decide how to act. In fact, `step` function returns us back current observations, reward function, and the `done` flag that indicates whether it makes sense to continue the simulation or not:" - ], - "cell_type": "markdown", - "metadata": {} + ] }, { - "source": [ - "env.reset()\n", - "\n", - "done = False\n", - "while not done:\n", - " env.render()\n", - " obs, rew, done, info = env.step(env.action_space.sample())\n", - " print(f\"{obs} -> {rew}\")\n", - "env.close()" - ], "cell_type": "code", - "metadata": {}, "execution_count": 4, + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "[ 0.03044442 -0.19543914 -0.04496216 0.28125618] -> 1.0\n", "[ 0.02653564 -0.38989186 -0.03933704 0.55942606] -> 1.0\n", @@ -168,14 +187,24 @@ "[ 0.12921301 0.59883361 -0.22594088 -1.22169133] -> 1.0\n" ] } + ], + "source": [ + "env.reset()\n", + "\n", + "done = False\n", + "while not done:\n", + " env.render()\n", + " obs, rew, done, info = env.step(env.action_space.sample())\n", + " print(f\"{obs} -> {rew}\")\n", + "env.close()" ] }, { + "cell_type": "markdown", + "metadata": {}, "source": [ "We can get min and max value of those numbers:" - ], - "cell_type": "markdown", - "metadata": {} + ] }, { "cell_type": "code", @@ -183,10 +212,11 @@ "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ - "[-4.8000002e+00 -3.4028235e+38 -4.1887903e-01 -3.4028235e+38]\n[4.8000002e+00 3.4028235e+38 4.1887903e-01 3.4028235e+38]\n" + "[-4.8000002e+00 -3.4028235e+38 -4.1887903e-01 -3.4028235e+38]\n", + "[4.8000002e+00 3.4028235e+38 4.1887903e-01 3.4028235e+38]\n" ] } ], @@ -196,11 +226,11 @@ ] }, { + "cell_type": "markdown", + "metadata": {}, "source": [ "## State Discretization" - ], - "cell_type": "markdown", - "metadata": {} + ] }, { "cell_type": "code", @@ -213,11 +243,11 @@ ] }, { + "cell_type": "markdown", + "metadata": {}, "source": [ "Let's also explore other discretization method using bins:" - ], - "cell_type": "markdown", - "metadata": {} + ] }, { "cell_type": "code", @@ -225,10 +255,11 @@ "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ - "Sample bins for interval (-5,5) with 10 bins\n [-5. -4. -3. -2. -1. 0. 1. 2. 3. 4. 5.]\n" + "Sample bins for interval (-5,5) with 10 bins\n", + " [-5. -4. -3. -2. -1. 0. 1. 2. 3. 4. 5.]\n" ] } ], @@ -247,11 +278,11 @@ ] }, { + "cell_type": "markdown", + "metadata": {}, "source": [ "Let's now run a short simulation and observe those discrete environment values." - ], - "cell_type": "markdown", - "metadata": {} + ] }, { "cell_type": "code", @@ -259,10 +290,21 @@ "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ - "(0, 0, -1, -3)\n(0, 0, -2, 0)\n(0, 0, -2, -3)\n(0, 1, -3, -6)\n(0, 2, -4, -9)\n(0, 3, -6, -12)\n(0, 2, -8, -9)\n(0, 3, -10, -13)\n(0, 4, -13, -16)\n(0, 4, -16, -19)\n(0, 4, -20, -17)\n(0, 4, -24, -20)\n" + "(0, 0, -1, -3)\n", + "(0, 0, -2, 0)\n", + "(0, 0, -2, -3)\n", + "(0, 1, -3, -6)\n", + "(0, 2, -4, -9)\n", + "(0, 3, -6, -12)\n", + "(0, 2, -8, -9)\n", + "(0, 3, -10, -13)\n", + "(0, 4, -13, -16)\n", + "(0, 4, -16, -19)\n", + "(0, 4, -20, -17)\n", + "(0, 4, -24, -20)\n" ] } ], @@ -279,11 +321,11 @@ ] }, { + "cell_type": "markdown", + "metadata": {}, "source": [ "## Q-Table Structure" - ], - "cell_type": "markdown", - "metadata": {} + ] }, { "cell_type": "code", @@ -299,11 +341,11 @@ ] }, { + "cell_type": "markdown", + "metadata": {}, "source": [ "## Let's Start Q-Learning!" - ], - "cell_type": "markdown", - "metadata": {} + ] }, { "cell_type": "code", @@ -323,8 +365,8 @@ "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "0: 108.0, alpha=0.3, epsilon=0.9\n" ] @@ -370,11 +412,11 @@ ] }, { + "cell_type": "markdown", + "metadata": {}, "source": [ "## Plotting Training Progress" - ], - "cell_type": "markdown", - "metadata": {} + ] }, { "cell_type": "code", @@ -382,25 +424,27 @@ "metadata": {}, "outputs": [ { - "output_type": "execute_result", "data": { "text/plain": [ "[]" ] }, + "execution_count": 20, "metadata": {}, - "execution_count": 20 + "output_type": "execute_result" }, { - "output_type": "display_data", "data": { - "text/plain": "
", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD4CAYAAADiry33AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO3deXxU9b3/8dcnCSTsa8CQgAEJIKIIBGSXTUWiYqu0Lq2o3MvV6nWhVlGrtbdasddq9dqfy9W2tr22WpdKXYu4W0VBRVBAQFACCEF2kCXk+/tjvkkm+yTMZCZn3s/HI4+c853vzPmenMl7vud7zpxjzjlERCS4UuLdABERiS0FvYhIwCnoRUQCTkEvIhJwCnoRkYBLi3cDADp37uxyc3Pj3QwRkSZl0aJFW5xzmXXVS4igz83NZeHChfFuhohIk2JmX0ZST0M3IiIBp6AXEQk4Bb2ISMAp6EVEAk5BLyIScBEFvZmtNbMlZvaxmS30ZR3NbJ6ZrfS/O/hyM7N7zWyVmX1iZoNjuQIiIlK7+vToxzvnjnfO5fv52cB851weMN/PA5wK5PmfmcD90WqsiIjU3+GcRz8VGOenHwVeB67z5X90oesfv2dm7c0syzm38XAa2pjWbd3Lj/+2mG7tMvjpaf3p3DqdbXsO8K/V31BwXBbOOf7+8XpO6NmJj77azsSjuzD5N2/yo3G9eXbxev484wTumb+S/lltOaJdBobxwBureePzIpbccjJmBsCLSzby+ooiphyXxYl9Kn7nYUnhDv7+8Xq6tk1n5tijyso/XredtBRjQHY7nHM8uaiQCf26cOvzy+jYqjnLNu7kX6u/4d5zB5HdvgWri3bz3UHZpKWm8PKnX3NMt7bc/sJybig4mpPueoNHpg+leZrxwdptzHlxOU9dOoIN2/dx+sBuPLbgK254Zglt0tO4cFQu//PqKm46rT+/eO4zlv9iMjf9fSl/W1RIn66tGdazI51apXPP/JX87PT+9OzcivfXbGXJ+h28tXJLg7fFJScexQNvrKZ3l9as2ry7rNwMUs0oLonfZbbbZKSxa19xxPVHHtWJpet3sHNfMcdmt2PJ+h306tyKL7bsAeDu7w/k6scXx6q53HJ6f7buPcgTH6zj6537YraccENzO/DB2m38YHgP1m/7luZpKbz86aZ6vcb5J/TgolG5TLrrzXov/4qJeaSacfcrn9da79YzB/DlN3v437fW8B9je/Hgm19UqfPdwdk8/eH6Gl9jcI/2PHXpSNZs2cOEX78RUftyOrTglVknktEsNaL6DWWRXI/ezNYA2wAHPOice8jMtjvn2ofV2eac62BmzwFznHNv+/L5wHXOuYWVXnMmoR4/PXr0GPLllxGd998ocmc/Xzad06EFb183ge8/+C4L1mzlvesnsm7bXqY98G5ZnYn9ujB/+eay+cqhFO73Fw1lfN8u7Nx3kONu+WdZ+do5BTW2Ifyx0vK1cwp4aelGLvnzh3Wuz7WT+3LxqJ70u+mlOuuWKv0HrUnz1BQOHCqJ+PVEksFvzxvMZY/V/T8Z7ofDj+QXZw5o0PLMbFHYKEuNIu3Rj3LObTCzLsA8M1te27KrKavyaeKcewh4CCA/Pz9h735SuO1bANZvD/0+eKiE3fsr9uLWbdtbYb6mkAfKeoDFhw5/lXd+G1lvcuvuA5TU8wYztYU8oJAXqcaufQfr/ZyiXftj0JKKIhqjd85t8L83A88Aw4BNZpYF4H+XdmkLge5hT88BNkSrwUGVO/t5LvnTong3Q0QCqM6gN7NWZtamdBo4GVgKzAWm+2rTgWf99FzgAn/2zXBgR1Man4+nlz79Ot5NEJEAimTopivwjD+AmAY85px7ycw+AJ4wsxnAV8A0X/8FYAqwCtgLXBT1VouIBETR7tgP3dQZ9M65L4CB1ZR/A0ysptwBl0WldQG0/+Ah5i7ewKijOjXaMuN4YoqI1OHLb/bWXekwJcRlipPJr15eQdGu/dxzzvGNtkyr7vC4iETdI2+viXcTqqVLIHhffrOHRV/WfqZJNJQeYd/5bf2PzotIYltZyxl38aQevXfif78OVD2fXUQklrY0whi9evRRYNV+dSBxOJf4bRSR2FHQi4gEnIZuoqAhBzsb80SY372zhjYZ2tQiyUo9+giMv/P1CvNNcRDknvkr490EEYkTBX0E1virC4qINEUK+nqq57XBouqv738Vv4WLSJOloI9QInzpaPbTS+LdBBFpghT0IiIBp6AH9h6o+7ru0R6yiecQkIgkFwU9sOCLrXXWKb0BSayHcL49cCi2CxCRpKOgr2TfwbqDNpad8UPq6otIlCnoK9l/sHFukVfbnkFjXPtCRJKHgr6eHv9gXUzv8bh19wHyb30lZq8vIslHQV9P9722it+/szZmr79174EqZbmzn+eQ7h4iIg2koAdcPUfdDxQf/gHTmobiP9uws9ryg4caZ0hJRIJHQd8Aq4sO/5IIroakX7l512G/tohIOAV9gvmwhrtcrdyUmHeuEZHEp6CvpL7DONG2uHBHteWn3/d2I7dERIJCQR8nlggXzxGRpKCgFxEJOAU98bnuTE0HY0VEok1BHwUahhGRRKagr8Sa5I0CRURqpqCvpCFn3SzbWP2XnEREEoGCnviM0Wu4R0Qai4JeRCTgFPTE9vryNS5TZ92ISCNR0MfJLf/4LN5NEJEkEXHQm1mqmX1kZs/5+Z5mtsDMVprZ42bW3Jen+/lV/vHc2DQ9etS7FpEgq0+P/kpgWdj8HcDdzrk8YBsww5fPALY553oDd/t6Ce3xD9bFuwn11uenL/L655vj3QwRaQIiCnozywEKgIf9vAETgCd9lUeBM/30VD+Pf3yiJfgpJis3l18Zsql07g8Ul/DCkq/j3QwRaQIi7dH/BrgWKL37RSdgu3Ou2M8XAtl+OhtYB+Af3+HrV2BmM81soZktLCoqamDzRUSkLnUGvZmdBmx2zi0KL66mqovgsfIC5x5yzuU75/IzMzMjamysxPvSxCIisZQWQZ1RwBlmNgXIANoS6uG3N7M032vPATb4+oVAd6DQzNKAdsDWqLc8SkpKHCVhd+lL7EEmEZH6q7NH75y73jmX45zLBc4BXnXOnQ+8Bpztq00HnvXTc/08/vFXXQKf1nLqPW+xfvu38W6GiEjMHM559NcBs8xsFaEx+Ed8+SNAJ18+C5h9eE2MrRWbdI9WEQm2SIZuyjjnXgde99NfAMOqqbMPmBaFtsVF4u57iIg0jL4ZKyIScAp6EZGAU9CLiARcvcbog+JAcQl9fvoiV0zoHe+miIjEXFL26PcVHwLg9++sjW9DREQaQVIGvYhIMlHQV6KzK0UkaBT0legKCCISNAp6EZGAU9CLiAScgr4SjdGLSNAo6CuZ95nu2iQiwZLUQb9rf3GVsi27D8ShJSIisZPUQS8ikgwU9JX8+p8r4t0EEZGoUtBXUqKjsSISMEkX9J9v2sW0+9+NdzNERBpN0gX9L19YptsHikhSSbqgFxFJNgp6EZGAU9CLiAScgl5EJOAU9CIiAaegFxEJuKQLet1YRESSTdIFvYhIslHQi4gEnIJeRCTgFPQiIgGnoBcRCbikC3oznXcjIsmlzqA3swwze9/MFpvZp2b2c1/e08wWmNlKM3vczJr78nQ/v8o/nhvbVRARkdpE0qPfD0xwzg0Ejgcmm9lw4A7gbudcHrANmOHrzwC2Oed6A3f7eglD/XkRSTZ1Br0L2e1nm/kfB0wAnvTljwJn+umpfh7/+ETTeImISNxENEZvZqlm9jGwGZgHrAa2O+eKfZVCINtPZwPrAPzjO4BO0Wy0iIhELqKgd84dcs4dD+QAw4Cjq6vmf1fXe69yJ1Yzm2lmC81sYVFRUaTtFRGReqrXWTfOue3A68BwoL2ZpfmHcoANfroQ6A7gH28HbK3mtR5yzuU75/IzMzMb1voG0CCSiCSbSM66yTSz9n66BTAJWAa8Bpztq00HnvXTc/08/vFXnXNVevQiItI40uquQhbwqJmlEvpgeMI595yZfQb81cxuBT4CHvH1HwH+ZGarCPXkz4lBu0VEJEJ1Br1z7hNgUDXlXxAar69cvg+YFpXWiYjIYUuKb8YeKnHcMvdTNmz/Nt5NERFpdJEM3TR576/Zyh/+tZbPN+2iZfPUeDdHRKRRJUWP3vmzO0t0TFhEklBSBH1FOr9SRJJLEga9iEhyUdCLiARcUgW9huhFJBklRdBb2Li8LoEgIskm0KdXOudYXbQn3s0QEYmrQPfoH3l7DZPueoPFhdvLyg6VaPxGRJJLoIP+o3WhgF+3dW9Z2avLN8erOSIicRHooBcRkSQLeg3aiEgySoqg15k2IpLMgh306sKLiAQ86D3T9W1EJIkF9jz63NnPl00/vnBdHFsiIhJfSdGjP1BcEu8miIjETVIEfRmN2YtIEgpU0O/eX8zU377D55t2xbspIiIJI1BB/69VW1i8bju/emlFvJsiIpIwAhX0dXl/7dZ4N0FEpNElVdCLiCSjQAW9jrWKiFQVqKAvpUseiIiUC2TQi4hIuUAFve4JKyJSVaCCvpRGbkREygUy6EVEpFzAgl5jNyIilQUs6EN01o2ISLlABr2IiJSrM+jNrLuZvWZmy8zsUzO70pd3NLN5ZrbS/+7gy83M7jWzVWb2iZkNjvVKlNJZNyIiVUXSoy8GfuycOxoYDlxmZv2B2cB851weMN/PA5wK5PmfmcD9UW91HXRHKRGRcnUGvXNuo3PuQz+9C1gGZANTgUd9tUeBM/30VOCPLuQ9oL2ZZUW95dXYrxuMiIhUUa8xejPLBQYBC4CuzrmNEPowALr4atlA+L37Cn1Z5deaaWYLzWxhUVFR/Vtejase/zgqryMiEiQRB72ZtQaeAq5yzu2srWo1ZVVGz51zDznn8p1z+ZmZmZE2IyI660ZEpFxEQW9mzQiF/P855572xZtKh2T8782+vBDoHvb0HGBDdJorIiL1FclZNwY8Aixzzt0V9tBcYLqfng48G1Z+gT/7Zjiwo3SIR0REGl9aBHVGAT8ElphZ6SD4DcAc4AkzmwF8BUzzj70ATAFWAXuBi6La4gho6EZEpFydQe+ce5uarxM2sZr6DrjsMNslIiJRom/GiogEXCCDXl+YEhEpF8igFxGRcgp6EZGAC2TQry7aHe8miIgkjEAG/fKvd8W7CSIiCSOQQS8iIuUU9CIiAaegFxEJOAW9iEjAKehFRAJOQS8iEnAKehGRgFPQi4gEnIJeRCTgFPQiIgGnoBcRCTgFvYhIwCnoRUQCTkEvIhJwCnoRkYBT0IuIBFxggr5w2954N0FEJCEFIujfXf0No+94Ld7NEBFJSIEI+uVf74x3E0REElYggt65eLdARCRxBSPo490AEZEEFoigFxGRmgUi6J3GbkREahSIoBcRkZo1+aDfd/AQtz6/LN7NEBFJWHUGvZn9zsw2m9nSsLKOZjbPzFb63x18uZnZvWa2ysw+MbPBsWw8wINvfBHrRYiINGmR9Oj/AEyuVDYbmO+cywPm+3mAU4E8/zMTuD86zazZ3oPFsV6EiEiTVmfQO+feBLZWKp4KPOqnHwXODCv/owt5D2hvZlnRamz1DYzpq4uINHkNHaPv6pzbCOB/d/Hl2cC6sHqFvqwKM5tpZgvNbGFRUVEDmwH/WLyhwc8VEUkG0T4Ya9WUVdvnds495JzLd87lZ2ZmNniBG3bsa/BzRUSSQUODflPpkIz/vdmXFwLdw+rlAOpyi4jEUUODfi4w3U9PB54NK7/An30zHNhROsQjIiLxkVZXBTP7CzAO6GxmhcDPgDnAE2Y2A/gKmOarvwBMAVYBe4GLYtBmERGphzqD3jl3bg0PTaymrgMuO9xGiYhI9DT5b8aKiEjtFPQiIgHXpIP+/TWVv8clIiKVNemg/8HDC+LdBBGRhNekg/7AoZJ4N0FEJOE16aAXEZG6KehFRAJOQS8iEnAKehGRgFPQi4gEnIJeRCTgFPQiInHUPC32MaygFxGJo7OH5MR8GQp6EZE4Om9Yj5gvQ0EvIhJHA7LbxXwZCnoRkTjp3aV1oyxHQS8iEidj8zIbZTkKehGROLnmlD6NshwFvYhInLRsXufdXKNCQS8iEnAKeklIfbo2zkEqaTzpjfDFIKme/vKSkJyLdwsk2sbkdY53E5KWgl6kEfzyO8dGXPfYRjivuql69OJhUX29Fs1So/p63Tu2iOrrRYuCXqSBxveNzalxd04bGPUAasq+Oyi7bPrEPuV/87F9av/7FxyXVedr5+d2qHd7Tu7ftcJ8r8xWjIvReyFaFPRS5vwTYv9V7Ibo27VNteV/nnFClbJOrZrHtC3nDO1eNn36wG4AXDDiSNbOKaj1ec1SrV7LuXh0br3bVpe1cwq45uTGOZ0vmobkdqBV86offJUDd3CP9hXmczrU3btOT0vh0nFHlQ0rRXKBsXF9u1SYP2twDtntQ8tqlpqYkZqYrZKo6pXZKqJ6t9VjeKHyP1ldLh/fO+K6o3tXHMt9+eqxVercd94gRsdhzLe095bZJp0zBnbjigm9+ckpfWt9zohenfhOWK80El3bZgBUG3CljvB1EtWpA4447Nd49rJRnDesBwtunMTim08GKgb43y4Zwc2n9WfBDRN57N+H07LS36tTq+ZMOrrm9+pPTunHdZNDPwBnDc7m/RsncvGonmV1hlbq9We2Secfl48um+/SJp3Zp/bjigm9Oe3YmvcirpjQm/wj678HEQ0K+iZkUKUeS6T+3/mDK7xxo2FafndunHI0AMNyO9ZZ/5pKYTiqd6da6885K/Sh819Tj6n28dOO6xZJMyOWF/ZV9PvOG8S8aj5cSv3homF8cOMk0lJTmHVyX9pkNAPgwpG5NK+mR/eXmcNJS03hhin9uHBkbll5Zpt0js5qW+0y+vi9mP+aOqDC3kL3ji147ZpxADzxHyPKyksD5KcFR5eVfS+/6lURv5ffvcK6Ho7OrdOrLX/1xyfy4pVjKqxruJqWX10IDuzeHjOjdXoa7VqG/s5XTepT9jpDczty8eiedG2bQUazVF798ThOCuuELLrpJB6enl82f+e0gfz7mPL/hTYZofPYB2S345Hp+fzs9GPo0iajQs/+4QuGcsvp/cvmT+rflWNz2vHFL6fwwA+GcPaQHNpkNGPWyX0Z2L3m/9ExfTI55ZjyD7+nLh1RY91oU9AniLp2Gbu0SeepS0Y26LWz2rXg5tP7c1xO+UG+W88cUOtzurWrvbc4rm8mk32P7ZJxvSJqx2XjjyqbPmdo7cNEQ47syNo5BVwwIheAD26cVGub75w2kGd+NLLsHzcSFjaaMm/WiRSE9cbyahguqs0tZxzD57edWuPjM8cexS1nlH9wDc3twItXjikbAgo3vFcn3r5uPGf5S9iWhvbLV42lZ+dWrJ1TQI9OLcvq//b8wVxzch9mjC4Psdu+cyzvXT+xwut2aZvBvFkncvNp/XllVs0fZvURvmdxZKeW9MpsXeMHWG2evDSy9/dZg7N569rxnNCramfhiHYZDO5R9QOjTXoak47uwtlDcrixoD9PXjKCn5zSl27ty/cOJh7dlQx/bCR8CLBdy2ZcOKon78yewJrbp5SVp6QYkwccgYW9kSaG7T3MOqkPr10zjldmjeXqSX3IP7JD2V7oHy4aypAj6+4gRYuCPgZKd+XrMx561/cG1vr4+zdOIiXFuOec4+vVlrVzCmjXItQTmnv5aOZ8N9RT7ndE7UFWenbDhSNzeSSsRwSw5vYpNEtNoXvHlqydU8CEflV3jR/4wZAqZT85pR9r5xSwdk5BhXBb/ovJQGg4qH9WW2af2q/KczPbpJeFeAffswt39pAcBvXoUHYlwNJeY/hxh/Drfg/s3p41txfwyqyxvHjlmBr+CiGDe7RniO9tRnMM9r/PDm3z/zl3EGvnFPC3S0YwMKcduZ1DAZ7ToTzIf3X2QNbOKajxm5Rd22Zw+YQ8zKys09AsNYUj2mUw7+qxvHRVxXW8eHRPenWuX8++8tlAE/t1oW/XNtz2ndAH8IhenXiyls5Ih5ah8ByTl1n2Plg7p4B7zjm+wvBKm/TaP6zNjO4dW9b4+FmDs8nr0pofDj+yrGzJz0/h4elDy+bzcztyWS3DiWP6hAK5Z+fyYc/s9i0qhHpNXrpqDPOuHssVE/Po2bkVvbu04cpJoW1zdFZb1s4pqDLOH2uN8/3bAMjr0pqnfjSS4275Z511Z4zuya59xfzbmF7c+c/PAUhLMYpLKp4cfnL/rvTLasuQIzsw6qjqhzLeu34i7cOC7YyB3fh80y4y0lJplpbCWYNzuP2FZTz90XpG9e7ElRP70KVNOu+s3sJx2VV3I78/tDsjj+pMj04tueOsY8nr2oY9+4tZun4nEOoZp1ioR/v2dePJateC1JSKb+7q3uxzLx/FkvU7uPGZpQBMHnAE/bPa8tnGndUeNAX4xZkDGNS9PRnNUnn3+gl0apVe655NwbFZLP96F5ecWL5n8OAPh1QYLik9KHbd5H4s/HIbV07MY8/+Yv7+8QbunDaQJxcVAnD/+YMB6N2l5g+8966fSIdWzUhPS2XvgWLunb+K8yI4YD0mrzOL123nzWvHY1T9Ww3IbsvufcW0qhRoQ3M78mzY2G8k/jRjGDu/La5Q9tx/juatlVvK5mvaOyndjOP6ZnJS/65l2y6rXQYbd+yjR8eWfLV1LwA/P+MYpo/MJXf287RJT2PX/mLyurbmjrOPA+Cta8eT3b4FKWHvlaP8h+2IXp1494tv6N+tLW9PGl/l2MLU47OZenzoGMaHN51Es1TjpLveJDuCg6nVKd1rORyl262+B9EB+h1R/72ZWDOXAN9Myc/PdwsXLqz380bcPp+NO/bV+3nXTu5L6/Q0bn72U1o0S+XpH40kNcW455WVPL9kIytvO5UHXl/Nr+eFQvrm0/pzsd8lds5x07NLuXBkLt978D227jnA9/JzSE1J4cqJeXz5zZ4Ku5TTf/c+Zw7qxstLN/HSp1+z+pdTqgRnuE8Kt3PGfe9w7rDuXDAiN6Jd4H0HD/H6is1MHlD36WSH465/rmDX/mJ+dnr14+YAS9fvoEXzVI7KbM3WPQf4dMMOxjTSFfoADhSXMH/Zpiq71KWeWlTIc59s4PcXVT0fe8XXu7jssQ956tKRZXtBySR39vMAvH/DRFYV7eaYrHZ8+NU29hwoZsqArLIQd87xwpKvmTzgiFrfy6VKShwvLo28fiLYX3yIs+7/Fz8t6M/waoaIEoWZLXLO5ddZLxZBb2aTgXuAVOBh59yc2uo3NOiLD5XwzEfr2VdcQtuMNIbmdqR5WgqpZlz+lw+57cxjSU0x9heXRHTd5/3Fh9iy+wDZ7VtQUuJYt20vR3aK7IyVSF77m90HKowJ1uTLb/bQo2PLiHYTRaJlz/5i9uwvpkuCn80j5eIW9GaWCnwOnAQUAh8A5zrnPqvpOQ0NehGRZBZp0MfiYOwwYJVz7gvn3AHgr8DUGCxHREQiEIugzwbWhc0X+rIKzGymmS00s4VFRUUxaIaIiEBsgr66geUq40POuYecc/nOufzMzMS+ToSISFMWi6AvBLqHzecAG2KwHBERiUAsgv4DIM/MeppZc+AcYG4MliMiIhGI+hemnHPFZnY58DKh0yt/55z7NNrLERGRyMTkm7HOuReAF2Lx2iIiUj+61o2ISMAlxCUQzKwI+LKBT+8MbKmzVrBonZOD1jk5HM46H+mcq/O0xYQI+sNhZgsj+WZYkGidk4PWOTk0xjpr6EZEJOAU9CIiAReEoH8o3g2IA61zctA6J4eYr3OTH6MXEZHaBaFHLyIitVDQi4gEXJMOejObbGYrzGyVmc2Od3vqw8y6m9lrZrbMzD41syt9eUczm2dmK/3vDr7czOxev66fmNngsNea7uuvNLPpYeVDzGyJf869liC3rDKzVDP7yMye8/M9zWyBb//j/hpJmFm6n1/lH88Ne43rffkKMzslrDzh3hNm1t7MnjSz5X57jwj6djazq/37eqmZ/cXMMoK2nc3sd2a22cyWhpXFfLvWtIxaOeea5A+h6+isBnoBzYHFQP94t6se7c8CBvvpNoTuytUf+BUw25fPBu7w01OAFwldBno4sMCXdwS+8L87+OkO/rH3gRH+OS8Cp8Z7vX27ZgGPAc/5+SeAc/z0A8ClfvpHwAN++hzgcT/d32/vdKCnfx+kJup7AngU+Dc/3RxoH+TtTOj+E2uAFmHb98KgbWdgLDAYWBpWFvPtWtMyam1rvP8JDuOPPAJ4OWz+euD6eLfrMNbnWUK3X1wBZPmyLGCFn36Q0C0ZS+uv8I+fCzwYVv6gL8sCloeVV6gXx/XMAeYDE4Dn/Jt4C5BWebsSujDeCD+d5utZ5W1dWi8R3xNAWx96Vqk8sNuZ8psPdfTb7TnglCBuZyCXikEf8+1a0zJq+2nKQzcR3cmqKfC7qoOABUBX59xGAP+7i69W0/rWVl5YTXm8/Qa4Fijx852A7c65Yj8f3s6ydfOP7/D16/u3iKdeQBHwez9c9bCZtSLA29k5tx64E/gK2Ehouy0i2Nu5VGNs15qWUaOmHPQR3ckq0ZlZa+Ap4Crn3M7aqlZT5hpQHjdmdhqw2Tm3KLy4mqqujseazDoT6qEOBu53zg0C9hDa3a5Jk19nP2Y8ldBwSzegFXBqNVWDtJ3rEtd1bMpB3+TvZGVmzQiF/P855572xZvMLMs/ngVs9uU1rW9t5TnVlMfTKOAMM1tL6KbxEwj18NubWekls8PbWbZu/vF2wFbq/7eIp0Kg0Dm3wM8/SSj4g7ydJwFrnHNFzrmDwNPASIK9nUs1xnataRk1aspB36TvZOWPoD8CLHPO3RX20Fyg9Mj7dEJj96XlF/ij98OBHX637WXgZDPr4HtSJxMav9wI7DKz4X5ZF4S9Vlw45653zuU453IJba9XnXPnA68BZ/tqlde59G9xtq/vfPk5/myNnkAeoQNXCfeecM59Dawzs76+aCLwGQHezoSGbIabWUvfptJ1Dux2DtMY27WmZdQsngdtonAgZAqhs1VWAzfGuz31bPtoQrtinwAf+58phMYm5wMr/e+Ovr4Bv9wf3t8AAACjSURBVPXrugTID3uti4FV/ueisPJ8YKl/zn1UOiAY5/UfR/lZN70I/QOvAv4GpPvyDD+/yj/eK+z5N/r1WkHYWSaJ+J4AjgcW+m39d0JnVwR6OwM/B5b7dv2J0JkzgdrOwF8IHYM4SKgHPqMxtmtNy6jtR5dAEBEJuKY8dCMiIhFQ0IuIBJyCXkQk4BT0IiIBp6AXEQk4Bb2ISMAp6EVEAu7/A6SijxMjKxrLAAAAAElFTkSuQmCC", "image/svg+xml": "\r\n\r\n\r\n\r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n\r\n", - "image/png": "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\n" + "text/plain": [ + "
" + ] }, "metadata": { "needs_background": "light" - } + }, + "output_type": "display_data" } ], "source": [ @@ -408,11 +452,11 @@ ] }, { + "cell_type": "markdown", + "metadata": {}, "source": [ "From this graph, it is not possible to tell anything, because due to the nature of stochastic training process the length of training sessions varies greatly. To make more sense of this graph, we can calculate **running average** over series of experiments, let's say 100. This can be done conveniently using `np.convolve`:" - ], - "cell_type": "markdown", - "metadata": {} + ] }, { "cell_type": "code", @@ -420,25 +464,27 @@ "metadata": {}, "outputs": [ { - "output_type": "execute_result", "data": { "text/plain": [ "[]" ] }, + "execution_count": 22, "metadata": {}, - "execution_count": 22 + "output_type": "execute_result" }, { - "output_type": "display_data", "data": { - "text/plain": "
", + "image/png": "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", "image/svg+xml": "\r\n\r\n\r\n\r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n\r\n", - "image/png": "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\n" + "text/plain": [ + "
" + ] }, "metadata": { "needs_background": "light" - } + }, + "output_type": "display_data" } ], "source": [ @@ -449,13 +495,13 @@ ] }, { + "cell_type": "markdown", + "metadata": {}, "source": [ "## Varying Hyperparameters and Seeing the Result in Action\n", "\n", "Now it would be interesting to actually see how the trained model behaves. Let's run the simulation, and we will be following the same action selection strategy as during training: sampling according to the probability distribution in Q-Table: " - ], - "cell_type": "markdown", - "metadata": {} + ] }, { "cell_type": "code", @@ -475,14 +521,14 @@ ] }, { + "cell_type": "markdown", + "metadata": {}, "source": [ "\n", "## Saving result to an animated GIF\n", "\n", "If you want to impress your friends, you may want to send them the animated GIF picture of the balancing pole. To do this, we can invoke `env.render` to produce an image frame, and then save those to animated GIF using PIL library:" - ], - "cell_type": "markdown", - "metadata": {} + ] }, { "cell_type": "code", @@ -490,8 +536,8 @@ "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "360\n" ] @@ -516,5 +562,32 @@ "print(i)" ] } - ] -} \ No newline at end of file + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.4 64-bit", + "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.10.4" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}