EVRoutePlanning_ValueIteration.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Il-Wk5Sspx-L"
   },
   "outputs": [],
   "source": [
    "#### Script written by Yash Gupta ####"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "tWzokFbUp33j"
   },
   "outputs": [],
   "source": [
    "# Import libraries!\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import scipy.stats as ss\n",
    "from datetime import datetime, timedelta\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "vxhcNr-ep36p"
   },
   "outputs": [],
   "source": [
    "'''\n",
    "Below class allows the user to create an environment/map with each node as a charging station \n",
    "or just a freeway/road. Once the map is initialized, the user can provide an origin-destination \n",
    "pair and get the optimized route for their electric vehicle specifications. This EV Route Planner \n",
    "also takes into account the uncertainty around wait times encountered at various charging stations \n",
    "at different times of the day. To model this decision making under uncertainty this class uses \n",
    "the value iteration approach to generate an optimal solution/policy/route.\n",
    "'''\n",
    "\n",
    "class EVRoutePlanning_ValueIteration:\n",
    "    def __init__(\n",
    "        self,\n",
    "        X: int = 10,\n",
    "        Y: int = 10,\n",
    "        grid_length: int = 10,\n",
    "        num_chargers: int = 10\n",
    "    ):\n",
    "        self.X = X # size of map/grid in X direction\n",
    "        self.Y = Y # size of map/grid in Y direction\n",
    "        self.grid_length = grid_length # length/size of grid(square) in miles\n",
    "        self.map_shape = (self.X, self.Y)\n",
    "        self.num_chargers = num_chargers # total number of chargers on the map\n",
    "        self.map, self.charging_stations = self._initialize_map_with_charging_stations()\n",
    "        self.charging_wait_times = {} # dictionary for wait times (in minutes) for every charger at each hour of the day\n",
    "        self.origin = 0 # index of origin on the map/grid\n",
    "        self.destination = 0 # index of destination on the map/grid\n",
    "        self.start_time = datetime.fromisoformat(\"2023-03-01\") # start time of the journey\n",
    "        self.start_soc = 0.85 # start soc of the journey\n",
    "        self.desired_soc = 0.5 # desired soc at the end of the journey\n",
    "        self.vehicle_range = 400 # maximum range of the car in miles\n",
    "        self.minimum_journey_time = 0 # minimum time(in minutes) required to reach the destination\n",
    "        self.max_soc = 0.95 # max soc upto which charging is recommended\n",
    "        self.min_soc = 0.15 # min soc going below which isn't recommended\n",
    "        self.charging_rate = 5 # charging rate = 5 miles/minute\n",
    "        self.position_reward = np.zeros(shape = self.map_shape) # rewards based on positions on the map/grid\n",
    "        self.value_function = np.zeros(shape = self.map_shape) # value function for each positions on the map/grid\n",
    "\n",
    "    \n",
    "    def _initialize_map_with_charging_stations(self):\n",
    "        map = np.zeros(shape = self.map_shape, dtype = int)\n",
    "        charging_stations = np.random.choice(np.arange(self.X * self.Y - 1, dtype = int), \n",
    "                                             size = self.num_chargers, \n",
    "                                             replace = False)\n",
    "        for index in charging_stations:\n",
    "            i, j = np.unravel_index(index, shape = self.map_shape)\n",
    "            map[i][j] = 1\n",
    "        \n",
    "        return map, charging_stations\n",
    "    \n",
    "    def generate_wait_time_distribution_per_charger(self, prob_peak_hour, list_sd_hours, list_peak_wait_time, prob_peak_wait_time):\n",
    "        '''prob_peak_hour is a list of size 24 with probability values such that peak time(hour) \n",
    "        of the day for a charger occurs at hour \"i\" i.e., P(peak_hour == i) = prob_peak_hour[i]\n",
    "        Note - sum(prob_peak_hour) should be equal to 1, ofcourse!! \n",
    "        \n",
    "        list_sd_hours is a list of choices given for choosing the standard deviation of the \n",
    "        wait time distributon at each charger. An example of this list could be [2, 3, 4] or \n",
    "        [3, 4, 5] or even [4] which means a fixed standard deviation of 4 hours for each charger.\n",
    "\n",
    "        list_peak_wait_time is a list of choices given for choosing the expected wait time at \n",
    "        peak hour of the day for each charger. An example of this list could be [20, 30, 40, 50]\n",
    "        or [25, 30, 35, 40, 50, 60]. We can also give as input, in prob_peak_wait_time, the \n",
    "        probability for each wait time choices in the list to make it more realistic.\n",
    "        '''\n",
    "\n",
    "        list_hours = np.arange(24, dtype = int)\n",
    "        for charger_index in self.charging_stations:\n",
    "            peak_hour = np.random.choice(a = list_hours, \n",
    "                                         size = 1, \n",
    "                                         p = prob_peak_hour)\n",
    "            sd_hour = np.random.choice(a = list_sd_hours,\n",
    "                                       size = 1)\n",
    "            peak_wait_time = np.random.choice(a = list_peak_wait_time,\n",
    "                                              size = 1,\n",
    "                                              p = prob_peak_wait_time)\n",
    "\n",
    "            # create a random variable for wait time distribution\n",
    "            # Please refer to scipy.stats.truncnorm for details of the following distribution\n",
    "            a = -12 / sd_hour\n",
    "            b = 11 / sd_hour\n",
    "            rv = ss.truncnorm(a, b, loc = peak_hour, scale = sd_hour)\n",
    "            peak_pdf = rv.pdf(peak_hour)\n",
    "            for i in range(-12, 12):\n",
    "                hour = (i + peak_hour + 24) % 24\n",
    "                wait_time = int(rv.pdf(i + peak_hour) / peak_pdf * peak_wait_time)\n",
    "                key = str(charger_index) + ',' + str(hour[0])\n",
    "                self.charging_wait_times[key] = wait_time\n",
    "        return\n",
    "\n",
    "    def create_journey(self, origin, destination, start_time, start_soc = 0.85, desired_soc = 0.5, vehicle_range = 220):\n",
    "        '''This function allows us to create a journey for an origin-destination pair. \n",
    "        It simply means that we now have a game/problem for our given environment/map \n",
    "        for which we need to do route planning/finding the best optimal policy.\n",
    "        \n",
    "        minimum_journey_time is estimated using the origin-destination to calculate \n",
    "        total distance to be travelled, start soc, desired soc, vehicle range, \n",
    "        average vehicle speed and charging speed'''\n",
    "\n",
    "        x_origin, y_origin = np.unravel_index(origin, shape = self.map_shape)\n",
    "        x_destination, y_destination = np.unravel_index(destination, shape = self.map_shape)\n",
    "        L1_distance_org_dest = abs(x_origin - x_destination) + abs(y_origin - y_destination)\n",
    "        total_journey_distance = L1_distance_org_dest * self.grid_length # in miles\n",
    "        dest_soc = start_soc - total_journey_distance / self.vehicle_range # soc at destination if not charged\n",
    "        required_charging_time = int((desired_soc - dest_soc) * self.vehicle_range / self.charging_rate) # answer in minutes\n",
    "        minimum_journey_time = total_journey_distance + required_charging_time # in minutes - assuming average vehicle speed of 1 miles/min\n",
    "\n",
    "        self.origin = origin\n",
    "        self.destination = destination\n",
    "        self.start_time = start_time\n",
    "        self.start_soc = start_soc\n",
    "        self.desired_soc = desired_soc\n",
    "        self.vehicle_range = vehicle_range\n",
    "        self.minimum_journey_time = minimum_journey_time\n",
    "        return\n",
    "\n",
    "        \n",
    "    def initialize_position_rewards(self, weight_L1 = 0.1, dest_over_org = 1):\n",
    "        '''origin takes the index of charging station from which we start our journey while\n",
    "        destination takes the index of the charging station where we end our journey. To get \n",
    "        (x, y) pair of coordinates we will unravel these indices. To initialize the rewards \n",
    "        based on positions, we need to define a distance metric. Our goal is to have higher \n",
    "        rewards for positions closer to the shortest path b/w origin and destination and lower \n",
    "        or even negative rewards for positions farther from the shortest path.\n",
    "        \n",
    "        weight_L1 is a hyperparameter that controls the weights of L1 distance relative to \n",
    "        L2 distance in computing the rewards for each position. Note that the value of \n",
    "        weight_L1 should be in the range [0,1]. default value is 0.1\n",
    "        \n",
    "        dest_over_org is another hyperparameter that controls the relative importance of \n",
    "        closing in on destination while moving away from origin. Rationally, we would want \n",
    "        dest_over_org > 1 at all times. default value is 1'''\n",
    "\n",
    "        x_origin, y_origin = np.unravel_index(self.origin, shape = self.map_shape)\n",
    "        x_destination, y_destination = np.unravel_index(self.destination, shape = self.map_shape)\n",
    "        L1_distance_org_dest = abs(x_origin - x_destination) + abs(y_origin - y_destination)\n",
    "        L2_distance_org_dest = np.sqrt((x_origin - x_destination)**2 + (y_origin - y_destination)**2)\n",
    "        \n",
    "        for i in range(self.X):\n",
    "            for j in range(self.Y):\n",
    "                L1_distance_cur_pos_dest = abs(i - x_destination) + abs(j - y_destination)\n",
    "                L2_distance_cur_pos_dest = np.sqrt((i - x_destination)**2 + (j - y_destination)**2)\n",
    "                dest_reward = weight_L1 * (L1_distance_org_dest - L1_distance_cur_pos_dest) + (1 - weight_L1) * (L2_distance_org_dest - L2_distance_cur_pos_dest)\n",
    "                dest_reward = weight_L1 * np.exp((L1_distance_org_dest - L1_distance_cur_pos_dest) / L1_distance_org_dest * dest_over_org) + (1 - weight_L1) * np.exp((L2_distance_org_dest - L2_distance_cur_pos_dest) / L2_distance_org_dest * dest_over_org)\n",
    "                L1_distance_cur_pos_org = abs(i - x_origin) + abs(j - y_origin)\n",
    "                L2_distance_cur_pos_org = np.sqrt((i - x_origin)**2 + (j - y_origin)**2)\n",
    "                org_reward = weight_L1 * (L1_distance_org_dest - L1_distance_cur_pos_org) + (1 - weight_L1) * (L2_distance_org_dest - L2_distance_cur_pos_org)\n",
    "                org_reward = weight_L1 * np.exp((L1_distance_org_dest - L1_distance_cur_pos_org) / L1_distance_org_dest) + (1 - weight_L1) * np.exp((L2_distance_org_dest - L2_distance_cur_pos_org) / L2_distance_org_dest)\n",
    "                cur_pos_reward = dest_over_org * dest_reward + org_reward\n",
    "                cur_pos_reward = dest_reward + org_reward\n",
    "                self.position_reward[i][j] = cur_pos_reward\n",
    "        \n",
    "        # Normalize the rewards based in the rewards range for time_reward and soc_reward\n",
    "        self.position_reward = self.position_reward / np.max(self.position_reward) * 100\n",
    "        self.position_reward[x_destination][y_destination] = 2 * (np.max(self.position_reward) - np.min(self.position_reward)) # very high reward for destination\n",
    "        self.position_reward[x_origin][y_origin] = 0\n",
    "\n",
    "        # Initialize value function using position rewards\n",
    "        discount_factor = 0.8 # choice based on how much we want our positions rewards to spread and act as a route guide\n",
    "        self._initialize_value_function(discount_factor = discount_factor)\n",
    "\n",
    "        return\n",
    "    \n",
    "    def _initialize_value_function(self, discount_factor = 0.8):\n",
    "        self.value_function = np.copy(self.position_reward) # initialize value function as position rewards\n",
    "        num_iterations = 2 * int(1/(1 - discount_factor))\n",
    "        for itr in range(num_iterations):\n",
    "            for i in range(self.X):\n",
    "                for j in range(self.Y):\n",
    "                    current_state = (i, j, self.start_time, self.start_soc)\n",
    "                    best_action, max_action_value_function, next_state = self._find_best_action(current_state=current_state, \n",
    "                                                                                            discount_factor=discount_factor, \n",
    "                                                                                            initializing_value_function=True)\n",
    "                    self.value_function[i][j] = max_action_value_function\n",
    "\n",
    "        return\n",
    "\n",
    "    def _transition_model(self, current_state, action):\n",
    "        '''current_state is in the form of (x_cur, y_cur, time_cur, soc_cur) and it returns \n",
    "        the final state reached by taking the given action. Remember that our action space \n",
    "        is [left, right, up, down] which is indexed as [0, 1, 2, 3]'''\n",
    "\n",
    "        x_cur, y_cur, time_cur, soc_cur = current_state\n",
    "        time_fin = time_cur + timedelta(minutes = self.grid_length) # assuming average speed of 1 miles/min\n",
    "        soc_fin = soc_cur - self.grid_length / self.vehicle_range # assuming constant discharge over range\n",
    "        hit_the_wall = False # to record if we hit the wall by taking the given action\n",
    "        if(action == 0):\n",
    "            y_fin = y_cur\n",
    "            x_fin = x_cur - 1\n",
    "            if(x_fin < 0):\n",
    "                hit_the_wall = True\n",
    "        elif(action == 1):\n",
    "            y_fin = y_cur\n",
    "            x_fin = x_cur + 1\n",
    "            if(x_fin >= self.X):\n",
    "                hit_the_wall = True\n",
    "        elif(action == 2):\n",
    "            x_fin = x_cur\n",
    "            y_fin = y_cur - 1\n",
    "            if(y_fin < 0):\n",
    "                hit_the_wall = True\n",
    "        elif(action == 3):\n",
    "            x_fin = x_cur\n",
    "            y_fin = y_cur + 1\n",
    "            if(y_fin >= self.Y):\n",
    "                hit_the_wall = True\n",
    "        else:\n",
    "            print('Action not allowed!') # give error message\n",
    "        \n",
    "        # Return initial state if you hit the wall as no state transition occurs!!\n",
    "        if(hit_the_wall):\n",
    "            return current_state, hit_the_wall\n",
    "\n",
    "        # Check if the final position is a charging station\n",
    "        if(self.map[x_fin][y_fin] == 1):\n",
    "            charger_index = np.ravel_multi_index((x_fin, y_fin), self.map_shape)\n",
    "            key = str(charger_index) + ',' + str(time_fin.hour)\n",
    "            wait_time = self.charging_wait_times[key]\n",
    "            time_fin = time_fin + timedelta(minutes = wait_time) # add waiting time to final time\n",
    "            charging_time = int((self.max_soc - soc_fin) * self.vehicle_range / self.charging_rate) # answer in minutes\n",
    "            time_fin = time_fin + timedelta(minutes = charging_time) # add charging time to the final time\n",
    "            buffer_time = np.random.choice([5.,10.]) # assuming 5 or 10 minutes buffer time for charging set up and hitting the road\n",
    "            time_fin = time_fin + timedelta(minutes = buffer_time)\n",
    "            soc_fin = self.max_soc # charging is done!\n",
    "        \n",
    "        final_state = (x_fin, y_fin, time_fin, soc_fin)\n",
    "\n",
    "        return final_state, hit_the_wall\n",
    "    \n",
    "    def _reward_for_state(self, state):\n",
    "        x, y, time, soc = state\n",
    "\n",
    "        # reward based on the soc of the state\n",
    "        soc_reward = (soc - self.min_soc) / (self.max_soc - self.min_soc) * 100\n",
    "\n",
    "        # required parameters for calculating time based reward\n",
    "        time_travelled_till_now = int((time - self.start_time) / timedelta(minutes=1)) # in minutes\n",
    "\n",
    "        x_destination, y_destination = np.unravel_index(self.destination, shape = self.map_shape)\n",
    "        L1_distance_state_dest = abs(x - x_destination) + abs(y - y_destination)\n",
    "        total_journey_distance = L1_distance_state_dest * self.grid_length # in miles\n",
    "        dest_soc = soc - total_journey_distance / self.vehicle_range # soc at destination if not charged\n",
    "        required_charging_time = int((self.desired_soc - dest_soc) * self.vehicle_range / self.charging_rate) # answer in minutes\n",
    "        state_journey_time = total_journey_distance + required_charging_time # in minutes\n",
    "\n",
    "        # reward based on the time of the state\n",
    "        importance_of_time = 5 # hyperparameter \n",
    "        time_reward = 100 * np.exp((self.minimum_journey_time - time_travelled_till_now - state_journey_time) / self.minimum_journey_time * importance_of_time)\n",
    "        # To-Do: Think more about the function or time reward\n",
    "\n",
    "        return soc_reward + time_reward\n",
    "    \n",
    "    def _find_best_action(self, current_state, discount_factor, initializing_value_function = False):\n",
    "        '''Returns the best action to take for the current state after calculating the values \n",
    "        of action value function for each action'''\n",
    "\n",
    "        x_cur, y_cur, time_cur, soc_cur = current_state # extracting the variables associated with the current state\n",
    "        if(initializing_value_function):\n",
    "            current_reward = self.position_reward[x_cur][y_cur] # only position rewards if initializing value function\n",
    "        else:\n",
    "            current_reward = self.position_reward[x_cur][y_cur] + self._reward_for_state(current_state)\n",
    "        \n",
    "        action_value_function = np.zeros(4) # value function for all 4 possible actions\n",
    "        list_next_state = [] # store next state for each action\n",
    "        for action in range(4):\n",
    "            next_state, hit_the_wall = self._transition_model(current_state, action)\n",
    "            action_value_function[action] = discount_factor * self.value_function[next_state[0]][next_state[1]]\n",
    "            list_next_state.append(next_state)\n",
    "            if(hit_the_wall):\n",
    "                action_value_function[action] = action_value_function[action] - 2 * abs(current_reward) # negative reward\n",
    "            else:\n",
    "                action_value_function[action] = action_value_function[action] + current_reward\n",
    "        best_action = np.argmax(action_value_function)\n",
    "        max_action_value_function = action_value_function[best_action]\n",
    "        next_state = list_next_state[best_action]\n",
    "        \n",
    "        return best_action, max_action_value_function, next_state\n",
    "    \n",
    "    def value_iteration(self, num_iterations = 5, discount_factor = 0.9):\n",
    "        # Initialize value function\n",
    "        self._initialize_value_function()\n",
    "        for itr in range(num_iterations):\n",
    "            x_route = []\n",
    "            y_route = []\n",
    "            k = 0\n",
    "            k_max = self.X * self.Y\n",
    "            previous_state_index = self.origin # initializing as origin\n",
    "            x_cur, y_cur = np.unravel_index(self.origin, shape = self.map_shape) # get current (x,y) from origin index\n",
    "            soc_cur = self.start_soc\n",
    "            time_cur = self.start_time\n",
    "            current_state = (x_cur, y_cur, time_cur, soc_cur)\n",
    "            while(previous_state_index != self.destination):\n",
    "                # can record policy here by storing the route\n",
    "                x_route.append(x_cur)\n",
    "                y_route.append(y_cur)\n",
    "\n",
    "                # Find the best action for the current state\n",
    "                best_action, max_action_value_function, next_state = self._find_best_action(current_state=current_state, \n",
    "                                                                                            discount_factor=discount_factor)\n",
    "                self.value_function[x_cur][y_cur] = max_action_value_function\n",
    "                current_state = next_state # updating the current state as next state reached after taking the best action\n",
    "                \n",
    "                previous_state_index = np.ravel_multi_index((x_cur, y_cur), self.map_shape) # updating the previous state index\n",
    "                x_cur, y_cur, time_cur, soc_cur = current_state # updating the current state variables\n",
    "                \n",
    "                # Check if the number of steps is less than k_max\n",
    "                k = k + 1 # step increment\n",
    "                if(k == k_max):\n",
    "                    print(\"Maximum steps reached!!\")\n",
    "                    break\n",
    "\n",
    "        return x_route, y_route\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "Xw5acQUpPKlT"
   },
   "outputs": [],
   "source": [
    "# Testing the environment\n",
    "m = EVRoutePlanning_ValueIteration(X=25, Y=25, grid_length=10, num_chargers=15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 441
    },
    "id": "WBUBM5vXhPqK",
    "outputId": "dddd3185-dd61-43c7-838f-9a3f938ad562"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the map with the location of all charging stations\n",
    "fig, ax = plt.subplots(figsize=(6, 6))\n",
    "\n",
    "ax.imshow(m.map, cmap = 'binary')\n",
    "ax.invert_yaxis()\n",
    "ax.set_title('Location of Charging Stations', fontsize = 15)\n",
    "ax.set_xlabel('X', fontsize = 13)\n",
    "ax.set_ylabel('Y', fontsize = 13)\n",
    "fig.tight_layout()\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "ERKEwRduNVZ_"
   },
   "outputs": [],
   "source": [
    "# Generate the wait time distribution with hour for each charging station\n",
    "m.generate_wait_time_distribution_per_charger(prob_peak_hour=[1/24] * 24 , list_sd_hours=[3,4], list_peak_wait_time=[20,25,30], prob_peak_wait_time=[0.3,0.4,0.3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "X07Ddmn7NVit"
   },
   "outputs": [],
   "source": [
    "# Sample an origin-destination pair\n",
    "o, d = np.random.choice(np.arange(m.X * m.Y), 2)\n",
    "date = datetime.fromisoformat(\"2020-03-01-09\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "C1Jbs5LkuO_c"
   },
   "outputs": [],
   "source": [
    "m.create_journey(origin=o, destination=d, start_time=date, start_soc=0.8, desired_soc=0.5, vehicle_range=180)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "hjJBW1IOuPGM"
   },
   "outputs": [],
   "source": [
    "# Initialize the position rewards based on origin-destination\n",
    "m.initialize_position_rewards(0.1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 385
    },
    "id": "J3oSj0f0VCLI",
    "outputId": "ed1dea86-09e5-4066-d5b0-f8357efdd25d"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the position rewards for each location\n",
    "# Test out various hyperparameter choices and how they influence the position rewards\n",
    "fig, ax1 = plt.subplots(figsize=(6, 6))\n",
    "\n",
    "pos = ax1.imshow(m.position_reward.T)\n",
    "ax1.invert_yaxis()\n",
    "ax1.set_title('Position Rewards for each Location', fontsize = 15)\n",
    "ax1.set_xlabel('X', fontsize = 13)\n",
    "ax1.set_ylabel('Y', fontsize = 13)\n",
    "fig.tight_layout()\n",
    "fig.colorbar(pos, ax=ax1, shrink=0.9)\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "4RGU0O5gy2o1",
    "outputId": "eed09f22-7511-4971-f10f-ac60393d4ead"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum steps reached!!\n"
     ]
    }
   ],
   "source": [
    "# Get the optimal policy/route using value iteration approach\n",
    "policy = m.value_iteration(num_iterations=1, discount_factor=0.9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 441
    },
    "id": "yB_i2wN3y2zb",
    "outputId": "490e63ef-5d6e-4173-bbe0-feafed68531d"
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAGoCAYAAAATsnHAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAAsTAAALEwEAmpwYAAAsbklEQVR4nO3de3xU9Z3/8fdHiCIJoFaNiIYgWFuCECV43xpqW61YqP68lEsFu0K9Va0uVWu3CtTqrpeupZcVb9QWUKBroYVabRUv1SLBZQvEoq1FLgIi1iAiMeDn98c5SUPIdZKZ8x3m9Xw85jGZM2fO+eRkyJvvmZPvx9xdAACEZp+kCwAAoDEEFAAgSAQUACBIBBQAIEgEFAAgSAQUACBIBBTSziLjzGyxmW0zs61m9qyZDU9xe4ea2a1mVtxgebmZuZkN6JDCW66jON7fOS2s5/VuH5rZcjO7wsxa/e8vPn5uZgVt2XeqzOxbZvZy/PX0evV/bGbrzGxWw+Pfgfv+ZPzzPSAd20f2IKCQCT+R9ICkxZLOlXSRpNWS5pnZDSls71BJt0gqbrD8FUknS/pbqoWm0d2Kahsm6RlJP5Z0RTu2tyHe3gvtL61RwyT9pt7jv8T7O03SdyWVS1poZvumYd+fVPTzPSAN20YW6Zx0Adi7mdmXJV0m6XJ3/+96T/3WzDZK+r6ZPeXur7R3X+6+VdKf2rudNFnt7rW1PW1m/SVdLulHqWzM3auVpu81HrmcIum6eos/qFf/i2a2XdIsSWWSXkxHHQAjKKTbNZL+Kun+Rp77vqT3JV1Vu8DMFpnZXDObYGar41NiC8ysV/x8saTl8erP1J56ip/b4xRf/PibZna3mW0xs3fM7N/i58aa2Rtm9p6ZPWRmXeq9rme87I24htfM7HsdOGJYqnojQDO7MD71V21ma83sNjNr8j+QTZ3iM7Px8XZ2mNmm+Fj2MLOz49NzfRqs3ydePqLe4jMlvaNoRNqU/4vvj6y3ra5m9kMz2xjvf4mZfaHB/lab2V0NltWdvjSzckm/jp/6e7x8db11i8zsUTN718y2m9nvzOyYZupEFiOgkDbxL9iTJf3a3Xc1fN7dqxSd7vpMg6dOlvQNRf+D/1dJAyX9Kn5ug6TR8ddXxuue3EIp10sqkDRS0kxJd5rZf0oaJ+lqSd+Ot3ltvdccLOnduIazJN0p6RJJU1vYV2sVS9ooSfEv8ccUBcKIeB//pjaOrszsO5Luk/SspC8rGqFVKfrefyfpLUljG7xsnKS3JS2ot2yYpIXe/DxoRfH93+stu1/RMbpN0anctZIWmNlpbfg2XlH0vUvSeYp+tudKkpkdpOiU5jGKRuUXSsqX9Hsz278N+0C2cHdu3NJyk3SYJJd0TTPr/JekD+s9XiSpRlJRvWWnxts5K348IH5c3mBb5fHyAfWWuaRn6j3eR1HI/UNS93rLZ0ta3EydnSWNkrRD0r7xsuJ4++e0cBxcURB2ltRN0sWSdkq6K37+T/VrjJd9S9IuSUfEj8fF2ylobN+KPq/ZLumeZur4nqJAsfixKfos8K4Gx2ezpPPqLZsuqSKuP0/Rfxj+V9Jv663zaUkfSxrbYFsrJP2u3rLd9tfE93ZO/Li4wXpTJG2RdFC9ZQcqCuErk36/c+v4GyMohOgVd19T+8Dd/6jof/knpLi9P9Tb1seKfkkv9egzq1p/ldSr9oFFrjWzSjP7UFFozpC0n/45emiLe+NtbFX0C/8Xkm41s06Sjpc0p8H6jyn6Bd/S6LDWyZL2l/RwM+s8JKm3oiCXpKHx4/qvOUFSD0lPNXjt4Lj+jxSd3uuuaERaa4iiwKv7PuJjPUfRhRUd4XNxXVvNrHM8Qn9f0enSsg7aBwJCQCGd3pFUreiXYFN6S1rfYNnbjaz3tqSeKdbxXoPHHzWxrEu9x9dKukvS44pOu52g6JSiGqzXWncq+iU+QFK+u49z922KTiXmSdrUYP3axwe1cvufiO83NLWCu7+haIR6SbzoEkkvu/vKeqsNk/Scu7/f4OWvxvWfomh0V6TodGKtnpK2ufv2Bq/bJKmrme3Xyu+jOQcrugK0psFtqOp9Foa9B1fxIW3cfaeZvSRpmJn9W/w/6jpm1l3R/+Yfb/DSQxvZ3KFq5pdvGlwgaa6731y7IL7yLlVr3L2ikeXvKPol2/B7Lozv323l9rfE9z3jbTblAUn3m9lNij7jub7B88Mk/byR122vV/9L8QUlk83sHndfrOhnU2BmXRuEVGH82ur48Q5JDS80ObC5b6yedyXNV3Sqr6GGgYq9ACMopNu9iv6u5dJGnrtR0amihhcDHG9mdafRzOxURb/AX44XfRTfpzKSaa39FY3+6hvd2Irt4dHFI0sVBWJ9Fyr6TOelVm7qJUkfas+LIBr6H0XH71FF//4frX3CzA6XdJx2v2CiKXcrCsLav2Nbouhzo/Prbc/ix/X/Vmudos+r6vtCg8dN/Xz/IKlE0kp3r2hwW9WKmpFlGEEhrdz9V2b235J+HI9AfqPofXeRog/Hb/I9/wZqs6Krv25R9EvqPxR9LvVE/Pwaxb+MzaxKUk0To5P2eErS1Wa2WNEf/o6W1K+D91HrFkm/M7OHFQXGsYpGCfe7+7rWbMDd3zOzKZJuiy+FX6jo87Jhkia5+/p4vR1mNkPR6cpZ7v5evc2cLemv7v5aK/a33cx+IGmKmR3t7q+a2SxJPzKzboqO2XhJn1J0NWGtxyVNNbNvKwq1/6codOqrDZuvm9mjikZgyyXdI2mMor8jm6ro1HChpNMlveDus1pxqJBNkr5Kg9vef1P04fk4RTNJfKDodMyzkoY3su4iSXMVXUZcG0S/lXRkg/VGS3pN0f+2PV5Wrsav4ruqsX00WHarpHfqPS5QdPHAu/HtAf3z6rIB8TrFav1VfFe1sM5Fiv6+6yNFo4zbJHWu9/w4NXMVX731vi6pUtHob6OiqxO7N1jnc/FrP9dg+eOS/quR2qZLqmhkeXdFV0PeFz/uqugS+U3x/iskndngNXmKgmZj/Np7JU2o/73F610v6U1FVzuurrf88PjnUruP1YouOClJ+n3OreNvtZebAkEws0WKguL8ltZFauK/AbtQ0lEefy4Yj7q2KLq8vOEVfEAiOMUH5Ih4xoXaKZYmeb2LVtz9I0V/owUEg4ACcsd9kk5UdCXcDxOuBWgRp/gAAEHiMnMAQJCy7hTfwQcf7MXFxUmXAQBI0dKlS99x90NaWi/rAqq4uFgVFR39Jy8AgEwxszdbsx6n+AAAQSKgAABBIqAAAEEioAAAQSKgAABBIqAAAEEioAAAQSKgAABBIqAAAEEioAAAQSKgAABBIqAAAEEioAAArVJVVaWSkhJVVVVlZH8EFACgVRYsWKDKykotXLgwI/sjoAAAzRo1apQKCgo0duxYSdLFF1+sgoICjRo1Kq37JaAAAM2aPHmyioqKlJeXJ0nKy8tT7969NWXKlLTul4ACADSrX79+mjx5smpqapSfn6+amhpNmjRJffv2Tet+CSgAQItmz56t/Px8TZo0Sfn5+ZozZ07a92nunvaddKSysjKn5TsAZNaSJUtUVFSkwsJCbdq0SWvXrlVZWVlK2zKzpe7e4os7p7R1AEBOGTJkSN3XhYWFKiwsTPs+OcUHAAgSAQUACBIBBQAIEgEFAAgSAQUACBIBBQAIEgEFAAhSzgVUpqeLBwCkJucCKtPTxQMAUpMzUx2NGjVK8+fPV3V1tXbu3KnOnTtrv/320/DhwzVz5sw0VAoA6TVz8RrNW7Y+o/scUdpLo04satc2WjvVUc6MoJKaLh4A0mXesvWq3LA1Y/ur3LA1o4GYM3Px1U4XP3LkSOXn56u6ujoj08UDQDr179ldj3395Izs66L7XsrIfmrlzAhKSma6eABAanJmBCVJEydO1NSpU1VYWKgxY8Zo7dq1SZcEAGhCTgVUEtPFAwBSk1On+AAA2YOAAgAEiYACAASJgAIABImAAgAEiYACAASJgAIABImAAgAEKSMBZWZHmtkzZlZpZivN7Jp4+UFm9pSZvR7fH5iJegBkF/q45aZMjaB2Srre3ftLOknSlWbWX9KNkv7g7kdL+kP8GAB2Qx+33JRIPygzmyfpR/Gt3N03mFlPSYvc/ZjmXptqPygA2SdX+ril2tdp8d/flSSd2Oegji6p2f2tvmNYu7YTbD8oMyuWdJykxZIK3X1D/NRGSY1OjmdmE8yswswqNm/enJlCASQuV/q4ZbqvU7bI6GSxZlYg6ZeSrnX3rWZW95y7u5k1Opxz92mSpknRCCoTtQJIXi71cUulr1Ntf6ZM9YMqvnFBRvZTK2MjKDPLUxROM9z9f+LFm+JTe4rv385UPQCyA33ccldGRlAWDZUelPSqu99T76n5ksZKuiO+n5eJegBkD/q45a5MneI7VdJXJS03s2Xxsm8rCqbZZvavkt6UdGGG6gGQJejjlrsyElDu/oIka+LpMzJRAwAguzCTBAAgSAQUACBIBBQAIEgEFAAgSAQUACBIBBQAIEgEFBAQ2kp0LI5ndiOggIDQVqJjcTyzWyLtNtqDdhvYG+VKW4lMybbjedF9L6lyw1b179m9Ta+j3QaAtMuVthKZkm3Hc0RprzaHUy5gBAUEYu7cuRo5cqT2228/VVdXa9asWTr//POTLitr5cLxzHS7jY7aHyMoIMvQVqJjcTyzX0YbFgJoGm0lOhbHM/sRUEAgaCvRsTie2Y9TfACAIBFQAIAgEVAAgCARUACAIBFQAIAgEVAAgCARUACAIBFQAIAgEVAAgCARUACAIDHVEQB0kDEPLJYk/eLSEzOyv9r+TLWzjKdbKj2r2oOAAoAO8sJf30m6hLTq37O7RpT2ytj+CCgAyHKZ6geVaXwGBQAIEgEFAAgSAQUACBIBBQAIEgEFAAgSAQUACBIBBQAIEgEFAAgSAQUACBIBBQAIEgEFALlkxgypuFjaZ5/ofsaMpCtqEnPxAUCumDFDmjBB2r49evzmm9FjSRo9Orm6mmDunnQNbVJWVuYVFRVJlwFgLzZz8RrNW7a+za+rbX9xYp+DOrqkjtnf4j9JO6olSf3ffkO3/OH+aHnv3tLq1WmosHFmttTdy1paj1N8ANDAvGXrVblha9JldLw4nPawZk1m62glTvEBQCP69+ze5jYWxTcukJS59hdt3t/tI6PTeg0VFXVgVR2HERQA5IrbbpO6dt19Wdeu0fIAEVAAkCtGj5amTYs+czKL7qdNC/ICCYlTfACQW0aPDjaQGmIEBQAIEgEFAAgSAQUACBIBBQAIEgEFAAgSAQUACBIBBQAIEgEFAAgSAQUACBIBBQAIElMdAUADtX2WamcLRzIIKADoQMf26pGxfZ3W7+CM7SsJBBQANFDboTZTfZ1S9YtLT0y6hLTiMygAQJAIKABAkAgoAECQCCgAQJAIKABAkAgoAECQCCgAQJAIKABAkAgoAECQCCgAQJAyElBm9pCZvW1mK+otu9XM1pvZsvh2diZqAQBkh0yNoKZLOquR5T9w99L4tjBDtQAAskBGJot19+fMrDgT+wKAWjMXr9G8Zevb/LrKDVvVv2f3NFSEtkj6M6irzOzP8SnAA5taycwmmFmFmVVs3rw5k/UByGLzlq1X5YatbX5d/57dNaK0VxoqQlsk2W7jp5KmSPL4/m5JX2tsRXefJmmaJJWVlXmmCgSQ/fr37B582ww0LrERlLtvcvdd7v6xpPslnZBULQCA8CQWUGbWs97DcyWtaGpdAEDuycgpPjObJalc0sFmtk7SLZLKzaxU0Sm+1ZK+nolaAADZIVNX8Y1sZPGDmdg3ACA7JX0VHwAAjSKgAABBIqAAAEEioAAAQSKgAABBIqAAAEEioAAAQSKgAABBIqAAAEFKcjZzAGgV+jrlJkZQAIJHX6fcxAgKQFagr1PuYQQFAAgSAQUACBIBBQAIEgEFAAgSAQUACBIBBQAIEgEFAAgSAQUACBIBBQAIEgEFAAgSAQWgzaqqqlRSUqKqqqqkS8FejIAC0GYLFixQZWWlFi5cmHQp2IsxWSyAVhs1apTmz5+v6upqSdLFF1+s8ePHa/jw4Zo5c2aLr6dtBtqCERSAVps8ebKKioqUl5cnScrLy1Pv3r01ZcqUVr2ethloC0ZQAFqtX79+mjx5skaOHKn8/HxVV1dr0qRJ6tu3b6u3QdsMtBYjKABtMnv2bOXn52vSpEnKz8/XnDlzki4JeylGUADaZOLEiZo6daoKCws1ZswYrV27NumSsJcioAC0yZAhQ+q+LiwsVGFhYYLVYG/GKT4AQJAIKABAkAgoAECQCCgAQJAIKABAkAgoAECQCCgAQJAIKABAkAgoAMgx2dLPi4ACgByTLf28mOoIQJvR1yk7tbefV6YxggLQZvR1yk7t7eeVaYygAKSEvk7ZpyP6eWUSIygAyCHZ1M+LERQA5JBs6udFQAFADsmmfl7NnuIzs5+a2X6ZKgYAgFotfQZVIul/zaw0A7UAAFCnpYA6XdIjkp43s4kZqAcAAEktfAbl7i7pDjN7QtLPzexcSSsarDMhjfUBAHJUay+S2CnJ4/Xz0lcOAACRFgPKzK6XdIuk/5B0u7t/nPaqAAA5r9mAMrOnJR0h6XPu/nJmSgIAoOWLJN6QdBzhtPfLlun3EYZdu3ZqyZIlvF+QVs0GlLtf6u4fZKoYJCdbpt9HGLZseVfbt2/n/YK0Yi6+HDdq1CgVFBRo7NixkqLp9wsKCjRq1KiEK0OIat8vf/nLXyTxfkF6EVA5Ltum30eyat8vZiaJ9wvSi4DKcbXT79fU1Cg/P181NTVBT7+PZNW+X9xdnTrtw/sFaUVAIaum30fyZs+erU6d9lFxcR/eL0griyaLyB5lZWVeUVGRdBl7lSVLlqioqEiFhYXatGmT1q5dq7KysqTLQqCWLFmi2xdvV17evvrhl4/i/YI2M7Ol7t7im4Z2G8iq6feRvCFDhijvlZck8X5BenGKDwAQJAIKABAkAgoAECQCCgAQJAIKABAkAgoAECQCCgAQJAIKABCkjASUmT1kZm+b2Yp6yw4ys6fM7PX4/sBM1AIASE2m+8ZlagQ1XdJZDZbdKOkP7n60pD/EjwEAgcp037iMTHXk7s+ZWXGDxSMklcdf/0zSIkk3ZKIeAJGZi9do3rL1bX5d5Yat6t+zexoqQohGjRql+fPnq7q6WlLUB2z8+PEaPny4Zs6cmbb9JvkZVKG7b4i/3iipyQm9zGyCmVWYWcXmzZszUx2QA+YtW6/KDVvb/Lr+PbtrRGmvNFSEECXVNy6IyWLd3c2syWnV3X2apGlSNJt5xgoDckD/nt312NdPTroMBKy2D9jIkSOVn5+v6urqjPQBS3IEtcnMekpSfP92grUAAJqRRN+4JEdQ8yWNlXRHfD8vwVoAAM2YOHGipk6dqsLCQo0ZM0Zr165N+z4zElBmNkvRBREHm9k6SbcoCqbZZvavkt6UdGEmagEAtF0SfeMydRXfyCaeOiMT+wcAZB9mkgAABImAAgAEiYACAASJgAIABImAAgAEiYACAASJgAKAHJPpthmpIqAAIMdkum1GqoKYLBZA+9A2A62RVNuMVDGCAvYCtM1AayTVNiNVjKCAvQRtM9CSpNpmpIoRFADkkCTaZqSKERQA5JAk2makioACgBySRNuMVHGKDwAQJAIKABAkAgoAECQCCgAQJAIKABAkAgoAECQCCgAQJAIKABAkAgoAECQCCgAQJKY6AtIg1f5MqaKvE/ZGjKCANEi1P1Oq6OuEvREjKCBN6M8EtA8jKABAkAgoAECQCCgAQJAIKABAkAgoAECQCCgAQJAIKABAkAgoAECQCCgAQJAIKABAkAgoAECQCCgAQJCYLBY5gfYXQPZhBIWcQPsLIPswgkLOoP0FkF0YQQEAgkRAAQCCREABAIJEQAEAgkRAAQCCREABAIJEQAEAgkRAAQCCREABAIJEQAEAgkRAAQCCREClWVVVlUpKSlRVVZV0KQCQVQioNFuwYIEqKyu1cOHCpEsBgKzCbOZpMmrUKM2fP1/V1dWSpIsvvljjx4/X8OHDNXPmzISrSx79mQC0hBFUmkyePFlFRUXKy8uTJOXl5al3796aMmVKwpWFgf5MAFrCCCpN+vXrp8mTJ2vkyJHKz89XdXW1Jk2apL59+yZdWjDozwSgOYyg0mj27NnKz8/XpEmTlJ+frzlz5iRdEgBkDUZQaTRx4kRNnTpVhYWFGjNmjNauXZt0SQCQNQioNBoyZEjd14WFhSosLEywGgDILpziAwAEiYACAASJgAIABImAAgAEiYACAASJgAIABImAAgAEKfGAMrPVZrbczJaZWUXS9QAAbXLCkHhAxYa6e6m7lyVdCADQJicMzCSxl8l0G4tU0f4CIaJNTlhCGEG5pCfNbKmZTWhsBTObYGYVZlaxefPmDJeXXTLdxiJVtL9AiGiTE5YQRlCnuft6MztU0lNm9hd3f67+Cu4+TdI0SSorK/MkiswmtLEAUkObnLAkPoJy9/Xx/duSHpd0QrIVAchltMkJR6IjKDPLl7SPu78ff/0FSZOTrAlAbqNNTjiSPsVXKOlxM6utZaa7P5FsSQByGW1ywpFoQLn7G5IGJVkDACBMiX8GBQBAYwgoAECQCCgAQJAIKABAkAgoAECQCCgAQJAIKABAkAgoAECQCCgAQJCSnupor5fp/kz0WQKwt2AElWaZ7s9EnyUAewtGUBlAfyYAaDtGUACAIBFQAIAgEVAAgCARUACAIBFQAIAgEVAAgCARUACAIBFQAIAg8Ye6ABJVU1OjdevWaceOHUmXgg7WpUsXHXHEEcrLy0vp9QQUgEStW7dO3bp1U3Fxscws6XLQQdxdW7Zs0bp169SnT5+UtsEpPgCJ2rFjhz7xiU8QTnsZM9MnPvGJdo2MCSgAiSOc9k7t/bnm3Cm+4hsXtOv1J/Y5qE3r0/4CAFLDCCrNaH8BhG/dunUaMWKEjj76aPXt21fXXHONPvrooz3We+utt3T++ee3uL2zzz5b7733XhoqzS05N4KqHQHR/gLIUn+fIf3fzdL2NVLXImnQbVKf0Slvzt113nnn6fLLL9e8efO0a9cuTZgwQTfffLPuvPPOuvV27typww8/XHPnzm1xmwsXLky5HvxTzgUUgCz29xnSyxOkXdujx9vfjB5LKYfU008/rS5duuiSSy6RJHXq1Ek/+MEP1KdPH/Xp00dPPPGEtm3bpl27dulnP/uZzjnnHK1YsULbt2/XuHHjtGLFCh1zzDF666239OMf/1hlZWUqLi5WRUWFtm3bpi9+8Ys67bTT9OKLL6pXr16aN2+e9t9//444Gns9TvEByB7/d/M/w6nWru3R8hStXLlSgwcP3m1Z9+7dVVRUpJ07d+qVV17R3Llz9eyzz+62zk9+8hMdeOCBqqys1JQpU7R06dJGt//666/ryiuv1MqVK3XAAQfol7/8Zcq15hoCCkD22L6mbcs7wOc//3kddNCeF0e98MIL+spXviJJGjBggAYOHNjo6/v06aPS0lJJ0uDBg7V69ep0lbrXIaAAZI+uRW1b3gr9+/ffY/SzdetWrVmzRp07d1Z+fn7K25ak/fbbr+7rTp06aefOne3aXi4hoABkj0G3SZ267r6sU9doeYrOOOMMbd++XY888ogkadeuXbr++us1btw4de3atcnXnXrqqZo9e7YkqbKyUsuXL0+5BjSOgAKQPfqMlk6YJnXtLcmi+xOmtesqPjPT448/rjlz5ujoo4/WJz/5SXXp0kXf//73m33dFVdcoc2bN6t///76zne+o5KSEvXo0SPlOrAnc/eka2iTsrIyr6ioSPn1F933kiQuMwdC8eqrr+rTn/500mW02a5du1RTU6MuXbrob3/7mz73uc9p1apV2nfffZMuLSiN/XzNbKm7l7X0Wi4zB4AUbN++XUOHDlVNTY3cXT/5yU8Ipw5GQAFACrp166b2nM1By/gMCgAQJAIKABCk3Aqov8+Q3vmT9Paz0q+Ko8cAMqaqqkolJSWqqqpKuhRkgdwJqNo5vD6ujh7XzuFFSAEZs2DBAlVWVjKZKloldwIqDXN4AWidUaNGqaCgQGPHjpUkXXzxxSooKNCoUaMSrizSqVMnlZaWqqSkRIMGDdLdd9+tjz/+OKVtNfz7qVNOOSXluqZPn6633nqr7vGll16qysrKlLeXbXInoOK5uvrv/4b67//GHssBpM/kyZNVVFSkvLw8SVJeXp569+6tKVOmtH1jM2ZIxcXSPvtE9zPafxZk//3317Jly7Ry5Uo99dRT+u1vf6tJkyaltK2GAfXiiy+mXFfDgHrggQfUv3//lLeXbXInoOK5um45/H7dcvj9eywHkD79+vXT5MmTVVNTo/z8fNXU1GjSpEnq27dv2zY0Y4Y0YYL05puSe3Q/YUKHhFStQw89VNOmTdOPfvQjubt27dqliRMnasiQIRo4cKDuu+8+SdKGDRv0mc98RqWlpRowYICef/553Xjjjfrwww9VWlqq0aOj2S0KCgokSYsWLVJ5ebnOP/98fepTn9Lo0aNVO1HC5MmTNWTIEA0YMEATJkyQu2vu3LmqqKjQ6NGjVVpaqg8//FDl5eV1l7bPmjVLxx57rAYMGKAbbrihrv6CggLdfPPNGjRokE466SRt2rSpw45Nxrl7Vt0GDx7sKXnjF+6PdnWfoX/eHu0aLQeQdhdccIH36NHD77rrLu/Ro4dfeOGF7u5eWVnZ+o307u0eRdPut96921Vbfn7+Hst69OjhGzdu9Pvuu8+nTJni7u47duzwwYMH+xtvvOF33XWXf+9733N39507d/rWrVsb3Vbt42eeeca7d+/ua9eu9V27dvlJJ53kzz//vLu7b9mypW79MWPG+Pz5893d/fTTT/clS5bUPVf7eP369X7kkUf622+/7TU1NT506FB//PHH3d1dUt3rJ06cWFd7Uhr7+Uqq8Fb8vs+dEVQa5vAC0HoTJ07UqlWrdP3112vVqlWaOHFi2zeypolT8k0t7wBPPvmkHnnkEZWWlurEE0/Uli1b9Prrr2vIkCF6+OGHdeutt2r58uXq1q1bi9s64YQTdMQRR2ifffZRaWlpXeuNZ555RieeeKKOPfZYPf3001q5cmWz21myZInKy8t1yCGHqHPnzho9erSee+45SdK+++6rc845R1L2t/fIrZkk+owmkICEDBkypO7rwsJCFRYWtn0jRUXRab3GlnegN954Q506ddKhhx4qd9fUqVN15pln7rHec889pwULFmjcuHG67rrrdPHFFze73cZab+zYsUNXXHGFKioqdOSRR+rWW2/Vjh07Uq49Ly9PZrbbPrJV7oygAGS/226TGrbA6No1Wt5BNm/erMsuu0xXXXWVzExnnnmmfvrTn6qmpkaS9Nprr+mDDz7Qm2++qcLCQo0fP16XXnqpXnnlFUlRQNSu2xq1YXTwwQdr27Ztmjt3bt1z3bp10/vvv7/Ha0444QQ9++yzeuedd7Rr1y7NmjVLp59+enu+7SDl1ggKQHaLLzzQzTdHp/WKiqJwGt2+MyO1FzbU1NSoc+fO+upXv6rrrrtOUnRp9+rVq3X88cfL3XXIIYfoV7/6lRYtWqQ777xTeXl5KigoqOsnNWHCBA0cOFDHH3+8ZrTi4o0DDjhA48eP14ABA3TYYYftNtIcN26cLrvsMu2///566aWX6pb37NlTd9xxh4YOHSp317BhwzRixIh2HYMQ5Vy7DQBhydZ2G2id9rTb4BQfACBIBBQAIEgEFAAgSAQUACBIBBQAIEgEVJrR/wYAUkNApRn9b4Dwbdy4UV/5ylfUt29fDR48WGeffbZee+01LVq0qG7aoI5WUVGhq6++ukO2tWrVKpWXl6u0tFSf/vSnNWHCBEnSsmXLWvW7p+F68+fP1x133NEhtbUHAZUmofe/AbJZR56ZcHede+65Ki8v19/+9jctXbpUt99+e4fMAt7cNENlZWX64Q9/2O59SNLVV1+tb37zm1q2bJleffVVfeMb35CUekANHz5cN954Y4fU1h4EVJp0aP8bALvpyDMTzzzzjPLy8nTZZZfVLRs0aJD+5V/+RZK0bdu2VrfIkKTy8nJde+21Kisr07333qslS5Zo4MCBKi0t1cSJEzVgwABJ2m10duutt+prX/uaysvLddRRR+0WXFOmTNExxxyj0047TSNHjtRdd921x/ewYcMGHXHEEXWPjz32WH300Uf67ne/q8cee0ylpaV67LHH9PLLL+vkk0/Wcccdp1NOOUWrVq1qdL3p06frqquukiStXr1an/3sZzVw4ECdccYZWhNPzDtu3DhdffXVOuWUU3TUUUftNkVTh2nNlOch3VJut5GAOXPmeOfOnT0/P987d+7sc+bMSbokIDhtabcxcuTIun9Pkur+fY0cOTLl/d97771+7bXXNvpcqi0yLr/88rrnSkpK/MUXX3R39xtuuMFLSkrqtj1s2DB3d7/lllv85JNP9h07dvjmzZv9oIMO8o8++shffvllHzRokH/44Ye+detW79evn99555171PnQQw959+7d/ayzzvJ77rnH//GPf7i7+8MPP+xXXnll3XpVVVVeU1Pj7u5PPfWUn3feeY2uV//xOeec49OnT3d39wcffNBHjBjh7u5jx471888/33ft2uUrV670vn37NnoMabcRqNmzZys/P1+TJk1Sfn6+5syZk3RJQFZL4sxEKi0yLrroIknSe++9p/fff18nn3yyJDV7in/YsGHab7/9dPDBB+vQQw/Vpk2b9Mc//lEjRoxQly5d1K1bN33pS19q9LWXXHKJXn31VV1wwQVatGiRTjrpJFVXV++xXlVVlS644AINGDBA3/zmN1ts6yFJL730Ul3dX/3qV/XCCy/UPfflL39Z++yzj/r375+WxogEVBp1SP8bAHU6rDNvPSUlJVq6dGmTzzfXImPu3Llavny5xo8fv1uLjPz8/DbX0dh+2uLwww/X1772Nc2bN0+dO3fWihUr9ljn3//93zV06FCtWLFCv/71r9vV1qNhzZ6GeV0JqDQaMmRIXc+bwsJClZW1ODcigBZ09JmJz372s6qurta0adPqlv35z3/W888/3+RrmmuRUd8BBxygbt26afHixZKkRx99tE21nXrqqXVBsm3bNv3mN79pdL0nnniirsXHxo0btWXLFvXq1WuPdh1VVVXq1auXJGn69Ol1y5tq6yFJp5xySl3dM2bMqPtsLhMIKABZpaPPTJiZHn/8cf3+979X3759VVJSoptuukmHHXZYk6+p3yLjzDPP3K1FRkMPPvigxo8fr9LSUn3wwQfq0aNHq2sbMmSIhg8froEDB+qLX/yijj322EZf/+STT2rAgAEaNGiQzjzzTN1555067LDDNHToUFVWVtZd/PCtb31LN910k4477rjdRmgN16tv6tSpevjhhzVw4ED9/Oc/17333tvq+tuLdhsAErW3t9vYtm2bCgoKJEl33HGHNmzY0KZf8rWv3759uz7zmc9o2rRpOv7449NVbodrT7sNGhYCQBotWLBAt99+u3bu3KnevXvvdmqtNSZMmKDKykrt2LFDY8eOzapwai8CCgDS6KKLLqq7qi8VM2fO7MBqsgufQQFIXLZ91IDWae/PlYACkKguXbpoy5YthNRext21ZcsWdenSJeVtcIoPQKKOOOIIrVu3Tps3b066FHSwLl267DYFU1slHlBmdpakeyV1kvSAuyc/hS6AjMnLy1OfPn2SLgMBSvQUn5l1kvRjSV+U1F/SSDPrn2RNAIAwJP0Z1AmS/urub7j7R5IelTQi4ZoAAAFIOqB6SVpb7/G6eNluzGyCmVWYWQXnqQEgNyT+GVRruPs0SdMkycw2m9mb7dzkwZLeaXdhex+OS+M4Lo3juDSO49K4+seld2tekHRArZd0ZL3HR8TLmuTuh7R3p2ZW0ZppNnINx6VxHJfGcVwax3FpXCrHJelTfEskHW1mfcxsX0lfkTQ/4ZoAAAFIdATl7jvN7CpJv1N0mflD7t5yBy0AwF4v6VN8cveFkhZmeLfTWl4lJ3FcGsdxaRzHpXEcl8a1+bhkXbsNAEBuSPozKAAAGkVAAQCClFMBZWZnmdkqM/urmd2YdD2hMLPVZrbczJaZWU63Kzazh8zsbTNbUW/ZQWb2lJm9Ht8fmGSNSWjiuNxqZuvj980yMzs7yRozzcyONLNnzKzSzFaa2TXx8px+vzRzXNr8fsmZz6Dief9ek/R5RTNWLJE00t0rEy0sAGa2WlKZu+f8Hxea2WckbZP0iLsPiJf9p6R33f2O+D82B7r7DUnWmWlNHJdbJW1z97uSrC0pZtZTUk93f8XMuklaKunLksYph98vzRyXC9XG90sujaCY9w8tcvfnJL3bYPEIST+Lv/6Zon9sOaWJ45LT3H2Du78Sf/2+pFcVTdWW0++XZo5Lm+VSQLVq3r8c5ZKeNLOlZjYh6WICVOjuG+KvN0oqTLKYwFxlZn+OTwHm1Kms+sysWNJxkhaL90udBsdFauP7JZcCCk07zd2PV9T25Mr4dA4a4dE58dw4L96yn0rqK6lU0gZJdydaTULMrEDSLyVd6+5b6z+Xy++XRo5Lm98vuRRQbZ73L1e4+/r4/m1Jjys6HYp/2hSfV689v/52wvUEwd03ufsud/9Y0v3KwfeNmeUp+iU8w93/J16c8++Xxo5LKu+XXAoo5v1rhJnlxx9kyszyJX1B0ormX5Vz5ksaG389VtK8BGsJRu0v4di5yrH3jZmZpAclveru99R7KqffL00dl1TeLzlzFZ8kxZc1/pf+Oe/fbclWlDwzO0rRqEmKpr6amcvHxcxmSSpX1Bpgk6RbJP1K0mxJRZLelHShu+fUBQNNHJdyRadrXNJqSV+v99nLXs/MTpP0vKTlkj6OF39b0ectOft+aea4jFQb3y85FVAAgOyRS6f4AABZhIACAASJgAIABImAAgAEiYACAASJgAIABImAAhJmZvvG7QfubrD8GjN708wOSKg0IFH8HRQQADMrkfSypC+5+9NmdqykP0k6292fTbY6IBkEFBCIuLHb9YrmKHtS0m9zqY8Q0BABBQQinsPsCUXtCdZJOinuXQbkJD6DAgIRt2ZYJOkQST8nnJDrGEEBgaj3udNUSZdJGujua5KtCkgOAQUEwMz2U9QS5tfufrOZPSypWNIZcf8cIOdwig8Iw+2SPpJ0a/z4akUBdV1C9QCJYwQFJMzMzlDU1G6wu6+qt/w0Sb9TdLHE8qTqA5JCQAEAgsQpPgBAkAgoAECQCCgAQJAIKABAkAgoAECQCCgAQJAIKABAkAgoAECQ/j+qAvm7IDsdfgAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the route\n",
    "fig, ax1 = plt.subplots(figsize=(6, 6))\n",
    "\n",
    "# Plot the route using actions\n",
    "ax1.plot(policy[0], policy[1])\n",
    "\n",
    "# Plot the origin\n",
    "o_x, o_y = np.unravel_index(o, m.map_shape)\n",
    "ax1.scatter(o_x, o_y, color = 'orange', label = 'Origin')\n",
    "\n",
    "# Plot the destination\n",
    "d_x, d_y = np.unravel_index(d, m.map_shape)\n",
    "ax1.scatter(d_x, d_y, color = 'red', label = 'Destination')\n",
    "\n",
    "# Plot the charging stations\n",
    "c_x, c_y = np.unravel_index(m.charging_stations, m.map_shape)\n",
    "ax1.scatter(c_x, c_y, color = 'black', label = 'Charging Station', marker = '*')\n",
    "\n",
    "ax1.set_title('Optimal Policy/Route', fontsize = 15)\n",
    "ax1.set_xlabel('X', fontsize = 13)\n",
    "ax1.set_ylabel('Y', fontsize = 13)\n",
    "ax1.legend()\n",
    "fig.tight_layout()\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 385
    },
    "id": "T-ipTie5eZbR",
    "outputId": "890fc65f-1b89-4e0b-fece-a77e5a60bcfb"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the value function for each location\n",
    "# Test out various hyperparameter choices and how they influence the position rewards\n",
    "fig, ax1 = plt.subplots(figsize=(6, 6))\n",
    "\n",
    "pos = ax1.imshow(m.value_function.T)\n",
    "ax1.invert_yaxis()\n",
    "ax1.set_title('Value Function for each Location', fontsize = 15)\n",
    "ax1.set_xlabel('X', fontsize = 13)\n",
    "ax1.set_ylabel('Y', fontsize = 13)\n",
    "fig.tight_layout()\n",
    "fig.colorbar(pos, ax=ax1, shrink=0.9)\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 354
    },
    "id": "-cbb1rQ9zEA5",
    "outputId": "62715417-5ac9-4217-801c-012d4ea5a76b"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Sample plot for truncnorm distribution\n",
    "\n",
    "peak = 18 # enter any peak hour value from [0, 23] - if unaware, pls remember datatime stores hours from 0 to 23 :))\n",
    "rv = ss.truncnorm(-12/4, 11/4, peak, 4)\n",
    "prob = np.zeros(24)\n",
    "for i in range(-12, 12):\n",
    "    prob[(i + peak + 24) % 24] = rv.pdf(i + peak) / rv.pdf(peak) * 40\n",
    "\n",
    "fig, ax1 = plt.subplots(figsize=(6, 5))\n",
    "\n",
    "ax1.plot(np.arange(24), prob)\n",
    "ax1.set_title('Wait time Distribution (Peak wait time of 40 mins at 6 p.m.)', fontsize = 14)\n",
    "ax1.set_xlabel('Time of the day (in hours)', fontsize = 13)\n",
    "ax1.set_ylabel('Wait time (in minutes)', fontsize = 13)\n",
    "ax1.set_xlim([0,23])\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "AFczSDGazEGB"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "W-tKnrIrOR9m"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.0"
  },
  "vscode": {
   "interpreter": {
    "hash": "147e0fad0828e2829dfb9aab4e3f1be6d10c3c50df9361cc18f4e91b899401fc"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}