RL Shortest Path.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import networkx as nx\n",
        "import numpy as np\n",
        "import random\n",
        "import time\n",
        "\n",
        "# Set seeds for reproducibility\n",
        "random.seed(0)\n",
        "np.random.seed(1)\n",
        "\n",
        "# PathFinder class: Contains methods for Q-learning, SARSA, and SARSA(λ) to find the optimal path in the graph\n",
        "class PathFinder(object):\n",
        "\n",
        "    def __init__(self, graph):\n",
        "        \"\"\"\n",
        "        Initialize the PathFinder with the graph.\n",
        "\n",
        "        Args:\n",
        "        - graph (networkx.Graph): The graph for which the pathfinding algorithm will be applied.\n",
        "        \"\"\"\n",
        "        self.graph = graph  # Store the graph\n",
        "        self.num_nodes = len(graph.nodes)  # Number of nodes in the graph\n",
        "\n",
        "    def q_learning(self, start_state=0, aim_state=10, num_epoch=500, gamma=0.8, epsilon=0.05, alpha=0.1):\n",
        "        \"\"\"\n",
        "        Perform Q-learning to find the shortest path from the start state to the aim state.\n",
        "\n",
        "        Args:\n",
        "        - start_state (int): The starting node of the path.\n",
        "        - aim_state (int): The destination node of the path.\n",
        "        - num_epoch (int): Number of episodes for training the Q-learning algorithm.\n",
        "        - gamma (float): Discount factor for future rewards (how much future rewards are valued).\n",
        "        - epsilon (float): Probability of choosing a random action (exploration vs exploitation).\n",
        "        - alpha (float): Learning rate (how much new information is learned at each step).\n",
        "\n",
        "        Returns:\n",
        "        - path (list): The path from start_state to aim_state learned by Q-learning.\n",
        "        \"\"\"\n",
        "        len_of_paths = []  # List to track the lengths of paths for each episode\n",
        "        q_table = np.zeros((self.num_nodes, self.num_nodes))  # Initialize Q-table (num_states x num_actions)\n",
        "\n",
        "        # Calculate 10% milestones for printing detailed info during training\n",
        "        epoch_thresholds = [int(i * num_epoch / 10) for i in range(1, 11)]\n",
        "\n",
        "        # Loop through each episode\n",
        "        for epoch in range(1, num_epoch + 1):\n",
        "            current_state = start_state  # Start at the initial state\n",
        "            path = [current_state]  # List to store the path\n",
        "            len_of_path = 0  # Track the length of the path\n",
        "\n",
        "            # Output progress for first episode and every 10% milestone\n",
        "            if epoch == 1 or epoch in epoch_thresholds:\n",
        "                print(f\"Episode {epoch}/{num_epoch}\")\n",
        "                print(f\"Starting state: {current_state}\")\n",
        "\n",
        "            # Loop until the goal state is reached\n",
        "            while True:\n",
        "                # Epsilon-Greedy action selection (either explore or exploit)\n",
        "                next_state = self.epsilon_greedy(current_state, q_table, epsilon=epsilon)\n",
        "                s_next_next = self.epsilon_greedy(next_state, q_table, epsilon=-0.2)  # greedy policy for next state\n",
        "\n",
        "                # Calculate the reward (negative edge weight)\n",
        "                reward = -self.graph[current_state][next_state]['weight']\n",
        "\n",
        "                # Q-table update using the Bellman equation\n",
        "                delta = reward + gamma * q_table[next_state, s_next_next] - q_table[current_state, next_state]\n",
        "                q_table[current_state, next_state] = q_table[current_state, next_state] + alpha * delta\n",
        "\n",
        "                # Output details for each step (if first epoch or one of the milestones)\n",
        "                if epoch == 1 or epoch in epoch_thresholds:\n",
        "                    print(f\"  Current state: {current_state} -> Next state: {next_state}\")\n",
        "                    print(f\"    Edge weight (distance): {self.graph[current_state][next_state]['weight']}  Reward: {reward}\")\n",
        "                    print(f\"    Updated Q-table: {q_table[current_state, next_state]:.4f}\")\n",
        "\n",
        "                # Update the current state and accumulate the path length (cost)\n",
        "                current_state = next_state\n",
        "                len_of_path += -reward  # Add the cost (negative of the reward) to the path length\n",
        "                path.append(current_state)\n",
        "\n",
        "                # If goal state is reached, break the loop\n",
        "                if current_state == aim_state:\n",
        "                    if epoch == 1 or epoch in epoch_thresholds:\n",
        "                        print(f\"  Goal state {aim_state} reached!\")\n",
        "                    break\n",
        "\n",
        "            len_of_paths.append(len_of_path)  # Store the length of the current path\n",
        "            if epoch == 1 or epoch in epoch_thresholds:\n",
        "                print(f\"Episode {epoch} completed. Path length: {len_of_path}\")\n",
        "                print(\"--------------------------------------------------\")\n",
        "\n",
        "        return path  # Return the learned path\n",
        "\n",
        "    def sarsa(self, start_state=0, aim_state=10, num_epoch=500, gamma=0.8, epsilon=0.05, alpha=0.1):\n",
        "        \"\"\"\n",
        "        Perform SARSA to find the shortest path from the start state to the aim state.\n",
        "\n",
        "        Args:\n",
        "        - start_state (int): The starting node of the path.\n",
        "        - aim_state (int): The destination node of the path.\n",
        "        - num_epoch (int): Number of episodes for training the SARSA algorithm.\n",
        "        - gamma (float): Discount factor for future rewards (how much future rewards are valued).\n",
        "        - epsilon (float): Probability of choosing a random action (exploration vs exploitation).\n",
        "        - alpha (float): Learning rate (how much new information is learned at each step).\n",
        "\n",
        "        Returns:\n",
        "        - path (list): The path from start_state to aim_state learned by SARSA.\n",
        "        \"\"\"\n",
        "        len_of_paths = []  # List to track the lengths of paths for each episode\n",
        "        q_table = np.zeros((self.num_nodes, self.num_nodes))  # Initialize Q-table (num_states x num_actions)\n",
        "\n",
        "        # Calculate 10% milestones for printing detailed info during training\n",
        "        epoch_thresholds = [int(i * num_epoch / 10) for i in range(1, 11)]\n",
        "\n",
        "        # Loop through each episode\n",
        "        for epoch in range(1, num_epoch + 1):\n",
        "            current_state = start_state  # Start at the initial state\n",
        "            path = [current_state]  # List to store the path\n",
        "            len_of_path = 0  # Track the length of the path\n",
        "\n",
        "            # Epsilon-Greedy action selection (choose the first action randomly)\n",
        "            current_action = self.epsilon_greedy(current_state, q_table, epsilon)\n",
        "\n",
        "            # Output progress for first episode and every 10% milestone\n",
        "            if epoch == 1 or epoch in epoch_thresholds:\n",
        "                print(f\"Episode {epoch}/{num_epoch}\")\n",
        "                print(f\"Starting state: {current_state}\")\n",
        "\n",
        "            # Loop until the goal state is reached\n",
        "            while True:\n",
        "                # Perform action to move to next state\n",
        "                next_state = self.get_next_state(current_state, current_action)\n",
        "                reward = -self.graph[current_state][next_state]['weight']  # Reward is negative of edge weight\n",
        "\n",
        "                # Epsilon-Greedy action selection for the next state\n",
        "                next_action = self.epsilon_greedy(next_state, q_table, epsilon)\n",
        "\n",
        "                # SARSA Q-table update\n",
        "                delta = reward + gamma * q_table[next_state, next_action] - q_table[current_state, current_action]\n",
        "                q_table[current_state, current_action] = q_table[current_state, current_action] + alpha * delta\n",
        "\n",
        "                # Output details for each step (if first epoch or one of the milestones)\n",
        "                if epoch == 1 or epoch in epoch_thresholds:\n",
        "                    print(f\"  Current state: {current_state} -> Next state: {next_state}\")\n",
        "                    print(f\"    Edge weight (distance): {self.graph[current_state][next_state]['weight']}  Reward: {reward}\")\n",
        "                    print(f\"    Updated Q-table: {q_table[current_state, current_action]:.4f}\")\n",
        "\n",
        "                # Update current state and action\n",
        "                current_state = next_state\n",
        "                current_action = next_action\n",
        "                len_of_path += -reward  # Add the cost (negative of the reward) to the path length\n",
        "                path.append(current_state)\n",
        "\n",
        "                # If goal state is reached, break the loop\n",
        "                if current_state == aim_state:\n",
        "                    if epoch == 1 or epoch in epoch_thresholds:\n",
        "                        print(f\"  Goal state {aim_state} reached!\")\n",
        "                    break\n",
        "\n",
        "            len_of_paths.append(len_of_path)  # Store the length of the current path\n",
        "            if epoch == 1 or epoch in epoch_thresholds:\n",
        "                print(f\"Episode {epoch} completed. Path length: {len_of_path}\")\n",
        "                print(\"--------------------------------------------------\")\n",
        "\n",
        "        return path  # Return the learned path\n",
        "\n",
        "    def sarsa_lambda(self, start_state=0, aim_state=10, num_epoch=500, gamma=0.8, epsilon=0.05, alpha=0.1, lambda_=0.9):\n",
        "        \"\"\"\n",
        "        Perform SARSA(λ) to find the shortest path from the start state to the aim state.\n",
        "\n",
        "        Args:\n",
        "        - start_state (int): The starting node of the path.\n",
        "        - aim_state (int): The destination node of the path.\n",
        "        - num_epoch (int): Number of episodes for training the SARSA(λ) algorithm.\n",
        "        - gamma (float): Discount factor for future rewards (how much future rewards are valued).\n",
        "        - epsilon (float): Probability of choosing a random action (exploration vs exploitation).\n",
        "        - alpha (float): Learning rate (how much new information is learned at each step).\n",
        "        - lambda_ (float): Eligibility trace decay factor (0 ≤ λ ≤ 1).\n",
        "\n",
        "        Returns:\n",
        "        - path (list): The path from start_state to aim_state learned by SARSA(λ).\n",
        "        \"\"\"\n",
        "        len_of_paths = []  # List to track the lengths of paths for each episode\n",
        "        q_table = np.zeros((self.num_nodes, self.num_nodes))  # Initialize Q-table (num_states x num_actions)\n",
        "        e_table = np.zeros((self.num_nodes, self.num_nodes))  # Initialize eligibility trace table\n",
        "\n",
        "        # Calculate 10% milestones for printing detailed info during training\n",
        "        epoch_thresholds = [int(i * num_epoch / 10) for i in range(1, 11)]\n",
        "\n",
        "        # Loop through each episode\n",
        "        for epoch in range(1, num_epoch + 1):\n",
        "            current_state = start_state  # Start at the initial state\n",
        "            path = [current_state]  # List to store the path\n",
        "            len_of_path = 0  # Track the length of the path\n",
        "\n",
        "            # Epsilon-Greedy action selection (choose the first action randomly)\n",
        "            current_action = self.epsilon_greedy(current_state, q_table, epsilon)\n",
        "\n",
        "            # Output progress for first episode and every 10% milestone\n",
        "            if epoch == 1 or epoch in epoch_thresholds:\n",
        "                print(f\"Episode {epoch}/{num_epoch}\")\n",
        "                print(f\"Starting state: {current_state}\")\n",
        "\n",
        "            # Loop until the goal state is reached\n",
        "            while True:\n",
        "                # Perform action to move to next state\n",
        "                next_state = self.get_next_state(current_state, current_action)\n",
        "                reward = -self.graph[current_state][next_state]['weight']  # Reward is negative of edge weight\n",
        "\n",
        "                # Epsilon-Greedy action selection for the next state\n",
        "                next_action = self.epsilon_greedy(next_state, q_table, epsilon)\n",
        "\n",
        "                # Update eligibility trace\n",
        "                e_table[current_state, current_action] += 1\n",
        "\n",
        "                # SARSA(λ) Q-table update with eligibility traces\n",
        "                delta = reward + gamma * q_table[next_state, next_action] - q_table[current_state, current_action]\n",
        "                q_table += alpha * delta * e_table  # Update Q-table using eligibility traces\n",
        "                e_table *= gamma * lambda_  # Decay eligibility traces\n",
        "\n",
        "                # Output details for each step (if first epoch or one of the milestones)\n",
        "                if epoch == 1 or epoch in epoch_thresholds:\n",
        "                    print(f\"  Current state: {current_state} -> Next state: {next_state}\")\n",
        "                    print(f\"    Edge weight (distance): {self.graph[current_state][next_state]['weight']}  Reward: {reward}\")\n",
        "                    print(f\"    Updated Q-table: {q_table[current_state, current_action]:.4f}\")\n",
        "\n",
        "                # Update current state and action\n",
        "                current_state = next_state\n",
        "                current_action = next_action\n",
        "                len_of_path += -reward  # Add the cost (negative of the reward) to the path length\n",
        "                path.append(current_state)\n",
        "\n",
        "                # If goal state is reached, break the loop\n",
        "                if current_state == aim_state:\n",
        "                    if epoch == 1 or epoch in epoch_thresholds:\n",
        "                        print(f\"  Goal state {aim_state} reached!\")\n",
        "                    break\n",
        "\n",
        "            len_of_paths.append(len_of_path)  # Store the length of the current path\n",
        "            if epoch == 1 or epoch in epoch_thresholds:\n",
        "                print(f\"Episode {epoch} completed. Path length: {len_of_path}\")\n",
        "                print(\"--------------------------------------------------\")\n",
        "\n",
        "        return path  # Return the learned path\n",
        "\n",
        "    def epsilon_greedy(self, s_curr, q, epsilon):\n",
        "        \"\"\"\n",
        "        Epsilon-Greedy action selection: Choose a state based on exploration (random choice) or exploitation (best Q-value).\n",
        "\n",
        "        Args:\n",
        "        - s_curr (int): Current state.\n",
        "        - q (numpy.ndarray): Q-table storing the value of each state-action pair.\n",
        "        - epsilon (float): Probability of choosing a random action for exploration.\n",
        "\n",
        "        Returns:\n",
        "        - s_next (int): The next state chosen based on the epsilon-greedy strategy.\n",
        "        \"\"\"\n",
        "        # Get the neighbors (connected nodes) of the current state\n",
        "        potential_next_states = np.where(np.array([self.graph.has_edge(s_curr, n) for n in range(self.num_nodes)]))\n",
        "        potential_next_states = potential_next_states[0]  # Convert to an array\n",
        "\n",
        "        # Epsilon-Greedy: Choose either exploration (random) or exploitation (best Q-value)\n",
        "        if random.random() > epsilon:  # Exploitation: Choose the state with the highest Q-value\n",
        "            q_of_next_states = q[s_curr][potential_next_states]  # Q-values of all next states\n",
        "            s_next = potential_next_states[np.argmax(q_of_next_states)]  # Choose the state with the max Q-value\n",
        "        else:  # Exploration: Choose a random neighboring state\n",
        "            s_next = random.choice(potential_next_states)\n",
        "\n",
        "        return s_next  # Return the next state chosen\n",
        "\n",
        "    def get_next_state(self, state, action):\n",
        "        \"\"\"\n",
        "        Get the next state based on the current state and action.\n",
        "\n",
        "        Args:\n",
        "        - state (int): Current state.\n",
        "        - action (int): Action taken (next state to go).\n",
        "\n",
        "        Returns:\n",
        "        - next_state (int): The next state after taking the action.\n",
        "        \"\"\"\n",
        "        return action  # In SARSA, action corresponds directly to the next state\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import networkx as nx\n",
        "import time\n",
        "\n",
        "def plot_graph(G, title, result_path=None, start_node=None, aim_node=None):\n",
        "    \"\"\"\n",
        "    Function to plot the graph with nodes and edges, with optional highlighting of the result path.\n",
        "\n",
        "    Args:\n",
        "    - G (networkx.Graph): The graph to plot.\n",
        "    - title (str): The title for the plot.\n",
        "    - result_path (list, optional): The list of nodes representing the learned path, if available.\n",
        "    - start_node (int, optional): The starting node to be highlighted.\n",
        "    - aim_node (int, optional): The aim (goal) node to be highlighted.\n",
        "\n",
        "    This function visualizes the graph, optionally highlights the nodes and edges based on the provided\n",
        "    result_path, and displays the start and aim nodes with distinct colors.\n",
        "    \"\"\"\n",
        "\n",
        "    # Set up the plot with a specific figure size\n",
        "    plt.figure(figsize=(10, 6))\n",
        "\n",
        "    # Position nodes using a force-directed layout\n",
        "    pos = nx.spring_layout(G)\n",
        "\n",
        "    # Get edge weights as labels (for display on the plot)\n",
        "    edge_labels = nx.get_edge_attributes(G, 'weight')\n",
        "\n",
        "    # If result_path is provided, highlight the edges of the optimal path\n",
        "    if result_path:\n",
        "        edge_colors = ['#99cd16' if (min(u, v), max(u, v)) in [(min(result_path[i], result_path[i+1]), max(result_path[i], result_path[i+1])) for i in range(len(result_path)-1)] else 'gray' for u, v in G.edges()]\n",
        "    else:\n",
        "        edge_colors = ['gray' for u, v in G.edges()]  # Default edge color if no result path\n",
        "\n",
        "    # Define node colors: red for start_node, yellow for aim_node, light blue for others\n",
        "    node_colors = []\n",
        "    for node in G.nodes():\n",
        "        if node == start_node:\n",
        "            node_colors.append('#cd1666')  # Start node as red\n",
        "        elif node == aim_node:\n",
        "            node_colors.append('#e5e21a')  # Aim node as yellow\n",
        "        else:\n",
        "            node_colors.append('#16accd')  # Default color for other nodes (light blue)\n",
        "\n",
        "    # Plot the graph: nodes, labels, edges, and edge weights\n",
        "    nx.draw_networkx_nodes(G, pos, node_color=node_colors, node_size=500)  # Customize node colors and size\n",
        "    nx.draw_networkx_labels(G, pos, font_size=12, font_weight='bold', font_color='black')  # Label the nodes\n",
        "    nx.draw_networkx_edges(G, pos, edge_color=edge_colors, width=2)  # Draw edges with specified color\n",
        "    nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels)  # Draw edge labels (weights)\n",
        "\n",
        "    # Remove the axis (black border)\n",
        "    ax = plt.gca()\n",
        "    ax.set_axis_off()  # This removes the axis lines and ticks\n",
        "\n",
        "    # Display the plot with a title\n",
        "    plt.title(title)\n",
        "    plt.show()  # Show the plot\n",
        "\n",
        "def shortestpathfinder(edges, start_node=0, aim_node=10, RL_algorithm='q_learning', num_epoch=500, gamma=0.8, epsilon=0.05, alpha=0.1, lambda_=0.9, plot=True):\n",
        "    \"\"\"\n",
        "    Function to execute Q-learning, SARSA, or SARSA(λ) on the provided graph and visualize the results.\n",
        "\n",
        "    Args:\n",
        "    - edges (list): List of edges where each edge is a tuple (u, v, weight).\n",
        "    - start_node (int, optional): The start node for pathfinding.\n",
        "    - aim_node (int, optional): The destination node for pathfinding.\n",
        "    - RL_algorithm (str, optional): The RL algorithm to use ('q-learning', 'sarsa', or 'sarsa_lambda').\n",
        "    - num_epoch (int, optional): Number of training episodes.\n",
        "    - gamma (float, optional): Discount factor for future rewards.\n",
        "    - epsilon (float, optional): Exploration rate.\n",
        "    - alpha (float, optional): Learning rate.\n",
        "    - lambda_ (float, optional): Eligibility trace decay factor (for SARSA(λ)).\n",
        "    - plot (bool, optional): Whether to plot the initial and final graph with the path.\n",
        "\n",
        "    This function constructs a graph from the provided edges, runs the specified reinforcement learning\n",
        "    algorithm (Q-learning, SARSA, or SARSA(λ)) to find the shortest path, and visualizes the graph and path.\n",
        "    \"\"\"\n",
        "    # Create the graph with weighted edges\n",
        "    G = nx.Graph()\n",
        "\n",
        "    # Add edges to the graph, ensuring each edge is added in both directions\n",
        "    for u, v, weight in edges:\n",
        "        if not G.has_edge(u, v):  # Add edge if it doesn't exist already\n",
        "            G.add_edge(u, v, weight=weight)\n",
        "        if not G.has_edge(v, u):  # Add reverse edge if it doesn't exist already\n",
        "            G.add_edge(v, u, weight=weight)\n",
        "\n",
        "    # Visualize the initial graph before Q-learning or SARSA starts (only if plot=True)\n",
        "    if plot:\n",
        "        plot_graph(G, \"Initial graph visualization:\", start_node=start_node, aim_node=aim_node)\n",
        "\n",
        "    # Instantiate PathFinder class to run reinforcement learning algorithms\n",
        "    rl = PathFinder(G)\n",
        "\n",
        "    # Record the start time for performance tracking\n",
        "    start_time = time.time()\n",
        "\n",
        "    # Perform Q-learning, SARSA, or SARSA(λ) based on the selected algorithm\n",
        "    if RL_algorithm == 'q_learning':\n",
        "        result_path = rl.q_learning(start_state=start_node, aim_state=aim_node, num_epoch=num_epoch, gamma=gamma, epsilon=epsilon, alpha=alpha)\n",
        "    elif RL_algorithm == 'sarsa':\n",
        "        result_path = rl.sarsa(start_state=start_node, aim_state=aim_node, num_epoch=num_epoch, gamma=gamma, epsilon=epsilon, alpha=alpha)\n",
        "    elif RL_algorithm == 'sarsa_lambda':\n",
        "        result_path = rl.sarsa_lambda(start_state=start_node, aim_state=aim_node, num_epoch=num_epoch, gamma=gamma, epsilon=epsilon, alpha=alpha, lambda_=lambda_)\n",
        "    else:\n",
        "        # Raise an error if an invalid RL_algorithm is provided\n",
        "        raise ValueError(\"Currently, only 'q-learning', 'sarsa', and 'sarsa_lambda' are supported.\")\n",
        "\n",
        "    # Record the end time for performance tracking\n",
        "    end_time = time.time()\n",
        "\n",
        "    # Calculate and print elapsed time\n",
        "    elapsed_time = end_time - start_time\n",
        "    print(f\"Time taken to complete {RL_algorithm}: {elapsed_time:.2f} seconds\")\n",
        "\n",
        "    # Print the learned path\n",
        "    print(f\"Learned path from node {start_node} to node {aim_node}: {result_path}\")\n",
        "\n",
        "    # Calculate the total path length (sum of edge weights along the path)\n",
        "    path_length = 0\n",
        "    for i in range(len(result_path) - 1):\n",
        "        u, v = result_path[i], result_path[i + 1]\n",
        "        path_length += G[u][v]['weight']  # Sum up the weights of the edges in the path\n",
        "\n",
        "    # Print the total path length\n",
        "    print(f\"Path length: {path_length}\")\n",
        "\n",
        "    # Visualize the graph with the learned path highlighted (if plot=True)\n",
        "    if plot:\n",
        "        plot_graph(G, f\"\\nGraph with the shortest path found by {RL_algorithm}:\", result_path, start_node=start_node, aim_node=aim_node)\n",
        "\n",
        "\n",
        "# Example of how to use the pathfinder function\n",
        "if __name__ == '__main__':\n",
        "    # Define edges with weights (distance between nodes), where only one direction is provided\n",
        "    edges = [\n",
        "            (0, 1, 1), (0, 3, 1), (4, 2, 2), (4, 1, 2),\n",
        "            (4, 8, 1), (4, 9, 2), (2, 3, 1), (2, 6, 2),\n",
        "            (2, 5, 1), (5, 6, 2), (7, 8, 1), (7, 5, 2),\n",
        "            (2, 10, 3), (10, 6, 1), (8, 9, 3), (8, 11, 1),\n",
        "            (9, 11, 1)  # Only one direction for the edges\n",
        "            ]\n",
        "\n",
        "    # Run the pathfinder for the defined edges with custom arguments (example for Q-Learning)\n",
        "    shortestpathfinder(edges, start_node=0, aim_node=11, RL_algorithm='q_learning', epsilon=0.02, plot=True, num_epoch=300)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "eE0pDLBzXRnD",
        "outputId": "a195e621-067b-45b7-a301-a2446bea6571"
      },
      "execution_count": 57,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Episode 1/300\n",
            "Starting state: 0\n",
            "  Current state: 0 -> Next state: 1\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.1000\n",
            "  Current state: 1 -> Next state: 0\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.1000\n",
            "  Current state: 0 -> Next state: 3\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.1000\n",
            "  Current state: 3 -> Next state: 0\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.1080\n",
            "  Current state: 0 -> Next state: 1\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.1900\n",
            "  Current state: 1 -> Next state: 4\n",
            "    Edge weight (distance): 2  Reward: -2\n",
            "    Updated Q-table: -0.2000\n",
            "  Current state: 4 -> Next state: 1\n",
            "    Edge weight (distance): 2  Reward: -2\n",
            "    Updated Q-table: -0.2080\n",
            "  Current state: 1 -> Next state: 0\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.1980\n",
            "  Current state: 0 -> Next state: 3\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.1900\n",
            "  Current state: 3 -> Next state: 2\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.1000\n",
            "  Current state: 2 -> Next state: 3\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.1080\n",
            "  Current state: 3 -> Next state: 2\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.1900\n",
            "  Current state: 2 -> Next state: 4\n",
            "    Edge weight (distance): 2  Reward: -2\n",
            "    Updated Q-table: -0.2000\n",
            "  Current state: 4 -> Next state: 2\n",
            "    Edge weight (distance): 2  Reward: -2\n",
            "    Updated Q-table: -0.2000\n",
            "  Current state: 2 -> Next state: 5\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.1000\n",
            "  Current state: 5 -> Next state: 2\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.1000\n",
            "  Current state: 2 -> Next state: 6\n",
            "    Edge weight (distance): 2  Reward: -2\n",
            "    Updated Q-table: -0.2000\n",
            "  Current state: 6 -> Next state: 2\n",
            "    Edge weight (distance): 2  Reward: -2\n",
            "    Updated Q-table: -0.2000\n",
            "  Current state: 2 -> Next state: 10\n",
            "    Edge weight (distance): 3  Reward: -3\n",
            "    Updated Q-table: -0.3000\n",
            "  Current state: 10 -> Next state: 2\n",
            "    Edge weight (distance): 3  Reward: -3\n",
            "    Updated Q-table: -0.3080\n",
            "  Current state: 2 -> Next state: 6\n",
            "    Edge weight (distance): 2  Reward: -2\n",
            "    Updated Q-table: -0.3800\n",
            "  Current state: 6 -> Next state: 5\n",
            "    Edge weight (distance): 2  Reward: -2\n",
            "    Updated Q-table: -0.2000\n",
            "  Current state: 5 -> Next state: 6\n",
            "    Edge weight (distance): 2  Reward: -2\n",
            "    Updated Q-table: -0.2000\n",
            "  Current state: 6 -> Next state: 10\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.1000\n",
            "  Current state: 10 -> Next state: 6\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.1080\n",
            "  Current state: 6 -> Next state: 10\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.1986\n",
            "  Current state: 10 -> Next state: 6\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.2131\n",
            "  Current state: 6 -> Next state: 10\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.2958\n",
            "  Current state: 10 -> Next state: 6\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.3078\n",
            "  Current state: 6 -> Next state: 2\n",
            "    Edge weight (distance): 2  Reward: -2\n",
            "    Updated Q-table: -0.3880\n",
            "  Current state: 2 -> Next state: 5\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.1900\n",
            "  Current state: 5 -> Next state: 7\n",
            "    Edge weight (distance): 2  Reward: -2\n",
            "    Updated Q-table: -0.2000\n",
            "  Current state: 7 -> Next state: 5\n",
            "    Edge weight (distance): 2  Reward: -2\n",
            "    Updated Q-table: -0.2080\n",
            "  Current state: 5 -> Next state: 2\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.1986\n",
            "  Current state: 2 -> Next state: 3\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.2058\n",
            "  Current state: 3 -> Next state: 0\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.2124\n",
            "  Current state: 0 -> Next state: 1\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.2868\n",
            "  Current state: 1 -> Next state: 0\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.2934\n",
            "  Current state: 0 -> Next state: 3\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.2862\n",
            "  Current state: 3 -> Next state: 2\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.2862\n",
            "  Current state: 2 -> Next state: 5\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.2869\n",
            "  Current state: 5 -> Next state: 2\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.2948\n",
            "  Current state: 2 -> Next state: 4\n",
            "    Edge weight (distance): 2  Reward: -2\n",
            "    Updated Q-table: -0.3800\n",
            "  Current state: 4 -> Next state: 8\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.1000\n",
            "  Current state: 8 -> Next state: 4\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.1000\n",
            "  Current state: 4 -> Next state: 9\n",
            "    Edge weight (distance): 2  Reward: -2\n",
            "    Updated Q-table: -0.2000\n",
            "  Current state: 9 -> Next state: 4\n",
            "    Edge weight (distance): 2  Reward: -2\n",
            "    Updated Q-table: -0.2080\n",
            "  Current state: 4 -> Next state: 8\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.1900\n",
            "  Current state: 8 -> Next state: 7\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.1000\n",
            "  Current state: 7 -> Next state: 8\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.1000\n",
            "  Current state: 8 -> Next state: 9\n",
            "    Edge weight (distance): 3  Reward: -3\n",
            "    Updated Q-table: -0.3000\n",
            "  Current state: 9 -> Next state: 8\n",
            "    Edge weight (distance): 3  Reward: -3\n",
            "    Updated Q-table: -0.3000\n",
            "  Current state: 8 -> Next state: 11\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.1000\n",
            "  Goal state 11 reached!\n",
            "Episode 1 completed. Path length: 76\n",
            "--------------------------------------------------\n",
            "Episode 30/300\n",
            "Starting state: 0\n",
            "  Current state: 0 -> Next state: 3\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -2.5645\n",
            "  Current state: 3 -> Next state: 2\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -2.3571\n",
            "  Current state: 2 -> Next state: 6\n",
            "    Edge weight (distance): 2  Reward: -2\n",
            "    Updated Q-table: -2.2211\n",
            "  Current state: 6 -> Next state: 5\n",
            "    Edge weight (distance): 2  Reward: -2\n",
            "    Updated Q-table: -2.1397\n",
            "  Current state: 5 -> Next state: 2\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -2.0261\n",
            "  Current state: 2 -> Next state: 5\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -2.1449\n",
            "  Current state: 5 -> Next state: 6\n",
            "    Edge weight (distance): 2  Reward: -2\n",
            "    Updated Q-table: -2.1704\n",
            "  Current state: 6 -> Next state: 10\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -2.0747\n",
            "  Current state: 10 -> Next state: 6\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -2.0841\n",
            "  Current state: 6 -> Next state: 10\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -2.1339\n",
            "  Current state: 10 -> Next state: 6\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -2.1464\n",
            "  Current state: 6 -> Next state: 10\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -2.1923\n",
            "  Current state: 10 -> Next state: 6\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -2.2028\n",
            "  Current state: 6 -> Next state: 2\n",
            "    Edge weight (distance): 2  Reward: -2\n",
            "    Updated Q-table: -2.2950\n",
            "  Current state: 2 -> Next state: 3\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -2.2084\n",
            "  Current state: 3 -> Next state: 2\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -2.3930\n",
            "  Current state: 2 -> Next state: 5\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -2.1925\n",
            "  Current state: 5 -> Next state: 2\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -2.0970\n",
            "  Current state: 2 -> Next state: 4\n",
            "    Edge weight (distance): 2  Reward: -2\n",
            "    Updated Q-table: -2.2616\n",
            "  Current state: 4 -> Next state: 1\n",
            "    Edge weight (distance): 2  Reward: -2\n",
            "    Updated Q-table: -1.6285\n",
            "  Current state: 1 -> Next state: 0\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -2.4588\n",
            "  Current state: 0 -> Next state: 1\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -2.5774\n",
            "  Current state: 1 -> Next state: 4\n",
            "    Edge weight (distance): 2  Reward: -2\n",
            "    Updated Q-table: -2.4760\n",
            "  Current state: 4 -> Next state: 8\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -1.4100\n",
            "  Current state: 8 -> Next state: 11\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.8906\n",
            "  Goal state 11 reached!\n",
            "Episode 30 completed. Path length: 32\n",
            "--------------------------------------------------\n",
            "Episode 60/300\n",
            "Starting state: 0\n",
            "  Current state: 0 -> Next state: 1\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -3.2903\n",
            "  Current state: 1 -> Next state: 0\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -3.1461\n",
            "  Current state: 0 -> Next state: 3\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -3.3008\n",
            "  Current state: 3 -> Next state: 2\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -3.1090\n",
            "  Current state: 2 -> Next state: 5\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -2.8869\n",
            "  Current state: 5 -> Next state: 7\n",
            "    Edge weight (distance): 2  Reward: -2\n",
            "    Updated Q-table: -2.7652\n",
            "  Current state: 7 -> Next state: 8\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -1.5834\n",
            "  Current state: 8 -> Next state: 11\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.9943\n",
            "  Goal state 11 reached!\n",
            "Episode 60 completed. Path length: 9\n",
            "--------------------------------------------------\n",
            "Episode 90/300\n",
            "Starting state: 0\n",
            "  Current state: 0 -> Next state: 1\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -3.6101\n",
            "  Current state: 1 -> Next state: 4\n",
            "    Edge weight (distance): 2  Reward: -2\n",
            "    Updated Q-table: -3.3729\n",
            "  Current state: 4 -> Next state: 8\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -1.7938\n",
            "  Current state: 8 -> Next state: 11\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -0.9998\n",
            "  Goal state 11 reached!\n",
            "Episode 90 completed. Path length: 5\n",
            "--------------------------------------------------\n",
            "Episode 120/300\n",
            "Starting state: 0\n",
            "  Current state: 0 -> Next state: 1\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -3.7254\n",
            "  Current state: 1 -> Next state: 4\n",
            "    Edge weight (distance): 2  Reward: -2\n",
            "    Updated Q-table: -3.4325\n",
            "  Current state: 4 -> Next state: 8\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -1.7996\n",
            "  Current state: 8 -> Next state: 11\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -1.0000\n",
            "  Goal state 11 reached!\n",
            "Episode 120 completed. Path length: 5\n",
            "--------------------------------------------------\n",
            "Episode 150/300\n",
            "Starting state: 0\n",
            "  Current state: 0 -> Next state: 1\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -3.7496\n",
            "  Current state: 1 -> Next state: 4\n",
            "    Edge weight (distance): 2  Reward: -2\n",
            "    Updated Q-table: -3.4396\n",
            "  Current state: 4 -> Next state: 8\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -1.8000\n",
            "  Current state: 8 -> Next state: 11\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -1.0000\n",
            "  Goal state 11 reached!\n",
            "Episode 150 completed. Path length: 5\n",
            "--------------------------------------------------\n",
            "Episode 180/300\n",
            "Starting state: 0\n",
            "  Current state: 0 -> Next state: 1\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -3.7518\n",
            "  Current state: 1 -> Next state: 4\n",
            "    Edge weight (distance): 2  Reward: -2\n",
            "    Updated Q-table: -3.4400\n",
            "  Current state: 4 -> Next state: 8\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -1.8000\n",
            "  Current state: 8 -> Next state: 11\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -1.0000\n",
            "  Goal state 11 reached!\n",
            "Episode 180 completed. Path length: 5\n",
            "--------------------------------------------------\n",
            "Episode 210/300\n",
            "Starting state: 0\n",
            "  Current state: 0 -> Next state: 1\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -3.7520\n",
            "  Current state: 1 -> Next state: 4\n",
            "    Edge weight (distance): 2  Reward: -2\n",
            "    Updated Q-table: -3.4400\n",
            "  Current state: 4 -> Next state: 8\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -1.8000\n",
            "  Current state: 8 -> Next state: 11\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -1.0000\n",
            "  Goal state 11 reached!\n",
            "Episode 210 completed. Path length: 5\n",
            "--------------------------------------------------\n",
            "Episode 240/300\n",
            "Starting state: 0\n",
            "  Current state: 0 -> Next state: 1\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -3.7520\n",
            "  Current state: 1 -> Next state: 4\n",
            "    Edge weight (distance): 2  Reward: -2\n",
            "    Updated Q-table: -3.4400\n",
            "  Current state: 4 -> Next state: 8\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -1.8000\n",
            "  Current state: 8 -> Next state: 11\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -1.0000\n",
            "  Goal state 11 reached!\n",
            "Episode 240 completed. Path length: 5\n",
            "--------------------------------------------------\n",
            "Episode 270/300\n",
            "Starting state: 0\n",
            "  Current state: 0 -> Next state: 1\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -3.7520\n",
            "  Current state: 1 -> Next state: 4\n",
            "    Edge weight (distance): 2  Reward: -2\n",
            "    Updated Q-table: -3.4400\n",
            "  Current state: 4 -> Next state: 8\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -1.8000\n",
            "  Current state: 8 -> Next state: 11\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -1.0000\n",
            "  Goal state 11 reached!\n",
            "Episode 270 completed. Path length: 5\n",
            "--------------------------------------------------\n",
            "Episode 300/300\n",
            "Starting state: 0\n",
            "  Current state: 0 -> Next state: 1\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -3.7520\n",
            "  Current state: 1 -> Next state: 4\n",
            "    Edge weight (distance): 2  Reward: -2\n",
            "    Updated Q-table: -3.4400\n",
            "  Current state: 4 -> Next state: 8\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -1.8000\n",
            "  Current state: 8 -> Next state: 11\n",
            "    Edge weight (distance): 1  Reward: -1\n",
            "    Updated Q-table: -1.0000\n",
            "  Goal state 11 reached!\n",
            "Episode 300 completed. Path length: 5\n",
            "--------------------------------------------------\n",
            "Time taken to complete q_learning: 0.23 seconds\n",
            "Learned path from node 0 to node 11: [0, 1, 4, 8, 11]\n",
            "Path length: 5\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}