21como-intro-to-deeplearning/3b-policy-gradient-harder.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a630157d-339d-4588-b2ba-6b01225644e2",
   "metadata": {},
   "source": [
    "# Introduction to Deep Learning\n",
    "\n",
    "## Hands-on 3a: Reinforcement Learning with Policy Gradient\n",
    "Giuseppe Carleo and Filippo Vicentini\n",
    "\n",
    "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/PhilipVinc/Lectures/blob/master/21como-intro-to-deeplearning/3b-policy-gradient-harder.ipynb) \n",
    "\n",
    "### Link to the GitHub repository:\n",
    "https://github.com/PhilipVinc/IntroDeepLearning   or  https://bit.ly/3ki90ki"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca2c0f0a-6af1-4fbb-8c2f-fc68bcadc8c5",
   "metadata": {},
   "source": [
    "## Intro\n",
    "\n",
    "This is a followup to notebook 3a (policy gradient). It reproduces the same problem but uses a variable map and try to train a policy to solve different environments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e291a1fd-b3e2-4d18-920a-e1b36f2519c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "#!pip install gym coax jax haiku flax optax matplotlib pygame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "eb14da3d-b46c-4c6d-ba9d-5cf930c28597",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import all things\n",
    "import gym               # defines the problem\n",
    "import coax              # easy to use policy gradient learning\n",
    "import jax               # \n",
    "import jax.numpy as jnp  #\n",
    "import haiku as hk       # easy to define neural networks\n",
    "import optax             # optimisers\n",
    "from matplotlib import pyplot as plt\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "37d55f19-6ed5-4db3-867a-65cb1f1a6d67",
   "metadata": {},
   "outputs": [],
   "source": [
    "# First, we define the problem\n",
    "env = gym.make('FrozenLake-v1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c83bc62b-9151-4f93-9087-50ae06a9daff",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can initialise a 'trajectory', or the 'state' of the system \n",
    "env.reset()\n",
    "# And then we can 'render' the current state with fancy graphics.\n",
    "env.render()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ef794bc0-b008-43d8-849c-4a2f47f501f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# By the way, we will later see that it's possible to generate other maps\n",
    "import gym\n",
    "\n",
    "from gym.envs.toy_text.frozen_lake import generate_random_map\n",
    "\n",
    "# size is the edge of the map, p is the probability to have ice (so $1-p$ is probability to have an hole)\n",
    "random_map = generate_random_map(size=4, p=0.8)\n",
    "\n",
    "# Then we provide the map object to the environemnt\n",
    "env = gym.make(\"FrozenLake-v1\", desc=random_map, is_slippery=False) # creating the FrozenLake environment\n",
    "env.reset()                     # reseting the environment to its initial state\n",
    "env.render()                    # prints the environment state to the standard output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "043f14e0-2d34-4ea5-a31e-ab70a4a036b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0 -1  0  0  0  0  0  0  0  0  0 -1  0  0  0  1]\n"
     ]
    }
   ],
   "source": [
    "def val(x):\n",
    "    if x == 'H':\n",
    "        return -1\n",
    "    elif x == 'G':\n",
    "        return 1\n",
    "    else:\n",
    "        return 0\n",
    "data = [[val(tile) for tile in line] for line in random_map]\n",
    "tile_data = np.array(data).flatten()\n",
    "print(tile_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "32147204-8a48-448c-8586-ba69ac5ae9ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "def map_state_values(desc):\n",
    "    data = [[val(tile) for tile in line] for line in random_map]\n",
    "    tile_data = jnp.array(data).flatten()\n",
    "    return tile_data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65ae567b-ddd4-423c-8391-1816feafc887",
   "metadata": {},
   "source": [
    "However, how do we store in memory the data representing the position of the elf, that of the target, and how do we encode our possible actions so that we can create a mathematical model of the problem?\n",
    "\n",
    "### Observation Space\n",
    "\n",
    "The observation is a value representing the agent's current position as `current_row * nrows + current_col` (where both the row and col start at 0).\n",
    "For example, the goal position in the $4\\times4$ map can be calculated as follows: $3 \\cdot 4 + 3 = 15$.\n",
    "The number of possible observations is dependent on the size of the map.\n",
    "For example, the $4\\times 4$ map has 16 possible observations.\n",
    "\n",
    "In mathematical terms, \n",
    "$$ s_t \\in [0,15]$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "8335768f-037a-487d-91cf-a1eaa84e8bb2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The observation state is:  Discrete(16)\n"
     ]
    }
   ],
   "source": [
    "print(\"The observation state is: \", env.observation_space)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "392a62f8-6225-43ca-b25d-077953c4f1b3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "And a random cofiguration will be:  3\n"
     ]
    }
   ],
   "source": [
    "print(\"And a random cofiguration will be: \", env.observation_space.sample())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab7d2cac-77de-4bc5-8c2b-d288021e0c57",
   "metadata": {},
   "source": [
    "### Action Space\n",
    "The agent takes a 1-element vector (aka, a scalar) for actions.\n",
    "The action space is `(dir)`, where `dir` decides direction to move in which can be:\n",
    "- 0: LEFT\n",
    "- 1: DOWN\n",
    "- 2: RIGHT\n",
    "- 3: UP\n",
    "\n",
    "In mathematical terms, \n",
    "$$ a_t \\in [0,3]$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "c50649e3-29bc-469a-8104-d5e0053c9ca6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The action space is:  Discrete(4)\n"
     ]
    }
   ],
   "source": [
    "print(\"The action space is: \", env.action_space)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f268ee2d-fdb3-4472-822d-2f762bee8922",
   "metadata": {},
   "source": [
    "### Reward\n",
    "\n",
    "Reward schedule $r_t(s_t)$:\n",
    "- Reach goal(G): +1\n",
    "- Reach hole(H): 0\n",
    "- Reach frozen(F): 0\n",
    "\n",
    "Note that the rewards for a succesful run will therefore be $r_0 = 0$, $r_1=0$ ... $r_T = 1$, so any succesful run will have\n",
    "$$\n",
    "R = \\sum_{t=0}^T r_t = 1,\n",
    "$$\n",
    "because we're giving a reward only when we hit the goa.\n",
    "\n",
    "This means that the reward for solving the puzzle in the smallest amount of moves, or infinitely main moves, is the same. To bias the policy to solve in fewer moves the puzzle, we can add some negative reward at every step."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8fbe1b6-cfd9-4b16-930a-24ba591df8e7",
   "metadata": {},
   "source": [
    "## Defining the policy\n",
    "\n",
    "We want to define the policy $ pi(a | s_t) $ that gives the probability of each move $a={0,1,2,3}$ given a current state configuration $s_t$.\n",
    "\n",
    "To have a simpler implentation we will define $\\pi : {0,1\\dots 15} \\rightarrow \\mathbb{R}^4 $, which will return the unnormalized log-probability of every action. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "080b59ec-3238-4866-9828-4a6b5d6c8e76",
   "metadata": {},
   "outputs": [],
   "source": [
    "def π_fun(S, is_training):\n",
    "    map_values = hk.get_state(\"map\", shape=S.shape, dtype=jnp.int32, init=jnp.zeros)\n",
    "    map_values = map_values.reshape(S.shape)\n",
    "    \n",
    "    state_and_map = jnp.hstack([map_values, S])\n",
    "    logits = hk.Linear(env.action_space.n, w_init=jnp.zeros)\n",
    "    \n",
    "    return {'logits': logits(state_and_map)}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b67fefbb-7f72-4418-8594-8a281e9cf165",
   "metadata": {},
   "source": [
    "We can investigate how that works..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a0aa8269-300e-40c7-9956-cc7192cd8416",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "({'logits': DeviceArray([0., 0., 0., 0.], dtype=float32)},\n",
       " {'~': {'map': DeviceArray([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], dtype=int32)}})"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# For example, this gives us\n",
    "forward = hk.transform_with_state(π_fun)\n",
    "pars, state = forward.init(jax.random.PRNGKey(1), jax.numpy.zeros(16), True)\n",
    "forward.apply(pars, state, jax.random.PRNGKey(1), jax.numpy.zeros(16), True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97bf721b-1a73-47fc-ae96-24a328d7f764",
   "metadata": {},
   "source": [
    "### Using Coax\n",
    "\n",
    "In principle we'd have to sample from the log-distribution above at every time $t$ to determine a trajectory ${s_1, a_1, s_2, a_2...}$, and we'd have to define the REINFORCE/Policy gradient algorithm ourselves.\n",
    "\n",
    "However, it turns out that somebody already did the hard work for ourselves. See for example https://coax.readthedocs.io/ so we're going to use this package going forward.\n",
    "\n",
    "We can create a Policy from the function `π_fun` and the environment description/state.\n",
    "THis is an object that encapsulates the current parameters of the policy, as well as the current state of the environment. \n",
    "It exposes a few useful functions such as:\n",
    " - `Policy.sample`, which samples a possible configuration given the state the environment is in\n",
    " - `Policy.update`, which updates the weights according to the REINFORCE gradient update"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "85f70e6c-d8b5-4427-9747-1a2f5863fb5a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# First we wrap the environment into a training monitor wrapper, so we can automatically log at every step some information\n",
    "env = coax.wrappers.TrainMonitor(env)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "620e4cbf-1582-4ef6-a0a3-92199a5094dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We create the Policy funciton\n",
    "pi = coax.Policy(π_fun, env)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "40685cbb-bc83-4e3f-8833-3422d0306fa5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# For example, what move can we have if we are in 0?\n",
    "actions = [pi(0) for i in range(1000)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "0565e6e5-4658-4712-9130-0f99d74dd102",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "log probabilities:  {'logits': DeviceArray([0., 0., 0., 0.], dtype=float32)}\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(\"log probabilities: \", pi.dist_params(0))\n",
    "plt.hist(actions);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9fb1623-35e4-4975-bda7-c5f445464746",
   "metadata": {},
   "source": [
    "This is consistent with the fact that our initialisation of the weights is all 0s."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "03a7c668-2e7d-4c20-94cd-5a6b0d453dc5",
   "metadata": {},
   "outputs": [],
   "source": [
    "pi.function_state['~']['map'] = map_state_values(env.desc)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9695b8ee-724d-4907-9818-392152b7e5c5",
   "metadata": {},
   "source": [
    "### Reward tracing \n",
    "\n",
    "We create a reward tracing object, which collects at every time $t$ the reward $r_t$ and eventually discounts it by a factor $\\gamma$ so that\n",
    "\n",
    "$$ R = \\sum_{t=0}^T \\gamma^t r_t $$\n",
    "\n",
    "This is basically a smarter version of a list, that we will use later. Using a $\\gamma < 1$ allows us to give higher rewards to shorter trajectories."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "56f18828-48de-4be2-ae9b-d1da27fac46b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# experience tracer\n",
    "tracer = coax.reward_tracing.MonteCarlo(gamma=0.9)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f898caa8-e9b9-4c39-a7c1-02d988bc2668",
   "metadata": {},
   "source": [
    "### Policy Gradient objective\n",
    "\n",
    "Coax has several objects functions used to train RL algorithms.\n",
    "`VanillaPG` is a A vanilla policy-gradient objective, a.k.a. REINFORCE-style objective.\n",
    "$$J(\\theta; s,a)\\ =\\ \\mathcal{A}(s,a)\\,\\log\\pi_\\theta(a|s)$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "73f28490-cc51-44cf-a865-1c6c36a32268",
   "metadata": {},
   "outputs": [],
   "source": [
    "vanilla_pg = coax.policy_objectives.VanillaPG(pi, optimizer=optax.adam(0.01))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95e6ed19-b5bc-412b-adb6-244f66d84a1b",
   "metadata": {},
   "source": [
    "### Writing down the 'RL' loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "56bf947a-1f11-4092-8e5a-6317224de524",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "# First we reset the environment so we get the initial state\n",
    "s_t = env.reset()\n",
    "print(s_t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "aaf4f789-8262-46ab-a3f2-1b3e8699a05e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "action a_t = 3\n"
     ]
    }
   ],
   "source": [
    "a_t = pi(s_t)\n",
    "print(f\"action a_t = {a_t}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "e27aa9e5-49df-4b89-a4ec-818e88682eb1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s_tnext: 0, r_t:0.0, is_done:False, info:{'prob': 1.0, 'monitor': {'T': 1, 'ep': 1}}\n"
     ]
    }
   ],
   "source": [
    "s_tnext, r_t, is_done, info = env.step(a_t)\n",
    "print(f\"s_tnext: {s_tnext}, r_t:{r_t}, is_done:{is_done}, info:{info}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "e94573e8-af9a-4798-a180-1ad5aad08f49",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We add to the reward tracer this last step\n",
    "tracer.add(s_t, a_t, r_t, is_done)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "080d0a06-3ec0-4956-8def-9771bdf49ce3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# And now, we repeat many times:\n",
    "tracer.reset()\n",
    "s_t = env.reset()\n",
    "for t in range(env.spec.max_episode_steps):\n",
    "    a_t = pi(s_t)\n",
    "    s_tnext, r_t, is_done, info = env.step(a_t)\n",
    "    tracer.add(s_t, a_t, r_t, is_done)\n",
    "    env.render()\n",
    "    \n",
    "    if is_done:\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "066b979c-42ef-49e8-b813-2e4d26b98446",
   "metadata": {},
   "outputs": [],
   "source": [
    "# and we then update the weights according to this\n",
    "while tracer:\n",
    "    transition_batch = tracer.pop()\n",
    "    vanilla_pg.update(transition_batch, Adv=transition_batch.Rn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "d062d809-89c3-414f-aeb5-3c9dce09aafb",
   "metadata": {},
   "outputs": [],
   "source": [
    "#vanilla_pg.pi.params"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "2afe4726-869a-4d31-a5f6-7b0408087f78",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Finally, we do this many times\n",
    "pi = coax.Policy(π_fun, env)\n",
    "vanilla_pg = coax.policy_objectives.VanillaPG(pi, optimizer=optax.adam(0.01))\n",
    "tracer.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bda615c7-ebb6-4242-8c14-ca976b214e0c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# You see that this did not work well. It's because there is no signal at the beginning as the reward is always 0!\n",
    "# Let's try to set the reward to non zero. For example, let's make him not take the useless moves such as up when he's at the top already.\n",
    "\n",
    "pi = coax.Policy(π_fun, env)\n",
    "vanilla_pg = coax.policy_objectives.VanillaPG(pi, optimizer=optax.adam(0.01))\n",
    "tracer.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9f38d438-2eda-4468-8520-b7d70866d3ad",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x15a3079a0>]"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(Rvals*Tsteps)\n",
    "plt.plot(jnp.cumsum(Rvals*Tsteps)/jnp.arange(Rvals.size))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "9caf6f0c-c481-4d2a-9119-fe596cab0fd4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 1)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "556bf89f-1651-4473-9b3d-576b3d14cba0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# You see that this did not work well again because he is not learning to get to the objective, and keeps falling on the holes.\n",
    "# Let's give him a penalty if he falls on the holes\n",
    "\n",
    "pi = coax.Policy(π_fun, env)\n",
    "vanilla_pg = coax.policy_objectives.VanillaPG(pi, optimizer=optax.adam(0.01))\n",
    "tracer.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "5600dd50-5944-4deb-8e3b-ddc6552f6f6b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# train\n",
    "Rvals = []\n",
    "Tsteps = []\n",
    "\n",
    "for ep in range(500):\n",
    "    random_map = generate_random_map(size=4, p=0.8)\n",
    "    env = gym.make(\"FrozenLake-v1\", desc=random_map, is_slippery=False) # creating the FrozenLake environment\n",
    "    env = coax.wrappers.TrainMonitor(env)\n",
    "    pi.function_state['~']['map'] = map_state_values(env.desc)\n",
    "\n",
    "    do_render = ep % 50 == 0\n",
    "\n",
    "    for rep in range(2):\n",
    "        s_t = env.reset()\n",
    "        if do_render:\n",
    "            env.render()\n",
    "\n",
    "        for t in range(env.spec.max_episode_steps):\n",
    "            a_t = pi(s_t)\n",
    "            s_tnext, r_t, is_done, info = env.step(a_t)\n",
    "\n",
    "            if jnp.array_equal(s_tnext, s_t):\n",
    "                r_t = r_t - 0.01\n",
    "            if is_done and s_tnext != 15:\n",
    "                r_t = r_t - 0.05\n",
    "                \n",
    "            xpos, ypos = divmod(s_tnext, 4)\n",
    "            distance = jnp.sqrt((xpos-3)**2 + (ypos-3)**2)\n",
    "            if not is_done:\n",
    "                r_t = r_t + 0.02/distance\n",
    "            \n",
    "            # update\n",
    "            tracer.add(s_t, a_t, r_t, is_done)\n",
    "\n",
    "            while tracer:\n",
    "                transition_batch = tracer.pop()\n",
    "                vanilla_pg.update(transition_batch, Adv=transition_batch.Rn)\n",
    "\n",
    "            if do_render:\n",
    "                env.render()\n",
    "\n",
    "            if is_done:\n",
    "                Rvals.append(env.G)\n",
    "                Tsteps.append(t)\n",
    "                #print(vanilla_pg.pi.params)\n",
    "                break\n",
    "\n",
    "            s_t = s_tnext\n",
    "\n",
    "        # early stopping\n",
    "        if env.avg_G > env.spec.reward_threshold:\n",
    "            break\n",
    "        \n",
    "Rvals = jnp.array(Rvals)\n",
    "Tsteps = jnp.array(Tsteps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "id": "48ba603e-2c9a-480a-b923-e3569f220f8b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x15a4aa080>]"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(Rvals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a65c5ebe-affa-405f-8150-6db2359cdfa8",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python (RL)",
   "language": "python",
   "name": "py-rl"
  },
  "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}