analysis_plots.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Analysis Notebook\n",
    "\n",
    "This notebook can be used to produce graphs for the data produced. It defaults to using all results, but that can be specified. \n",
    "*** "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 0. Setup <a class=\"anchor\" id=\"0\"></a>\n",
    "This section imports all files and sets up the notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import all pacakges\n",
    "import os\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Choose which results to use\n",
    "results_to_use = []  # If this is empty, all files in the folder will be used\n",
    "WARMUP_EPOCHS = 0 # Number of epochs to ignore.\n",
    "sim_colours = ['blue', 'green', 'red', 'orange', 'purple', 'brown', 'pink', 'gray', 'olive', 'cyan']\n",
    "\n",
    "\n",
    "all_results = os.listdir('results/')\n",
    "\n",
    "if results_to_use == [] or results_to_use == [\"\"]:\n",
    "    results_to_use = all_results\n",
    "# remove DS_Store from the list\n",
    "if '.DS_Store' in results_to_use:\n",
    "    results_to_use.remove('.DS_Store')\n",
    "\n",
    "# order them alphabetically\n",
    "results_to_use.sort()\n",
    "print(\"Using results: \" + str(results_to_use))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a dictionary. Each key is a set of results. \n",
    "\n",
    "all_sim_results = {}\n",
    "\n",
    "for sim in results_to_use:\n",
    "    all_sim_results[sim] = {}\n",
    "    all_sim_results[sim]['configuration'] = pd.read_csv(\n",
    "        'results/' + sim + '/configuration.txt', header=None, delimiter=\":\")\n",
    "    types_of_results = []\n",
    "    # Get all the filenames in the folder, excluding the extension\n",
    "    for file in os.listdir('results/' + sim + '/exported_data/'):\n",
    "        if file.endswith(\".npy\"):\n",
    "            types_of_results.append(file[:-4])\n",
    "    # Create a dictionary for each type of result\n",
    "    for result in types_of_results:\n",
    "        all_sim_results[sim][result] = np.load(\n",
    "            'results/' + sim + '/exported_data/' + result + '.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Show all the all_sim_results in the notebook\n",
    "for set_of_results in results_to_use:\n",
    "    print(\"Results: \" + set_of_results)\n",
    "    print(all_sim_results[set_of_results]['configuration'])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Average Trip Satisfaction  <a class=\"anchor\" id=\"1\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.clf()\n",
    "plt.rcParams['figure.titlesize'] = 50  # Title font size\n",
    "plt.rcParams['figure.labelsize'] = 50  # Axes labels font size\n",
    "plt.rcParams['axes.titlesize'] = 50  # Title font size\n",
    "plt.rcParams['axes.labelsize'] = 40  # Axes labels font size\n",
    "plt.rcParams['xtick.labelsize'] = 30  # X-axis tick labels font size\n",
    "plt.rcParams['ytick.labelsize'] = 30  # Y-axis tick labels font size\n",
    "plt.rcParams['figure.figsize'] = (40, 20)  # Figure size\n",
    "plt.rcParams['lines.markersize'] = 1  # Figure markersize\n",
    "plt.rcParams['legend.markerscale'] = 15  # Legend markersize\n",
    "plt.rcParams['legend.fontsize'] = 20  # Legend font size\n",
    "plt.rcParams['figure.dpi'] = 200  # Legend font size\n",
    "average_satisfaction_score_results = []\n",
    "std_satisfaction_score_results = []\n",
    "\n",
    "for sim in results_to_use:\n",
    "    average_satisfaction_score_results.append(\n",
    "        all_sim_results[sim]['average_satisfaction_score'])\n",
    "\n",
    "for sim in results_to_use:\n",
    "    std_satisfaction_score_results.append(\n",
    "        all_sim_results[sim]['std_satisfaction_score'])\n",
    "\n",
    "for i, history in enumerate(average_satisfaction_score_results):\n",
    "    average_satisfaction_score_results[i] = history[WARMUP_EPOCHS:]\n",
    "    std_satisfaction_score_results[i] = std_satisfaction_score_results[i][WARMUP_EPOCHS:]\n",
    "for i, history in enumerate(average_satisfaction_score_results):\n",
    "    plt.plot(list(range(len(history))), history,\n",
    "             'o', ls='none', label=results_to_use[i], color=sim_colours[i])\n",
    "\n",
    "for i, history in enumerate(std_satisfaction_score_results):\n",
    "    plt.fill_between(list(range(len(average_satisfaction_score_results[i]))), average_satisfaction_score_results[\n",
    "                     i] - history, average_satisfaction_score_results[i] + history, alpha=0.2, color=sim_colours[i], interpolate=True)\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Average Trip Satisfaction Score\\n')\n",
    "plt.title('History of Average Trip Satisfaction Score\\n')\n",
    "plt.legend()\n",
    "plt.show()\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Average Auction Reward per Intersection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_single_reward_history(average_reward_per_intersection, label, colour, axs):\n",
    "    for i in range(average_reward_per_intersection.shape[0]):\n",
    "        for j in range(average_reward_per_intersection.shape[0]):\n",
    "            axs[i, j].plot(\n",
    "                average_reward_per_intersection[i, j], 'o', color=colour, label=label)\n",
    "            axs[i, j].set_title('[' + str(i) + ',' + str(j) + ']')\n",
    "\n",
    "def plot_std_fill(avg_values, std_fill, colour, axs):\n",
    "    for i in range(std_fill.shape[0]):\n",
    "        for j in range(std_fill.shape[0]):\n",
    "            axs[i, j].fill_between(list(range(len(avg_values[i, j]))), avg_values[i, j] - std_fill[i, j], avg_values[i, j] + std_fill[i, j], alpha=0.2, color=colour, interpolate=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.clf()\n",
    "plt.rcParams['figure.titlesize'] = 50  # Title font size\n",
    "plt.rcParams['figure.labelsize'] = 45  # Axes labels font size\n",
    "plt.rcParams['axes.titlesize'] = 30  # Title font size\n",
    "plt.rcParams['axes.labelsize'] = 30\n",
    "plt.rcParams['xtick.labelsize'] = 30  # X-axis tick labels font size\n",
    "plt.rcParams['ytick.labelsize'] = 30  # Y-axis tick labels font size\n",
    "plt.rcParams['figure.figsize'] = (30, 20)  # Figure size\n",
    "plt.rcParams['lines.markersize'] = 4  # Figure markersize\n",
    "plt.rcParams['legend.markerscale'] = 3  # Legend markersize\n",
    "plt.rcParams['legend.fontsize'] = 25  # Legend font size\n",
    "plt.rcParams['figure.dpi'] = 200  # Legend font size\n",
    "\n",
    "average_reward_per_intersection_history_results = []\n",
    "std_reward_per_intersection_history_results = []\n",
    "for sim in results_to_use:\n",
    "    average_reward_per_intersection_history_results.append(\n",
    "        all_sim_results[sim]['average_reward_per_intersection_history'])\n",
    "\n",
    "fig, axs = plt.subplots(\n",
    "    average_reward_per_intersection_history_results[0].shape[0],\n",
    "    average_reward_per_intersection_history_results[0].shape[1], sharex=True, sharey=True)\n",
    "\n",
    "for i, history in enumerate(average_reward_per_intersection_history_results):\n",
    "    plot_single_reward_history(history, results_to_use[i], sim_colours[i], axs)\n",
    "    \n",
    "for i, history in enumerate(std_reward_per_intersection_history_results):    \n",
    "    plot_std_fill(average_reward_per_intersection_history_results[i], std_reward_per_intersection_history_results[i], sim_colours[i], axs)\n",
    "\n",
    "fig.supxlabel('Epoch\\n')\n",
    "fig.supylabel('\\nAverage Auction Reward')\n",
    "fig.suptitle(\n",
    "    '\\n History of Average Auction Reward per Intersection')\n",
    "\n",
    "plt.subplots_adjust(right=0.9)\n",
    "lgnd = plt.legend(loc='upper left', bbox_to_anchor=(1, 1.5))\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Average Auction Reward Central Intersection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import statsmodels.api as sm\n",
    "\n",
    "plt.clf()\n",
    "plt.rcParams['figure.titlesize'] = 50  # Title font size\n",
    "plt.rcParams['figure.labelsize'] = 45  # Axes labels font size\n",
    "plt.rcParams['axes.titlesize'] = 30  # Title font size\n",
    "plt.rcParams['axes.labelsize'] = 30\n",
    "plt.rcParams['xtick.labelsize'] = 30  # X-axis tick labels font size\n",
    "plt.rcParams['ytick.labelsize'] = 30  # Y-axis tick labels font size\n",
    "plt.rcParams['figure.figsize'] = (30, 20)  # Figure size\n",
    "plt.rcParams['lines.markersize'] = 4  # Figure markersize\n",
    "plt.rcParams['legend.markerscale'] = 3  # Legend markersize\n",
    "plt.rcParams['legend.fontsize'] = 25  # Legend font size\n",
    "plt.rcParams['figure.dpi'] = 200  # Legend font size\n",
    "\n",
    "average_reward_per_intersection_history_results = []\n",
    "std_reward_per_intersection_history_results = []\n",
    "for sim in results_to_use:\n",
    "    average_reward_per_intersection_history_results.append(\n",
    "        all_sim_results[sim]['average_reward_per_intersection_history'][1,1])\n",
    "\n",
    "\n",
    "for i, history in enumerate(average_reward_per_intersection_history_results):\n",
    "    model = sm.OLS(history, sm.add_constant(np.arange(len(history)))).fit()\n",
    "    print(\"\\subsubsection{\", results_to_use[i], \"}\")\n",
    "    print(model.summary().tables[1].as_latex_tabular())\n",
    "    \n",
    "    plt.plot(list(range(len(history))), history,\n",
    "             'o', ls='none', label=results_to_use[i], color=sim_colours[i])\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Average Auction Reward\\n')\n",
    "plt.title('History of Average Auction Reward\\n')\n",
    "plt.legend()\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Average Throughput per Intersection <a id=\"3\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_throughput_history(throughput_history_per_intersection, label, colour, axs):\n",
    "    for i in range(throughput_history_per_intersection.shape[0]):\n",
    "        for j in range(throughput_history_per_intersection.shape[0]):\n",
    "            axs[i, j].plot(\n",
    "                throughput_history_per_intersection[i, j], 'o', color=colour, label=label)\n",
    "            axs[i, j].set_title('[' + str(i) + ',' + str(j) + ']')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.clf()\n",
    "plt.rcParams['figure.titlesize'] = 50  # Title font size\n",
    "plt.rcParams['figure.labelsize'] = 45  # Axes labels font size\n",
    "plt.rcParams['axes.titlesize'] = 30  # Title font size\n",
    "plt.rcParams['axes.labelsize'] = 30\n",
    "plt.rcParams['xtick.labelsize'] = 30  # X-axis tick labels font size\n",
    "plt.rcParams['ytick.labelsize'] = 30  # Y-axis tick labels font size\n",
    "plt.rcParams['figure.figsize'] = (30, 20)  # Figure size\n",
    "plt.rcParams['lines.markersize'] = 4  # Figure markersize\n",
    "plt.rcParams['legend.markerscale'] = 3  # Legend markersize\n",
    "plt.rcParams['legend.fontsize'] = 25  # Legend font size\n",
    "plt.rcParams['figure.dpi'] = 200  # Legend font size\n",
    "\n",
    "average_throughput_per_intersection_history_results = []\n",
    "std_throughput_per_intersection_history_results = []\n",
    "\n",
    "for sim in results_to_use:\n",
    "    average_throughput_per_intersection_history_results.append(\n",
    "        all_sim_results[sim]['average_throughput_per_intersection'])\n",
    "\n",
    "for sim in results_to_use:\n",
    "    std_throughput_per_intersection_history_results.append(\n",
    "        all_sim_results[sim]['std_throughput_per_intersection'])\n",
    "\n",
    "fig, axs = plt.subplots(\n",
    "    average_throughput_per_intersection_history_results[0].shape[0],\n",
    "    average_throughput_per_intersection_history_results[0].shape[1], sharex=True, sharey=True)\n",
    "\n",
    "for i, history in enumerate(average_throughput_per_intersection_history_results):\n",
    "    plot_throughput_history(history, results_to_use[i], sim_colours[i], axs)\n",
    "\n",
    "for i, history in enumerate(std_throughput_per_intersection_history_results):\n",
    "    plot_std_fill(average_throughput_per_intersection_history_results[i],\n",
    "                  std_throughput_per_intersection_history_results[i], sim_colours[i], axs)\n",
    "\n",
    "fig.supxlabel('Epoch\\n')\n",
    "fig.supylabel('\\nAverage Throughput')\n",
    "fig.suptitle('Average Throughput per Intersection ')\n",
    "plt.subplots_adjust(right=0.9)\n",
    "lgnd = plt.legend(loc='upper left', bbox_to_anchor=(1, 1.5))\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Average Average Time Waited per Intersection <a id=\"4\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def plot_average_time_waited_history(average_time_waited_history_per_intersection, label, colour, axs):\n",
    "    for i in range(average_time_waited_history_per_intersection.shape[0]):\n",
    "        for j in range(average_time_waited_history_per_intersection.shape[0]):\n",
    "            axs[i, j].plot(\n",
    "                average_time_waited_history_per_intersection[i, j], 'o', color=colour, label=label)\n",
    "            axs[i, j].set_title('[' + str(i) + ',' + str(j) + ']')\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.clf()\n",
    "plt.rcParams['figure.titlesize'] = 50  # Title font size\n",
    "plt.rcParams['figure.labelsize'] = 45  # Axes labels font size\n",
    "plt.rcParams['axes.titlesize'] = 30  # Title font size\n",
    "plt.rcParams['axes.labelsize'] = 30\n",
    "plt.rcParams['xtick.labelsize'] = 30  # X-axis tick labels font size\n",
    "plt.rcParams['ytick.labelsize'] = 30  # Y-axis tick labels font size\n",
    "plt.rcParams['figure.figsize'] = (30, 20)  # Figure size\n",
    "plt.rcParams['lines.markersize'] = 1  # Figure markersize\n",
    "plt.rcParams['legend.markerscale'] = 15  # Legend markersize\n",
    "plt.rcParams['legend.fontsize'] = 25  # Legend font size\n",
    "plt.rcParams['figure.dpi'] = 200  # Legend font size\n",
    "\n",
    "average_average_time_waited_per_intersection_history_results = []\n",
    "std_average_time_waited_per_intersection_history_results = []\n",
    "\n",
    "for sim in results_to_use:\n",
    "    average_average_time_waited_per_intersection_history_results.append(\n",
    "        all_sim_results[sim]['average_average_time_waited_per_intersection_history'])\n",
    "\n",
    "for sim in results_to_use:\n",
    "    std_average_time_waited_per_intersection_history_results.append(\n",
    "        all_sim_results[sim]['std_average_time_waited_per_intersection_history'])\n",
    "\n",
    "fig, axs = plt.subplots(\n",
    "    average_average_time_waited_per_intersection_history_results[0].shape[0],\n",
    "    average_average_time_waited_per_intersection_history_results[0].shape[1], sharex=True, sharey=True)\n",
    "\n",
    "for i, history in enumerate(average_average_time_waited_per_intersection_history_results):\n",
    "    plot_average_time_waited_history(\n",
    "        history, results_to_use[i], sim_colours[i], axs)\n",
    "\n",
    "for i, history in enumerate(std_average_time_waited_per_intersection_history_results):\n",
    "    plot_std_fill(average_average_time_waited_per_intersection_history_results[i],\n",
    "                  std_average_time_waited_per_intersection_history_results[i], sim_colours[i], axs)\n",
    "\n",
    "fig.supxlabel('Epoch\\n')\n",
    "fig.supylabel('\\nAverage Time Waited')\n",
    "fig.suptitle('Average Time Waited per Intersection')\n",
    "plt.subplots_adjust(right=0.9)\n",
    "lgnd = plt.legend(loc='upper left', bbox_to_anchor=(1, 1.5))\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Average Max Time Waited per Intersection <a id=\"4\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_max_time_waited_history(max_time_waited_history_per_intersection, label, colour, axs):\n",
    "    for i in range(max_time_waited_history_per_intersection.shape[0]):\n",
    "        for j in range(max_time_waited_history_per_intersection.shape[0]):\n",
    "            axs[i, j].plot(\n",
    "                max_time_waited_history_per_intersection[i, j], 'o', color=colour, label=label)\n",
    "            axs[i, j].set_title('[' + str(i) + ',' + str(j) + ']')\n",
    "            axs[i, j].set_xlim([0, 1000])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.clf()\n",
    "plt.rcParams['figure.titlesize'] = 50  # Title font size\n",
    "plt.rcParams['figure.labelsize'] = 45  # Axes labels font size\n",
    "plt.rcParams['axes.titlesize'] = 30  # Title font size\n",
    "plt.rcParams['axes.labelsize'] = 30\n",
    "plt.rcParams['xtick.labelsize'] = 30  # X-axis tick labels font size\n",
    "plt.rcParams['ytick.labelsize'] = 30  # Y-axis tick labels font size\n",
    "plt.rcParams['figure.figsize'] = (30, 20)  # Figure size\n",
    "plt.rcParams['lines.markersize'] = 1  # Figure markersize\n",
    "plt.rcParams['legend.markerscale'] = 15  # Legend markersize\n",
    "plt.rcParams['legend.fontsize'] = 25  # Legend font size\n",
    "plt.rcParams['figure.dpi'] = 200  # Legend font size\n",
    "\n",
    "average_max_time_waited_per_intersection_history_results = []\n",
    "std_max_time_waited_per_intersection_history_results = []\n",
    "\n",
    "for sim in results_to_use:\n",
    "    average_max_time_waited_per_intersection_history_results.append(\n",
    "        all_sim_results[sim]['average_max_time_waited_per_intersection_history'])\n",
    "\n",
    "for sim in results_to_use:\n",
    "    std_max_time_waited_per_intersection_history_results.append(\n",
    "        all_sim_results[sim]['std_max_time_waited_per_intersection_history'])\n",
    "\n",
    "fig, axs = plt.subplots(\n",
    "    average_max_time_waited_per_intersection_history_results[0].shape[0],\n",
    "    average_max_time_waited_per_intersection_history_results[0].shape[1], sharex=True, sharey=True)\n",
    "\n",
    "for i, history in enumerate(average_max_time_waited_per_intersection_history_results):\n",
    "    plot_max_time_waited_history(\n",
    "        history, results_to_use[i], sim_colours[i], axs)\n",
    "\n",
    "for i, history in enumerate(std_max_time_waited_per_intersection_history_results):\n",
    "    plot_std_fill(average_max_time_waited_per_intersection_history_results[i],\n",
    "                  std_max_time_waited_per_intersection_history_results[i], sim_colours[i], axs)\n",
    "\n",
    "fig.supxlabel('Epoch\\n')\n",
    "fig.supylabel('\\nAverage Max Time Waited')\n",
    "fig.suptitle('Average Max Time Waited per Intersection ')\n",
    "plt.subplots_adjust(right=0.9)\n",
    "lgnd = plt.legend(loc='upper left', bbox_to_anchor=(1, 1.5))\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. Average Max Time Waited for central Intersection <a id=\"4\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.clf()\n",
    "plt.rcParams['figure.titlesize'] = 50  # Title font size\n",
    "plt.rcParams['figure.labelsize'] = 45  # Axes labels font size\n",
    "plt.rcParams['axes.titlesize'] = 30  # Title font size\n",
    "plt.rcParams['axes.labelsize'] = 30\n",
    "plt.rcParams['xtick.labelsize'] = 30  # X-axis tick labels font size\n",
    "plt.rcParams['ytick.labelsize'] = 30  # Y-axis tick labels font size\n",
    "plt.rcParams['figure.figsize'] = (30, 20)  # Figure size\n",
    "plt.rcParams['lines.markersize'] = 3  # Figure markersize\n",
    "plt.rcParams['legend.markerscale'] = 5  # Legend markersize\n",
    "plt.rcParams['legend.fontsize'] = 25  # Legend font size\n",
    "plt.rcParams['figure.dpi'] = 200  # Legend font size\n",
    "\n",
    "average_max_time_waited_per_intersection_history_results = []\n",
    "\n",
    "for sim in results_to_use:\n",
    "    average_max_time_waited_per_intersection_history_results.append(\n",
    "        all_sim_results[sim]['average_max_time_waited_per_intersection_history'][1,1])\n",
    "\n",
    "\n",
    "for i, history in enumerate(average_max_time_waited_per_intersection_history_results):\n",
    "    model = sm.OLS(history, sm.add_constant(np.arange(len(history)))).fit()\n",
    "    plt.plot(list(range(len(history))), history,\n",
    "             'o', ls='none', label=results_to_use[i], color=sim_colours[i])\n",
    "plt.xlim([0, 2000])\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Average Max Time Waited\\n')\n",
    "plt.title('History of Max Time Waited \\n')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8. Average Gini (based on time waited) coefficient per Intersection <a id=\"5\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_gini_history(gini_history_per_intersection, label, colour, axs):\n",
    "    for i in range(gini_history_per_intersection.shape[0]):\n",
    "        for j in range(gini_history_per_intersection.shape[0]):\n",
    "            axs[i, j].plot(\n",
    "                gini_history_per_intersection[i, j], 'o', color=colour, label=label)\n",
    "            axs[i, j].set_title('[' + str(i) + ',' + str(j) + ']')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.clf()\n",
    "plt.rcParams['figure.titlesize'] = 50  # Title font size\n",
    "plt.rcParams['figure.labelsize'] = 45  # Axes labels font size\n",
    "plt.rcParams['axes.titlesize'] = 30  # Title font size\n",
    "plt.rcParams['axes.labelsize'] = 30\n",
    "plt.rcParams['xtick.labelsize'] = 30  # X-axis tick labels font size\n",
    "plt.rcParams['ytick.labelsize'] = 30  # Y-axis tick labels font size\n",
    "plt.rcParams['figure.figsize'] = (30, 20)  # Figure size\n",
    "plt.rcParams['lines.markersize'] = 1  # Figure markersize\n",
    "plt.rcParams['legend.markerscale'] = 15  # Legend markersize\n",
    "plt.rcParams['legend.fontsize'] = 25  # Legend font size\n",
    "plt.rcParams['figure.dpi'] = 200  # Legend font size\n",
    "\n",
    "average_gini_per_intersection_history_results = []\n",
    "std_gini_per_intersection_history_results = []\n",
    "\n",
    "for sim in results_to_use:\n",
    "    average_gini_per_intersection_history_results.append(\n",
    "        all_sim_results[sim]['average_gini_time_waited_per_intersection_history'])\n",
    "\n",
    "for sim in results_to_use:\n",
    "    std_gini_per_intersection_history_results.append(\n",
    "        all_sim_results[sim]['std_gini_time_waited_per_intersection_history'])\n",
    "\n",
    "fig, axs = plt.subplots(\n",
    "    average_gini_per_intersection_history_results[0].shape[0],\n",
    "    average_gini_per_intersection_history_results[0].shape[1], sharex=True, sharey=True)\n",
    "\n",
    "for i, history in enumerate(average_gini_per_intersection_history_results):\n",
    "    plot_gini_history(history, results_to_use[i], sim_colours[i], axs)\n",
    "\n",
    "for i, history in enumerate(std_gini_per_intersection_history_results):\n",
    "    plot_std_fill(average_gini_per_intersection_history_results[i],\n",
    "                  std_gini_per_intersection_history_results[i], sim_colours[i], axs)\n",
    "\n",
    "fig.supxlabel('Epoch\\n')\n",
    "fig.supylabel('\\nAverage Gini Coefficient')\n",
    "fig.suptitle('Average Gini per Intersection (Based on Time Waited)')\n",
    "plt.subplots_adjust(right=0.9)\n",
    "lgnd = plt.legend(loc='upper left', bbox_to_anchor=(1, 1.5))\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9. Average Parameter Valuations per Intersection <a id=\"5\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_average_valuation_per_parameter_per_intersection(rewards, parameters, counts, label, colour, axs):\n",
    "    for i in range(rewards.shape[0]):\n",
    "        for j in range(rewards.shape[0]):\n",
    "            axs[i, j].scatter(\n",
    "                parameters[:, 0], rewards[i, j, :], s=counts[i, j, :], marker=\"o\", c=colour, label=label)\n",
    "            axs[i, j].set_title('[' + str(i) + ',' + str(j) + ']')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.clf()\n",
    "plt.rcParams['figure.titlesize'] = 50  # Title font size\n",
    "plt.rcParams['figure.labelsize'] = 45  # Axes labels font size\n",
    "plt.rcParams['axes.titlesize'] = 30  # Title font size\n",
    "plt.rcParams['axes.labelsize'] = 30\n",
    "plt.rcParams['xtick.labelsize'] = 30  # X-axis tick labels font size\n",
    "plt.rcParams['ytick.labelsize'] = 30  # Y-axis tick labels font size\n",
    "plt.rcParams['figure.figsize'] = (30, 20)  # Figure size\n",
    "plt.rcParams['lines.markersize'] = 4  # Figure markersize\n",
    "plt.rcParams['legend.markerscale'] = 3  # Legend markersize\n",
    "plt.rcParams['legend.fontsize'] = 25  # Legend font size\n",
    "plt.rcParams['figure.dpi'] = 200  # Legend font size\n",
    "\n",
    "average_valuations_per_parameter_per_intersection = []\n",
    "parameters_used = []\n",
    "counts_per_parameter = []\n",
    "for sim in results_to_use:\n",
    "    average_valuations_per_parameter_per_intersection.append(\n",
    "        all_sim_results[sim]['average_reward_per_parameter_set_per_intersection_rewards'])\n",
    "    parameters_used.append(\n",
    "        all_sim_results[sim]['average_reward_per_parameter_set_per_intersection_parameters'])\n",
    "    counts_per_parameter.append(\n",
    "        all_sim_results[sim]['average_reward_per_parameter_set_per_intersection_counts'])\n",
    "\n",
    "\n",
    "fig, axs = plt.subplots(\n",
    "    average_valuations_per_parameter_per_intersection[0].shape[0],\n",
    "    average_valuations_per_parameter_per_intersection[0].shape[1], sharex=True, sharey=True)\n",
    "\n",
    "for i, reward_set in enumerate(average_valuations_per_parameter_per_intersection):\n",
    "    plot_average_valuation_per_parameter_per_intersection(\n",
    "        reward_set, parameters_used[i], counts_per_parameter[i],  results_to_use[i], sim_colours[i], axs)\n",
    "\n",
    "fig.supxlabel('Delay Boost Value\\n')\n",
    "fig.supylabel('\\n Average Expected Reward')\n",
    "fig.suptitle('Average Expected Reward per Parameter')\n",
    "plt.subplots_adjust(right=0.9)\n",
    "lgnd = plt.legend(loc='upper left', bbox_to_anchor=(1, 1.5))\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10. Bid and Inact Ranks per Intersection <a id=\"5\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_bid_inact_ranks(mean_bid_rank_per_intersection, se_bid_rank_per_intersection, mean_inact_rank_per_intersection, se_inact_rank_per_intersection, label, colour, axs, shift):\n",
    "    rank_labels = ['Bid Rank', 'Time Waited \\n Rank']\n",
    "    for i in range(mean_bid_rank_per_intersection.shape[0]):\n",
    "        for j in range(mean_bid_rank_per_intersection.shape[0]):\n",
    "            rank_means = [mean_bid_rank_per_intersection[i, j],\n",
    "                          mean_inact_rank_per_intersection[i, j]]\n",
    "            rank_ses = [se_bid_rank_per_intersection[i, j],\n",
    "                        se_inact_rank_per_intersection[i, j]]\n",
    "            # Create a barplot of the bid ranks per intersection\n",
    "            X_axis = np.arange(len(rank_means))\n",
    "            axs[i, j].set_xticks([-1, 0, 1, 2])\n",
    "            axs[i, j].set_xticklabels(['Bid Rank', 'Time Waited \\n Rank', 'Bid Rank', 'Time Waited \\n Rank'])\n",
    "                \n",
    "            # axs[i, j].set_xticks(X_axis + shift)\n",
    "            # axs[i, j].set_xticklabels(rank_labels)\n",
    "            axs[i, j].bar(X_axis+shift, rank_means,\n",
    "                          label=label, yerr=rank_ses, color=colour)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.clf()\n",
    "plt.rcParams['figure.titlesize'] = 45  # Title font size\n",
    "plt.rcParams['figure.labelsize'] = 35  # Axes labels font size\n",
    "plt.rcParams['axes.titlesize'] = 30  # Title font size\n",
    "plt.rcParams['xtick.labelsize'] = 25  # X-axis tick labels font size\n",
    "plt.rcParams['ytick.labelsize'] = 25  # Y-axis tick labels font size\n",
    "plt.rcParams['figure.figsize'] = (40, 20)  # Figure size\n",
    "plt.rcParams['errorbar.capsize'] = 10  # Error bar capsize\n",
    "\n",
    "shifts = [-1, 1]\n",
    "mean_bid_rank_per_intersection_results = []\n",
    "se_bid_rank_per_intersection_results = []\n",
    "mean_inact_rank_per_intersection_results = []\n",
    "se_inact_rank_per_intersection_results = []\n",
    "\n",
    "for sim in results_to_use:\n",
    "    mean_bid_rank_per_intersection_results.append(\n",
    "        all_sim_results[sim]['mean_bid_rank_per_intersection'])\n",
    "    se_bid_rank_per_intersection_results.append(\n",
    "        all_sim_results[sim]['se_bid_rank_per_intersection'])\n",
    "    mean_inact_rank_per_intersection_results.append(\n",
    "        all_sim_results[sim]['mean_inact_rank_per_intersection'])\n",
    "    se_inact_rank_per_intersection_results.append(\n",
    "        all_sim_results[sim]['se_inact_rank_per_intersection'])\n",
    "\n",
    "fig, axs = plt.subplots(\n",
    "    mean_bid_rank_per_intersection_results[0].shape[0],\n",
    "    mean_bid_rank_per_intersection_results[0].shape[1], sharex=False, sharey=True)\n",
    "\n",
    "for i, (mean_b, se_b, mean_i, se_i) in enumerate(zip(mean_bid_rank_per_intersection_results, se_bid_rank_per_intersection_results, mean_inact_rank_per_intersection_results, se_inact_rank_per_intersection_results)):\n",
    "    plot_bid_inact_ranks(mean_b, se_b, mean_i, se_i,\n",
    "                         results_to_use[i], sim_colours[i], axs, shifts[i])\n",
    "\n",
    "fig.supxlabel('Rank Type\\n')\n",
    "fig.supylabel('\\nAverage Rank Value')\n",
    "fig.suptitle(\n",
    "    '\\n Average Bid Rank and Time Waited Rank of Winner per Intersection')\n",
    "plt.subplots_adjust(right=0.9)\n",
    "lgnd = plt.legend(loc='upper left', bbox_to_anchor=(1, 1.5))\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 11. Valuation per Aggression <a id=\"5\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_average_valuation_per_parameter_per_intersection(rewards, parameters, counts, label, colour, axs):\n",
    "    for i in range(rewards.shape[0]):\n",
    "        for j in range(rewards.shape[0]):\n",
    "            axs[i, j].scatter(\n",
    "                parameters[:, 0], rewards[i, j, :], s=counts[i, j, :], marker=\"o\", c=colour, label=label)\n",
    "            axs[i, j].set_title('[' + str(i) + ',' + str(j) + ']')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.clf()\n",
    "plt.rcParams['figure.titlesize'] = 50  # Title font size\n",
    "plt.rcParams['figure.labelsize'] = 50  # Axes labels font size\n",
    "plt.rcParams['axes.titlesize'] = 50  # Title font size\n",
    "plt.rcParams['axes.labelsize'] = 40  # Axes labels font size\n",
    "plt.rcParams['xtick.labelsize'] = 30  # X-axis tick labels font size\n",
    "plt.rcParams['ytick.labelsize'] = 30  # Y-axis tick labels font size\n",
    "plt.rcParams['figure.figsize'] = (40, 20)  # Figure size\n",
    "plt.rcParams['lines.markersize'] = 1  # Figure markersize\n",
    "plt.rcParams['legend.markerscale'] = 0.5  # Legend markersize\n",
    "plt.rcParams['legend.fontsize'] = 30  # Legend font size\n",
    "plt.rcParams['figure.dpi'] = 200  # Legend font size\n",
    "\n",
    "average_valuations_per_parameter = []\n",
    "parameters_used = []\n",
    "counts_per_parameter = []\n",
    "for sim in results_to_use:\n",
    "    average_valuations_per_parameter.append(\n",
    "        all_sim_results[sim]['all_sims_adaptive_bidding_parameters_valuations'])\n",
    "    parameters_used.append(\n",
    "        all_sim_results[sim]['all_sims_adaptive_bidding_parameters_space'])\n",
    "    counts_per_parameter.append(\n",
    "        all_sim_results[sim]['all_sims_adaptive_bidding_parameters_counts'])\n",
    "    \n",
    "\n",
    "for i, set in enumerate(average_valuations_per_parameter):\n",
    "    plt.scatter(parameters_used[i], set,\n",
    "            s=counts_per_parameter[i]*20, marker=\"o\", label=results_to_use[i], color=sim_colours[i])\n",
    "\n",
    "\n",
    "\n",
    "plt.title('Average Expected Trip Satisfaction per Bid Aggression\\n')\n",
    "plt.xlabel('\\nBid Aggression')\n",
    "plt.ylabel('Expected Trip Satisfaction\\n')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "cars",
   "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.16"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}