FrozenLake_using_Dynamic_programming_Final_version.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Group No\n",
    "\n",
    "## Group Member Names:\n",
    "1. \n",
    "2.\n",
    "3.\n"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1.**Problem statement**: \n",
    "\n",
    "* Develop a reinforcement learning agent using dynamic programming to solve the Treasure Hunt problem in a FrozenLake environment. The agent must learn the optimal policy for navigating the lake while avoiding holes and maximizing its treasure collection.\n",
    "\n",
    "2.**Scenario**:\n",
    "* A treasure hunter is navigating a slippery 5x5 FrozenLake grid. The objective is to navigate through the lake collecting treasures while avoiding holes and ultimately reaching the exit (goal).\n",
    "Grid positions on a 5x5 map with tiles labeled as S, F, H, G, T. The state includes the current position of the agent and whether treasures have been collected. \n",
    "\n",
    "\n",
    "#### Objective\n",
    "* The agent must learn the optimal policy π* using dynamic programming to maximize its cumulative reward while navigating the lake.\n",
    "\n",
    "#### About the environment\n",
    "\n",
    "The environment consists of several types of tiles:\n",
    "* Start (S): The initial position of the agent, safe to step.\n",
    "* Frozen Tiles (F): Frozen surface, safe to step.\n",
    "* Hole (H): Falling into a hole ends the game immediately (die, end).\n",
    "* Goal (G): Exit point; reaching here ends the game successfully (safe, end).\n",
    "* Treasure Tiles (T): Added to the environment. Stepping on these tiles awards +5 reward but does not end the game. \n",
    "\n",
    "After stepping on a treasure tile, it becomes a frozen tile (F).\n",
    "The agent earns rewards as follows:\n",
    "* Reaching the goal (G): +10 reward.\n",
    "* Falling into a hole (H): -10 reward.\n",
    "* Collecting a treasure (T): +5 reward.\n",
    "* Stepping on a frozen tile (F): 0 reward.\n",
    "\n",
    "#### States\n",
    "* Current position of the agent (row, column).\n",
    "* A boolean flag (or equivalent) for whether each treasure has been collected.\n",
    "\n",
    "#### Actions\n",
    "* Four possible moves: up, down, left, right\n",
    "\n",
    "#### Rewards\n",
    "* Goal (G): +10.\n",
    "* Treasure (T): +5 per treasure.\n",
    "* Hole (H): -10.\n",
    "* Frozen tiles (F): 0.\n",
    "\n",
    "#### Environment\n",
    "Modify the FrozenLake environment in OpenAI Gym to include treasures (T) at certain positions. Inherit the original FrozenLakeEnv and modify the reset and step methods accordingly.\n",
    "Example grid:\n",
    "\n",
    "![image.png](attachment:image.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Outcomes:**\n",
    "1.\tCreate the custom environment by modifying the existing “FrozenLakeNotSlippery-v0” in OpenAI Gym and Implement the dynamic programming using value iteration and policy improvement to learn the optimal policy for the Treasure Hunt problem.\n",
    "2.\tCalculate the state-value function (V*) for each state on the map after learning the optimal policy.\n",
    "3.\tCompare the agent’s performance with and without treasures, discussing the trade-offs in reward maximization.\n",
    "4.\tVisualize the agent’s direction on the map using the learned policy.\n",
    "5.\tCalculate expected total reward over multiple episodes to evaluate performance."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import required libraries and Define the custom environment - 2 Marks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import required libraries\n",
    "import numpy as np\n",
    "import gym\n",
    "from gym import spaces\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from IPython.display import clear_output\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Custom environment to create the given grid and respective functions that are required for the problem\n",
    "\n",
    "#Include functions to take an action, get reward, to check if episode is over\n",
    "# Define the custom environment\n",
    "class TreasureHuntEnv(gym.Env):\n",
    "    def __init__(self, with_treasures=True):\n",
    "        super(TreasureHuntEnv, self).__init__()\n",
    "        \n",
    "        # Define grid size and action/observation spaces\n",
    "        self.size = 5\n",
    "        self.action_space = spaces.Discrete(4)  # 4 actions: up, down, left, right\n",
    "        self.observation_space = spaces.Discrete(self.size * self.size)\n",
    "        \n",
    "        # Define grids\n",
    "        self.treasure_grid = [\n",
    "            ['S', 'F', 'F', 'H', 'T'],\n",
    "            ['F', 'H', 'F', 'F', 'F'],\n",
    "            ['F', 'F', 'F', 'T', 'F'],\n",
    "            ['T', 'F', 'H', 'F', 'F'],\n",
    "            ['F', 'F', 'F', 'F', 'G']\n",
    "        ]\n",
    "        \n",
    "        self.no_treasure_grid = [\n",
    "            ['S', 'F', 'F', 'H', 'F'],\n",
    "            ['F', 'H', 'F', 'F', 'F'],\n",
    "            ['F', 'F', 'F', 'F', 'F'],\n",
    "            ['F', 'F', 'H', 'F', 'F'],\n",
    "            ['F', 'F', 'F', 'F', 'G']\n",
    "        ]\n",
    "        \n",
    "        self.with_treasures = with_treasures\n",
    "        self.base_grid = self.treasure_grid if with_treasures else self.no_treasure_grid\n",
    "        \n",
    "        # Define deterministic movement directions\n",
    "        self.actions = {\n",
    "            0: (-1, 0),  # Up\n",
    "            1: (1, 0),   # Down\n",
    "            2: (0, -1),  # Left\n",
    "            3: (0, 1)    # Right\n",
    "        }\n",
    "        \n",
    "        self.reset()\n",
    "    \n",
    "    def reset(self):\n",
    "        \"\"\"Reset environment to initial state\"\"\"\n",
    "        self.position = (0, 0)  # Start position\n",
    "        self.grid = [row[:] for row in self.base_grid]\n",
    "        self.treasure_collected = set()\n",
    "        return self._get_state()\n",
    "    \n",
    "    def _get_state(self):\n",
    "        \"\"\"Convert (row, col) position to state number\"\"\"\n",
    "        row, col = self.position\n",
    "        return row * self.size + col\n",
    "    \n",
    "    def step(self, action):\n",
    "        \"\"\"Execute one deterministic step in the environment\"\"\"\n",
    "        row, col = self.position\n",
    "        d_row, d_col = self.actions[action]\n",
    "        \n",
    "        # Calculate new position with boundary checks\n",
    "        new_row = max(0, min(row + d_row, self.size - 1))\n",
    "        new_col = max(0, min(col + d_col, self.size - 1))\n",
    "        self.position = (new_row, new_col)\n",
    "        \n",
    "        # Get current cell type and calculate reward\n",
    "        cell = self.grid[new_row][new_col]\n",
    "        reward = 0\n",
    "        done = False\n",
    "        \n",
    "        if cell == 'H':  # Hole\n",
    "            reward = -10\n",
    "            done = True\n",
    "        elif cell == 'G':  # Goal\n",
    "            reward = 10\n",
    "            done = True\n",
    "        elif cell == 'T':  # Treasure\n",
    "            pos_key = (new_row, new_col)\n",
    "            if pos_key not in self.treasure_collected:\n",
    "                reward = 5\n",
    "                self.treasure_collected.add(pos_key)\n",
    "                self.grid[new_row][new_col] = 'F'\n",
    "        \n",
    "        return self._get_state(), reward, done, {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Value Iteration Algorithm - 1 Mark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Value Iteration Algorithm\n",
    "def value_iteration(env, gamma=0.99, theta=1e-8):\n",
    "    \"\"\"\n",
    "    Implement value iteration algorithm to find optimal value function\n",
    "    \n",
    "    Args:\n",
    "        env: The environment\n",
    "        gamma: Discount factor\n",
    "        theta: Convergence threshold\n",
    "    \n",
    "    Returns:\n",
    "        V: Optimal value function\n",
    "    \"\"\"\n",
    "    # Initialize value function\n",
    "    V = np.zeros(env.observation_space.n)\n",
    "    \n",
    "    while True:\n",
    "        delta = 0  # Track maximum change in value\n",
    "        \n",
    "        # Update value for each state\n",
    "        for s in range(env.observation_space.n):\n",
    "            v = V[s]  # Store current value\n",
    "            \n",
    "            # Calculate values for all actions\n",
    "            values = []\n",
    "            for a in range(env.action_space.n):\n",
    "                # Set environment to current state\n",
    "                env.position = (s // env.size, s % env.size)\n",
    "                next_state, reward, done, _ = env.step(a)\n",
    "                \n",
    "                # Calculate value\n",
    "                if done:\n",
    "                    values.append(reward)  # Terminal state\n",
    "                else:\n",
    "                    values.append(reward + gamma * V[next_state])  # Non-terminal state\n",
    "            \n",
    "            # Update state value with maximum action value\n",
    "            V[s] = max(values)\n",
    "            delta = max(delta, abs(v - V[s]))\n",
    "        \n",
    "        # Check convergence\n",
    "        if delta < theta:\n",
    "            break\n",
    "    \n",
    "    return V\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Policy Improvement Function - 1 Mark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_optimal_policy(env, V, gamma=0.99):\n",
    "    \"\"\"\n",
    "    Extract optimal policy from value function\n",
    "    \n",
    "    Args:\n",
    "        env: The environment\n",
    "        V: Value function\n",
    "        gamma: Discount factor\n",
    "    \n",
    "    Returns:\n",
    "        policy: Optimal policy array\n",
    "    \"\"\"\n",
    "    policy = np.zeros(env.observation_space.n, dtype=int)\n",
    "    \n",
    "    # For each state\n",
    "    for s in range(env.observation_space.n):\n",
    "        values = []\n",
    "        # Try all actions\n",
    "        for a in range(env.action_space.n):\n",
    "            env.position = (s // env.size, s % env.size)\n",
    "            next_state, reward, done, _ = env.step(a)\n",
    "            \n",
    "            # Calculate action value\n",
    "            if done:\n",
    "                values.append(reward)\n",
    "            else:\n",
    "                values.append(reward + gamma * V[next_state])\n",
    "        \n",
    "        # Choose action with maximum value\n",
    "        policy[s] = np.argmax(values)\n",
    "    \n",
    "    return policy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Print the Optimal Value Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Display Value Function and Policy Visualization\n",
    "def display_value_function(env, V):\n",
    "    \"\"\"\n",
    "    Display and analyze the state-value function using heatmap\n",
    "    \"\"\"\n",
    "    plt.figure(figsize=(10, 8))\n",
    "    \n",
    "    # Create heatmap of values\n",
    "    value_grid = V.reshape(env.size, env.size)\n",
    "    sns.heatmap(value_grid, annot=True, fmt='.2f', cmap='RdYlGn',\n",
    "                cbar_kws={'label': 'State Value'})\n",
    "    \n",
    "    plt.title('State-Value Function (V*)')\n",
    "    plt.xlabel('Column')\n",
    "    plt.ylabel('Row')\n",
    "    plt.show()\n",
    "    \n",
    "    # Print analysis\n",
    "    print(\"\\nState-Value Function Analysis:\")\n",
    "    print(\"-\" * 40)\n",
    "    print(f\"Maximum Value: {np.max(V):.2f}\")\n",
    "    print(f\"Minimum Value: {np.min(V):.2f}\")\n",
    "    print(f\"Average Value: {np.mean(V):.2f}\")\n",
    "    print(\"\\nInterpretation:\")\n",
    "    print(\"- Higher values (green) indicate more valuable states\")\n",
    "    print(\"- Lower values (red) indicate dangerous or less valuable states\")\n",
    "    print(\"- Values represent expected cumulative rewards from each state\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualization of the learned optimal policy - 1 Mark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def visualize_learned_policy(env, policy):\n",
    "    \"\"\"\n",
    "    Visualize the optimal policy for the environment with treasures\n",
    "    \"\"\"\n",
    "    arrows = ['↑', '↓', '←', '→']\n",
    "    plt.figure(figsize=(10, 10))\n",
    "    \n",
    "    # Create grid visualization\n",
    "    for i in range(env.size):\n",
    "        for j in range(env.size):\n",
    "            cell = env.base_grid[i][j]\n",
    "            \n",
    "            # Set cell colors\n",
    "            color = {\n",
    "                'S': 'white',\n",
    "                'F': 'lightblue',\n",
    "                'H': 'red',\n",
    "                'G': 'green',\n",
    "                'T': 'yellow'\n",
    "            }.get(cell, 'white')\n",
    "            \n",
    "            plt.fill([j, j+1, j+1, j], \n",
    "                    [env.size-i-1, env.size-i-1, env.size-i, env.size-i], \n",
    "                    color=color)\n",
    "            \n",
    "            # Add policy arrows\n",
    "            state = i * env.size + j\n",
    "            if cell not in ['H', 'G']:\n",
    "                plt.text(j+0.5, env.size-i-0.5, arrows[policy[state]], \n",
    "                        horizontalalignment='center', \n",
    "                        verticalalignment='center',\n",
    "                        fontsize=20,\n",
    "                        color='blue')\n",
    "    \n",
    "    legend_elements = [\n",
    "        plt.Rectangle((0,0),1,1, facecolor='white', label='Start'),\n",
    "        plt.Rectangle((0,0),1,1, facecolor='lightblue', label='Frozen'),\n",
    "        plt.Rectangle((0,0),1,1, facecolor='red', label='Hole'),\n",
    "        plt.Rectangle((0,0),1,1, facecolor='green', label='Goal'),\n",
    "        plt.Rectangle((0,0),1,1, facecolor='yellow', label='Treasure')\n",
    "    ]\n",
    "    plt.legend(handles=legend_elements, loc='center left', bbox_to_anchor=(1, 0.5))\n",
    "    \n",
    "    plt.grid(True)\n",
    "    plt.title('Learned Optimal Policy\\n(Arrows show optimal actions)')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluate the policy - 1 Mark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Performance Evaluation Functions\n",
    "def evaluate_performance(env, policy, n_episodes=1000):\n",
    "    \"\"\"\n",
    "    Calculate expected total reward over multiple episodes\n",
    "    \"\"\"\n",
    "    rewards = []\n",
    "    successes = 0\n",
    "    treasures_collected = 0\n",
    "    \n",
    "    for episode in range(n_episodes):\n",
    "        state = env.reset()\n",
    "        total_reward = 0\n",
    "        done = False\n",
    "        episode_treasures = 0\n",
    "        \n",
    "        while not done:\n",
    "            action = policy[state]\n",
    "            next_state, reward, done, _ = env.step(action)\n",
    "            total_reward += reward\n",
    "            \n",
    "            if reward == 5:  # Treasure collected\n",
    "                episode_treasures += 1\n",
    "                treasures_collected += 1\n",
    "            if reward == 10:  # Reached goal\n",
    "                successes += 1\n",
    "                \n",
    "            state = next_state\n",
    "            \n",
    "        rewards.append(total_reward)\n",
    "    \n",
    "    print(\"\\nPerformance Evaluation:\")\n",
    "    print(\"-\" * 40)\n",
    "    print(f\"Number of Episodes: {n_episodes}\")\n",
    "    print(f\"Success Rate: {(successes/n_episodes)*100:.2f}%\")\n",
    "    print(f\"Average Total Reward: {np.mean(rewards):.2f}\")\n",
    "    print(f\"Standard Deviation: {np.std(rewards):.2f}\")\n",
    "    print(f\"Average Treasures Collected: {treasures_collected/n_episodes:.2f}\")\n",
    "    print(f\"95% Confidence Interval: [{np.percentile(rewards, 2.5):.2f}, {np.percentile(rewards, 97.5):.2f}]\")\n",
    "    \n",
    "    return rewards\n",
    "\n",
    "def compare_performance(env_with, env_without, policy_with, policy_without):\n",
    "    \"\"\"\n",
    "    Compare and analyze performance between scenarios\n",
    "    \"\"\"\n",
    "    print(\"\\nComparing Performance: With vs Without Treasures\")\n",
    "    print(\"-\" * 50)\n",
    "    \n",
    "    # Evaluate both policies\n",
    "    print(\"\\nScenario 1: With Treasures\")\n",
    "    rewards_with = evaluate_performance(env_with, policy_with)\n",
    "    \n",
    "    print(\"\\nScenario 2: Without Treasures\")\n",
    "    rewards_without = evaluate_performance(env_without, policy_without)\n",
    "    \n",
    "    # Create performance comparison plot\n",
    "    plt.figure(figsize=(12, 5))\n",
    "    \n",
    "    # Box plot for comparison\n",
    "    plt.boxplot([rewards_with, rewards_without], \n",
    "                labels=['With Treasures', 'Without Treasures'])\n",
    "    plt.title('Reward Distribution Comparison')\n",
    "    plt.ylabel('Total Reward')\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "    \n",
    "    # Print trade-off analysis\n",
    "    print(\"\\nTrade-off Analysis:\")\n",
    "    print(\"-\" * 40)\n",
    "    print(\"With Treasures:\")\n",
    "    print(\"✓ Higher potential rewards\")\n",
    "    print(\"✓ More reward opportunities\")\n",
    "    print(\"✗ Higher risk of failure\")\n",
    "    print(\"✗ More complex paths\")\n",
    "    print(\"\\nWithout Treasures:\")\n",
    "    print(\"✓ More consistent performance\")\n",
    "    print(\"✓ Simpler paths\")\n",
    "    print(\"✗ Lower maximum reward\")\n",
    "    print(\"✗ Fewer reward opportunities\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Main Execution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "1. Creating Environment\n",
      "----------------------------------------\n",
      "Environment created successfully\n",
      "\n",
      "2. Computing Optimal Solution\n",
      "----------------------------------------\n",
      "Optimal solution computed\n",
      "\n",
      "3. State-Value Function Analysis\n",
      "----------------------------------------\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "State-Value Function Analysis:\n",
      "----------------------------------------\n",
      "Maximum Value: 10.00\n",
      "Minimum Value: 9.32\n",
      "Average Value: 9.70\n",
      "\n",
      "Interpretation:\n",
      "- Higher values (green) indicate more valuable states\n",
      "- Lower values (red) indicate dangerous or less valuable states\n",
      "- Values represent expected cumulative rewards from each state\n",
      "\n",
      "4. Learned Policy Visualization\n",
      "----------------------------------------\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "5. Performance Analysis\n",
      "----------------------------------------\n",
      "\n",
      "Comparing Performance: With vs Without Treasures\n",
      "--------------------------------------------------\n",
      "\n",
      "Scenario 1: With Treasures\n",
      "\n",
      "Performance Evaluation:\n",
      "----------------------------------------\n",
      "Number of Episodes: 1000\n",
      "Success Rate: 100.00%\n",
      "Average Total Reward: 15.00\n",
      "Standard Deviation: 0.00\n",
      "Average Treasures Collected: 1.00\n",
      "95% Confidence Interval: [15.00, 15.00]\n",
      "\n",
      "Scenario 2: Without Treasures\n",
      "\n",
      "Performance Evaluation:\n",
      "----------------------------------------\n",
      "Number of Episodes: 1000\n",
      "Success Rate: 100.00%\n",
      "Average Total Reward: 10.00\n",
      "Standard Deviation: 0.00\n",
      "Average Treasures Collected: 0.00\n",
      "95% Confidence Interval: [10.00, 10.00]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Trade-off Analysis:\n",
      "----------------------------------------\n",
      "With Treasures:\n",
      "✓ Higher potential rewards\n",
      "✓ More reward opportunities\n",
      "✗ Higher risk of failure\n",
      "✗ More complex paths\n",
      "\n",
      "Without Treasures:\n",
      "✓ More consistent performance\n",
      "✓ Simpler paths\n",
      "✗ Lower maximum reward\n",
      "✗ Fewer reward opportunities\n",
      "\n",
      "Analysis Complete!\n"
     ]
    }
   ],
   "source": [
    "# Main Execution\n",
    "if __name__ == \"__main__\":\n",
    "    # 1. Create environment with treasures\n",
    "    print(\"\\n1. Creating Environment\")\n",
    "    print(\"-\" * 40)\n",
    "    env = TreasureHuntEnv(with_treasures=True)\n",
    "    print(\"Environment created successfully\")\n",
    "    \n",
    "    # 2. Calculate optimal value function and policy\n",
    "    print(\"\\n2. Computing Optimal Solution\")\n",
    "    print(\"-\" * 40)\n",
    "    V = value_iteration(env)\n",
    "    policy = get_optimal_policy(env, V)\n",
    "    print(\"Optimal solution computed\")\n",
    "    \n",
    "    # 3. Display state-value function\n",
    "    print(\"\\n3. State-Value Function Analysis\")\n",
    "    print(\"-\" * 40)\n",
    "    display_value_function(env, V)\n",
    "    \n",
    "    # 4. Visualize learned policy\n",
    "    print(\"\\n4. Learned Policy Visualization\")\n",
    "    print(\"-\" * 40)\n",
    "    visualize_learned_policy(env, policy)\n",
    "    \n",
    "    # 5. Performance evaluation\n",
    "    print(\"\\n5. Performance Analysis\")\n",
    "    print(\"-\" * 40)\n",
    "    # Create environment without treasures for comparison\n",
    "    env_without = TreasureHuntEnv(with_treasures=False)\n",
    "    V_without = value_iteration(env_without)\n",
    "    policy_without = get_optimal_policy(env_without, V_without)\n",
    "    \n",
    "    # Compare performance\n",
    "    compare_performance(env, env_without, policy, policy_without)\n",
    "    \n",
    "    print(\"\\nAnalysis Complete!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "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.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}