evaluate_hashes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Field Testing Simulation and Metrics Evaluation\n",
    "\n",
    "This notebook simulates field testing for routing optimization, evaluates navigation performance, and generates synthetic feedback. The workflow includes:\n",
    "\n",
    "1. Setting up the road network and geospatial data.\n",
    "2. Simulating field testing scenarios between buildings and landmarks.\n",
    "3. Generating synthetic feedback based on simulation results.\n",
    "4. Calculating performance metrics, such as travel time and success rate.\n",
    "\n",
    "The goal is to assess the effectiveness of routing optimizations and identify potential areas for improvement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/users/smalla/landmark-based-urban-navigation/venv/lib64/python3.9/site-packages/networkx/utils/backends.py:135: RuntimeWarning: networkx backend defined more than once: nx-loopback\n",
      "  backends.update(_get_backends(\"networkx.backends\"))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "31019057 2169068697 {'osmid': 171603743, 'lanes': '3', 'ref': 'F26', 'name': 'चाबहिल-बौद्ध-जोरपाटी सडक', 'highway': 'primary', 'width': '14', 'oneway': False, 'reversed': True, 'length': np.float64(46.559), 'speed_kph': 35.5, 'travel_time': 4.7}\n",
      "31019057 724349918 {'osmid': 171603743, 'lanes': '3', 'ref': 'F26', 'name': 'चाबहिल-बौद्ध-जोरपाटी सडक', 'highway': 'primary', 'width': '14', 'oneway': False, 'reversed': False, 'length': np.float64(187.325), 'geometry': <LINESTRING (85.364 27.72, 85.363 27.72, 85.363 27.721, 85.362 27.721, 85.36...>, 'speed_kph': 35.5, 'travel_time': 19.0}\n",
      "31019057 5622458522 {'osmid': [588729673, 588729674, 588729675], 'highway': 'residential', 'oneway': False, 'reversed': False, 'length': np.float64(136.057), 'geometry': <LINESTRING (85.364 27.72, 85.364 27.721, 85.364 27.721, 85.364 27.721, 85.3...>, 'speed_kph': 24.5, 'travel_time': 20.0}\n",
      "31019141 2126598729 {'osmid': 4825630, 'oneway': True, 'lanes': '2', 'name': 'कान्ति पथ', 'highway': 'primary', 'width': '14', 'reversed': False, 'length': np.float64(159.45100000000002), 'geometry': <LINESTRING (85.314 27.707, 85.314 27.708, 85.314 27.708, 85.314 27.708)>, 'speed_kph': 35.5, 'travel_time': 16.2}\n",
      "31019141 1918201219 {'osmid': 218316959, 'name': 'Siddhidas Marg', 'highway': 'residential', 'oneway': False, 'reversed': False, 'length': np.float64(93.821), 'geometry': <LINESTRING (85.314 27.707, 85.314 27.707, 85.314 27.707, 85.313 27.707, 85....>, 'speed_kph': 24.5, 'travel_time': 13.8}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Simulating Field Testing:   4%|▍         | 5913/149054 [28:21<11:12:22,  3.55it/s]"
     ]
    }
   ],
   "source": [
    "import osmnx as ox\n",
    "import networkx as nx\n",
    "from tqdm import tqdm\n",
    "import pandas as pd\n",
    "from multiprocessing import Pool, cpu_count\n",
    "import itertools\n",
    "\n",
    "\n",
    "def heuristic(u, v, G):\n",
    "    \"\"\"\n",
    "    Custom heuristic function for A* algorithm that calculates great-circle distance.\n",
    "    Args:\n",
    "        u (int): Start node ID.\n",
    "        v (int): End node ID.\n",
    "        G (networkx.Graph): Road network graph.\n",
    "    Returns:\n",
    "        float: Great-circle distance between u and v.\n",
    "    \"\"\"\n",
    "    try:\n",
    "        u_lat, u_lon = G.nodes[u]['y'], G.nodes[u]['x']\n",
    "        v_lat, v_lon = G.nodes[v]['y'], G.nodes[v]['x']\n",
    "        return ox.distance.great_circle_vec(u_lat, u_lon, v_lat, v_lon)\n",
    "    except KeyError as e:\n",
    "        raise ValueError(f\"Missing node attributes for {u} or {v}: {e}\")\n",
    "\n",
    "\n",
    "def process_scenario(args):\n",
    "    \"\"\"\n",
    "    Process a single field-testing scenario for multiprocessing.\n",
    "    Args:\n",
    "        args (tuple): Tuple containing building, landmark, and the graph.\n",
    "    Returns:\n",
    "        dict: Result of the simulation scenario.\n",
    "    \"\"\"\n",
    "    building, random_landmark, G = args\n",
    "    try:\n",
    "        building_coords = (building['latitude'], building['longitude'])\n",
    "        landmark_coords = (random_landmark['lat'], random_landmark['lon'])\n",
    "\n",
    "        building_node = ox.distance.nearest_nodes(G, building_coords[1], building_coords[0])\n",
    "        landmark_node = ox.distance.nearest_nodes(G, landmark_coords[1], landmark_coords[0])\n",
    "\n",
    "        if not nx.has_path(G, building_node, landmark_node):\n",
    "            return {\n",
    "                'Building': f\"({building_coords[0]}, {building_coords[1]})\",\n",
    "                'Landmark': f\"({landmark_coords[0]}, {landmark_coords[1]}) - {random_landmark['tags_name']}\",\n",
    "                'Path Length': None,\n",
    "                'Travel Time (s)': None,\n",
    "                'Status': 'Failed',\n",
    "                'Error': 'No path exists between nodes'\n",
    "            }\n",
    "\n",
    "        path = nx.astar_path(\n",
    "            G,\n",
    "            building_node,\n",
    "            landmark_node,\n",
    "            heuristic=lambda u, v: heuristic(u, v, G),\n",
    "            weight='travel_time'\n",
    "        )\n",
    "        path_length = len(path)\n",
    "        # Corrected travel time computation\n",
    "        travel_time = sum(\n",
    "            G.get_edge_data(path[i], path[i+1])[0].get('travel_time', 0)  # Retrieve travel time for exact edge\n",
    "            for i in range(len(path)-1)\n",
    "        )\n",
    "\n",
    "        return {\n",
    "            'Building': f\"({building_coords[0]}, {building_coords[1]})\",\n",
    "            'Landmark': f\"({landmark_coords[0]}, {landmark_coords[1]}) - {random_landmark['tags_name']}\",\n",
    "            'Path Length': path_length,\n",
    "            'Travel Time (s)': travel_time,\n",
    "            'Status': 'Success'\n",
    "        }\n",
    "    except Exception as e:\n",
    "        return {\n",
    "            'Building': f\"({building['latitude']}, {building['longitude']})\",\n",
    "            'Landmark': f\"({random_landmark['lat']}, {random_landmark['lon']}) - {random_landmark['tags_name']}\",\n",
    "            'Path Length': None,\n",
    "            'Travel Time (s)': None,\n",
    "            'Status': 'Failed',\n",
    "            'Error': str(e)\n",
    "        }\n",
    "\n",
    "def simulate_field_testing(buildings_df, landmarks_df, G, num_scenarios=1000):\n",
    "    \"\"\"\n",
    "    Simulate field testing for landmark-based addressing and pathfinding using multiprocessing.\n",
    "    Args:\n",
    "        buildings_df (pd.DataFrame): Building data with latitude and longitude.\n",
    "        landmarks_df (pd.DataFrame): Landmark data with latitude, longitude, and names.\n",
    "        G (networkx.Graph): Road network graph.\n",
    "        num_scenarios (int): Number of test scenarios to simulate.\n",
    "    Returns:\n",
    "        pd.DataFrame: Results of simulated testing.\n",
    "    \"\"\"\n",
    "    if num_scenarios > len(buildings_df):\n",
    "        raise ValueError(\"Number of scenarios cannot exceed the number of buildings.\")\n",
    "    \n",
    "    if num_scenarios == 0:\n",
    "        building_sample = buildings_df\n",
    "        landmark_sample = landmarks_df\n",
    "        num_scenarios = len(buildings_df)\n",
    "    else:\n",
    "        building_sample = buildings_df.sample(num_scenarios)\n",
    "        landmark_sample = landmarks_df.sample(min(num_scenarios, len(landmarks_df)))\n",
    "\n",
    "    # Create arguments for multiprocessing\n",
    "    args = zip(building_sample.to_dict('records'), itertools.cycle(landmark_sample.to_dict('records')), itertools.repeat(G))\n",
    "\n",
    "    # Utilize all available CPUs\n",
    "    with Pool(cpu_count()) as pool:\n",
    "        results = list(tqdm(pool.imap(process_scenario, args), total=num_scenarios, desc=\"Simulating Field Testing\"))\n",
    "\n",
    "    return pd.DataFrame(results)\n",
    "\n",
    "\n",
    "# Load the graph and datasets\n",
    "G = ox.graph_from_place(\"Kathmandu, Nepal\", network_type=\"drive\")\n",
    "\n",
    "# Add speed and travel time attributes to the graph\n",
    "G = ox.add_edge_speeds(G)  # Add speed limits to edges\n",
    "G = ox.add_edge_travel_times(G)  # Calculate travel time based on speed and length\n",
    "\n",
    "# Validate the edge attributes (optional)\n",
    "for u, v, data in list(G.edges(data=True))[:5]:\n",
    "    print(u, v, data)\n",
    "\n",
    "# Load datasets\n",
    "buildings = pd.read_csv('./data/kathmandu_buildings.csv')\n",
    "landmarks = pd.read_csv('./data/cleaned_landmarks.csv')\n",
    "\n",
    "# Simulate field testing\n",
    "simulation_results = simulate_field_testing(buildings, landmarks, G, num_scenarios=0) # tweak the number of scenarios here if needed\n",
    "simulation_results.to_csv('./data/simulated_field_testing_results.csv', index=False)\n",
    "print(\"Simulation completed. Results saved to './data/simulated_field_testing_results.csv'.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of buildings: 149054\n",
      "Number of landmarks: 7765\n",
      "Number of simulation results: 10\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Dataset Summary:\n",
      "              Dataset   Count\n",
      "0           Buildings  149054\n",
      "1           Landmarks    7765\n",
      "2  Simulation Results      10\n"
     ]
    }
   ],
   "source": [
    "# Import necessary libraries\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "\n",
    "# Visualize the number of records in each dataset\n",
    "print(\"Number of buildings:\", len(buildings))\n",
    "print(\"Number of landmarks:\", len(landmarks))\n",
    "print(\"Number of simulation results:\", len(simulation_results))\n",
    "\n",
    "# Create a summary of dataset sizes\n",
    "summary_stats = {\n",
    "    \"Dataset\": [\"Buildings\", \"Landmarks\", \"Simulation Results\"],\n",
    "    \"Count\": [len(buildings), len(landmarks), len(simulation_results)]\n",
    "}\n",
    "\n",
    "# Plot dataset counts\n",
    "plt.figure(figsize=(8, 5))\n",
    "plt.bar(summary_stats[\"Dataset\"], summary_stats[\"Count\"], color='skyblue')\n",
    "plt.title(\"Dataset Record Counts\")\n",
    "plt.xlabel(\"Dataset\")\n",
    "plt.ylabel(\"Number of Records\")\n",
    "plt.show()\n",
    "\n",
    "# Display a table summarizing the dataset counts\n",
    "summary_table = pd.DataFrame(summary_stats)\n",
    "print(\"\\nDataset Summary:\")\n",
    "print(summary_table)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Preview of simulation results:\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Building</th>\n",
       "      <th>Landmark</th>\n",
       "      <th>Path Length</th>\n",
       "      <th>Travel Time (s)</th>\n",
       "      <th>Status</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>(27.69636534795584, 85.30758771868153)</td>\n",
       "      <td>(27.7203029, 85.3512059) - Stupa community hos...</td>\n",
       "      <td>90</td>\n",
       "      <td>883.7</td>\n",
       "      <td>Success</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>(27.71660505, 85.342233)</td>\n",
       "      <td>(27.7183368, 85.3470781) - Hamro bhetghat Rodh...</td>\n",
       "      <td>15</td>\n",
       "      <td>136.3</td>\n",
       "      <td>Success</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>(27.71497899545228, 85.29905142221061)</td>\n",
       "      <td>(27.7389793, 85.3382731) - Nimto Restro And Bar</td>\n",
       "      <td>86</td>\n",
       "      <td>784.6</td>\n",
       "      <td>Success</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>(27.728312000000003, 85.3198967)</td>\n",
       "      <td>(27.6829433, 85.3434407) - Tedi Pharmacy</td>\n",
       "      <td>112</td>\n",
       "      <td>1135.4</td>\n",
       "      <td>Success</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>(27.69021812879776, 85.34775889056178)</td>\n",
       "      <td>(27.7109936, 85.3111151) - लुल्बिनी तन्दुरी र ...</td>\n",
       "      <td>69</td>\n",
       "      <td>757.8</td>\n",
       "      <td>Success</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>(27.68231376350843, 85.34605120601329)</td>\n",
       "      <td>(27.6756886, 85.385366) - Prism Savings And Cr...</td>\n",
       "      <td>54</td>\n",
       "      <td>543.6</td>\n",
       "      <td>Success</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>(27.71113245, 85.31204199999999)</td>\n",
       "      <td>(27.7392088, 85.3392954) - Richmond Food Cafe</td>\n",
       "      <td>57</td>\n",
       "      <td>785.3</td>\n",
       "      <td>Success</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>(27.7219023124812, 85.32294630635832)</td>\n",
       "      <td>(27.6295866, 85.5257384) - Radhakrishna Bachat...</td>\n",
       "      <td>132</td>\n",
       "      <td>1191.0</td>\n",
       "      <td>Success</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>(27.714647718218515, 85.29953840289019)</td>\n",
       "      <td>(27.6861744, 85.2771876) - Maitinagar Pharmacy</td>\n",
       "      <td>84</td>\n",
       "      <td>980.3</td>\n",
       "      <td>Success</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>(27.694831227303126, 85.33580984445484)</td>\n",
       "      <td>(27.7396211, 85.337974) - Agricultural Develop...</td>\n",
       "      <td>75</td>\n",
       "      <td>714.6</td>\n",
       "      <td>Success</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                  Building  \\\n",
       "0   (27.69636534795584, 85.30758771868153)   \n",
       "1                 (27.71660505, 85.342233)   \n",
       "2   (27.71497899545228, 85.29905142221061)   \n",
       "3         (27.728312000000003, 85.3198967)   \n",
       "4   (27.69021812879776, 85.34775889056178)   \n",
       "5   (27.68231376350843, 85.34605120601329)   \n",
       "6         (27.71113245, 85.31204199999999)   \n",
       "7    (27.7219023124812, 85.32294630635832)   \n",
       "8  (27.714647718218515, 85.29953840289019)   \n",
       "9  (27.694831227303126, 85.33580984445484)   \n",
       "\n",
       "                                            Landmark  Path Length  \\\n",
       "0  (27.7203029, 85.3512059) - Stupa community hos...           90   \n",
       "1  (27.7183368, 85.3470781) - Hamro bhetghat Rodh...           15   \n",
       "2    (27.7389793, 85.3382731) - Nimto Restro And Bar           86   \n",
       "3           (27.6829433, 85.3434407) - Tedi Pharmacy          112   \n",
       "4  (27.7109936, 85.3111151) - लुल्बिनी तन्दुरी र ...           69   \n",
       "5  (27.6756886, 85.385366) - Prism Savings And Cr...           54   \n",
       "6      (27.7392088, 85.3392954) - Richmond Food Cafe           57   \n",
       "7  (27.6295866, 85.5257384) - Radhakrishna Bachat...          132   \n",
       "8     (27.6861744, 85.2771876) - Maitinagar Pharmacy           84   \n",
       "9  (27.7396211, 85.337974) - Agricultural Develop...           75   \n",
       "\n",
       "   Travel Time (s)   Status  \n",
       "0            883.7  Success  \n",
       "1            136.3  Success  \n",
       "2            784.6  Success  \n",
       "3           1135.4  Success  \n",
       "4            757.8  Success  \n",
       "5            543.6  Success  \n",
       "6            785.3  Success  \n",
       "7           1191.0  Success  \n",
       "8            980.3  Success  \n",
       "9            714.6  Success  "
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Display the first few rows of simulation results\n",
    "print(\"\\nPreview of simulation results:\")\n",
    "simulation_results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Geospatial and Graph Setup\n",
    "\n",
    "This section initializes the road network graph using OSMnx, loads datasets containing building and landmark information, and defines helper functions, such as a custom heuristic for the A* algorithm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Synthetic feedback generated. Results saved to './data/synthetic_feedback.csv'.\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "def generate_synthetic_feedback(simulation_results):\n",
    "    \"\"\"\n",
    "    Generate synthetic feedback based on simulated field testing results.\n",
    "\n",
    "    Args:\n",
    "        simulation_results (pd.DataFrame): Results from simulated field testing.\n",
    "\n",
    "    Returns:\n",
    "        pd.DataFrame: Synthetic feedback with performance metrics.\n",
    "    \"\"\"\n",
    "    feedback = []\n",
    "    for _, row in simulation_results.iterrows():\n",
    "        if row['Path Length'] and row['Travel Time (s)']:\n",
    "            feedback.append({\n",
    "                'Scenario': f\"Building {row['Building']} to Landmark {row['Landmark']}\",\n",
    "                'Feedback': \"Navigation successful and efficient.\",\n",
    "                'Rating': random.randint(8, 10) if row['Travel Time (s)'] < 300 else random.randint(6, 8)\n",
    "            })\n",
    "        else:\n",
    "            feedback.append({\n",
    "                'Scenario': f\"Building {row['Building']} to Landmark {row['Landmark']}\",\n",
    "                'Feedback': \"Navigation failed or suboptimal.\",\n",
    "                'Rating': random.randint(3, 5)\n",
    "            })\n",
    "\n",
    "    return pd.DataFrame(feedback)\n",
    "\n",
    "# Generate synthetic feedback\n",
    "synthetic_feedback = generate_synthetic_feedback(simulation_results)\n",
    "synthetic_feedback.to_csv('./data/synthetic_feedback.csv', index=False)\n",
    "print(\"Synthetic feedback generated. Results saved to './data/synthetic_feedback.csv'.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Field Testing Simulation\n",
    "\n",
    "The field-testing simulation involves generating random scenarios between buildings and landmarks, computing paths using the A* algorithm, and measuring travel time and path length. Multiprocessing is utilized to speed up the simulations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Performance Metrics: {'Average Travel Time (s)': np.float64(791.26), 'Average Path Length': np.float64(77.4), 'Success Rate (%)': 100.0}\n"
     ]
    }
   ],
   "source": [
    "def calculate_metrics(simulation_results):\n",
    "    \"\"\"\n",
    "    Calculate performance metrics from simulated results.\n",
    "\n",
    "    Args:\n",
    "        simulation_results (pd.DataFrame): Simulated field testing results.\n",
    "\n",
    "    Returns:\n",
    "        dict: Calculated performance metrics.\n",
    "    \"\"\"\n",
    "    successful_paths = simulation_results[simulation_results['Path Length'].notnull()]\n",
    "    avg_travel_time = successful_paths['Travel Time (s)'].mean()\n",
    "    avg_path_length = successful_paths['Path Length'].mean()\n",
    "    success_rate = len(successful_paths) / len(simulation_results) * 100\n",
    "\n",
    "    return {\n",
    "        'Average Travel Time (s)': avg_travel_time,\n",
    "        'Average Path Length': avg_path_length,\n",
    "        'Success Rate (%)': success_rate\n",
    "    }\n",
    "\n",
    "# Calculate metrics\n",
    "metrics = calculate_metrics(simulation_results)\n",
    "print(\"Performance Metrics:\", metrics)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Synthetic Feedback Generation\n",
    "\n",
    "Based on the results of the field-testing simulation, synthetic feedback is generated. Each scenario is rated and categorized as successful or suboptimal based on travel time and pathfinding results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Performance Metrics: {'Average Travel Time (s)': np.float64(0.0), 'Average Path Length': np.float64(78.93813387423936), 'Success Rate (%)': 98.6}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Performance Metrics Calculation\n",
    "\n",
    "Key metrics such as average travel time, average path length, and success rate are calculated from the simulation results. These metrics help evaluate the overall performance of the routing optimization."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion\n",
    "\n",
    "The notebook demonstrates a systematic approach to simulating and evaluating routing performance. By analyzing synthetic feedback and performance metrics, insights can be gained to refine routing strategies. Future extensions could include:\n",
    "\n",
    "- Incorporating real-world feedback for validation.\n",
    "- Exploring other pathfinding algorithms for comparison.\n",
    "- Enhancing the simulation with additional datasets or constraints."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "venv",
   "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.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}