diff --git a/lessons/6-Other/22-DeepRL/CartPole-RL-Pytorch.ipynb b/lessons/6-Other/22-DeepRL/CartPole-RL-Pytorch.ipynb
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..c6e599959ec9616a5813e6fe3d605f63cac3f452 100644
--- a/lessons/6-Other/22-DeepRL/CartPole-RL-Pytorch.ipynb
+++ b/lessons/6-Other/22-DeepRL/CartPole-RL-Pytorch.ipynb
@@ -0,0 +1,671 @@
+{
+ "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 [this blog post](https://medium.com/swlh/policy-gradient-reinforcement-learning-with-keras-57ca6ed32555), [official TensorFlow documentation](https://www.tensorflow.org/tutorials/reinforcement_learning/actor_critic) and [this Keras RL example](https://keras.io/examples/rl/actor_critic_cartpole/).\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": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "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",
+ "Collecting pygame\n",
+ " Downloading pygame-2.1.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (21.9 MB)\n",
+ "\u001b[2K \u001b[90m鈹佲攣鈹佲攣鈹佲攣鈹佲攣鈹佲攣鈹佲攣鈹佲攣鈹佲攣鈹佲攣鈹佲攣鈹佲攣鈹佲攣鈹佲攣鈹佲攣鈹佲攣鈹佲攣鈹佲攣鈹佲攣鈹佲攣鈹佲攣\u001b[0m \u001b[32m21.9/21.9 MB\u001b[0m \u001b[31m3.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n",
+ "\u001b[?25hRequirement 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",
+ "Requirement already satisfied: gym-notices>=0.0.4 in /home/leo/.local/lib/python3.10/site-packages (from gym) (0.0.7)\n",
+ "Installing collected packages: pygame\n",
+ "Successfully installed pygame-2.1.2\n"
+ ]
+ }
+ ],
+ "source": [
+ "import sys\n",
+ "!{sys.executable} -m pip install gym pygame"
+ ]
+ },
+ {
+ "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": 41,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "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",
+ "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": 42,
+ "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.01024284 0.23410203 -0.02896851 -0.2558368 ] -> 1.0\n",
+ "[-0.0055608 0.42962533 -0.03408524 -0.5575143 ] -> 1.0\n",
+ "[ 0.00303171 0.6252088 -0.04523553 -0.86073816] -> 1.0\n",
+ "[ 0.01553589 0.82091665 -0.06245029 -1.1672944 ] -> 1.0\n",
+ "[ 0.03195422 1.0167931 -0.08579618 -1.4788847 ] -> 1.0\n",
+ "[ 0.05229008 1.2128513 -0.11537387 -1.7970835 ] -> 1.0\n",
+ "[ 0.07654711 1.0191944 -0.15131554 -1.542374 ] -> 1.0\n",
+ "[ 0.096931 0.82618064 -0.18216303 -1.3004787 ] -> 1.0\n",
+ "[ 0.11345461 0.63377684 -0.2081726 -1.0699085 ] -> 1.0\n",
+ "[ 0.12613015 0.83095175 -0.22957078 -1.420047 ] -> 1.0\n",
+ "Total reward: 10.0\n"
+ ]
+ }
+ ],
+ "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}\")\n",
+ "\n",
+ "env.close()"
+ ]
+ },
+ {
+ "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": 47,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "import tensorflow as tf\n",
+ "from tensorflow import keras\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, 2),\n",
+ "# torch.nn.ReLU(),\n",
+ "# torch.nn.Linear(2, num_actions)\n",
+ "# )\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",
+ ")\n",
+ "\n",
+ "optimizer = torch.optim.Adam(model.parameters(), lr=0.01)\n",
+ "# optimizer = torch.optim.SGD(model.parameters(), lr=0.01)\n",
+ "# optimizer = keras.optimizers.Adam(learning_rate=0.01)"
+ ]
+ },
+ {
+ "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": 48,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def run_episode(max_steps_per_episode = 10000,render=False): \n",
+ " states, actions, probs, rewards = [],[],[],[]\n",
+ " state = env.reset()\n",
+ " # print(state.dtype)\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": 49,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Total reward: 24.0\n"
+ ]
+ }
+ ],
+ "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": 50,
+ "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": 87,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def train_on_batch4(states,actions,probs,rewards):\n",
+ " rewards = discounted_rewards(rewards)\n",
+ " probs = probs[np.arange(len(probs)),actions]\n",
+ " # probs = probs.reshape(-1,1)\n",
+ " rewards = rewards.reshape(-1,1)\n",
+ " probs = torch.from_numpy(probs)\n",
+ " rewards = torch.from_numpy(rewards)\n",
+ " loss = -torch.mean(torch.log(probs) * rewards)\n",
+ " optimizer.zero_grad()\n",
+ " loss.backward()\n",
+ " optimizer.step()\n",
+ " return loss.item()\n",
+ "\n",
+ "def train_on_batch2(states,target):\n",
+ " states = torch.from_numpy(states)\n",
+ " # target = target.reshape(-1,1)\n",
+ " target = torch.from_numpy(target)\n",
+ " y = model(states)\n",
+ " print(y)\n",
+ " loss = -torch.mean(torch.log(y) * target)\n",
+ " optimizer.zero_grad()\n",
+ " loss.backward()\n",
+ " optimizer.step()\n",
+ " return loss.item()\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.nn.CrossEntropyLoss()(predictions, y) # (y, predictions)\n",
+ " loss.backward()\n",
+ " optimizer.step()\n",
+ " return loss.item()\n",
+ " w.data.sub_(learning_rate * w.grad)\n",
+ " b.data.sub_(learning_rate * b.grad)\n",
+ " w.grad.zero_()\n",
+ " b.grad.zero_()\n",
+ " return loss"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 88,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "0 -> 25.0\n",
+ "100 -> 21.0\n",
+ "200 -> 7.0\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "[<matplotlib.lines.Line2D at 0x7f8843d55060>]"
+ ]
+ },
+ "execution_count": 88,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "<Figure size 432x288 with 1 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "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",
+ " # loss = train_on_batch4(states,actions,probs,rewards)\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": 40,
+ "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"
+ ]
+ },
+ {
+ "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_41886/1459719159.py\u001b[0m in \u001b[0;36m<module>\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_41886/4189192208.py\u001b[0m in \u001b[0;36mrun_episode\u001b[0;34m(max_steps_per_episode, render)\u001b[0m\n\u001b[1;32m 5\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 6\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----> 7\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 8\u001b[0m \u001b[0maction_probs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrom_numpy\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;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 9\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[0mdetach\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumpy\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[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)"
+ ]
+ },
+ {
+ "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": 103,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "num_inputs = 4\n",
+ "num_actions = 2\n",
+ "num_hidden = 128\n",
+ "\n",
+ "inputs = keras.layers.Input(shape=(num_inputs,))\n",
+ "common = keras.layers.Dense(num_hidden, activation=\"relu\")(inputs)\n",
+ "action = keras.layers.Dense(num_actions, activation=\"softmax\")(common)\n",
+ "critic = keras.layers.Dense(1)(common)\n",
+ "\n",
+ "model = keras.Model(inputs=inputs, outputs=[action, critic])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We would need to slightly modify our `run_episode` function to return also critic results:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 104,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def run_episode(max_steps_per_episode = 10000,render=False): \n",
+ " states, actions, probs, rewards, critic = [],[],[],[],[]\n",
+ " state = env.reset()\n",
+ " for _ in range(max_steps_per_episode):\n",
+ " if render:\n",
+ " env.render()\n",
+ " action_probs, est_rew = model(np.expand_dims(state,0))\n",
+ " action = np.random.choice(num_actions, p=np.squeeze(action_probs[0]))\n",
+ " nstate, reward, done, info = env.step(action)\n",
+ " if done:\n",
+ " break\n",
+ " states.append(state)\n",
+ " actions.append(action)\n",
+ " probs.append(tf.math.log(action_probs[0,action]))\n",
+ " rewards.append(reward)\n",
+ " critic.append(est_rew[0,0])\n",
+ " state = nstate\n",
+ " return states, actions, probs, rewards, critic"
+ ]
+ },
+ {
+ "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": 105,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "running reward: 5.82 at episode 10\n",
+ "running reward: 9.43 at episode 20\n",
+ "running reward: 10.30 at episode 30\n",
+ "running reward: 10.28 at episode 40\n",
+ "running reward: 11.00 at episode 50\n",
+ "running reward: 13.01 at episode 60\n",
+ "running reward: 21.78 at episode 70\n",
+ "running reward: 40.54 at episode 80\n",
+ "running reward: 73.70 at episode 90\n",
+ "running reward: 100.19 at episode 100\n",
+ "running reward: 159.20 at episode 110\n",
+ "Solved at episode 114!\n"
+ ]
+ }
+ ],
+ "source": [
+ "optimizer = keras.optimizers.Adam(learning_rate=0.01)\n",
+ "huber_loss = keras.losses.Huber()\n",
+ "episode_count = 0\n",
+ "running_reward = 0\n",
+ "\n",
+ "while True: # Run until solved\n",
+ " state = env.reset()\n",
+ " episode_reward = 0\n",
+ " with tf.GradientTape() as tape:\n",
+ " _,_,action_probs, rewards, critic_values = run_episode()\n",
+ " episode_reward = np.sum(rewards)\n",
+ " \n",
+ " # Update running reward to check condition for solving\n",
+ " running_reward = 0.05 * episode_reward + (1 - 0.05) * running_reward\n",
+ "\n",
+ " # Calculate discounted rewards that will be labels for our critic\n",
+ " dr = discounted_rewards(rewards)\n",
+ "\n",
+ " # Calculating loss values to update our network\n",
+ " actor_losses = []\n",
+ " critic_losses = []\n",
+ " for log_prob, value, rew in zip(action_probs, critic_values, dr):\n",
+ " # When we took the action with probability `log_prob`, we received discounted reward of `rew`,\n",
+ " # while critic predicted it to be `value` \n",
+ " # First we calculate actor loss, to make actor predict actions that lead to higher rewards\n",
+ " diff = rew - value\n",
+ " actor_losses.append(-log_prob * diff)\n",
+ "\n",
+ " # The critic loss is to minimize the difference between predicted reward `value` and actual\n",
+ " # discounted reward `rew`\n",
+ " critic_losses.append(\n",
+ " huber_loss(tf.expand_dims(value, 0), tf.expand_dims(rew, 0))\n",
+ " )\n",
+ "\n",
+ " # Backpropagation\n",
+ " loss_value = sum(actor_losses) + sum(critic_losses)\n",
+ " grads = tape.gradient(loss_value, model.trainable_variables)\n",
+ " optimizer.apply_gradients(zip(grads, model.trainable_variables))\n",
+ "\n",
+ " # Log details\n",
+ " episode_count += 1\n",
+ " if episode_count % 10 == 0:\n",
+ " template = \"running reward: {:.2f} at episode {}\"\n",
+ " print(template.format(running_reward, episode_count))\n",
+ "\n",
+ " if running_reward > 195: # Condition to consider the task solved\n",
+ " print(\"Solved at episode {}!\".format(episode_count))\n",
+ " break\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Let's run the episode and see how good our model is:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 99,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "_ = run_episode(render=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Finally, let's close the environment."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 106,
+ "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 71f925f1604f3f7c78fb29ef7af46c3077774afa..6315a1ce6dad4098e5023ece209c5c0ca2c45f3a 100644
--- a/lessons/6-Other/22-DeepRL/CartPole-RL-TF.ipynb
+++ b/lessons/6-Other/22-DeepRL/CartPole-RL-TF.ipynb
@@ -26,14 +26,10 @@
"text": [
"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",
- "Collecting pygame\n",
- " Downloading pygame-2.1.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (21.9 MB)\n",
- "\u001b[2K \u001b[90m鈹佲攣鈹佲攣鈹佲攣鈹佲攣鈹佲攣鈹佲攣鈹佲攣鈹佲攣鈹佲攣鈹佲攣鈹佲攣鈹佲攣鈹佲攣鈹佲攣鈹佲攣鈹佲攣鈹佲攣鈹佲攣鈹佲攣鈹佲攣\u001b[0m \u001b[32m21.9/21.9 MB\u001b[0m \u001b[31m3.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n",
- "\u001b[?25hRequirement 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",
+ "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",
- "Installing collected packages: pygame\n",
- "Successfully installed pygame-2.1.2\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"
]
}
],
@@ -115,27 +111,41 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "[-0.01453476 -0.23855041 -0.04445581 0.29491952] -> 1.0\n",
- "[-0.01930577 -0.4330113 -0.03855742 0.57325697] -> 1.0\n",
- "[-0.027966 -0.62757206 -0.02709228 0.8535481 ] -> 1.0\n",
- "[-0.04051744 -0.43209147 -0.01002132 0.55247074] -> 1.0\n",
- "[-0.04915927 -0.23683023 0.00102809 0.25664735] -> 1.0\n",
- "[-0.05389587 -0.04172298 0.00616104 -0.03571114] -> 1.0\n",
- "[-0.05473033 0.15331008 0.00544682 -0.32644385] -> 1.0\n",
- "[-0.05166413 0.34835407 -0.00108206 -0.6174041 ] -> 1.0\n",
- "[-0.04469705 0.15324724 -0.01343014 -0.3250622 ] -> 1.0\n",
- "[-0.0416321 0.34855783 -0.01993139 -0.62195 ] -> 1.0\n",
- "[-0.03466095 0.54395235 -0.03237038 -0.92084295] -> 1.0\n",
- "[-0.0237819 0.7394964 -0.05078724 -1.2235206 ] -> 1.0\n",
- "[-0.00899197 0.5450641 -0.07525766 -0.9471733 ] -> 1.0\n",
- "[ 0.00190931 0.7411144 -0.09420113 -1.2625213 ] -> 1.0\n",
- "[ 0.0167316 0.54731464 -0.11945155 -1.0007646 ] -> 1.0\n",
- "[ 0.02767789 0.74381286 -0.13946684 -1.3284469 ] -> 1.0\n",
- "[ 0.04255415 0.55069894 -0.16603577 -1.0824591 ] -> 1.0\n",
- "[ 0.05356812 0.35811067 -0.18768495 -0.84614 ] -> 1.0\n",
- "[ 0.06073034 0.55522907 -0.20460775 -1.1914812 ] -> 1.0\n",
- "[ 0.07183492 0.7523274 -0.22843738 -1.5406975 ] -> 1.0\n",
- "Total reward: 20.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"
]
}
],
@@ -186,22 +196,22 @@
"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:22:33.879054: 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:22:33.879079: 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",
+ "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:22:35.795765: 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:22:35.795964: 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:22:35.796020: 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:22:35.796070: 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:22:35.796120: 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:22:35.796169: 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:22:35.796218: 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:22:35.796267: 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:22:35.796317: 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:22:35.796325: 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",
+ "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:22:35.796558: 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",
+ "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"
]
}
@@ -321,53 +331,56 @@
},
{
"cell_type": "code",
- "execution_count": 9,
+ "execution_count": 8,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
- "0 -> 220.0\n",
- "100 -> 499.0\n"
+ "0 -> 29.0\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
- "2022-07-24 16:24:08.306764: W tensorflow/core/data/root_dataset.cc:247] Optimization loop failed: CANCELLED: Operation was cancelled\n",
- "2022-07-24 16:24:18.603528: W tensorflow/core/data/root_dataset.cc:247] Optimization loop failed: CANCELLED: Operation was cancelled\n"
+ "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": [
- "200 -> 499.0\n"
+ "100 -> 135.0\n",
+ "200 -> 484.0\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
- "2022-07-24 16:25:03.522510: W tensorflow/core/data/root_dataset.cc:247] Optimization loop failed: CANCELLED: Operation was cancelled\n",
- "2022-07-24 16:25:08.844014: W tensorflow/core/data/root_dataset.cc:247] Optimization loop failed: CANCELLED: Operation was cancelled\n"
+ "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": [
- "[<matplotlib.lines.Line2D at 0x7fe3b268a650>]"
+ "[<matplotlib.lines.Line2D at 0x7f40201e7b20>]"
]
},
- "execution_count": 9,
+ "execution_count": 8,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
- "image/png": "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",
+ "image/png": "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",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
@@ -406,7 +419,7 @@
},
{
"cell_type": "code",
- "execution_count": 11,
+ "execution_count": 10,
"metadata": {},
"outputs": [
{
@@ -416,8 +429,8 @@
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31merror\u001b[0m Traceback (most recent call last)",
- "\u001b[0;32m/tmp/ipykernel_37078/1459719159.py\u001b[0m in \u001b[0;36m<module>\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_37078/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/tmp/ipykernel_44248/1459719159.py\u001b[0m in \u001b[0;36m<module>\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",
@@ -454,7 +467,7 @@
},
{
"cell_type": "code",
- "execution_count": 103,
+ "execution_count": null,
"metadata": {},
"outputs": [],
"source": [
@@ -479,7 +492,7 @@
},
{
"cell_type": "code",
- "execution_count": 104,
+ "execution_count": null,
"metadata": {},
"outputs": [],
"source": [
@@ -512,7 +525,7 @@
},
{
"cell_type": "code",
- "execution_count": 105,
+ "execution_count": null,
"metadata": {},
"outputs": [
{
@@ -594,7 +607,7 @@
},
{
"cell_type": "code",
- "execution_count": 99,
+ "execution_count": null,
"metadata": {},
"outputs": [],
"source": [
@@ -610,7 +623,7 @@
},
{
"cell_type": "code",
- "execution_count": 106,
+ "execution_count": null,
"metadata": {},
"outputs": [],
"source": [