13_dqn.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Understanding Deep Q-Networks (DQN): A Complete Guide\n",
    "\n",
    "# Table of Contents\n",
    "\n",
    "- [Introduction](#introduction)\n",
    "- [What is DQN?](#what-is-dqn)\n",
    "  - [Why Deep Learning for Q-Learning?](#why-deep-learning)\n",
    "- [Where and How DQN is Used](#where-and-how-dqn-is-used)\n",
    "- [Mathematical Foundation of DQN](#mathematical-foundation-of-dqn)\n",
    "  - [Q-Learning Recap](#q-learning-recap)\n",
    "  - [Function Approximation](#function-approximation)\n",
    "  - [The DQN Loss Function](#the-dqn-loss-function)\n",
    "- [Step-by-Step Explanation of DQN](#step-by-step-explanation-of-dqn)\n",
    "- [Key Components of DQN](#key-components-of-dqn)\n",
    "  - [Q-Network](#q-network)\n",
    "  - [Experience Replay](#experience-replay)\n",
    "  - [Target Network](#target-network)\n",
    "  - [Exploration vs. Exploitation](#exploration-vs-exploitation)\n",
    "  - [Loss Function (MSE/Huber)](#loss-function-msehuber)\n",
    "  - [Hyperparameters](#hyperparameters)\n",
    "- [Practical Example: Custom Grid World](#practical-example-custom-grid-world)\n",
    "- [Setting up the Environment](#setting-up-the-environment)\n",
    "- [Creating the Custom Environment](#creating-the-custom-environment)\n",
    "- [Implementing the DQN Algorithm](#implementing-the-dqn-algorithm)\n",
    "  - [Defining the Q-Network](#defining-the-q-network)\n",
    "  - [Defining the Replay Memory](#defining-the-replay-memory)\n",
    "  - [Action Selection (Epsilon-Greedy)](#action-selection-epsilon-greedy)\n",
    "  - [Optimization Step](#optimization-step)\n",
    "  - [Target Network Update](#target-network-update)\n",
    "- [Running the DQN Algorithm](#running-the-dqn-algorithm)\n",
    "  - [Hyperparameter Setup](#hyperparameter-setup)\n",
    "  - [Initialization](#initialization)\n",
    "  - [Training Loop](#training-loop)\n",
    "- [Visualizing the Learning Process](#visualizing-the-learning-process)\n",
    "- [Analyzing the Learned Policy (Optional Visualization)](#analyzing-the-learned-policy-optional-visualization)\n",
    "- [Common Challenges and Solutions in DQN](#common-challenges-and-solutions-in-dqn)\n",
    "- [Conclusion](#conclusion)\n",
    "\n",
    "## What is DQN?\n",
    "\n",
    "Deep Q-Network (DQN) is a seminal algorithm in deep reinforcement learning that successfully combined Q-learning with deep neural networks to handle complex problems with high-dimensional state spaces. It demonstrated the power of using function approximation to learn value functions where traditional tabular methods fail due to the sheer size or continuous nature of the state space.\n",
    "\n",
    "### Why Deep Learning for Q-Learning?\n",
    "\n",
    "Tabular Q-learning maintains a table mapping every state-action pair to its estimated Q-value. This approach faces significant challenges:\n",
    "\n",
    "1.  **Curse of Dimensionality:** As the number of state variables or their possible values increases, the size of the Q-table grows exponentially, quickly becoming computationally infeasible to store and update (e.g., game states represented by pixels, robotic sensor readings).\n",
    "2.  **Continuous States:** Tabular methods cannot directly handle continuous state variables, requiring discretization, which can lose information and still suffer from dimensionality issues.\n",
    "\n",
    "Deep neural networks overcome these limitations by acting as **function approximators**. Instead of storing a value for each specific state-action pair, a neural network $Q(s, a; \\theta)$ learns a mapping from states (and possibly actions) to Q-values, parameterized by its weights $\\theta$. This allows the network to generalize knowledge across similar states, making it suitable for large or continuous state spaces. Typically, the network takes the state $s$ as input and outputs estimated Q-values for all discrete actions possible in that state.\n",
    "\n",
    "## Where and How DQN is Used\n",
    "\n",
    "DQN marked a breakthrough, enabling RL solutions for previously intractable problems:\n",
    "\n",
    "1.  **Video Game Playing:** Famously used to achieve superhuman performance on Atari 2600 games using raw pixel data as input.\n",
    "2.  **Robotics:** Learning control policies from sensor data (though often adapted for continuous actions).\n",
    "3.  **Optimization Problems:** Used in areas like resource allocation or system control where states are complex.\n",
    "4.  **Sequential Decision Making:** Applicable in various domains like recommendation systems or dialogue management where states can be high-dimensional.\n",
    "\n",
    "DQN is best suited for problems where:\n",
    "- The state space is large, high-dimensional, or continuous.\n",
    "- The action space is discrete.\n",
    "- A model of the environment dynamics is not available (model-free).\n",
    "- Learning can proceed off-policy (learning the optimal policy while potentially following a different exploration policy).\n",
    "\n",
    "## Mathematical Foundation of DQN\n",
    "\n",
    "### Q-Learning Recap\n",
    "\n",
    "The foundation of DQN is the Q-learning update rule, which aims to iteratively improve the estimate of the action-value function $Q(s, a)$ – the expected total discounted future reward starting from state $s$, taking action $a$, and following the optimal policy thereafter. The Bellman optimality equation for $Q^*(s, a)$ is:\n",
    "\n",
    "$$Q^*(s, a) = \\mathbb{E}[R_{t+1} + \\gamma \\max_{a'} Q^*(S_{t+1}, a') | S_t=s, A_t=a]$$\n",
    "\n",
    "The tabular Q-learning update rule approximates this iteratively:\n",
    "$$Q(s_t, a_t) \\leftarrow Q(s_t, a_t) + \\alpha \\left[ \\underbrace{r_t + \\gamma \\max_{a'} Q(s_{t+1}, a')}_{\\text{TD Target}} - Q(s_t, a_t) \\right]$$\n",
    "\n",
    "### Function Approximation\n",
    "\n",
    "DQN replaces the Q-table with a neural network $Q(s, a; \\theta)$. The network typically takes the state $s$ as input and outputs a vector of Q-values, $Q(s, \\cdot; \\theta)$, for all actions.\n",
    "\n",
    "### The DQN Loss Function\n",
    "\n",
    "Training the Q-network involves minimizing the difference between the predicted Q-value for the action taken, $Q(s_t, a_t; \\theta)$, and a target value derived from the Bellman equation. A naive target would be $r_t + \\gamma \\max_{a'} Q(s_{t+1}, a'; \\theta)$. However, using the same rapidly changing network for both prediction and target leads to instability. DQN introduces two crucial techniques:\n",
    "\n",
    "1.  **Experience Replay:** Transitions $(s_t, a_t, r_t, s_{t+1}, \\text{done}_t)$ experienced by the agent are stored in a replay buffer $\\mathcal{D}$. Training involves sampling mini-batches of these transitions randomly from $\\mathcal{D}$. This breaks the correlation between consecutive samples, making the training process more stable and data-efficient, resembling supervised learning.\n",
    "\n",
    "2.  **Target Network:** A separate network $Q(s, a; \\theta^-)$ with weights $\\theta^-$ is used to compute the target Q-values. These weights are frozen for a period and only updated periodically (e.g., every $C$ steps) by copying the weights from the main Q-network ($\\theta^- \\leftarrow \\theta$). This creates a more stable target for the main network to learn towards.\n",
    "\n",
    "The target value $Y_t$ for a transition $(s_t, a_t, r_t, s_{t+1}, d_t)$ sampled from the replay buffer is:\n",
    "$$ Y_t = \\begin{cases} r_t & \\text{if } d_t \\text{ is True (terminal state)} \\\\ r_t + \\gamma \\max_{a'} Q(s_{t+1}, a'; \\theta^-) & \\text{if } d_t \\text{ is False (non-terminal state)} \\end{cases} $$\n",
    "\n",
    "The loss function, typically Mean Squared Error (MSE) or Huber loss (Smooth L1), is minimized over the mini-batch using gradient descent:\n",
    "$$ L(\\theta) = \\mathbb{E}_{(s, a, r, s', d) \\sim \\mathcal{D}} \\left[ (Y_j - Q(s_j, a_j; \\theta))^2 \\right] $$\n",
    "\n",
    "## Step-by-Step Explanation of DQN\n",
    "\n",
    "1.  **Initialize**: Replay memory $\\mathcal{D}$ (capacity $N$), main Q-network $Q(s, a; \\theta)$ (random weights $\\theta$), target network $Q(s, a; \\theta^-)$ ($\\theta^- = \\theta$), exploration parameter $\\epsilon$.\n",
    "2.  **For each episode**:\n",
    "    a.  Reset environment, get initial state $s_1$. Preprocess state if needed.\n",
    "    b.  **For each step $t$**:\n",
    "        i.  Select action $a_t$ using epsilon-greedy based on $Q(s_t, \\cdot; \\theta)$.\n",
    "        ii. Execute $a_t$, observe reward $r_t$, next state $s_{t+1}$, done flag $d_t$. Preprocess $s_{t+1}$.\n",
    "        iii. Store $(s_t, a_t, r_t, s_{t+1}, d_t)$ in $\\mathcal{D}$.\n",
    "        iv. **Sample mini-batch**: Get random batch from $\\mathcal{D}$.\n",
    "        v.  **Calculate targets $Y_j$** using the target network $Q(s, a; \\theta^-)$.\n",
    "        vi. **Train main network**: Perform gradient descent step on $L(\\theta) = (Y_j - Q(s_j, a_j; \\theta))^2$.\n",
    "        vii. **Update target network**: Every $C$ steps, set $\\theta^- \\leftarrow \\theta$.\n",
    "        viii. $s_t \\leftarrow s_{t+1}$.\n",
    "        ix. If $d_t$, break episode.\n",
    "3.  **Repeat**: Until convergence or max episodes.\n",
    "\n",
    "## Key Components of DQN\n",
    "\n",
    "### Q-Network\n",
    "- The core function approximator. Learns to map states to action-values.\n",
    "- Architecture depends on the state representation (MLP for vectors, CNN for images).\n",
    "- Uses non-linear activation functions (like ReLU).\n",
    "- Output layer typically has units equal to the number of discrete actions, outputting raw Q-values (no final activation).\n",
    "\n",
    "### Experience Replay\n",
    "- Stores agent's experiences.\n",
    "- Breaks correlations and allows reusing data, improving stability and sample efficiency.\n",
    "- Implemented using data structures like `deque`.\n",
    "\n",
    "### Target Network\n",
    "- A copy of the main Q-network, updated less frequently.\n",
    "- Provides stable targets during the calculation of the TD error, preventing the 'moving target' problem.\n",
    "- Crucial for stabilizing DQN training.\n",
    "\n",
    "### Exploration vs. Exploitation\n",
    "- Commonly uses epsilon-greedy: act randomly with probability $\\epsilon$, greedily (based on Q-network) with probability $1-\\epsilon$.\n",
    "- Epsilon annealing: $\\epsilon$ decreases over time (e.g., linearly or exponentially) from a high initial value to a low final value.\n",
    "\n",
    "### Loss Function (MSE/Huber)\n",
    "- Measures the difference between the network's prediction and the TD target.\n",
    "- Huber loss (Smooth L1 Loss in PyTorch) is often preferred over MSE as it's less sensitive to outliers, which can occur with large TD errors early in training.\n",
    "\n",
    "### Hyperparameters\n",
    "- DQN performance is sensitive to hyperparameters like learning rate, buffer size, batch size, target update frequency, discount factor, and epsilon schedule. Careful tuning is often required.\n",
    "\n",
    "## Practical Example: Custom Grid World\n",
    "\n",
    "Since Gymnasium is disallowed, we'll create a simple, custom Grid World environment.\n",
    "\n",
    "**Environment Description:**\n",
    "- **Grid Size:** 10x10.\n",
    "- **State:** Agent's `(row, col)` position. Represented as a normalized vector `[row/10, col/10]` for the network input.\n",
    "- **Actions:** 4 discrete actions: 0 (up), 1 (down), 2 (left), 3 (right).\n",
    "- **Start State:** (0, 0).\n",
    "- **Goal State:** (9, 9).\n",
    "- **Rewards:**\n",
    "    - +10 for reaching the goal state (9, 9).\n",
    "    - -1 for hitting a wall (attempting to move off-grid).\n",
    "    - -0.1 for any other step (small cost to encourage efficiency).\n",
    "- **Termination:** Episode ends when the agent reaches the goal or after a maximum number of steps."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Setting up the Environment\n",
    "\n",
    "We need to import the required libraries and set up the environment. So let's do that first."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device: cpu\n"
     ]
    }
   ],
   "source": [
    "# Import necessary libraries for numerical computations, plotting, and utility functions\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import random\n",
    "import math\n",
    "from collections import namedtuple, deque\n",
    "from itertools import count\n",
    "from typing import List, Tuple, Dict, Optional\n",
    "\n",
    "# Import PyTorch for building and training neural networks\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "\n",
    "# Set up the device to use GPU if available, otherwise fallback to CPU\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(f\"Using device: {device}\")\n",
    "\n",
    "# Set a random seed for reproducibility across runs\n",
    "seed = 42\n",
    "random.seed(seed)  # Seed for Python's random module\n",
    "np.random.seed(seed)  # Seed for NumPy\n",
    "torch.manual_seed(seed)  # Seed for PyTorch (CPU)\n",
    "if torch.cuda.is_available():\n",
    "    torch.cuda.manual_seed_all(seed)  # Seed for PyTorch (GPU)\n",
    "\n",
    "# Enable inline plotting for Jupyter Notebook\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating the Custom Environment\n",
    "\n",
    "The very first step is to create a custom environment that simulates a simple grid world. This environment will have a grid of size 10x10, where the agent can move in four directions: up, down, left, and right. The agent starts at the top-left corner (0, 0) and aims to reach the bottom-right corner (9, 9). The agent receives rewards based on its actions and the state it reaches. The rewards are defined as follows:\n",
    "- +10 for reaching the goal (bottom-right corner)\n",
    "- -1 for hitting a wall (out of bounds)\n",
    "- -0.1 for each step taken (to encourage shorter paths)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Custom Grid World Environment\n",
    "class GridEnvironment:\n",
    "    \"\"\"\n",
    "    A simple 10x10 Grid World environment.\n",
    "    State: (row, col) represented as normalized vector [row/10, col/10].\n",
    "    Actions: 0 (up), 1 (down), 2 (left), 3 (right).\n",
    "    Rewards: +10 for reaching the goal, -1 for hitting a wall, -0.1 for each step.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, rows: int = 10, cols: int = 10) -> None:\n",
    "        \"\"\"\n",
    "        Initializes the Grid World environment.\n",
    "\n",
    "        Parameters:\n",
    "        - rows (int): Number of rows in the grid.\n",
    "        - cols (int): Number of columns in the grid.\n",
    "        \"\"\"\n",
    "        self.rows: int = rows\n",
    "        self.cols: int = cols\n",
    "        self.start_state: Tuple[int, int] = (0, 0)  # Starting position\n",
    "        self.goal_state: Tuple[int, int] = (rows - 1, cols - 1)  # Goal position\n",
    "        self.state: Tuple[int, int] = self.start_state  # Current state\n",
    "        self.state_dim: int = 2  # State represented by 2 coordinates (row, col)\n",
    "        self.action_dim: int = 4  # 4 discrete actions: up, down, left, right\n",
    "\n",
    "        # Action mapping: maps action index to (row_delta, col_delta)\n",
    "        self.action_map: Dict[int, Tuple[int, int]] = {\n",
    "            0: (-1, 0),  # Up\n",
    "            1: (1, 0),   # Down\n",
    "            2: (0, -1),  # Left\n",
    "            3: (0, 1)    # Right\n",
    "        }\n",
    "\n",
    "    def reset(self) -> torch.Tensor:\n",
    "        \"\"\"\n",
    "        Resets the environment to the start state.\n",
    "\n",
    "        Returns:\n",
    "            torch.Tensor: The initial state as a normalized tensor.\n",
    "        \"\"\"\n",
    "        self.state = self.start_state\n",
    "        return self._get_state_tensor(self.state)\n",
    "\n",
    "    def _get_state_tensor(self, state_tuple: Tuple[int, int]) -> torch.Tensor:\n",
    "        \"\"\"\n",
    "        Converts a (row, col) tuple to a normalized tensor for the network.\n",
    "\n",
    "        Parameters:\n",
    "        - state_tuple (Tuple[int, int]): The state represented as a tuple (row, col).\n",
    "\n",
    "        Returns:\n",
    "            torch.Tensor: The normalized state as a tensor.\n",
    "        \"\"\"\n",
    "        # Normalize coordinates to be between 0 and 1\n",
    "        normalized_state: List[float] = [\n",
    "            state_tuple[0] / (self.rows - 1),\n",
    "            state_tuple[1] / (self.cols - 1)\n",
    "        ]\n",
    "        return torch.tensor(normalized_state, dtype=torch.float32, device=device)\n",
    "\n",
    "    def step(self, action: int) -> Tuple[torch.Tensor, float, bool]:\n",
    "        \"\"\"\n",
    "        Performs one step in the environment based on the given action.\n",
    "\n",
    "        Args:\n",
    "            action (int): The action to take (0: up, 1: down, 2: left, 3: right).\n",
    "\n",
    "        Returns:\n",
    "            Tuple[torch.Tensor, float, bool]: \n",
    "                - next_state_tensor (torch.Tensor): The next state as a normalized tensor.\n",
    "                - reward (float): The reward for the action.\n",
    "                - done (bool): Whether the episode has ended.\n",
    "        \"\"\"\n",
    "        # If the goal state is already reached, return the current state\n",
    "        if self.state == self.goal_state:\n",
    "            return self._get_state_tensor(self.state), 0.0, True\n",
    "\n",
    "        # Get the row and column deltas for the action\n",
    "        dr, dc = self.action_map[action]\n",
    "        current_row, current_col = self.state\n",
    "        next_row, next_col = current_row + dr, current_col + dc\n",
    "\n",
    "        # Default step cost\n",
    "        reward: float = -0.1\n",
    "        hit_wall: bool = False\n",
    "\n",
    "        # Check if the action leads to hitting a wall (out of bounds)\n",
    "        if not (0 <= next_row < self.rows and 0 <= next_col < self.cols):\n",
    "            # Stay in the same state and incur a penalty\n",
    "            next_row, next_col = current_row, current_col\n",
    "            reward = -1.0\n",
    "            hit_wall = True\n",
    "\n",
    "        # Update the state\n",
    "        self.state = (next_row, next_col)\n",
    "        next_state_tensor: torch.Tensor = self._get_state_tensor(self.state)\n",
    "\n",
    "        # Check if the goal state is reached\n",
    "        done: bool = (self.state == self.goal_state)\n",
    "        if done:\n",
    "            reward = 10.0  # Reward for reaching the goal\n",
    "\n",
    "        return next_state_tensor, reward, done\n",
    "\n",
    "    def get_action_space_size(self) -> int:\n",
    "        \"\"\"\n",
    "        Returns the size of the action space.\n",
    "\n",
    "        Returns:\n",
    "            int: The number of possible actions (4).\n",
    "        \"\"\"\n",
    "        return self.action_dim\n",
    "\n",
    "    def get_state_dimension(self) -> int:\n",
    "        \"\"\"\n",
    "        Returns the dimension of the state representation.\n",
    "\n",
    "        Returns:\n",
    "            int: The number of dimensions in the state (2).\n",
    "        \"\"\"\n",
    "        return self.state_dim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Okay, now that we have implemented our custom grid environment, let's instantiate it and verify its properties and functionality."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Custom Grid Environment:\n",
      "Size: 10x10\n",
      "State Dim: 2\n",
      "Action Dim: 4\n",
      "Start State: (0, 0)\n",
      "Goal State: (9, 9)\n",
      "Example state tensor for (0,0): tensor([0., 0.])\n",
      "Step result (action=right): next_state=[0.         0.11111111], reward=-0.1, done=False\n",
      "Step result (action=up): next_state=[0.         0.11111111], reward=-1.0, done=False\n"
     ]
    }
   ],
   "source": [
    "# Instantiate the custom grid environment with a 10x10 grid\n",
    "custom_env = GridEnvironment(rows=10, cols=10)\n",
    "\n",
    "# Get the size of the action space and state dimension\n",
    "n_actions_custom = custom_env.get_action_space_size()\n",
    "n_observations_custom = custom_env.get_state_dimension()\n",
    "\n",
    "# Print basic information about the environment\n",
    "print(f\"Custom Grid Environment:\")\n",
    "print(f\"Size: {custom_env.rows}x{custom_env.cols}\")  # Grid size\n",
    "print(f\"State Dim: {n_observations_custom}\")  # State dimension (2 for row and column)\n",
    "print(f\"Action Dim: {n_actions_custom}\")  # Number of possible actions (4)\n",
    "print(f\"Start State: {custom_env.start_state}\")  # Starting position\n",
    "print(f\"Goal State: {custom_env.goal_state}\")  # Goal position\n",
    "\n",
    "# Reset the environment and print the normalized state tensor for the start state\n",
    "print(f\"Example state tensor for (0,0): {custom_env.reset()}\")\n",
    "\n",
    "# Take an example step: move 'right' (action=3) and print the result\n",
    "next_s, r, d = custom_env.step(3)  # Action 3 corresponds to moving right\n",
    "print(f\"Step result (action=right): next_state={next_s.cpu().numpy()}, reward={r}, done={d}\")\n",
    "\n",
    "# Take another example step: move 'up' (action=0) and print the result\n",
    "# This should hit a wall since the agent is at the top row\n",
    "next_s, r, d = custom_env.step(0)  # Action 0 corresponds to moving up\n",
    "print(f\"Step result (action=up): next_state={next_s.cpu().numpy()}, reward={r}, done={d}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see that the agent is at the top row and moving up results in hitting a wall, which incurs a penalty of -1.0. The next state remains the same as the current state."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Implementing the DQN Algorithm\n",
    "\n",
    "Now, let's implement the core components: the Q-Network, the Replay Memory, the action selection policy, the optimization step, and the target network update mechanism.\n",
    "\n",
    "### Defining the Q-Network\n",
    "\n",
    "We define a simple Multi-Layer Perceptron (MLP) using PyTorch's `nn.Module`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the Q-Network architecture\n",
    "class DQN(nn.Module):\n",
    "    \"\"\" Simple MLP Q-Network \"\"\"\n",
    "    def __init__(self, n_observations: int, n_actions: int):\n",
    "        \"\"\"\n",
    "        Initialize the DQN.\n",
    "\n",
    "        Parameters:\n",
    "        - n_observations (int): Dimension of the state space.\n",
    "        - n_actions (int): Number of possible actions.\n",
    "        \"\"\"\n",
    "        super(DQN, self).__init__()\n",
    "        # Define network layers\n",
    "        # Simple MLP: Input -> Hidden1 -> ReLU -> Hidden2 -> ReLU -> Output\n",
    "        self.layer1 = nn.Linear(n_observations, 128) # Input layer\n",
    "        self.layer2 = nn.Linear(128, 128)           # Hidden layer\n",
    "        self.layer3 = nn.Linear(128, n_actions)      # Output layer (Q-values for each action)\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"\n",
    "        Forward pass through the network.\n",
    "\n",
    "        Parameters:\n",
    "        - x (torch.Tensor): Input tensor representing the state(s).\n",
    "\n",
    "        Returns:\n",
    "        - torch.Tensor: Output tensor representing Q-values for each action.\n",
    "        \"\"\"\n",
    "        # Ensure input is float tensor\n",
    "        if not isinstance(x, torch.Tensor):\n",
    "             x = torch.tensor(x, dtype=torch.float32, device=device)\n",
    "        elif x.dtype != torch.float32:\n",
    "             x = x.to(dtype=torch.float32)\n",
    "\n",
    "        # Apply layers with ReLU activation\n",
    "        x = F.relu(self.layer1(x))\n",
    "        x = F.relu(self.layer2(x))\n",
    "        return self.layer3(x) # Output layer has no activation (raw Q-values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Defining the Replay Memory\n",
    "\n",
    "We use `collections.deque` for efficient storage and `random.sample` for batch sampling. A `namedtuple` helps organize the transition data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the structure for storing transitions\n",
    "Transition = namedtuple('Transition',\n",
    "                        ('state', 'action', 'next_state', 'reward', 'done'))\n",
    "\n",
    "# Define the Replay Memory class\n",
    "class ReplayMemory(object):\n",
    "    \"\"\" Stores transitions and allows sampling batches. \"\"\"\n",
    "    def __init__(self, capacity: int):\n",
    "        \"\"\"\n",
    "        Initialize the Replay Memory.\n",
    "\n",
    "        Parameters:\n",
    "        - capacity (int): Maximum number of transitions to store.\n",
    "        \"\"\"\n",
    "        self.memory = deque([], maxlen=capacity)\n",
    "\n",
    "    def push(self, *args):\n",
    "        \"\"\"\n",
    "        Save a transition.\n",
    "\n",
    "        Parameters:\n",
    "        - *args: The transition elements (state, action, next_state, reward, done).\n",
    "        \"\"\"\n",
    "        self.memory.append(Transition(*args))\n",
    "\n",
    "    def sample(self, batch_size: int) -> List[Transition]:\n",
    "        \"\"\"\n",
    "        Sample a random batch of transitions from memory.\n",
    "\n",
    "        Parameters:\n",
    "        - batch_size (int): The number of transitions to sample.\n",
    "\n",
    "        Returns:\n",
    "        - List[Transition]: A list containing the sampled transitions.\n",
    "        \"\"\"\n",
    "        return random.sample(self.memory, batch_size)\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        \"\"\" Return the current size of the memory. \"\"\"\n",
    "        return len(self.memory)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Action Selection (Epsilon-Greedy)\n",
    "\n",
    "This function selects an action based on the current state and Q-network, using the epsilon-greedy strategy for exploration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Action Selection (Epsilon-Greedy - Modified for single state tensor input)\n",
    "def select_action_custom(state: torch.Tensor,\n",
    "                         policy_net: nn.Module,\n",
    "                         epsilon_start: float,\n",
    "                         epsilon_end: float,\n",
    "                         epsilon_decay: int,\n",
    "                         n_actions: int) -> Tuple[torch.Tensor, float]:\n",
    "    \"\"\"\n",
    "    Selects an action using the epsilon-greedy strategy for a single state tensor.\n",
    "\n",
    "    Parameters:\n",
    "    - state (torch.Tensor): The current state as a tensor of shape [state_dim].\n",
    "    - policy_net (nn.Module): The Q-network used to estimate Q-values.\n",
    "    - epsilon_start (float): Initial value of epsilon (exploration rate).\n",
    "    - epsilon_end (float): Final value of epsilon after decay.\n",
    "    - epsilon_decay (int): Decay rate for epsilon (higher value means slower decay).\n",
    "    - n_actions (int): Number of possible actions.\n",
    "\n",
    "    Returns:\n",
    "    - Tuple[torch.Tensor, float]: \n",
    "        - The selected action as a tensor of shape [1, 1].\n",
    "        - The current epsilon value after decay.\n",
    "    \"\"\"\n",
    "    global steps_done_custom  # Counter to track the number of steps taken\n",
    "    sample = random.random()  # Generate a random number for epsilon-greedy decision\n",
    "    # Compute the current epsilon value based on the decay formula\n",
    "    epsilon_threshold = epsilon_end + (epsilon_start - epsilon_end) * \\\n",
    "        math.exp(-1. * steps_done_custom / epsilon_decay)\n",
    "    steps_done_custom += 1  # Increment the step counter\n",
    "\n",
    "    if sample > epsilon_threshold:\n",
    "        # Exploitation: Choose the action with the highest Q-value\n",
    "        with torch.no_grad():\n",
    "            # Add a batch dimension to the state tensor to make it [1, state_dim]\n",
    "            state_batch = state.unsqueeze(0)\n",
    "            # Get the action with the maximum Q-value (output shape: [1, n_actions])\n",
    "            action = policy_net(state_batch).max(1)[1].view(1, 1)  # Reshape to [1, 1]\n",
    "    else:\n",
    "        # Exploration: Choose a random action\n",
    "        action = torch.tensor([[random.randrange(n_actions)]], device=device, dtype=torch.long)\n",
    "\n",
    "    return action, epsilon_threshold"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Optimization Step and Selecting Action\n",
    "\n",
    "The optimization step involves sampling a mini-batch from the replay memory, calculating the target Q-values using the target network, and updating the main Q-network using backpropagation. The action selection is done using the epsilon-greedy strategy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def optimize_model(memory: ReplayMemory,\n",
    "                   policy_net: nn.Module,\n",
    "                   target_net: nn.Module,\n",
    "                   optimizer: optim.Optimizer,\n",
    "                   batch_size: int,\n",
    "                   gamma: float,\n",
    "                   criterion: nn.Module = nn.SmoothL1Loss()) -> Optional[float]:\n",
    "    \"\"\"\n",
    "    Performs one step of optimization on the policy network.\n",
    "\n",
    "    Parameters:\n",
    "    - memory (ReplayMemory): The replay memory containing past transitions.\n",
    "    - policy_net (nn.Module): The main Q-network being optimized.\n",
    "    - target_net (nn.Module): The target Q-network used for stable target computation.\n",
    "    - optimizer (optim.Optimizer): The optimizer for updating the policy network.\n",
    "    - batch_size (int): The number of transitions to sample for each optimization step.\n",
    "    - gamma (float): The discount factor for future rewards.\n",
    "    - criterion (nn.Module): The loss function to use (default: SmoothL1Loss).\n",
    "\n",
    "    Returns:\n",
    "    - Optional[float]: The loss value for the optimization step, or None if not enough samples.\n",
    "    \"\"\"\n",
    "    # Ensure there are enough samples in memory to perform optimization\n",
    "    if len(memory) < batch_size:\n",
    "        return None\n",
    "\n",
    "    # Sample a batch of transitions from replay memory\n",
    "    transitions = memory.sample(batch_size)\n",
    "    batch = Transition(*zip(*transitions))  # Unpack transitions into separate components\n",
    "\n",
    "    # Identify non-final states (states that are not terminal)\n",
    "    non_final_mask = torch.tensor(tuple(map(lambda s: s is not None, batch.next_state)),\n",
    "                                  device=device, dtype=torch.bool)\n",
    "\n",
    "    # Stack non-final next states into a tensor\n",
    "    if any(non_final_mask):  # Check if there are any non-final states\n",
    "        non_final_next_states = torch.stack([s for s in batch.next_state if s is not None])\n",
    "\n",
    "    # Stack current states, actions, rewards, and dones into tensors\n",
    "    state_batch = torch.stack(batch.state)\n",
    "    action_batch = torch.cat(batch.action)\n",
    "    reward_batch = torch.cat(batch.reward)\n",
    "    done_batch = torch.cat(batch.done)\n",
    "\n",
    "    # Compute Q(s_t, a) for the actions taken\n",
    "    state_action_values = policy_net(state_batch).gather(1, action_batch)\n",
    "\n",
    "    # Compute V(s_{t+1}) for the next states using the target network\n",
    "    next_state_values = torch.zeros(batch_size, device=device)\n",
    "    with torch.no_grad():\n",
    "        if any(non_final_mask):  # Only compute for non-final states\n",
    "            next_state_values[non_final_mask] = target_net(non_final_next_states).max(1)[0]\n",
    "\n",
    "    # Compute the expected Q values using the Bellman equation\n",
    "    expected_state_action_values = (next_state_values * gamma) + reward_batch\n",
    "\n",
    "    # Compute the loss between predicted and expected Q values\n",
    "    loss = criterion(state_action_values, expected_state_action_values.unsqueeze(1))\n",
    "\n",
    "    # Perform backpropagation and optimization\n",
    "    optimizer.zero_grad()  # Clear previous gradients\n",
    "    loss.backward()  # Compute gradients\n",
    "    torch.nn.utils.clip_grad_value_(policy_net.parameters(), 100)  # Clip gradients to prevent explosion\n",
    "    optimizer.step()  # Update the policy network\n",
    "\n",
    "    return loss.item()  # Return the loss value for logging"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Target Network Update\n",
    "\n",
    "This function copies the weights from the main policy network to the target network. We'll use a \"hard\" update every `TARGET_UPDATE` steps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_target_net(policy_net: nn.Module, target_net: nn.Module) -> None:\n",
    "    \"\"\"\n",
    "    Copies the weights from the policy network to the target network.\n",
    "\n",
    "    Parameters:\n",
    "    - policy_net (nn.Module): The main Q-network whose weights are to be copied.\n",
    "    - target_net (nn.Module): The target Q-network to which weights are copied.\n",
    "\n",
    "    Returns:\n",
    "    - None\n",
    "    \"\"\"\n",
    "    target_net.load_state_dict(policy_net.state_dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Running the DQN Algorithm\n",
    "\n",
    "Set up the hyperparameters, initialize the networks, optimizer, and replay memory, then run the main training loop.\n",
    "\n",
    "### Hyperparameter Setup\n",
    "\n",
    "So we need to set up the environment and hyperparameters for the custom grid world. These parameters will define the learning rate, discount factor, batch size, and other important settings for the DQN algorithm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hyperparameters for Custom Grid World\n",
    "BATCH_SIZE_CUSTOM = 128\n",
    "GAMMA_CUSTOM = 0.99         # Discount factor (encourage looking ahead)\n",
    "EPS_START_CUSTOM = 1.0      # Start with full exploration\n",
    "EPS_END_CUSTOM = 0.05       # End with 5% exploration\n",
    "EPS_DECAY_CUSTOM = 10000    # Slower decay for potentially larger state space exploration needs\n",
    "TAU_CUSTOM = 0.005          # Tau for soft updates (alternative, not used here)\n",
    "LR_CUSTOM = 5e-4            # Learning rate (might need tuning)\n",
    "MEMORY_CAPACITY_CUSTOM = 10000\n",
    "TARGET_UPDATE_FREQ_CUSTOM = 20 # Update target net less frequently maybe\n",
    "NUM_EPISODES_CUSTOM = 500      # More episodes might be needed\n",
    "MAX_STEPS_PER_EPISODE_CUSTOM = 200 # Max steps per episode (grid size related)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initialization\n",
    "\n",
    "So after defining the environment and the DQN, we can initialize the policy and target networks, optimizer, and replay memory. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Re-instantiate the custom GridEnvironment\n",
    "custom_env: GridEnvironment = GridEnvironment(rows=10, cols=10)\n",
    "\n",
    "# Get the size of the action space and state dimension\n",
    "n_actions_custom: int = custom_env.get_action_space_size()  # Number of possible actions (4)\n",
    "n_observations_custom: int = custom_env.get_state_dimension()  # Dimension of the state space (2)\n",
    "\n",
    "# Initialize the policy network (main Q-network) and target network\n",
    "policy_net_custom: DQN = DQN(n_observations_custom, n_actions_custom).to(device)  # Main Q-network\n",
    "target_net_custom: DQN = DQN(n_observations_custom, n_actions_custom).to(device)  # Target Q-network\n",
    "\n",
    "# Copy the weights from the policy network to the target network and set it to evaluation mode\n",
    "target_net_custom.load_state_dict(policy_net_custom.state_dict())  # Synchronize weights\n",
    "target_net_custom.eval()  # Set target network to evaluation mode\n",
    "\n",
    "# Initialize the optimizer for the policy network\n",
    "optimizer_custom: optim.AdamW = optim.AdamW(policy_net_custom.parameters(), lr=LR_CUSTOM, amsgrad=True)\n",
    "\n",
    "# Initialize the replay memory with the specified capacity\n",
    "memory_custom: ReplayMemory = ReplayMemory(MEMORY_CAPACITY_CUSTOM)\n",
    "\n",
    "# Lists for plotting\n",
    "episode_rewards_custom = []\n",
    "episode_lengths_custom = []\n",
    "episode_epsilons_custom = []\n",
    "episode_losses_custom = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training Loop\n",
    "\n",
    "Now that we have coded everything, let's train the DQN agent on the custom grid world environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting DQN Training on Custom Grid World...\n",
      "Episode 50/500 | Avg Reward (last 50): -13.14 | Avg Length: 109.86 | Avg Loss: 0.0330 | Epsilon: 0.599\n",
      "Episode 100/500 | Avg Reward (last 50): 0.68 | Avg Length: 60.18 | Avg Loss: 0.0290 | Epsilon: 0.456\n",
      "Episode 150/500 | Avg Reward (last 50): 0.20 | Avg Length: 62.06 | Avg Loss: 0.0240 | Epsilon: 0.348\n",
      "Episode 200/500 | Avg Reward (last 50): 4.34 | Avg Length: 40.32 | Avg Loss: 0.0115 | Epsilon: 0.293\n",
      "Episode 250/500 | Avg Reward (last 50): 5.62 | Avg Length: 32.48 | Avg Loss: 0.0110 | Epsilon: 0.257\n",
      "Episode 300/500 | Avg Reward (last 50): 5.81 | Avg Length: 30.50 | Avg Loss: 0.0068 | Epsilon: 0.228\n",
      "Episode 350/500 | Avg Reward (last 50): 6.96 | Avg Length: 25.32 | Avg Loss: 0.0144 | Epsilon: 0.206\n",
      "Episode 400/500 | Avg Reward (last 50): 6.56 | Avg Length: 25.90 | Avg Loss: 0.0134 | Epsilon: 0.187\n",
      "Episode 450/500 | Avg Reward (last 50): 6.57 | Avg Length: 29.74 | Avg Loss: 0.0024 | Epsilon: 0.168\n",
      "Episode 500/500 | Avg Reward (last 50): 7.58 | Avg Length: 20.84 | Avg Loss: 0.0010 | Epsilon: 0.157\n",
      "Custom Grid World Training Finished.\n"
     ]
    }
   ],
   "source": [
    "print(\"Starting DQN Training on Custom Grid World...\")\n",
    "\n",
    "# Initialize the global counter for epsilon decay\n",
    "steps_done_custom = 0\n",
    "\n",
    "# Training Loop\n",
    "for i_episode in range(NUM_EPISODES_CUSTOM):\n",
    "    # Reset the environment and get the initial state tensor\n",
    "    state = custom_env.reset()\n",
    "    total_reward = 0\n",
    "    current_losses = []\n",
    "\n",
    "    for t in range(MAX_STEPS_PER_EPISODE_CUSTOM):\n",
    "        # Select an action using epsilon-greedy policy\n",
    "        action_tensor, current_epsilon = select_action_custom(\n",
    "            state, policy_net_custom, EPS_START_CUSTOM, EPS_END_CUSTOM, EPS_DECAY_CUSTOM, n_actions_custom\n",
    "        )\n",
    "        action = action_tensor.item()\n",
    "\n",
    "        # Take a step in the environment\n",
    "        next_state_tensor, reward, done = custom_env.step(action)\n",
    "        total_reward += reward\n",
    "\n",
    "        # Prepare tensors for storing in replay memory\n",
    "        reward_tensor = torch.tensor([reward], device=device, dtype=torch.float32)\n",
    "        action_tensor_mem = torch.tensor([[action]], device=device, dtype=torch.long)\n",
    "        done_tensor = torch.tensor([done], device=device, dtype=torch.bool)\n",
    "\n",
    "        # Store the transition in replay memory\n",
    "        memory_next_state = next_state_tensor if not done else None\n",
    "        memory_custom.push(state, action_tensor_mem, memory_next_state, reward_tensor, done_tensor)\n",
    "\n",
    "        # Move to the next state\n",
    "        state = next_state_tensor\n",
    "\n",
    "        # Perform one optimization step on the policy network\n",
    "        loss = optimize_model(\n",
    "            memory_custom, policy_net_custom, target_net_custom, optimizer_custom, BATCH_SIZE_CUSTOM, GAMMA_CUSTOM\n",
    "        )\n",
    "        if loss is not None:\n",
    "            current_losses.append(loss)\n",
    "\n",
    "        # Break the loop if the episode is done\n",
    "        if done:\n",
    "            break\n",
    "\n",
    "    # Store episode statistics\n",
    "    episode_rewards_custom.append(total_reward)\n",
    "    episode_lengths_custom.append(t + 1)\n",
    "    episode_epsilons_custom.append(current_epsilon)\n",
    "    episode_losses_custom.append(np.mean(current_losses) if current_losses else 0)\n",
    "\n",
    "    # Update the target network periodically\n",
    "    if i_episode % TARGET_UPDATE_FREQ_CUSTOM == 0:\n",
    "        update_target_net(policy_net_custom, target_net_custom)\n",
    "\n",
    "    # Print progress every 50 episodes\n",
    "    if (i_episode + 1) % 50 == 0:\n",
    "        avg_reward = np.mean(episode_rewards_custom[-50:])\n",
    "        avg_length = np.mean(episode_lengths_custom[-50:])\n",
    "        avg_loss = np.mean([l for l in episode_losses_custom[-50:] if l > 0])\n",
    "        print(\n",
    "            f\"Episode {i_episode+1}/{NUM_EPISODES_CUSTOM} | \"\n",
    "            f\"Avg Reward (last 50): {avg_reward:.2f} | \"\n",
    "            f\"Avg Length: {avg_length:.2f} | \"\n",
    "            f\"Avg Loss: {avg_loss:.4f} | \"\n",
    "            f\"Epsilon: {current_epsilon:.3f}\"\n",
    "        )\n",
    "\n",
    "print(\"Custom Grid World Training Finished.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualizing the Learning Process\n",
    "\n",
    "Plot the results for the custom Grid World environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x300 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plotting results for Custom Grid World\n",
    "plt.figure(figsize=(20, 3))\n",
    "\n",
    "# Rewards\n",
    "plt.subplot(1, 3, 1)\n",
    "plt.plot(episode_rewards_custom)\n",
    "plt.title('DQN Custom Grid: Episode Rewards')\n",
    "plt.xlabel('Episode')\n",
    "plt.ylabel('Total Reward')\n",
    "plt.grid(True)\n",
    "rewards_ma_custom = np.convolve(episode_rewards_custom, np.ones(50)/50, mode='valid')\n",
    "if len(rewards_ma_custom) > 0: # Avoid plotting empty MA\n",
    "    plt.plot(np.arange(len(rewards_ma_custom)) + 49, rewards_ma_custom, label='50-episode MA', color='orange')\n",
    "plt.legend()\n",
    "\n",
    "\n",
    "# Lengths\n",
    "plt.subplot(1, 3, 2)\n",
    "plt.plot(episode_lengths_custom)\n",
    "plt.title('DQN Custom Grid: Episode Lengths')\n",
    "plt.xlabel('Episode')\n",
    "plt.ylabel('Steps')\n",
    "plt.grid(True)\n",
    "lengths_ma_custom = np.convolve(episode_lengths_custom, np.ones(50)/50, mode='valid')\n",
    "if len(lengths_ma_custom) > 0:\n",
    "    plt.plot(np.arange(len(lengths_ma_custom)) + 49, lengths_ma_custom, label='50-episode MA', color='orange')\n",
    "plt.legend()\n",
    "\n",
    "# Epsilon\n",
    "plt.subplot(1, 3, 3)\n",
    "plt.plot(episode_epsilons_custom)\n",
    "plt.title('DQN Custom Grid: Epsilon Decay')\n",
    "plt.xlabel('Episode')\n",
    "plt.ylabel('Epsilon')\n",
    "plt.grid(True)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Analysis of DQN Learning Curves (Custom Grid World):**\n",
    "\n",
    "1.  **Rewards Curve:** The rewards should generally increase over time, possibly with more fluctuations than CartPole due to the step cost and potential for getting stuck temporarily. The moving average should show a clear learning trend towards positive values as the agent more frequently reaches the goal (+10) while minimizing steps (-0.1 cost) and wall hits (-1).\n",
    "2.  **Episode Length Curve:** Initially high, the episode lengths should decrease as the agent learns more direct paths to the goal. Plateaus or spikes might indicate periods where exploration leads to longer paths or getting trapped. Convergence towards the minimum possible steps from start to goal indicates good learning.\n",
    "3.  **Epsilon Decay:** Shows the planned decrease in exploration probability over episodes.\n",
    "\n",
    "This demonstrates DQN learning a policy in a custom, manually defined environment using only basic libraries alongside PyTorch for the neural network components."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Analyzing the Learned Policy (Optional Visualization)\n",
    "\n",
    "We can create a policy grid similar to the tabular methods, but now the policy is derived from the Q-network's output for each state."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Plotting Learned Policy from DQN:\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_dqn_policy_grid(policy_net: nn.Module, env: GridEnvironment, device: torch.device) -> None:\n",
    "    \"\"\"\n",
    "    Plots the greedy policy derived from the DQN for the given environment.\n",
    "\n",
    "    Parameters:\n",
    "    - policy_net (nn.Module): The trained Q-network used to derive the policy.\n",
    "    - env (GridEnvironment): The custom grid environment.\n",
    "    - device (torch.device): The device (CPU/GPU) on which the tensors are processed.\n",
    "\n",
    "    Returns:\n",
    "    - None: Displays the policy grid as a plot.\n",
    "    \"\"\"\n",
    "    # Get the dimensions of the grid environment\n",
    "    rows: int = env.rows\n",
    "    cols: int = env.cols\n",
    "\n",
    "    # Initialize an empty grid to store the policy symbols\n",
    "    policy_grid: np.ndarray = np.empty((rows, cols), dtype=str)\n",
    "\n",
    "    # Define symbols for each action\n",
    "    action_symbols: Dict[int, str] = {0: '↑', 1: '↓', 2: '←', 3: '→'}\n",
    "\n",
    "    # Create a figure for the plot\n",
    "    fig, ax = plt.subplots(figsize=(cols * 0.6, rows * 0.6))  # Adjust size based on grid dimensions\n",
    "\n",
    "    # Iterate over each cell in the grid\n",
    "    for r in range(rows):\n",
    "        for c in range(cols):\n",
    "            state_tuple: Tuple[int, int] = (r, c)  # Current state as a tuple\n",
    "\n",
    "            # If the current cell is the goal state, mark it with 'G'\n",
    "            if state_tuple == env.goal_state:\n",
    "                policy_grid[r, c] = 'G'\n",
    "                ax.text(c, r, 'G', ha='center', va='center', color='green', fontsize=12, weight='bold')\n",
    "            else:\n",
    "                # Convert the state to a tensor representation\n",
    "                state_tensor: torch.Tensor = env._get_state_tensor(state_tuple)\n",
    "\n",
    "                # Use the policy network to determine the best action\n",
    "                with torch.no_grad():\n",
    "                    # Add a batch dimension to the state tensor\n",
    "                    state_tensor = state_tensor.unsqueeze(0)\n",
    "                    # Get Q-values for the current state\n",
    "                    q_values: torch.Tensor = policy_net(state_tensor)\n",
    "                    # Select the action with the highest Q-value\n",
    "                    best_action: int = q_values.max(1)[1].item()\n",
    "\n",
    "                # Store the action symbol in the policy grid\n",
    "                policy_grid[r, c] = action_symbols[best_action]\n",
    "                # Add the action symbol to the plot\n",
    "                ax.text(c, r, policy_grid[r, c], ha='center', va='center', color='black', fontsize=12)\n",
    "\n",
    "    # Set up the grid visualization\n",
    "    ax.matshow(np.zeros((rows, cols)), cmap='Greys', alpha=0.1)  # Background grid\n",
    "    ax.set_xticks(np.arange(-.5, cols, 1), minor=True)\n",
    "    ax.set_yticks(np.arange(-.5, rows, 1), minor=True)\n",
    "    ax.grid(which='minor', color='black', linestyle='-', linewidth=1)  # Minor grid lines\n",
    "    ax.set_xticks([])  # Remove x-axis ticks\n",
    "    ax.set_yticks([])  # Remove y-axis ticks\n",
    "    ax.set_title(\"DQN Learned Policy (Custom Grid)\")  # Title of the plot\n",
    "\n",
    "    # Display the plot\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "# Plot the policy learned by the trained network\n",
    "print(\"\\nPlotting Learned Policy from DQN:\")\n",
    "plot_dqn_policy_grid(policy_net_custom, custom_env, device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Common Challenges and Solutions in DQN\n",
    "\n",
    "**Challenge: Unstable Training / Divergence**\n",
    "*   **Solutions**:\n",
    "    *   **Tune Learning Rate:** Lower the learning rate (`LR`).\n",
    "    *   **Increase Target Network Update Frequency:** Update the target network less often (increase `TARGET_UPDATE_FREQ`) or use soft updates (`TAU`).\n",
    "    *   **Gradient Clipping:** Prevent exploding gradients.\n",
    "    *   **Larger Replay Buffer:** Increase `MEMORY_CAPACITY`.\n",
    "    *   **Different Optimizer/Loss:** Try RMSprop or Huber loss.\n",
    "\n",
    "**Challenge: Slow Learning**\n",
    "*   **Solutions**:\n",
    "    *   **Tune Hyperparameters:** Increase learning rate cautiously, adjust epsilon decay, optimize batch size.\n",
    "    *   **Network Architecture:** Experiment with different numbers of layers/neurons.\n",
    "    *   **Prioritized Experience Replay:** Sample more \"important\" transitions from the buffer more often (more complex extension).\n",
    "    *   **Double DQN / Dueling DQN:** Extensions that can improve performance and stability.\n",
    "\n",
    "**Challenge: Overestimation of Q-values**\n",
    "*   **Solution**: Implement **Double DQN**, which decouples action selection and value estimation in the target calculation.\n",
    "\n",
    "**Challenge: Correlation in Replay Buffer**\n",
    "*   **Solution**: Ensure sufficient buffer size and random sampling. Consider prioritized replay.\n",
    "\n",
    "## Conclusion\n",
    "\n",
    "The Deep Q-Network (DQN) algorithm successfully extends Q-learning to handle high-dimensional state spaces by using a deep neural network as a function approximator. Key innovations like Experience Replay and the use of a Target Network are crucial for stabilizing the learning process when combining deep learning with temporal difference methods.\n",
    "\n",
    "As demonstrated with the CartPole environment, DQN can learn effective policies for tasks with continuous state spaces and discrete actions directly from experience. While basic DQN has limitations (e.g., overestimation, handling continuous actions), it forms the foundation for many advanced deep reinforcement learning algorithms like Double DQN, Dueling DQN, Rainbow, and Actor-Critic methods that address these challenges and tackle even more complex problems. Understanding DQN is a vital step in mastering modern reinforcement learning techniques."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv-all-rl-algos",
   "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}