diff --git a/.gitignore b/.gitignore
index 3362dbf3a..1baa34e73 100644
--- a/.gitignore
+++ b/.gitignore
@@ -151,3 +151,7 @@ Session.vim
 *~
 # Auto-generated tag files
 tags
+
+# ignore png files in nb_models
+nasbench301/nb_models
+naslib/checkpoints
\ No newline at end of file
diff --git a/examples/optimizers.ipynb b/examples/optimizers.ipynb
new file mode 100644
index 000000000..c166de60e
--- /dev/null
+++ b/examples/optimizers.ipynb
@@ -0,0 +1,587 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import numpy as np\n",
+    "import json\n",
+    "import matplotlib.pyplot as plt\n",
+    "import matplotlib\n",
+    "matplotlib.rcParams['pdf.fonttype'] = 42\n",
+    "import pickle\n",
+    "import pandas as pd\n",
+    "\n",
+    "from collections import defaultdict"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# this defines all of the default colors and markers for the plots\n",
+    "# keys = ['bananas/bananas', 'hb', 'ls', 'rs', 're', 'ls_svr', 'rea_svr', 'bananas_svr/bananas']\n",
+    "# predictors = ['hb', 'bohb', 'ls', 'bananas', 're', 'npenas', 'dehb', 'rs', 'sh', ]\n",
+    "predictors = ['ls', 'bananas', 're', 'rs', 'bohb', 'dehb', 'hb', 'sh', 'npenas']\n",
+    "# predictors = ['bohb', 'hb']\n",
+    "benchmark_datasets = ['asr', ]\n",
+    "# benchmark_datasets = ['ImageNet16-120', ]\n",
+    "# TODO: What of this am I really needing?\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",
+    "            (0.7058823529411765, 0.12156862745098039, 0.4666666666666667),\n",
+    "            (0.4666666666666667, 0.8901960784313725, 0.7607843137254902,),\n",
+    "           ]\n",
+    "\n",
+    "fmts = ['-', '--', ':']\n",
+    "markers = ['^', 'v', 'o']\n",
+    "defaults = [np.array(d) for d in defaults]\n",
+    "\n",
+    "# \n",
+    "pred_plot_dict={\n",
+    "    'ls':{'color':defaults[0], 'fmt':fmts[0]},\n",
+    "    # 'ls_lce':{'color':defaults[0], 'fmt':fmts[1]},\n",
+    "    # 'ls_svr':{'color':defaults[0], 'fmt':fmts[2]},\n",
+    "    're':{'color':defaults[1], 'fmt':fmts[2]},\n",
+    "    # 'rea_lce':{'color':defaults[1], 'fmt':fmts[1]},\n",
+    "    # 'rea_svr':{'color':defaults[1], 'fmt':fmts[2]},\n",
+    "    'bananas/bananas':{'color':defaults[2], 'fmt':fmts[0]},\n",
+    "    'bananas':{'color':defaults[2], 'fmt':fmts[0]},\n",
+    "    # 'bananas_lce/bananas':{'color':defaults[2], 'fmt':fmts[1]},\n",
+    "    # 'bananas_svr/bananas':{'color':defaults[2], 'fmt':fmts[2]},    \n",
+    "    'rs':{'color':defaults[3], 'fmt':fmts[0]},\n",
+    "    'sh': {'color': defaults[1], 'fmt':fmts[0]},\n",
+    "    'hb':{'color':defaults[4], 'fmt':fmts[0]},\n",
+    "    'bohb':{'color':defaults[5], 'fmt':fmts[0]},\n",
+    "    'dehb':{'color':defaults[6], 'fmt':fmts[2]},\n",
+    "    'npenas':{'color':defaults[0], 'fmt':fmts[1]},\n",
+    "}\n",
+    "\n",
+    "# define colors, formats, and markers\n",
+    "c_max = 10\n",
+    "colors = [*defaults[:c_max], *defaults[:c_max], *defaults[:c_max]]\n",
+    "fmts = [*['-']*c_max, *['--']*c_max, *[':']*c_max]\n",
+    "markers = [*['^']*c_max, *['v']*c_max, *['o']*c_max]\n",
+    "\n",
+    "# https://matplotlib.org/2.1.2/api/_as_gen/matplotlib.pyplot.plot.html\n",
+    "\n",
+    "# some of them are not used\n",
+    "pred_label_dict={\n",
+    "    'bananas/gcn':'BANANAS-GCN', 'bananas':'BANANAS', 'bananas/xgb':'BANANAS-XGB', \n",
+    "    'npenas/gcn':'NPENAS-GCN', 'npenas/bananas':'NPENAS-BANANAS', 'npenas/xgb':'NPENAS-XGB', \n",
+    "    'rs':'RS',\n",
+    "    're': 'RE',\n",
+    "    'ls': 'LS',\n",
+    "    'hb': 'HB',\n",
+    "    'sh': 'SH',\n",
+    "    'bohb': 'BOHB',\n",
+    "    'dehb': 'DEHB',\n",
+    "    'rea_svr': 'REA-SVR',\n",
+    "    'bananas_svr/bananas':'BANANAS-SVR',\n",
+    "    'rea_lce': 'REA-WPM',\n",
+    "    'bananas_lce/bananas':'BANANAS-WPM',\n",
+    "    'ls_svr': 'LS-SVR',\n",
+    "    'ls_lce': 'LS-WPM',\n",
+    "    'ls_svr_hp': 'LS-SVR-HP',\n",
+    "    'rea_svr_hp': 'REA-SVR-HP',\n",
+    "    'bananas_svr_hp/bananas': 'BANANAS-SVR-HP',\n",
+    "    'npenas': 'NPENAS',\n",
+    "}\n",
+    "\n",
+    "val_gts = {'cifar10': 97.61, \n",
+    "           'cifar100': 73.49, \n",
+    "           'ImageNet16-120': 50.0, \n",
+    "           'nasbench311': 95.8, \n",
+    "           'nasbench111':95.6, \n",
+    "           'nasbenchnlp':100.7,\n",
+    "           'asr': 1.00,\n",
+    "           }\n",
+    "\n",
+    "datasets = {'cifar10': 'cifar10',\n",
+    "           'cifar100': 'cifar100', \n",
+    "           'ImageNet16-120': 'ImageNet16-120', \n",
+    "           'nasbench311': 'cifar10', \n",
+    "           'nasbench111':'cifar10', \n",
+    "           'nasbenchnlp':'ptb',\n",
+    "           'asr':'asr'\n",
+    "           }"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def merge_and_fill_trajectories(pandas_data_frames, default_value=None):\n",
+    "    # merge all trajectories keeping all time steps\n",
+    "    df = pd.DataFrame().join(pandas_data_frames, how='outer')\n",
+    "\n",
+    "    # forward fill to make it a propper step function\n",
+    "    df = df.fillna(method='ffill')\n",
+    "    if default_value is None:\n",
+    "        # backward fill to replace the NaNs for the early times by the\n",
+    "        # performance of a random configuration\n",
+    "        df = df.fillna(method='bfill')\n",
+    "    else:\n",
+    "        df = df.fillna(default_value)\n",
+    "    return df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_trajectories(losses, iterations):\n",
+    "    dfs = []\n",
+    "    for i in range(len(losses)):\n",
+    "        loss = losses[i]\n",
+    "        iteration = iterations[i]\n",
+    "        # print('Run %d, Min: %f'%(i, loss))\n",
+    "        df = pd.DataFrame({str(i): loss}, index=iteration)\n",
+    "        dfs.append(df)\n",
+    "\n",
+    "    df = merge_and_fill_trajectories(dfs, default_value=None)\n",
+    "\n",
+    "    return np.array(df.T), np.array(df.index)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_results(predictor, path, metric='valid_acc', key_choice=None):\n",
+    "    output = defaultdict(list)\n",
+    "    time = defaultdict(list)\n",
+    "    nan_count = 0\n",
+    "    missing_results_count = 0\n",
+    "    file_count = 0\n",
+    "    dataset_paths = []\n",
+    "    for dataset_folder in os.listdir(path):\n",
+    "        dataset_path = os.path.join(path, dataset_folder)\n",
+    "        if not(dataset_folder == datasets[key_choice] and os.path.isdir(dataset_path)):\n",
+    "            continue\n",
+    "        dataset_paths.append(dataset_path)\n",
+    "    \n",
+    "    optimizer_paths = []\n",
+    "    for dataset_path in dataset_paths:\n",
+    "        optimizer_path = os.path.join(dataset_path, predictor)\n",
+    "        if not os.path.isdir(optimizer_path):\n",
+    "            continue\n",
+    "        optimizer_paths.append(optimizer_path)\n",
+    "        # for optimizer_folder in os.listdir(dataset_path):\n",
+    "        #     optimizer_path = os.path.join(dataset_path, optimizer_folder)\n",
+    "        #     if not os.path.isdir(optimizer_path):\n",
+    "        #         continue\n",
+    "        #     optimizer_paths.append(optimizer_path)\n",
+    "\n",
+    "    config_paths = []\n",
+    "    for optimizer_path in optimizer_paths:\n",
+    "        for config_folder in os.listdir(optimizer_path):\n",
+    "            if config_folder[:7] != \"config_\":\n",
+    "                continue\n",
+    "            config_path = os.path.join(optimizer_path, config_folder)\n",
+    "            if not os.path.isdir(config_path):\n",
+    "                continue\n",
+    "            config_paths.append(config_path)\n",
+    "    \n",
+    "    result_paths = []\n",
+    "    for config_path in config_paths:\n",
+    "        for seed_folder in os.listdir(config_path):\n",
+    "            seed_dir = os.path.join(config_path, seed_folder)\n",
+    "            if not os.path.isdir(seed_dir):\n",
+    "                continue\n",
+    "            result_file = os.path.join(config_path, seed_folder, 'errors.json')\n",
+    "            if not os.path.isfile(result_file):\n",
+    "                continue\n",
+    "            result_paths.append(result_file)\n",
+    "    \n",
+    "    for result_file in result_paths:\n",
+    "        try:\n",
+    "            result = json.load(open(result_file))\n",
+    "        except:\n",
+    "            print(\"An exception occurred\")\n",
+    "            continue\n",
+    "        # config = result[0]\n",
+    "        epochs = len(result[1]['train_time'])\n",
+    "\n",
+    "        val_acc = result[1]['valid_acc'][:epochs]\n",
+    "\n",
+    "        if key_choice == 'nasbench111':\n",
+    "            val_incumbent = [(val_gts[key_choice] - val_acc[0] *  100.) / 100.]\n",
+    "            for  ind in range(1, len(val_acc)):\n",
+    "                val_incumbent.append((val_gts[key_choice] - max(val_acc[:ind]) *100.)  / 100)\n",
+    "        elif key_choice == 'nasbenchnlp':\n",
+    "            val_incumbent = [np.exp(100 - val) - val_gts[key_choice] for val in val_acc]\n",
+    "        elif key_choice == 'asr':\n",
+    "            val_incumbent = [(val_gts[key_choice] - val_acc[0])]\n",
+    "            for ind in range(1, len(val_acc)):\n",
+    "                val_incumbent.append((val_gts[key_choice] - max(val_acc[:ind])))\n",
+    "        else:\n",
+    "            # TODO: is this scaling really necessary?\n",
+    "            val_incumbent = [(val_gts[key_choice] - val_acc[0]) / 100]\n",
+    "            for ind in range(1, len(val_acc)):\n",
+    "                val_incumbent.append((val_gts[key_choice] - max(val_acc[:ind])) / 100)\n",
+    "\n",
+    "\n",
+    "        runtime = result[1]['runtime']\n",
+    "        train_time = result[1]['train_time']\n",
+    "        runtime = [sum(runtime[:epoch]) for epoch in range(1, len(runtime)+1)]\n",
+    "        train_time = [sum(train_time[:epoch]) for epoch in range(1, len(train_time)+1)]\n",
+    "        total_time = [i+j for i,j in zip(runtime, train_time)]\n",
+    "        if predictor in {'rs', 'ls', 're', 'bananas', 'npenas'} and not key_choice == 'asr':\n",
+    "            # continue\n",
+    "            total_time[:] = [x * 200.0 for x in total_time]\n",
+    "        elif predictor in {'rs', 'ls', 're', 'bananas', 'npenas'} and key_choice == 'asr':\n",
+    "            total_time = train_time\n",
+    "            total_time[:] = [x * -40 for x in total_time]\n",
+    "        # I think we should just plot validation accs, since that's what the nas algorithm uses\n",
+    "        if metric == 'valid_acc':\n",
+    "            incumbent = val_incumbent\n",
+    "            #incumbent = val_acc\n",
+    "        elif metric == 'test_acc':\n",
+    "            test_err = [100 - x for x in result[1]['test_acc']]\n",
+    "            inc_idx, best, best_idx = [], np.inf, 0\n",
+    "            for i, err in enumerate(val_err):\n",
+    "                if err < best:\n",
+    "                    best, best_idx = err, i\n",
+    "                inc_idx.append(best_idx)\n",
+    "            incumbent = [test_err[idx] for idx in inc_idx]\n",
+    "\n",
+    "        if len(incumbent) == epochs:\n",
+    "            output[result[0]['config_id']].append(incumbent)\n",
+    "            time[result[0]['config_id']].append(total_time)\n",
+    "\n",
+    "            # output.append(incumbent)\n",
+    "            # time.append(total_time)\n",
+    "        else:\n",
+    "            nan_count += 1\n",
+    "\n",
+    "    output = {key: np.array(item) for key,item in output.items()}\n",
+    "    time = {key: np.array(item) for key,item in time.items()}\n",
+    "    # output = np.array(output)\n",
+    "    # time = np.array(time)\n",
+    "    \n",
+    "    # output, time = get_trajectories(output, time)\n",
+    "\n",
+    "    for config_id in output.keys():\n",
+    "        output[config_id], time[config_id] = get_trajectories(output[config_id], time[config_id])\n",
+    "    # output, time = get_trajectories(output, time)\n",
+    "    print(f\"predictor: {predictor}\")\n",
+    "    means = defaultdict(list)\n",
+    "    means = {key: np.mean(item, axis=0) for key,item in output.items()}\n",
+    "    incumbent_settings = min(means.items(), key=lambda item: item[1][-1])\n",
+    "    # incumbent_settings = [0, means[0]]\n",
+    "    print(f\"Best config: {incumbent_settings[0]}\")\n",
+    "    mean = incumbent_settings[1]\n",
+    "    std = np.std(output[incumbent_settings[0]], axis=0)\n",
+    "    std_error = np.std(output[incumbent_settings[0]], axis=0, ddof=1) / np.sqrt(np.size(output[incumbent_settings[0]]))\n",
+    "    time = time[incumbent_settings[0]]\n",
+    "    # print(predictor, 'output shape', output.shape, 'nans', nan_count, 'missing files', missing_results_count)\n",
+    "    # print(f\"predictor: {predictor}, best config: {incumbent_settings[0]}\")\n",
+    "    print('first mean', mean[0], 'last mean', mean[-1])\n",
+    "    print('first std', std[0], 'last std', std[-1])\n",
+    "    print('time ', time[-1])\n",
+    "    return mean, std, std_error, time"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def save_results_to_dict(folder, predictors, key_choice):\n",
+    "    results_dict = {}\n",
+    "    print('\\n saving', key_choice)\n",
+    "    for _, predictor in enumerate(predictors):\n",
+    "        mean, std, std_error, runtime = get_results(predictor, folder, metric='valid_acc', key_choice=key_choice)\n",
+    "        key = predictor\n",
+    "        results_dict[key] = {'label':pred_label_dict[predictor], \n",
+    "                             'key':key, 'mean':mean, 'std':std, \n",
+    "                             'std_error': std_error, 'runtime': runtime}\n",
+    "    return results_dict"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def save_all_results():     \n",
+    "    # key_choice = 'nasbench311'\n",
+    "    folder = os.path.expanduser(os.path.join(base_path, 'nasbench201'))\n",
+    "    all_results = {dataset:save_results_to_dict(folder, predictors, dataset) for dataset in benchmark_datasets}\n",
+    "    return all_results"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Load results into dictionary"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "base_path = '/Users/lars/Projects/results/all_experiments/'\n",
+    "\n",
+    "results = save_all_results()\n",
+    "\n",
+    "# result_file = open('/Users/lars/Downloads/results_1/results_ob', 'wb')\n",
+    "# pickle.dump(results, result_file)\n",
+    "# result_file.close()\n",
+    "\n",
+    "# result_file = open('/Users/lars/Downloads/results_1/results_ob', 'rb')\n",
+    "# results = pickle.load(result_file)\n",
+    "print"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# filepath='/Users/lars/Projects/results/plot_files/nb201.pickle'\n",
+    "# result_file = open(filepath, 'wb')\n",
+    "# pickle.dump(results, result_file)\n",
+    "# result_file.close()\n",
+    "\n",
+    "result_file = open('/Users/lars/Projects/results/plot_files/nbasr.pickle', 'rb')\n",
+    "results = pickle.load(result_file)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Plotting results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "result_folder = 'plots_naslib/'\n",
+    "if not os.path.exists(result_folder):\n",
+    "    os.makedirs(result_folder)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 324x252 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# plot performance vs runtime\n",
+    "\n",
+    "for key_choice in results.keys():\n",
+    "    results_dict = results[key_choice]\n",
+    "\n",
+    "    keys = predictors\n",
+    "\n",
+    "\n",
+    "    keys = sorted(keys)\n",
+    "\n",
+    "    plt.rcParams['axes.grid'] = True\n",
+    "    plt.rcParams['grid.linestyle'] = 'dotted'\n",
+    "    add_sub_axes = False\n",
+    "\n",
+    "    fig, ax = plt.subplots(figsize=[4.5, 3.5])\n",
+    "    if add_sub_axes:\n",
+    "        sub_axes = plt.axes([.6, .5, .3, .38]) \n",
+    "\n",
+    "\n",
+    "    for i, key in enumerate(keys):\n",
+    "        mean = results_dict[key]['mean']\n",
+    "        sem = results_dict[key]['std_error']\n",
+    "        label = results_dict[key]['label']\n",
+    "        x = results_dict[key]['runtime']\n",
+    "        #tag = '_'.join(key.split('_')[:-1])\n",
+    "        tag = key\n",
+    "        color = pred_plot_dict[tag]['color']\n",
+    "        fmt = pred_plot_dict[tag]['fmt']\n",
+    "        ax.plot(x, mean, label=label, color=color, linestyle=fmt, linewidth=2.5)\n",
+    "        ax.fill_between(x, mean-2*sem, mean+2*sem,\n",
+    "                        color=color, alpha=0.2)\n",
+    "\n",
+    "        if add_sub_axes:\n",
+    "            n = 450\n",
+    "            X_detail = x[n:]\n",
+    "            Y_detail = mean[n:]\n",
+    "            sem_detail = sem[n:]\n",
+    "            sub_axes.plot(X_detail, Y_detail, color=color, linestyle=fmt)\n",
+    "            sub_axes.tick_params(labelbottom=False) \n",
+    "\n",
+    "    ax.set_xlabel('Runtime (seconds)', fontsize=14)\n",
+    "\n",
+    "    if key_choice == 'nasbenchnlp':\n",
+    "        ax.set_ylabel('Perplexity regret', fontsize=14) #nas201\n",
+    "    else:\n",
+    "        ax.set_ylabel('Valid. regret', fontsize=14) #nas201\n",
+    "\n",
+    "    # ax.grid(True, which=\"both\",ls=\"-\", alpha=.5)\n",
+    "\n",
+    "    if key_choice == 'cifar10':    \n",
+    "        ax.set_xscale('log')\n",
+    "        ax.set_yscale('log')\n",
+    "        # for nasbench201\n",
+    "        # ax.set_ylim([2e-4, 1e-2])\n",
+    "        # ax.set_xlim([2.0e5, 7.6*1e5])\n",
+    "\n",
+    "        # for nasbench311\n",
+    "        ax.set_ylim([2.5e-2, 4.2e-2])\n",
+    "        ax.set_xlim([1.9e4 *7 / 7, 1.8e6])\n",
+    "        ax.legend(bbox_to_anchor=(1.04,0.5), loc=\"center left\", borderaxespad=0)\n",
+    "        # ax.set_title('NAS-Bench-201 CIFAR10', fontsize=14)\n",
+    "        ax.set_title('NAS-Bench-311 CIFAR10', fontsize=14)\n",
+    "        save_path = os.path.join(result_folder, 'nas201_c10.pdf')\n",
+    "        plt.savefig(os.path.expanduser(save_path), bbox_inches = 'tight', pad_inches = 0.1)\n",
+    "    elif key_choice == 'cifar100':    \n",
+    "        ax.set_xscale('log')\n",
+    "        ax.set_yscale('log')\n",
+    "        ax.set_ylim([0.002, 0.03])\n",
+    "        ax.set_xlim([1e5, 1e6])\n",
+    "        ax.legend(bbox_to_anchor=(1.04,0.5), loc=\"center left\", borderaxespad=0)\n",
+    "        ax.set_title('NAS-Bench-201 CIFAR100', fontsize=14)\n",
+    "        save_path = os.path.join(result_folder, 'nas201_c100.pdf')\n",
+    "        plt.savefig(os.path.expanduser(save_path), bbox_inches = 'tight', pad_inches = 0.1)\n",
+    "    elif key_choice == 'ImageNet16-120':    \n",
+    "        ax.set_xscale('log')\n",
+    "        ax.set_yscale('log')\n",
+    "        # ax.set_ylim([0.0025, 0.3])\n",
+    "        ax.set_ylim([2.7e-2, 6.8e-2])\n",
+    "        ax.set_xlim([1.5e5, 3.2e6])\n",
+    "        ax.legend(bbox_to_anchor=(1.04,0.5), loc=\"center left\", borderaxespad=0)\n",
+    "        ax.set_title('NAS-Bench-201 ImageNet16-120', fontsize=14, loc='right')\n",
+    "        save_path = os.path.join(result_folder, 'nas201_im.pdf')\n",
+    "        plt.savefig(os.path.expanduser(save_path), bbox_inches = 'tight', pad_inches = 0.1)\n",
+    "    elif key_choice == 'nasbench311':    \n",
+    "        ax.set_xscale('log')\n",
+    "        ax.set_yscale('log')\n",
+    "        # ax.set_ylim([.035, .066])\n",
+    "        # ax.set_xlim([400, 2100])\n",
+    "        # ax.set_ylim([2e-3, .028])\n",
+    "        # ax.set_xlim([5e4, 4*10e5])\n",
+    "        ax.legend(ncol=2, loc=3, fontsize=8)\n",
+    "        ax.set_title('NAS-Bench-311 CIFAR10', fontsize=14)\n",
+    "        save_path = os.path.join(result_folder, 'nas311_c10.pdf')\n",
+    "        plt.show()\n",
+    "        plt.savefig(os.path.expanduser(save_path), bbox_inches = 'tight', pad_inches = 0.1)\n",
+    "\n",
+    "    elif key_choice == 'nasbench111':\n",
+    "        ax.set_xscale('log')\n",
+    "        ax.set_yscale('log')\n",
+    "        ax.set_ylim([4e-4, 8e-2])\n",
+    "        ax.set_xlim([2e4, 5.8*10e4])\n",
+    "        ax.legend(ncol=2, loc=3, fontsize=8)\n",
+    "        ax.set_title('NAS-Bench-111 CIFAR10', fontsize=14)\n",
+    "        save_path = os.path.join(result_folder, 'nas111_c10.pdf')\n",
+    "        plt.savefig(os.path.expanduser(save_path), bbox_inches = 'tight', pad_inches = 0.1)\n",
+    "\n",
+    "    elif key_choice == 'nasbenchnlp':\n",
+    "        ax.set_xscale('log')\n",
+    "        ax.set_yscale('log')\n",
+    "        ax.set_ylim([.5, 4.2e1])\n",
+    "        ax.set_xlim([5e4, 1.1*10e6])\n",
+    "        ax.legend(ncol=2, loc=3, fontsize=8)\n",
+    "        ax.set_title('NAS-Bench-NLP11 PTB', fontsize=14)\n",
+    "        save_path = os.path.join(result_folder, 'nasn11_ptb.pdf')\n",
+    "        plt.savefig(os.path.expanduser(save_path), bbox_inches = 'tight', pad_inches = 0.1)\n",
+    "    \n",
+    "    elif key_choice == 'asr':\n",
+    "        # ax.set_xscale('log')\n",
+    "        ax.set_yscale('log')\n",
+    "        ax.set_ylim([0.026, 0.04])\n",
+    "        ax.set_xlim([700, 16000])\n",
+    "        ax.legend(bbox_to_anchor=(1.04,0.5), loc=\"center left\", borderaxespad=0)\n",
+    "        ax.set_title('NAS-Bench-ASR', fontsize=14)\n",
+    "        save_path = os.path.join(result_folder, 'nbasr.pdf')\n",
+    "        ax.set_xlabel('Iterations', fontsize=14)\n",
+    "        plt.savefig(os.path.expanduser(save_path), bbox_inches = 'tight', pad_inches = 0.1)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "interpreter": {
+   "hash": "e28e65abac2798f30acc960ffff31a2f506562b074c32d55b97f302318a49627"
+  },
+  "kernelspec": {
+   "display_name": "jupyter-venv",
+   "language": "python",
+   "name": "jupyter-venv"
+  },
+  "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.8.9"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/optimizers_HPO.ipynb b/examples/optimizers_HPO.ipynb
new file mode 100644
index 000000000..23e7e9876
--- /dev/null
+++ b/examples/optimizers_HPO.ipynb
@@ -0,0 +1,1783 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Plotting for NAS-Bench-Suite predictors"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import random\n",
+    "import numpy as np\n",
+    "import json\n",
+    "import matplotlib.pyplot as plt\n",
+    "import matplotlib\n",
+    "from scipy.stats import kendalltau\n",
+    "matplotlib.rcParams['pdf.fonttype'] = 42"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "11/14: added extra matrix experiments for the rebuttal. \n",
+    "BBO has a lot more weird nan issues than pred, so I made some adjustments.\n",
+    "\n",
+    "This notebook is similar to plot_pred_nov12.ipynb but with black-box optimizer (NAS) \n",
+    "results instead of performance predictor results.\n",
+    "\n",
+    "plot_pred_nov12.ipynb is slightly cleaner and better commented than this notebook.\n"
+   ]
+  },
+  {
+   "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/bbo_results_oct1/bbo_results_oct1_0/nasbench201/cifar100/npenas/config_28/7\n",
+    "\n",
+    "# and the result dict structure:\n",
+    "# results_dict[28][nb201_c10_c10][npenas] = [np.mean(values), np.std(values)]\n",
+    "\n",
+    "def get_hpo_results(optimizers, search_spaces, root):\n",
+    "    errors = 0\n",
+    "    results_dict = {}\n",
+    "    root = os.path.expanduser(root)\n",
+    "    for search_space in search_spaces:\n",
+    "        # print(search_space)\n",
+    "        for optimizer in optimizers:\n",
+    "            # print(optimizer)\n",
+    "            optimizer_path = os.path.join(root, file_dict[search_space], optimizer)\n",
+    "            #print(optimizer_path)\n",
+    "            if not os.path.exists(optimizer_path):\n",
+    "                continue\n",
+    "            for hpo_folder in os.listdir(optimizer_path):  #change seed and hpo_folder\n",
+    "                #print(hpo_folder)\n",
+    "                if hpo_folder[:7] != 'config_':\n",
+    "                    continue\n",
+    "                hpo_seed = int(hpo_folder.split('_')[-1])\n",
+    "                values = []\n",
+    "                for seed in os.listdir(optimizer_path + '/' + hpo_folder):\n",
+    "                    result_path = optimizer_path + '/' + hpo_folder + '/' + seed + '/errors.json'\n",
+    "                    # print(result_path)\n",
+    "                    if not os.path.isfile(result_path):\n",
+    "                        continue\n",
+    "                    result = json.load(open(result_path))\n",
+    "                    valid_accs = result[1]['valid_acc']\n",
+    "                    value = np.max(valid_accs)\n",
+    "                    \n",
+    "                    #print(value)\n",
+    "                    if np.isnan(value):\n",
+    "                        #print(type(value))\n",
+    "                        continue\n",
+    "                    value = float(value)\n",
+    "                    #print(value)\n",
+    "                    values.append(value)\n",
+    "                \n",
+    "                \n",
+    "                    \n",
+    "                # had to add these if statements because file structure is in a different order\n",
+    "                if hpo_seed not in results_dict:\n",
+    "                    results_dict[hpo_seed] = {}\n",
+    "                if search_space not in results_dict[hpo_seed]:\n",
+    "                    results_dict[hpo_seed][search_space] = {}\n",
+    "                if optimizer not in results_dict[hpo_seed][search_space]:\n",
+    "                    results_dict[hpo_seed][search_space][optimizer] = {}\n",
+    "                results_dict[hpo_seed][search_space][optimizer] = [np.mean(values), np.std(values)]\n",
+    "                   \n",
+    "    return results_dict"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "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",
+    "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",
+    "# TODO: adapt this for multi-fidelity\n",
+    "color_dict={\n",
+    "    #'rs':{'color':defaults[0], 'fmt':fmts[0]},\n",
+    "    #'re':{'color':defaults[1], 'fmt':fmts[0]},\n",
+    "    #'ls':{'color':defaults[2], 'fmt':fmts[0]},\n",
+    "    #'bananas':{'color':defaults[3], 'fmt':fmts[0]},\n",
+    "    #'npenas':{'color':defaults[4], 'fmt':fmts[0]},\n",
+    "    'sh': {'color': defaults[1], 'fmt': fmts[0]},\n",
+    "    'hb': {'color': defaults[2], 'fmt': fmts[0]},\n",
+    "    'bohb': {'color': defaults[3], 'fmt': fmts[0]},\n",
+    "    'dehb': {'color': defaults[4], 'fmt': fmts[0]},\n",
+    "\n",
+    "}\n",
+    "\n",
+    "# https://matplotlib.org/2.1.2/api/_as_gen/matplotlib.pyplot.plot.html\n",
+    "\n",
+    "# how the optimizer names will be displayed in the plot legends:\n",
+    "# TODO: adapt this for multi-fidelity\n",
+    "pred_label_dict={\n",
+    "    'rs': 'Rand. Search', 're':'Reg. Evo.', 'ls':'Local Search', \n",
+    "    'bananas':'BANANAS', 'npenas':'NPENAS', 'sh': 'Succesive Halving', 'hb': 'Hyberband',\n",
+    "    'bohb': 'BOHB', 'dehb': 'DEHB'\n",
+    "}\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# search space constants\n",
+    "\n",
+    "# how the search space name will be displayed in the plot titles:\n",
+    "# TODO: adapt this for multi-fidelity\n",
+    "\n",
+    "ss_dict_lined = {'nb201_c10':'NB-201\\n CIFAR10'}\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",
+    "                 'nb311_c10':'NB-311\\n CIFAR10',\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",
+    "# TODO: adapt this for multi-fidelity\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",
+    "                 'nb311_c10': 'NB-301 CIFAR10',\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",
+    "# these are the filenames as of sep24\n",
+    "# TODO: adapt this for multi-fidelity\n",
+    "file_dict = {\n",
+    "    'nb101':'nasbench101/cifar10', \n",
+    "    'nb201_c10':'nasbench201/cifar10', \n",
+    "    'nb201_c100':'nasbench201/cifar100', \n",
+    "    'nb201_im':'nasbench201/ImageNet16-120', \n",
+    "    'nb311_c10':'nasbench311/cifar10',\n",
+    "    'darts':'darts/cifar10', \n",
+    "    'nlp':'nlp/LM-task', \n",
+    "    'asr':'asr/asr', \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',\n",
+    "    'mr_seg':'mr/seg',\n",
+    "    'mr_video':'mr/video',\n",
+    "            }\n",
+    "# TODO: adapt this for multi-fidelity\n",
+    "ss_dict_mat = {'nb101':'NB-101', \n",
+    "                 'nb201_c10':'NB-201', \n",
+    "                 'nb201_c100':'NB-201', \n",
+    "                 'nb201_im':'NB-201', \n",
+    "                 'nb311_c10': 'NB-311',\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",
+    "          }"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Now load all of the data\n",
+    " - Each algorithm is tagged as \"algorithm_date\" and then later we can pick which ones we want to plot\n",
+    " - The next cell will create a dictionary will all of the results from the specified search space"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n",
+      "what?\n"
+     ]
+    }
+   ],
+   "source": [
+    "# do not accidentally run this twice.\n",
+    "# takes >30 min to load all these results\n",
+    "if True:\n",
+    "    search_spaces = ['nb201_c10','nb201_c100','nb201_im', 'nb311_c10', 'asr']\n",
+    "    # search_spaces = ['asr']\n",
+    "    optimizers=('sh', 'hb', 'bohb','dehb')\n",
+    "    #optimizers=('rs', 're', 'ls', 'npenas',  'hb', 'bohb','dehb')\n",
+    "    root = '/home/till/all_experiments_smaller'\n",
+    "\n",
+    "\n",
+    "    results = get_hpo_results(optimizers, search_spaces, root=root)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'nb201_c10': {'sh': [91.266, 0.14058449416631907],\n",
+       "  'hb': [91.237, 0.1937549999354859],\n",
+       "  'bohb': [91.28399998876952, 0.16047927996122993],\n",
+       "  'dehb': [91.46839998706055, 0.15957393322422234]},\n",
+       " 'nb201_c100': {'sh': [72.83599995605468, 0.4194091327042208],\n",
+       "  'hb': [73.04799997802735, 0.3842082780699827],\n",
+       "  'bohb': [72.273, 0.3776254758355177],\n",
+       "  'dehb': [72.381, 0.46007499388686585]},\n",
+       " 'nb201_im': {'sh': [46.12666665445964, 0.3039737034405422],\n",
+       "  'hb': [46.273333309936525, 0.2164357401938302],\n",
+       "  'bohb': [45.981666661580405, 0.32909388676447],\n",
+       "  'dehb': [46.31166666056315, 0.31305396116253725]},\n",
+       " 'nb311_c10': {'sh': [94.36338508817775, 0.05634092470148716],\n",
+       "  'hb': [94.26923521643795, 0.05639211939481929],\n",
+       "  'bohb': [94.28346731038835, 0.08095619478093283],\n",
+       "  'dehb': [94.26727583389199, 0.05562582737382367]},\n",
+       " 'asr': {'sh': [0.9391645073890686, 0.00866653351374373],\n",
+       "  'hb': [0.9391645073890686, 0.00866653351374373],\n",
+       "  'bohb': [0.9391645073890686, 0.00866653351374373],\n",
+       "  'dehb': [0.9391645073890686, 0.00866653351374373]}}"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results[12]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ss_group_full = ['nb101', 'nb201_c10', 'nb201_c100', 'nb201_im', 'darts', 'asr', 'nlp',\n",
+    "                 'mr_3ddet', 'mr_video', 'mr_cls', 'mr_seg',\n",
+    "            'transmicro_obj', 'transmicro_scene', 'transmicro_jigsaw', \n",
+    "            'transmicro_room', 'transmicro_segment', 'transmicro_normal', 'transmicro_auto', \n",
+    "            'transmacro_obj', 'transmacro_scene', 'transmacro_jigsaw', \n",
+    "            'transmacro_room', 'transmacro_segment', 'transmacro_normal', 'transmacro_auto']\n",
+    "\n",
+    "ss_group_full = [\"nb201_c10\",'nb201_c100', 'nb201_im', 'nb311_c10', 'asr']"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Now plot everything"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "result_folder = 'plots_naslib/'\n",
+    "# specify the seed that represents the default config:\n",
+    "default_config = 0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# plot default and hpo side by side\n",
+    "def plot_default_hpo(results, ss_group, optimizers, offset=0.1, scale_type='0-1', one_line=False, label=False, save=None):\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 optimizer in optimizers:\n",
+    "            mean = results[default_config][search_space][optimizer][0]\n",
+    "            means.append(mean)\n",
+    "\n",
+    "            hpo_means = []\n",
+    "            for hpo_seed in results.keys():\n",
+    "                if optimizer not in results[hpo_seed][search_space]:\n",
+    "                    continue\n",
+    "                hpo_means.append(results[hpo_seed][search_space][optimizer][0])\n",
+    "            mean = np.max(hpo_means)\n",
+    "            means.append(mean)\n",
+    "        \n",
+    "        #print(search_space, means[::2])\n",
+    "        if scale_type == '0-1':\n",
+    "            min_acc, max_acc = np.min(means), np.max(means)\n",
+    "            \n",
+    "            means = [(m - min_acc) / (max_acc - min_acc) for m in means]\n",
+    "\n",
+    "        i = 0\n",
+    "        print(means)\n",
+    "        for optimizer in optimizers:\n",
+    "            color = color_dict[optimizer]['color']\n",
+    "            \n",
+    "            # to average nbmr\n",
+    "            first, second = i, i+1\n",
+    "            if optimizer == 'rs' and 'mr' in search_space:\n",
+    "                second = i\n",
+    "            \n",
+    "            if width == 1:\n",
+    "                ax.scatter(width-offset, means[first], label=pred_label_dict[optimizer], color=color, marker='o')\n",
+    "                ax.scatter(width+offset, means[second], label=pred_label_dict[optimizer]+'+HPO', color=color, marker='x')\n",
+    "            else:\n",
+    "                ax.scatter(width-offset, means[first], color=color, marker='o')    \n",
+    "                ax.scatter(width+offset, means[second], color=color, marker='x')\n",
+    "            i = i + 2\n",
+    "\n",
+    "    ax.set_xticks(range(1, len(ss_order)+1))\n",
+    "    if label:\n",
+    "        ax.set_xticklabels(ss_order, fontsize=12, rotation=90)\n",
+    "    else:\n",
+    "        ax.set_xticklabels(['' for _ in range(len(ss_order))], fontsize=12, rotation=90)\n",
+    "\n",
+    "    if one_line:\n",
+    "        ax.legend(loc=(1.5,-.6))\n",
+    "    else:\n",
+    "        ax.legend(loc=(1.01,0))\n",
+    "    #ax.set_xlabel('NAS Benchmark Task', fontsize=14)    \n",
+    "    ax.set_ylabel('Scaled Accuracy', fontsize=12)   \n",
+    "    #ax.set_title('Scaled Accuracy of NAS Algorithms', fontsize=14)\n",
+    "    ax.set_title('NAS Algorithms', fontsize=14)\n",
+    "    \n",
+    "    # ax.set_ylim([0.87, 1.01])\n",
+    "\n",
+    "    if save:\n",
+    "        plt.savefig(result_folder + save, bbox_inches = 'tight', pad_inches = 0.1)\n",
+    "    #print(results)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0.0, 0.9837089326419765, 0.8851479823472483, 0.9004208577623529, 0.9481401064322361, 0.974205812232986, 0.9697257672864024, 1.0]\n",
+      "[0.0, 1.0, 0.9909803289368057, 0.9971905892109996, 0.878160579624427, 0.9893538370545611, 0.9569717580955222, 0.9847700724530541]\n",
+      "[0.0, 1.0, 0.9493108997275121, 0.969399667011749, 0.9138051849225748, 0.9778089243083563, 0.9614576043946751, 0.9976640991715656]\n",
+      "[0.0, 1.0, 0.954000984109979, 0.954000984109979, 0.9017026020519446, 0.9373531208241042, 0.9772525033885769, 0.9772525033885769]\n",
+      "[0.8860806085516122, 1.0, 0.6101329843431573, 0.7215281043880724, 0.3949428233214571, 0.653175106276154, 0.0, 0.1443015311489578]\n"
+     ]
+    },
+    {
+     "ename": "FileNotFoundError",
+     "evalue": "[Errno 2] No such file or directory: 'plots_naslib/multi-fidelity-zoomed-HPO.pdf'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
+      "\u001b[0;32m/tmp/ipykernel_4834/4026343565.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# plot_default_hpo(results, ss_group_full, optimizers, scale_type='0-1', one_line=True, label=True) #, save='optimizers_appendix.pdf')\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0moptimizers\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'sh'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'hb'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'bohb'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'dehb'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mplot_default_hpo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresults\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mss_group_full\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptimizers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mscale_type\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'0-1'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mone_line\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msave\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'multi-fidelity-zoomed-HPO.pdf'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0mplot_default_hpo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresults\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mss_group_full\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptimizers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mscale_type\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mone_line\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m#, save='optimizers_appendix.pdf')\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/tmp/ipykernel_4834/460307967.py\u001b[0m in \u001b[0;36mplot_default_hpo\u001b[0;34m(results, ss_group, optimizers, offset, scale_type, one_line, label, save)\u001b[0m\n\u001b[1;32m     69\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     70\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0msave\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 71\u001b[0;31m         \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msavefig\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresult_folder\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0msave\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbbox_inches\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'tight'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpad_inches\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0.1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     72\u001b[0m     \u001b[0;31m#print(results)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/anaconda3/envs/naslib_exercises/lib/python3.7/site-packages/matplotlib/pyplot.py\u001b[0m in \u001b[0;36msavefig\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    977\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0msavefig\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    978\u001b[0m     \u001b[0mfig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgcf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 979\u001b[0;31m     \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msavefig\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    980\u001b[0m     \u001b[0mfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw_idle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m   \u001b[0;31m# need this if 'transparent=True' to reset colors\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    981\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mres\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/anaconda3/envs/naslib_exercises/lib/python3.7/site-packages/matplotlib/figure.py\u001b[0m in \u001b[0;36msavefig\u001b[0;34m(self, fname, transparent, **kwargs)\u001b[0m\n\u001b[1;32m   3044\u001b[0m                         ax.patch._cm_set(facecolor='none', edgecolor='none'))\n\u001b[1;32m   3045\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3046\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprint_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   3047\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3048\u001b[0m     def ginput(self, n=1, timeout=30, show_clicks=True,\n",
+      "\u001b[0;32m~/anaconda3/envs/naslib_exercises/lib/python3.7/site-packages/matplotlib/backend_bases.py\u001b[0m in \u001b[0;36mprint_figure\u001b[0;34m(self, filename, dpi, facecolor, edgecolor, orientation, format, bbox_inches, pad_inches, bbox_extra_artists, backend, **kwargs)\u001b[0m\n\u001b[1;32m   2323\u001b[0m                         \u001b[0morientation\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0morientation\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2324\u001b[0m                         \u001b[0mbbox_inches_restore\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0m_bbox_inches_restore\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2325\u001b[0;31m                         **kwargs)\n\u001b[0m\u001b[1;32m   2326\u001b[0m             \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2327\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mbbox_inches\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mrestore_bbox\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/anaconda3/envs/naslib_exercises/lib/python3.7/site-packages/matplotlib/backend_bases.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m   1646\u001b[0m             \u001b[0mkwargs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1647\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1648\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1649\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1650\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/anaconda3/envs/naslib_exercises/lib/python3.7/site-packages/matplotlib/_api/deprecation.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*inner_args, **inner_kwargs)\u001b[0m\n\u001b[1;32m    387\u001b[0m             \u001b[0;31m# Early return in the simple, non-deprecated case (much faster than\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    388\u001b[0m             \u001b[0;31m# calling bind()).\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 389\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minner_args\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0minner_kwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    390\u001b[0m         \u001b[0marguments\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msignature\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minner_args\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0minner_kwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marguments\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    391\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mis_varargs\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0marguments\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/anaconda3/envs/naslib_exercises/lib/python3.7/site-packages/matplotlib/backends/backend_pdf.py\u001b[0m in \u001b[0;36mprint_pdf\u001b[0;34m(self, filename, dpi, bbox_inches_restore, metadata)\u001b[0m\n\u001b[1;32m   2781\u001b[0m             \u001b[0mfile\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfilename\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_file\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2782\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2783\u001b[0;31m             \u001b[0mfile\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mPdfFile\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfilename\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetadata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmetadata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2784\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2785\u001b[0m             \u001b[0mfile\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnewPage\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwidth\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mheight\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/anaconda3/envs/naslib_exercises/lib/python3.7/site-packages/matplotlib/backends/backend_pdf.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, filename, metadata)\u001b[0m\n\u001b[1;32m    652\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moriginal_file_like\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    653\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtell_base\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 654\u001b[0;31m         \u001b[0mfh\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mopened\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcbook\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto_filehandle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfilename\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"wb\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreturn_opened\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    655\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mopened\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    656\u001b[0m             \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/anaconda3/envs/naslib_exercises/lib/python3.7/site-packages/matplotlib/cbook/__init__.py\u001b[0m in \u001b[0;36mto_filehandle\u001b[0;34m(fname, flag, return_opened, encoding)\u001b[0m\n\u001b[1;32m    449\u001b[0m             \u001b[0mfh\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbz2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mBZ2File\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mflag\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    450\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 451\u001b[0;31m             \u001b[0mfh\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mflag\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mencoding\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mencoding\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    452\u001b[0m         \u001b[0mopened\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    453\u001b[0m     \u001b[0;32melif\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'seek'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'plots_naslib/multi-fidelity-zoomed-HPO.pdf'"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 151.2x144 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# plot_default_hpo(results, ss_group_full, optimizers, scale_type='0-1', one_line=True, label=True) #, save='optimizers_appendix.pdf')\n",
+    "optimizers=('sh', 'hb', 'bohb','dehb')\n",
+    "plot_default_hpo(results, ss_group_full, optimizers, scale_type='0-1', one_line=True, label=True, save='multi-fidelity-zoomed-HPO.pdf')\n",
+    "plot_default_hpo(results, ss_group_full, optimizers, scale_type=None, one_line=True, label=True) #, save='optimizers_appendix.pdf')\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# run the transabilty model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "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, optimizers, optimizer):\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 optimizers:\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][optimizer][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, title = \"Optimizers\"):\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 {}'.format(title))\n",
+    "    else:\n",
+    "        plt.title('Generalizability for {}'.format(title))\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_oneline[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_oneline[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": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "num valid 100\n",
+      "num valid 100\n",
+      "num valid 100\n",
+      "num valid 100\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x360 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x360 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x360 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x360 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x360 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x360 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x360 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x360 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAa0AAAGMCAYAAABppv2kAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAA7l0lEQVR4nO3debxkVXnu8d9DKzLKEEYBaUTUMCgyRxBRGVoTRQkqSBSMSLiRgCBGHKItxoEggjdhEJErGhUIKqAiCArGAbEBOw3dKDRzI4PQEHBg6O7n/rFXwaaoM9c5dXbV8/186kPtadW7z2nqPWvtd68t20RERDTBcr0OICIiYrSStCIiojGStCIiojGStCIiojGStCIiojGStCIiojGStGKgSLpC0sHl/QGSfjjB9naTtGiY7adJ+pdO+0qaL2m3iXx+ra11Jf23pEckndCNNidD/ecxjmM/LOmMbscUzfKsXgcQzSdpP+BIYEvgj8CtwFnAqZ7GNwLa/jrw9Un+jEOH2bZF672k2cALbf/dOD/qEOB+4Lnd+plL2hA4DpgFrADMB461/b1RHn8QcLDtXVrrhvt5jMT2p8d7bPSP9LRiQiS9H/gCcDywHrAucCiwM7D8FMcyyH+EbQwsGE/C6vRzk7Qm8DPgcWALYC3gROAbkvadYKzTxoD/m2km23nlNa4XsBpVz+pvR9jvOcDngDuAe4HTgBXLtt2ARcD7gfuAu4F3jfHYDwL3AF8D1gC+B/weeLC837DW3hVUf/0DHAT8rLz/Z+APtdcTwFfKtncBNwCPALcA/1BrrxXDh6l6OrcBB9S2fwX41/q+tW23AbtT9WQeL5/5B+B/gLcA17T9HI8CLujw8/1KOfbxcvzu5ed2EvC78joJeM5QP7cObX4SuB5Yrm39B4HbAZVlA4eXn8v9VH+8LAf8JfAosLTE9NBQP4/ys2/97t8EvB64EVgMfLj22bOB/yzv/6Pt97UEmF22PQ/4FtW/gVuBw9vaOA/4T+Bh4GBgB+Dqsnwv8Ple/7+V19Cv9LRiIv6K6svxghH2+yzwImBr4IXABsDHatvXo0qAGwDvBk6WtMYYjl2TqqdxCNUX5v8ry88H/kz1BTcs2/9mexXbq1B94f4eOKdsvg/4G+C5VAnsREnbtMWwVontQOB0SS8e6TNrn30x8GngnBLDy4ALgU0k/WVt13cAX+1w/EFUw5ytc7gM+AiwE9XP7WVUX8wfbYu5/nNrtwfwLdvL2tafS/VzfVFt3ZuB7YBtgL2Bv7d9A1WP+8oS0+pDnP56VEOPrd/rl4C/A7YFXgn8i6RNOpzzYbXf1y5Uf6BcIGk54LtUiX8D4LXA+yTtVTt8b6rEtTrVz+0LwBdsPxfYtJxjTFNJWjERawH3217SWiHpF5IekvRnSbtKEtWX4pG2F9t+hOoLer9aO09QXSt5wvZFVH85v3iUxy4DPm77Mdt/tv2A7W/Z/lPZ/1PAq0Z7QpJWBM6n+hL7AYDt79u+2ZWfAD+k+kKt+5cSw0+A7wNvHe1ndmL7Maqk+Xclri2AmVQ9x9E4gOpnep/t3wOfoEp6LU/7uXU4fi2qnk+7u2vbW44rv587qHp0+48yRqh+95+y/QRwdmn3C7YfsT0fWECVdDuStDbV7+ufbP8a2B5Y2/axth+3fQtVIqz/m7nS9vm2l5VzfwJ4oaS1bP/B9i/HEH9MsYznxkQ8AKwl6VmtxGX7FQClSm45YG1gJeCaKgcBIGBGvZ164gP+BKwyymN/b/vRJzdKK1Fde5lFNVQIsKqkGbaXjuKcvgz81vZxtTZfB3ycqnexXInputoxD9r+Y235dqohqok6C/impI9SJZxzSzIbjeeVOIaK6Wk/tw7uB9bvsH792vaWO4f5nJE8UPu9tJLnvbXtf6b6t/AMkp5N1WP6hu2zy+qNgedJeqi26wzgp0PEC1Xv/ljgN5JuBT7hURabxNRLTysm4krgMarhlqHcT/XFs4Xt1ctrtTKsM5LRHNteePB+4MXAjmW4Z9eyXoxA0jFUiendtXXPobo+8jlg3TLMdVFbe2tIWrm2/Hyq60hj8YwCivIX/+NUvbq3U12zG63fUX2BDxXTSAUblwH7lOG2urdSfenfWFu30RCfM9mVo/9OdR2qPux5J3Br7d/L6rZXtf362j5Pi8v2Tbb3B9ahqpY8r+33GdNIklaMm+2HqIadTpG0r6RVJS0naWtg5bLPMqrhmRMlrQMgaYO2awxDtT+eY1elSnQPlQq4j4/mXEpv6nDgzW3DZctTXbf7PbCk7LdnhyY+IWl5Sa+kuv71X6P53Jp7gZkdksRXqa7JPWH7Z2No75vARyWtLWktqutF/zmG40+kus74ZUnrSVpB0v5U18o+YLv+xf8BSWtI2gg4gqeuBd4LbCip61Wkkv6Batj3gLbrbr8CHpH0QUkrSpohaUtJ2w/T1t9JWru081BZ3X4tL6aJJK2YENv/RlXV9s9UX1L3Al+kqjL7Rdntg8BC4JeSHqb6K360hQpjPfYkYEWqXtovgYtH+TlvoxqOvEHSH8rrtHJd7HCqi/MPUvV4Lmw79p6y7XdUF/YPtf2bUX5uSyvJPSDp2tr6r1Hd/zaWhAPwr1QVcfOohjKvLetGxfYDVAUOK1BdV3qA6vf8DtvntO1+AXANMJfqet6Xy/ofU93bdY+k++mu/YEXAL+r/b4+XIYa/4aqAOVWqn8HZ1Al4KHMAuZL+gNVUcZ+Q1zni2lAT/+DKSKmk1IYch+wje2beh1PO0kGNrO9sNexxGBITytievs/wJzpmLAieiHVgxHTlKTbqAo+3tTbSCKmjwwPRkREY2R4MCIiGiNJKyIiGiPXtKahUpEVETEa99teeyIN7PXqlf3A4tFMGPN018x77BLbsyby2WOVpDVN7d4/T3940mU+jx0PmLbPJxyXq77+fmbNPLLXYXTdxbedyC5vOr7XYXTdz87/ABuf1l/ndfuhH7h95L2Gd//ipVx1yYZjPu7Z69+81sh7dVeSVkTEwDNLnzGh//SUpBURMeAMLJv0qSK7I0krIiJY1pDpFpO0IiIGnDFLG3LPbpJWRERkeDAiIprBwNIkrYiIaIr0tCIiohEMuaYVERHN0Yzawcw9GBERDZKeVkTEgDNuTCFGeloREYPOsHQcr5FImiXpt5IWSjpmiH3eKmmBpPmSvjFSm+lpRUQMuGoap+6SNAM4GdgDWATMkXSh7QW1fTYDPgTsbPtBSeuM1G6SVkTEwBNLUbcb3QFYaPsWAElnA3sDC2r7vAc42faDALbvG6nRDA9GRAw4A8s89hewlqSra69Das1uANxZW15U1tW9CHiRpJ9L+qWkEZ/NlZ5WRESMt6d1v+3tJvCxzwI2A3YDNgT+W9JWth8a7oCIiBhg1TROXR8evAvYqLa8YVlXtwi4yvYTwK2SbqRKYnOGajTDgxERwTJrzK8RzAE2k7SJpOWB/YAL2/Y5n6qXhaS1qIYLbxmu0fS0IiIG3GT0tGwvkXQYcAkwAzjT9nxJxwJX276wbNtT0gJgKfAB2w8M126SVkTEgDNi6SQMvNm+CLiobd3Hau8NHFVeo5KkFRERoxnumxYmnFolWdIJteWjJc0u72dLukvSXEm/kXSqpGd8pqSNJF1euyv6iNq2NSVdKumm8t81yvqXSLpS0mOSjh4mvlUkfVHSzZKukXSFpB3Ltj+U/86U9OcSZ+u1fNl2UjmH5WptHiTp97XzOrK2bVdJ10paImnftlgOLOdxk6QDx/zDjoiYBK3hwbG+eqEb/cHHgH3KRbROTrS9NbA5sBXwqg77LAHeb3tzYCfgvZI2L9uOAX5kezPgR2UZYDFwOPC5EeI7o+y7me1tgXcBnWK92fbWtdfjJVG9mepeg/a4zynntTPwEUmtKpk7gIOAp01HImlN4OPAjlQ33X28lYAjInpLLPVyY371Qjc+dQlwOnDkCPstD6wAPNi+wfbdtq8t7x8BbuCpm9D2Bs4q788C3lT2u8/2HOCJoT5Q0qZUSeKjtpeV4261/f1RnVlV1TIfOBXYv9MO5aLhQmD9snyb7Xk8c1aUvYBLbS8ud39fCox4I11ExGSrpnFabsyvXujWp54MHCBptQ7bjpQ0F7gbuNH23OEakjQTeDlwVVm1ru27y/t7gHXHENcWwFzbS0ex76a1ocGTy7r9gW8C3wH+WtKzO8T7fKpkPG+E9kdzd3hERE8M0vAgth8Gvko1XNeuNTy4DrCypP2GakfSKsC3gPeVNts/xzBp8+fXhwffW65pvR44v8RyFVVvqeVtkuZR9bJOsf3oRAOQ9AZJp0+0nYiIsbAHa3iw5STg3cDKnTaWO54vBnYthRetXs2hAKUX8y3g67a/XTv0Xknrl33WB0acULFmPvCyMtvwWO0FrA5cJ+k2YBeePkR4ju2XAq8APitpvRHaG/HucNvftX0IERHRUdeSlu3FwLlUiesZJImqaOFm23fWejWnlW1fBm6w/fm2Qy8EWpV2BwIXjCGmm4GrgU+Uz2hVCv71KA7fHzjY9kzbM4FNgD0krdT2GVcDXwOOeGYTT9O6iW6NUoCxZ1kXEdFzy9CYX73Q7f7dCTyzMq91Tet6qruiT+lw3M7AO4DX1Hpgry/bPkuVLG4Cdi/LSFpP0iKqm9I+KmmRpOd2aPtgqutgCyVdD3yFEXprJTHNAp4s2LD9R+BnwBs6HHIc8C5Jq0ravsT1FuCLkuaX4xcDn6Sa2mQOcGxZFxHRU1XJ+3JjfvXChG8utr1K7f29wEq15dnA7FG08TPonLZLdd5rO6y/h2qIbaS2H6Z6ZkunbauU/94GbFlb/ydgzQ7771Nb/Ept/e+A1vDgnKHisn0mcOZIMUdETC317BrVWGVGjIiIAdcqeW+CJK2IiGBpQ6ZxStKKiBhwkzVh7mRI0oqICJblmlZERDRBq3qwCZK0IiIGnFGuaUVERHOkejAiIhrBJvdpRUREU/RuWqaxStKKiBhwJj2tiIhokFQPRkREIxixLNWDERHRFE3paTUjyoiICNLTiogYeCbTOEVERGOIpSl5j4iIJkhPKyIiGiU9rYiIaARb6WlFRERzZEaMiIhoBEPmHoyIiKZQY3past3rGKKNpPxSImK0rrG93UQaWH+LNfz333z1mI/79Mu+M+HPHqv0tKap3fb8bK9D6LorfngMu2vfXofRVZf5PPZa9aBeh9F1lzzyFWa98AO9DqPrLl54PK/42+N7HUZX/eJb3fk9TcY0TpJmAV8AZgBn2P5s2/aDgOOBu8qq/7B9xnBtJmlFRAy4yZgwV9IM4GRgD2ARMEfShbYXtO16ju3DRttuklZERLCs+z2tHYCFtm8BkHQ2sDfQnrTGpBlX3iIiYtLYsNQa82sEGwB31pYXlXXt/lbSPEnnSdpopEaTtCIigmXWmF/AWpKurr0OGePHfheYafulwKXAWSMdkOHBiIgBV13TGlcf5v5hqgfvAuo9pw15quCi+lz7gdriGcC/jfSB6WlFRARLy0zvY3mNYA6wmaRNJC0P7AdcWN9B0vq1xTcCN4zUaHpaEREDrprlvbvVg7aXSDoMuISq5P1M2/MlHQtcbftC4HBJbwSWAIuBg0ZqN0krIiImhe2LgIva1n2s9v5DwIfG0maSVkTEwMss7xER0SCZMDciIhqhdZ9WEyRpRUREhgcjIqIZJmPuwcmSpBUREbmmFRERzTAZ92lNliStiIjINa2IiGgI55pWREQ0hMk1rYiIaJD0tCIiohFSiBEREY2SpBUREY3QpJuLR13jKMmSTqgtHy1pdnk/W9JdkuZK+o2kUyU9o21JG0m6XNICSfMlHVHbtqakSyXdVP67Rln/EklXSnpM0tHDxLeKpC9KulnSNZKukLRj2faH8t+Zkv5c4my9li/bTirnsFytzYMk/b52XkfWtu0q6VpJSyTt2xbLgeU8bpJ0YG39tpKuk7RQ0v+V1Ix/JRHR95ahMb96YSyF+Y8B+0haa4jtJ9reGtgc2Ap4VYd9lgDvt705sBPwXkmbl23HAD+yvRnwo7IM1YPBDgc+N0J8Z5R9N7O9LfAuoFOsN9veuvZ6vCSqNwN3doj7nHJeOwMfkdR6fPQdVA8s+0Z9Z0lrAh8HdgR2AD7eSsDAqcB7gM3Ka9YI5xQRMflcDQ+O9dULY0laS4DTgSNH2G95YAXgwfYNtu+2fW15/wjVo5U3KJv3Bs4q788C3lT2u8/2HOCJoT5Q0qZUSeKjtpeV4261/f1RnRnsBsynSir7d9rB9gPAQmD9snyb7XnAsrZd9wIutb3Y9oPApcCs8ljp59r+pW0DX22dY0REjM5Yb4E+GThA0modth0paS5wN3Cj7bnDNSRpJvBy4Kqyal3bd5f39wDrjiGuLYC5tpeOYt9Na0ODJ5d1+wPfBL4D/LWkZ3eI9/lUyXjeCO1vQNVja1lU1m1Q3revr3/GGySdPopziIjomlb1YL/1tLD9MFUP4fAOm1vDg+sAK0vab6h2JK0CfAt4X2mz/XNM9XOcDPXhwfeWa1qvB84vsVxF1VtqeZukeVS9rFNsPzpJcWH7u7YPmaz2IyKG0pdJqzgJeDewcqeNtp8ALgZ2LYUXrV7NoQClF/Mt4Ou2v1079N4yhEb5731jiGk+8DJJM8Z8NlWCWh24TtJtwC48fYjwHNsvBV4BfFbSeiO0dxewUW15w7LurvK+fX1ERE+1qgf7MmnZXgycS5W4nqFUxO1M1aO5s9arOa1s+zJwg+3Ptx16IdCqtDsQuGAMMd0MXA18olWRVyoF/3oUh+8PHGx7pu2ZwCbAHpJWavuMq4GvAUc8s4mnuQTYU9IapQBjT+CSMvT5sKSdSozvHMs5RkRMJltjfvXCeKf1PYFnVua1rmldD8wATulw3M7AO4DX1Hpgry/bPkuVLG4Cdi/LSFpP0iLgKOCjkhZJem6Htg+mug62UNL1wFcYobdWEtMs4MmCDdt/BH4GvKHDIccB75K0qqTtS1xvAb4oaX45fjHwSWBOeR1b1gH8I1WV40LgZuAHw8UXETFVmlLyPuqbi22vUnt/L7BSbXk2MHsUbfwMOp9pqc57bYf19/D0YbWh2n6Yqpy807ZVyn9vA7asrf8TsGaH/fepLX6ltv53QGt4cM5Qcdk+Ezizw/qr658fETEd2JkRIyIiGqRXw31jlaQVETHwmjONU5JWRESkpxUREc2QR5NERERzuCrGaIIkrYiI6FkJ+1glaUVEDDiTa1oREdEYqR6MiIgGyTWtiIhojKYMD4537sGIiIgpl6QVETHg7MmZ5V3SLEm/lbRQ0jHD7Pe3kixpu5HazPBgRER0vRCjPN/wZGAPqie1z5F0oe0FbfutSvXIp6ue2cozpacVERGltzW21wh2ABbavsX248DZwN4d9vsk1WOfRvVU+CStiIgY7/DgWpKurr0OqTW5AXBnbXlRWfckSdsAG9n+PqOU4cGIiAFnxv0k4vttj3gdqhNJywGfBw4ay3HpaUVERDUrxhhfI7gL2Ki2vGFZ17Iq1UNxr5B0G7ATcOFIxRjpaUVEDDpPyn1ac4DNJG1Claz2A97+5Efa/wus1VqWdAVwdHnC+5DS04qIiK53tWwvAQ4DLgFuAM61PV/SsZLeON4w09OKiIhJmRHD9kXARW3rPjbEvruNps0krYiIyNyDERHRDE16NInclPQ6QCTllxIRo3XNeMvOW57zgg284affO+bjbtn/IxP+7LFKT2uamrXREb0OoesuvvMLzHreYb0Oo6su/t1/sLv27XUYXXeZz2Ob93y+12F03bVfOopNvvGpXofRVbe+/SNdaacp/ZckrYiIGNWNV9NBklZExMAb94wYUy5JKyIiGtPTys3FERHRGOlpRUQMusmZxmlSJGlFRERjhgeTtCIiAkhPKyIimiI9rYiIaIwkrYiIaAQDKcSIiIimyDROERHRHElaERHRGBkejIiIpmjKA5GStCIiBp3J8GBERDSFMjwYERENkp5WREQ0RpJWREQ0RpJWREQ0QoNmxMhDICMiojFGTFqSLOmE2vLRkmaX97Ml3SVprqTfSDpV0jPalLSRpMslLZA0X9IRtW1rSrpU0k3lv2uU9S+RdKWkxyQdPUx8t0laa4zn3RWSrpB0dW15O0lXjHDMTElvn/TgIiLGQB77qxdG09N6DNhnmMRwou2tgc2BrYBXddhnCfB+25sDOwHvlbR52XYM8CPbmwE/KssAi4HDgc+N5kR6aB1JrxvD/jOBJK2ImF48jlcPjCZpLQFOB44cYb/lgRWAB9s32L7b9rXl/SPADcAGZfPewFnl/VnAm8p+99meAzwxihhbPZjfSPqKpBslfV3S7pJ+XnpxO5T9dig9uF9L+oWkF5f1K0k6t/QGvyPpKknblW17lmOulfRfklapffTxwEc6xDND0vGS5kiaJ+kfyqbPAq8svdORfqYREVEz2mtaJwMHSFqtw7YjJc0F7gZutD13uIYkzQReDlxVVq1r++7y/h5g3VHG1MkLgROAl5TX24FdgKOBD5d9fgO80vbLgY8Bny7r/xF4sPQG/wXYtsS7FvBRYHfb2wBXA0fVPvNK4HFJr26L5d3A/9reHtgeeI+kTah6kj+1vbXtEydwrhERXdNPw4PYfhj4KtVwXbvW8OA6wMqS9huqndJD+RbwvtJm++dMtNN5q+3rbC8D5lMNOxq4jmpYDmA14L8kXQ+cCGxR1u8CnF3iuB6YV9bvRDX0+fOSnA8ENm773H+lSmx1ewLvLMdcBfwFsNlwwUt6g6TTR3uyERFdY4391QNjqR48iar3sHKnjbafAC4Gdi2FF3PL61AASc+mSlhft/3t2qH3Slq/7LM+cN/YT+NJj9XeL6stL+Op8v5PApfb3hJ4A9WQ5nAEXFp6Rlvb3tz2u+s72P4xsCJVgqsf90+14zax/cPhPsj2d20fMkI8ERHdNZ7rWdO5pwVgezFwLlXiegZJAnYGbrZ9Z+3L+rSy7cvADbY/33bohVS9F8p/LxjrSYzRasBd5f1BtfU/B94KUIpEtirrfwnsLOmFZdvKkl7Uod1/Bf65tnwJ8H9KskbSiyStDDwCrNqdU4mI6JJ+S1rFCUB7FWHrmtb1wAzglA7H7Qy8A3hNrQf2+rLts8Aekm4Cdi/LSFpP0iKq60cflbRI0nPHGG8n/wZ8RtKvefrN1acAa0taQJWA5lNdk/o9VXL7pqR5VNewXtLeqO2LgN/XVp0BLACuLUORXyyfNw9YKul/UogREdNFU65pjTgjhu1Vau/vBVaqLc8GZo+ijZ9RDZd12vYA8NoO6+8BNhxF2zPL2/uBLWvrD6q9v621zfaVQL2n1LoW9Sjwd7YflbQpcBlweznmx1TFFO2fvVvb8ra198uoij8+zDO9ZqTzioiYUpOQhCTNAr5A1aE5w/Zn27YfCrwXWAr8ATjE9oLh2sw0Tk9ZCbi8DOcJ+Efbj/c4poiIqdHlpCVpBlXl+R7AImCOpAvbktI3bJ9W9n8j8Hlg1nDtJmkV5f6x7XodR0TEVJuk4b4dgIW2bwGQdDbVfblPJq22KvKVGUXqTNKKiIjJKGHfALiztrwI2LF9J0nvpapdWJ5RXDrJhLkRETHe6sG1JF1de435lh3bJ9veFPggz7zf9RnS04qIiPEOD95ve6jLKncBG9WWN+Sp2406ORs4daQPTE8rIiIm4z6tOcBmkjaRtDywH9V9uU+SVJ8l6K+Bm0ZqND2tiIhBNwmFGLaXSDqMaqKFGcCZtudLOha42vaFwGGSdqeaGP1BnppoYkhJWhERMSn3aZVJFy5qW/ex2vsjxtpmhgcjIqIx0tOKiIiezSU4VklaERHRs7kExyrDgxER0RjpaUVERIYHIyKiIXr4qJGxStKKiIj0tCIiokGStCIioglEhgcjIqJJkrQiIqIRUogRERGNkqQVERGNkaQVERFN0ZThQdkNiXSASE355xMR08A1wzw9eFRWXH8jv+DAo8Z83ILjjprwZ49VelrT1NK7Nxt5p4aZsf5NbH/gCb0Oo6vmnPV+3nnV3/c6jK776o5nsrv27XUYXXeZz+Ov3vK5XofRVVf+19ETb2R0TyKeFpK0IiKiMcODmeU9IiIaIz2tiIjI8GBERDRHU4YHk7QiIiI9rYiIaIhUD0ZERFOovJogSSsiItLTioiI5kghRkRENEeSVkRENEaSVkRENEIeAhkREY2SpBUREU2RnlZERDRHklZERDRFeloREdEMmcYpIiIapSFJKw+BjIiISSFplqTfSloo6ZgO24+StEDSPEk/krTxSG0maUVEDDhRXdMa62vYNqUZwMnA64DNgf0lbd6226+B7Wy/FDgP+LeRYk3SioiIp65rjeU1vB2AhbZvsf04cDaw99M+0r7c9p/K4i+BDUdqdMJJS5IlnVBbPlrS7PJ+tqS7JM2V9BtJp0p6xmdKWkHSryT9j6T5kj5R27aJpKtK9/IcScuX9btKulbSEkn7DhPfepLOlnSzpGskXSTpRZJmSrq+7LObpP8tcc6VdFnt+PMl/bKtzfp5LZC0f23bW8o5LJO0XdtxHyrn8VtJe43hxxwRMalkj/k1gg2AO2vLi8q6obwb+MFIjXajp/UYsI+ktYbYfqLtram6h1sBrxqijdfYfhmwNTBL0k5l23GljRcCD1KdGMAdwEHAN4YKTJKA7wBX2N7U9rbAh4B1O+z+U9tbl9fu5fjVgW2B1SS9YIjz2hv4oqRnl/XXA/sA/90Wy+bAfsAWwCzglNJ9jojorfH0sqqctZakq2uvQ8bz8ZL+DtgOOH6kfbuRtJYApwNHjrDf8sAKVInnaVz5Q1l8dnm5JJ3XUI11ApwFvKkcc5vtecCyYT7z1cATtk+rfdb/2P7pSCdV7AN8l6pbu1+nHWzfBPwJWKMs32D7tx123Rs42/Zjtm8FFlJ1nyMiem6c17Tut71d7XV6rcm7gI1qyxuWdU//XGl34CPAG20/NlKc3bqmdTJwgKTVOmw7UtJc4G7gRttzOzUgaUbZ7z7gUttXAX8BPGR7SdltpO5luy2Ba0a57ytrw4MfKev2B75ZXvt3OkjSNsBNtu8bof2xdpUjIqZO969pzQE2K5d4lqf6w//C+g6SXg58kSphjfQdCnQpadl+GPgqcHiHza1htHWAlSUN1WNZWvbbENhB0pbdiG0M6sODn5K0LrAZ8DPbNwJPtMV0pKT5wFXAp7oRgKQ3SDp95D0jIrqr29WDpbNxGHAJcANwru35ko6V9May2/HAKsB/lQ7DhUM096RuVg+eRHW9aeVOG20/AVwM7Cppo1qv5tC2/R4CLqe67vMAsLqk1k3QHbuXw5hPdU1qPN5KNeR3q6TbgJk8vbd1ou0tgL8FvixphRHaG7GrbPu7tsc1JhwRMSHd72lh+yLbLyo1BZ8q6z5m+8Lyfnfb69Y6DG8cvsUuJi3bi4FzeapQ4mnK9amdgZtt31kL8jRJa5eiByStCOwB/Ma2qRJYqzrwQOCCMYT1Y+A59YuDkl4q6ZWjOHZ/YJbtmbZnUiW/Z/QSyw//6hLbcC4E9pP0HEmbUPXifjW604iImETj6GX1aq7Cbt+ndQLQXkXYuqZ1PTADOKXDcesDl0uaRzUOeqnt75VtHwSOkrSQ6hrXlwEkbS9pEfAWquq9+e2NlqT3ZmD3UvI+H/gMcM9wJyFpJrAx1X0DrbZuBf5X0o4dDjm2xLicpDeXuP4K+L6kS8rx86mS+gKqHud7bS8dLo6IiCkzCT2tyTDhuQdtr1J7fy+wUm15NjB7FG3MA14+xLZb6FBlZ3sOo7gRzfbvqIb6Otmy7HMFcEXtmNvoUCRhe5vy9qq29dcALy6L3ymvTrF8ii5d/4qI6JbWjBhNkAlzIyICRr5ZeFpI0oqIiPS0IiKiIXp4jWqskrQiIgINN7fQNJKkFRERjelp5dEkERHRGOlpRURECjEiIqIhTEreIyKiOdLTioiI5kjSioiIJsg0ThER0Rx2rmlFRERzpKcVERHNkaQVERFNkZ5WREQ0g4FlzchaSVoREZHhwYiIaI4MD0ZERHOk5D0iIpoiPa2IiGiGPLk4IiKaoprGqRlZS25IoINEakpHPSKmgWtsbzeRBp773A293Y6Hjfm4yy/70IQ/e6zS05qmdr/8fb0Ooesue/VJbHza8b0Oo6tuP/QDbHH053sdRtfN/9xRbHNw/53XtWccxe7at9dhdNVlPq87DS3rTjOTLUkrIiIaMzyYpBURMehSiBEREc2RR5NERESDNKX8K0krIiLS04qIiIYwqCHVg8v1OoCIiJgG7LG/RiBplqTfSloo6ZgO23eVdK2kJdLo7kVI0oqIiKcqCMfyGoakGcDJwOuAzYH9JW3ettsdwEHAN0YbZoYHIyJiMu7T2gFYaPsWAElnA3sDC1o72L6tbBv14GR6WhERMRnDgxsAd9aWF5V1E5KeVkTEoDPjncZpLUlX15ZPt316V2IaQpJWRMSAEx7v8OD9w0yYexewUW15w7JuQjI8GBERkzE8OAfYTNImkpYH9gMunGiYSVoREdH1pGV7CXAYcAlwA3Cu7fmSjpX0RgBJ20taBLwF+KKk+SOFmeHBiIhBN/5rWsM3a18EXNS27mO193Oohg1HLUkrIiIa82iSDA9GRERjpKcVERGZMDciIpoiz9OKiIimMElaERHRIA15NEmSVkREpHpwJJIs6YTa8tGSZpf3syXdJWmupN9IOlXSkLFKOqnsv1xt3bqSvifpfyQtkHRRWT9T0p9L2wskfVXSs9va26psnytpsaRby/vLyvHXl/12K+dxcO3Yrcu6o8vyVyTtK+k7pY2Fkv631v4ruvQjjYgYv0l4ntZk6GXJ+2PAPpLWGmL7iba3pnoOy1bAqzrtVBLVm6lmE67vcyxwqe2X2d4cqD+A7ObS9lZUN7a9td6m7etsb132uRD4QFnevUMI17cdvz/wP+072X5zae9g4Ket9m3/Yojzj4iYGgaWeeyvHuhl0loCnA4cOcJ+ywMrAA8OsX03YD5wKlXCaFmfaip8AGzPaz/Q9lLgV0xsuvzbgRVKz07ALOAHE2gvImKKjaOXNYA9LaieanmApNU6bDtS0lzgbuBG23OHaGN/4JvAd4C/rg31nQx8WdLlkj4i6XntB0paAdgRuHhip8F5VHNnvQK4lqoXOWaS3iBpUqf1j4joKElrZLYfBr4KHN5hc2t4cB1gZUn7te9QZg5+PXB+aesqYK/S9iXAC4AvAS8Bfi1p7XLopiUh3gvc3akXNkbnUiWtVgIdF9vftX3IBGOJiBi7JK1ROwl4N7Byp422n6DqCe0qaaNaAcOhVAlqdeA6SbcBu1AbIrS92PY3bL+Dapr8Xcum1jWtTYFtWzMOj5fte4AngD2AH02krYiIKdega1o9L3m3vVjSuVSJ68z27eU60c7Ar23fCWxd2/YN4GDb3yzLKwO3SloJ2An4pe0/SVqVKkHd0fbZ90s6BvgQE3/Oy8eAdWwvrUKOiGgKg5txo9Z06GkBnAC0VxG2rmldD8wATqlvLIlpFvD91jrbfwR+BrwB2Ba4WtI84ErgjDINfrvzgZUkvXIiJ2D7F7bPn0gbERE905DhwZ71tGyvUnt/L7BSbXk2MHuE4/8ErNlh/T61xeM7bL8N2LK2bOBlw3zOQUMdb/sK4IoOx8yuvW8/vuMxERE90xoebICeDw9GRMQ00JAZMZK0IiKiMUlrulzTioiIGFF6WhERAy/P04qIiKYwsKwZJe9JWhERkZ5WREQ0SJJWREQ0Q++mZRqrJK2IiEFncEOmcUrSioiI9LQiIqJBck0rIiIawU7Je0RENEh6WhER0RROTysiIpoh0zhFRERT5HlaERHRKLlPKyIimsCAG9LTyvO0IiIGnV31tMb6GoGkWZJ+K2mhpGM6bH+OpHPK9qskzRypzSStiIjoOkkzgJOB1wGbA/tL2rxtt3cDD9p+IXAicNxI7SZpRUQEXuYxv0awA7DQ9i22HwfOBvZu22dv4Kzy/jzgtZI0XKNJWhERMRnDgxsAd9aWF5V1HfexvQT4X+AvhmtUbkht/iCR9Hvg9in6uNWo/qH0m348r348J+jP85rKc9rY9toTaUDSxcBa4zh0BeDR2vLptk8vbe4LzLJ9cFl+B7Cj7cNqn3t92WdRWb657HP/UB+Y6sFpaKL/AMdC0um2D5mqz5sq/Xhe/XhO0J/n1bRzsj1rEpq9C9iotrxhWddpn0WSnkWV7B8YrtEMD8Z3ex3AJOnH8+rHc4L+PK9+PKexmgNsJmkTScsD+wEXtu1zIXBgeb8v8GOPMPyX4cGIiJgUkl4PnATMAM60/SlJxwJX275Q0grA14CXA4uB/WzfMmybSVoREdEUGR6MiIjGSNKKmKYkHTGadU2iyo6S9imvHUe6L2c6k7RTr2MYNBkeHCCSVgNm8dS9EncBl9h+qGdBdYGkvYA38fTzusD2xT0LqgskXWt7m7Z1v7b98l7FNBGS9gROAW7iqSqyDYEXAv9o+4e9im28Ov2OYnIlaQ0ISe8EPg78kKd/YewBfML2V3sV20RIOgl4EfBVqpsXoTqvdwI32W5cz0TS/sDbgV2An9Y2rQoss/3angQ2QZJuAF5n+7a29ZsAF9n+y54ENgFJWlMvSWtASPot1U17D7WtXwO4yvaLehLYBEm6sVPsZcjpRtub9SCsCZG0MbAJ8BmgPsnoI8C8MnNA40i6CfjL9vhLOfSCMv9co0h6CPjvobbbfuPURTMYcnPx4BDVEwjaLSvbmupRSdvbntO2fnuefqd+Y9i+nWpGlL8qCWwz25dJWhFYkSp5NdGZwBxJZ/PU9D4bUd2/8+WeRTUxvwdO6HUQgyRJa3B8CrhW0g956gvj+VTDg5/sWVQTdxBwqqRVeWp4cCOqKXQO6lFMXSHpPcAhwJrAplTDnqcBjRwetP0ZSedTTZL6V2X1XcABthf0LLCJ+YPtn/Q6iEGS4cEBUoYC9+KZhRgP9i6q7pC0HrXzsn1PL+PpBklzqWbKvqpVfCHpOttb9TSweJKkb9vep9dxDJL0tAZISU5n9zqObitVka+ilrQkNb4qEnjM9uOtivAyN1tf/pUp6Qe2X9frOMbh65KGTFq2vz2VwQyCJK1o9F/vQ1RFvhr4tKTGVkUWP5H0YWBFSXsA/0iD57STNFSVnYCtpzCUbvqbYbYZSNLqsgwPDohh/hoUcNpUzizfTf1aFQkgaTmqJ7vuSfV7ugQ4Y6QJRacrSUuBn9C58Gcn2ytOcUjRQOlpDY5zgK/TeXhphSmOpZv6tSoS28uAL5VXP7gB+AfbN7VvkHRnh/2nPUlHDbfd9uenKpZBkaQ1OOYBn7N9ffsGSbv3IJ5u6buqSEmXM/S1Kzf15mJgNkNPHfdPUxhHN30OmAv8AHiMhv+h1AQZHhwQkl4J3G77jg7btrN9dQ/C6op+q4qUtG2H1TsB/wzcZ3v7KQ4phiDpZcD+VNOjXQN8E/hRU4dwmyBJK5C0su0/9jqOeCZJrwL+hWoI91O2f9DjkCZE0gxgjdbj1MtsGAcBRzZxGqc6Sa+gSmC7Ax+03f7Aw+iCzPI+QCRtIGm78kWBpHUkfZpqAtO+I+m6XscwXpL2kvRTqoT1Kdu79EHC2o/qQX/zJP2kTKB7C/A64ICeBjdBktamepDhVlQ3ud/X24j6V65pDQhJ7wM+AiwEniPpFOA4qolmOw1HNcIIVZHrTWUs3SJpDrA2cDxwZVn3ZLm47Wt7FNpEfRTY1vbCcj5XAvvabnIZ/98Db6XqCZ8HvNV2EtYkyvDggJC0ANjF9mJJzwduBHa2fU2PQ5sQSU8wdFXkvrZXneKQJkzSFQxfiPGaKQyna9pnRJd0ve0texnTRElaBlxPNVcktP3eMmFu96WnNTgetb0YwPYdkn7b9IRV9F1VpO3deh3DJFmnrUR89fpyQ8vDX93rAAZNktbg2FDS/60tr19ftn14D2LqhvcBDw+x7c1TGEfXSVoJOAp4vu1DJG0GvNj293oc2nh9ieqZYJ2WGznkk8lyp16GBweEpAOH2277rKmKZao0vSpS0jlUZdTvtL1lSWK/sL11byPrviEeLzPtlWKfIb9Ebb90CsMZCOlpDYihkpKkFYA3THE4XSVpA2B9qgckPi5pHaoe2EHA83oY2kRtavtt5UnG2P6TWrPn9gFJm1OViO8PPARs19OAxme4uQdjEiRpDaByr8xeVF8We1I90v2/ehrUOPVrVWTxeHnwowEkbUo160JjSZrJU4nqCWBjYDvbt/UwrIn4ku09ex3EIEnSGiDlRtW3A68HfgXsDGxi+089DWxiDqG6ztNXVZHFx4GLgY0kfZ3q93VQTyOaAElXAs+lejzO39q+SdKtDU5YUN2aEFMoSWtASFoE3AGcChxt+5HyhdHkhAX9WxWJ7UslXUs1hZOAI1ozSTTUvVRTba1L9WV/Ew0twKhZLc/TmlpJWoPjPOBNwNuApZIuoPlfGNC/VZH1G4rvLv99fnng5e22l/QorHGz/aYS/z7A7FINubqkHWz/qsfhjddqVNe1Ol1rzPO0JkGqBwdIuYi/G9X1hNdT/Q/3buAi23/oYWjj1s9VkZJ+CWxDdS+agC2B+VS/t/9j+4c9DG/CSsHMW6n+PT7f9kY9DmnM2m+YjsmXpDUgJD2r/te5pGfzVDHGXrbX6llwk6BVFWm7kQUmAJK+DfyL7flleXPgWKrZ3r/dtNJ3ST9sFS1I+pDtz9S2bWz79qGPnp4k/dr2y3sdxyDJhLmD48nhF0n/bvsJ29+zfQDQuL9wO5E0Q9LrJX2Nalqdt/U6pgl6USthAdheALzE9i09jGki6kULb6lvaGLCKt7R6wAGTa5pDY76mPvO9Q22/zzFsXRVn1ZFAsyXdCpVtR1USXiBpOdQlYs3Td8N63SaPiwmV4YHB0R97L2fxuHbqiLPr1VFbtLj0Cas3KP1j8AuZdXPgVOAR4GVmnYdUtJDwH9T/QH1yvL+SZlcNkYjSWtASPoT1Q24AjYt7ynLbup0M5JOoqqKvB74BnABcJ3tF/QwrOig9IiH1G/z+Ena2fbPex1Hv0nSGhCSNh5ue4OvKfRlVSRAKQn/DLA51fOaAEhCnj7K7DJvpbr/7GLb10v6G+DDwIop0ui+JK1otH6uipT0M6pZMU6kmh/yXcBytj/W08DGaZjJZRvb25f0FapCpl8BOwK/o5pD8Rjb5/cusv6VpDUgJD3C8F8Yz53ikLqi7Vrdv9v+p9q2FZtcZCLpGtvbSrrO9lb1db2ObTz6sbcv6XrgpbaXldss7qGa6PiBHofWt1I9OCCa+ATfUerbqkjgMUnLATdJOgy4C1ilxzFNxLOBdduv80jamerLvoket70MwPajkm5JwppcuU9rQEjaXtLrOqx/naRG/uVe9PNQwRHASsDhVDPWvwMYdgaQae4kOj+w8+GyrYleImleeV1XW75O0rxeB9ePMjw4ICT9GHhX+xBMGbL5f7Zf05vIJqZfqyL7kaQ5trcfYtuTQ6BN0o9DntNdhgcHx6qd/geyfbukxhYrAH/Z6wAmi6TtqJ4VtjG1/1cbnIhXH2bbilMVRDd1+CPwL4BdgTv65WkD002S1uBYY5htK01ZFF3W53/Jfh34AHAdsKzHsXTD1ZLeY/tL9ZWSDgYa+QUv6XtUlYLXS1ofuBa4GthU0um2T+ppgH0ow4MDQtJpwAPAR11+6eX+pk8A69k+pJfxjVe/VkVCVfJue5eR92wGSesC3wEe56kktR2wPPBm240rxpA03/YW5f2HqeaGfKekVYGfN7hXPG2lpzU43g+cASyUNLesexnVX4UH9yqoierjqkiAj0s6A/gR8FhrZVMfLGj7XuAVkl5N9ZgVgO/b/nEPw5qo+hyQrwW+BFCmE+uH3vG0k57WgJH0AmCLsji/wTOGA1VVJLCW7R+0rX8dcF+TrytI+k/gJVTP0Gp9Adr23/cuqqiT9F3gh8Ai4EyqiZofKvNGXt3qhUX3JGlFo/VrVSSApN/afnGv44ihlQdZHgusD5zcejBn6U1ua/tzvYyvH2V4MJquX6siAX4hafPyHK2YhmzfBxzaYdOVQNP//U1LSVrRdH1ZFVnsBMyVdCvVNa3cezaNlclzW/Ne7gn8FGjsk7OnqwwPBpJWaeps6P1aFQlD37jaj2X+Tb25GIZ8COkL+uAhpNNSeloBsAB4fq+DGKe+q4qUtGZ5+0hPA+kySfsMtQlYbypj6Za2h5AeXXsIaRLWJEnSGhCSjhpqEw2ehNX2H4H9+6wq8hqqe8/UYZuBpj5P6xyqG6Y7De+s0GFdE5xH9RDStwFLJV1Af8+H2XMZHhwQkh4FjgeWdNh8pO3VpzaiGDSSrgEOtH19h2132t6oB2FNWIeHkK4O/D0NfwjpdJWkNSAk/QL4p073LTX5CyOaQ9Irgdtt39Fh23a2r+5BWF3VTw8hna6StAaEpBcDi23/vsO2dctsBRExQZIOsX160x9COl0laUXfanJVZD+S9Czg3cCbgeeV1XcBFwBftv3EUMc2Sf1p2tF9SVoDQtJqwIeoLhqvQ3Wx+D6qL4zP2n6oZ8FNEkl32G5qVWRHTU7Ekr4JPAScRTXtEcCGVA+2XNP223oUWldJ+rXtl/c6jn6V6sHBcS7wY2C31mzaktaj+sI4l+pmyMbp16rIYTT59oRtbb+obd0i4JeSbuxFQJPkDb0OoJ8laQ2OmbaPq68oyes4SU2egPXTDF0VudwUx9IVfZyIF0t6C/At28sAJC0HvAV4sKeRTUC5ufhB2/MkvRXYVdLNwCm2Hxvh8BijDA8OCEk/BC4DzmoVXZTnGx0E7GF79x6GN279WBXZr7cnSJoJHAe8hipJiao8/MdUD1K8tWfBjZOkk4GXAs8BbqT6o+JiqlkxlrN9QA/D60tJWgNC0hrAMcDeVNe0AO4FLgSOs724V7FNRD9WRfZjIm5XHkuP7Qd6HctESFpge3NJK1AVlaxje2m5d2teU6emms6StCKmmX5MxC2SdqCa9HeOpM2BWcAN7c9Da4p6pWB71WCqCCdHrmkNEEkvATYAflmmP2qtn2X74t5FNn79WBVp+7fDbGtywvo48DrgWZIuBXYELgc+JGkb25/qaYDjs065Bqnae8ry2r0Lq3+lpzUgJB0OvBe4AdgaOML2BWVbY/8ilHQJ1TWRszpURb7WduOqIvsxEUM1kzvVv73nAPcAG9p+uDzl96omPnKlJOIh2f7EVMUyKJK0BkT5wvgr238oF8TPA75m+wtNvq9kuKf7NvXJv/2YiOHp9y+1/5uTNNf21j0LLhojw4ODY7nWTam2b5O0G3BeeWZTp9nEm+J2Sf9M56rIO3sZ2AT06+0Jj0taqTy2Y9vWytKzXNa7sMZP0seG2Wzbn5yyYAZEI+9jiXG5V9LWrYWSwP6G6pHgTa5wehvwF8BPJC2WtBi4AlgTeGsvA5uA2yX9c0m+QJWIJX2Q5iZigF1bz5lq3adVPJuqF9lEf+zwgmq6qg/2Kqh+luHBASFpQ2BJa7ipbdvOtn/eg7Cig369PaGT1uSyvY6jGyStChxBlbDOBU6wfV9vo+o/SVoDrF++MPqxKnJQNLkIqKU8afoo4ACqeRW/YLuxM3xMdxkeHGyH9jqAiSpVkRcA/wTMl7R3bfOnexPVxEl6iaTXSlq5bf2sXsU0SZp8PRVJxwNzgEeArWzPTsKaXOlpDbAmVw229GNVZL/entCJpA1tLxp5z+lJ0jLgMaopt+pfpqIqxHhuTwLrY6keHGz9MBt1P1ZFvodqRvQnE7Gkmba/QHPPCei/yWVtZ7RqiiVpDZB++8Io7pW0te25UFVFSvob4EyaWxXZj4n4aZPLlkeR1CeXPZPqmlDEsDI8OCD6dTbqfqyKlPRj4KhWIi7rnkX5Yrc9o1exTUQml41uSNIaEIP0hdH0qsh+TMSQyWWjOzI8ODgeBbD9qKTbbS8ty5b0RG9D67pDgcYmrU6FCa1E3NSEVWRy2ZiwJK3BMUhfGI297jOMRifi4kvAqh3eA5wx9eFEE2V4cEAM0mzUTS+j7qSp5fsR3ZakFY3XqSoSaHpV5NP0QyLO5LLRDUlaA6JfvzD6uCqy7xKxpPd3WL0y1Vx9f2F7lSkOKRooSWtA9OsXRj9WRfZrIq7L5LIxXinEGBC2T2i9r31hvAs4GzhhqOMaoB+rIl89RCL+IjCvx7FNSIfJZbfJXH0xFklaA6RPvzD6sSqyHxNxa3LZfaiqILdqzfoRMRYZHhwQbV8YJ/fLF0Y/VkVKWgR8nirxHlneU5bfZ3ujXsU2EZlcNrohSWtA5AujOfoxEUd0S5JWNFq/VkVGRGdJWtFo/VgVmUQcMbQkregb/VJG3Y+JOKJbkrSi8TpURX6hD6oigf5JxBHdkpL3aLR+LaPu09sTIiYsPa1otH6siuzX2xMiuiFJK2Ka6cdEHNEtSVoREdEYy/U6gIiIiNFK0oqIiMZI0oqIiMZI0oqIiMZI0oqIiMZI0oqIiMb4/+UxAlCmJR+PAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 432x360 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x360 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#have to load different results\n",
+    "norm_matrices = []\n",
+    "kt_matrices = []\n",
+    "for i, optimizer in enumerate(optimizers):\n",
+    "    div_mat, scaled_mat, kt_mat, scaled_seed_results = compute_matrix(results, search_spaces, optimizers, optimizer)\n",
+    "    #norm = compute_matrix(results, best_configs[i], optimizer, search_spaces)\n",
+    "    norm_matrices.append(scaled_mat)\n",
+    "    kt_matrices.append(kt_mat)\n",
+    "    scaled_matrix = scale_matrix(kt_mat, mean_div=2.5)\n",
+    "    scaled_kt_matrix = scale_matrix(kt_mat, mean_div=-100000)\n",
+    "    scaled_matrix = plot_matrix(scaled_matrix, search_spaces, cmap='viridis', title=optimizer) #, save='bbo_matrix_avg.pdf')\n",
+    "    scaled_kt_matrix = plot_matrix(scaled_kt_matrix, search_spaces, cmap='viridis_r',hparam=True,  title=optimizer)\n",
+    "\n",
+    "avg_norm_matrix = np.mean(np.array(norm_matrices), axis=0)\n",
+    "avg_kt_matrix = np.mean(np.array(kt_matrices), axis=0)\n",
+    "\n",
+    "scaled_matrix = scale_matrix(avg_norm_matrix, mean_div=2.5)\n",
+    "scaled_kt_matrix = scale_matrix(avg_kt_matrix, mean_div=-1000000)\n",
+    "#this the difference vs right search space and the wrong for the best seed of every search space \n",
+    "avg_scaled_matrix = plot_matrix(avg_norm_matrix, search_spaces, cmap='viridis') #, save='bbo_matrix_avg.pdf')\n",
+    "#run all config on all searchspaces and compare the rank\n",
+    "_ = plot_matrix(avg_kt_matrix, search_spaces, cmap='viridis_r', hparam=True) #, save='bbo_corr_matrix.pdf')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[1.        , 0.38065873, 0.41468707, 0.0158923 , 0.07523479],\n",
+       "       [0.38065873, 1.        , 0.40940666, 0.        , 0.10527008],\n",
+       "       [0.41468707, 0.40940666, 1.        , 0.06412977, 0.0558042 ],\n",
+       "       [0.0158923 , 0.        , 0.06412977, 1.        , 0.20932858],\n",
+       "       [0.07523479, 0.10527008, 0.0558042 , 0.20932858, 1.        ]])"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "scaled_kt_matrix"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3.7.12 64-bit",
+   "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.12"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "0cbe1a134e19725d24844610af4192e14b6927fb15622514c6c43df3d887b744"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/examples/plot.ipynb b/examples/plot.ipynb
index da847d2e9..137b21a27 100644
--- a/examples/plot.ipynb
+++ b/examples/plot.ipynb
@@ -28,7 +28,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -65,7 +65,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -162,30 +162,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "mlp output shape (2, 600) nans 1 missing files 0\n",
-      "lgb output shape (1, 300) nans 0 missing files 0\n",
-      "xgb output shape (2, 600) nans 0 missing files 0\n",
-      "rf output shape (2, 600) nans 0 missing files 0\n",
-      "bayes_lin_reg output shape (3, 900) nans 0 missing files 0\n",
-      "gp output shape (3, 900) nans 0 missing files 0\n",
-      "none output shape (3, 900) nans 0 missing files 0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/zelaa/.local/lib/python3.7/site-packages/numpy-1.16.4-py3.7-linux-x86_64.egg/numpy/core/fromnumeric.py:3367: RuntimeWarning: Degrees of freedom <= 0 for slice\n",
-      "  **kwargs)\n",
-      "/home/zelaa/.local/lib/python3.7/site-packages/numpy-1.16.4-py3.7-linux-x86_64.egg/numpy/core/_methods.py:130: RuntimeWarning: invalid value encountered in true_divide\n",
-      "  ret, rcount, out=ret, casting='unsafe', subok=False)\n"
+     "ename": "NameError",
+     "evalue": "name 'get_results' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m/var/folders/6r/q53rnwms52v42bg8k7xxg2yc0000gn/T/ipykernel_9832/1992346954.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpredictor\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpredictors\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m     \u001b[0mmean\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstd\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstd_error\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mruntime\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_results\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpredictor\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfolder\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mepochs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mepochs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetric\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'test_acc'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mug\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     10\u001b[0m     results_dict[predictor] = {'label':pred_label_dict[predictor], \n\u001b[1;32m     11\u001b[0m                                \u001b[0;34m'key'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mpredictor\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'mean'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mmean\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'std'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mstd\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'get_results' is not defined"
      ]
     }
    ],
@@ -195,7 +183,7 @@
     "results_dict = {}\n",
     "\n",
     "folder = os.path.expanduser('../../re_run_0/cifar10/nas_predictors/nasbench201')\n",
-    "predictors=('mlp', 'lgb', 'xgb', 'rf', 'bayes_lin_reg', 'gp', 'none')\n",
+    "predictors = ['var_sparse_gp']\n",
     "\n",
     "for i, predictor in enumerate(predictors):\n",
     "    mean, std, std_error, runtime = get_results(predictor, folder, epochs=epochs, metric='test_acc', ug=True)\n",
@@ -211,7 +199,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 576x288 with 1 Axes>"
       ]
@@ -298,7 +286,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.10"
+   "version": "3.7.10"
   }
  },
  "nbformat": 4,
diff --git a/naslib/benchmarks/bbo/runner.py b/naslib/benchmarks/bbo/runner.py
index 390a59ec3..f22d49550 100644
--- a/naslib/benchmarks/bbo/runner.py
+++ b/naslib/benchmarks/bbo/runner.py
@@ -3,6 +3,8 @@
 #from nasbench import api
 
 from naslib.defaults.trainer import Trainer
+from naslib.defaults.trainer_multifidelity import Trainer as Trainer_MF
+
 from naslib.optimizers import RandomSearch, Npenas, \
 RegularizedEvolution, LocalSearch, Bananas, BasePredictor
 
@@ -20,7 +22,7 @@
 
 utils.log_args(config)
 
-writer = SummaryWriter(config.save)
+# writer = SummaryWriter(config.save)
 
 supported_optimizers = {
     'rs': RandomSearch(config),
@@ -37,7 +39,7 @@
     'nlp': NasBenchNLPSearchSpace(),
     'transbench101_micro': TransBench101SearchSpace(),
     'transbench101_macro': TransBench101SearchSpace(),
-    'asr': NasBenchASRSearchSpace()
+    'asr': NasBenchASRSearchSpace(),
 }
 
 dataset_api = get_dataset_api(config.search_space, config.dataset)
@@ -53,6 +55,11 @@
 optimizer.adapt_search_space(search_space, dataset_api=dataset_api)
 
 trainer = Trainer(optimizer, config, lightweight_output=True)
-
-trainer.search(resume_from="", summary_writer=writer, report_incumbent=False)
+multi_fidelity_optimizers = {'sh', 'hb'}
+if config.optimizer in multi_fidelity_optimizers:
+    trainer = Trainer_MF(optimizer, config, lightweight_output=True)
+# trainer.search(resume_from="", summary_writer=writer, report_incumbent=False)
+trainer.search(resume_from="", report_incumbent=False)
 trainer.evaluate(resume_from="", dataset_api=dataset_api, metric=metric)
+
+# error: FileNotFoundError: [Errno 2] No such file or directory: '/Users/lars/Projects/NASLib/naslib/data/nasbench_only108.pkl'
diff --git a/naslib/benchmarks/create_configs.py b/naslib/benchmarks/create_configs.py
index c30219dcb..9e91fbc69 100644
--- a/naslib/benchmarks/create_configs.py
+++ b/naslib/benchmarks/create_configs.py
@@ -11,6 +11,7 @@ def main(args):
     if args.config_type == 'bbo-bs':
         args.start_seed = int(args.start_seed)
         args.trials = int(args.trials)
+        #num_config = int(args.num_config)
         num_config = 100 
         
         # first generate the default config at config 0
@@ -19,8 +20,8 @@ def main(args):
         os.makedirs(folder, exist_ok=True)       
             
         for seed in range(args.start_seed, args.start_seed + args.trials):
-            np.random.seed(seed)
-            random.seed(seed)
+            # np.random.seed(seed)
+            # random.seed(seed)
 
             config = {
                 "seed": seed,
@@ -61,10 +62,17 @@ def main(args):
             folder = f"naslib/benchmarks/bbo/configs_cpu/{args.search_space}/{args.dataset}/{args.optimizer}/config_{config_id}"
             os.makedirs(folder, exist_ok=True)
             
-            
+            sample_size = int(np.random.choice(range(5, 100)))
+            population_size = int(np.random.choice(range(5, 100)))
+            num_init = int(np.random.choice(range(5, 100)))
+            k = int(np.random.choice(range(10, 50)))
+            num_arches_to_mutate = int(np.random.choice(range(1, 20)))
+            max_mutations = int(np.random.choice(range(1, 20)))
+            num_candidates = int(np.random.choice(range(5, 50)))
+
             for seed in range(args.start_seed, args.start_seed + args.trials):
-                np.random.seed(seed)
-                random.seed(seed)
+                # np.random.seed(seed)
+                # random.seed(seed)
 
                 config = {
                     "seed": seed,
@@ -77,17 +85,17 @@ def main(args):
                         "checkpoint_freq": args.checkpoint_freq,
                         "epochs": args.epochs,
                         "fidelity": args.fidelity,
-                        "sample_size": int(np.random.choice(range(5, 100))),
-                        "population_size": int(np.random.choice(range(5, 100))),
-                        "num_init": int(np.random.choice(range(5, 100))),
-                        "k":int(np.random.choice(range(10, 50))),
+                        "sample_size": sample_size,
+                        "population_size": population_size,
+                        "num_init": num_init,
+                        "k": k,
                         "num_ensemble": 3,
                         "acq_fn_type": "its",
                         "acq_fn_optimization": args.acq_fn_optimization,
                         "encoding_type": "path",
-                        "num_arches_to_mutate": int(np.random.choice(range(1, 20))),
-                        "max_mutations": int(np.random.choice(range(1, 20))),
-                        "num_candidates": int(np.random.choice(range(5, 50))),
+                        "num_arches_to_mutate": num_arches_to_mutate,
+                        "max_mutations": max_mutations,
+                        "num_candidates": num_candidates,
                         "predictor": args.predictor,
                         "debug_predictor": False,
                     },
diff --git a/naslib/benchmarks/mf/config.yaml b/naslib/benchmarks/mf/config.yaml
new file mode 100644
index 000000000..a55c8153b
--- /dev/null
+++ b/naslib/benchmarks/mf/config.yaml
@@ -0,0 +1,26 @@
+start_seed: 0
+trials: 2
+out_dir: run
+out_dir_configs: configs
+
+search_space: 
+  - nasbench201
+  - nasbench311
+  - asr
+datasets: 
+  - cifar10
+  - cifar100
+  - ImageNet16-120
+  - TIMIT
+optimizers: # sh, rs, ls, ...
+  - rs
+  - ls
+  - re
+  - bananas
+  - npenas
+  - sh
+  - hb
+  - bohb
+  - dehb
+
+num_config: 2
\ No newline at end of file
diff --git a/naslib/benchmarks/mf/create_configs.py b/naslib/benchmarks/mf/create_configs.py
new file mode 100644
index 000000000..acab9f532
--- /dev/null
+++ b/naslib/benchmarks/mf/create_configs.py
@@ -0,0 +1,257 @@
+import os
+
+
+import yaml
+from glob import glob
+import numpy as np
+from addict import Dict
+import itertools
+
+def dump_configs(
+    configs: list,
+    optimizer: str,
+    dataset: str,
+    search_space: str,
+    out_dir = 'run'
+):
+    # setting default values specific to search space/dataset combination
+    if search_space == 'nasbench201':
+        fidelity = 200
+        max_budget = fidelity
+        enc_dim = 6
+        min_points_in_model = enc_dim + 1
+
+        if dataset == 'cifar10':
+            budgets = 1_100_000
+        elif dataset == 'cifar100':
+            budgets = 2_000_000
+        elif dataset == 'ImageNet16-120':
+            budgets = 6_500_5000
+        else:
+            return
+        
+    elif search_space == 'nasbench311':
+        fidelity = 97
+        max_budget = fidelity
+        enc_dim = 32
+        min_points_in_model = enc_dim + 1
+        if dataset == 'cifar10':
+            budgets = 2_500_000
+        else: 
+            return
+
+    elif search_space == 'asr':
+        fidelity = 39
+        max_budget = fidelity
+        enc_dim = 6
+        min_points_in_model = enc_dim + 1
+        if dataset != 'TIMIT':
+            return
+        budgets = 16_000
+    else:
+        return
+
+    os.makedirs(out_dir, exist_ok=True)
+    for config in configs:
+        config_id = config['config_id']
+        seed = config['seed']
+        filename = os.path.join(".", out_dir, f"{search_space}_{dataset}_{optimizer}_config_{config_id}_{seed}.yaml")
+
+        with open(filename, "w") as fh:
+            config['search_space'] = search_space
+            config['dataset'] = dataset
+            config['optimizer'] = optimizer
+
+            config['search']['max_budget'] = max_budget
+            config['search']['fidelity'] = fidelity
+            config['search']['budgets'] = budgets
+            config['search']['min_points_in_model'] = min_points_in_model
+            config['search']['enc_dim'] = enc_dim
+            yaml.dump(config, fh)
+
+def create_configs(
+    start_seed: int = 0,
+    trials: int = 100,
+    predictor: str = "xgb",
+    fidelity: int = 200,
+    acq_fn_optimization: str = "mutation",
+    out_dir: str = "run",
+    checkpoint_freq: int = 5000,
+    epochs: int = 400,
+    num_config: int = 100,
+    **kwargs
+):
+    """Function creates config for given parameters
+
+    Args:
+        start_seed: starting seed.
+        trials: Number of trials.
+        predictor: which predictor.
+        fidelity: Fidelity.
+        acq_fn_optimization: acq_fn.
+        epochs: How many search epochs.
+        num_config: Number of configs explored by HPO (Random Search).
+
+    Returns:
+        configs.
+
+    """
+    start_seed = int(start_seed)
+    trials = int(trials)
+    # first generate the default config at config 0
+    config_id = 0
+    configs = []
+    for seed in range(start_seed, start_seed + trials):
+        config = {
+            "seed": seed,
+            "search_space": None,
+            "dataset": None,
+            "optimizer": None,
+            "out_dir": out_dir,
+            "config_id": config_id,
+            "search": {
+                "sample_size": 10,
+                "population_size": 50,
+                "num_init": 10,
+                "k":10,
+                "num_ensemble": 3,
+                "acq_fn_type": "its",
+                "num_arches_to_mutate": 1,
+                "num_candidates": 50,
+                "checkpoint_freq": checkpoint_freq,
+                "epochs": epochs,
+                "number_archs": 128,
+                "method": "random",
+                "eta": 2,
+                "max_budget": None,
+                "min_budget": 1,
+                "n_process": 1000,
+                "epsilon": 1e-6,
+                "num_ensemble": 3,
+                "acq_fn_type": "its",
+                "acq_fn_optimization": acq_fn_optimization,
+                "encoding_type": "path",
+                "predictor": predictor,
+                "debug_predictor": False,
+                # config secton for successive halving/ hyperband,
+                "min_budget": 1,
+                "fidelity": fidelity,
+                "n_process": 1_000_000,
+                "budgets": None, 
+                # config section for bohb
+                "min_bandwith": 0.001,
+                "top_n_percent": 0.1,
+                "min_points_in_model": None,
+                # config section for dehb
+                "enc_dim": None,
+                "max_mutations": 1,
+                "crossover_prob": 0.5,
+                "mutate_prob": 0.5,
+            },
+        }
+        configs.append(config)
+        
+    for config_id in range(1, num_config):
+        sample_size = int(np.random.choice(range(5, 100)))
+        population_size = int(np.random.choice(range(5, 100)))
+        num_init = int(np.random.choice(range(5, 100)))
+        k = int(np.random.choice(range(10, 50)))
+        num_arches_to_mutate = int(np.random.choice(range(1, 20)))
+        max_mutations = int(np.random.choice(range(1, 20)))
+        num_candidates = int(np.random.choice(range(5, 50)))
+
+        # SH/HB
+        min_budget = int(np.random.choice(range(1, 50)))
+        eta = int(np.random.choice(range(2, 5)))
+        # BOHB
+        min_bandwith = float(np.random.choice(np.arange(0.0, 0.011, 0.001)))
+        top_n_percent = float(np.random.choice(np.arange(0.05, 0.31, 0.01)))
+        # DEHB
+        max_mutations = int(np.random.choice(range(1, 5)))
+        crossover_prob = float(np.random.choice(np.arange(0.0, 1.10, 0.1)))
+        mutate_prob = float(np.random.choice(np.arange(0.0, 1.10, 0.1)))
+
+        for seed in range(start_seed, start_seed + trials):
+            config = {
+                "seed": seed,
+                "search_space": None,
+                "dataset": None,
+                "optimizer": None,
+                "out_dir": out_dir,
+                "config_id": config_id,
+                "search": {
+                    "checkpoint_freq": checkpoint_freq,
+                    "epochs": epochs,
+                    "fidelity": fidelity,
+                    "sample_size": sample_size,
+                    "population_size": population_size,
+                    "num_init": num_init,
+                    "k": k,
+                    "num_ensemble": 3,
+                    "acq_fn_type": "its",
+                    "acq_fn_optimization": acq_fn_optimization,
+                    "encoding_type": "path",
+                    "num_arches_to_mutate": num_arches_to_mutate,
+                    "max_mutations": max_mutations,
+                    "num_candidates": num_candidates,
+                    "predictor": predictor,
+                    "debug_predictor": False,
+                    # config section for successive halving,
+                    # config secton for Hyperband,
+                    "min_budget": min_budget,
+                    "max_budget": None,
+                    "fidelity": fidelity,
+                    "n_process": 1_000_000,
+                    "budgets": None, 
+                    "eta": eta,
+                    "epsilon": 1e-6,
+                    # config section for BOHB
+                    "min_bandwith": min_bandwith,
+                    "top_n_percent": top_n_percent,
+                    "min_points_in_model": None,
+                    # config section for DEHB
+                    # config section for dehb
+                    "enc_dim": None,
+                    "max_mutations": max_mutations,
+                    "crossover_prob": crossover_prob,
+                    "mutate_prob": mutate_prob,
+                },
+            }
+            configs.append(config)
+    return configs
+
+
+def check_config(out_dir):
+    folder = os.path.join(out_dir)
+    config_files_path = os.path.join(folder, "**", "*.yaml")  
+    files = glob(config_files_path, recursive=True)
+    print(f"{len(files)} config file(s) created")
+
+def main():
+    with open("/Users/lars/Projects/NASLib_cleanup/naslib/benchmarks/mf/config.yaml", 'r') as stream:
+        config = yaml.safe_load(stream)
+    # convert such that config elements are accessiable via attributes
+    config = Dict(config)
+    start_seed = config.start_seed if config.start_seed else 0
+    trials = config.trials
+
+    optimizers = config.optimizers
+
+    out_dir = config.out_dir
+    out_dir_configs = config.out_dir_configs
+
+    search_spaces = config.search_space
+    datasets = config.datasets
+    num_config = config.num_config
+    configs = create_configs(
+            start_seed=start_seed,
+            trials=trials,
+            out_dir=out_dir,
+            num_config=num_config
+        )
+    for search_space, dataset, optimizer in itertools.product(search_spaces, datasets, optimizers):        
+        dump_configs(dataset=dataset, optimizer=optimizer, search_space=search_space, configs=configs, out_dir=out_dir_configs)
+    check_config(out_dir_configs)
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/naslib/benchmarks/mf/run_config.sh b/naslib/benchmarks/mf/run_config.sh
new file mode 100644
index 000000000..450d4c309
--- /dev/null
+++ b/naslib/benchmarks/mf/run_config.sh
@@ -0,0 +1,8 @@
+#!/bin/bash
+directory=/path/to/configs
+
+index=$1
+# selects config by index given from SLURM scheduler
+config_file_seed=$(ls -d $directory/* | sed "${index}q;d")
+
+/home/gernel/miniconda3/bin/python -u ~/work/NASLib/naslib/benchmarks/mf/runner.py --config-file $config_file_seed
diff --git a/naslib/benchmarks/mf/runner.py b/naslib/benchmarks/mf/runner.py
new file mode 100644
index 000000000..aacb9d759
--- /dev/null
+++ b/naslib/benchmarks/mf/runner.py
@@ -0,0 +1,59 @@
+import logging
+
+#from nasbench import api
+
+from naslib.defaults.trainer import Trainer
+from naslib.defaults.trainer_multifidelity import Trainer as Trainer_MF
+
+from naslib.optimizers import RandomSearch, Npenas, \
+RegularizedEvolution, LocalSearch, Bananas, SuccessiveHalving, HB, BOHB, DEHB
+
+from naslib.search_spaces.core.query_metrics import Metric
+from naslib.search_spaces import NasBench201SearchSpace, NasBenchASRSearchSpace
+from naslib.utils import utils, setup_logger, get_dataset_api
+
+# from torch.utils.tensorboard import SummaryWriter
+
+config = utils.get_config_from_args(config_type='bbo-bs')
+
+logger = setup_logger(config.save + "/log.log")
+logger.setLevel(logging.INFO)
+
+utils.log_args(config)
+
+# writer = SummaryWriter(config.save)
+
+supported_optimizers = {
+    'rs': RandomSearch,
+    're': RegularizedEvolution,
+    'bananas': Bananas,
+    'npenas': Npenas,
+    'ls': LocalSearch,
+    'sh': SuccessiveHalving,
+    'hb': HB,
+    'bohb': BOHB,
+    'dehb': DEHB,
+}
+
+supported_search_spaces = {
+    'nasbench201': NasBench201SearchSpace,    
+    'asr': NasBenchASRSearchSpace,
+}
+
+dataset_api = get_dataset_api(config.search_space, config.dataset)
+utils.set_seed(config.seed)
+
+search_space = supported_search_spaces[config.search_space]()
+
+metric = Metric.VAL_ACCURACY if config.search_space == 'darts' else None
+
+optimizer = supported_optimizers[config.optimizer](config)
+optimizer.adapt_search_space(search_space, dataset_api=dataset_api)
+
+trainer = Trainer(optimizer, config, lightweight_output=True)
+multi_fidelity_optimizers = {'sh', 'hb', 'bohb', 'dehb'}
+if config.optimizer in multi_fidelity_optimizers:
+    trainer = Trainer_MF(optimizer, config, lightweight_output=True)
+# trainer.search(resume_from="", summary_writer=writer, report_incumbent=False)
+trainer.search(resume_from="")
+trainer.evaluate(resume_from="", dataset_api=dataset_api)
diff --git a/naslib/benchmarks/mf/submit_array.sbatch b/naslib/benchmarks/mf/submit_array.sbatch
new file mode 100644
index 000000000..874ab6901
--- /dev/null
+++ b/naslib/benchmarks/mf/submit_array.sbatch
@@ -0,0 +1,19 @@
+#!/bin/bash
+#SBATCH -p bosch_cpu-cascadelake #bosch_gpu-rtx2080    #bosch_cpu-cascadelake  # partition (queue)
+#SBATCH -t 1-00:00           # time (D-HH:MM)
+#SBATCH --output=/path/to/log/%A_%a.%N.out
+#SBATCH --job-name=naslib-exps
+#SBATCH --chdir=/path/to/your/workdir
+#SBATCH --mem=40G
+#SBATCH --array=1-12000
+
+# array size needs to be set to amount of config files
+
+# Print some information about the job to STDOUT
+echo "Workingdir: $PWD";
+echo "Started at $(date)";
+echo "Running job $SLURM_JOB_NAME using $SLURM_JOB_CPUS_PER_NODE cpus per node with given JID $SLURM_JOB_ID on queue $SLURM_JOB_PARTITION";
+/path/to/run_config.sh $SLURM_ARRAY_TASK_ID
+ 
+echo "DONE";
+echo "Finished at $(date)";
diff --git a/naslib/benchmarks/nas_predictors/discrete_config.yaml b/naslib/benchmarks/nas_predictors/discrete_config.yaml
index 35c62de6f..750fcbff5 100644
--- a/naslib/benchmarks/nas_predictors/discrete_config.yaml
+++ b/naslib/benchmarks/nas_predictors/discrete_config.yaml
@@ -1,37 +1,41 @@
-seed: 0
-optimizer: bananas
-search_space: nasbench201
-dataset: cifar10
+config_id: 0
+dataset: None
+optimizer: sh
 out_dir: run
-
 search:
-  seed: 0
-  checkpoint_freq: 1000
-  epochs: 100
-  fidelity: -1
-
-  predictor_type: var_sparse_gp
-  num_init: 10  
-  k: 10
-
-  # BANANAS
-  num_ensemble: 3
+  acq_fn_optimization: mutation
   acq_fn_type: its
-  acq_fn_optimization: random_sampling
-  encoding_type: adjacency_one_hot
-  num_arches_to_mutate: 2
+  budget_max: 128
+  budget_type: epoch
+  budgets: 16000
+  checkpoint_freq: 5000
+  crossover_prob: 0.5
+  debug_predictor: false
+  enc_dim: 6
+  encoding_type: path
+  epochs: 200
+  epsilon: 1.0e-06
+  eta: 2
+  fidelity: 39
+  k: 10
+  max_budget: 39
   max_mutations: 1
-  num_candidates: 20
-  
-  # jacov data loader
-  batch_size: 256
-  data_size: 25000
-  cutout: False
-  cutout_length: 16
-  cutout_prob: 1.0
-  train_portion: 0.7
-  
-  # other params
-  debug_predictor: False
+  method: random
+  min_bandwith: 0.001
+  min_budget: 1
+  min_fidelity: 1
+  min_points_in_model: 7
+  mutate_prob: 0.5
+  n_process: 1000000
+  num_arches_to_mutate: 1
+  num_candidates: 50
+  num_ensemble: 3
+  num_init: 10
+  number_archs: 128
+  predictor_type: test
+  population_size: 50
+  predictor: var_sparse_gp
   sample_size: 10
-  population_size: 30
+  top_n_percent: 0.1
+search_space: asr
+seed: 0
diff --git a/naslib/benchmarks/nas_predictors/nas_predictor_config.yaml b/naslib/benchmarks/nas_predictors/nas_predictor_config.yaml
index 0c7fb5afd..4023f47ec 100644
--- a/naslib/benchmarks/nas_predictors/nas_predictor_config.yaml
+++ b/naslib/benchmarks/nas_predictors/nas_predictor_config.yaml
@@ -1,7 +1,7 @@
 seed: 0
 optimizer: oneshot
-search_space: darts
-dataset: cifar10
+search_space: asr
+dataset: None
 out_dir: run
 
 experiment_type: single
diff --git a/naslib/benchmarks/predictors/predictor_config.yaml b/naslib/benchmarks/predictors/predictor_config.yaml
index 5c88a81bb..c00753e12 100644
--- a/naslib/benchmarks/predictors/predictor_config.yaml
+++ b/naslib/benchmarks/predictors/predictor_config.yaml
@@ -7,10 +7,10 @@
 experiment_type: single
 
 # nasbench101, nasbench201, darts, or nlp
-search_space: nasbench201
+search_space: asr
 
 # cifar10, cifar100, or ImageNet16-120 (only important for nasbench201)
-dataset: cifar10
+dataset: None
 
 # one of the 31 predictors in benchmarks/predictors/runner.py
 predictor: xgb
diff --git a/naslib/defaults/trainer_multifidelity.py b/naslib/defaults/trainer_multifidelity.py
new file mode 100644
index 000000000..bb559254e
--- /dev/null
+++ b/naslib/defaults/trainer_multifidelity.py
@@ -0,0 +1,598 @@
+import codecs
+import time
+import json
+import logging
+import os
+import copy
+import torch
+import numpy as np
+import gc
+from fvcore.common.checkpoint import PeriodicCheckpointer
+
+from naslib.search_spaces.core.query_metrics import Metric
+
+from naslib.utils import utils
+from naslib.utils.logging import log_every_n_seconds, log_first_n
+
+from .additional_primitives import DropPathWrapper
+
+logger = logging.getLogger(__name__)
+
+
+class Trainer(object):
+    """
+    Default implementation that handles dataloading and preparing batches, the
+    train loop, gathering statistics, checkpointing and doing the final
+    final evaluation.
+    This trainer is purposed for multi-fidelity optimizers.
+    """
+
+    def __init__(self, optimizer, config, lightweight_output=False):
+        """
+        Initializes the trainer.
+        Args:
+            optimizer: A NASLib optimizer
+            config (AttrDict): The configuration loaded from a yaml file, e.g
+                via  `utils.get_config_from_args()`
+        """
+        self.optimizer = optimizer
+        self.config = config
+        self.lightweight_output = lightweight_output
+        self.n_process = config.search.n_process
+
+        # anytime
+        computed_epochs = self.optimizer.compute_epochs()
+        self.budgets = self.config.search.budgets
+        self.search_time = 0
+        if computed_epochs is not None:
+            self.epochs, self.rounds = computed_epochs
+        else:
+            self.epochs = config.search.epochs
+
+        # preparations
+        self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+        # measuring stuff
+        self.train_top1 = utils.AverageMeter()
+        self.train_top5 = utils.AverageMeter()
+        self.train_loss = utils.AverageMeter()
+        self.val_top1 = utils.AverageMeter()
+        self.val_top5 = utils.AverageMeter()
+        self.val_loss = utils.AverageMeter()
+
+        n_parameters = optimizer.get_model_size()
+        logger.info("param size = %fMB", n_parameters)
+        self.errors_dict = utils.AttrDict(
+            {'train_acc': [],
+             'train_loss': [],
+             'valid_acc': [],
+             'valid_loss': [],
+             'test_acc': [],
+             'test_loss': [],
+             'runtime': [],
+             'train_time': [],
+             'arch_eval': [],
+             'latest_arch': [],
+             'latest_acc': [],
+             'params': n_parameters}
+        )
+
+    def search(self, resume_from=""):
+        """
+        Start the architecture search.
+        Generates a json file with training statistics.
+        Args:
+            resume_from (str): Checkpoint file to resume from. If not given then
+                train from scratch.
+        """
+        logger.info("Start training")
+
+        np.random.seed(self.config.search.seed)
+        torch.manual_seed(self.config.search.seed)
+
+        self.optimizer.before_training()
+        checkpoint_freq = self.config.search.checkpoint_freq
+        if self.optimizer.using_step_function:
+            self.scheduler = self.build_search_scheduler(self.optimizer.op_optimizer, self.config)
+            start_epoch = self._setup_checkpointers(resume_from, period=checkpoint_freq, scheduler=self.scheduler)
+        else:
+            start_epoch = self._setup_checkpointers(resume_from, period=checkpoint_freq)
+
+        if self.optimizer.using_step_function:
+            self.train_queue, self.valid_queue, _ = self.build_search_dataloaders(self.config)
+
+        if type(self.epochs) is list:
+            for i in range(self.n_process):
+                for epochs, round in zip(self.epochs, self.rounds):
+                    for e in range(start_epoch, sum(epochs)):
+                        start_time = time.time()
+                        self.optimizer.new_epoch(e, round, i)
+
+                        if self.optimizer.using_step_function:
+                            for step, data_train in enumerate(self.train_queue):
+                                data_train = (
+                                    data_train[0].to(self.device), data_train[1].to(self.device, non_blocking=True))
+                                data_val = next(iter(self.valid_queue))
+                                data_val = (data_val[0].to(self.device), data_val[1].to(self.device, non_blocking=True))
+
+                                stats = self.optimizer.step(data_train, data_val)
+                                logits_train, logits_val, train_loss, val_loss = stats
+
+                                self._store_accuracies(logits_train, data_train[1], 'train')
+                                self._store_accuracies(logits_val, data_val[1], 'val')
+
+                                log_every_n_seconds(logging.INFO,
+                                                    "Round {}: Epoch {}-{}, Train loss: {:.5f}, validation loss: {:.5f}, learning rate: {}".format(
+                                                        round, e, step, train_loss, val_loss,
+                                                        self.scheduler.get_last_lr()), n=5)
+
+                                if torch.cuda.is_available():
+                                    log_first_n(logging.INFO,
+                                                "cuda consumption\n {}".format(torch.cuda.memory_summary()),
+                                                n=3)
+
+                                self.train_loss.update(float(train_loss.detach().cpu()))
+                                self.val_loss.update(float(val_loss.detach().cpu()))
+
+                            self.scheduler.step()
+
+                            end_time = time.time()
+
+                            self.errors_dict.train_acc.append(self.train_top1.avg)
+                            self.errors_dict.train_loss.append(self.train_loss.avg)
+                            self.errors_dict.valid_acc.append(self.val_top1.avg)
+                            self.errors_dict.valid_loss.append(self.val_loss.avg)
+                            self.errors_dict.runtime.append(end_time - start_time)
+                        else:
+                            end_time = time.time()
+                            train_acc, valid_acc, test_acc, train_time = self.optimizer.train_statistics()
+                            train_loss, valid_loss, test_loss = -1, -1, -1
+
+                            self.errors_dict.train_acc.append(train_acc)
+                            self.errors_dict.train_loss.append(train_loss)
+                            self.errors_dict.valid_acc.append(valid_acc)
+                            self.errors_dict.valid_loss.append(valid_loss)
+                            self.errors_dict.test_acc.append(test_acc)
+                            self.errors_dict.test_loss.append(test_loss)
+                            self.errors_dict.runtime.append(end_time - start_time)
+                            self.train_top1.avg = train_acc
+                            self.val_top1.avg = valid_acc
+                            if train_time > 0:
+                                self.search_time += end_time - start_time
+                                self.search_time += train_time
+                            else:
+                                # case if we do not work with train_time as budget, like in NASBenchASR
+                                _, latest_arch_epoch = self.optimizer.get_latest_architecture()
+                                self.search_time += 1 * latest_arch_epoch
+                                train_time = 1 * latest_arch_epoch
+                            self.errors_dict.train_time.append(train_time)
+                        self.periodic_checkpointer.step(e)
+
+                        anytime_results = self.optimizer.test_statistics()
+                        if anytime_results:
+                            # record anytime performance
+                            self.errors_dict.arch_eval.append(anytime_results)
+                            log_every_n_seconds(logging.INFO, "Round {} Epoch {}, Anytime results: {}".format(
+                                round, e, anytime_results), n=5)
+
+                        self._log_to_json()
+                        self._log_and_reset_accuracies(e, round, i)
+                        if self.search_time > self.budgets:
+                            return
+
+                    self.optimizer.after_training()
+        else:
+            for e in range(start_epoch, self.epochs):
+                start_time = time.time()
+                self.optimizer.new_epoch(e)
+                if self.optimizer.using_step_function:
+                    for step, data_train in enumerate(self.train_queue):
+                        data_train = (data_train[0].to(self.device), data_train[1].to(self.device, non_blocking=True))
+                        data_val = next(iter(self.valid_queue))
+                        data_val = (data_val[0].to(self.device), data_val[1].to(self.device, non_blocking=True))
+
+                        stats = self.optimizer.step(data_train, data_val)
+                        logits_train, logits_val, train_loss, val_loss = stats
+
+                        self._store_accuracies(logits_train, data_train[1], 'train')
+                        self._store_accuracies(logits_val, data_val[1], 'val')
+
+                        log_every_n_seconds(logging.INFO,
+                                            "Epoch {}-{}, Train loss: {:.5f}, validation loss: {:.5f}, learning rate: {}".format(
+                                                e, step, train_loss, val_loss, self.scheduler.get_last_lr()), n=5)
+
+                        if torch.cuda.is_available():
+                            log_first_n(logging.INFO, "cuda consumption\n {}".format(torch.cuda.memory_summary()), n=3)
+
+                        self.train_loss.update(float(train_loss.detach().cpu()))
+                        self.val_loss.update(float(val_loss.detach().cpu()))
+
+                    self.scheduler.step()
+
+                    end_time = time.time()
+
+                    self.errors_dict.train_acc.append(self.train_top1.avg)
+                    self.errors_dict.train_loss.append(self.train_loss.avg)
+                    self.errors_dict.valid_acc.append(self.val_top1.avg)
+                    self.errors_dict.valid_loss.append(self.val_loss.avg)
+                    self.errors_dict.runtime.append(end_time - start_time)
+                else:
+                    end_time = time.time()
+                    train_acc, valid_acc, test_acc, train_time = self.optimizer.train_statistics()
+                    train_loss, valid_loss, test_loss = -1, -1, -1
+
+                    self.errors_dict.train_acc.append(train_acc)
+                    self.errors_dict.train_loss.append(train_loss)
+                    self.errors_dict.valid_acc.append(valid_acc)
+                    self.errors_dict.valid_loss.append(valid_loss)
+                    self.errors_dict.test_acc.append(test_acc)
+                    self.errors_dict.test_loss.append(test_loss)
+                    self.errors_dict.runtime.append(end_time - start_time)
+
+                    self.train_top1.avg = train_acc
+                    self.val_top1.avg = valid_acc
+                    if train_time > 0:
+                        self.search_time += end_time - start_time
+                        self.search_time += train_time
+                    else:
+                        # case if we do not work with train_time as budget, like in NASBenchASR
+                        _, latest_arch_epoch = self.optimizer.get_latest_architecture()
+                        self.search_time += 1 * latest_arch_epoch
+                        train_time = 1
+                    self.errors_dict.train_time.append(train_time)
+
+                self.periodic_checkpointer.step(e)
+
+                anytime_results = self.optimizer.test_statistics()
+                if anytime_results:
+                    # record anytime performance
+                    self.errors_dict.arch_eval.append(anytime_results)
+                    log_every_n_seconds(logging.INFO, "Epoch {}, Anytime results: {}".format(
+                        e, anytime_results), n=5)
+
+                self._log_to_json()
+                self._log_and_reset_accuracies(e)
+                if self.search_time > self.budgets:
+                    gc.collect()
+                    return
+
+            self.optimizer.after_training()
+        logger.info("Training finished. Total Budgets[s]: {}".format(self.search_time))
+
+    def evaluate_oneshot(self, resume_from="", dataloader=None):
+        """
+        Evaluate the one-shot model on the specified dataset.
+        Generates a json file with training statistics.
+        Args:
+            resume_from (str): Checkpoint file to resume from. If not given then
+                evaluate with the current one-shot weights.
+        """
+        logger.info("Start one-shot evaluation")
+        self.optimizer.before_training()
+        self._setup_checkpointers(resume_from)
+
+        loss = torch.nn.CrossEntropyLoss()
+
+        if dataloader is None:
+            # load only the validation data
+            _, dataloader, _ = self.build_search_dataloaders(self.config)
+
+        self.optimizer.graph.eval()
+        with torch.no_grad():
+            start_time = time.time()
+            for step, data_val in enumerate(dataloader):
+                input_val = data_val[0].to(self.device)
+                target_val = data_val[1].to(self.device, non_blocking=True)
+
+                logits_val = self.optimizer.graph(input_val)
+                val_loss = loss(logits_val, target_val)
+
+                self._store_accuracies(logits_val, data_val[1], 'val')
+                self.val_loss.update(float(val_loss.detach().cpu()))
+
+            end_time = time.time()
+
+            self.errors_dict.valid_acc.append(self.val_top1.avg)
+            self.errors_dict.valid_loss.append(self.val_loss.avg)
+            self.errors_dict.runtime.append(end_time - start_time)
+
+            self._log_to_json()
+
+        logger.info("Evaluation finished")
+        return self.val_top1.avg
+
+    def evaluate(
+            self,
+            retrain=True,
+            search_model="",
+            resume_from="",
+            best_arch=None,
+            dataset_api=None
+    ):
+        """
+        Evaluate the final architecture as given from the optimizer.
+        If the search space has an interface to a benchmark then query that.
+        Otherwise train as defined in the config.
+        Args:
+            retrain (bool): Reset the weights from the architecure search
+            search_model (str): Path to checkpoint file that was created during
+                search. If not provided, then try to load 'model_final.pth' from search
+            resume_from (str): Resume retraining from the given checkpoint file.
+            best_arch: Parsed model you want to directly evaluate and ignore the final model
+                from the optimizer.
+        """
+        logger.info("Start evaluation")
+        if not best_arch:
+
+            if not search_model:
+                search_model = os.path.join(self.config.save, "search", "model_final.pth")
+            self._setup_checkpointers(search_model)  # required to load the architecture
+
+            best_arch, _ = self.optimizer.get_final_architecture()
+        logger.info("Final architecture:\n" + best_arch.modules_str())
+
+        if best_arch.QUERYABLE:
+            metric = Metric.TEST_ACCURACY
+            result = best_arch.query(
+                metric=metric, dataset=self.config.dataset, dataset_api=dataset_api
+            )
+            logger.info("Queried results ({}): {}".format(metric, result))
+        else:
+            best_arch.to(self.device)
+            if retrain:
+                logger.info("Starting retraining from scratch")
+                best_arch.reset_weights(inplace=True)
+
+                self.train_queue, self.valid_queue, self.test_queue = self.build_eval_dataloaders(self.config)
+
+                optim = self.build_eval_optimizer(best_arch.parameters(), self.config)
+                scheduler = self.build_eval_scheduler(optim, self.config)
+
+                start_epoch = self._setup_checkpointers(
+                    resume_from,
+                    search=False,
+                    period=self.config.evaluation.checkpoint_freq,
+                    model=best_arch,  # checkpointables start here
+                    optim=optim,
+                    scheduler=scheduler
+                )
+
+                grad_clip = self.config.evaluation.grad_clip
+                loss = torch.nn.CrossEntropyLoss()
+
+                best_arch.train()
+                self.train_top1.reset()
+                self.train_top5.reset()
+                self.val_top1.reset()
+                self.val_top5.reset()
+
+                # Enable drop path
+                best_arch.update_edges(
+                    update_func=lambda edge: edge.data.set('op', DropPathWrapper(edge.data.op)),
+                    scope=best_arch.OPTIMIZER_SCOPE,
+                    private_edge_data=True
+                )
+
+                # train from scratch
+                epochs = self.config.evaluation.epochs
+                for e in range(start_epoch, epochs):
+                    if torch.cuda.is_available():
+                        log_first_n(logging.INFO, "cuda consumption\n {}".format(torch.cuda.memory_summary()), n=20)
+
+                    # update drop path probability
+                    drop_path_prob = self.config.evaluation.drop_path_prob * e / epochs
+                    best_arch.update_edges(
+                        update_func=lambda edge: edge.data.set('drop_path_prob', drop_path_prob),
+                        scope=best_arch.OPTIMIZER_SCOPE,
+                        private_edge_data=True
+                    )
+
+                    # Train queue
+                    for i, (input_train, target_train) in enumerate(self.train_queue):
+                        input_train = input_train.to(self.device)
+                        target_train = target_train.to(self.device, non_blocking=True)
+
+                        optim.zero_grad()
+                        logits_train = best_arch(input_train)
+                        train_loss = loss(logits_train, target_train)
+                        if hasattr(best_arch, 'auxilary_logits'):  # darts specific stuff
+                            log_first_n(logging.INFO, "Auxiliary is used", n=10)
+                            auxiliary_loss = loss(best_arch.auxilary_logits(), target_train)
+                            train_loss += self.config.evaluation.auxiliary_weight * auxiliary_loss
+                        train_loss.backward()
+                        if grad_clip:
+                            torch.nn.utils.clip_grad_norm_(best_arch.parameters(), grad_clip)
+                        optim.step()
+
+                        self._store_accuracies(logits_train, target_train, 'train')
+                        log_every_n_seconds(logging.INFO, "Epoch {}-{}, Train loss: {:.5}, learning rate: {}".format(
+                            e, i, train_loss, scheduler.get_last_lr()), n=5)
+
+                    # Validation queue
+                    if self.valid_queue:
+                        for i, (input_valid, target_valid) in enumerate(self.valid_queue):
+                            input_valid = input_valid.cuda().float()
+                            target_valid = target_valid.cuda().float()
+
+                            # just log the validation accuracy
+                            with torch.no_grad():
+                                logits_valid = best_arch(input_valid)
+                                self._store_accuracies(logits_valid, target_valid, 'val')
+
+                    scheduler.step()
+                    self.periodic_checkpointer.step(e)
+                    self._log_and_reset_accuracies(e)
+
+            # Disable drop path
+            best_arch.update_edges(
+                update_func=lambda edge: edge.data.set('op', edge.data.op.get_embedded_ops()),
+                scope=best_arch.OPTIMIZER_SCOPE,
+                private_edge_data=True
+            )
+
+            # measure final test accuracy
+            top1 = utils.AverageMeter()
+            top5 = utils.AverageMeter()
+
+            best_arch.eval()
+
+            for i, data_test in enumerate(self.test_queue):
+                input_test, target_test = data_test
+                input_test = input_test.to(self.device)
+                target_test = target_test.to(self.device, non_blocking=True)
+
+                n = input_test.size(0)
+
+                with torch.no_grad():
+                    logits = best_arch(input_test)
+
+                    prec1, prec5 = utils.accuracy(logits, target_test, topk=(1, 5))
+                    top1.update(prec1.data.item(), n)
+                    top5.update(prec5.data.item(), n)
+
+                log_every_n_seconds(logging.INFO, "Inference batch {} of {}.".format(i, len(self.test_queue)), n=5)
+
+            logger.info("Evaluation finished. Test accuracies: top-1 = {:.5}, top-5 = {:.5}".format(top1.avg, top5.avg))
+
+    @staticmethod
+    def build_search_dataloaders(config):
+        train_queue, valid_queue, test_queue, _, _ = utils.get_train_val_loaders(config, mode='train')
+        return train_queue, valid_queue, _  # test_queue is not used in search currently
+
+    @staticmethod
+    def build_eval_dataloaders(config):
+        train_queue, valid_queue, test_queue, _, _ = utils.get_train_val_loaders(config, mode='val')
+        return train_queue, valid_queue, test_queue
+
+    @staticmethod
+    def build_eval_optimizer(parameters, config):
+        return torch.optim.SGD(
+            parameters,
+            lr=config.evaluation.learning_rate,
+            momentum=config.evaluation.momentum,
+            weight_decay=config.evaluation.weight_decay,
+        )
+
+    @staticmethod
+    def build_search_scheduler(optimizer, config):
+        return torch.optim.lr_scheduler.CosineAnnealingLR(
+            optimizer,
+            T_max=config.search.epochs,
+            eta_min=config.search.learning_rate_min
+        )
+
+    @staticmethod
+    def build_eval_scheduler(optimizer, config):
+        return torch.optim.lr_scheduler.CosineAnnealingLR(
+            optimizer,
+            T_max=config.evaluation.epochs,
+            eta_min=config.evaluation.learning_rate_min
+        )
+
+    def _log_and_reset_accuracies(self, epoch, *args):
+        if args:
+            r, i = args[0], args[1]
+            logger.info(
+                "Process: {}, Round {} Epoch {} done. Train accuracy (top1): {:.5f}, Validation accuracy: {:.5f}, Query time: {:.5f}, Training time: {:.5f}, Accumulated time: {:.5f}".format(
+                    i,
+                    r,
+                    epoch,
+                    self.train_top1.avg,
+                    self.val_top1.avg,
+                    self.errors_dict['runtime'][-1],
+                    self.errors_dict['train_time'][-1],
+                    sum(self.errors_dict['runtime']) +
+                    sum(self.errors_dict['train_time'])
+                ))
+        else:
+            logger.info(
+                "Epoch {} done. Train accuracy (top1): {:.5f}, Validation accuracy: {:.5f}, Query time: {:.5f}, Training time: {:.5f}, Accumulated time: {:.5f}".format(
+                    epoch,
+                    self.train_top1.avg,
+                    self.val_top1.avg,
+                    self.errors_dict['runtime'][-1],
+                    self.errors_dict['train_time'][-1],
+                    sum(self.errors_dict['runtime']) +
+                    sum(self.errors_dict['train_time']),
+                ))
+        self.train_top1.reset()
+        self.train_top5.reset()
+        self.train_loss.reset()
+        self.val_top1.reset()
+        self.val_top5.reset()
+        self.val_loss.reset()
+
+    def _store_accuracies(self, logits, target, split):
+        """Update the accuracy counters"""
+        logits = logits.clone().detach().cpu()
+        target = target.clone().detach().cpu()
+        prec1, prec5 = utils.accuracy(logits, target, topk=(1, 5))
+        n = logits.size(0)
+
+        if split == 'train':
+            self.train_top1.update(prec1.data.item(), n)
+            self.train_top5.update(prec5.data.item(), n)
+        elif split == 'val':
+            self.val_top1.update(prec1.data.item(), n)
+            self.val_top5.update(prec5.data.item(), n)
+        else:
+            raise ValueError("Unknown split: {}. Expected either 'train' or 'val'")
+
+    def _prepare_dataloaders(self, config, mode='train'):
+        """
+        Prepare train, validation, and test dataloaders with the splits defined
+        in the config.
+        Args:
+            config (AttrDict): config from config file.
+        """
+        train_queue, valid_queue, test_queue, _, _ = utils.get_train_val_loaders(config, mode)
+        self.train_queue = train_queue
+        self.valid_queue = valid_queue
+        self.test_queue = test_queue
+
+    def _setup_checkpointers(self, resume_from="", search=True, period=1, **add_checkpointables):
+        """
+        Sets up a periodic chechkpointer which can be used to save checkpoints
+        at every epoch. It will call optimizer's `get_checkpointables()` as objects
+        to store.
+        Args:
+            resume_from (str): A checkpoint file to resume the search or evaluation from.
+            search (bool): Whether search or evaluation phase is checkpointed. This is required
+                because the files are in different folders to not be overridden
+            add_checkpointables (object): Additional things to checkpoint together with the
+                optimizer's checkpointables.
+        """
+        checkpointables = self.optimizer.get_checkpointables()
+        checkpointables.update(add_checkpointables)
+
+        checkpointer = utils.Checkpointer(
+            model=checkpointables.pop('model'),
+            save_dir=self.config.save + "/search" if search else self.config.save + "/eval",
+            # **checkpointables #NOTE: this is throwing an Error
+        )
+
+        self.periodic_checkpointer = PeriodicCheckpointer(
+            checkpointer,
+            period=period,
+            max_iter=1)
+
+        if resume_from:
+            logger.info("loading model from file {}".format(resume_from))
+            checkpoint = checkpointer.resume_or_load(resume_from, resume=True)
+            if checkpointer.has_checkpoint():
+                return checkpoint.get("iteration", -1) + 1
+        return 0
+
+    def _log_to_json(self):
+        """log training statistics to json file"""
+        if not os.path.exists(self.config.save):
+            os.makedirs(self.config.save)
+        if not self.lightweight_output:
+            with codecs.open(os.path.join(self.config.save, 'errors.json'), 'w', encoding='utf-8') as file:
+                json.dump(self.errors_dict, file, separators=(',', ':'))
+        else:
+            with codecs.open(os.path.join(self.config.save, 'errors.json'), 'w', encoding='utf-8') as file:
+                lightweight_dict = copy.deepcopy(self.errors_dict)
+                for key in ['arch_eval', 'train_loss', 'valid_loss', 'test_loss']:
+                    lightweight_dict.pop(key)
+                json.dump([self.config, lightweight_dict], file, separators=(',', ':'))
diff --git a/naslib/optimizers/__init__.py b/naslib/optimizers/__init__.py
index c7cdb2393..5b4a8f25f 100644
--- a/naslib/optimizers/__init__.py
+++ b/naslib/optimizers/__init__.py
@@ -4,8 +4,12 @@
 from .oneshot.gdas.optimizer import GDASOptimizer
 from .oneshot.drnas.optimizer import DrNASOptimizer
 from .discrete.rs.optimizer import RandomSearch
+from .discrete.sh.optimizer import SuccessiveHalving
 from .discrete.re.optimizer import RegularizedEvolution
 from .discrete.ls.optimizer import LocalSearch
 from .discrete.bananas.optimizer import Bananas
 from .discrete.bp.optimizer import BasePredictor
 from .discrete.npenas.optimizer import Npenas
+from .discrete.hb.optimizer import HB
+from .discrete.bohb.optimizer import BOHB
+from .discrete.dehb.optimizer import DEHB
diff --git a/naslib/optimizers/core/metaclasses.py b/naslib/optimizers/core/metaclasses.py
index b97ce83e8..f12aa5af6 100644
--- a/naslib/optimizers/core/metaclasses.py
+++ b/naslib/optimizers/core/metaclasses.py
@@ -38,6 +38,13 @@ def test_statistics(self):
         Return anytime test statistics if provided by the optimizer
         """
         pass
+    
+
+    def compute_epochs(self):
+        """
+        Return anytime epochs if provided by the optimizer
+        """
+        return None
 
     @abstractmethod
     def adapt_search_space(self, search_space, scope=None):
diff --git a/naslib/optimizers/discrete/bohb/__init__.py b/naslib/optimizers/discrete/bohb/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/naslib/optimizers/discrete/bohb/optimizer.py b/naslib/optimizers/discrete/bohb/optimizer.py
new file mode 100644
index 000000000..966eb8134
--- /dev/null
+++ b/naslib/optimizers/discrete/bohb/optimizer.py
@@ -0,0 +1,301 @@
+import collections
+import copy
+import logging
+import math
+import numpy as np
+import os
+import statsmodels.api as sm
+import torch
+
+from naslib.optimizers.core.metaclasses import MetaOptimizer
+from naslib.search_spaces.core.query_metrics import Metric
+from naslib.utils.logging import log_every_n_seconds
+from naslib.utils.utils import AttrDict, count_parameters_in_MB
+
+logger = logging.getLogger(__name__)
+
+
+class BOHB(MetaOptimizer):
+    """
+    This implementation is mainly based on https://github.com/automl/nas-bench-x11. 
+    Falkner, Stefan, et al. 
+    BOHB: Robust and Efficient Hyperparameter Optimization at Scale. arXiv:1807.01774, 
+    arXiv, 4th July 2018. arXiv.org, http://arxiv.org/abs/1807.01774.
+    """
+    # training the models is not implemented
+    using_step_function = False
+
+    def __init__(self, config):
+        super().__init__()
+        # Hyperband related stuff
+        self.config = config
+        self.rounds = []
+        self.round_sizes = []
+        self.fidelities = []
+        self.min_bandwidth = self.config.search.min_bandwith
+        self.kde_models = dict()
+        self._epsilon = float(self.config.search.epsilon)
+        self.min_budget = self.config.search.min_budget
+        self.max_budget = self.config.search.max_budget
+        self.eta = self.config.search.eta
+        self.min_points_in_model = self.config.search.min_points_in_model
+        self.top_n_percent = self.config.search.top_n_percent
+        self.min_budget = min(self.min_budget, self.max_budget)
+        s_max = math.floor(math.log(self.max_budget / self.min_budget, self.eta) + self._epsilon)
+        # set up round sizes, fidelities, and list of arches
+        for s in reversed(range(s_max + 1)):
+            self.rounds.append(s)
+            round_sizes = []
+            fidelities = []
+            n = math.ceil((s_max + 1) * self.eta ** s / (s + 1) - self._epsilon)  # initial number of configurations
+            r = self.max_budget / self.eta ** s  # initial number of iterations to run configurations for
+            for i in range(s + 1):
+                n_i = math.floor(n / self.eta ** i + self._epsilon)
+                r_i = min(math.floor(r * self.eta ** i + self._epsilon), config.search.fidelity)
+                round_sizes.append(n_i)
+                fidelities.append(r_i)
+            self.round_sizes.append(round_sizes)
+            self.fidelities.append(fidelities)
+        for budget in self.fidelities[0][1:]:
+            budget = min(budget, config.search.fidelity)
+            self.kde_models[budget] = {}
+            self.kde_models[budget]['good'] = collections.deque(maxlen=300)
+            self.kde_models[budget]['bad'] = collections.deque(maxlen=300)
+            self.kde_models[budget]['minimize_kde'] = None
+        self.performance_metric = Metric.VAL_ACCURACY
+        self.dataset = config.dataset
+        self.history = torch.nn.ModuleList()
+
+        self.epochs = self.compute_epochs()
+        self.current_round = []
+        self.current_round_ = []
+        self.next_round = []
+        self.round_number = 0
+        self.prev_round = 0
+        self.process = 0
+
+    def adapt_search_space(self, search_space, scope=None, dataset_api=None):
+        assert search_space.QUERYABLE, "Hyperband_simple is currently only implemented for benchmarks."
+        self.search_space = search_space.clone()
+        self.scope = scope if scope else search_space.OPTIMIZER_SCOPE
+        self.dataset_api = dataset_api
+        self.max_training_epoch = self.search_space.get_max_epochs()
+
+    def compute_epochs(self):
+        return self.round_sizes, self.rounds[::-1]
+
+    def impute_conditional_data(self, array):
+        return_array = np.zeros(array.shape)
+        for i in range(array.shape[0]):
+            datum = np.copy(array[i])
+            nan_indices = np.argwhere(np.isnan(datum)).flatten()
+            while np.any(nan_indices):
+                nan_idx = nan_indices[0]
+                valid_indices = np.argwhere(np.isfinite(array[:, nan_idx])).flatten()
+                if valid_indices:
+                    # pick one of them at random and overwrite all NaN values
+                    row_idx = np.random.choice(valid_indices)
+                    datum[nan_indices] = array[row_idx, nan_indices]
+                else:
+                    # no good point in the data has this value activated, so fill it with a valid but random value
+                    t = self.vartypes[nan_idx]
+                    if t == 0:
+                        datum[nan_idx] = np.random.rand()
+                    else:
+                        datum[nan_idx] = np.random.randint(t)
+                nan_indices = np.argwhere(np.isnan(datum)).flatten()
+            return_array[i, :] = datum
+        return return_array
+
+    def fit_kde(self, round):
+        budget = self.fidelities[round][0]
+        good_models = self.kde_models[budget]['good']
+        bad_models = self.kde_models[budget]['bad']
+        if self.config.search_space == 'nasbench101':
+            from naslib.predictors.utils.encodings_nb101 import encode_101
+            good_enc = np.array([encode_101(m.arch, encoding_type='adjacency_cat') for m in good_models])
+            bad_enc = np.array([encode_101(m.arch, encoding_type='adjacency_cat') for m in bad_models])
+            self.kde_vartypes = ""
+            self.vartypes = []
+            for _ in range(len(good_enc[0]) - 5):  # adj encoding + one-hot ops list
+                self.kde_vartypes += 'u'
+                self.vartypes += [2]
+            for _ in range(len(good_enc[0]) - 5, len(good_enc[0])):  # adj encoding + one-hot ops list
+                self.kde_vartypes += 'u'
+                self.vartypes += [3]
+        elif self.config.search_space == "nasbench201":
+            from naslib.search_spaces.nasbench201.conversions import convert_naslib_to_op_indices
+            good_enc = np.array([convert_naslib_to_op_indices(m.arch) for m in good_models])
+            bad_enc = np.array([convert_naslib_to_op_indices(m.arch) for m in bad_models])
+            self.kde_vartypes = ""
+            self.vartypes = []
+            for _ in range(len(good_enc[0])):  # we use unordered discrete variable
+                self.kde_vartypes += 'u'
+                self.vartypes += [5]  # depend on the encoding of search spaces
+        elif self.config.search_space == "darts":
+            from naslib.search_spaces.darts.conversions import convert_naslib_to_compact, \
+                make_compact_mutable, convert_mutable_to_vector
+            good_enc = np.array(
+                [convert_mutable_to_vector(make_compact_mutable(convert_naslib_to_compact(m.arch))) for m in
+                 good_models])
+            bad_enc = np.array(
+                [convert_mutable_to_vector(make_compact_mutable(convert_naslib_to_compact(m.arch))) for m in
+                 bad_models])
+            self.kde_vartypes = ""
+            self.vartypes = []
+            for i in range(len(good_enc[0])):  # we use unordered discrete variable
+                self.kde_vartypes += 'u'
+                if i % 2 == 0:
+                    self.vartypes += [5]  # depend on the encoding of search spaces
+                else:
+                    self.vartypes += [7]
+        elif self.config.search_space == "asr":
+            good_enc = np.array([sum(m.arch.get_compact(), []) for m in good_models])
+            bad_enc = np.array([sum(m.arch.get_compact(), []) for m in bad_models])
+            self.kde_vartypes = ""
+            self.vartypes = []
+            for i in range(len(good_enc[0])):  # we use unordered discrete variable
+                self.kde_vartypes += 'u'
+                if i == 0 or i == 2 or i == 5:
+                    self.vartypes += [6]
+                else:
+                    self.vartypes += [2]
+
+        self.vartypes = np.array(self.vartypes, dtype=int)
+        good_enc = self.impute_conditional_data(good_enc)
+        bad_enc = self.impute_conditional_data(bad_enc)
+        self.good_kde = sm.nonparametric.KDEMultivariate(data=good_enc, var_type=self.kde_vartypes,
+                                                         bw='normal_reference')
+        self.bad_kde = sm.nonparametric.KDEMultivariate(data=bad_enc, var_type=self.kde_vartypes,
+                                                        bw='normal_reference')
+        self.bad_kde.bw = np.clip(self.bad_kde.bw, self.min_bandwidth, None)
+        self.good_kde.bw = np.clip(self.good_kde.bw, self.min_bandwidth, None)
+        l = self.good_kde.pdf
+        g = self.bad_kde.pdf
+        self.minimize_me = lambda x: max(1e-32, g(x) / max(l(x), 1e-32))
+
+    def new_epoch(self, epoch, round, i):
+        if self.process < i:  # re-init for each new process
+            del self.current_round
+            del self.next_round
+            self.current_round_ = []
+            self.current_round = []
+            self.next_round = []
+            self.round_number = 0
+            self.prev_round = 0
+            self.process = i
+            self.clean_history()
+
+        if self.prev_round < round:  # reset round_number for each new round
+            self.prev_round = round
+            self.round_number = 0
+
+        if epoch < self.round_sizes[round][0]:
+            # sample random architectures
+            model = torch.nn.Module()  # hacky way to get arch and accuracy checkpointable
+            model.arch = self.search_space.clone()
+            budget = self.fidelities[round][0]
+            if round == 0:
+                model.arch.sample_random_architecture(dataset_api=self.dataset_api)
+            else:
+                logger.info("budget: {}, the number of good enc: {}".format(budget, len(self.kde_models[budget]['good'])))
+                logger.info("budget: {}, the number of bad enc: {}".format(budget, len(self.kde_models[budget]['bad'])))
+                if epoch == 0 and \
+                        len(self.kde_models[budget]['good']) >= self.min_points_in_model and \
+                        len(self.kde_models[budget]['bad']) >= self.min_points_in_model:
+                    self.fit_kde(round)
+                    self.kde_models[budget]['minimize_kde'] = True
+                if not self.kde_models[budget]['minimize_kde']:
+                    model.arch.sample_random_architecture(dataset_api=self.dataset_api)
+                else:
+                    model.arch.model_based_sample_architecture(dataset_api=self.dataset_api,
+                                                               minimize_me=self.minimize_me,
+                                                               good_kde=self.good_kde,
+                                                               vartypes=self.vartypes
+                                                               )
+
+            model.epoch = min(self.fidelities[round][0], self.max_training_epoch)
+            model.accuracy = model.arch.query(self.performance_metric,
+                                              self.dataset,
+                                              epoch=model.epoch,
+                                              dataset_api=self.dataset_api)
+            self._update_history(model)
+            self.next_round.append(model)
+
+        else:
+            if len(self.current_round) == 0:
+                # if we are at the end of a round of hyperband, continue training only the best
+                logger.info("Starting a new round: continuing to train the best arches")
+                cutoff = math.ceil(self.round_sizes[round][self.round_number] * self.top_n_percent)
+                self.current_round = sorted(self.next_round, key=lambda x: -x.accuracy)[:cutoff]
+                self.current_round_ = sorted(self.next_round, key=lambda x: -x.accuracy)[cutoff:]
+                self.round_number += 1
+                self.round_number = min(self.round_number, len(self.fidelities[round]) - 1)
+                while len(self.current_round_) > 0:
+                    self.kde_models[self.fidelities[round][self.round_number]]['bad'].append(self.current_round_.pop())
+                self.next_round = []
+            # train the next architecture
+            model = self.current_round.pop()
+            """
+            Note: technically we would just continue training this arch, but right now,
+            just for simplicity, we treat it as if we start to train it again from scratch
+            """
+            model = copy.deepcopy(model)
+            model.epoch = min(self.fidelities[round][self.round_number], self.max_training_epoch)
+            model.accuracy = model.arch.query(self.performance_metric,
+                                              self.dataset,
+                                              epoch=model.epoch,
+                                              dataset_api=self.dataset_api)
+            self.kde_models[self.fidelities[round][self.round_number]]['good'].append(model)
+            self._update_history(model)
+            self.next_round.append(model)
+
+    def _update_history(self, child):
+        self.history.append(child)
+
+    def clean_history(self):
+        best_arch = max(self.history, key=lambda x: x.accuracy)
+        self.history = torch.nn.ModuleList()
+        self.history.append(best_arch)
+
+    def get_final_architecture(self):
+
+        # Returns the sampled architecture with the lowest validation error.
+        best_arch = max(self.history, key=lambda x: x.accuracy)
+        return best_arch.arch, best_arch.epoch
+
+    def get_latest_architecture(self):
+
+        # Returns the architecture from the most recent epoch
+        latest_arch = self.history[-1]
+        return latest_arch.arch, latest_arch.epoch
+
+    def train_statistics(self):
+        best_arch, best_arch_epoch = self.get_final_architecture()
+        latest_arch, latest_arch_epoch = self.get_latest_architecture()
+        train_time = latest_arch.query(Metric.TRAIN_TIME, self.dataset, dataset_api=self.dataset_api,
+                                       epoch=latest_arch_epoch)
+        previous_train_time = latest_arch.query(Metric.TRAIN_TIME, self.dataset, dataset_api=self.dataset_api,
+                                                epoch=self.fidelities[self.prev_round][
+                                                    self.round_number - 1]) if self.round_number > 0 else 0
+        train_time = train_time - previous_train_time
+        return (
+            best_arch.query(Metric.TRAIN_ACCURACY, self.dataset, dataset_api=self.dataset_api,
+                            epoch=best_arch_epoch - 1),
+            best_arch.query(Metric.VAL_ACCURACY, self.dataset, dataset_api=self.dataset_api, epoch=best_arch_epoch),
+            best_arch.query(Metric.TEST_ACCURACY, self.dataset, dataset_api=self.dataset_api, epoch=best_arch_epoch),
+            train_time,
+        )
+
+    def test_statistics(self):
+        best_arch, epoch = self.get_final_architecture()
+        return best_arch.query(Metric.RAW, self.dataset, dataset_api=self.dataset_api, epoch=epoch)
+
+    def get_op_optimizer(self):
+        raise NotImplementedError()
+
+    def get_checkpointables(self):
+        return {'model': self.history}
+
+    def get_model_size(self):
+        return count_parameters_in_MB(self.history)
diff --git a/naslib/optimizers/discrete/dehb/__init__.py b/naslib/optimizers/discrete/dehb/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/naslib/optimizers/discrete/dehb/optimizer.py b/naslib/optimizers/discrete/dehb/optimizer.py
new file mode 100644
index 000000000..62b4c8812
--- /dev/null
+++ b/naslib/optimizers/discrete/dehb/optimizer.py
@@ -0,0 +1,220 @@
+import collections
+import copy
+import logging
+import math
+import numpy as np
+import torch
+
+from naslib.optimizers.core.metaclasses import MetaOptimizer
+from naslib.search_spaces.core.query_metrics import Metric
+from naslib.utils.logging import log_every_n_seconds
+from naslib.utils.utils import AttrDict, count_parameters_in_MB
+
+logger = logging.getLogger(__name__)
+
+
+class DEHB(MetaOptimizer):
+    """
+    This implementation is mainly based on https://github.com/automl/nas-bench-x11. 
+    Awad, Noor, et al. 
+    DEHB: Evolutionary Hyperband for Scalable, Robust and Efficient Hyperparameter Optimization. 
+    arXiv:2105.09821, arXiv, 21st October 2021. 
+    arXiv.org, http://arxiv.org/abs/2105.09821.
+    """
+    # training the models is not implemented
+    using_step_function = False
+
+    def __init__(self, config):
+        super().__init__()
+        # Hyperband related stuff
+        self.config = config
+        self.rounds = []
+        self.round_sizes = []
+        self.fidelities = []
+        self._epsilon = float(self.config.search.epsilon)
+        self.min_budget = self.config.search.min_budget
+        self.max_budget = self.config.search.max_budget
+        self.eta = self.config.search.eta
+        self.enc_dim = self.config.search.enc_dim
+        self.max_mutations = self.config.search.max_mutations
+        self.crossover_prob = self.config.search.crossover_prob
+        self.top_n_percent = self.config.search.top_n_percent
+        self.mutate_prob = self.config.search.mutate_prob
+        self.de = dict()
+        self.pop_size = {}
+        self.counter = 0
+        self.min_budget = min(self.min_budget, self.max_budget)
+        s_max = math.floor(math.log(self.max_budget / self.min_budget, self.eta) + self._epsilon)
+        # set up round sizes, fidelities, and list of arches
+        for s in reversed(range(s_max + 1)):
+            self.rounds.append(s)
+            round_sizes = []
+            fidelities = []
+            n = math.ceil((s_max + 1) * self.eta ** s / (s + 1) - self._epsilon)  # initial number of configurations
+            r = self.max_budget / self.eta ** s  # initial number of iterations to run configurations for
+            for i in range(s + 1):
+                n_i = math.floor(n / self.eta ** i + self._epsilon)
+                r_i = min(math.floor(r * self.eta ** i + self._epsilon), config.search.fidelity)
+                round_sizes.append(n_i)
+                fidelities.append(r_i)
+                self.pop_size[r_i] = self.pop_size.get(r_i, 0) + n_i
+            self.round_sizes.append(round_sizes)
+            self.fidelities.append(fidelities)
+        for budget in self.fidelities[0][1:]:
+            budget = min(budget, config.search.fidelity)
+            self.de[budget] = {}
+            self.de[budget]['promotions'] = collections.deque(maxlen=100)
+
+        self.performance_metric = Metric.VAL_ACCURACY
+        self.dataset = config.dataset
+        self.history = torch.nn.ModuleList()
+
+        self.epochs = self.compute_epochs()
+        self.current_round = []
+        self.next_round = []
+        self.round_number = 0
+        self.prev_round = 0
+        self.counter = 0
+        self.process = 0
+
+    def adapt_search_space(self, search_space, scope=None, dataset_api=None):
+        assert search_space.QUERYABLE, "Hyperband_simple is currently only implemented for benchmarks."
+        self.search_space = search_space.clone()
+        self.scope = scope if scope else search_space.OPTIMIZER_SCOPE
+        self.dataset_api = dataset_api
+        self.max_training_epoch = self.search_space.get_max_epochs()
+
+    def compute_epochs(self):
+        return self.round_sizes, self.rounds[::-1]
+
+    def new_epoch(self, epoch, round, i):
+        if self.process < i:  # re-init for each new process
+            # to save ram for experiements
+            del self.current_round
+            del self.next_round
+            del self.round_number
+            del self.prev_round
+            del self.process
+            self.current_round = []
+            self.next_round = []
+            self.round_number = 0
+            self.prev_round = 0
+            self.counter = 0
+            self.process = i
+            self.clean_history()
+
+        if self.prev_round < round:  # reset round_number for each new round
+            self.prev_round = round
+            self.round_number = 0
+
+        if epoch < self.round_sizes[round][0]:
+            # sample random architectures
+            model = torch.nn.Module()  # hacky way to get arch and accuracy checkpointable
+            model.arch = self.search_space.clone()
+            budget = self.fidelities[round][0]
+            if round == 0:
+                model.arch.sample_random_architecture(dataset_api=self.dataset_api)
+            else:
+                if len(self.de[budget]['promotions']) > 0:
+                    logger.info('promotion from budget: {}, length: {}'.format(budget, len(self.de[budget]['promotions'])))
+                    model = self.de[budget]['promotions'].pop()
+                    model = copy.deepcopy(model)
+                    arch = self.search_space.clone()
+                    arch.mutate(model.arch, dataset_api=self.dataset_api)
+                    model.arch = arch
+                else:
+                    model.arch.sample_random_architecture(dataset_api=self.dataset_api)
+
+            model.epoch = min(self.fidelities[round][0], self.max_training_epoch)
+            model.accuracy = model.arch.query(self.performance_metric,
+                                              self.dataset,
+                                              epoch=model.epoch,
+                                              dataset_api=self.dataset_api)
+
+            self._update_history(model)
+            self.next_round.append(model)
+
+        else:
+            if len(self.current_round) == 0:
+                # if we are at the end of a round of hyperband, continue training only the best
+                logger.info("Starting a new round: continuing to train the best arches")
+                self.counter = 0
+                cutoff = math.ceil(self.round_sizes[round][self.round_number] * self.top_n_percent)
+                self.current_round = sorted(self.next_round, key=lambda x: -x.accuracy)[:cutoff]
+                self.round_number += 1
+                self.round_number = min(self.round_number, len(self.fidelities[round]) - 1)
+                self.next_round = []
+
+            # train the next architecture
+            model = self.current_round.pop()
+            self.counter += 1
+            """
+            Note: technically we would just continue training this arch, but right now,
+            just for simplicity, we treat it as if we start to train it again from scratch
+            """
+            model = copy.deepcopy(model)
+
+            if np.random.rand(1) < self.mutate_prob:
+                candidate = model.arch.clone()
+                for _ in range(self.max_mutations):
+                    arch_ = self.search_space.clone()
+                    arch_.mutate(candidate, dataset_api=self.dataset_api)
+                    candidate = arch_
+                mutant = candidate
+                arch = self.search_space.clone()
+                arch.crossover_bin(model.arch, mutant, self.enc_dim, self.crossover_prob, dataset_api=self.dataset_api)
+                model.arch = arch
+            model.epoch = min(self.fidelities[round][self.round_number], self.max_training_epoch)
+            model.accuracy = model.arch.query(self.performance_metric,
+                                              self.dataset,
+                                              epoch=model.epoch,
+                                              dataset_api=self.dataset_api)
+            self.de[self.fidelities[round][self.round_number]]['promotions'].append(model)
+            self._update_history(model)
+            self.next_round.append(model)
+
+    def _update_history(self, child):
+        self.history.append(child)
+
+    def clean_history(self):
+        best_arch = max(self.history, key=lambda x: x.accuracy)
+        self.history = torch.nn.ModuleList()
+        self.history.append(best_arch)
+
+    def get_final_architecture(self):
+
+        # Returns the sampled architecture with the lowest validation error.
+        best_arch = max(self.history, key=lambda x: x.accuracy)
+        return best_arch.arch, best_arch.epoch
+
+    def get_latest_architecture(self):
+
+        # Returns the architecture from the most recent epoch
+        latest_arch = self.history[-1]
+        return latest_arch.arch, latest_arch.epoch
+
+    def train_statistics(self):
+        best_arch, best_arch_epoch = self.get_final_architecture()
+        latest_arch, latest_arch_epoch = self.get_latest_architecture()
+        train_time = latest_arch.query(Metric.TRAIN_TIME, self.dataset, dataset_api=self.dataset_api,
+                                       epoch=latest_arch_epoch)
+        return (
+            best_arch.query(Metric.TRAIN_ACCURACY, self.dataset, dataset_api=self.dataset_api,
+                            epoch=best_arch_epoch - 1),
+            best_arch.query(Metric.VAL_ACCURACY, self.dataset, dataset_api=self.dataset_api, epoch=best_arch_epoch),
+            best_arch.query(Metric.TEST_ACCURACY, self.dataset, dataset_api=self.dataset_api, epoch=best_arch_epoch),
+            train_time,
+        )
+
+    def test_statistics(self):
+        best_arch, epoch = self.get_final_architecture()
+        return best_arch.query(Metric.RAW, self.dataset, dataset_api=self.dataset_api, epoch=epoch)
+
+    def get_op_optimizer(self):
+        raise NotImplementedError()
+
+    def get_checkpointables(self):
+        return {'model': self.history}
+
+    def get_model_size(self):
+        return count_parameters_in_MB(self.history)
diff --git a/naslib/optimizers/discrete/hb/__init__.py b/naslib/optimizers/discrete/hb/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/naslib/optimizers/discrete/hb/optimizer.py b/naslib/optimizers/discrete/hb/optimizer.py
new file mode 100644
index 000000000..4483b9573
--- /dev/null
+++ b/naslib/optimizers/discrete/hb/optimizer.py
@@ -0,0 +1,182 @@
+import collections
+import copy
+import logging
+import math
+import numpy as np
+import torch
+
+from naslib.optimizers.core.metaclasses import MetaOptimizer
+from naslib.search_spaces.core.query_metrics import Metric
+from naslib.utils.logging import log_every_n_seconds
+from naslib.utils.utils import AttrDict, count_parameters_in_MB
+
+logger = logging.getLogger(__name__)
+
+
+class HB(MetaOptimizer):
+    """
+    This implementation is mainly based on https://github.com/automl/nas-bench-x11. 
+    
+    Li, Lisha, et al. 
+    Hyperband: A Novel Bandit-Based Approach to Hyperparameter Optimization. 
+    arXiv:1603.06560, arXiv, 18th June 2018. 
+    arXiv.org, http://arxiv.org/abs/1603.06560.
+    """
+    # training the models is not implemented
+    using_step_function = False
+
+    def __init__(self, config):
+        super().__init__()
+        # Hyperband related stuff
+        self.config = config
+        self.rounds = []
+        self.round_sizes = []
+        self.fidelities = []
+        self.max_budget = self.config.search.max_budget
+        self.min_budget = self.config.search.min_budget
+        self.eta = self.config.search.eta
+        self._epsilon = float(self.config.search.epsilon)
+        self.min_budget = min(self.min_budget, self.max_budget)
+        s_max = math.floor(math.log(self.max_budget / self.min_budget, self.eta) + self._epsilon)
+        # set up round sizes, fidelities, and list of arches
+        for s in reversed(range(s_max + 1)):
+            self.rounds.append(s)
+            round_sizes = []
+            fidelities = []
+            n = math.ceil((s_max + 1) * self.eta ** s / (s + 1) - self._epsilon)  # initial number of configurations
+            r = self.max_budget / self.eta ** s  # initial number of iterations to run configurations for
+            for i in range(s + 1):
+                n_i = math.floor(n / self.eta ** i + self._epsilon)
+                r_i = min(math.floor(r * self.eta ** i + self._epsilon), config.search.fidelity)
+                round_sizes.append(n_i)
+                fidelities.append(r_i)
+            self.round_sizes.append(round_sizes)
+            self.fidelities.append(fidelities)
+
+        self.performance_metric = Metric.VAL_ACCURACY
+        self.dataset = config.dataset
+        self.history = torch.nn.ModuleList()
+
+        self.epochs = self.compute_epochs()
+        self.current_round = []
+        self.next_round = []
+        self.round_number = 0
+        self.prev_round = 0
+        self.process = 0
+
+    def adapt_search_space(self, search_space, scope=None, dataset_api=None):
+        assert search_space.QUERYABLE, "Hyperband_simple is currently only implemented for benchmarks."
+        self.search_space = search_space.clone()
+        self.scope = scope if scope else search_space.OPTIMIZER_SCOPE
+        self.dataset_api = dataset_api
+        self.max_training_epoch = self.search_space.get_max_epochs()
+
+    def compute_epochs(self):
+        return self.round_sizes, self.rounds[::-1]
+
+    def new_epoch(self, epoch, round, i):
+        # round - bracket
+        # epoch - number of architectures in bracket so far
+        if self.process < i:  # re-init for each new process
+            del self.current_round
+            del self.next_round
+            del self.round_number
+            del self.prev_round
+            del self.process
+            self.current_round = []
+            self.next_round = []
+            self.round_number = 0  # index to fidelity
+            self.prev_round = 0
+            self.process = i
+            self.clean_history()
+
+        if self.prev_round < round:  # reset round_number for each new round # check if new bracket
+            self.prev_round = round
+            self.round_number = 0
+
+        if epoch < self.round_sizes[round][0]:  # check if first fidelity of bracket
+            # sample random architectures
+            model = torch.nn.Module()  # hacky way to get arch and accuracy checkpointable
+            model.arch = self.search_space.clone()
+            model.arch.sample_random_architecture(dataset_api=self.dataset_api)
+            model.epoch = self.fidelities[round][0]
+            model.accuracy = model.arch.query(self.performance_metric,
+                                              self.dataset,
+                                              epoch=model.epoch,
+                                              dataset_api=self.dataset_api)
+            self._update_history(model)
+            self.next_round.append(model)
+
+        else:
+            if len(self.current_round) == 0:  # fidelity is full
+                # if we are at the end of a round of hyperband, continue training only the best
+                logger.info("Starting a new round: continuing to train the best arches")
+                self.round_number += 1
+                cutoff = self.round_sizes[round][self.round_number]
+                self.current_round = sorted(self.next_round, key=lambda x: -x.accuracy)[:cutoff]
+                self.next_round = []
+
+            # train the next architecture
+            model = self.current_round.pop()  # architecture to train
+            """
+            Note: technically we would just continue training this arch, but right now,
+            just for simplicity, we treat it as if we start to train it again from scratch
+            """
+            model = copy.deepcopy(model)
+            model.epoch = self.fidelities[round][self.round_number]
+            model.accuracy = model.arch.query(self.performance_metric,
+                                              self.dataset,
+                                              epoch=model.epoch,
+                                              dataset_api=self.dataset_api)
+            self._update_history(model)
+            self.next_round.append(model)
+
+    def _update_history(self, child):
+        self.history.append(child)
+
+    def clean_history(self):
+        best_arch = max(self.history, key=lambda x: x.accuracy)
+        self.history = torch.nn.ModuleList()
+        self.history.append(best_arch)
+
+    def get_final_architecture(self):
+
+        # Returns the sampled architecture with the lowest validation error.
+        best_arch = max(self.history, key=lambda x: x.accuracy)
+        return best_arch.arch, best_arch.epoch
+
+    def get_latest_architecture(self):
+
+        # Returns the architecture from the most recent epoch
+        latest_arch = self.history[-1]
+        return latest_arch.arch, latest_arch.epoch
+
+    def train_statistics(self):
+        best_arch, best_arch_epoch = self.get_final_architecture()
+        latest_arch, latest_arch_epoch = self.get_latest_architecture()
+        train_time = latest_arch.query(Metric.TRAIN_TIME, self.dataset, dataset_api=self.dataset_api,
+                                       epoch=latest_arch_epoch)
+        previous_train_time = latest_arch.query(Metric.TRAIN_TIME, self.dataset, dataset_api=self.dataset_api,
+                                                epoch=self.fidelities[self.prev_round][
+                                                    self.round_number - 1]) if self.round_number > 0 else 0
+        train_time = train_time - previous_train_time
+        return (
+            best_arch.query(Metric.TRAIN_ACCURACY, self.dataset, dataset_api=self.dataset_api,
+                            epoch=best_arch_epoch - 1),
+            best_arch.query(Metric.VAL_ACCURACY, self.dataset, dataset_api=self.dataset_api, epoch=best_arch_epoch),
+            best_arch.query(Metric.TEST_ACCURACY, self.dataset, dataset_api=self.dataset_api, epoch=best_arch_epoch),
+            train_time,
+        )
+
+    def test_statistics(self):
+        best_arch, epoch = self.get_final_architecture()
+        return best_arch.query(Metric.RAW, self.dataset, dataset_api=self.dataset_api, epoch=epoch)
+
+    def get_op_optimizer(self):
+        raise NotImplementedError()
+
+    def get_checkpointables(self):
+        return {'model': self.history}
+
+    def get_model_size(self):
+        return count_parameters_in_MB(self.history)
diff --git a/naslib/optimizers/discrete/sh/__init__.py b/naslib/optimizers/discrete/sh/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/naslib/optimizers/discrete/sh/optimizer.py b/naslib/optimizers/discrete/sh/optimizer.py
new file mode 100644
index 000000000..2cfa2614c
--- /dev/null
+++ b/naslib/optimizers/discrete/sh/optimizer.py
@@ -0,0 +1,168 @@
+import logging
+import math
+import torch
+import copy
+
+from naslib.optimizers.core.metaclasses import MetaOptimizer
+
+from naslib.search_spaces.core.query_metrics import Metric
+
+from naslib.utils.utils import count_parameters_in_MB
+
+logger = logging.getLogger(__name__)
+
+
+class SuccessiveHalving(MetaOptimizer):
+    # training the models is not implemented
+    using_step_function = False
+
+    def __init__(self, config):
+        super().__init__()
+        # Hyperband related stuff
+        self.config = config
+        self.round_sizes = []
+        self.fidelities = []
+        self.max_budget = self.config.search.max_budget
+        self.min_budget = self.config.search.min_budget
+        self.eta = self.config.search.eta
+        self._epsilon = float(self.config.search.epsilon)
+        self.min_budget = min(self.min_budget, self.max_budget)
+        times_of_split = math.floor(math.log(self.max_budget / self.min_budget, self.eta) + self._epsilon)
+        # set up round sizes, fidelities, and list of arches
+
+        n = math.ceil((times_of_split + 1) * self.eta ** times_of_split / (
+                    times_of_split + 1) + self._epsilon)  # initial number of configurations
+        r = int(self.max_budget / self.eta ** times_of_split)  # initial number of iterations to run configurations for
+        for _ in range(times_of_split + 1):
+            self.round_sizes.append(n)
+            self.fidelities.append(r)
+            # n= 2*3 ** 1/2  for i in range(s + 1):
+            n = math.floor(n / self.eta)
+            # TODO: maybe this can be replaced by search space get_max_epoch()
+            r = min(math.floor(r * self.eta), config.search.fidelity)
+
+        self.performance_metric = Metric.VAL_ACCURACY
+        self.dataset = config.dataset
+        self.history = torch.nn.ModuleList()
+
+        self.epochs = self.compute_epochs()
+        self.current_round = []
+        self.next_round = []
+        self.round_number = 0
+        self.prev_round = 0
+        self.process = 0
+
+    def adapt_search_space(self, search_space, scope=None, dataset_api=None):
+        assert search_space.QUERYABLE, "Hyperband_simple is currently only implemented for benchmarks."
+        self.search_space = search_space.clone()
+        self.scope = scope if scope else search_space.OPTIMIZER_SCOPE
+        self.dataset_api = dataset_api
+        self.max_training_epoch = self.search_space.get_max_epochs()
+
+    def compute_epochs(self):
+        return [self.round_sizes], [0]
+
+    def new_epoch(self, epoch, round, i):
+
+        if self.process < i:  # re-init for each new process
+            del self.current_round
+            del self.next_round
+            del self.round_number
+            del self.prev_round
+            del self.process
+            self.clean_history()
+            self.current_round = []
+            self.next_round = []
+            self.round_number = 0
+            self.prev_round = 0
+            self.process = i
+
+        if epoch < self.round_sizes[self.round_number]:
+            # sample random architectures
+            model = torch.nn.Module()  # hacky way to get arch and accuracy checkpointable
+            model.arch = self.search_space.clone()
+            model.arch.sample_random_architecture(dataset_api=self.dataset_api)
+            model.epoch = self.fidelities[self.round_number]
+            model.accuracy = model.arch.query(self.performance_metric,
+                                              self.dataset,
+                                              epoch=model.epoch,
+                                              dataset_api=self.dataset_api)
+
+            self._update_history(model)
+            self.next_round.append(model)
+
+        else:
+            if len(self.current_round) == 0:
+                # if we are at the end of a round of hyperband, continue training only the best
+                logger.info("Starting a new round: continuing to train the best arches")
+                self.round_number += 1
+                cutoff = self.round_sizes[self.round_number]
+                self.current_round = sorted(self.next_round, key=lambda x: -x.accuracy)[:cutoff]
+                del self.next_round
+                self.next_round = []
+
+            # train the next architecture
+            model = self.current_round.pop()
+            """
+            Note: technically we would just continue training this arch, but right now,
+            just for simplicity, we treat it as if we start to train it again from scratch
+            """
+            model = copy.deepcopy(model)
+            model.epoch = self.fidelities[self.round_number]
+            model.accuracy = model.arch.query(self.performance_metric,
+                                              self.dataset,
+                                              epoch=model.epoch,
+                                              dataset_api=self.dataset_api)
+            self._update_history(model)
+            self.next_round.append(model)
+        logger.info("fidelity: {}".format(self.fidelities[self.round_number]))
+
+    def _update_history(self, child):
+        self.history.append(child)
+
+    def clean_history(self):
+        best_arch = max(self.history, key=lambda x: x.accuracy)
+        self.history = torch.nn.ModuleList()
+        self.history.append(best_arch)
+
+    def get_final_architecture(self):
+
+        # Returns the sampled architecture with the lowest validation error.
+        best_arch = max(self.history, key=lambda x: x.accuracy)
+        return best_arch.arch, best_arch.epoch
+
+    def get_latest_architecture(self):
+
+        # Returns the architecture from the most recent epoch
+        latest_arch = self.history[-1]
+        return latest_arch.arch, latest_arch.epoch
+
+    def train_statistics(self):
+        best_arch, best_arch_epoch = self.get_final_architecture()
+        latest_arch, latest_arch_epoch = self.get_latest_architecture()
+        train_time = latest_arch.query(Metric.TRAIN_TIME, self.dataset, dataset_api=self.dataset_api,
+                                       epoch=latest_arch_epoch)
+        previous_train_time = latest_arch.query(Metric.TRAIN_TIME, self.dataset, dataset_api=self.dataset_api,
+                                                epoch=self.fidelities[
+                                                    self.round_number - 1]) if self.round_number > 0 else 0
+        train_time = train_time - previous_train_time
+        return (
+            best_arch.query(Metric.TRAIN_ACCURACY, self.dataset, dataset_api=self.dataset_api,
+                            epoch=best_arch_epoch - 1),
+            best_arch.query(Metric.VAL_ACCURACY, self.dataset, dataset_api=self.dataset_api, epoch=best_arch_epoch),
+            best_arch.query(Metric.TEST_ACCURACY, self.dataset, dataset_api=self.dataset_api, epoch=best_arch_epoch),
+            train_time,
+        )
+
+    def test_statistics(self):
+        best_arch, epoch = self.get_final_architecture()
+        return best_arch.query(Metric.RAW, self.dataset, dataset_api=self.dataset_api, epoch=epoch)
+
+    def get_op_optimizer(self):
+        raise NotImplementedError()
+
+    def get_checkpointables(self):
+        return {'model': self.history}
+
+    def get_model_size(self):
+        return count_parameters_in_MB(self.history)
diff --git a/naslib/predictors/ensemble.py b/naslib/predictors/ensemble.py
index 99a70355d..77aec30be 100644
--- a/naslib/predictors/ensemble.py
+++ b/naslib/predictors/ensemble.py
@@ -1,6 +1,8 @@
 import numpy as np
 import copy
 
+from torch._C import TracingState
+
 from naslib.predictors.predictor import Predictor
 from naslib.predictors.mlp import MLPPredictor
 from naslib.predictors.trees import LGBoost, XGBoost, NGBoost, RandomForestPredictor
@@ -27,6 +29,7 @@ def __init__(
         ss_type=None,
         hpo_wrapper=True,
         config=None,
+        hyperparams = None,
     ):
         self.num_ensemble = num_ensemble
         self.predictor_type = predictor_type
@@ -34,8 +37,9 @@ def __init__(
         self.ss_type = ss_type
         self.hpo_wrapper = hpo_wrapper
         self.config = config
-        self.hyperparams = None
+        self.hyperparams = hyperparams
         self.ensemble = None
+        
 
     def get_ensemble(self):
         # TODO: if encoding_type is not None, set the encoding type
@@ -104,12 +108,16 @@ def get_ensemble(self):
                 zero_cost=["jacov"],
                 lce=[],
                 encoding_type="seminas",
-                ss_type=self.ss_type,
-                run_pre_compute=False,
-                semi=True,
-                max_zerocost=1000,
-                config=self.config,
-            ),
+                 ss_type=self.ss_type,
+                 run_pre_compute=False,
+                 semi=True,
+                 max_zerocost=1000,
+                 config=self.config,
+             ),
+            
+
+            
+
         }
 
         return [
@@ -139,9 +147,8 @@ def fit(self, xtrain, ytrain, train_info=None):
     def query(self, xtest, info=None):
         predictions = []
         for i in range(self.num_ensemble):
-            prediction = self.ensemble[i].query(xtest, info)
+            prediction = self.ensemble[i].query(xtest, info) #added info dict
             predictions.append(prediction)
-
         return np.array(predictions)
 
     def set_hyperparams(self, params):
diff --git a/naslib/predictors/utils/encodings.py b/naslib/predictors/utils/encodings.py
index d90d26242..00f4e7f6f 100644
--- a/naslib/predictors/utils/encodings.py
+++ b/naslib/predictors/utils/encodings.py
@@ -215,7 +215,7 @@ def encode_gcn_transbench101(arch):
 def encode_bonas_nasbench201(arch):
     """
     Input:
-    a list of categorical ops starting from 0
+    a list of categorical ops startfroming  0
     """
     ops = arch.get_op_indices()
     # offset ops list by one, add input and output to ops list
diff --git a/naslib/search_spaces/nasbench201/graph.py b/naslib/search_spaces/nasbench201/graph.py
index 1c7b517ed..3713bbe00 100644
--- a/naslib/search_spaces/nasbench201/graph.py
+++ b/naslib/search_spaces/nasbench201/graph.py
@@ -188,8 +188,7 @@ def query(
             # return hyperparameter info
             return query_results[dataset]["cost_info"]
         elif metric == Metric.TRAIN_TIME:
-            return query_results[dataset]["cost_info"]["train_time"]
-
+            return query_results[dataset]['cost_info']['train_time'] * epoch
         if full_lc and epoch == -1:
             return query_results[dataset][metric_to_nb201[metric]]
         elif full_lc and epoch != -1:
@@ -198,6 +197,41 @@ def query(
             # return the value of the metric only at the specified epoch
             return query_results[dataset][metric_to_nb201[metric]][epoch]
 
+    def model_based_sample_architecture(self, dataset_api=None, minimize_me=None, good_kde=None, vartypes=None):
+        """
+        This will perform a model-based architecture sampling and update the edges in the
+        naslib object accordingly.
+        """
+        num_samples = 128
+        random_fraction = 0.33
+        best = np.inf
+        best_vector = None
+        for i in range(num_samples):
+            idx = np.random.randint(0, len(good_kde.data))
+            datum = good_kde.data[idx]
+            vector = []
+            for m, bw, t in zip(datum, good_kde.bw, vartypes):
+                if np.random.rand() < (1 - bw):
+                    vector.append(int(m))
+                else:
+                    vector.append(np.random.randint(t))
+            val = minimize_me(vector)
+            if val < best:
+                best = val
+                best_vector = vector
+        if best_vector is None or np.random.rand() < random_fraction:
+            self.sample_random_architecture(dataset_api=dataset_api)
+        else:
+            for i in range(len(best_vector)):
+                best_vector[i] = int(np.rint(best_vector[i]))
+            self.set_op_indices(best_vector)
+
+
+
+    def get_max_epochs(self):
+        # Return the max number of epochs that can be queried
+        return 199
+
     def get_op_indices(self):
         if self.op_indices is None:
             self.op_indices = convert_naslib_to_op_indices(self)
@@ -227,6 +261,19 @@ def sample_random_architecture(self, dataset_api=None):
         op_indices = np.random.randint(5, size=(6))
         self.set_op_indices(op_indices)
 
+
+    def crossover_bin(self, parent, mutant, dim, prob, dataset_api=None):
+        '''Performs the binomial crossover of DE
+        '''
+        target_indices = np.array(convert_naslib_to_op_indices(parent))
+        mutant_indices = np.array(convert_naslib_to_op_indices(mutant))
+        cross_points = np.random.rand(dim) < prob
+        if not np.any(cross_points):  #at leat one gen is a crosspoint
+            cross_points[np.random.randint(0, dim)] = True
+
+        offspring = np.where(cross_points, mutant_indices, target_indices)
+        self.set_op_indices(offspring)
+
     def mutate(self, parent, dataset_api=None):
         """
         This will mutate one op from the parent op indices, and then
@@ -241,6 +288,10 @@ def mutate(self, parent, dataset_api=None):
         op_indices[edge] = op_index
         self.set_op_indices(op_indices)
 
+
+
+
+
     def get_nbhd(self, dataset_api=None):
         # return all neighbors of the architecture
         self.get_op_indices()
diff --git a/naslib/search_spaces/nasbenchasr/graph.py b/naslib/search_spaces/nasbenchasr/graph.py
index 108e4cc2e..b383230ce 100644
--- a/naslib/search_spaces/nasbenchasr/graph.py
+++ b/naslib/search_spaces/nasbenchasr/graph.py
@@ -55,7 +55,8 @@ def query(self, metric=None, dataset=None, path=None, epoch=-1,
             Metric.TRAIN_TIME,
             Metric.RAW,
         ]
-        query_results = dataset_api["asr_data"].full_info(self.compact)
+        # seed has to be set manually, otherwise one would get different metric values for the same architecture!
+        query_results = dataset_api["asr_data"].full_info(self.compact, seed=1234)
 
 
         if metric != Metric.VAL_ACCURACY:
@@ -63,6 +64,11 @@ def query(self, metric=None, dataset=None, path=None, epoch=-1,
                 return query_results[metric_to_asr[metric]]
             elif (metric == Metric.PARAMETERS) or (metric == Metric.FLOPS):
                 return query_results['info'][metric_to_asr[metric]]
+            elif (metric == Metric.TRAIN_TIME):
+                if epoch == -1:
+                    return self.get_max_epochs() + 1
+                else:
+                    return 1 * epoch
             elif metric in [Metric.TRAIN_ACCURACY, Metric.TRAIN_LOSS,
                             Metric.TRAIN_TIME, Metric.RAW]:
                 return -1
@@ -99,6 +105,38 @@ def sample_random_architecture(self, dataset_api):
         compact = m
         self.set_compact(compact)
         return compact
+    def model_based_sample_architecture(self, dataset_api=None, minimize_me=None, good_kde=None, vartypes=None):
+        """
+        This will perform a model-based architecture sampling and update the edges in the
+        naslib object accordingly.
+        """
+        num_samples = 128
+        random_fraction = 0.33
+        best = np.inf
+        best_vector = None
+        for i in range(num_samples):
+            idx = np.random.randint(0, len(good_kde.data))
+            datum = good_kde.data[idx]
+            vector = []
+            for m, bw, t in zip(datum, good_kde.bw, vartypes):
+                if np.random.rand() < (1 - bw):
+                    vector.append(int(m))
+                else:
+                    vector.append(np.random.randint(t))
+            val = minimize_me(vector)
+            if val < best:
+                best = val
+                best_vector = vector
+        if best_vector is None or np.random.rand() < random_fraction:
+            self.sample_random_architecture(dataset_api=dataset_api)
+        else:
+            for i in range(len(best_vector)):
+                best_vector[i] = int(np.rint(best_vector[i]))
+            best_vector = [[best_vector[0],best_vector[1]],
+                           [best_vector[2],best_vector[3],best_vector[4]],
+                           [best_vector[5],best_vector[6], best_vector[7], best_vector[8]]]
+            self.set_compact(best_vector)
+
 
     def mutate(self, parent, mutation_rate=1, dataset_api=None):
         """
@@ -113,7 +151,7 @@ def mutate(self, parent, mutation_rate=1, dataset_api=None):
 
         for _ in range(int(mutation_rate)):
             mutation_type = np.random.choice([2])
-
+           
             if mutation_type == 1:
                 # change an edge
                 # first pick up a node
@@ -137,7 +175,29 @@ def mutate(self, parent, mutation_rate=1, dataset_api=None):
                 compact[node_id][0] = new_op_id
 
         self.set_compact(compact)
+    def crossover_bin(self, parent, mutant, dim, prob, dataset_api=None):
+        '''Performs the binomial crossover of DE
+           this write now only for the things that mutate 
+        '''
+        parent_compact = parent.get_compact()
+        compact = copy.deepcopy(parent_compact)
+        mutant_compact= mutant.get_compact()
+        cross_node = np.random.rand(3) < prob
+        cross_type = np.random.rand(2) < prob
+        for i,node in enumerate(cross_node):
+            if not node:
+                continue
+            if cross_type[0]:
+                cross_edges = np.random.rand(len(compact[i][1:])) 
+                for j,egde in enumerate(cross_edges):
+                    if not egde:
+                        continue
+                    compact[i][j+1] =  mutant_compact[i][j+1]
+            if cross_type[1]:
+                compact[i][0] = mutant_compact[i][0]
+        self.set_compact(compact)
 
+      
 
     def get_nbhd(self, dataset_api=None):
         """