result_plot.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.ticker as mtick\n",
    "import matplotlib\n",
    "matplotlib.rcParams['pdf.fonttype'] = 42\n",
    "matplotlib.rcParams['ps.fonttype'] = 42\n",
    "import seaborn as sns\n",
    "sns.set_color_codes()\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import os\n",
    "import math\n",
    "from matplotlib.ticker import FuncFormatter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cacc_slowdown\n"
     ]
    }
   ],
   "source": [
    "# base_dir = '/Users/tchu/Documents/rl_test/deeprl_dist/atsc_large_grid/'\n",
    "# base_dir = '/Users/tchu/Documents/rl_test/deeprl_dist/atsc_real_net/'\n",
    "# base_dir = '/Users/tchu/Documents/rl_test/deeprl_dist/cacc_catchup/'\n",
    "base_dir = '/Users/tchu/Documents/rl_test/deeprl_dist/cacc_slowdown/'\n",
    "plot_dir = base_dir + 'plots/'\n",
    "if not os.path.exists(plot_dir):\n",
    "    os.mkdir(plot_dir)\n",
    "algo_names = ['IA2C', 'ConseNet', 'FPrint', 'DIAL', 'CommNet', 'NeurComm']\n",
    "algo_labels = ['ia2c', 'ia2c_cu', 'ia2c_fp', 'ma2c_dial', 'ma2c_cnet', 'ma2c_nc']\n",
    "color_cycle = sns.color_palette()\n",
    "TRAIN_STEP = 1e6\n",
    "# TRAIN_STEP = 1e5\n",
    "train_dir = base_dir + 'training/'\n",
    "# moving average window to smoothen curves\n",
    "window = 100\n",
    "test_dir = base_dir + 'execution/'\n",
    "exp_name = base_dir.split('/')[-2]\n",
    "print(exp_name)\n",
    "\n",
    "def millions(x, pos):\n",
    "    return '%1.1fM' % (x*1e-6)\n",
    "\n",
    "def millions1(x, pos):\n",
    "    return '%1.2fM' % (x*1e-6)\n",
    "\n",
    "def thousands(x, pos):\n",
    "    return '%dK' % (x*1e-3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Detailed training curves over alpha levels per algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "IA2C, alpha=0.9, avg R_bar of last 50 episodes: -163.47\n",
      "IA2C, alpha=1.0, avg R_bar of last 50 episodes: -202.42\n",
      "ConseNet, alpha=0.9, avg R_bar of last 50 episodes: -188.64\n",
      "ConseNet, alpha=1.0, avg R_bar of last 50 episodes: -199.54\n",
      "FPrint, alpha=0.9, avg R_bar of last 50 episodes: -169.98\n",
      "FPrint, alpha=1.0, avg R_bar of last 50 episodes: -178.53\n",
      "DIAL, alpha=0.9, avg R_bar of last 50 episodes: -251.94\n",
      "DIAL, alpha=1.0, avg R_bar of last 50 episodes: -214.48\n",
      "CommNet, alpha=0.9, avg R_bar of last 50 episodes: -247.62\n",
      "CommNet, alpha=1.0, avg R_bar of last 50 episodes: -169.78\n",
      "NeurComm, alpha=0.9, avg R_bar of last 50 episodes: -228.49\n",
      "NeurComm, alpha=1.0, avg R_bar of last 50 episodes: -145.93\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "\n",
    "def plot_single_train_curve(algo_i):\n",
    "    data = []\n",
    "    alphas = [0.9, 1.0]\n",
    "    for alpha in alphas:\n",
    "        data_dir = train_dir + ('%s_%.1f.csv' % (algo_labels[algo_i], alpha))\n",
    "        data.append(pd.read_csv(data_dir))\n",
    "    plt.figure()\n",
    "\n",
    "    colors = 'br'\n",
    "    for i, alpha in enumerate(alphas):\n",
    "        df = data[i]\n",
    "        print('%s, alpha=%.1f, avg R_bar of last 50 episodes: %.2f' % (algo_names[algo_i], alpha, np.mean(df.avg_reward.values[-50:])))\n",
    "        # use moving avg to make plot smoother\n",
    "        x_mean = df.avg_reward.rolling(window).mean().values\n",
    "        x_std = df.std_reward.rolling(window).mean().values\n",
    "        plt.plot(df.step.values, x_mean, color=colors[i], linewidth=3, label=r'$\\alpha$=%.1f' % (alpha))\n",
    "        plt.fill_between(df.step.values, x_mean - x_std, x_mean + x_std, facecolor=colors[i], edgecolor='none', alpha=0.1)\n",
    "\n",
    "    plt.xlim([0, TRAIN_STEP])\n",
    "    plt.ylim([-375, -125])\n",
    "\n",
    "    formatter = FuncFormatter(millions)\n",
    "    plt.gca().xaxis.set_major_formatter(formatter)\n",
    "    plt.xticks(fontsize=18)\n",
    "    plt.yticks(fontsize=18)\n",
    "    plt.grid(True, which='both')\n",
    "#     plt.xlabel('Training step', fontsize=20)\n",
    "#     plt.ylabel('Average episode reward', fontsize=20)\n",
    "    plt.legend(loc='lower right', fontsize=18)\n",
    "    plt.tight_layout()\n",
    "    plt.savefig(plot_dir + ('/%s_train.pdf' % algo_labels[algo_i]))\n",
    "    plt.close()\n",
    "    \n",
    "for i in range(6):\n",
    "    plot_single_train_curve(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ablation Study: alpha impact"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ia2c, alpha=0.80, avg R_bar of last k episodes: -529.23\n",
      "ma2c_cnet, alpha=0.80, avg R_bar of last k episodes: -881.84\n",
      "ia2c, alpha=0.90, avg R_bar of last k episodes: -884.92\n",
      "ma2c_cnet, alpha=0.90, avg R_bar of last k episodes: -1124.34\n",
      "ia2c, alpha=1.00, avg R_bar of last k episodes: -2951.67\n",
      "ma2c_cnet, alpha=1.00, avg R_bar of last k episodes: -795.22\n"
     ]
    }
   ],
   "source": [
    "comp_data = []\n",
    "algos = ['ia2c', 'ma2c_cnet']\n",
    "# algos = ['ia2c', 'ma2c_nc', 'ma2c_cnet']\n",
    "alphas = [0.8, 0.9, 1.0]\n",
    "highlights = [0.9, 1.0]\n",
    "highlights = [0.9, 0.9]\n",
    "highlights = [1.0, 1.0]\n",
    "highlights = [0.8, 1.0]\n",
    "alpha_labels = {0.8:'0.8', 0.6:'0.6', 0.9:'0.9', 0.95:'0.95', 1.0:'1.0'}\n",
    "for algo in algos:\n",
    "    data = []\n",
    "    for alpha in alphas:\n",
    "#         if algo == 'ma2c_cnet' and alpha == 0.8:\n",
    "#             data.append(None)\n",
    "#             continue\n",
    "#         if exp_name.startswith('atsc'):\n",
    "        data_dir = train_dir + ('%s_%s.csv' % (algo, alpha_labels[alpha]))\n",
    "        data.append(pd.read_csv(data_dir))\n",
    "#         else:\n",
    "#             cur_dfs = []\n",
    "#             for trial in range(1, 4):\n",
    "#                 if not trial:\n",
    "#                     data_dir = train_dir + ('%s_%s.csv' % (algo, alpha_labels[alpha]))\n",
    "#                 else:\n",
    "#                     data_dir = train_dir + ('%s_%s_%d.csv' % (algo, alpha_labels[alpha], trial))\n",
    "#                 cur_df = pd.read_csv(data_dir)\n",
    "#                 cur_df['trial_id'] = trial\n",
    "#                 cur_dfs.append(cur_df)\n",
    "#             data.append(pd.concat(cur_dfs))\n",
    "    comp_data.append(data)\n",
    "plt.figure(figsize=(8,6))\n",
    "\n",
    "\n",
    "for j, alpha in enumerate(alphas):\n",
    "    for i, algo in enumerate(algos):\n",
    "#         if algo == 'ma2c_cnet' and alpha == 0.8:\n",
    "#             continue\n",
    "        df = comp_data[i][j]\n",
    "#         if exp_name.startswith('atsc'):\n",
    "        x_mean = df.avg_reward.rolling(window).mean().values\n",
    "#             x_std = df.std_reward.rolling(window).mean().values\n",
    "        x_final = np.mean(df.avg_reward.values[-50:])\n",
    "        t = df.step.values\n",
    "#         else:\n",
    "#             xs, final_xs = [], []\n",
    "#             for trial in range(1, 4):\n",
    "#                 x = df[df.trial_id == trial].avg_reward\n",
    "#                 final_xs.append(x.values[-1])\n",
    "#                 xs.append(x)\n",
    "#                 xs.append(x.rolling(window).mean().values)\n",
    "            \n",
    "#             xs = np.array(xs)\n",
    "#             x_final = np.mean(np.array(final_xs))\n",
    "#             x_mean = np.mean(xs, axis=0)\n",
    "# #             x_std = np.std(xs, axis=0)\n",
    "#             t = df[df.trial_id == 1].step.values\n",
    "        print('%s, alpha=%.2f, avg R_bar of last k episodes: %.2f' % (algo, alpha, x_final))\n",
    "        \n",
    "#         print('{},{}: {:.2f}, {:.2f}'.format(alpha, algo, np.nanmean(x_mean), np.nanmean(x_std)))\n",
    "        if algo == 'ia2c':\n",
    "            color = color_cycle[0]\n",
    "        else:\n",
    "            color = color_cycle[1]\n",
    "        if alpha >= 0.95:\n",
    "            sty = '-'    \n",
    "#         elif alpha == 0.9:\n",
    "#             sty = '--'\n",
    "        elif alpha >= 0.9:\n",
    "            sty = '-.'\n",
    "        else:\n",
    "            sty = ':'\n",
    "        if alpha == highlights[i]:\n",
    "            lw = 4\n",
    "            ap = 1\n",
    "        else:\n",
    "            lw = 2\n",
    "            ap = 0.75\n",
    "        plt.plot(t, x_mean, sty, color=color, linewidth=lw, label='%s,'% algo_names[algo_labels.index(algo)] + \\\n",
    "                 alpha_labels[alpha], alpha=ap)\n",
    "#         plt.fill_between(df.step.values, x_mean - x_std, x_mean + x_std, facecolor=color, edgecolor='none', alpha=0.1)\n",
    "plt.xlim([0, TRAIN_STEP])\n",
    "# Grid\n",
    "# plt.ylim([-400, -150])\n",
    "\n",
    "formatter = FuncFormatter(millions)\n",
    "plt.gca().xaxis.set_major_formatter(formatter)\n",
    "plt.xticks(fontsize=18)\n",
    "plt.yticks(fontsize=18)\n",
    "plt.grid(True, which='both')\n",
    "plt.xlabel('Training step', fontsize=18)\n",
    "plt.ylabel('Average episode reward', fontsize=18)\n",
    "# plt.legend(loc='lower right', ncol=3, fontsize=13)\n",
    "# plt.legend(loc='lower left', bbox_to_anchor=(0, 1, 1, 0.2), mode='expand', ncol=3, fontsize=14)\n",
    "plt.tight_layout()\n",
    "plt.savefig(plot_dir + ('/alpha_comp.pdf'))\n",
    "# plt.savefig(plot_dir + ('/alpha_comp2.pdf'))\n",
    "plt.close()\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ablation Study: NeurComm impact"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "comp_data = []\n",
    "algos = ['ma2c_baseline', 'ma2c_concat', 'ma2c_fprint', 'ma2c_nc_1.0']\n",
    "labels = ['Baseline', 'Concat Only', 'FPrint Only', 'NeurComm']\n",
    "for algo in algos:\n",
    "    if algo in ['ma2c_baseline', 'ma2c_nc_1.0', 'ma2c_fprint', 'ma2c_concat']:\n",
    "        data_dir = train_dir + ('%s.csv' % (algo))\n",
    "        comp_data.append(pd.read_csv(data_dir))\n",
    "    else:\n",
    "        comp_data.append(None)\n",
    "\n",
    "plt.figure(figsize=(8,6))\n",
    "colors = [1, 0, 2, 3]\n",
    "stys = [':', '-.', '-.', '-']\n",
    "for i, algo in enumerate(algos):\n",
    "    if i not in [0, 2, 3, 1]:\n",
    "        continue\n",
    "    df = comp_data[i]\n",
    "    x_mean = df.avg_reward.rolling(window).mean().values\n",
    "    x_std = df.std_reward.rolling(window).mean().values\n",
    "    color = color_cycle[colors[i]]\n",
    "    sty = stys[i]\n",
    "    if algo == 'ma2c_nc_1.0':\n",
    "        lw = 4\n",
    "        ap = 1\n",
    "    else:\n",
    "        lw = 3\n",
    "        ap = 0.75\n",
    "    plt.plot(df.step.values, x_mean, sty, color=color, linewidth=lw, alpha=ap, label=labels[i])\n",
    "#         plt.fill_between(df.step.values, x_mean - x_std, x_mean + x_std, facecolor=color, edgecolor='none', alpha=0.1)\n",
    "plt.xlim([0, TRAIN_STEP])\n",
    "# plt.ylim([-365, -135])\n",
    "formatter = FuncFormatter(millions)\n",
    "plt.gca().xaxis.set_major_formatter(formatter)\n",
    "plt.xticks(fontsize=18)\n",
    "plt.yticks(fontsize=18)\n",
    "plt.grid(True, which='both')\n",
    "plt.xlabel('Training step', fontsize=18)\n",
    "plt.ylabel('Average episode reward', fontsize=18)\n",
    "# plt.legend(loc='lower right', ncol=2, fontsize=16)\n",
    "# plt.legend(loc='lower left', bbox_to_anchor=(0, 1, 1, 0.2), mode='expand', ncol=2, fontsize=16)\n",
    "plt.tight_layout()\n",
    "plt.savefig(plot_dir + ('/comm_comp.pdf'))\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training result: plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "IA2C, avg R_bar of last 50 episodes: -529.23\n",
      "FPrint, avg R_bar of last 50 episodes: -682.26\n",
      "ConseNet, avg R_bar of last 50 episodes: -822.98\n",
      "DIAL, avg R_bar of last 50 episodes: -1055.15\n",
      "CommNet, avg R_bar of last 50 episodes: -795.22\n",
      "NeurComm, avg R_bar of last 50 episodes: -894.51\n"
     ]
    }
   ],
   "source": [
    "#'IA2C', 'ConseNet', 'FPrint', 'DIAL', 'CommNet', 'NeurComm'\n",
    "colors = [0, 5, 2, 6, 1, 3]\n",
    "# # ATSC Grid\n",
    "# alphas = [0.9, 0.9, 0.95] + [1.0] * 3\n",
    "# ylim = [-375, -125]\n",
    "# # ATSC Monaco\n",
    "# alphas = [0.9, 0.9, 0.9] + [0.9, 0.9, 1.0]\n",
    "# ylim = [-650, -200]\n",
    "# # CACC Catchup\n",
    "# alphas = [1.0] * 6\n",
    "# ylim = [-2000, 100]\n",
    "# CACC Slowdown\n",
    "alphas = [0.8, 0.8, 0.9] + [1.0, 1.0, 1.0]\n",
    "ylim = [-3000, -300]\n",
    "alpha_labels = {0.8:'0.8', 0.6:'0.6', 0.9:'0.9', 0.95:'0.95', 1.0:'1.0'}\n",
    "comp_data = []\n",
    "for alpha, algo in zip(alphas, algo_labels):\n",
    "#     if algo not in ['ma2c_cnet', 'ma2c_nc', 'ma2c_dial']:\n",
    "#         comp_data.append(None)\n",
    "#         continue\n",
    "    data_dir = train_dir + ('%s_%s.csv' % (algo, alpha_labels[alpha]))\n",
    "    comp_data.append(pd.read_csv(data_dir))\n",
    "    \n",
    "plt.figure(figsize=(8,6))\n",
    "for i in [0, 2, 1, 3, 4, 5]:\n",
    "#     if i not in [4,5, 3]:\n",
    "#         continue\n",
    "    df = comp_data[i]\n",
    "    print('%s, avg R_bar of last 50 episodes: %.2f' % (algo_names[i], np.mean(df.avg_reward.values[-50:])))\n",
    "    algo = algo_names[i]\n",
    "    x_mean = df.avg_reward.rolling(window).mean().values\n",
    "    x_std = df.avg_reward.rolling(window).std().values\n",
    "    if i < 3:\n",
    "        sty = ':'\n",
    "    else:\n",
    "        sty = '-'\n",
    "    if i == 5:\n",
    "        lw = 4\n",
    "        ap = 1\n",
    "    else:\n",
    "        lw = 3\n",
    "        ap = 0.75\n",
    "    plt.plot(df.step.values, x_mean, sty, color=color_cycle[colors[i]], linewidth=lw, alpha=ap, label=algo)\n",
    "    plt.fill_between(df.step.values, x_mean - x_std, x_mean + x_std, facecolor=color_cycle[colors[i]], edgecolor='none', alpha=0.1)\n",
    "plt.xlim([0, TRAIN_STEP])\n",
    "plt.ylim(ylim)\n",
    "formatter = FuncFormatter(millions)\n",
    "plt.gca().xaxis.set_major_formatter(formatter)\n",
    "plt.xticks(fontsize=18)\n",
    "plt.yticks(fontsize=18)\n",
    "plt.grid(True, which='both')\n",
    "plt.xlabel('Training step', fontsize=18)\n",
    "plt.ylabel('Average episode reward', fontsize=18)\n",
    "# plt.legend(loc='lower right',  ncol=2, fontsize=16)\n",
    "# plt.legend(loc='lower left', bbox_to_anchor=(0, 1, 1, 0.2), mode='expand', ncol=3, fontsize=18)\n",
    "plt.tight_layout()\n",
    "plt.savefig(plot_dir + ('/train_comp.pdf'))\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "IA2C, avg R_bar of last episode: -684.44\n",
      "DIAL, avg R_bar of last episode: -619.39\n",
      "ConseNet, avg R_bar of last episode: -665.96\n",
      "CommNet, avg R_bar of last episode: -636.75\n",
      "FPrint, avg R_bar of last episode: -689.25\n",
      "NeurComm, avg R_bar of last episode: -657.48\n",
      "==========FINAL==========\n",
      "IA2C\n",
      "best alphas: [1, 1, 1, 1, 1]\n",
      "best finals: [-530.6652572756196, -748.3210763595446, -600.867879931384, -1179.4013597725545, -362.93944210134117]\n",
      "avg R_bar: -560.70, collision number: 1\n",
      "ConseNet\n",
      "best alphas: [1, 0.95, 0.95, 1, 1]\n",
      "best finals: [-443.44698548647233, -653.1516921207358, -664.7826260344099, -1215.2992371469254, -353.1333441909887]\n",
      "avg R_bar: -528.63, collision number: 1\n",
      "FPrint\n",
      "best alphas: [1, 0.95, 1, 0.95, 0.95]\n",
      "best finals: [-425.2583270354055, -697.7867176713187, -652.7752375520131, -1302.6096361735474, -367.8137209531051]\n",
      "avg R_bar: -535.91, collision number: 1\n",
      "DIAL\n",
      "best alphas: [1, 0.95, 1, 1, 0.95]\n",
      "best finals: [-517.4721102882304, -584.5785640125223, -557.1715036659043, -1083.3631248606907, -354.35186948233735]\n",
      "avg R_bar: -503.39, collision number: 1\n",
      "CommNet\n",
      "best alphas: [1, 1, 0.95, 1, 0.95]\n",
      "best finals: [-571.3063642713117, -672.314628709471, -485.45705265417536, -1056.78054004054, -397.88901137755414]\n",
      "avg R_bar: -531.74, collision number: 1\n",
      "NeurComm\n",
      "best alphas: [0.95, 1, 0.95, 1, 0.95]\n",
      "best finals: [-541.4546460393888, -606.6101646967362, -564.5731683277895, -1104.7103972303141, -470.0583857598008]\n",
      "avg R_bar: -545.67, collision number: 1\n"
     ]
    }
   ],
   "source": [
    "colors = [0, 5, 2, 6, 1, 3]\n",
    "# # CACC Catchup\n",
    "# ylim = [-6000, 0]\n",
    "# # CACC Slowdown\n",
    "# ylim = [-2000, -400]\n",
    "alpha_labels = {0.8:'0.8', 0.6:'0.6', 0.9:'0.9', 0.95:'0.95', 1.0:'1.0'}\n",
    "comp_data = []\n",
    "best_finals = [[-float('inf')] * 5 for _ in range(len(algo_labels))]\n",
    "best_alphas = [[0] * 5 for _ in range(len(algo_labels))]\n",
    "\n",
    "for algo in np.array(algo_labels):\n",
    "    cur_dfs = []\n",
    "    for trial in range(1, 6):\n",
    "        cur_df_alphas = []\n",
    "        for alpha in [0.95, 1]:\n",
    "            if not trial:\n",
    "                data_dir = train_dir + ('%s_%s.csv' % (algo, alpha_labels[alpha]))\n",
    "            else:\n",
    "                data_dir = train_dir + ('%s_%s_%d.csv' % (algo, alpha_labels[alpha], trial))\n",
    "            cur_df_alphas.append(pd.read_csv(data_dir))\n",
    "        x_final_1 = cur_df_alphas[0].avg_reward.values[-1]\n",
    "        x_final_2 = cur_df_alphas[1].avg_reward.values[-1]\n",
    "        if x_final_1 > x_final_2:\n",
    "            best_finals[algo_labels.index(algo)][trial-1] = x_final_1\n",
    "            best_alphas[algo_labels.index(algo)][trial-1] = 0.95\n",
    "            cur_df = cur_df_alphas[0]\n",
    "        else:\n",
    "            best_finals[algo_labels.index(algo)][trial-1] = x_final_2\n",
    "            best_alphas[algo_labels.index(algo)][trial-1] = 1\n",
    "            cur_df = cur_df_alphas[1]\n",
    "        cur_df['trial_id'] = trial\n",
    "        cur_dfs.append(cur_df)\n",
    "    df = pd.concat(cur_dfs)\n",
    "    comp_data.append(df)\n",
    "    \n",
    "plt.figure(figsize=(8,6))\n",
    "for i in [0, 3, 1, 4, 2, 5]:\n",
    "# for i1 in range(3):\n",
    "#     i = [0,4,5][i1]\n",
    "    df = comp_data[i]\n",
    "    xs, final_xs = [], []\n",
    "    for trial in range(1, 6):\n",
    "        x = df[df.trial_id == trial].avg_reward\n",
    "        final_xs.append(x.values[-1])\n",
    "        xs.append(x.rolling(window).mean().values)\n",
    "    xs = np.array(xs)\n",
    "    final_xs = np.array(final_xs)\n",
    "    print('%s, avg R_bar of last episode: %.2f' % (algo_names[i], np.mean(final_xs)))\n",
    "    algo = algo_names[i]\n",
    "    x_mean = np.mean(xs, axis=0)\n",
    "    x_std = np.std(xs, axis=0)\n",
    "    if i < 3:\n",
    "        sty = ':'\n",
    "    else:\n",
    "        sty = '-'\n",
    "    ts = df[df.trial_id == 1].step.values\n",
    "    plt.plot(ts, x_mean, sty, color=color_cycle[colors[i]], linewidth=3, label=algo)\n",
    "    plt.fill_between(ts, x_mean - x_std, x_mean + x_std, facecolor=color_cycle[i], edgecolor='none', alpha=0.1)\n",
    "plt.xlim([0, TRAIN_STEP])\n",
    "plt.ylim(ylim)\n",
    "formatter = FuncFormatter(thousands)\n",
    "plt.gca().xaxis.set_major_formatter(formatter)\n",
    "plt.xticks(fontsize=18)\n",
    "plt.yticks(fontsize=18)\n",
    "plt.grid(True, which='both')\n",
    "plt.xlabel('Training step', fontsize=18)\n",
    "plt.ylabel('Average episode reward', fontsize=18)\n",
    "# plt.legend(loc='lower left', bbox_to_anchor=(0, 1, 1, 0.2), mode='expand', ncol=3, fontsize=18)\n",
    "plt.tight_layout()\n",
    "plt.savefig(plot_dir + ('/train_comp.pdf'))\n",
    "plt.close()\n",
    "\n",
    "print('='*10 + 'FINAL' + '='*10)\n",
    "for i in range(6):\n",
    "    print(algo_names[i])\n",
    "    print('best alphas: {}'.format(best_alphas[i]))\n",
    "    Rs, violations = [], 0\n",
    "    print('best finals: {}'.format(best_finals[i]))\n",
    "    for R in best_finals[i]:\n",
    "        if R > -1000:\n",
    "            Rs.append(R)\n",
    "        else:\n",
    "            violations += 1\n",
    "    print('avg R_bar: {:.2f}, collision number: {:d}'.format(np.mean(Rs), violations))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ATSC execution result: summary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ia2c\n",
      "avg_queue: mean 1.93, min 0.00, max: 2.97\n",
      "avg_speed_mps: mean 2.36, min 0.00, max: 13.58\n",
      "avg_wait_sec: mean 147.45, min 0.00, max: 290.02\n",
      "number_arrived_car: mean 0.22, min 0.00, max: 0.72\n",
      "wait_sec: mean 295, max 3147\n",
      "R_bar: mean -369.66, std 45.53\n",
      "reward: mean -369.66, min -554.66, max: 0.00\n",
      "ia2c_fp\n",
      "avg_queue: mean 1.87, min 0.00, max: 2.78\n",
      "avg_speed_mps: mean 1.26, min 0.00, max: 13.77\n",
      "avg_wait_sec: mean 174.84, min 0.00, max: 286.77\n",
      "number_arrived_car: mean 0.11, min 0.00, max: 0.42\n",
      "wait_sec: mean 428, max 3356\n",
      "R_bar: mean -359.37, std 42.32\n",
      "reward: mean -359.37, min -529.66, max: 0.00\n",
      "ia2c_cu\n",
      "avg_queue: mean 2.74, min 0.00, max: 4.51\n",
      "avg_speed_mps: mean 1.03, min 0.00, max: 13.54\n",
      "avg_wait_sec: mean 187.27, min 0.00, max: 303.03\n",
      "number_arrived_car: mean 0.07, min 0.00, max: 0.38\n",
      "wait_sec: mean 540, max 3387\n",
      "R_bar: mean -528.94, std 37.23\n",
      "reward: mean -528.94, min -860.84, max: 0.00\n",
      "ma2c_nc\n",
      "avg_queue: mean 1.27, min 0.00, max: 1.88\n",
      "avg_speed_mps: mean 0.55, min 0.00, max: 13.35\n",
      "avg_wait_sec: mean 221.10, min 0.00, max: 294.15\n",
      "number_arrived_car: mean 0.06, min 0.00, max: 0.36\n",
      "wait_sec: mean 569, max 3449\n",
      "R_bar: mean -226.33, std 8.94\n",
      "reward: mean -226.33, min -346.70, max: 0.00\n",
      "ma2c_cnet\n",
      "avg_queue: mean 1.56, min 0.00, max: 2.46\n",
      "avg_speed_mps: mean 0.61, min 0.00, max: 13.58\n",
      "avg_wait_sec: mean 236.53, min 0.00, max: 355.16\n",
      "number_arrived_car: mean 0.02, min 0.00, max: 0.26\n",
      "wait_sec: mean 847, max 3410\n",
      "R_bar: mean -262.97, std 24.45\n",
      "reward: mean -262.97, min -426.12, max: 0.00\n",
      "ma2c_dial\n",
      "avg_queue: mean 1.88, min 0.00, max: 2.98\n",
      "avg_speed_mps: mean 0.94, min 0.00, max: 13.62\n",
      "avg_wait_sec: mean 231.29, min 0.00, max: 356.25\n",
      "number_arrived_car: mean 0.03, min 0.00, max: 0.32\n",
      "wait_sec: mean 506, max 3454\n",
      "R_bar: mean -339.43, std 33.33\n",
      "reward: mean -339.43, min -546.98, max: 0.00\n"
     ]
    }
   ],
   "source": [
    "# # ATSC Grid\n",
    "# prefix = 'large_grid'\n",
    "# # ATSC Monaco\n",
    "prefix = 'atsc_real_net'\n",
    "table_names = ['traffic', 'trip', 'control']\n",
    "\n",
    "\n",
    "def load_summarize_data():\n",
    "    data = {}\n",
    "    for algo in ['ia2c', 'ia2c_fp', 'ia2c_cu', 'ma2c_nc', 'ma2c_cnet', 'ma2c_dial']:\n",
    "#     for algo in ['ma2c_nc', 'ma2c_cnet', 'ma2c_dial']:\n",
    "        print(algo)\n",
    "        data[algo] = {}\n",
    "        for tab in table_names:\n",
    "            data_dir = test_dir + ('%s_%s_%s.csv' % (prefix, algo, tab))\n",
    "            df = pd.read_csv(data_dir)\n",
    "            if tab == 'control':\n",
    "                col_names = ['reward']\n",
    "            elif tab == 'traffic':\n",
    "                col_names = ['avg_queue', 'avg_speed_mps', 'avg_wait_sec', 'number_arrived_car']\n",
    "            else:\n",
    "                col_names = ['wait_sec']\n",
    "            print_metrics(df, col_names, tab)\n",
    "            data[algo][tab] = df\n",
    "    return data  \n",
    "            \n",
    "def print_metrics(df, col_names, tab_name):\n",
    "    if tab_name == 'control':\n",
    "        rewards = df.groupby(['episode']).reward.mean()\n",
    "        mean_reward = np.mean(rewards.values)\n",
    "        std_reward = np.std(rewards.values)\n",
    "        print('R_bar: mean %.2f, std %.2f' % (mean_reward, std_reward))\n",
    "    episodes = list(df.episode.unique())\n",
    "    num_episode = len(episodes)\n",
    "    for name in col_names:\n",
    "        if tab_name != 'trip':\n",
    "            res = df.loc[df.episode == episodes[0], name].values\n",
    "            for episode in episodes[1:]:\n",
    "                res += df.loc[df.episode == episode, name].values\n",
    "            res = res / num_episode\n",
    "            print('%s: mean %.2f, min %.2f, max: %.2f' % (name, np.mean(res), np.min(res), np.max(res)))\n",
    "        else:\n",
    "            res = []\n",
    "            for episode in episodes:\n",
    "                res += list(df.loc[df.episode == episode, name].values)\n",
    "            print('%s: mean %d, max %d' % (name, np.mean(res), np.max(res)))\n",
    "            \n",
    "data = load_summarize_data()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ATSC execution result: plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "EPISODE_SEC = 3600\n",
    "colors = [0, 5, 2, 6, 1, 3]\n",
    "def plot_comp_series(algos, col_name, tab_name, ylabel, window=60):\n",
    "    plt.figure(figsize=(8,6))\n",
    "    for algo in algos:\n",
    "        df = data[algo][tab_name]\n",
    "        plot_series(df, algo, col_name, tab_name, window)\n",
    "    plt.xticks(fontsize=18)\n",
    "    plt.yticks(fontsize=18)\n",
    "    plt.xlim([0, 3600])\n",
    "    if col_name == 'avg_queue':\n",
    "        plt.ylim([0, 3.5])\n",
    "    else:\n",
    "        plt.ylim([0, 700])\n",
    "    plt.grid(True, which='both')\n",
    "    plt.xlabel('Simulation time (sec)', fontsize=18)\n",
    "    plt.ylabel(ylabel, fontsize=18)\n",
    "#     plt.legend(loc='upper left', fontsize=18)\n",
    "    plt.tight_layout()\n",
    "    plt.savefig(plot_dir + ('/%s_comp.pdf' % col_name))\n",
    "    plt.close()\n",
    "    \n",
    "def plot_series(df, algo, col_name, tab_name, window):\n",
    "    episodes = list(df.episode.unique())\n",
    "    num_episode = len(episodes)\n",
    "    x = np.zeros((num_episode, EPISODE_SEC))\n",
    "    for i, episode in enumerate(episodes):\n",
    "        t_col = 'arrival_sec' if  tab_name == 'trip' else 'time_sec' \n",
    "        cur_df = df[df.episode == episode].sort_values(t_col)\n",
    "        if window > 0:\n",
    "            cur_x = cur_df[col_name].rolling(window, min_periods=1).mean().values\n",
    "        else:\n",
    "            cur_x = cur_df[col_name].values    \n",
    "        x[i] = cur_x\n",
    "    x_mean = np.mean(x, axis=0)\n",
    "    x_std = np.std(x, axis=0)\n",
    "    t = np.arange(1, EPISODE_SEC + 1)\n",
    "    algo_i = algo_labels.index(algo)\n",
    "#     print(algo_i)\n",
    "    color = color_cycle[colors[algo_i]]\n",
    "    if algo == 'ma2c_nc':\n",
    "        lw = 4\n",
    "        ap = 1\n",
    "    else:\n",
    "        lw = 3\n",
    "        ap = 0.75\n",
    "    plt.plot(t, x_mean, color=color, linewidth=lw, alpha=ap, label=algo_names[algo_i])\n",
    "    x_lo = x_mean - x_std\n",
    "    x_lo = np.maximum(x_lo, 0)\n",
    "    x_hi = x_mean + x_std\n",
    "    plt.fill_between(t, x_lo, x_hi, facecolor=color, edgecolor='none', alpha=0.1)\n",
    "\n",
    "cur_algos = ['ma2c_nc', 'ma2c_cnet', 'ia2c', 'ia2c_fp']\n",
    "plot_comp_series(cur_algos, 'avg_queue', 'traffic', 'Average queue length (veh)')\n",
    "plot_comp_series(cur_algos, 'avg_wait_sec', 'traffic', 'Average intersection delay (s/veh)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### CACC execution result: summary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 337,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ia2c\n",
      "avg_headway_m: mean 0.00, std: 0.00\n",
      "avg_speed_mps: mean 0.00, std: 0.00\n",
      "avg_accel_mps2: mean 0.00, std: 0.00\n",
      "VIOLIATION: 50\n",
      "R_bar: mean -2209.37\n",
      "ia2c_fp\n",
      "avg_headway_m: mean 18.21, std: 2.40\n",
      "avg_speed_mps: mean 15.47, std: 3.37\n",
      "avg_accel_mps2: mean 0.56, std: 0.48\n",
      "VIOLIATION: 8\n",
      "R_bar: mean -697.85\n",
      "ia2c_cu\n",
      "avg_headway_m: mean 11.60, std: 0.49\n",
      "avg_speed_mps: mean 8.59, std: 1.19\n",
      "avg_accel_mps2: mean 0.23, std: 0.28\n",
      "VIOLIATION: 23\n",
      "R_bar: mean -1038.09\n",
      "ma2c_nc\n",
      "avg_headway_m: mean 15.84, std: 2.10\n",
      "avg_speed_mps: mean 13.43, std: 2.77\n",
      "avg_accel_mps2: mean 0.50, std: 0.27\n",
      "VIOLIATION: 13\n",
      "R_bar: mean -934.73\n",
      "ma2c_cnet\n",
      "avg_headway_m: mean 16.24, std: 2.16\n",
      "avg_speed_mps: mean 13.82, std: 2.88\n",
      "avg_accel_mps2: mean 0.50, std: 0.29\n",
      "VIOLIATION: 12\n",
      "R_bar: mean -950.84\n",
      "ma2c_dial\n",
      "avg_headway_m: mean 14.42, std: 1.70\n",
      "avg_speed_mps: mean 12.28, std: 2.49\n",
      "avg_accel_mps2: mean 0.45, std: 0.21\n",
      "VIOLIATION: 16\n",
      "R_bar: mean -1111.68\n"
     ]
    }
   ],
   "source": [
    "\n",
    "prefix = exp_name.split('_')[1]\n",
    "table_names = ['traffic', 'control']\n",
    "\n",
    "def load_summarize_data():\n",
    "    data = {}\n",
    "    for algo in ['ia2c', 'ia2c_fp', 'ia2c_cu', 'ma2c_nc', 'ma2c_cnet', 'ma2c_dial']:\n",
    "#     for algo in ['ma2c_nc', 'ma2c_cnet']:\n",
    "        print(algo)\n",
    "        data[algo] = {}\n",
    "        for tab in table_names:\n",
    "            data_dir = test_dir + ('%s_%s_%s.csv' % (prefix, algo, tab))\n",
    "            df = pd.read_csv(data_dir)\n",
    "            if tab == 'control':\n",
    "                col_names = ['reward']\n",
    "            elif tab == 'traffic':\n",
    "                df['avg_headway_m'] = 0\n",
    "                df['avg_speed_mps'] = 0\n",
    "                df['avg_accel_mps2'] = 0\n",
    "                for i in range(1, 9):\n",
    "                    df['avg_headway_m'] += df['headway_{:d}_m'.format(i)]\n",
    "                    df['avg_speed_mps'] += df['velocity_{:d}_mps'.format(i)]\n",
    "                    df['avg_accel_mps2'] += abs(df['accel_{:d}_mps2'.format(i)])\n",
    "                df['avg_headway_m'] /= 8\n",
    "                df['avg_speed_mps'] /= 8\n",
    "                df['avg_accel_mps2'] /= 8\n",
    "                col_names = ['avg_headway_m', 'avg_speed_mps', 'avg_accel_mps2']\n",
    "            print_metrics(df, col_names, tab)\n",
    "            data[algo][tab] = df\n",
    "    return data  \n",
    "            \n",
    "def print_metrics(df, col_names, tab_name):\n",
    "    if tab_name == 'control':\n",
    "        rewards = df.groupby(['episode']).reward.mean()\n",
    "        mean_reward = np.mean(rewards.values)\n",
    "        print('R_bar: mean %.2f' % (mean_reward))\n",
    "        return\n",
    "    episodes = list(df.episode.unique())\n",
    "    num_episode = len(episodes)\n",
    "    num_violation = 0\n",
    "    for k, name in enumerate(col_names):\n",
    "        res = np.zeros(601)\n",
    "        for episode in episodes:\n",
    "            cur_res = df.loc[df.episode == episode, name].values\n",
    "            if len(cur_res) == 601:\n",
    "                res += cur_res\n",
    "            elif not k:\n",
    "                num_violation += 1\n",
    "        res = res / num_episode\n",
    "        print('%s: mean %.2f, std: %.2f' % (name, np.mean(res), np.std(res)))\n",
    "    print('VIOLIATION: %d' % num_violation)\n",
    "            \n",
    "data = load_summarize_data()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### CACC execution result: plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 338,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_comp_series(algos, col_name, tab_name, ylabel, window=-1):\n",
    "    plt.figure(figsize=(8,6))\n",
    "#     i_episode = -1\n",
    "    for algo in algos:\n",
    "        df = data[algo][tab_name]\n",
    "#         if i_episode == -1:\n",
    "#             i_episode = np.argmax(data[algo]['control'].groupby('episode').reward.mean().values)+1\n",
    "        df = df[df.episode == 1]\n",
    "        plot_series(df, algo, col_name, tab_name, window)\n",
    "    plt.xticks(fontsize=18)\n",
    "    plt.yticks(fontsize=18)\n",
    "    plt.xlim([0, 60])\n",
    "    plt.grid(True, which='both')\n",
    "    plt.xlabel('Simulation time (sec)', fontsize=18)\n",
    "    plt.ylabel(ylabel, fontsize=18)\n",
    "    plt.legend(loc='upper right', fontsize=18)\n",
    "    plt.tight_layout()\n",
    "    plt.savefig(plot_dir + ('/%s_comp.pdf' % col_name))\n",
    "    plt.close()\n",
    "    \n",
    "def plot_series(df, algo, col_name, tab_name, window):\n",
    "    algo_i = algo_labels.index(algo)\n",
    "    color = color_cycle[colors[algo_i]]\n",
    "    t = df.time_sec.values\n",
    "    for veh_i in [1, 8]:\n",
    "        if col_name == 'headway':\n",
    "            cur_col_name = 'headway_{:d}_m'.format(veh_i)\n",
    "        else:\n",
    "            cur_col_name = 'velocity_{:d}_mps'.format(veh_i)\n",
    "        if window > 0:\n",
    "            cur_x = df[cur_col_name].rolling(window, min_periods=1).mean().values\n",
    "        else:\n",
    "            cur_x = df[cur_col_name].values    \n",
    "        style = '-' if veh_i == 8 else ':'\n",
    "        plt.plot(t, cur_x, color=color, linewidth=3, linestyle=style,\n",
    "                 label='{}, veh# {:d}'.format(algo_names[algo_i], veh_i))\n",
    "# Catchup\n",
    "cur_algos = ['ma2c_nc', 'ia2c_fp']\n",
    "# # Slowdown\n",
    "# cur_algos = ['ma2c_nc', 'ia2c']\n",
    "plot_comp_series(cur_algos, 'headway', 'traffic', 'Vehicle headway (m)')\n",
    "plot_comp_series(cur_algos, 'velocity', 'traffic', 'Vehicle velocity (m/s)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "302\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(30, 15-0.1, -2.5*0.02)\n",
    "print(len(a))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([30.  , 29.95, 29.9 , 29.85, 29.8 , 29.75, 29.7 , 29.65, 29.6 ,\n",
       "       29.55, 29.5 , 29.45, 29.4 , 29.35, 29.3 , 29.25, 29.2 , 29.15,\n",
       "       29.1 , 29.05, 29.  , 28.95, 28.9 , 28.85, 28.8 , 28.75, 28.7 ,\n",
       "       28.65, 28.6 , 28.55, 28.5 , 28.45, 28.4 , 28.35, 28.3 , 28.25,\n",
       "       28.2 , 28.15, 28.1 , 28.05, 28.  , 27.95, 27.9 , 27.85, 27.8 ,\n",
       "       27.75, 27.7 , 27.65, 27.6 , 27.55, 27.5 , 27.45, 27.4 , 27.35,\n",
       "       27.3 , 27.25, 27.2 , 27.15, 27.1 , 27.05, 27.  , 26.95, 26.9 ,\n",
       "       26.85, 26.8 , 26.75, 26.7 , 26.65, 26.6 , 26.55, 26.5 , 26.45,\n",
       "       26.4 , 26.35, 26.3 , 26.25, 26.2 , 26.15, 26.1 , 26.05, 26.  ,\n",
       "       25.95, 25.9 , 25.85, 25.8 , 25.75, 25.7 , 25.65, 25.6 , 25.55,\n",
       "       25.5 , 25.45, 25.4 , 25.35, 25.3 , 25.25, 25.2 , 25.15, 25.1 ,\n",
       "       25.05, 25.  , 24.95, 24.9 , 24.85, 24.8 , 24.75, 24.7 , 24.65,\n",
       "       24.6 , 24.55, 24.5 , 24.45, 24.4 , 24.35, 24.3 , 24.25, 24.2 ,\n",
       "       24.15, 24.1 , 24.05, 24.  , 23.95, 23.9 , 23.85, 23.8 , 23.75,\n",
       "       23.7 , 23.65, 23.6 , 23.55, 23.5 , 23.45, 23.4 , 23.35, 23.3 ,\n",
       "       23.25, 23.2 , 23.15, 23.1 , 23.05, 23.  , 22.95, 22.9 , 22.85,\n",
       "       22.8 , 22.75, 22.7 , 22.65, 22.6 , 22.55, 22.5 , 22.45, 22.4 ,\n",
       "       22.35, 22.3 , 22.25, 22.2 , 22.15, 22.1 , 22.05, 22.  , 21.95,\n",
       "       21.9 , 21.85, 21.8 , 21.75, 21.7 , 21.65, 21.6 , 21.55, 21.5 ,\n",
       "       21.45, 21.4 , 21.35, 21.3 , 21.25, 21.2 , 21.15, 21.1 , 21.05,\n",
       "       21.  , 20.95, 20.9 , 20.85, 20.8 , 20.75, 20.7 , 20.65, 20.6 ,\n",
       "       20.55, 20.5 , 20.45, 20.4 , 20.35, 20.3 , 20.25, 20.2 , 20.15,\n",
       "       20.1 , 20.05, 20.  , 19.95, 19.9 , 19.85, 19.8 , 19.75, 19.7 ,\n",
       "       19.65, 19.6 , 19.55, 19.5 , 19.45, 19.4 , 19.35, 19.3 , 19.25,\n",
       "       19.2 , 19.15, 19.1 , 19.05, 19.  , 18.95, 18.9 , 18.85, 18.8 ,\n",
       "       18.75, 18.7 , 18.65, 18.6 , 18.55, 18.5 , 18.45, 18.4 , 18.35,\n",
       "       18.3 , 18.25, 18.2 , 18.15, 18.1 , 18.05, 18.  , 17.95, 17.9 ,\n",
       "       17.85, 17.8 , 17.75, 17.7 , 17.65, 17.6 , 17.55, 17.5 , 17.45,\n",
       "       17.4 , 17.35, 17.3 , 17.25, 17.2 , 17.15, 17.1 , 17.05, 17.  ,\n",
       "       16.95, 16.9 , 16.85, 16.8 , 16.75, 16.7 , 16.65, 16.6 , 16.55,\n",
       "       16.5 , 16.45, 16.4 , 16.35, 16.3 , 16.25, 16.2 , 16.15, 16.1 ,\n",
       "       16.05, 16.  , 15.95, 15.9 , 15.85, 15.8 , 15.75, 15.7 , 15.65,\n",
       "       15.6 , 15.55, 15.5 , 15.45, 15.4 , 15.35, 15.3 , 15.25, 15.2 ,\n",
       "       15.15, 15.1 , 15.05, 15.  , 14.95])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}