examples/plot_predictors.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plotting for NAS-Bench-Suite Predictors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook was used to plot the performance predictor experiments from Section 4 of \n",
    "[NAS-Bench-Suite: NAS Evaluation is (Now) Surprisingly Easy](https://arxiv.org/abs/2201.13396). This includes plotting the results of MLP, XGBoost, RF, BOHAMIANN, GP, and NAO."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import os\n",
    "import copy\n",
    "import numpy as np\n",
    "import json\n",
    "import pickle\n",
    "import random\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib\n",
    "from scipy.stats import kendalltau\n",
    "matplotlib.rcParams['pdf.fonttype'] = 42"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# method that gathers all of the results\n",
    "\n",
    "# example result path:\n",
    "# ~/results_nas_bench_suite/predictor_hpo_sep24/predictor_hpo_sep24_50/hpo_52/nasbench201/cifar100/xgb/3/errors.json\n",
    "\n",
    "def get_hpo_results(predictors, search_spaces, root):\n",
    "    results_dict = {}\n",
    "    root = os.path.expanduser(root)\n",
    "    for seed_header in os.listdir(root):\n",
    "        for seed_dir in os.listdir(root + '/' + seed_header):\n",
    "            hpo_seed = int(seed_dir.split('_')[-1])\n",
    "            hpo_seed_dict = {}\n",
    "            seed_path = root + '/' + seed_header + '/' + seed_dir\n",
    "            for search_space in search_spaces:\n",
    "                search_space_dict = {}\n",
    "                for predictor in predictors:\n",
    "                    predictor_path = seed_path + '/' + file_dict[search_space] + '/' + predictor\n",
    "                    values = []\n",
    "                    if os.path.exists(predictor_path):\n",
    "                        for seed in os.listdir(predictor_path):\n",
    "                            result_path = predictor_path + '/' + seed + '/errors.json'\n",
    "                            if os.path.isfile(result_path):\n",
    "                                result = json.load(open(result_path))\n",
    "                                value = result[1]['spearman']\n",
    "                                if not np.isnan(value):\n",
    "                                    values.append(value)\n",
    "                        if len(values) >= 3:\n",
    "                            search_space_dict[predictor] = [np.mean(values), np.std(values)]\n",
    "                        else:\n",
    "                            print(len(values), 'not enough values', hpo_seed, search_space, predictor)\n",
    "                hpo_seed_dict[search_space] = search_space_dict\n",
    "            results_dict[hpo_seed] = hpo_seed_dict\n",
    "    return results_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define constants that will be used throughout the notebook\n",
    "\n",
    "\"\"\"\n",
    "Set up colors. There are 11 colors defined in 'defaults', and 3 markers/formats for the plot lines.\n",
    "So there are 33 color/markers total.\n",
    "\"\"\"\n",
    "\n",
    "defaults = [(0.12156862745098039, 0.4666666666666667, 0.7058823529411765),\n",
    "            (1.0, 0.4980392156862745, 0.054901960784313725),\n",
    "            (0.17254901960784313, 0.6274509803921569, 0.17254901960784313),\n",
    "            (0.8392156862745098, 0.15294117647058825, 0.1568627450980392),\n",
    "            (0.5803921568627451, 0.403921568627451, 0.7411764705882353),\n",
    "            (0.5490196078431373, 0.33725490196078434, 0.29411764705882354),\n",
    "            (0.8901960784313725, 0.4666666666666667, 0.7607843137254902),\n",
    "            (0.4980392156862745, 0.4980392156862745, 0.4980392156862745),\n",
    "            (0.7372549019607844, 0.7411764705882353, 0.13333333333333333),\n",
    "            (0.09019607843137255, 0.7450980392156863, 0.8117647058823529),\n",
    "            (0.0, 0.0, 0.0)\n",
    "           ]\n",
    "\n",
    "fmts = ['-', '--', ':', '-.']\n",
    "markers = ['^', 'v', 'o']\n",
    "defaults = [np.array(d) for d in defaults]\n",
    "\n",
    "color_dict={\n",
    "    'bohamiann':{'color':defaults[0], 'fmt':fmts[0]},\n",
    "    'gp':{'color':defaults[1], 'fmt':fmts[0]},\n",
    "    'nao':{'color':defaults[2], 'fmt':fmts[0]},\n",
    "    'mlp':{'color':defaults[2], 'fmt':fmts[0]},\n",
    "    'rf':{'color':defaults[3], 'fmt':fmts[0]},\n",
    "    'xgb':{'color':defaults[4], 'fmt':fmts[0]},\n",
    "}\n",
    "\n",
    "# how the predictor names will be displayed in the plot legends:\n",
    "pred_label_dict={\n",
    "    'mlp':'MLP', 'xgb':'XGBoost', 'rf':'RF', 'bohamiann':'BOHAMIANN', \n",
    "    'gp':'GP', 'nao':'NAO', \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [],
   "source": [
    "# search space constants\n",
    "\n",
    "# how the search space names will be displayed in the plot titles:\n",
    "ss_dict_lined = {'nb101':'NB-101\\n CIFAR10', \n",
    "                 'nb201_c10':'NB-201\\n CIFAR10', \n",
    "                 'nb201_c100':'NB-201\\n CIFAR100', \n",
    "                 'nb201_im':'NB-201\\n ImageNet', \n",
    "                 'darts':'DARTS\\n CIFAR10',\n",
    "                 'nlp':'NB-NLP\\n TreeBank',\n",
    "                 'asr':'NB-ASR\\n TIMIT',\n",
    "                 'mr_3ddet':'NB-MR\\n KITTI',\n",
    "                 'mr_cls':'NB-MR\\n ImageNet',\n",
    "                 'mr_seg':'NB-MR\\n City',\n",
    "                 'mr_video':'NB-MR\\n HMDB51',\n",
    "                 'transmicro_obj':'TNB-Micro\\n Object', \n",
    "                 'transmicro_scene':'TNB-Micro\\n Scene', \n",
    "                 'transmicro_jigsaw':'TNB-Micro\\n Jigsaw', \n",
    "                 'transmicro_room':'TNB-Micro\\n Room',\n",
    "                 'transmicro_segment':'TNB-Micro\\n Semantic', \n",
    "                 'transmicro_normal':'TNB-Micro\\n Surface', \n",
    "                 'transmicro_auto':'TNB-Micro\\n Autoenc.', \n",
    "                 'transmacro_obj':'TNB-Macro\\n Object', \n",
    "                 'transmacro_scene':'TNB-Macro\\n Scene', \n",
    "                 'transmacro_jigsaw':'TNB-Macro\\n Jigsaw', \n",
    "                 'transmacro_room':'TNB-Macro\\n Room',\n",
    "                 'transmacro_segment':'TNB-Macro\\n Semantic', \n",
    "                 'transmacro_normal':'TNB-Macro\\n Surface', \n",
    "                 'transmacro_auto':'TNB-Macro\\n Autoenc.', \n",
    "          }\n",
    "\n",
    "# single-line version of the search space names:\n",
    "ss_dict_oneline = {'nb101':'NB-101 CIFAR10', \n",
    "                 'nb201_c10':'NB-201 CIFAR10', \n",
    "                 'nb201_c100':'NB-201 CIFAR100', \n",
    "                 'nb201_im':'NB-201 ImageNet', \n",
    "                 'darts':'DARTS CIFAR10',\n",
    "                 'nlp':'NB-NLP TreeBank',\n",
    "                 'asr':'NB-ASR TIMIT',\n",
    "                 'mr_3ddet':'NB-MR KITTI',\n",
    "                 'mr_cls':'NB-MR ImageNet',\n",
    "                 'mr_seg':'NB-MR City',\n",
    "                 'mr_video':'NB-MR HMDB51',\n",
    "                 'transmicro_obj':'TNB-Micro Object', \n",
    "                 'transmicro_scene':'TNB-Micro Scene', \n",
    "                 'transmicro_jigsaw':'TNB-Micro Jigsaw', \n",
    "                 'transmicro_room':'TNB-Micro Room',\n",
    "                 'transmicro_segment':'TNB-Micro Semantic', \n",
    "                 'transmicro_normal':'TNB-Micro Surface', \n",
    "                 'transmicro_auto':'TNB-Micro Autoenc.', \n",
    "                 'transmacro_obj':'TNB-Macro Object', \n",
    "                 'transmacro_scene':'TNB-Macro Scene', \n",
    "                 'transmacro_jigsaw':'TNB-Macro Jigsaw', \n",
    "                 'transmacro_room':'TNB-Macro Room',\n",
    "                 'transmacro_segment':'TNB-Macro Semantic', \n",
    "                 'transmacro_normal':'TNB-Macro Surface', \n",
    "                 'transmacro_auto':'TNB-Macro Autoenc.', \n",
    "          }\n",
    "\n",
    "# abbreviations used for the matrix plots:\n",
    "ss_dict_mat = {'nb101':'NB-101', \n",
    "                 'nb201_c10':'NB-201', \n",
    "                 'nb201_c100':'NB-201', \n",
    "                 'nb201_im':'NB-201', \n",
    "                 'darts':'DARTS',\n",
    "                 'nlp':'NB-NLP',\n",
    "                 'asr':'NB-ASR',\n",
    "                 'mr_3ddet':'NB-MR',\n",
    "                 'mr_cls':'NB-MR',\n",
    "                 'mr_seg':'NB-MR',\n",
    "                 'mr_video':'NB-MR',\n",
    "                 'transmicro_obj':'TNB-Micro', \n",
    "                 'transmicro_scene':'TNB-Micro', \n",
    "                 'transmicro_jigsaw':'TNB-Micro', \n",
    "                 'transmicro_room':'TNB-Micro',\n",
    "                 'transmicro_segment':'TNB-Micro', \n",
    "                 'transmicro_normal':'TNB-Micro', \n",
    "                 'transmicro_auto':'TNB-Micro', \n",
    "                 'transmacro_obj':'TNB-Macro', \n",
    "                 'transmacro_scene':'TNB-Macro', \n",
    "                 'transmacro_jigsaw':'TNB-Macro', \n",
    "                 'transmacro_room':'TNB-Macro',\n",
    "                 'transmacro_segment':'TNB-Macro', \n",
    "                 'transmacro_normal':'TNB-Macro', \n",
    "                 'transmacro_auto':'TNB-Macro', \n",
    "          }\n",
    "\n",
    "# these are the file paths we used\n",
    "file_dict = {\n",
    "    'nb101':'nasbench101/cifar10', \n",
    "    'nb201_c10':'nasbench201/cifar10', \n",
    "    'nb201_c100':'nasbench201/cifar100', \n",
    "    'nb201_im':'nasbench201/ImageNet16-120', \n",
    "    'darts':'darts/cifar10', \n",
    "    'nlp':'nlp/penntreebank', \n",
    "    'asr':'asr/timit', \n",
    "    'transmicro_obj':'transbench101_micro/class_object',\n",
    "    'transmicro_scene':'transbench101_micro/class_scene',\n",
    "    'transmicro_jigsaw':'transbench101_micro/jigsaw',\n",
    "    'transmicro_room':'transbench101_micro/room_layout',\n",
    "    'transmicro_segment':'transbench101_micro/segmentsemantic',\n",
    "    'transmicro_normal':'transbench101_micro/normal',\n",
    "    'transmicro_auto':'transbench101_micro/autoencoder',\n",
    "    'transmacro_obj':'transbench101_macro/class_object',\n",
    "    'transmacro_scene':'transbench101_macro/class_scene',\n",
    "    'transmacro_jigsaw':'transbench101_macro/jigsaw',\n",
    "    'transmacro_room':'transbench101_macro/room_layout',\n",
    "    'transmacro_segment':'transbench101_macro/segmentsemantic',\n",
    "    'transmacro_normal':'transbench101_macro/normal',\n",
    "    'transmacro_auto':'transbench101_macro/autoencoder',\n",
    "    'mr_3ddet':'mr/3ddet',\n",
    "    'mr_cls':'mr/cls-50-1000',\n",
    "    'mr_seg':'mr/seg',\n",
    "    'mr_video':'mr/video',\n",
    "            }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Now load all of the data\n",
    " - Each algorithm is tagged as \"algorithm_date\"\n",
    " - The next cell will create a dictionary will all of the results from the specified search space"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 not enough values 128 nb101 bohamiann\n",
      "0 not enough values 128 nb201_c10 bohamiann\n",
      "0 not enough values 128 nb201_c100 bohamiann\n",
      "0 not enough values 128 nb201_im bohamiann\n",
      "0 not enough values 128 darts bohamiann\n",
      "0 not enough values 128 asr bohamiann\n",
      "0 not enough values 128 nlp bohamiann\n",
      "0 not enough values 128 transmicro_obj bohamiann\n",
      "0 not enough values 128 transmicro_scene bohamiann\n",
      "0 not enough values 128 transmicro_jigsaw bohamiann\n",
      "0 not enough values 128 transmicro_room bohamiann\n",
      "0 not enough values 128 transmicro_segment bohamiann\n",
      "0 not enough values 128 transmicro_normal bohamiann\n",
      "0 not enough values 128 transmicro_auto bohamiann\n",
      "0 not enough values 128 transmacro_obj bohamiann\n",
      "0 not enough values 128 transmacro_scene bohamiann\n",
      "0 not enough values 128 transmacro_jigsaw bohamiann\n",
      "0 not enough values 128 transmacro_room bohamiann\n",
      "0 not enough values 128 transmacro_segment bohamiann\n",
      "0 not enough values 128 transmacro_normal bohamiann\n",
      "0 not enough values 128 transmacro_auto bohamiann\n",
      "0 not enough values 145 nb101 bohamiann\n",
      "0 not enough values 145 nb201_c10 bohamiann\n",
      "0 not enough values 145 nb201_c100 bohamiann\n",
      "0 not enough values 145 nb201_im bohamiann\n",
      "0 not enough values 145 darts bohamiann\n",
      "0 not enough values 145 asr bohamiann\n",
      "0 not enough values 145 nlp bohamiann\n",
      "0 not enough values 145 transmicro_obj bohamiann\n",
      "0 not enough values 145 transmicro_scene bohamiann\n",
      "0 not enough values 145 transmicro_jigsaw bohamiann\n",
      "0 not enough values 145 transmicro_room bohamiann\n",
      "0 not enough values 145 transmicro_segment bohamiann\n",
      "0 not enough values 145 transmicro_normal bohamiann\n",
      "0 not enough values 145 transmicro_auto bohamiann\n",
      "0 not enough values 145 transmacro_obj bohamiann\n",
      "0 not enough values 145 transmacro_scene bohamiann\n",
      "0 not enough values 145 transmacro_jigsaw bohamiann\n",
      "0 not enough values 145 transmacro_room bohamiann\n",
      "0 not enough values 145 transmacro_segment bohamiann\n",
      "0 not enough values 145 transmacro_normal bohamiann\n",
      "0 not enough values 145 transmacro_auto bohamiann\n",
      "0 not enough values 154 nb101 bohamiann\n",
      "0 not enough values 154 nb201_c10 bohamiann\n",
      "0 not enough values 154 nb201_c100 bohamiann\n",
      "0 not enough values 154 nb201_im bohamiann\n",
      "0 not enough values 154 darts bohamiann\n",
      "0 not enough values 154 asr bohamiann\n",
      "0 not enough values 154 nlp bohamiann\n",
      "0 not enough values 154 transmicro_obj bohamiann\n",
      "0 not enough values 154 transmicro_scene bohamiann\n",
      "0 not enough values 154 transmicro_jigsaw bohamiann\n",
      "0 not enough values 154 transmicro_room bohamiann\n",
      "0 not enough values 154 transmicro_segment bohamiann\n",
      "0 not enough values 154 transmicro_normal bohamiann\n",
      "0 not enough values 154 transmicro_auto bohamiann\n",
      "0 not enough values 154 transmacro_obj bohamiann\n",
      "0 not enough values 154 transmacro_scene bohamiann\n",
      "0 not enough values 154 transmacro_jigsaw bohamiann\n",
      "0 not enough values 154 transmacro_room bohamiann\n",
      "0 not enough values 154 transmacro_segment bohamiann\n",
      "0 not enough values 154 transmacro_normal bohamiann\n",
      "0 not enough values 154 transmacro_auto bohamiann\n",
      "0 not enough values 68 nb101 bohamiann\n",
      "0 not enough values 68 nb201_c10 bohamiann\n",
      "0 not enough values 68 nb201_c100 bohamiann\n",
      "0 not enough values 68 nb201_im bohamiann\n",
      "0 not enough values 68 darts bohamiann\n",
      "0 not enough values 68 asr bohamiann\n",
      "0 not enough values 68 nlp bohamiann\n",
      "0 not enough values 68 transmicro_obj bohamiann\n",
      "0 not enough values 68 transmicro_scene bohamiann\n",
      "0 not enough values 68 transmicro_jigsaw bohamiann\n",
      "0 not enough values 68 transmicro_room bohamiann\n",
      "0 not enough values 68 transmicro_segment bohamiann\n",
      "0 not enough values 68 transmicro_normal bohamiann\n",
      "0 not enough values 68 transmicro_auto bohamiann\n",
      "0 not enough values 68 transmacro_obj bohamiann\n",
      "0 not enough values 68 transmacro_scene bohamiann\n",
      "0 not enough values 68 transmacro_jigsaw bohamiann\n",
      "0 not enough values 68 transmacro_room bohamiann\n",
      "0 not enough values 68 transmacro_segment bohamiann\n",
      "0 not enough values 68 transmacro_normal bohamiann\n",
      "0 not enough values 68 transmacro_auto bohamiann\n",
      "0 not enough values 18 nb101 bohamiann\n",
      "0 not enough values 18 nb201_c10 bohamiann\n",
      "0 not enough values 18 nb201_c100 bohamiann\n",
      "0 not enough values 18 nb201_im bohamiann\n",
      "0 not enough values 18 darts bohamiann\n",
      "0 not enough values 18 asr bohamiann\n",
      "0 not enough values 18 nlp bohamiann\n",
      "0 not enough values 18 transmicro_obj bohamiann\n",
      "0 not enough values 18 transmicro_scene bohamiann\n",
      "0 not enough values 18 transmicro_jigsaw bohamiann\n",
      "0 not enough values 18 transmicro_room bohamiann\n",
      "0 not enough values 18 transmicro_segment bohamiann\n",
      "0 not enough values 18 transmicro_normal bohamiann\n",
      "0 not enough values 18 transmicro_auto bohamiann\n",
      "0 not enough values 18 transmacro_obj bohamiann\n",
      "0 not enough values 18 transmacro_scene bohamiann\n",
      "0 not enough values 18 transmacro_jigsaw bohamiann\n",
      "0 not enough values 18 transmacro_room bohamiann\n",
      "0 not enough values 18 transmacro_segment bohamiann\n",
      "0 not enough values 18 transmacro_normal bohamiann\n",
      "0 not enough values 18 transmacro_auto bohamiann\n"
     ]
    }
   ],
   "source": [
    "search_spaces = ['nb101', 'nb201_c10', 'nb201_c100', 'nb201_im', 'darts', 'asr', 'nlp',\n",
    "                 'mr_3ddet', 'mr_cls', 'mr_seg', 'mr_video',\n",
    "                 'transmicro_obj', 'transmicro_scene', 'transmicro_jigsaw', \n",
    "                 'transmicro_room', 'transmicro_segment', 'transmicro_normal', \n",
    "                 'transmicro_auto', \n",
    "                 'transmacro_obj', 'transmacro_scene', 'transmacro_jigsaw', \n",
    "                 'transmacro_room', 'transmacro_segment', 'transmacro_normal', \n",
    "                 'transmacro_auto']\n",
    "\n",
    "predictors=('bohamiann', 'gp', 'rf', 'xgb', 'nao')\n",
    "root = '~/plotting_data/predictors/'\n",
    "results = get_hpo_results(predictors, search_spaces, root=root)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Now plot everything"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: for these results, we put the default config as seed 0. The following methods are hard-coded to that fact."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 412,
   "metadata": {},
   "outputs": [],
   "source": [
    "result_folder = 'plots_nov10/'\n",
    "# default config is 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot default and hpo side by side\n",
    "def plot_default_hpo(results, ss_group, predictors, offset=0.1, scale_type='0-1', one_line=False, save=None):\n",
    "\n",
    "    if not one_line:\n",
    "        plot_width = .7 * len(ss_group)\n",
    "    else:\n",
    "        plot_width = .42 * len(ss_group)\n",
    "    fig, ax = plt.subplots(figsize=(plot_width,2))\n",
    "    width = 0\n",
    "    ss_order = []\n",
    "    for search_space in ss_group:\n",
    "        if one_line:\n",
    "            ss_order.append(ss_dict_oneline[search_space])\n",
    "        else:\n",
    "            ss_order.append(ss_dict_lined[search_space])\n",
    "        width += 1\n",
    "        means = []\n",
    "        for predictor in predictors:            \n",
    "            mean = results[0][search_space][predictor][0]\n",
    "            means.append(mean)\n",
    "\n",
    "            hpo_means = []\n",
    "            for hpo_seed in results.keys():\n",
    "                if predictor in results[hpo_seed][search_space]:\n",
    "                    hpo_means.append(results[hpo_seed][search_space][predictor][0])\n",
    "            mean = np.max(hpo_means)\n",
    "            means.append(mean)\n",
    "\n",
    "        if scale_type == '0-1':\n",
    "            min_acc, max_acc = np.min(means), np.max(means)\n",
    "            means = [(m - min_acc) / (max_acc - min_acc) for m in means]\n",
    "\n",
    "        i = 0\n",
    "        for predictor in predictors:\n",
    "            color = color_dict[predictor]['color']\n",
    "            if width == 1:\n",
    "                ax.scatter(width-offset, means[i], label=pred_label_dict[predictor], color=color, marker='o')\n",
    "                ax.scatter(width+offset, means[i+1], label=pred_label_dict[predictor] + '+HPO', color=color, marker='x')\n",
    "            else:\n",
    "                ax.scatter(width-offset, means[i], color=color, marker='o')\n",
    "                ax.scatter(width+offset, means[i+1], color=color, marker='x')\n",
    "            i += 2\n",
    "\n",
    "    ax.legend(loc=(1.01,-.37))\n",
    "    #ax.set_xticklabels([s.ljust(0) for s in ss_order], fontsize=12, rotation=90)\n",
    "    ax.set_xticklabels(ss_order, fontsize=12, rotation=90)\n",
    "    ax.set_xticks(range(1, len(ss_order)+1))\n",
    "    ax.set_ylabel('Scaled Spearman Rank    ', fontsize=12)   \n",
    "\n",
    "    #ax.set_title('Scaled Spearman Rank Correlation of Performance Predictors', fontsize=14)\n",
    "    ax.set_title('Performance Predictors', fontsize=14)\n",
    "    \n",
    "    if save:\n",
    "        plt.savefig(result_folder + save, bbox_inches = 'tight', pad_inches = 0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ubuntu/anaconda3/envs/mvenv/lib/python3.7/site-packages/ipykernel_launcher.py:46: UserWarning: FixedFormatter should only be used together with FixedLocator\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 756x144 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 756x144 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot the full results:\n",
    "plot_default_hpo(results, search_spaces, predictors, one_line=True, scale_type='0-1') #, save='predictors.pdf')\n",
    "\n",
    "# plot a representative subset:\n",
    "ss_group = ['nb101', 'nb201_c10', 'nb201_c100', 'nb201_im', 'darts', 'asr', 'nlp', \\\n",
    "            'mr_3ddet', 'mr_video', 'mr_cls', 'mr_seg', \\\n",
    "            'transmicro_scene', 'transmicro_segment', 'transmacro_scene', 'transmacro_segment']\n",
    "plot_default_hpo(results, ss_group, predictors, scale_type='0-1') #, save='predictors.pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 383,
   "metadata": {},
   "outputs": [],
   "source": [
    "# compute the average ranks of the predictors, and the number of wins\n",
    "# we give weight 1 to each search space, including the ones with multiple datasets (nb201, trans, mr)\n",
    "# (correctly weighing each search_space,dataset pair makes the code a bit more complex)\n",
    "\n",
    "def compute_ranks(results, predictors):\n",
    "    rank_results = []\n",
    "    full_ranks_no_hpo = None\n",
    "    full_ranks_hpo = None\n",
    "    for hpo in [False, True]:\n",
    "        ranks = np.zeros((len(search_spaces), len(predictors)))\n",
    "        nb201_indices = []\n",
    "        trans_indices = []\n",
    "        mr_indices = []\n",
    "        for i, search_space in enumerate(results[0].keys()):\n",
    "            values = []\n",
    "            for predictor in predictors:\n",
    "                if not hpo:\n",
    "                    values.append(results[0][search_space][predictor][0])\n",
    "                else:\n",
    "                    means = []\n",
    "                    for hpo_seed in results.keys():\n",
    "                        if predictor in results[hpo_seed][search_space]:\n",
    "                            means.append(results[hpo_seed][search_space][predictor][0])\n",
    "                    values.append(np.max(means))\n",
    "            ranks[i] = np.flip(np.array(values).argsort()).argsort()\n",
    "            if 'nb201' in search_space:\n",
    "                nb201_indices.append(i)\n",
    "            elif 'trans' in search_space:\n",
    "                trans_indices.append(i)\n",
    "            elif 'mr' in search_space:\n",
    "                mr_indices.append(i)\n",
    "                \n",
    "        # compute num_wins\n",
    "        num_wins = [0 for i in range(len(predictors))]\n",
    "        for i in range(len(ranks)):\n",
    "            if i in nb201_indices:\n",
    "                num_wins[np.argmin(ranks[i])] += 1/3\n",
    "            elif i in trans_indices:\n",
    "                num_wins[np.argmin(ranks[i])] += 1/14\n",
    "            elif i in mr_indices:\n",
    "                num_wins[np.argmin(ranks[i])] += 1/4                \n",
    "            else:\n",
    "                num_wins[np.argmin(ranks[i])] += 1\n",
    "                \n",
    "        # scale by weight\n",
    "        for i in nb201_indices[1:]:\n",
    "            ranks[nb201_indices[0]] += ranks[i]\n",
    "        ranks[nb201_indices[0]] /= 3\n",
    "            \n",
    "        for i in trans_indices[1:]:\n",
    "            ranks[trans_indices[0]] += ranks[i]\n",
    "        ranks[trans_indices[0]] /= 14\n",
    "        \n",
    "        for i in mr_indices[1:]:\n",
    "            ranks[mr_indices[0]] += ranks[i]\n",
    "        ranks[mr_indices[0]] /= 4\n",
    "\n",
    "        indices_to_delete = [*nb201_indices[1:], *trans_indices[1:], *mr_indices[1:]]\n",
    "        indices_to_delete.sort(reverse=True)\n",
    "\n",
    "        for i in indices_to_delete:\n",
    "            ranks = np.delete(ranks, i, axis=0)\n",
    "\n",
    "        if not hpo:\n",
    "            full_ranks_no_hpo = ranks\n",
    "        else:\n",
    "            full_ranks_hpo = ranks\n",
    "        avg_ranks = np.mean(ranks, axis=0) + 1\n",
    "        rank_results.append(avg_ranks)\n",
    "        rank_results.append(num_wins)\n",
    "\n",
    "    print(\"\\t Avg. rank, default\\t Num. wins, default\\t Avg. rank, HPO\\t Num. wins, HPO\")\n",
    "    for i, predictor in enumerate(predictors):\n",
    "        # print in readable format\n",
    "        if i == 0:\n",
    "            print(predictor, *[str(np.round(rank_results[j][i], 2))+'\\t\\t\\t' for j in range(len(rank_results))])\n",
    "        else:\n",
    "            print(predictor, '\\t', *[str(np.round(rank_results[j][i], 2))+'\\t\\t\\t' for j in range(len(rank_results))])\n",
    "            \n",
    "    for i, predictor in enumerate(predictors):\n",
    "        # print in latex format\n",
    "        print(pred_label_dict[predictor], '&', *[str(np.round(rank_results[j][i], 2))+' &' for j in range(len(rank_results))])\n",
    "    return full_ranks_no_hpo, full_ranks_hpo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 385,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\t Avg. rank, default\t Num. wins, default\t Avg. rank, HPO\t Num. wins, HPO\n",
      "bohamiann 2.99\t\t\t 0.33\t\t\t 3.36\t\t\t 0.07\t\t\t\n",
      "gp \t 4.25\t\t\t 0.29\t\t\t 4.37\t\t\t 0.07\t\t\t\n",
      "rf \t 1.57\t\t\t 3.71\t\t\t 2.41\t\t\t 0.14\t\t\t\n",
      "xgb \t 2.95\t\t\t 1\t\t\t 1.23\t\t\t 5.38\t\t\t\n",
      "nao \t 3.25\t\t\t 1.67\t\t\t 3.62\t\t\t 1.33\t\t\t\n",
      "BOHAMIANN & 2.99 & 0.33 & 3.36 & 0.07 &\n",
      "GP & 4.25 & 0.29 & 4.37 & 0.07 &\n",
      "RF & 1.57 & 3.71 & 2.41 & 0.14 &\n",
      "XGBoost & 2.95 & 1 & 1.23 & 5.38 &\n",
      "NAO & 3.25 & 1.67 & 3.62 & 1.33 &\n"
     ]
    }
   ],
   "source": [
    "full_ranks_no_hpo, full_ranks_hpo = compute_ranks(results, predictors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 431,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-0.0657951694959769 ss_sizes no_hpo bohamiann\n",
      "0.2503130871608794 ss_sizes no_hpo gp\n",
      "-0.15877683720748895 ss_sizes no_hpo rf\n",
      "-0.39036002917941326 ss_sizes no_hpo xgb\n",
      "0.19518001458970663 ss_sizes no_hpo nao\n",
      "ss_sizes no_hpo -.07 & .25 & -.16 & -.39 & .2 & \n",
      "0.15018785229652765 ss_sizes hpo bohamiann\n",
      "0.05292561240249632 ss_sizes hpo gp\n",
      "-0.50709255283711 ss_sizes hpo rf\n",
      "-0.3944053188733077 ss_sizes hpo xgb\n",
      "0.19518001458970663 ss_sizes hpo nao\n",
      "ss_sizes hpo .15 & .05 & -.51 & -.39 & .2 & \n",
      "-0.3289758474798845 nbhd_sizes no_hpo bohamiann\n",
      "0.45056355688958294 nbhd_sizes no_hpo gp\n",
      "-0.2646280620124816 nbhd_sizes no_hpo rf\n",
      "0.0 nbhd_sizes no_hpo xgb\n",
      "0.0 nbhd_sizes no_hpo nao\n",
      "nbhd_sizes no_hpo -.33 & .45 & -.26 & .0 & .0 & \n",
      "0.3504383220252312 nbhd_sizes hpo bohamiann\n",
      "0.3704792868174742 nbhd_sizes hpo gp\n",
      "-0.3944053188733077 nbhd_sizes hpo rf\n",
      "-0.50709255283711 nbhd_sizes hpo xgb\n",
      "0.0 nbhd_sizes hpo nao\n",
      "nbhd_sizes hpo .35 & .37 & -.39 & -.51 & .0 & \n"
     ]
    }
   ],
   "source": [
    "# compute correlation between algo performance and {size, RWA}\n",
    "algo_rankings = {\n",
    "    'no_hpo':full_ranks_no_hpo,\n",
    "    'hpo':full_ranks_hpo\n",
    "}\n",
    "# 101, 201, darts, asr, nlp, trans, mr\n",
    "ss_rankings = {\n",
    "    'ss_sizes':[432625, 6466, 1e18, 8242, 1e53, 3676, 1e23],\n",
    "    'nbhd_sizes':[20.114, 24, 120, 21, 42, 15, 45.3],\n",
    "}\n",
    "\n",
    "for key1, ss_rank in ss_rankings.items():\n",
    "    for key2, alg_rankings in algo_rankings.items():\n",
    "        res = []\n",
    "        for i, predictor in enumerate(predictors):        \n",
    "            alg_rank = [ss[i] for ss in alg_rankings]\n",
    "            value = kendalltau(alg_rank, ss_rank)[0]\n",
    "            s = str(np.round(value, 2))\n",
    "            if s[0] == '-':\n",
    "                s = '-' + s[2:]\n",
    "            else:\n",
    "                s = s[1:]\n",
    "            res.append(s + ' & ')\n",
    "            # print in readable format:\n",
    "            print(value, key1, key2, predictor)\n",
    "\n",
    "        # print in latex format:\n",
    "        print(key1, key2, ''.join(res))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 410,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "plot a matrix where entry [i,j] is the regret of a predictor \n",
    "tuned on search space i and evaluated on search space j.\n",
    "\n",
    "Some of the matrix code is different types of scaling so that we can see the trends better\n",
    "\"\"\"\n",
    "def compute_matrix(results, ss_group, predictors, predictor):\n",
    "\n",
    "    # first, compute a list of all seeds that have full info\n",
    "    hpo_seeds = []\n",
    "    for hpo_seed in results.keys():\n",
    "        valid = True\n",
    "        for search_space in ss_group:\n",
    "            for pred in predictors:\n",
    "                if not (search_space in results[hpo_seed] and \\\n",
    "                        pred in results[hpo_seed][search_space]):\n",
    "                    valid = False\n",
    "        if valid:\n",
    "            hpo_seeds.append(hpo_seed)\n",
    "        else:\n",
    "            pass\n",
    "    print('num valid', len(hpo_seeds))\n",
    "\n",
    "    # now compute the raw results and best seed for each search space\n",
    "    best_seeds = []\n",
    "    raw_seed_results = np.zeros((len(ss_group), len(hpo_seeds)))\n",
    "    scaled_seed_results = np.zeros((len(ss_group), len(hpo_seeds)))\n",
    "    for i, search_space in enumerate(ss_group):\n",
    "        raw_seed_results[i] = [results[hpo_seed][search_space][predictor][0] for hpo_seed in hpo_seeds]\n",
    "        best_seeds.append(np.argmax(raw_seed_results[i]))\n",
    "        # 0-1 scaling:\n",
    "        min_acc, max_acc = np.min(raw_seed_results[i]), np.max(raw_seed_results[i])\n",
    "        scaled_seed_results[i] = [(m - min_acc) / (max_acc - min_acc) for m in raw_seed_results[i]]\n",
    "\n",
    "    # compute the matrices\n",
    "    div_matrix = np.zeros((len(ss_group), len(ss_group)))\n",
    "    kt_matrix = np.zeros((len(ss_group), len(ss_group)))\n",
    "    scaled_matrix = np.zeros((len(ss_group), len(ss_group)))\n",
    "\n",
    "    for i, ss_1 in enumerate(ss_group):\n",
    "        for j, ss_2 in enumerate(ss_group):\n",
    "            div_matrix[i][j] = scaled_seed_results[i][best_seeds[j]] / scaled_seed_results[i][best_seeds[i]]\n",
    "            scaled_matrix[i][j] = scaled_seed_results[i][best_seeds[i]] - scaled_seed_results[i][best_seeds[j]]\n",
    "            kt_matrix[i][j] = kendalltau(raw_seed_results[i], raw_seed_results[j])[0]\n",
    "\n",
    "    return div_matrix, scaled_matrix, kt_matrix, scaled_seed_results\n",
    "\n",
    "def scale_matrix(matrix, mean_div=2.5):\n",
    "    # further scaling of the results\n",
    "    # needs to happen in its own method so that an avg_matrix is input\n",
    "    scaled_matrix = np.zeros((len(matrix), len(matrix)))\n",
    "    maximum = np.max(matrix)\n",
    "    mean = np.mean(matrix)\n",
    "    for i in range(len(matrix)):\n",
    "        for j in range(len(matrix)):\n",
    "            if mean_div > 0:\n",
    "                scaled_matrix[i][j] = np.minimum(matrix[i][j], mean * mean_div)\n",
    "            else:\n",
    "                scaled_matrix[i][j] = np.maximum(matrix[i][j], mean / mean_div * -1)\n",
    "\n",
    "    # 0-1 scale\n",
    "    min_acc, max_acc = np.min(scaled_matrix), np.max(scaled_matrix)\n",
    "    for i in range(len(scaled_matrix)):\n",
    "        for j in range(len(scaled_matrix)):\n",
    "            scaled_matrix[i][j] = (scaled_matrix[i][j] - min_acc) / (max_acc - min_acc) \n",
    "\n",
    "    return scaled_matrix\n",
    "\n",
    "def plot_matrix(matrix, ss_group, save=None, cmap='viridis', hparam=False):\n",
    "    coords = matrix\n",
    "    cellsize = 5\n",
    "    fig, ax = plt.subplots(1,1,figsize=(cellsize*1.2, cellsize*coords.shape[0]/coords.shape[1]))\n",
    "    im = ax.pcolormesh(coords, edgecolor='k', linewidth=0.5, cmap=cmap) \n",
    "    if hparam:\n",
    "        plt.title('HParam. Corr. for Predictors')\n",
    "    else:\n",
    "        plt.title('Generalizability for Predictors')\n",
    "    plt.gca().invert_yaxis()\n",
    "    ax.set_xticks([])\n",
    "    ax.set_xticklabels('')\n",
    "    ax.set_xticks([c+0.5 for c in range(coords.shape[0]-0)], minor=True)\n",
    "    ax.set_xticklabels([ss_dict_mat[ss] for ss in ss_group], minor=True, rotation=90)\n",
    "    ax.set_yticks([])\n",
    "    ax.set_yticklabels('')    \n",
    "    ax.set_yticks([c+0.5 for c in range(coords.shape[1]-0)], minor=True)\n",
    "    ax.set_yticklabels([ss_dict_mat[ss] for ss in ss_group], minor=True)\n",
    "    fig.colorbar(im, ax=ax)\n",
    "    \n",
    "    if save:\n",
    "        plt.savefig(result_folder + save, bbox_inches = 'tight', pad_inches = 0.1)\n",
    "        \n",
    "    return matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 414,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "num valid 295\n",
      "num valid 295\n",
      "num valid 295\n",
      "num valid 295\n",
      "num valid 295\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "matrices = []\n",
    "kt_matrices = []\n",
    "for predictor in predictors:\n",
    "    _, mat, kt_mat, _ = compute_matrix(results, search_spaces, predictors, predictor=predictor)\n",
    "    matrices.append(mat)\n",
    "    kt_matrices.append(kt_mat)\n",
    "\n",
    "avg_matrix = np.mean(np.array(matrices), axis=0)\n",
    "avg_kt_matrix = np.mean(np.array(kt_matrices), axis=0)\n",
    "\n",
    "scaled_matrix = scale_matrix(avg_matrix, mean_div=2.5)\n",
    "scaled_kt_matrix = scale_matrix(avg_kt_matrix, mean_div=-100000)\n",
    "\n",
    "_ = plot_matrix(scaled_matrix, search_spaces, cmap='viridis') #, save='pred_matrix_avg.pdf')\n",
    "_ = plot_matrix(scaled_kt_matrix, search_spaces, cmap='viridis_r', hparam=True) #, save='pred_corr_matrix.pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 415,
   "metadata": {},
   "outputs": [],
   "source": [
    "def shorten_matrix(matrix):\n",
    "    # this has hard-coded indices for groups of search_spaces\n",
    "    if len(matrix) != 25:\n",
    "        print('invalid matrix')\n",
    "        return\n",
    "\n",
    "    # compute a smaller matrix based on just ss_groups\n",
    "    # the search spaces with multiple datasets (nb201, mr, trans) are hard-coded.\n",
    "    ss_idx_groups = [[0], [1,2,3], [4], [5], [6], [7,8,9,10], [i for i in range(11,25)]]\n",
    "    ss_matrix = np.zeros((len(ss_idx_groups), len(ss_idx_groups)))\n",
    "    for i, ss_1 in enumerate(ss_idx_groups):\n",
    "        for j, ss_2 in enumerate(ss_idx_groups):\n",
    "            ss_matrix[i][j] = np.mean(matrix[ss_1, :][:, ss_2])\n",
    "\n",
    "    if False:\n",
    "        # debug by looking at the matrix\n",
    "        coords = ss_matrix\n",
    "        cellsize = 5\n",
    "        fig, ax = plt.subplots(1,1,figsize=(cellsize*1.2, cellsize*coords.shape[0]/coords.shape[1]))\n",
    "        im = ax.pcolormesh(coords, edgecolor='k', linewidth=0.5) \n",
    "        plt.title('Generalizability for Predictors')\n",
    "        plt.gca().invert_yaxis()\n",
    "        fig.colorbar(im, ax=ax)\n",
    "    return ss_matrix\n",
    "\n",
    "def summarize_matrix(matrix):\n",
    "    # compute the average transfer score\n",
    "    to_avgs = []\n",
    "    from_avgs = []\n",
    "    adjustment = len(matrix) / (len(matrix) - 1)\n",
    "    for i in range(len(matrix)):\n",
    "        to_avgs.append(np.mean(matrix[i,:]) * adjustment)\n",
    "        from_avgs.append(np.mean(matrix[:,i]) * adjustment)\n",
    "    mean_avgs = np.mean([to_avgs, from_avgs], axis=0)\n",
    "    to_avgs = np.round(to_avgs, 3)\n",
    "    from_avgs = np.round(from_avgs, 3)\n",
    "    mean_avgs = np.round(mean_avgs, 3)\n",
    "    print(*[str(t) + ' &' for t in to_avgs])\n",
    "    print(*[str(t) + ' &' for t in from_avgs])\n",
    "    print(mean_avgs)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 430,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "summary of matrix (just 0-1 scaling)\n",
      ".0 & .42 & .28 & .46 & .48 & .21 & .41 &\n",
      ".43 & .02 & .29 & .11 & .11 & .32 & .09 &\n",
      ".08 & .47 & .0 & .48 & .34 & .26 & .41 &\n",
      ".28 & .23 & .31 & .0 & .07 & .32 & .12 &\n",
      ".25 & .31 & .27 & .09 & .0 & .36 & .15 &\n",
      ".19 & .39 & .28 & .42 & .47 & .2 & .4 &\n",
      ".37 & .13 & .41 & .16 & .15 & .4 & .15 &\n",
      "\n",
      "0.376 & 0.229 & 0.34 & 0.224 & 0.239 & 0.393 & 0.293 &\n",
      "0.268 & 0.328 & 0.307 & 0.288 & 0.27 & 0.345 & 0.287 &\n",
      "[0.322 0.279 0.323 0.256 0.254 0.369 0.29 ]\n"
     ]
    }
   ],
   "source": [
    "shortened_matrix = shorten_matrix(avg_matrix)\n",
    "print('summary of matrix (with 0-1 scaling)')\n",
    "rounded = np.round(shortened_matrix, 2)\n",
    "\n",
    "for row in rounded:\n",
    "    print(*[str(i)[1:] + ' &' for i in row])\n",
    "print()\n",
    "\n",
    "summarize_matrix(shortened_matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 423,
   "metadata": {},
   "outputs": [],
   "source": [
    "# leave one out experiment\n",
    "def leave_one_out(seed_results):\n",
    "    # first shorten the tensor\n",
    "    if seed_results.shape[0] != 25:\n",
    "        print('invalid seed results')\n",
    "        return\n",
    "\n",
    "    # compute a smaller matrix based on just ss_groups\n",
    "    ss_idx_groups = [[0], [1,2,3], [4], [5], [6], [7,8,9,10], [i for i in range(11,25)]]\n",
    "    ss_seed_results = np.zeros((len(ss_idx_groups), seed_results.shape[1]))\n",
    "    for i, ss in enumerate(ss_idx_groups):\n",
    "        ss_seed_results[i] = np.mean(seed_results[ss, :], axis=0)\n",
    "        \n",
    "        # 0-1 scaling:\n",
    "        min_acc, max_acc = np.min(ss_seed_results[i]), np.max(ss_seed_results[i])\n",
    "        ss_seed_results[i] = [(m - min_acc) / (max_acc - min_acc) for m in ss_seed_results[i]]\n",
    "\n",
    "    # now compute leave one out regret values\n",
    "    loo_to = []\n",
    "    loo_from = []\n",
    "    for i, ss_1 in enumerate(ss_seed_results):\n",
    "        avg_minus_i = np.mean(np.array([row for j,row in enumerate(ss_seed_results) if j != i]), axis=0)\n",
    "        best_minus_i_idx = np.argmax(avg_minus_i)\n",
    "        best_i_idx = np.argmax(ss_seed_results[i])\n",
    "        loo_to.append(ss_seed_results[i][best_i_idx] - ss_seed_results[i][best_minus_i_idx])\n",
    "        loo_from.append(avg_minus_i[best_minus_i_idx] - avg_minus_i[best_i_idx])\n",
    "\n",
    "    print(*[str(i) + ' &' for i in np.round(loo_to, 3)])\n",
    "    print(*[str(i) + ' &' for i in np.round(loo_from, 3)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 424,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.372 & 0.37 & 0.48 & 0.195 & 0.185 & 0.445 & 0.252 &\n",
      "0.226 & 0.16 & 0.223 & 0.058 & 0.029 & 0.241 & 0.056 &\n"
     ]
    }
   ],
   "source": [
    "leave_one_out(avg_seed_results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this is used to compare the best predictors on nb101 and nb201 vs best on every other search space\n",
    "def compute_subsets(results, predictors, ss_group, ss_indices_1, ss_indices_2):\n",
    "    rank_results = []\n",
    "    print(predictors)\n",
    "    for hpo in [False, True]:\n",
    "        ranks = np.zeros((len(search_spaces), len(predictors)))\n",
    "        nb201_indices = []\n",
    "        trans_indices = []\n",
    "        mr_indices = []\n",
    "        for i, search_space in enumerate(ss_group):\n",
    "            values = []\n",
    "            for predictor in predictors:\n",
    "                if not hpo:\n",
    "                    values.append(results[0][search_space][predictor][0])\n",
    "                else:\n",
    "                    means = []\n",
    "                    for hpo_seed in results.keys():\n",
    "                        if predictor in results[hpo_seed][search_space]:\n",
    "                            means.append(results[hpo_seed][search_space][predictor][0])\n",
    "                    values.append(np.max(means))\n",
    "            ranks[i] = np.flip(np.array(values).argsort()).argsort()\n",
    "            if 'nb201' in search_space:\n",
    "                nb201_indices.append(i)\n",
    "            elif 'trans' in search_space:\n",
    "                trans_indices.append(i)\n",
    "            elif 'mr' in search_space:\n",
    "                mr_indices.append(i)\n",
    "                \n",
    "        # scale by weight\n",
    "        for i in nb201_indices[1:]:\n",
    "            ranks[nb201_indices[0]] += ranks[i]\n",
    "        ranks[nb201_indices[0]] /= 3\n",
    "            \n",
    "        for i in trans_indices[1:]:\n",
    "            ranks[trans_indices[0]] += ranks[i]\n",
    "        ranks[trans_indices[0]] /= 14\n",
    "        \n",
    "        for i in mr_indices[1:]:\n",
    "            ranks[mr_indices[0]] += ranks[i]\n",
    "        ranks[mr_indices[0]] /= 4\n",
    "\n",
    "        indices_to_delete = [*nb201_indices[1:], *trans_indices[1:], *mr_indices[1:]]\n",
    "        indices_to_delete.sort(reverse=True)\n",
    "\n",
    "        for i in indices_to_delete:\n",
    "            ranks = np.delete(ranks, i, axis=0)\n",
    "               \n",
    "        ranks_1, ranks_2 = [], []\n",
    "        for i in range(len(ranks)):\n",
    "            if i in ss_indices_1:\n",
    "                ranks_1.append(ranks[i])\n",
    "            elif i in ss_indices_2:\n",
    "                ranks_2.append(ranks[i])\n",
    "                \n",
    "        avg_ranks = np.mean(ranks, axis=0) + 1\n",
    "        avg_ranks_1 = np.mean(ranks_1, axis=0) + 1\n",
    "        avg_ranks_2 = np.mean(ranks_2, axis=0) + 1\n",
    "        \n",
    "        avg_ranks_1 = [np.round(a, 2) for a in avg_ranks_1]\n",
    "        avg_ranks_2 = [np.round(a, 2) for a in avg_ranks_2]\n",
    "        avg_ranks = [np.round(a, 2) for a in avg_ranks]\n",
    "\n",
    "        print('a:', *[str(a)+' &' for a in avg_ranks])\n",
    "        print('1:', *[str(a)+' &' for a in avg_ranks_1])\n",
    "        print('2:', *[str(a)+' &' for a in avg_ranks_2])\n",
    "        \n",
    "        rank_results.append(avg_ranks)\n",
    "\n",
    "    #print(rank_results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('bohamiann', 'gp', 'rf', 'xgb', 'nao')\n",
      "a: 2.99 & 4.25 & 1.57 & 2.95 & 3.25 &\n",
      "1: 2.83 & 4.67 & 2.17 & 4.17 & 1.17 &\n",
      "2: 3.06 & 4.08 & 1.33 & 2.46 & 4.08 &\n",
      "a: 3.36 & 4.37 & 2.41 & 1.23 & 3.62 &\n",
      "1: 3.67 & 5.0 & 3.17 & 1.67 & 1.5 &\n",
      "2: 3.24 & 4.12 & 2.11 & 1.06 & 4.47 &\n"
     ]
    }
   ],
   "source": [
    "full_ss = ['nb101', \n",
    "           'nb201_c10', 'nb201_c100', 'nb201_im',\n",
    "           'darts', \n",
    "           'asr', \n",
    "           'nlp',\n",
    "           'mr_cls', 'mr_3ddet', 'mr_seg', 'mr_video',\n",
    "           'transmicro_obj', 'transmicro_scene', 'transmicro_jigsaw', \n",
    "           'transmicro_room', 'transmicro_segment', 'transmicro_normal', \n",
    "           'transmicro_auto', 'transmacro_obj', 'transmacro_scene', 'transmacro_jigsaw', \n",
    "           'transmacro_room', 'transmacro_segment', 'transmacro_normal', \n",
    "           'transmacro_auto']\n",
    "\n",
    "ss_indices_1 = [0, 1]\n",
    "ss_indices_2 = [2, 3, 4, 5, 6]\n",
    "\n",
    "\n",
    "compute_subsets(results, predictors, full_ss, ss_indices_1, ss_indices_2)"
   ]
  },
  {
   "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.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}