Tabular_TD_MAZE_solver.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "761dea3e",
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "plt.rcParams['font.size'] = 13\n",
    "from IPython.display import display, HTML, Image as IMM\n",
    "from PIL import Image\n",
    "from copy import deepcopy\n",
    "from tqdm.notebook import tqdm"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4766844",
   "metadata": {},
   "source": [
    "### Maze definition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "22d30566",
   "metadata": {},
   "outputs": [],
   "source": [
    "class BuildMaze(): \n",
    "    \"\"\" Defines a maze with variable dimensions. The maze includes special cells of 'Blocks,' \n",
    "    through which one cannot go, 'Holes,' which teleport one back to start, and 'Food' which \n",
    "    elevates one's score. Block, hole, and food locations are defined randomly according to \n",
    "    the desired fractions of those cells. Start and goal locations are at the top left and \n",
    "    bottom right, respectively.\"\"\"\n",
    "    \n",
    "    def __init__(self, rows, cols, cell_fractions, seed=10):\n",
    "        self.rows = rows # maze row count\n",
    "        self.cols = cols # maze column count\n",
    "        self.cell_fractions = cell_fractions # list of block, hole, and food fractions, e.g., [0.3,0.1,0.1]\n",
    "        self.start = [0,0] # start at top left\n",
    "        self.goal = [self.rows-1,self.cols-1] # exit at bottom right\n",
    "        self.seed = seed #fixes the maze structure for a given configuration \n",
    "    \n",
    "    def special_cells(self): \n",
    "        \"\"\"Based on the maze dimensions and desired cell fractions, returns the (row index, column \n",
    "        index) for each special cell. The output is a list of 3 lists, containing the index tuples \n",
    "        for blocks, holes, and food respectively.\"\"\"\n",
    "        \n",
    "        np.random.seed(self.seed)\n",
    "        \n",
    "        # Create a 2D array of zeros \n",
    "        array_2d = np.zeros((self.rows, self.cols), dtype=int) \n",
    "        \n",
    "        # Calculate total number of special cells \n",
    "        total_fraction = np.sum(self.cell_fractions) # <1\n",
    "        num_cells = int(total_fraction * self.rows * self.cols)  \n",
    "        \n",
    "        # Random list of special cell 1D indices (replace=False --> each index used only once)\n",
    "        indices = np.random.choice(self.rows * self.cols, num_cells, replace=False) \n",
    "        \n",
    "        # Randomly choose Block 1D indices out of all special cell 1D indices\n",
    "        num_blocks = int(self.cell_fractions[0]*self.rows * self.cols)\n",
    "        blocks = np.random.choice(indices,num_blocks,replace=False)\n",
    "        \n",
    "        # Randomly choose Hole 1D indices out of remaining special cell 1D indices\n",
    "        remaining_indices = [x for x in indices if x not in blocks]\n",
    "        num_holes = int(self.cell_fractions[1]*self.rows * self.cols)\n",
    "        holes = np.random.choice(remaining_indices,num_holes, replace=False)\n",
    "        \n",
    "        # Food 1D indices are just the remaining special 1D indices\n",
    "        food = [y for y in remaining_indices if y not in holes]\n",
    "\n",
    "        # Convert each 1D special cell index to a 2D special cell index         \n",
    "        Z=[[],[],[]]\n",
    "        i=0\n",
    "        for L in [blocks, holes, food]:\n",
    "            row_indices = np.array(L) // self.cols #integer division to get the row index lists\n",
    "            col_indices = np.array(L) % self.cols #modulo operator to get the column index lists  \n",
    "            \n",
    "            # Make (row,column) tuples for each special cell\n",
    "            rowi, coli = [], []\n",
    "            for k in range(len(row_indices)):\n",
    "                # We do not want special cells right next to start and end points to ensure no blockage\n",
    "                if (row_indices[k]>1 or col_indices[k]>1) and (row_indices[k]<self.rows-2 or col_indices[k]<self.cols-2):\n",
    "                    rowi.append(row_indices[k])\n",
    "                    coli.append(col_indices[k])\n",
    "                    \n",
    "            Z[i] = [(rowi[i], coli[i]) for i in range(len(rowi))]\n",
    "            i += 1\n",
    "        \n",
    "        return Z #e.g., [[(2, 0), (0, 3), (0, 2)], [(1, 3)], [(1, 2)]] for a 4x4 maze\n",
    "    \n",
    "\n",
    "    def maze_rgb(self, pos=False, traj = False):\n",
    "        \"\"\"Returns an RGB array representation of maze, of shape (rows, cols, 3).\"\"\"\n",
    "        \n",
    "        # create a 3D array, whose RGB view is a full gray canvas (with each element = 220)\n",
    "        backgr = np.ones(shape = [self.rows,self.cols,3], dtype=np.uint8)*220\n",
    "        \n",
    "        # assign 'cyan' to start and goal locations\n",
    "        backgr[self.start[0]][self.start[1]] = [0, 255, 255] \n",
    "        backgr[self.goal[0]][self.goal[1]] = [0, 255, 255]\n",
    "        \n",
    "        # assign 'blue' to agent's location if pos flag is on\n",
    "        if pos:\n",
    "            backgr[pos[0]][pos[1]] = [0,0,255]\n",
    "               \n",
    "        # assign 'black', 'red', and 'green' to blocks, holes, and food cells, respectively\n",
    "        for b in self.blocks:\n",
    "            backgr[b[0]][b[1]] = [0,0,0]\n",
    "        for h in self.holes:\n",
    "            backgr[h[0]][h[1]] = [255,0,0]\n",
    "        for f in self.food:\n",
    "            backgr[f[0]][f[1]] = [50, 205, 50]\n",
    "        \n",
    "        # assign 'cyan' to agent's trajectory (except the start and goal locations) if traj flag is on\n",
    "        if traj:\n",
    "            for i in range (1,len(traj)-1):\n",
    "                backgr[traj[i][0]][traj[i][1]] = [0, 255, 255]\n",
    "        \n",
    "        return backgr #(rows,cols,3)\n",
    "    \n",
    "    def scaled_maze_rgb(self, pos=False, traj=False):\n",
    "        \"\"\"Scales up the rows and cols of maze's RGB array by 25x so that they get \n",
    "        visible once converted to image.\"\"\"\n",
    "\n",
    "        image_scale_factor = 25\n",
    "        scene = self.maze_rgb(pos,traj).repeat(image_scale_factor, axis=0).repeat(image_scale_factor, axis=1)\n",
    "        grid_spacing = image_scale_factor\n",
    "        \n",
    "        # Add vertical gridline\n",
    "        for x in range(0, scene.shape[1], grid_spacing):\n",
    "            scene[:, x:x + 1] = [255, 255, 255]  \n",
    "        \n",
    "        # Add horizontal gridline\n",
    "        for y in range(0, scene.shape[0], grid_spacing):\n",
    "            scene[y:y + 1, :] = [255, 255, 255]  \n",
    "        \n",
    "        return scene #(rows x 25,cols x 25,3)\n",
    "    \n",
    "    def rgb_view(self,pos=False,traj=False):\n",
    "        \"\"\"Returns RGB view of maze using the scaled RGB value array.\"\"\"\n",
    "        \n",
    "        return Image.fromarray(self.scaled_maze_rgb(pos,traj), 'RGB') \n",
    "\n",
    "    def make_gif(self,frames, path): \n",
    "        \"\"\"Creates a GIF file at the specified path containing all the frames from the frames list.\"\"\"\n",
    "\n",
    "        frame_one = frames[0]\n",
    "        \n",
    "        # 300 msec/frame, looping indefinitely\n",
    "        frame_one.save(path, format=\"GIF\", append_images=frames, save_all=True, duration=300, loop=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db0b3f0c",
   "metadata": {},
   "source": [
    "### Environment class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "525dbc01",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Env_Maze(BuildMaze):\n",
    "    \"\"\"Initiates the environment and subscribes its steps.\"\"\"\n",
    "    \n",
    "    def __init__(self,rows, cols, cell_fractions,seed_env):\n",
    "        super().__init__(rows, cols, cell_fractions,seed_env)\n",
    "        [self.blocks,self.holes,self.food] = super().special_cells() \n",
    "        \n",
    "     \n",
    "    def loc_to_state(self, loc):\n",
    "        \"\"\"Returns the state index based on grid cell location (x, y).\"\"\"\n",
    "        \n",
    "        return self.cols*loc[0]+loc[1]\n",
    "       \n",
    "        \n",
    "    def env_start(self):\n",
    "        \"\"\"The first method called when the episode starts, before the start of agent. \n",
    "        Returns the first state from the environment.\"\"\"\n",
    "        \n",
    "        reward = 0\n",
    "        self.total_reward = 0\n",
    "        self.current_pos = self.start #[0,0]\n",
    "        self.current_state = self.loc_to_state(self.current_pos)\n",
    "        terminal = False \n",
    "        self.R_S_term = (reward, self.current_state, terminal)\n",
    "        \n",
    "        return self.current_state\n",
    "    \n",
    "    \n",
    "    def env_step(self, action):\n",
    "        \"\"\"Environment's reaction to agent's action (i.e., move to either left, right, up, or down) \n",
    "        in terms of the reward, new state, and terminal flag. Reward = -1 for each move except \n",
    "        it is -10 for falling into holes, and 10 for finding food.\"\"\"\n",
    "\n",
    "        new_pos = deepcopy(self.current_pos)\n",
    "\n",
    "        # First find the new coordinate by disregarding the special cells\n",
    "        # While making sure to stay within the maze boundaries\n",
    "        if action == 0: #right\n",
    "            new_pos[1] = min(new_pos[1]+1, self.cols-1)\n",
    "        elif action == 1: #up\n",
    "            new_pos[0] = max(new_pos[0]-1, 0)\n",
    "        elif action == 2: #left\n",
    "            new_pos[1] = max(new_pos[1]-1, 0)\n",
    "        elif action == 3: #down\n",
    "            new_pos[0] = min(new_pos[0]+1, self.rows-1)\n",
    "        else:\n",
    "            raise Exception(\"Invalid action.\")\n",
    "\n",
    "        # Starting assumptions: did not hit the Goal state nor a special cell        \n",
    "        terminal = False\n",
    "        reward = -1.0\n",
    "        \n",
    "        # Stay in place if the action led to any blocks (still with reward = -1)\n",
    "        if tuple(new_pos) in self.blocks: \n",
    "            new_pos = deepcopy(self.current_pos)\n",
    "            \n",
    "        # Reward = 100 for finding food, once eaten, the food is gone\n",
    "        elif tuple(new_pos) in self.food:\n",
    "            reward = 10\n",
    "            self.food = [t for t in self.food if t != tuple(new_pos)] \n",
    "\n",
    "        # Reward = -100 for falling into a hole, and the agent is sent back to start position\n",
    "        elif tuple(new_pos) in self.holes:\n",
    "            reward = -10\n",
    "            new_pos = deepcopy(self.start)\n",
    "\n",
    "        # Reaching the goal state turns the terminal flag on (reward = -1)\n",
    "        elif new_pos == self.goal:\n",
    "            terminal = True\n",
    "\n",
    "        self.current_pos = new_pos\n",
    "        self.current_state = self.loc_to_state(self.current_pos) \n",
    "        self.total_reward += reward\n",
    "        self.R_S_term = (reward, self.current_state, terminal)\n",
    "        \n",
    "        return self.R_S_term "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65ab9565",
   "metadata": {},
   "source": [
    "### Agent class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2f8ca7a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Agent_TD():\n",
    "    \"\"\"Describes the TD Agent's behavior according to 3 TD learning algorithms.\"\"\"\n",
    "    \n",
    "    def __init__(self, num_states, epsilon, discount, step_size, seed_agent):\n",
    "             \n",
    "        self.num_actions = 4 # left, right, up, down\n",
    "        self.num_states = num_states # total number of cells in the maze\n",
    "        self.epsilon = epsilon # for epsilon-greedy action selection\n",
    "        self.gamma = discount # discount factor\n",
    "        self.alpha = step_size # learning rate\n",
    "        self.rand_generator = np.random.RandomState(seed_agent) # controlling the randomness in agent's moves   \n",
    "        self.q = np.zeros((self.num_states, self.num_actions)) # starting action-values all zero\n",
    "                     \n",
    "   \n",
    "    def argmax(self, q_values):\n",
    "        \"\"\"Argmax function with random tie-breaking (vs. the deterministic method in numpy)\"\"\"\n",
    "        \n",
    "        top = float(\"-inf\")\n",
    "        ties = []\n",
    "\n",
    "        for i in range(len(q_values)):\n",
    "            if q_values[i] > top:\n",
    "                top = q_values[i]\n",
    "                ties = []\n",
    "            if q_values[i] == top:\n",
    "                ties.append(i)\n",
    "\n",
    "        return self.rand_generator.choice(ties) # controlled by seed_agent\n",
    "    \n",
    "    \n",
    "    def select_action_epsilon_greedy(self, current_q):   \n",
    "        \"\"\"Epsilon-greedy action selection. If generated number < epsilon, the agent \n",
    "        takes a random action, otherwise selects the action with the highest Q-value \n",
    "        available at the particular state the agent is in.\"\"\"\n",
    "\n",
    "        if self.rand_generator.rand() < self.epsilon:\n",
    "            action = self.rand_generator.randint(self.num_actions) # controlled by seed_agent\n",
    "        else:\n",
    "            action = self.argmax(current_q)\n",
    "        \n",
    "        return action\n",
    "    \n",
    "    \n",
    "    def probs_epsilon_soft(self, current_q):\n",
    "        \"\"\"Returns the probabilities for action selection according to epsilon-soft policy.\n",
    "        Ensures all actions to have some probability while the greedy action is favored.\"\"\"\n",
    "        \n",
    "        # Find the index of the action with the highest Q-value\n",
    "        idxmax = self.argmax(current_q)\n",
    "        \n",
    "        # Initialize the probability distribution ensuring that all actions have a chance to be selected.\n",
    "        probs = [(self.epsilon/self.num_actions) for i in range(self.num_actions)]\n",
    "        \n",
    "        # Increase the selection probability of the action with idxmax while ensuring total probs = 1 \n",
    "        probs[idxmax]+=1-self.epsilon\n",
    "        \n",
    "        return probs\n",
    "    \n",
    "            \n",
    "    def agent_start(self, current_state):\n",
    "        \"\"\" Samples/returns the first action at the first state (from env_start) \n",
    "        using epsilon-greedy policy\"\"\"\n",
    "   \n",
    "        current_q = self.q[current_state,:]\n",
    "        action = self.select_action_epsilon_greedy(current_q)\n",
    "        \n",
    "        self.prev_state = current_state\n",
    "        self.prev_action = action\n",
    "        \n",
    "        return action\n",
    "    \n",
    "       \n",
    "    def agent_step(self, algorithm, reward, current_state):\n",
    "        \"\"\" Updates the value of the previous action using one of the 3 TD algorithms. \n",
    "        Other arguments are reward and state from env_step. Samples and returns an  \n",
    "        action using the epsilon-greedy policy.\"\"\"\n",
    "\n",
    "        # Action values at the current state:\n",
    "        current_q = self.q[current_state,:]\n",
    "        \n",
    "        # Epsilon-greedy action selection\n",
    "        action = self.select_action_epsilon_greedy(current_q)\n",
    "\n",
    "        # Identify the 'target' according to TD control algorithm\n",
    "        \n",
    "        if algorithm == \"SARSA\": \n",
    "            target = reward + self.gamma*self.q[current_state, action]\n",
    "        \n",
    "        elif algorithm == \"Expected SARSA\":  \n",
    "            probs =  self.probs_epsilon_soft(current_q)\n",
    "            target = reward + self.gamma*np.sum(np.array(probs)*np.array(current_q))\n",
    "            \n",
    "        elif algorithm == \"Q-Learning\": \n",
    "            target = reward + self.gamma*np.max(current_q)\n",
    "            \n",
    "        # Update the value of the previous action using a common update equation for all algorithms\n",
    "        self.q[self.prev_state, self.prev_action]+=self.alpha*(target-self.q[self.prev_state, self.prev_action])\n",
    "        \n",
    "        self.prev_state = current_state\n",
    "        self.prev_action = action\n",
    "        \n",
    "        return action\n",
    "\n",
    "\n",
    "    def agent_end(self, reward): \n",
    "        \"\"\" Updates the value of the previous action while at the terminal state (with \n",
    "        zero action-value). Reward from the latest env_step is the only argument. Does \n",
    "        not return an action.\n",
    "        \"\"\"\n",
    "        \n",
    "        # Same target for all algorithms since current_q = 0\n",
    "        target = reward \n",
    "        \n",
    "        self.q[self.prev_state, self.prev_action]+=self.alpha*(target-self.q[self.prev_state, self.prev_action])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be40466d",
   "metadata": {},
   "source": [
    "### RL loop definition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "8b6a4ab7",
   "metadata": {},
   "outputs": [],
   "source": [
    "class RL(Env_Maze, Agent_TD):\n",
    "    \"\"\" Implements the RL loop by combining the env and agent classes.\"\"\"\n",
    "\n",
    "    def __init__(self, rows, cols, cell_fractions,seed_env, \n",
    "                 epsilon, discount, step_size, seed_agent):\n",
    "        super().__init__(rows, cols, cell_fractions,seed_env)\n",
    "        Agent_TD.__init__(self, rows*cols, epsilon, discount, step_size, seed_agent)\n",
    "            \n",
    "            \n",
    "    def episode(self, algorithm):\n",
    "        \"\"\" Runs a single episode, based on the TD control algorithm, from env_start to agent_end. \n",
    "        Returns the score and episode length.\"\"\"\n",
    "        \n",
    "        # The first state, as returned by env_start\n",
    "        current_state = self.env_start() \n",
    "        \n",
    "        # Start the trajectory, scores (cumulative reward), and RGB frames lists) \n",
    "        self.traject=[tuple(self.current_pos)] \n",
    "        score = 0\n",
    "        self.fr = [(Image.fromarray(self.scaled_maze_rgb(pos=tuple(self.current_pos), traj=False), 'RGB'))]\n",
    "        \n",
    "        # Take the first epsilon-greedy action according to agent_start\n",
    "        action = self.agent_start(current_state)\n",
    "        \n",
    "        # Environment's first step, returning the new state and reward for the previous action\n",
    "        (reward, current_state, term) = self.env_step(action)\n",
    "        \n",
    "        # Add the first position, reward, and frame \n",
    "        self.traject.append(tuple(self.current_pos)) \n",
    "        score += reward\n",
    "        self.fr.append(Image.fromarray(self.scaled_maze_rgb(pos=tuple(self.current_pos), traj=False), 'RGB'))\n",
    "        \n",
    "        # As long as terminal state is not reached:\n",
    "        while term == False:\n",
    "\n",
    "            # Next action according to agent_step\n",
    "            action = self.agent_step(algorithm, reward, current_state) \n",
    "            \n",
    "            # Next environment step per env_step\n",
    "            (reward, current_state, term) = self.env_step(action)  \n",
    "            \n",
    "            # Add the new position, score, and frame\n",
    "            self.traject.append(tuple(self.current_pos))\n",
    "            score += reward\n",
    "            self.fr.append(Image.fromarray(self.scaled_maze_rgb(pos=tuple(self.current_pos), traj=False), 'RGB'))\n",
    "            \n",
    "        # Finalize the episode by updating the latest action value according to agent_end\n",
    "        self.agent_end(reward) \n",
    "        \n",
    "        return score, len(self.traject)\n",
    "        \n",
    "        \n",
    "    def run_exp(self, algorithm, num_episodes, save_fr):\n",
    "        \"\"\" Runs a single experiment based on the TD control algorithm and number of episodes.\n",
    "        Returns the scores list and episode length list for all episodes.\"\"\"\n",
    "        \n",
    "        # Dictionaries or lists to hold the trajectories, cumulative rewards, episode lengths, and frames \n",
    "        self.traj_dict={}\n",
    "        scores = []\n",
    "        episode_lengths = []\n",
    "        self.fr_dict={} \n",
    "        \n",
    "        # Start from episode 1\n",
    "        for episode in range(1, num_episodes + 1):\n",
    "            \n",
    "            # Run an episode\n",
    "            score, episode_length = self.episode(algorithm)\n",
    "            \n",
    "            # Replenish the food cells which may be consumed during the previous episode\n",
    "            self.food = super().special_cells()[2]\n",
    "            \n",
    "            # Save the trajectory and scores in their respective lists\n",
    "            scores.append(score)\n",
    "            episode_lengths.append(episode_length)\n",
    "            \n",
    "            # Save the trajectories and frames only after the first and the last episodes\n",
    "            if (episode ==1 or episode == num_episodes) and save_fr==True:\n",
    "                self.traj_dict[episode]=self.traject \n",
    "                self.fr_dict[episode]=self.fr           \n",
    "        \n",
    "        # Replenish the food cells which may be consumed during the last episode\n",
    "        self.food = super().special_cells()[2]\n",
    "        \n",
    "        return scores, episode_lengths    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42a52675",
   "metadata": {},
   "source": [
    "### Plotting functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "55495025",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_episodes(num_episodes,A,B):    \n",
    "    \"\"\"Shows the scores and number of steps vs. training episodes for 3 TD control algorithms.\"\"\"\n",
    "    \n",
    "    plt.figure(figsize=(12, 4))\n",
    "    plt.grid(linestyle='--', linewidth=0.7) \n",
    "\n",
    "    for algo in [\"Q-Learning\", \"SARSA\", \"Expected SARSA\"]:\n",
    "        plt.subplot(1, 2, 1)\n",
    "        plt.plot(np.arange(num_episodes),A[algo], label=algo)\n",
    "        plt.legend (loc='best')\n",
    "        plt.xlabel('Episodes')\n",
    "        plt.ylabel('Average score')\n",
    "        plt.grid(linestyle='--', linewidth=0.5) \n",
    "\n",
    "        plt.subplot(1, 2, 2)\n",
    "        plt.plot(np.arange(num_episodes), B[algo], label=algo)\n",
    "        plt.legend (loc='best')\n",
    "        plt.xlabel('Episodes')\n",
    "        plt.ylabel('Average episode length')\n",
    "        \n",
    "        plt.tight_layout(pad=2)\n",
    "        plt.grid(linestyle='--', linewidth=0.5)\n",
    "\n",
    "\n",
    "def display_gifs(num_episodes):\n",
    "    \"\"\"Displays GIFs before and after training side by side\"\"\"\n",
    "\n",
    "    width=240\n",
    "    space=50 \n",
    "    margin=10\n",
    "    \n",
    "    for algo in [\"Q-Learning\", \"SARSA\", \"Expected SARSA\"]:\n",
    "    \n",
    "        gif1 = f'.\\\\images\\\\{algo}_last_exp_episode_1.gif'\n",
    "        gif2 = f'.\\\\images\\\\{algo}_last_exp_episode_{num_episodes}.gif'\n",
    "\n",
    "        display(HTML(f\"\"\"\n",
    "        <div style=\"text-align: center;\">\n",
    "            <h2 style=\"margin-bottom: {margin}px;\">{algo}</h2>\n",
    "            <div style=\"display: flex; justify-content: center; align-items: flex-end;\">\n",
    "                <div style=\"text-align: center; margin-right: {space}px;\">\n",
    "                    <img src=\"{gif1}\" width=\"{width}px\" style=\"display: block;\">\n",
    "                    <p style=\"font-size: 18px; margin-top: 5px;\">Before training</p>\n",
    "                </div>\n",
    "                <div style=\"text-align: center;\">\n",
    "                    <img src=\"{gif2}\" width=\"{width}px\" style=\"display: block;\">\n",
    "                    <p style=\"font-size: 18px; margin-top: 5px;\">After training</p>\n",
    "                </div>\n",
    "            </div>\n",
    "        </div>\n",
    "        \"\"\"))\n",
    "\n",
    "\n",
    "def plot_trajectories(num_episodes):\n",
    "    \"\"\"Shows the visited cells before and after training for the 3 TD control methods, \n",
    "    along with the number of steps.\"\"\"\n",
    "    \n",
    "    for algo in [\"Q-Learning\", \"SARSA\", \"Expected SARSA\"]:\n",
    "        keys = list(C[algo].keys())\n",
    "\n",
    "        plt.figure(figsize=(9, 6))\n",
    "\n",
    "        plt.subplot(1, 2, 1)\n",
    "        traj1 = C[algo][keys[0]]\n",
    "        plt.imshow(m.rgb_view(traj=traj1))\n",
    "        plt.title(f'{algo}, before training\\nEpisode length = {len(traj1)}',fontsize=14)\n",
    "        plt.axis('off')\n",
    "\n",
    "        plt.subplot(1, 2, 2)\n",
    "        traj2 = C[algo][keys[1]]\n",
    "        plt.imshow(m.rgb_view(traj=traj2))\n",
    "        plt.title(f'{algo}, after training\\nEpisode length = {len(traj2)}', fontsize=14)\n",
    "        plt.axis('off')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a3c4398",
   "metadata": {},
   "source": [
    "### Demo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d5761436",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/jpeg": "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\n",
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOEAAACWCAIAAACn9nhUAAAESElEQVR4Ae3cQW3rABRFQfurTMzglz+ElkGwuAmHcyUvpgCOnMmNvOo77/s+/BF4sMDX+9nO6PneY3+9Xknsuq7zbJ7r/SMMn+qZqSOyOh5p9S+ZlAiBnYCN7myVGwEbbRxVdgI2urNVbgRstHFU2QnY6M5WuRGw0cZRZSdgoztb5UbARhtHlZ2Aje5slRsBG20cVXYCNrqzVW4EbLRxVNkJ2OjOVrkRsNHGUWUnYKM7W+VGwEYbR5WdgI3ubJUbARttHFV2Aja6s1VuBGy0cVTZCdjozla5EbDRxlFlJ3C6AbHDVU4EPjcgnnnXIHyq8JzE9+934v7z/ydMPdOqYveuTyYnMhSw0SGudCJgowmjyFDARoe40omAjSaMIkMBGx3iSicCNpowigwFbHSIK50I2GjCKDIUsNEhrnQiYKMJo8hQwEaHuNKJgI0mjCJDARsd4konAjaaMIoMBWx0iCudCNhowigyFLDRIa50ImCjCaPIUMBGh7jSiYCNJowiQwEbHeJKJwI2mjCKDAXcgBjiSicC8Q2I6t/+39dTwrsGz0yFVuE5ieM8k2Ed3TfoXd98Iyo7ARvd2So3AjbaOKrsBGx0Z6vcCNho46iyE7DRna1yI2CjjaPKTsBGd7bKjYCNNo4qOwEb3dkqNwI22jiq7ARsdGer3AjYaOOoshOw0Z2tciNgo42jyk7ARne2yo2AjTaOKjsBG93ZKjcCNto4quwEbHRnq9wI2GjjqLITsNGdrXIjYKONo8pOwA2Ina1yI/C5AREeIwhT4V2DMBWek3jgtYXrusIPWI3Bu775ravsBGx0Z6vcCNho46iyE7DRna1yI2CjjaPKTsBGd7bKjYCNNo4qOwEb3dkqNwI22jiq7ARsdGer3AjYaOOoshOw0Z2tciNgo42jyk7ARne2yo2AjTaOKjsBG93ZKjcCNto4quwEbHRnq9wI2GjjqLITsNGdrXIjYKONo8pOwEZ3tsqNgI02jio7ATcgdrbKjcDnBsQD/+3/vu/wcEOYeqZV+FQPTHnXN791lZ2Aje5slRsBG20cVXYCNrqzVW4EbLRxVNkJ2OjOVrkRsNHGUWUnYKM7W+VGwEYbR5WdgI3ubJUbARttHFV2Aja6s1VuBGy0cVTZCdjozla5EbDRxlFlJ2CjO1vlRsBGG0eVnYCN7myVGwEbbRxVdgI2urNVbgRstHFU2QnY6M5WuRGw0cZRZSfgBsTOVrkRiG9AhBcEzvNMPuL7nMQRpY70MkX4AcNU+Q0m399xeNdHkDIzARud0QpHAjYaQcrMBGx0RiscCdhoBCkzE7DRGa1wJGCjEaTMTMBGZ7TCkYCNRpAyMwEbndEKRwI2GkHKzARsdEYrHAnYaAQpMxOw0RmtcCRgoxGkzEzARme0wpGAjUaQMjMBG53RCkcCNhpByswEbHRGKxwJ2GgEKTMTsNEZrXAkYKMRpMxM4A9DB6TtemTG5QAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=225x150>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Define the maze and visually verify the availability of a path from start to finish\n",
    "\n",
    "rows = 6\n",
    "cols = 9\n",
    "fractions = [0.3,0.1,0.2]\n",
    "seed_env = 2\n",
    "\n",
    "Env_Maze(rows, cols, fractions, seed_env).rgb_view()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "0a53a0a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set agent parameters\n",
    "\n",
    "epsilon = 0.15 \n",
    "discount = 0.95\n",
    "step_size = 0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "0791cc5e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set number of episodes and experiments\n",
    "\n",
    "num_episodes = 30\n",
    "num_exp = 50 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "d0d4fd7a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8065c8b48fbd458992b7986bbba1ac06",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/3 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Run and average the experiments\n",
    "\n",
    "# Dictinaries to hold the outputs of interest\n",
    "A, B, C, D = {}, {}, {}, {}\n",
    "\n",
    "# Loop across the 3 TD control algorithms\n",
    "for algo in tqdm([\"Q-Learning\", \"SARSA\", \"Expected SARSA\"]):\n",
    "    \n",
    "    # Start the scores and episode length matrices\n",
    "    scores_matrix = np.empty((0, num_episodes))\n",
    "    episode_length_matrix = np.empty((0, num_episodes))\n",
    "\n",
    "    # Run num_exp number of experiments for each algorithm\n",
    "    for exp in tqdm(range(num_exp), leave=False):\n",
    "        \n",
    "        # Restart the RL loop class for each experiment\n",
    "        m= RL(rows, cols, fractions, seed_env, \n",
    "             epsilon, discount, step_size, seed_agent=exp)\n",
    "        \n",
    "        # Frames and trajectory are only stored for the last experiment \n",
    "        save_fr = True if exp == num_exp - 1 else False\n",
    "        \n",
    "        # Run a single experiment\n",
    "        scores, episode_lengths = m.run_exp(algo,num_episodes, save_fr)\n",
    "        \n",
    "        # Stack rows to scores and episode length matrices for each experiment\n",
    "        scores_matrix = np.vstack((scores_matrix, np.array(scores)))\n",
    "        episode_length_matrix = np.vstack((episode_length_matrix, np.array(episode_lengths)))\n",
    "        \n",
    "    # Determine for each algorithm:\n",
    "    \n",
    "    # Average of scores for each episode    \n",
    "    A[algo] = np.mean(scores_matrix, axis=0)\n",
    "    \n",
    "    # Average of episode lengths for each episode\n",
    "    B[algo] = np.mean(episode_length_matrix, axis=0)\n",
    "    \n",
    "    # Trajectories of the first and last episodes for the last experiment\n",
    "    C[algo] = m.traj_dict\n",
    "    \n",
    "    # Movies of the first and last episodes for the last experiment\n",
    "    D[algo] = m.fr_dict\n",
    "    for key in D[algo].keys():\n",
    "        m.make_gif(D[algo][key],f\".\\\\images\\\\{algo}_last_exp_episode_{key}.gif\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "a3a3743c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Average score and episode length vs. number of episodes for the 3 TD algorithms\n",
    "\n",
    "plot_episodes(num_episodes,A,B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "6c5d0894",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Agent's trajectory before and after training for the 3 TD algorithms\n",
    "\n",
    "plot_trajectories(num_episodes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "aa5b1f64",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <div style=\"text-align: center;\">\n",
       "            <h2 style=\"margin-bottom: 10px;\">Q-Learning</h2>\n",
       "            <div style=\"display: flex; justify-content: center; align-items: flex-end;\">\n",
       "                <div style=\"text-align: center; margin-right: 50px;\">\n",
       "                    <img src=\".\\images\\Q-Learning_last_exp_episode_1.gif\" width=\"240px\" style=\"display: block;\">\n",
       "                    <p style=\"font-size: 18px; margin-top: 5px;\">Before training</p>\n",
       "                </div>\n",
       "                <div style=\"text-align: center;\">\n",
       "                    <img src=\".\\images\\Q-Learning_last_exp_episode_30.gif\" width=\"240px\" style=\"display: block;\">\n",
       "                    <p style=\"font-size: 18px; margin-top: 5px;\">After training</p>\n",
       "                </div>\n",
       "            </div>\n",
       "        </div>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "\n",
       "        <div style=\"text-align: center;\">\n",
       "            <h2 style=\"margin-bottom: 10px;\">SARSA</h2>\n",
       "            <div style=\"display: flex; justify-content: center; align-items: flex-end;\">\n",
       "                <div style=\"text-align: center; margin-right: 50px;\">\n",
       "                    <img src=\".\\images\\SARSA_last_exp_episode_1.gif\" width=\"240px\" style=\"display: block;\">\n",
       "                    <p style=\"font-size: 18px; margin-top: 5px;\">Before training</p>\n",
       "                </div>\n",
       "                <div style=\"text-align: center;\">\n",
       "                    <img src=\".\\images\\SARSA_last_exp_episode_30.gif\" width=\"240px\" style=\"display: block;\">\n",
       "                    <p style=\"font-size: 18px; margin-top: 5px;\">After training</p>\n",
       "                </div>\n",
       "            </div>\n",
       "        </div>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "\n",
       "        <div style=\"text-align: center;\">\n",
       "            <h2 style=\"margin-bottom: 10px;\">Expected SARSA</h2>\n",
       "            <div style=\"display: flex; justify-content: center; align-items: flex-end;\">\n",
       "                <div style=\"text-align: center; margin-right: 50px;\">\n",
       "                    <img src=\".\\images\\Expected SARSA_last_exp_episode_1.gif\" width=\"240px\" style=\"display: block;\">\n",
       "                    <p style=\"font-size: 18px; margin-top: 5px;\">Before training</p>\n",
       "                </div>\n",
       "                <div style=\"text-align: center;\">\n",
       "                    <img src=\".\\images\\Expected SARSA_last_exp_episode_30.gif\" width=\"240px\" style=\"display: block;\">\n",
       "                    <p style=\"font-size: 18px; margin-top: 5px;\">After training</p>\n",
       "                </div>\n",
       "            </div>\n",
       "        </div>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Agent's animated journey before and after training for the 3 TD algorithms\n",
    "\n",
    "display_gifs(num_episodes)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.19"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}