Problem Extension - RL-Based Optimization of Driveington.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ul5WL1cCpnfd",
   "metadata": {
    "id": "ul5WL1cCpnfd"
   },
   "source": [
    "# Problem Extension: Driveington"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e8ad4226",
   "metadata": {
    "id": "e8ad4226"
   },
   "outputs": [],
   "source": [
    "import math\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import time"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "J5eE1sYQp1ME",
   "metadata": {
    "id": "J5eE1sYQp1ME"
   },
   "source": [
    "# Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b73d2320",
   "metadata": {
    "id": "b73d2320"
   },
   "source": [
    "![image](https://i.imgur.com/faZJu3H.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "Au0SYrX1p5j8",
   "metadata": {
    "id": "Au0SYrX1p5j8"
   },
   "source": [
    "In this notebook, the focus is on how to extend the traffic optimization in hand, to a system which realtes better to a real city traffic management.\n",
    "\n",
    "I have designed the above traffic network, which belongs to an imaginary city called **Driveington**.\n",
    "\n",
    "- In this city, the drivers start driving from their origin to their destinations every morning. Each agent has their own origin and destinations pairs. These pairs generated randomly based on a sampling table created by assigning probabilities which indicates for a given city section, how likely it is to be a destination or an origin. *For example, the section \"LaneEnd\", thought as a suburban area, is much more likely to be an origin for a driver than a destination. In the other hand, the section \"JamHub\" is considered as the city center, which living costs are high but a popular destination.*\n",
    "- I have employed an object-oriented approach, which distinguishes the characteristics of each entity in a traffic network.\n",
    "- From a RL perspective, each vehicle (driver) is an agent, and the city itself is the environment. Each vehicle can be one of two types: a bus or a car. The difference is that a bus has twice as much influence on the congestion on a road than a car.\n",
    "- The training is very time consuming, therefore for now I have selected the population as 500. I also implemented stochastic behaviors on the roads, vehicles and the cities. But for the same time constraints, they are disabled for this implementation. If activated, a vehicle can change its destination randomly, a road can become much more congested permanently, and the city might not allow a driver to transfer to a new road on a given time step. These are implemented by keeping in mind the real-life scenerios."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "TXjEFobMsy7H",
   "metadata": {
    "id": "TXjEFobMsy7H"
   },
   "source": [
    "# Traffic Network of Driveington as a RL Problem"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6P1DEtGTs3sr",
   "metadata": {
    "id": "6P1DEtGTs3sr"
   },
   "source": [
    "### Environment\n",
    "The city itself acts as a RL enviornment. It takes next section ID as an action, an returns the corresponding state with a step reward. If the driver arrived in its destination, any action submitted by the agent is treated the same and the movement is not allowed.\n",
    "\n",
    "### State Space\n",
    "The states in each step are tuples in form `origin, destination, a dictionary of possible roads and the number of vehicles using it`. To make the training more efficient, the state space is made more discrete by applying a binning operation for the number of vehicles on each road. By using the number of vehicles instead of travel time for each road, it is aimed to develop an understanding for each agent about the characteristics of the different roads.\n",
    "\n",
    "### Actions\n",
    "Given the state, the agent has access to the list of next possible roads to take with their congestions. The selected action is the ID of the section that the selected route leads to. The IDs of each city section is their initials. The action selection policy is **deterministic**.\n",
    "\n",
    "In the beginning of the training, the epsilon is equal to 1 for every agent. This is useful for exploring the state space, which is very large in this problem. After the epsilon decays down to 0, the agents start to exploit their policies.\n",
    "\n",
    "### Agents\n",
    "Each vehicle is an agent. Therefore if the population is selected as 500, the system is a multi-agent system with 500 agents.\n",
    "\n",
    "Each agent is from one of the two types: bus or car. A bus has twice as much influence on the road congestion. The busses are around 5% of the population.\n",
    "\n",
    "Each agent is focused on reaching to their destinations with maximal cumulative reward. To do that, each of them need to pick routes that not only involve minimal number of turns, but also the time spent in each road should be minimal. Also considering that the agents take actions in an order, the decision of one agent affects other agent's decision. Considering all these, we can see that this is an example of a system with **competing agents**.\n",
    "\n",
    "### Rewards\n",
    "The rewards are calculated as following:\n",
    "\n",
    "- $ - t_x $ if the agent has not arrived, where x is the road agent picked and $t_x$ is the current travel time in the road x.\n",
    "- $ 0 $ if the agent has arrived to its destination, regardless of its action.\n",
    "\n",
    "### Stochastic Behaviors\n",
    "For this implementation, the stoachstic behaviors are disabled. If you wish to enable them, the entities have the following behaviors:\n",
    "\n",
    "- An agent might change it destination in the mid-trajectory.\n",
    "- A road can get more congested temporarily, similar to real-life events like accidents or netural disasters.\n",
    "- A city can reject the movement of an agent, the agent remains on the same road for that timestep.\n",
    "\n",
    "### Episode\n",
    "An episode is not constrained to a limited number of steps. An episode ends when all agents arrive to their destinations. Therefore it might take as little as 1 step, to thousands.\n",
    "\n",
    "### Learning\n",
    "Given above properties of this system, a Deep-Q-Learning approach might seem feasible. However, again, due to the time constraints and that I still observed improvements with this approach, I employed a Q-Learning technique. The Q-table is a look-up table that assigns each state-action pair an expected future reward."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "NG4DfcUn2fH6",
   "metadata": {
    "id": "NG4DfcUn2fH6"
   },
   "source": [
    "# Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0ea2fee4",
   "metadata": {
    "id": "0ea2fee4"
   },
   "outputs": [],
   "source": [
    "population = 500"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "8f0bc392",
   "metadata": {
    "id": "8f0bc392"
   },
   "outputs": [],
   "source": [
    "travel_time = lambda q_x, t0_x, Q_x: t0_x * (1 + pow(q_x/Q_x, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "iNMdIq7UtCHC",
   "metadata": {
    "id": "iNMdIq7UtCHC"
   },
   "outputs": [],
   "source": [
    "num_episodes = 20000\n",
    "decay_rate = 0.999 # Epsilon decay each episode"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4bZEPx1I2Xr7",
   "metadata": {
    "id": "4bZEPx1I2Xr7"
   },
   "source": [
    "# Classes: Sections, Roads, Vehicles and the City"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "2767ca8b",
   "metadata": {
    "id": "2767ca8b"
   },
   "outputs": [],
   "source": [
    "class Section:\n",
    "\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        self.id = name[0]\n",
    "        self.neighbors = list()\n",
    "\n",
    "\n",
    "    def make_connection(self, section):\n",
    "        self.neighbors.append(section)\n",
    "        self.neighbors.sort(key=lambda x: x.id)\n",
    "\n",
    "\n",
    "    def is_neighbor(self, section_id):\n",
    "        for n in self.neighbors:\n",
    "            if n.id == section_id:\n",
    "                return True\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c4237e52",
   "metadata": {
    "id": "c4237e52"
   },
   "outputs": [],
   "source": [
    "class Road:\n",
    "\n",
    "    def __init__(self, origin, destination, free_flow, capacity):\n",
    "        self.origin = origin\n",
    "        self.destination = destination\n",
    "        self.id = self.origin.id + self.destination.id\n",
    "\n",
    "        self.free_flow = free_flow\n",
    "        self.capacity = capacity\n",
    "        self.number_of_vehicles = 0\n",
    "        self.randomness = -1 #np.random.rand()/50.0 # Random behavior of road (temporary increase of congestion)\n",
    "\n",
    "\n",
    "    def reset(self):\n",
    "        self.number_of_vehicles = 0\n",
    "\n",
    "\n",
    "    def get_congestion(self):\n",
    "        return self.travel_time(self.number_of_vehicles, self.free_flow, self.capacity, self.randomness)\n",
    "\n",
    "\n",
    "    def travel_time(self, q_x, t0_x, Q_x, randomness):\n",
    "        incident = randomness > np.random.rand()\n",
    "        congestion = t0_x * (1 + pow(q_x/Q_x, 2)) * (5 if incident else 1)\n",
    "        return congestion\n",
    "\n",
    "\n",
    "    def add_car(self, influence):\n",
    "        self.number_of_vehicles += influence\n",
    "\n",
    "\n",
    "    def remove_car(self, influence):\n",
    "        self.number_of_vehicles -= influence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d369c8f2",
   "metadata": {
    "id": "d369c8f2"
   },
   "outputs": [],
   "source": [
    "class Vehicle: # RL Agent\n",
    "\n",
    "    def __init__(self, id, vehicle_type, origin, destination, alpha=0.3, gamma=0.8, epsilon=1.0):\n",
    "        self.id = id\n",
    "        self.vehicle_type = vehicle_type\n",
    "        self.influence = 1 if (self.vehicle_type == \"car\") else 2\n",
    "\n",
    "        self.origin = origin\n",
    "        self.original_dest = destination\n",
    "        self.destination = self.original_dest\n",
    "        self.prev_location = None\n",
    "        self.location = origin\n",
    "\n",
    "        self.arrived = False\n",
    "        self.randomness = -1 #np.random.rand()/20.0 # # Random behavior of drivers (destination change)\n",
    "\n",
    "        self.q_table = {}\n",
    "\n",
    "        self.alpha = alpha\n",
    "        self.epsilon = epsilon\n",
    "        self.gamma = gamma\n",
    "\n",
    "\n",
    "    def initialize_q_value(self, state, action): # 1\n",
    "        state_str = str(state)  # string as a key\n",
    "        if state_str not in self.q_table:\n",
    "            self.q_table[state_str] = {}\n",
    "        if action not in self.q_table[state_str]:\n",
    "            self.q_table[state_str][action] = 0.0 # -100.0 # Initialize Q-value to 0\n",
    "\n",
    "\n",
    "    def reset(self):\n",
    "        self.prev_location = None\n",
    "        self.location = self.origin\n",
    "        self.arrived = False\n",
    "        self.destination = self.original_dest\n",
    "\n",
    "\n",
    "    def pick_action(self, state):\n",
    "        loc_id, dest_id, congestions = state\n",
    "\n",
    "        possible_actions = list(congestions.keys())\n",
    "        for a in possible_actions:\n",
    "            self.initialize_q_value(state, a)\n",
    "\n",
    "        if np.random.rand() < self.epsilon:\n",
    "            return np.random.choice(possible_actions)\n",
    "        else:\n",
    "            best_value = float(\"-inf\")\n",
    "            best_action = None\n",
    "            for action in possible_actions:\n",
    "                value = self.q_table[str(state)][action]\n",
    "                if value > best_value:\n",
    "                    best_value = value\n",
    "                    best_action = action\n",
    "            return best_action\n",
    "\n",
    "\n",
    "    def learn(self, state, action, reward, next_state):\n",
    "        prev_loc, dest, prev_congestions = state\n",
    "        new_loc, _, new_congestions = next_state\n",
    "\n",
    "        next_possible_actions = list(new_congestions.keys())\n",
    "        for a in next_possible_actions:\n",
    "            self.initialize_q_value(next_state, a)\n",
    "\n",
    "        best_future_q = max(self.q_table[str(next_state)].values())\n",
    "        prev_q = self.q_table[str(state)][action]\n",
    "        new_q =  prev_q + (self.alpha * (reward + (self.gamma * best_future_q)))\n",
    "        self.q_table[str(state)][action] = new_q\n",
    "\n",
    "\n",
    "    def move_to_section(self, section):\n",
    "        #if section == self.location: return False\n",
    "\n",
    "        self.prev_location = self.location\n",
    "        self.location = section\n",
    "\n",
    "        if self.location == self.destination: self.arrived = True\n",
    "\n",
    "        if self.randomness > np.random.rand(): # Vehicle changed destination for some reason\n",
    "            self.destination = np.random.choice((self.origin, np.random.choice(self.destination.neighbors)))\n",
    "\n",
    "        return True\n",
    "\n",
    "\n",
    "    def decay_epsilon(self, decay_rate, min_epsilon=0):\n",
    "        self.epsilon = max(min_epsilon, self.epsilon * decay_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "1601f670",
   "metadata": {
    "id": "1601f670"
   },
   "outputs": [],
   "source": [
    "class City: # RL Environment\n",
    "\n",
    "    def __init__(self, sections, randomness, state_bin = 5):\n",
    "        self.sections = sections\n",
    "        self.roads = list()\n",
    "        self.randomness = -1 # 0.05 # Random behavior of environment\n",
    "        self.state_bin = state_bin\n",
    "\n",
    "\n",
    "    def reset(self):\n",
    "        for r in self.roads: r.reset()\n",
    "\n",
    "\n",
    "    def build_roads(self, roads):\n",
    "        for road in roads:\n",
    "            section1_id, section2_id, free_flow, capacity = road\n",
    "            section1, section2 = self.get_section_from_id(section1_id), self.get_section_from_id(section2_id)\n",
    "            if all((section1, section2)):\n",
    "                section1.make_connection(section2)\n",
    "                section2.make_connection(section1)\n",
    "                self.roads.append(Road(section1, section2, free_flow, capacity))\n",
    "                self.roads.append(Road(section2, section1, free_flow, capacity))\n",
    "\n",
    "\n",
    "    def step(self, vehicle_influence, prev_loc, loc, dest, action):\n",
    "        arrived = (loc.id == dest.id)\n",
    "\n",
    "        action = action if not arrived else loc.id\n",
    "        prev_loc_id = \"x\" if not prev_loc else prev_loc.id\n",
    "        loc_id, to_section_id = loc.id, action\n",
    "\n",
    "        moved = self.move_vehicle(vehicle_influence, prev_loc_id, loc_id, to_section_id)\n",
    "        next_loc_id = to_section_id if moved else loc_id\n",
    "        next_loc = self.get_section_from_id(next_loc_id)\n",
    "\n",
    "        state = self.get_state(next_loc, dest)\n",
    "\n",
    "        step_penalty = 0\n",
    "        if self.get_road_from_o_d(loc_id, next_loc_id):\n",
    "            step_penalty = -1 * self.get_road_from_o_d(loc_id, next_loc_id).get_congestion()\n",
    "        elif (not arrived) and (not moved):\n",
    "            step_penalty = -1 * self.get_road_from_o_d(prev_loc_id, loc_id).get_congestion()\n",
    "\n",
    "        return step_penalty, state, next_loc\n",
    "\n",
    "\n",
    "    def bin_value(self, value):\n",
    "        return math.ceil(value / self.state_bin)\n",
    "\n",
    "\n",
    "    def get_state(self, loc, dest):\n",
    "        neighbors = loc.neighbors\n",
    "        neighbor_congestions = {n.id: self.bin_value(self.get_road_from_o_d(loc.id, n.id).number_of_vehicles) for n in neighbors}\n",
    "        state = [loc.id, dest.id, neighbor_congestions]\n",
    "        return state\n",
    "\n",
    "\n",
    "    def move_vehicle(self, vehicle_influence, prev_loc_id, loc_id, to_section_id):\n",
    "        incident = self.randomness > np.random.rand()\n",
    "        if not incident:\n",
    "            old_road, new_road = self.get_road_from_o_d(prev_loc_id, loc_id), self.get_road_from_o_d(loc_id, to_section_id)\n",
    "            if old_road: old_road.remove_car(vehicle_influence)\n",
    "            if new_road: new_road.add_car(vehicle_influence)\n",
    "            return True\n",
    "        else: # Vehicle did not move for some reason (stochastic environment)\n",
    "            return False\n",
    "\n",
    "\n",
    "    def get_congestion(self):\n",
    "        congestions = []\n",
    "        for road in self.roads: congestions.append(road.get_congestion())\n",
    "        return sum(congestions)\n",
    "\n",
    "\n",
    "    def get_section_from_id(self, section_id):\n",
    "        for s in self.sections:\n",
    "            if s.id == section_id: return s\n",
    "        return None\n",
    "\n",
    "\n",
    "    def get_road_from_o_d(self, origin, destination):\n",
    "        road_id = origin[0] + destination[0]\n",
    "        for r in self.roads:\n",
    "            if r.id == road_id: return r\n",
    "        return None"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sQA64CAI2Mrd",
   "metadata": {
    "id": "sQA64CAI2Mrd"
   },
   "source": [
    "# Constructing the city"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "327c0d90",
   "metadata": {
    "id": "327c0d90"
   },
   "outputs": [],
   "source": [
    "def create_sampling_tables(sect_names, sect_sampling_coeff):\n",
    "    sections, origin_sample_table, dest_sample_table = list(), list(), list()\n",
    "    for idx, s in enumerate(sect_names):\n",
    "        sections.append(Section(s))\n",
    "        origin_sample_table.extend([sections[-1]]*sect_sampling_coeff[idx][0])\n",
    "        dest_sample_table.extend([sections[-1]]*sect_sampling_coeff[idx][1])\n",
    "    return sections, origin_sample_table, dest_sample_table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "a8d96146",
   "metadata": {
    "id": "a8d96146"
   },
   "outputs": [],
   "source": [
    "def generate_population(nr_vehicles, origin_sample_table, dest_sample_table):\n",
    "    vehicles = list()\n",
    "    for i in range(nr_vehicles):\n",
    "        vehicle_type = \"car\" if np.random.rand() > 0.05 else \"bus\"\n",
    "        origin, destination = np.random.choice(origin_sample_table), np.random.choice(dest_sample_table)\n",
    "        while destination == origin: destination = np.random.choice(dest_sample_table)\n",
    "        vehicles.append(Vehicle(i, vehicle_type, origin, destination))\n",
    "    return vehicles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "b6ab22e2",
   "metadata": {
    "id": "b6ab22e2"
   },
   "outputs": [],
   "source": [
    "sect_names = [\"AveHub\",\"BusBay\",\"CarCove\",\"DashDale\",\"EcoEnd\",\"FastField\",\"GearBay\",\"HighHill\",\"JamHub\",\"KerbKey\",\"LaneEnd\"]\n",
    "# How likely these sections should be origins and destinations?\n",
    "sect_sampling_coeff = [(1, 9), (1, 9), (9, 1), (1, 1), (9, 1), (1, 1), (9, 1), (1, 1), (0, 10), (5, 5), (10, 0)]\n",
    "\n",
    "# Road origins and destinations, free flow durations and capacities\n",
    "roads = [[\"LaneEnd\", \"FastField\", 2/60, 300], [\"FastField\", \"HighHill\", 8/60, 800], [\"HighHill\", \"GearBay\", 6/60, 500],\\\n",
    "         [\"FastField\", \"JamHub\", 13/60, 400], [\"HighHill\", \"BusBay\", 10/60, 500], [\"GearBay\", \"BusBay\", 15/60, 600], \\\n",
    "         [\"GearBay\", \"CarCove\", 25/60, 1000], [\"AveHub\", \"JamHub\", 3/60, 250], [\"JamHub\", \"BusBay\", 4/60, 250], \\\n",
    "         [\"AveHub\", \"EcoEnd\", 15/60, 600], [\"AveHub\", \"KerbKey\", 7/60, 300], [\"JamHub\", \"DashDale\", 9/60, 450], \\\n",
    "         [\"EcoEnd\", \"KerbKey\", 4/60, 250], [\"DashDale\", \"CarCove\", 3/60, 300]]\n",
    "roads = [[r[0][0], r[1][0], r[2], r[3]] for r in roads]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "e3e356aa",
   "metadata": {
    "id": "e3e356aa"
   },
   "outputs": [],
   "source": [
    "sections, origin_sample_table, dest_sample_table = create_sampling_tables(sect_names, sect_sampling_coeff)\n",
    "vehicles = generate_population(population, origin_sample_table, dest_sample_table)\n",
    "\n",
    "city = City(sections, 0.05)\n",
    "city.build_roads(roads)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "58d31bd3",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "58d31bd3",
    "outputId": "03fe6f51-cc45-4acf-c844-9cc0e1388b5f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- Sections ---\n",
      "AveHub neighbors to: ['EcoEnd', 'JamHub', 'KerbKey']\n",
      "BusBay neighbors to: ['GearBay', 'HighHill', 'JamHub']\n",
      "CarCove neighbors to: ['DashDale', 'GearBay']\n",
      "DashDale neighbors to: ['CarCove', 'JamHub']\n",
      "EcoEnd neighbors to: ['AveHub', 'KerbKey']\n",
      "FastField neighbors to: ['HighHill', 'JamHub', 'LaneEnd']\n",
      "GearBay neighbors to: ['BusBay', 'CarCove', 'HighHill']\n",
      "HighHill neighbors to: ['BusBay', 'FastField', 'GearBay']\n",
      "JamHub neighbors to: ['AveHub', 'BusBay', 'DashDale', 'FastField']\n",
      "KerbKey neighbors to: ['AveHub', 'EcoEnd']\n",
      "LaneEnd neighbors to: ['FastField']\n",
      "\n",
      "--- Some of the vehicles ---\n",
      "car is now at KerbKey. It is going from KerbKey to AveHub\n",
      "car is now at GearBay. It is going from GearBay to BusBay\n",
      "car is now at LaneEnd. It is going from LaneEnd to BusBay\n",
      "car is now at HighHill. It is going from HighHill to KerbKey\n",
      "car is now at AveHub. It is going from AveHub to JamHub\n",
      "car is now at LaneEnd. It is going from LaneEnd to FastField\n",
      "car is now at LaneEnd. It is going from LaneEnd to JamHub\n",
      "car is now at EcoEnd. It is going from EcoEnd to JamHub\n",
      "car is now at GearBay. It is going from GearBay to BusBay\n",
      "car is now at CarCove. It is going from CarCove to AveHub\n"
     ]
    }
   ],
   "source": [
    "print(\"--- Sections ---\")\n",
    "for s in city.sections:\n",
    "    print(s.name, \"neighbors to:\", [x.name for x in s.neighbors])\n",
    "\n",
    "print(\"\\n--- Some of the vehicles ---\")\n",
    "for v in vehicles[:10]:\n",
    "    print(\"%s is now at %s. It is going from %s to %s\"%(v.vehicle_type, v.location.name, v.origin.name, v.destination.name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "0fa3a323",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "0fa3a323",
    "outputId": "63b5f1b3-a549-41f4-87d9-4133d1ea1d61"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LaneEnd is the most popular origin with 115 vehicles.\n",
      " JamHub is the most popular destination with 149 vehicles.\n"
     ]
    }
   ],
   "source": [
    "origin_dest_counter = {x:[0, 0] for x in sect_names}\n",
    "for v in vehicles:\n",
    "    origin_dest_counter[v.origin.name][0] += 1\n",
    "    origin_dest_counter[v.destination.name][1] += 1\n",
    "\n",
    "max_dest, max_dest_nr, max_origin, max_origin_nr = None, 0, None, 0\n",
    "for sect, values in origin_dest_counter.items():\n",
    "    org, dest = values\n",
    "    if org > max_origin_nr:\n",
    "        max_origin_nr = org\n",
    "        max_origin = sect\n",
    "    if dest > max_dest_nr:\n",
    "        max_dest_nr = dest\n",
    "        max_dest = sect\n",
    "\n",
    "print(max_origin, \"is the most popular origin with\", max_origin_nr, \"vehicles.\\n\",\\\n",
    "      max_dest, \"is the most popular destination with\", max_dest_nr, \"vehicles.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "MoAg8ZBI2Q4q",
   "metadata": {
    "id": "MoAg8ZBI2Q4q"
   },
   "source": [
    "# Training"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7j_Cd7zI2GLb",
   "metadata": {
    "id": "7j_Cd7zI2GLb"
   },
   "source": [
    "## Stats from random agents"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8U_ShiryjbCM",
   "metadata": {
    "id": "8U_ShiryjbCM"
   },
   "source": [
    "Let's try out for one episode and see what a set of agents which make decisions at random can achieve in this environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "0vGU5t3q0OtA",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 504
    },
    "id": "0vGU5t3q0OtA",
    "outputId": "c366def1-12df-4bcb-ca24-e0f47298076f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Finished episode in 140 steps.\n",
      "Total reward: -1291.560\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "city.reset()\n",
    "trajectories = dict()\n",
    "\n",
    "for v in vehicles:\n",
    "  v.reset()\n",
    "  trajectories[v.id] = [v.location.name]\n",
    "\n",
    "episode_reward = 0\n",
    "step_counter = 0\n",
    "step_congestions = list()\n",
    "\n",
    "while not all([v.arrived for v in vehicles]):\n",
    "\n",
    "    step_counter += 1\n",
    "\n",
    "    for v in vehicles:\n",
    "\n",
    "        state = city.get_state(v.location, v.destination)\n",
    "        action = v.pick_action(state)\n",
    "        step_reward, next_state, next_loc = city.step(v.influence, v.prev_location, v.location, v.destination, action)\n",
    "        v.move_to_section(next_loc)\n",
    "\n",
    "        trajectories[v.id].append(next_loc.name)\n",
    "\n",
    "        episode_reward += step_reward\n",
    "\n",
    "    step_congestions.append(city.get_congestion())\n",
    "\n",
    "\n",
    "print(\"Finished episode in %d steps.\" % (step_counter))\n",
    "print(\"Total reward: %.3f\\n\" % (episode_reward))\n",
    "\n",
    "plt.plot(step_congestions, color=\"red\")\n",
    "plt.grid(True)\n",
    "plt.xlabel(\"Steps\")\n",
    "plt.ylabel(\"Traffic congestion\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "iDRYlXq2joFo",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "iDRYlXq2joFo",
    "outputId": "16a43fe0-f3ab-434c-f7c8-645ba78c35b4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "car #0 moving from KerbKey to AveHub followed (first 10):  ['KerbKey', 'EcoEnd', 'KerbKey', 'EcoEnd', 'KerbKey', 'AveHub', 'AveHub', 'AveHub', 'AveHub', 'AveHub']\n",
      "car #1 moving from GearBay to BusBay followed (first 10):  ['GearBay', 'CarCove', 'GearBay', 'BusBay', 'BusBay', 'BusBay', 'BusBay', 'BusBay', 'BusBay', 'BusBay']\n",
      "car #2 moving from LaneEnd to BusBay followed (first 10):  ['LaneEnd', 'FastField', 'LaneEnd', 'FastField', 'HighHill', 'GearBay', 'HighHill', 'GearBay', 'BusBay', 'BusBay']\n",
      "car #3 moving from HighHill to KerbKey followed (first 10):  ['HighHill', 'FastField', 'HighHill', 'BusBay', 'GearBay', 'HighHill', 'FastField', 'LaneEnd', 'FastField', 'JamHub']\n",
      "car #4 moving from AveHub to JamHub followed (first 10):  ['AveHub', 'KerbKey', 'AveHub', 'KerbKey', 'EcoEnd', 'KerbKey', 'EcoEnd', 'AveHub', 'JamHub', 'JamHub']\n",
      "car #5 moving from LaneEnd to FastField followed (first 10):  ['LaneEnd', 'FastField', 'FastField', 'FastField', 'FastField', 'FastField', 'FastField', 'FastField', 'FastField', 'FastField']\n",
      "car #6 moving from LaneEnd to JamHub followed (first 10):  ['LaneEnd', 'FastField', 'LaneEnd', 'FastField', 'JamHub', 'JamHub', 'JamHub', 'JamHub', 'JamHub', 'JamHub']\n",
      "car #7 moving from EcoEnd to JamHub followed (first 10):  ['EcoEnd', 'AveHub', 'KerbKey', 'EcoEnd', 'AveHub', 'EcoEnd', 'AveHub', 'JamHub', 'JamHub', 'JamHub']\n",
      "car #8 moving from GearBay to BusBay followed (first 10):  ['GearBay', 'BusBay', 'BusBay', 'BusBay', 'BusBay', 'BusBay', 'BusBay', 'BusBay', 'BusBay', 'BusBay']\n",
      "car #9 moving from CarCove to AveHub followed (first 10):  ['CarCove', 'GearBay', 'CarCove', 'GearBay', 'HighHill', 'FastField', 'LaneEnd', 'FastField', 'JamHub', 'DashDale']\n"
     ]
    }
   ],
   "source": [
    "for v in vehicles[:10]:\n",
    "  print(\"%s #%d moving from %s to %s followed (first 10): \" % (v.vehicle_type, v.id, v.origin.name, v.destination.name), trajectories[v.id][:10])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "vrIoJjGD2De8",
   "metadata": {
    "id": "vrIoJjGD2De8"
   },
   "source": [
    "## Training Loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "b617a6f0",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "b617a6f0",
    "outputId": "31a47708-6887-4c57-d2c8-5d1a78f5e0f1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\r",
      "At episode: 1\r",
      "------------ EPISODE #1 ------------\n",
      " [FINAL REWARD] -1255.628 [EPSILON] 0.999000 [STEPS] 189\n",
      "------------ EPISODE #1000 ------------\n",
      " [FINAL REWARD] -402.332 [EPSILON] 0.367695 [STEPS] 39\n",
      "------------ EPISODE #2000 ------------\n",
      " [FINAL REWARD] -341.792 [EPSILON] 0.135200 [STEPS] 19\n",
      "------------ EPISODE #3000 ------------\n",
      " [FINAL REWARD] -318.913 [EPSILON] 0.049712 [STEPS] 21\n",
      "------------ EPISODE #4000 ------------\n",
      " [FINAL REWARD] -277.656 [EPSILON] 0.018279 [STEPS] 15\n",
      "------------ EPISODE #5000 ------------\n",
      " [FINAL REWARD] -268.795 [EPSILON] 0.006721 [STEPS] 12\n",
      "------------ EPISODE #6000 ------------\n",
      " [FINAL REWARD] -271.907 [EPSILON] 0.002471 [STEPS] 11\n",
      "------------ EPISODE #7000 ------------\n",
      " [FINAL REWARD] -264.412 [EPSILON] 0.000909 [STEPS] 14\n",
      "------------ EPISODE #8000 ------------\n",
      " [FINAL REWARD] -274.239 [EPSILON] 0.000334 [STEPS] 12\n",
      "------------ EPISODE #9000 ------------\n",
      " [FINAL REWARD] -263.121 [EPSILON] 0.000123 [STEPS] 15\n",
      "------------ EPISODE #10000 ------------\n",
      " [FINAL REWARD] -259.939 [EPSILON] 0.000045 [STEPS] 16\n",
      "------------ EPISODE #11000 ------------\n",
      " [FINAL REWARD] -251.611 [EPSILON] 0.000017 [STEPS] 14\n",
      "------------ EPISODE #12000 ------------\n",
      " [FINAL REWARD] -249.678 [EPSILON] 0.000006 [STEPS] 9\n",
      "------------ EPISODE #13000 ------------\n",
      " [FINAL REWARD] -245.657 [EPSILON] 0.000002 [STEPS] 10\n",
      "------------ EPISODE #14000 ------------\n",
      " [FINAL REWARD] -255.705 [EPSILON] 0.000001 [STEPS] 15\n",
      "------------ EPISODE #15000 ------------\n",
      " [FINAL REWARD] -266.998 [EPSILON] 0.000000 [STEPS] 11\n",
      "------------ EPISODE #16000 ------------\n",
      " [FINAL REWARD] -244.640 [EPSILON] 0.000000 [STEPS] 11\n",
      "------------ EPISODE #17000 ------------\n",
      " [FINAL REWARD] -239.824 [EPSILON] 0.000000 [STEPS] 9\n",
      "------------ EPISODE #18000 ------------\n",
      " [FINAL REWARD] -238.420 [EPSILON] 0.000000 [STEPS] 10\n",
      "------------ EPISODE #19000 ------------\n",
      " [FINAL REWARD] -243.499 [EPSILON] 0.000000 [STEPS] 10\n",
      "------------ EPISODE #20000 ------------\n",
      " [FINAL REWARD] -235.794 [EPSILON] 0.000000 [STEPS] 10\n",
      "\n",
      "\n",
      "[COMPLETED] : 02 hours, 12 minutes, 52 seconds\n"
     ]
    }
   ],
   "source": [
    "episode_rewards = list()\n",
    "episode_steps = list()\n",
    "\n",
    "start_time = time.time()\n",
    "\n",
    "for episode in range(num_episodes):\n",
    "\n",
    "    city.reset()\n",
    "    for v in vehicles: v.reset()\n",
    "\n",
    "    episode_reward = 0\n",
    "    step_counter = 0\n",
    "\n",
    "    while not all([v.arrived for v in vehicles]):\n",
    "\n",
    "        step_counter += 1\n",
    "\n",
    "        for v in vehicles:\n",
    "\n",
    "            state = city.get_state(v.location, v.destination)\n",
    "            action = v.pick_action(state)\n",
    "            step_reward, next_state, next_loc = city.step(v.influence, v.prev_location, v.location, v.destination, action)\n",
    "            v.learn(state, action, step_reward, next_state)\n",
    "            v.move_to_section(next_loc)\n",
    "\n",
    "            episode_reward += step_reward\n",
    "\n",
    "    print(\"\\rAt episode: %d\" % (episode+1), end='')\n",
    "    episode_steps.append(step_counter)\n",
    "    episode_rewards.append(episode_reward)\n",
    "\n",
    "    for v in vehicles: v.decay_epsilon(decay_rate) # Decay epsilon\n",
    "\n",
    "    if ((episode+1) % (num_episodes//20) == 0) or (episode == 0):\n",
    "        print(\"\\r------------ EPISODE #%d ------------\\n [FINAL REWARD] %.3f [EPSILON] %.6f [STEPS] %d\" \\\n",
    "              % (episode+1, episode_reward, v.epsilon, step_counter))\n",
    "\n",
    "\n",
    "print(\"\\n\\n[COMPLETED] : %s\" % (time.strftime(\"%H hours, %M minutes, %S seconds\", time.gmtime(time.time() - start_time))))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "MyCnhyJxnlUm",
   "metadata": {
    "id": "MyCnhyJxnlUm"
   },
   "source": [
    "## Training Stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "90b73743",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 449
    },
    "id": "90b73743",
    "outputId": "00970686-43dc-4b6b-e8b5-c80935b5911d"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(episode_rewards, color=\"purple\")\n",
    "plt.xlabel(\"Episode\")\n",
    "plt.ylabel(\"Episode rewards\")\n",
    "plt.grid(True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "28ed7485",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 449
    },
    "id": "28ed7485",
    "outputId": "e10cc8fb-c77f-4052-f6d6-dcc84839c47d"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(episode_steps, color=\"purple\")\n",
    "plt.xlabel(\"Episode\")\n",
    "plt.ylabel(\"Episode steps\")\n",
    "plt.grid(True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "RY-AmGcRSQob",
   "metadata": {
    "id": "RY-AmGcRSQob"
   },
   "source": [
    "# Testing the agents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "KBFkL3i4N6CS",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 541
    },
    "id": "KBFkL3i4N6CS",
    "outputId": "d75b6edc-a672-44c1-b7d4-147b0bec43bf"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\r",
      "Step: 1\r",
      "Step: 2\r",
      "Step: 3\r",
      "Step: 4\r",
      "Step: 5\r",
      "Step: 6\r",
      "Step: 7\r",
      "Step: 8\r",
      "Step: 9\r",
      "Step: 10\r",
      "Step: 11\n",
      "Finished episode in 11 steps.\n",
      "Total reward: -254.144\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "city.reset()\n",
    "trajectories = dict()\n",
    "\n",
    "for v in vehicles:\n",
    "  v.reset()\n",
    "  v.epsilon = 0\n",
    "  trajectories[v.id] = [v.location.name]\n",
    "\n",
    "episode_reward = 0\n",
    "step_counter = 0\n",
    "step_congestions = list()\n",
    "\n",
    "while not all([v.arrived for v in vehicles]):\n",
    "\n",
    "    step_counter += 1\n",
    "\n",
    "    for v in vehicles:\n",
    "\n",
    "        state = city.get_state(v.location, v.destination)\n",
    "        action = v.pick_action(state)\n",
    "        step_reward, next_state, next_loc = city.step(v.influence, v.prev_location, v.location, v.destination, action)\n",
    "        v.move_to_section(next_loc)\n",
    "\n",
    "        trajectories[v.id].append(next_loc.name)\n",
    "\n",
    "        episode_reward += step_reward\n",
    "    print(\"\\rStep: %d\" % (step_counter), end='')\n",
    "    step_congestions.append(city.get_congestion())\n",
    "\n",
    "\n",
    "print(\"\\nFinished episode in %d steps.\" % (step_counter))\n",
    "print(\"Total reward: %.3f\\n\\n\" % (episode_reward))\n",
    "\n",
    "plt.plot(step_congestions, color=\"red\")\n",
    "plt.grid(True)\n",
    "plt.xlabel(\"Steps\")\n",
    "plt.ylabel(\"Traffic congestion\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "fakktJ7XkBeo",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "fakktJ7XkBeo",
    "outputId": "bb684f0d-a701-4cf4-a888-0d13f9406cfc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "car #0 moving from KerbKey to AveHub followed (first 10):  ['KerbKey', 'AveHub', 'AveHub', 'AveHub', 'AveHub', 'AveHub', 'AveHub', 'AveHub', 'AveHub', 'AveHub', 'AveHub', 'AveHub']\n",
      "car #1 moving from GearBay to BusBay followed (first 10):  ['GearBay', 'BusBay', 'BusBay', 'BusBay', 'BusBay', 'BusBay', 'BusBay', 'BusBay', 'BusBay', 'BusBay', 'BusBay', 'BusBay']\n",
      "car #2 moving from LaneEnd to BusBay followed (first 10):  ['LaneEnd', 'FastField', 'JamHub', 'AveHub', 'JamHub', 'BusBay', 'BusBay', 'BusBay', 'BusBay', 'BusBay', 'BusBay', 'BusBay']\n",
      "car #3 moving from HighHill to KerbKey followed (first 10):  ['HighHill', 'FastField', 'LaneEnd', 'FastField', 'JamHub', 'AveHub', 'KerbKey', 'KerbKey', 'KerbKey', 'KerbKey', 'KerbKey', 'KerbKey']\n",
      "car #4 moving from AveHub to JamHub followed (first 10):  ['AveHub', 'JamHub', 'JamHub', 'JamHub', 'JamHub', 'JamHub', 'JamHub', 'JamHub', 'JamHub', 'JamHub', 'JamHub', 'JamHub']\n",
      "car #5 moving from LaneEnd to FastField followed (first 10):  ['LaneEnd', 'FastField', 'FastField', 'FastField', 'FastField', 'FastField', 'FastField', 'FastField', 'FastField', 'FastField', 'FastField', 'FastField']\n",
      "car #6 moving from LaneEnd to JamHub followed (first 10):  ['LaneEnd', 'FastField', 'JamHub', 'JamHub', 'JamHub', 'JamHub', 'JamHub', 'JamHub', 'JamHub', 'JamHub', 'JamHub', 'JamHub']\n",
      "car #7 moving from EcoEnd to JamHub followed (first 10):  ['EcoEnd', 'AveHub', 'JamHub', 'JamHub', 'JamHub', 'JamHub', 'JamHub', 'JamHub', 'JamHub', 'JamHub', 'JamHub', 'JamHub']\n",
      "car #8 moving from GearBay to BusBay followed (first 10):  ['GearBay', 'BusBay', 'BusBay', 'BusBay', 'BusBay', 'BusBay', 'BusBay', 'BusBay', 'BusBay', 'BusBay', 'BusBay', 'BusBay']\n",
      "car #9 moving from CarCove to AveHub followed (first 10):  ['CarCove', 'DashDale', 'CarCove', 'GearBay', 'CarCove', 'GearBay', 'BusBay', 'JamHub', 'AveHub', 'AveHub', 'AveHub', 'AveHub']\n"
     ]
    }
   ],
   "source": [
    "for v in vehicles[:10]:\n",
    "  print(\"%s #%d moving from %s to %s followed (first 10): \" % (v.vehicle_type, v.id, v.origin.name, v.destination.name), trajectories[v.id])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7306dc3f",
   "metadata": {},
   "source": [
    "### The episode takes way shorter, with more cumulative rewards, and the repetative movements are avoided."
   ]
  }
 ],
 "metadata": {
  "colab": {
   "machine_shape": "hm",
   "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.11.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}