reinforce_baseline.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# REINFORCE with Baseline Monte Carlo\n",
    "\n",
    "This notebook demonstates an improved version of the REINFORCE policy gradient method, called REINFORCE with Baseline. This is the Monte Carlo version of REINFORCE, which means the model can only be updated after the episode has terminated. We will be using the Cartpole environment, since episode termination is easy to achieve on this problem. Monte Carlo algorithms are not well suited to environments that don't provide a straight forward termination path, because they can get stuck in an infinite loop and never complete the first episode, due to not being able to learn during the episode.\n",
    "\n",
    "Unlike the vanilla REINFORCE, we will be using a state-value function to assist with training. The state-value function will help reduce variance in the sample estimate for the policy gradient and ensure the model converges to the optimal solution quicker. We will be using multi-layer perceptron's for both the policy function and state-value function. The algorithm is on-policy, so it starts by generating an episode $S_0, A_0, R_1, ..., S_{T-1}, A_{T-1}, R_T$, following the policy, $\\pi_\\theta$, until the terminal time step $T$. After the episode has completed, the policy, $\\pi_\\theta$, and state-value functions, $\\hat{v}(S_t, w)$, weights are updated. The state-value function will be used as a baseline, which will be subtracted by the return, $G_t$, to give us the error, $\\delta$. $\\delta$, is given by:\n",
    "$$\\delta_t \\leftarrow G_t - \\hat{v}(S_t, w),$$\n",
    "where $G_t$ is the discounted return from timestep $t$, given by,\n",
    "$$G_t \\leftarrow \\sum_{k=t+1}^{T}\\gamma^{k-t-1}R_k,$$\n",
    "where $\\gamma$ is the discount rate, and $R_k$ is the reward at time step $k$. The error, $\\delta$, is then used in place of the return to update the state-value parameters, $w$, in the following update:\n",
    "$$w \\leftarrow w + \\alpha^{w}\\nabla\\hat{v}(S_t, w)\\delta_t,$$\n",
    "where $\\alpha$ is the step-size or learning rate. The error, $\\delta$, is also used in place of the return to update policy parameters, $\\theta$, in the following update:\n",
    "$$\\theta \\leftarrow \\theta + \\alpha^{\\theta} \\gamma^{t} \\nabla_\\theta \\log(\\pi_\\theta(a_t | s_t))\\delta_t.$$\n",
    "\n",
    "Using the error, $\\delta$, in-place of the return, $G_t$, ensures that the performance of an action taken is easier to measure. For example in the Cartpole problem the rewards are based on time spent in a non-terminal state. This results in a linear decrease in the returns from the earlier states to the later states. Regardless of the action taken in the first few states, the returns will always be high, this results in a small difference in return between taking a bad action and a good action. Similarly in the last few states the returns will be low regardless of whether a good or bad action was taken. But when using the state-value baseline, the return from the action is essentially compared against the expected average return in that state. So choosing a bad action will result in a lower return than the state-value functions expected return, resulting in a negative $\\delta$. If the action is better than the state-value functions expected return then the $\\delta$ will be positive. This ensures that the direction and size of the parameter update is more appropriate for the action taken in that state. \n",
    "\n",
    "For more information on the REINFORCE Baseline algorithm, see OpenAI's post [Baselines in Policy Gradients](https://spinningup.openai.com/en/latest/spinningup/rl_intro3.html#baselines-in-policy-gradients), and chapter 13.4 of [Reinforcement Learning: An Introduction](http://incompleteideas.net/book/RLbook2018.pdf).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import gymnasium as gym\n",
    "import numpy as np\n",
    "from IPython.display import Video\n",
    "import jax\n",
    "import flax.linen as nn\n",
    "from jax import random\n",
    "from jax import value_and_grad\n",
    "import jax.numpy as jnp\n",
    "import optax\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Type of environment, options include:\n",
    "# CartPole-v1\n",
    "ENV_TYPE = \"CartPole-v1\"\n",
    "\n",
    "# Save videos from training\n",
    "SAVE_VIDEOS = False\n",
    "VIDEOS_ROOT_DIR = './videos/reinforce_baseline/'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the environment\n",
    "env = gym.make(ENV_TYPE, render_mode=\"rgb_array\")\n",
    "\n",
    "# Number of possible states and actions\n",
    "num_actions = env.action_space.n\n",
    "obs_dims = env.observation_space.shape\n",
    "obs_upper_bounds = env.observation_space.high\n",
    "obs_lower_bounds = env.observation_space.low"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create The Policy "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "An NVIDIA GPU may be present on this machine, but a CUDA-enabled jaxlib is not installed. Falling back to cpu.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\u001b[3m                               _policy_fn Summary                               \u001b[0m\n",
      "┏━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
      "┃\u001b[1m \u001b[0m\u001b[1mpath   \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mmodule    \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1minputs      \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1moutputs     \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mparams                 \u001b[0m\u001b[1m \u001b[0m┃\n",
      "┡━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
      "│         │ _policy_fn │ \u001b[2mfloat32\u001b[0m[4]   │ \u001b[2mfloat32\u001b[0m[2]   │                         │\n",
      "├─────────┼────────────┼──────────────┼──────────────┼─────────────────────────┤\n",
      "│ Dense_0 │ Dense      │ \u001b[2mfloat32\u001b[0m[4]   │ \u001b[2mfloat32\u001b[0m[256] │ bias: \u001b[2mfloat32\u001b[0m[256]      │\n",
      "│         │            │              │              │ kernel: \u001b[2mfloat32\u001b[0m[4,256]  │\n",
      "│         │            │              │              │                         │\n",
      "│         │            │              │              │ \u001b[1m1,280 \u001b[0m\u001b[1;2m(5.1 KB)\u001b[0m          │\n",
      "├─────────┼────────────┼──────────────┼──────────────┼─────────────────────────┤\n",
      "│ Dense_1 │ Dense      │ \u001b[2mfloat32\u001b[0m[256] │ \u001b[2mfloat32\u001b[0m[64]  │ bias: \u001b[2mfloat32\u001b[0m[64]       │\n",
      "│         │            │              │              │ kernel: \u001b[2mfloat32\u001b[0m[256,64] │\n",
      "│         │            │              │              │                         │\n",
      "│         │            │              │              │ \u001b[1m16,448 \u001b[0m\u001b[1;2m(65.8 KB)\u001b[0m        │\n",
      "├─────────┼────────────┼──────────────┼──────────────┼─────────────────────────┤\n",
      "│ Dense_2 │ Dense      │ \u001b[2mfloat32\u001b[0m[64]  │ \u001b[2mfloat32\u001b[0m[2]   │ bias: \u001b[2mfloat32\u001b[0m[2]        │\n",
      "│         │            │              │              │ kernel: \u001b[2mfloat32\u001b[0m[64,2]   │\n",
      "│         │            │              │              │                         │\n",
      "│         │            │              │              │ \u001b[1m130 \u001b[0m\u001b[1;2m(520 B)\u001b[0m             │\n",
      "├─────────┼────────────┼──────────────┼──────────────┼─────────────────────────┤\n",
      "│\u001b[1m \u001b[0m\u001b[1m       \u001b[0m\u001b[1m \u001b[0m│\u001b[1m \u001b[0m\u001b[1m          \u001b[0m\u001b[1m \u001b[0m│\u001b[1m \u001b[0m\u001b[1m            \u001b[0m\u001b[1m \u001b[0m│\u001b[1m \u001b[0m\u001b[1m       Total\u001b[0m\u001b[1m \u001b[0m│\u001b[1m \u001b[0m\u001b[1m17,858 \u001b[0m\u001b[1;2m(71.4 KB)\u001b[0m\u001b[1m       \u001b[0m\u001b[1m \u001b[0m│\n",
      "└─────────┴────────────┴──────────────┴──────────────┴─────────────────────────┘\n",
      "\u001b[1m                                                                                \u001b[0m\n",
      "\u001b[1m                       Total Parameters: 17,858 \u001b[0m\u001b[1;2m(71.4 KB)\u001b[0m\u001b[1m                       \u001b[0m\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "class _policy_fn(nn.Module):\n",
    "\n",
    "    @nn.compact\n",
    "    def __call__(self, x):\n",
    "        x = nn.Dense(256)(x)\n",
    "        x = jax.nn.relu(x)\n",
    "        x = nn.Dense(64)(x)\n",
    "        x = jax.nn.relu(x)\n",
    "        x = nn.Dense(num_actions)(x)\n",
    "        return jax.nn.softmax(x)\n",
    "\n",
    "# Create the model object\n",
    "policy_fn = _policy_fn()\n",
    "# Display the model details\n",
    "dummy_x, _ = env.reset()\n",
    "rng_key = random.PRNGKey(64)\n",
    "print(policy_fn.tabulate(rng_key, dummy_x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\u001b[3m                              _value_fn Summary                               \u001b[0m\n",
      "┏━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
      "┃\u001b[1m \u001b[0m\u001b[1mpath   \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mmodule   \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1minputs      \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1moutputs     \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mparams                \u001b[0m\u001b[1m \u001b[0m┃\n",
      "┡━━━━━━━━━╇━━━━━━━━━━━╇━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
      "│         │ _value_fn │ \u001b[2mfloat32\u001b[0m[4]   │ \u001b[2mfloat32\u001b[0m[1]   │                        │\n",
      "├─────────┼───────────┼──────────────┼──────────────┼────────────────────────┤\n",
      "│ Dense_0 │ Dense     │ \u001b[2mfloat32\u001b[0m[4]   │ \u001b[2mfloat32\u001b[0m[256] │ bias: \u001b[2mfloat32\u001b[0m[256]     │\n",
      "│         │           │              │              │ kernel: \u001b[2mfloat32\u001b[0m[4,256] │\n",
      "│         │           │              │              │                        │\n",
      "│         │           │              │              │ \u001b[1m1,280 \u001b[0m\u001b[1;2m(5.1 KB)\u001b[0m         │\n",
      "├─────────┼───────────┼──────────────┼──────────────┼────────────────────────┤\n",
      "│ Dense_1 │ Dense     │ \u001b[2mfloat32\u001b[0m[256] │ \u001b[2mfloat32\u001b[0m[1]   │ bias: \u001b[2mfloat32\u001b[0m[1]       │\n",
      "│         │           │              │              │ kernel: \u001b[2mfloat32\u001b[0m[256,1] │\n",
      "│         │           │              │              │                        │\n",
      "│         │           │              │              │ \u001b[1m257 \u001b[0m\u001b[1;2m(1.0 KB)\u001b[0m           │\n",
      "├─────────┼───────────┼──────────────┼──────────────┼────────────────────────┤\n",
      "│\u001b[1m \u001b[0m\u001b[1m       \u001b[0m\u001b[1m \u001b[0m│\u001b[1m \u001b[0m\u001b[1m         \u001b[0m\u001b[1m \u001b[0m│\u001b[1m \u001b[0m\u001b[1m            \u001b[0m\u001b[1m \u001b[0m│\u001b[1m \u001b[0m\u001b[1m       Total\u001b[0m\u001b[1m \u001b[0m│\u001b[1m \u001b[0m\u001b[1m1,537 \u001b[0m\u001b[1;2m(6.1 KB)\u001b[0m\u001b[1m        \u001b[0m\u001b[1m \u001b[0m│\n",
      "└─────────┴───────────┴──────────────┴──────────────┴────────────────────────┘\n",
      "\u001b[1m                                                                              \u001b[0m\n",
      "\u001b[1m                       Total Parameters: 1,537 \u001b[0m\u001b[1;2m(6.1 KB)\u001b[0m\u001b[1m                       \u001b[0m\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "class _value_fn(nn.Module):\n",
    "\n",
    "    @nn.compact\n",
    "    def __call__(self, x):\n",
    "        x = nn.Dense(256)(x)\n",
    "        x = jax.nn.relu(x)\n",
    "        x = nn.Dense(1)(x)\n",
    "        return x\n",
    "\n",
    "# Create the model object\n",
    "value_fn = _value_fn()\n",
    "# Display the model details\n",
    "print(value_fn.tabulate(rng_key, dummy_x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def policy_loss_fn(policy_variables, value_variables, states, actions, returns):\n",
    "    action_dists = policy_fn.apply(policy_variables, states)\n",
    "    probs = action_dists[jnp.arange(len(actions)), actions]\n",
    "    values = value_fn.apply(value_variables, states)\n",
    "    values = values.flatten()\n",
    "    errors = returns - values\n",
    "    log_probs = jnp.log(probs)\n",
    "    loss = -(log_probs * errors).mean()\n",
    "    return loss "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def value_loss_fn(variables, states, returns):\n",
    "    values = value_fn.apply(variables, states)\n",
    "    values = values.flatten()\n",
    "    errors = returns - values\n",
    "    loss = (errors * values).mean()\n",
    "    return loss "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Learn The Optimal Action-Value Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ubuntu22/repos/reinforcement-learning-algorithms/venv-pre/lib/python3.10/site-packages/gymnasium/wrappers/rendering.py:282: UserWarning: \u001b[33mWARN: Overwriting existing videos at /home/ubuntu22/repos/reinforcement-learning-algorithms/videos/reinforce_baseline folder (try specifying a different `video_folder` for the `RecordVideo` wrapper if this is not desired)\u001b[0m\n",
      "  logger.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode 5 Average Returns: 37.60\n",
      "Episode 10 Average Returns: 34.00\n",
      "Episode 15 Average Returns: 52.60\n",
      "Episode 20 Average Returns: 43.20\n",
      "Episode 25 Average Returns: 71.40\n",
      "Episode 30 Average Returns: 59.80\n",
      "Episode 35 Average Returns: 110.00\n",
      "Episode 40 Average Returns: 93.60\n",
      "Episode 45 Average Returns: 122.60\n",
      "Episode 50 Average Returns: 159.60\n"
     ]
    }
   ],
   "source": [
    "# Number of episodes to train on\n",
    "episodes = 53\n",
    "# Sliding window for episode evaluation (needs to be less than episodes)\n",
    "episode_window = 5\n",
    "# Discount ratio\n",
    "gamma = 0.99 \n",
    "# Step size\n",
    "policy_alpha = 0.001\n",
    "value_alpha = 0.001\n",
    "\n",
    "policy_variables = policy_fn.init(rng_key, dummy_x)\n",
    "policy_optimizer = optax.adam(learning_rate=policy_alpha)\n",
    "policy_opt_state = policy_optimizer.init(policy_variables)\n",
    "\n",
    "value_variables = value_fn.init(rng_key, dummy_x)\n",
    "value_optimizer = optax.adam(learning_rate=value_alpha)\n",
    "value_opt_state = value_optimizer.init(value_variables)\n",
    "\n",
    "env = gym.make(ENV_TYPE, render_mode=\"rgb_array\")\n",
    "env = gym.wrappers.RecordEpisodeStatistics(env, buffer_length=episodes)\n",
    "\n",
    "if SAVE_VIDEOS:\n",
    "    os.makedirs(VIDEOS_ROOT_DIR, exist_ok=True)\n",
    "    env = gym.wrappers.RecordVideo(\n",
    "        env=env, \n",
    "        video_folder=VIDEOS_ROOT_DIR,\n",
    "        episode_trigger=lambda episode: episode % 10 == 0,\n",
    "        video_length=0,\n",
    "        name_prefix=ENV_TYPE,\n",
    "        fps=30\n",
    "        )\n",
    "\n",
    "for episode in range(1, episodes+1):\n",
    "    terminated, truncated = False, False\n",
    "    reward = 0\n",
    "    rewards = []\n",
    "    state, info = env.reset()\n",
    "    states = []\n",
    "    actions = []\n",
    "    # Generate an episode following the policy\n",
    "    while not (terminated or truncated):\n",
    "        states.append(state)\n",
    "        # Select the action following the parametrized policy\n",
    "        action_dist = policy_fn.apply(policy_variables, state)\n",
    "        action_dist = np.array(action_dist).astype(np.float64)\n",
    "        # Divide by the total to ensure the values sum to one\n",
    "        action_dist /= action_dist.sum()\n",
    "        action = np.random.choice(np.arange(num_actions), p=action_dist)\n",
    "        actions.append(action)\n",
    "        # Take the action and observe reward and next state\n",
    "        next_state, reward, terminated, truncated, info = env.step(int(action))\n",
    "        rewards.append(reward)\n",
    "        state = next_state\n",
    "\n",
    "\n",
    "    rewards = jnp.array(rewards)\n",
    "    states = jnp.array(states)\n",
    "    actions = jnp.array(actions)\n",
    "\n",
    "    T = len(states)\n",
    "    weights = []\n",
    "    # Update the policies parameters\n",
    "    for t, state in enumerate(states):\n",
    "        G = 0\n",
    "        for k in range(t, T):\n",
    "            G += (gamma**(k - t)) * rewards[k]\n",
    "        weights.append(G)\n",
    "    weights = jnp.array(weights)\n",
    "\n",
    "    value_loss, value_grads = value_and_grad(value_loss_fn, argnums=0)(value_variables, states, weights)\n",
    "    value_updates, value_opt_state = value_optimizer.update(value_grads, value_opt_state, value_variables)\n",
    "    value_variables = optax.apply_updates(value_variables, value_updates)\n",
    "\n",
    "    policy_loss, policy_grads = value_and_grad(policy_loss_fn, argnums=0)(policy_variables, value_variables, states, actions, weights)\n",
    "    policy_updates, policy_opt_state = policy_optimizer.update(policy_grads, policy_opt_state, policy_variables)\n",
    "    policy_variables = optax.apply_updates(policy_variables, policy_updates)\n",
    "            \n",
    "\n",
    "    if episode % episode_window == 0:\n",
    "        print(f'Episode {episode} Average Returns: {np.mean(np.array(env.env.return_queue).flatten()[-episode_window:]) :.2f}')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot The Results\n",
    "\n",
    "For cartpole rewards are assigned for the time spent in a non-terminal state. The episode length and rewards will be identical in this case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Code used from: https://gymnasium.farama.org/tutorials/blackjack_tutorial/#visualizing-the-training\n",
    "fig, axs = plt.subplots(ncols=2, figsize=(12, 5))\n",
    "axs[0].set_title(\"Episode rewards\")\n",
    "reward_moving_average = (\n",
    "    np.convolve(\n",
    "        np.array(env.env.return_queue).flatten(), np.ones(episode_window), mode=\"valid\"\n",
    "    )\n",
    "    / episode_window\n",
    ")\n",
    "axs[0].plot(range(len(reward_moving_average)), reward_moving_average)\n",
    "axs[1].set_title(\"Episode lengths\")\n",
    "length_moving_average = (\n",
    "    np.convolve(\n",
    "        np.array(env.env.length_queue).flatten(), np.ones(episode_window), mode=\"valid\"\n",
    "    )\n",
    "    / episode_window\n",
    ")\n",
    "axs[1].plot(range(len(length_moving_average)), length_moving_average)\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training Episode Videos"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Episode 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<video src=\"./videos/reinforce_baseline//CartPole-v1-episode-0.mp4\" controls  >\n",
       "      Your browser does not support the <code>video</code> element.\n",
       "    </video>"
      ],
      "text/plain": [
       "<IPython.core.display.Video object>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Video(f\"{VIDEOS_ROOT_DIR}/{ENV_TYPE}-episode-0.mp4\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Episode 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<video src=\"./videos/reinforce_baseline//CartPole-v1-episode-10.mp4\" controls  >\n",
       "      Your browser does not support the <code>video</code> element.\n",
       "    </video>"
      ],
      "text/plain": [
       "<IPython.core.display.Video object>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Video(f\"{VIDEOS_ROOT_DIR}/{ENV_TYPE}-episode-10.mp4\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Episode 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<video src=\"./videos/reinforce_baseline//CartPole-v1-episode-20.mp4\" controls  >\n",
       "      Your browser does not support the <code>video</code> element.\n",
       "    </video>"
      ],
      "text/plain": [
       "<IPython.core.display.Video object>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Video(f\"{VIDEOS_ROOT_DIR}/{ENV_TYPE}-episode-20.mp4\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Episode 30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<video src=\"./videos/reinforce_baseline//CartPole-v1-episode-30.mp4\" controls  >\n",
       "      Your browser does not support the <code>video</code> element.\n",
       "    </video>"
      ],
      "text/plain": [
       "<IPython.core.display.Video object>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Video(f\"{VIDEOS_ROOT_DIR}/{ENV_TYPE}-episode-30.mp4\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Episode 40"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<video src=\"./videos/reinforce_baseline//CartPole-v1-episode-40.mp4\" controls  >\n",
       "      Your browser does not support the <code>video</code> element.\n",
       "    </video>"
      ],
      "text/plain": [
       "<IPython.core.display.Video object>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Video(f\"{VIDEOS_ROOT_DIR}/{ENV_TYPE}-episode-40.mp4\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Episode 50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<video src=\"./videos/reinforce_baseline//CartPole-v1-episode-50.mp4\" controls  >\n",
       "      Your browser does not support the <code>video</code> element.\n",
       "    </video>"
      ],
      "text/plain": [
       "<IPython.core.display.Video object>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Video(f\"{VIDEOS_ROOT_DIR}/{ENV_TYPE}-episode-50.mp4\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "flax",
   "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.12"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "0a8d1f2580cdfde5c5829808ec6fccc81a351d243fb8b1925f7928e44ccf575b"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}