visualization_metrics.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib notebook \n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from pandas.plotting import scatter_matrix\n",
    "import pandas as pd\n",
    "import visualization_metrics as v\n",
    "import seaborn as sns\n",
    "RP = v.RegrParams\n",
    "\n",
    "params = {\n",
    "    'plot': True,\n",
    "    'undersample':  not True,\n",
    "    'oversample': False \n",
    "}\n",
    "suffix_file = \"_averages\"\n",
    "dict_vals = {}\n",
    "dict_vals_new = {}\n",
    "dict_groups = {}\n",
    "run_all = True \n",
    "run_some = False\n",
    "run_half = not True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "\n",
    "if False:\n",
    "    rp = RP()\n",
    "    #rp.is_overhead_node_linear = False\n",
    "    #rp.is_latency_overhead_vertical = True\n",
    "    #rp.is_latency_overhead_linear = False\n",
    "    params['regr_params'] = rp\n",
    "    val, val_new, groups = v.main(\"gen\" + suffix_file + \".csv\", **params)\n",
    "    dict_vals['double_rr'] = val\n",
    "    dict_vals_new['double_rr'] = val_new\n",
    "    dict_groups['double_rr'] = groups"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# All receivers\n",
    "## Round-robin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "if run_all:\n",
    "    rp = RP()\n",
    "    rp.is_overhead_node_linear = False\n",
    "    rp.is_latency_overhead_vertical = True\n",
    "    rp.is_latency_overhead_linear = False\n",
    "    params['regr_params'] = rp\n",
    "    val, val_new, groups = v.main(\"generated/aggregated/rr_20_nodes_4_depth_all_receivers_gen\" + suffix_file + \".csv\", **params)\n",
    "    dict_vals['rr'] = val\n",
    "    dict_vals_new['rr'] = val_new\n",
    "    dict_groups['rr'] = groups"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Double round-robin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "if run_all:\n",
    "    rp = RP()\n",
    "    rp.is_overhead_node_linear = False\n",
    "    rp.is_latency_overhead_vertical = True\n",
    "    rp.is_latency_overhead_linear = False\n",
    "    params['regr_params'] = rp\n",
    "    val, val_new, groups = v.main(\"generated/aggregated/double_rr_20_nodes_4_depth_all_receivers_gen\" + suffix_file + \".csv\", **params)\n",
    "    dict_vals['double_rr'] = val\n",
    "    dict_vals_new['double_rr'] = val_new\n",
    "    dict_groups['double_rr'] = groups"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Triple round-robin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "if run_all:\n",
    "    rp = RP()\n",
    "    rp.is_overhead_node_linear = False\n",
    "    rp.is_latency_overhead_vertical = True\n",
    "    rp.is_latency_overhead_linear = False\n",
    "    params['regr_params'] = rp\n",
    "    val, val_new, groups = v.main(\"generated/aggregated/triple_rr_20_nodes_4_depth_all_receivers_gen\" + suffix_file + \".csv\", **params)\n",
    "    dict_vals['triple_rr'] = val\n",
    "    dict_vals_new['triple_rr'] = val_new\n",
    "    dict_groups['triple_rr'] = groups"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Maximal Overhead"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "if run_all:\n",
    "    rp = RP()\n",
    "    rp.is_latency_node_linear = False\n",
    "    rp.is_latency_overhead_linear = False\n",
    "    params['regr_params'] = rp\n",
    "    val, val_new, groups = v.main(\"generated/aggregated/overhead_10-20_nodes_4_depth_all_receivers_gen\" + suffix_file + \".csv\", **params)\n",
    "    dict_vals['overhead'] = val\n",
    "    dict_vals_new['overhead'] = val_new\n",
    "    dict_groups['overhead'] = groups"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arbitrary "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# run this if you want to show non filtered arbitrary runs\n",
    "if run_all and False:\n",
    "    rp = RP()\n",
    "    params['regr_params'] = rp\n",
    "    val, val_new, groups = v.main(\"generated/aggregated/arbitrary_20_nodes_4_depth_all_receivers_gen\"+suffix_file+\".csv\", **params)\n",
    "    dict_vals['arbitrary'] = val\n",
    "    dict_vals_new['arbitrary'] = val_new\n",
    "    dict_groups['arbitrary'] = groups"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# run this if you want to show filtered arbitrary runs\n",
    "if run_all:\n",
    "    rp = RP()\n",
    "    params['regr_params'] = rp\n",
    "    params['filter_overhead'] = True\n",
    "    val, val_new, groups = v.main(\"generated/aggregated/arbitrary_filtered_20_nodes_4_depth_all_receivers_gen\"+suffix_file+\".csv\", **params)\n",
    "    del params['filter_overhead']\n",
    "    dict_vals['arbitrary'] = val\n",
    "    dict_vals_new['arbitrary'] = val_new\n",
    "    dict_groups['arbitrary'] = groups"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Some receivers\n",
    "## Round-robin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "if run_some:\n",
    "    rp = RP()\n",
    "    params['regr_params'] = rp\n",
    "    val, val_new, groups = v.main(\"generated/aggregated/rr_20_nodes_4_depth_some_receivers_gen\" + suffix_file + \".csv\", **params)\n",
    "    dict_vals['rr_some'] = val\n",
    "    dict_vals_new['rr_some'] = val_new\n",
    "    dict_groups['rr_some'] = groups"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Double round-robin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "if run_some:\n",
    "    rp = RP()\n",
    "    params['regr_params'] = rp\n",
    "    val, val_new, groups = v.main(\"generated/aggregated/double_rr_20_nodes_4_depth_some_receivers_gen\" + suffix_file + \".csv\", **params)\n",
    "    dict_vals['double_rr_some'] = val\n",
    "    dict_vals_new['double_rr_some'] = val_new\n",
    "    dict_groups['double_rr_some'] = groups"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Maximal Overhead "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "if run_some:\n",
    "    rp = RP()\n",
    "    params['regr_params'] = rp\n",
    "    val, val_new, groups = v.main(\"generated/aggregated/overhead_10-20_nodes_4_depth_some_receivers_gen\" + suffix_file + \".csv\", **params)\n",
    "    dict_vals['overhead_some'] = val\n",
    "    dict_vals_new['overhead_some'] = val_new\n",
    "    dict_groups['overhead_some'] = groups"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Half receivers\n",
    "## Round-robin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "if run_half:\n",
    "    rp = RP()\n",
    "    rp.is_overhead_node_linear = False\n",
    "    rp.is_latency_overhead_vertical = True\n",
    "    rp.is_latency_overhead_linear = False\n",
    "    params['regr_params'] = rp\n",
    "    val, val_new, groups = v.main(\"generated/aggregated/rr_20_nodes_4_depth_half_receivers_gen\" + suffix_file + \".csv\", **params)\n",
    "    dict_vals['rr_half'] = val\n",
    "    dict_vals_new['rr_half'] = val_new\n",
    "    dict_groups['rr_half'] = groups"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Double round-robin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "if run_half:\n",
    "    rp = RP()\n",
    "    rp.is_overhead_node_linear = False\n",
    "    rp.is_latency_overhead_vertical = True\n",
    "    rp.is_latency_overhead_linear = False\n",
    "    params['regr_params'] = rp\n",
    "    val, val_new, groups = v.main(\"generated/aggregated/double_rr_20_nodes_4_depth_half_receivers_gen\" + suffix_file + \".csv\", **params)\n",
    "    dict_vals['double_rr_half'] = val\n",
    "    dict_vals_new['double_rr_half'] = val_new\n",
    "    dict_groups['double_rr_half'] = groups"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Triple round-robin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "if run_half:\n",
    "    rp = RP()\n",
    "    rp.is_overhead_node_linear = False\n",
    "    rp.is_latency_overhead_vertical = True\n",
    "    rp.is_latency_overhead_linear = False\n",
    "    params['regr_params'] = rp\n",
    "    val, val_new, groups = v.main(\"generated/aggregated/triple_rr_20_nodes_4_depth_half_receivers_gen\" + suffix_file + \".csv\", **params)\n",
    "    dict_vals['triple_rr_half'] = val\n",
    "    dict_vals_new['triple_rr_half'] = val_new\n",
    "    dict_groups['triple_rr_half'] = groups"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Maximal Overhead"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "if run_half:\n",
    "    rp = RP()\n",
    "    rp.is_latency_node_linear = False\n",
    "    rp.is_latency_overhead_linear = False\n",
    "    params['regr_params'] = rp\n",
    "    val, val_new, groups = v.main(\"generated/aggregated/overhead_20_nodes_4_depth_half_receivers_gen\" + suffix_file + \".csv\", **params)\n",
    "    dict_vals['overhead_half'] = val\n",
    "    dict_vals_new['overhead_half'] = val_new\n",
    "    dict_groups['overhead_half'] = groups"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arbitrary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "if run_half:\n",
    "    rp = RP()\n",
    "    params['regr_params'] = rp\n",
    "    val, val_new, groups = v.main(\"generated/aggregated/arbitrary_20_nodes_4_depth_half_receivers_gen\"+suffix_file+\".csv\", **params)\n",
    "    dict_vals['arbitrary_half'] = val\n",
    "    dict_vals_new['arbitrary_half'] = val_new\n",
    "    dict_groups['arbitrary_half'] = groups"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pretty(ugly_name):\n",
    "    pretty_out = ''\n",
    "    pretties = {\n",
    "        'rr': \"Round-robin\",\n",
    "        'overhead': \"Maximal\\n Overhead\",\n",
    "        'arbitrary': \"Arbitrary\"\n",
    "    }\n",
    "    for k, v in pretties.items():\n",
    "        if k in ugly_name:\n",
    "            pretty_out += v\n",
    "    if 'filtered' in ugly_name:\n",
    "        pretty_out += \"Filtered\"\n",
    "    if 'rng' in ugly_name:\n",
    "        pretty_out += \" (Some)\"\n",
    "    elif 'half' in ugly_name:\n",
    "        pretty_out += ' (Half)'\n",
    "    if 'double' in ugly_name:\n",
    "        pretty_out = \"Double\\n\" + pretty_out\n",
    "    elif 'triple' in ugly_name:\n",
    "        pretty_out = \"Triple\\n\" + pretty_out\n",
    "    return pretty_out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot(dict_vals, filename):\n",
    "    keys = sorted([k for k in dict_vals.keys() if k != 'rnd'])\n",
    "    r = np.arange(len(keys))\n",
    "    offset = 0.2\n",
    "    l = [dict_vals[k] for k in keys]\n",
    "    x, y, z, e = zip(*l)\n",
    "    import seaborn as sns\n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(111)\n",
    "    ax.bar(r-offset, x,width=offset,color='b',align='center')\n",
    "    ax.bar(r,        y,width=offset,color='g',align='center')\n",
    "    ax.bar(r+offset, z,width=offset,color='r',align='center')\n",
    "    ax.bar(r+2*offset, e,width=offset,color='k',align='center')\n",
    "    ax.set_xlabel(\"Strategy\")\n",
    "    ax.set_ylabel(\"Score\")\n",
    "    ax.set_title(\"Strategies scores\")\n",
    "    ax.set_xticks(r)\n",
    "    plt.xticks(rotation=45)\n",
    "    ax.set_xticklabels([pretty(k) for k in keys])\n",
    "    ax.legend([\"Nb. nodes\", \"Latency\", \"Overhead\", \"RMSE\"])\n",
    "    fig.tight_layout()\n",
    "    plt.show()\n",
    "    save_path = \"./generated/imgs/\"\n",
    "    plt.savefig(save_path + filename + \".png\", dpi=600)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "raw_dict_vals = dict_vals\n",
    "raw_dict_vals_new = dict_vals_new\n",
    "raw_dict_groups = dict_groups\n",
    "\n",
    "# TODO: sanity check of the 6 next lines\n",
    "# should be combined into 3 lines with 'and \"half\" not in k' at the end\n",
    "# also should create dict_NAMEHERE_some and dict_NAMEHERE_half\n",
    "# for the end of the analysis\n",
    "\n",
    "dict_vals = {k:v for (k, v) in raw_dict_vals.items() if \"some\" not in k}\n",
    "dict_vals_new = {k:v for (k, v) in raw_dict_vals_new.items() if \"some\" not in k}\n",
    "dict_groups = {k:v for (k, v) in raw_dict_groups.items() if \"some\" not in k}\n",
    "\n",
    "dict_vals = {k:v for (k, v) in dict_vals.items() if \"half\" not in k}\n",
    "dict_vals_new = {k:v for (k, v) in dict_vals_new.items() if \"half\" not in k}\n",
    "dict_groups = {k:v for (k, v) in dict_groups.items() if \"half\" not in k}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Strategies comparison graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def do_stuff(ax, name, grouped_df):\n",
    "    #print(grouped_df.mean())\n",
    "    mean = grouped_df.mean()\n",
    "    latency = mean['latency'].values\n",
    "    overhead = mean['overhead'].values\n",
    "    std = grouped_df.std()\n",
    "    std_latency = std['latency'].values\n",
    "    std_overhead = std['overhead'].values\n",
    "    zipped = zip(std_latency, std_overhead)\n",
    "    radii = [(2 + l + o)*3 for l,o in zipped]\n",
    "    # an arrow will be at the end of the plot so no need for a dot\n",
    "    radii[-1] = 0\n",
    "    p = ax.plot(latency, overhead)\n",
    "    last_color = p[-1].get_color()\n",
    "    ax.scatter(latency, overhead, s=radii)\n",
    "    x = latency[-2]\n",
    "    y = overhead[-2]\n",
    "    dx = latency[-1] - x\n",
    "    dy = overhead[-1] - y\n",
    "    \n",
    "    # if the last items in latency and overhead overlap, dx = dy = 0\n",
    "    # and the arrow points upwards for no reason\n",
    "    # get the previous item in the list to have a better estimate\n",
    "    # if all items overlap then we have an upwards arrow and don't care\n",
    "    i = -3\n",
    "    while dy == 0 and dx == 0 and -i < len(latency):\n",
    "        x = latency[i]\n",
    "        y = overhead[i]\n",
    "        dx = latency[-1] - x\n",
    "        dy = overhead[-1] - y\n",
    "        i -= 1\n",
    "    plt.arrow(x, y, dx, dy, width=0, head_length=.6, head_width=.5, color=last_color)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "ax = plt.subplot(111)\n",
    "for name in dict_groups.keys():\n",
    "    do_stuff(ax, name, dict_groups[name])\n",
    "plt.title(\"Evolution of Latency/Overhead across Number of Nodes\")\n",
    "plt.xlabel(\"Latency\")\n",
    "plt.ylabel(\"Overhead\")\n",
    "box = ax.get_position()\n",
    "ax.set_position([box.x0, box.y0, box.width * 0.8, box.height])\n",
    "ax.legend([pretty(n) for n in dict_groups.keys()], loc='center left', bbox_to_anchor=(1,0.5))\n",
    "plt.savefig(\"./generated/imgs/tendency_20_nodes_4_depth_all_receivers.png\", dpi=600)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model fitting All receivers\n",
    "## Basic model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "if run_all:\n",
    "    print(\"strategy nb_nodes latency overhead rmse\")\n",
    "    for k, (a, b, c, e) in dict_vals.items():\n",
    "        print(k, a, b, c, e)\n",
    "        #print(k, c)\n",
    "    plot(dict_vals, \"final_plot_basic_model\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  New model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if run_all:\n",
    "    print(\"strategy nb_nodes latency overhead rmse\")\n",
    "    for k, (a, b, c, e) in dict_vals_new.items():\n",
    "        print(k, a, b, c, e)\n",
    "        #print(k, c)\n",
    "    plot(dict_vals_new, \"final_plot_new_model\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def norm(t, max_t):\n",
    "    new_t = ()\n",
    "    return tuple(item/m for item, m in zip(t, max_t))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Normalized model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if run_all:\n",
    "    l = [v for v in dict_vals.values()]\n",
    "    x, y, z, e = zip(*l)\n",
    "    x = max(x)\n",
    "    y = max(y)\n",
    "    z = max(z)\n",
    "    e = max(e)\n",
    "    t = (x,y,z,e)\n",
    "    dict_vals_norm = {k: norm(v, t) for k, v in dict_vals.items()}\n",
    "    plot(dict_vals_norm, \"final_plot_norm_model\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Normalized new model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if run_all:\n",
    "    l = [v for v in dict_vals_new.values()]\n",
    "    x, y, z, e = zip(*l)\n",
    "    x = max(x)\n",
    "    y = max(y)\n",
    "    z = max(z)\n",
    "    e = max(e)\n",
    "    t = (x,y,z,e)\n",
    "    dict_vals_new_norm = {k: norm(v, t) for k, v in dict_vals_new.items()}\n",
    "    plot(dict_vals_new_norm, \"final_plot_new_norm_model\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict_vals = {k:v for (k, v) in raw_dict_vals.items() if \"half\" in k}\n",
    "dict_vals_new = {k:v for (k, v) in raw_dict_vals_new.items() if \"half\" in k}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model fitting Half receivers\n",
    "## Basic model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "if run_half:\n",
    "    print(\"strategy nb_nodes latency overhead rmse\")\n",
    "    for k, (a, b, c, e) in dict_vals.items():\n",
    "        print(k, a, b, c, e)\n",
    "        #print(k, c)\n",
    "    plot(dict_vals, \"final_plot_basic_model_half\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## New model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if run_half:\n",
    "    print(\"strategy nb_nodes latency overhead rmse\")\n",
    "    for k, (a, b, c, e) in dict_vals_new.items():\n",
    "        print(k, a, b, c, e)\n",
    "        #print(k, c)\n",
    "    plot(dict_vals_new, \"final_plot_new_model_half\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Normalized basic model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if run_half:\n",
    "    l = [v for v in dict_vals.values()]\n",
    "    x, y, z, e = zip(*l)\n",
    "    x = max(x)\n",
    "    y = max(y)\n",
    "    z = max(z)\n",
    "    e = max(e)\n",
    "    t = (x,y,z,e)\n",
    "    dict_vals_norm = {k: norm(v, t) for k, v in dict_vals.items()}\n",
    "    plot(dict_vals_norm, \"final_plot_norm_model_half\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Normalized new model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if run_half:\n",
    "    l = [v for v in dict_vals_new.values()]\n",
    "    x, y, z, e = zip(*l)\n",
    "    x = max(x)\n",
    "    y = max(y)\n",
    "    z = max(z)\n",
    "    e = max(e)\n",
    "    t = (x,y,z,e)\n",
    "    dict_vals_new_norm = {k: norm(v, t) for k, v in dict_vals_new.items()}\n",
    "    plot(dict_vals_new_norm, \"final_plot_new_norm_model_half\")"
   ]
  }
 ],
 "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}