Results_plotting.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "f862be9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import mbore\n",
    "import tqdm.notebook\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "4670f41f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "a930a57e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# set up the things we need to load all optimisation runs\n",
    "problem_names = [\"DTLZ\", \"WFG\", \"RW\", \"WFG_HD\"]\n",
    "problem_names_to_paper = {\n",
    "    \"DTLZ\": \"DTLZ\",\n",
    "    \"WFG\": \"WFG\",\n",
    "    \"RW\": \"Real-world\",\n",
    "    \"WFG_HD\": \"WFG (High-dimensional)\"\n",
    "}\n",
    "\n",
    "final_results_dir = \"final_results\"\n",
    "\n",
    "# note that these are the names used to run the code (not in the paper)\n",
    "models = [\"XGB\", \"FCNet\", \"GP\"]\n",
    "\n",
    "scalarizers = [\n",
    "    \"HypI\",\n",
    "    \"DomRank\",\n",
    "    \"HypCont\", # known as 'PHC' in the paper\n",
    "    \"ParEGO\", # known as 'AT' in the paper\n",
    "]\n",
    "\n",
    "# settings that we used for all problems\n",
    "budget = 300\n",
    "n_runs = 21\n",
    "\n",
    "# mappings to ensure consistent labels across plots\n",
    "model_to_paper = {\"XGB\": \"XGB\", \"FCNet\": \"MLP\", \"GP\": \"GP\"}\n",
    "\n",
    "scalar_to_paper = {\n",
    "    \"HypI\": \"HYPI\",\n",
    "    \"DomRank\": \"DOMRANK\",\n",
    "    \"HypCont\": \"PHC\",\n",
    "    \"ParEGO\": \"AT\",\n",
    "}\n",
    "\n",
    "# colours and linestyles\n",
    "model_colors = {\n",
    "    \"XGB\": \"#e66101\", # orange\n",
    "    \"FCNet\": \"#5e3c99\", # purple\n",
    "    \"GP\": \"#b2abd2\", # light purple\n",
    "}\n",
    "\n",
    "scalar_to_ls = {\n",
    "    \"HypI\": \"-.\", \n",
    "    \"DomRank\": \"--\", \n",
    "    \"HypCont\": \"-\",\n",
    "    \"ParEGO\": \":\"\n",
    "}\n",
    "\n",
    "scalar_conv_to_paper = {\n",
    "    \"HypI\": \"HYPI\",\n",
    "    \"DomRank\": \"DR\",\n",
    "    \"HypCont\": \"PHC\",\n",
    "    \"ParEGO\": \"AT\",\n",
    "}\n",
    "\n",
    "def plot_settings(ncols=1, nrows=1, fontsizebase=11, usetex=True):\n",
    "    from tueplots import  axes, fontsizes\n",
    "\n",
    "    base_width = 3.25\n",
    "    base_height = 2.0\n",
    "\n",
    "    settings = {\n",
    "        'text.usetex': usetex, # needs to be turned on for final paper!\n",
    "        'font.family': 'serif',\n",
    "        'text.latex.preamble': ''.join([\n",
    "            r\"\\usepackage{libertine}\",\n",
    "            r\"\\usepackage[libertine]{newtxmath}\",\n",
    "        ]),\n",
    "        # 'font.serif': ['Linux Libertine'],\n",
    "        # 'font.family': 'serif',\n",
    "        # 'mathtext.fontset': 'custom',\n",
    "        # 'mathtext.rm': 'Linux Libertine',\n",
    "        # 'mathtext.it': 'Linux Libertine:italic',\n",
    "        # 'mathtext.bf': 'Linux Libertine:bold',\n",
    "        'pdf.fonttype': 42,\n",
    "        'ps.fonttype': 42,\n",
    "\n",
    "        'figure.constrained_layout.use': True,\n",
    "        'figure.autolayout': False,\n",
    "        \"hatch.linewidth\" : 0.5,\n",
    "        \"figure.figsize\": (base_width * ncols, base_height * nrows ),\n",
    "    }\n",
    "    settings.update(fontsizes._from_base(base=fontsizebase))\n",
    "    settings.update(axes.lines())\n",
    "\n",
    "    return settings\n",
    "\n",
    "def gs_compress(path):\n",
    "    import subprocess\n",
    "    import shutil\n",
    "    import os\n",
    "    \n",
    "    # copy file to temp\n",
    "    tempname = \"temp1.pdf\"\n",
    "    final_name = \"final.pdf\"\n",
    "    shutil.copyfile(path, tempname)\n",
    "    \n",
    "    cmd = [\n",
    "        r\"gswin64.exe\",\n",
    "        \"-sDEVICE=pdfwrite\",\n",
    "        \"-dSubsetFonts=true\",\n",
    "        \"-dPDFSETTINGS=/prepress\",\n",
    "        \"-dCompressFonts=true\",\n",
    "        \"-dNOPAUSE\",\n",
    "        \"-dBATCH\",\n",
    "        f'-sOutputFile={final_name}',\n",
    "        f'{tempname}'\n",
    "    ]\n",
    "\n",
    "    try:\n",
    "        subprocess.run(' '.join(cmd))\n",
    "\n",
    "        # rename final\n",
    "        shutil.move(final_name, path)\n",
    "        os.remove(tempname)\n",
    "    except:\n",
    "        print('Ghostscript not installed (or not on Windows), skipping pdf compression')\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "016f3a08",
   "metadata": {},
   "source": [
    "#### Plots showing which scalarisation is the best overall (for a given problem set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "919a23cd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4b91b34bca2b4a4093b5f3ead5878f17",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/4 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Problem set: DTLZ. 56 total problems\n",
      "Problem set: WFG. 63 total problems\n",
      "Problem set: RW. 10 total problems\n",
      "Problem set: WFG. 27 total problems\n"
     ]
    }
   ],
   "source": [
    "for original_problem_name in tqdm.notebook.tqdm(problem_names):\n",
    "\n",
    "    savename = f\"{original_problem_name:s}_statstests.npz\"\n",
    "    savepath = os.path.join(final_results_dir, savename)\n",
    "\n",
    "    with np.load(savepath, allow_pickle=True) as fd:\n",
    "        assert original_problem_name == fd[\"original_problem_name\"]\n",
    "        \n",
    "        # per-scalariser results\n",
    "        # td[indicator][scalarizer][problem_id][dim][fdim]\n",
    "        td = fd[\"td\"].item()\n",
    "\n",
    "        # results for each combo of (scalarizer, model)\n",
    "        # tds[indicator][problem_id][dim][fdim]\n",
    "        tds = fd[\"tds\"].item()\n",
    "\n",
    "    problem_name, prob_dict = mbore.problem_sets.get_problem_dict(\n",
    "        original_problem_name\n",
    "    )\n",
    "    total_problems = mbore.problem_sets.get_number_of_problems(prob_dict)\n",
    "    print(f\"Problem set: {problem_name:s}. {total_problems:d} total problems\")\n",
    "\n",
    "    # gather up the keys for this list\n",
    "    n_scalarizers_and_models = len(scalarizers) * len(models)\n",
    "\n",
    "    scalarizers_and_model_combos = [\n",
    "        (scalarizer, model)\n",
    "        for scalarizer in scalarizers\n",
    "        for model in models\n",
    "    ]\n",
    "\n",
    "    for indicator in [\"hv\", \"igd+\"]:\n",
    "        yv = []\n",
    "        labels = []\n",
    "        bar_colors = []\n",
    "\n",
    "        for i, (scalar, model) in enumerate(scalarizers_and_model_combos):\n",
    "            yv.append(i)\n",
    "\n",
    "            scal_print_name = scalar_to_paper[scalar]\n",
    "            m_print_name = model_to_paper[model]\n",
    "\n",
    "            labels.append(f\"{m_print_name:s} + {scal_print_name:s}\")\n",
    "            bar_colors.append(model_colors[model])\n",
    "\n",
    "        counts = np.zeros(len(scalarizers_and_model_combos))\n",
    "\n",
    "        for problem_id in prob_dict:\n",
    "            for dim, fdims in prob_dict[problem_id]:\n",
    "                for fdim in fdims:\n",
    "                    counts += tds[indicator][problem_id][dim][fdim][\"best_mask\"]\n",
    "\n",
    "        counts /= total_problems\n",
    "\n",
    "        #title = f\"Test problems: {problem_name}. Indicator: {indicator[:3]}\"\n",
    "        #title = \"Proportion of times each combination is best\"\n",
    "        title = f\"{indicator.upper():s}\"\n",
    "        title += f\" Performance Summary:\"\n",
    "        title += f\" {problem_names_to_paper[original_problem_name]}\"\n",
    "\n",
    "        xlabel = \"Scalarisation method\"\n",
    "\n",
    "        with plt.rc_context(plot_settings(ncols=1, nrows=0.65, fontsizebase=10)):\n",
    "\n",
    "            n = len(scalarizers)\n",
    "            m = len(models)\n",
    "            \n",
    "            width = 0.2\n",
    "\n",
    "            fig, ax = plt.subplots()\n",
    "\n",
    "            for i in range(n):\n",
    "                xv = np.array([-0.21, 0, 0.21]) + i\n",
    "                widths = counts[m * i: (i+1)*m]\n",
    "\n",
    "                ax.bar(\n",
    "                    x=xv, \n",
    "                    height=widths,\n",
    "                    width=width,\n",
    "                    color=[model_colors[m] for m in models]\n",
    "                )\n",
    "\n",
    "            # # show the split line to make the grounpings even *more* obvious\n",
    "            # for i in range(n-1):\n",
    "            #     ax.axvline(i + 0.5, c='k', alpha=0.2, ls='--')\n",
    "            \n",
    "            ax.set_xticks(np.arange(n))\n",
    "            ax.set_xticklabels(\n",
    "                [scalar_to_paper[s] for s in scalarizers], \n",
    "                rotation=0)\n",
    "            ax.set_ylim([0, 1])\n",
    "\n",
    "            # create legend\n",
    "            for m in models:\n",
    "                ax.plot(0, 0, label=model_to_paper[m], color=model_colors[m], lw=5)\n",
    "            \n",
    "            ax.legend(\n",
    "                loc=\"upper left\", \n",
    "                ncol=len(models),\n",
    "                handletextpad=0.5, # distance between colour and text\n",
    "                columnspacing=1, # spacing between columns (labels)\n",
    "                borderaxespad=0.05, # spacing from the edge of the plot\n",
    "                frameon=False,\n",
    "            )\n",
    "\n",
    "            ax.set_title(title)\n",
    "            # ax.set_xlabel(xlabel)\n",
    "            fname = f'{indicator:s}_{original_problem_name:s}_summary_barchart.pdf'\n",
    "            plt.savefig(fname)\n",
    "            plt.close()\n",
    "            plt.show()\n",
    "\n",
    "            gs_compress(fname)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a76eb46",
   "metadata": {},
   "source": [
    "### Plots showing which *model* (XGB/MLP/GP) is best by dimensionality and objective, PER SCALARISER"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "9f2a2d78",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hv_DTLZ_dim_HypI.pdf\n",
      "hv_DTLZ_dim_DomRank.pdf\n",
      "hv_DTLZ_dim_HypCont.pdf\n",
      "hv_DTLZ_dim_ParEGO.pdf\n",
      "igd+_DTLZ_dim_HypI.pdf\n",
      "igd+_DTLZ_dim_DomRank.pdf\n",
      "igd+_DTLZ_dim_HypCont.pdf\n",
      "igd+_DTLZ_dim_ParEGO.pdf\n",
      "hv_WFG_dim_HypI.pdf\n",
      "hv_WFG_dim_DomRank.pdf\n",
      "hv_WFG_dim_HypCont.pdf\n",
      "hv_WFG_dim_ParEGO.pdf\n",
      "igd+_WFG_dim_HypI.pdf\n",
      "igd+_WFG_dim_DomRank.pdf\n",
      "igd+_WFG_dim_HypCont.pdf\n",
      "igd+_WFG_dim_ParEGO.pdf\n",
      "hv_WFG_HD_dim_HypI.pdf\n",
      "hv_WFG_HD_dim_DomRank.pdf\n",
      "hv_WFG_HD_dim_HypCont.pdf\n",
      "hv_WFG_HD_dim_ParEGO.pdf\n",
      "igd+_WFG_HD_dim_HypI.pdf\n",
      "igd+_WFG_HD_dim_DomRank.pdf\n",
      "igd+_WFG_HD_dim_HypCont.pdf\n",
      "igd+_WFG_HD_dim_ParEGO.pdf\n"
     ]
    }
   ],
   "source": [
    "box_dim_data = {}\n",
    "\n",
    "for original_problem_name in problem_names:\n",
    "    if original_problem_name == \"RW\":\n",
    "        continue\n",
    "\n",
    "    savename = f\"{original_problem_name:s}_statstests.npz\"\n",
    "    savepath = os.path.join(final_results_dir, savename)\n",
    "\n",
    "    with np.load(savepath, allow_pickle=True) as fd:\n",
    "        assert original_problem_name == fd[\"original_problem_name\"]\n",
    "        \n",
    "        # per-scalariser results\n",
    "        # td[indicator][scalarizer][problem_id][dim][fdim]\n",
    "        td = fd[\"td\"].item()\n",
    "\n",
    "        # results for each combo of (scalarizer, model)\n",
    "        # tds[indicator][problem_id][dim][fdim]\n",
    "        tds = fd[\"tds\"].item()\n",
    "\n",
    "    problem_name, prob_dict = mbore.problem_sets.get_problem_dict(\n",
    "        original_problem_name\n",
    "    )\n",
    "    total_problems = mbore.problem_sets.get_number_of_problems(prob_dict)\n",
    "\n",
    "    # get all the function dimensions used\n",
    "    dims = np.sort(\n",
    "        np.unique(\n",
    "            [\n",
    "                dim\n",
    "                for problem_id in prob_dict\n",
    "                for dim, _ in prob_dict[problem_id]\n",
    "            ]\n",
    "        )\n",
    "    )\n",
    "\n",
    "    for indicator in [\"hv\", \"igd+\"]:\n",
    "\n",
    "        n_methods = len(models)\n",
    "\n",
    "        for scalarizer in scalarizers:\n",
    "            exp_counts = {dim: 0 for dim in dims}\n",
    "            box_data = {dim: np.zeros(n_methods) for dim in dims}\n",
    "\n",
    "            for problem_id in prob_dict:\n",
    "                for dim, fdims in prob_dict[problem_id]:\n",
    "                    for fdim in fdims:\n",
    "\n",
    "                        box_data[dim] += td[indicator][scalarizer][problem_id][\n",
    "                            dim\n",
    "                        ][fdim][\"best_mask\"]\n",
    "                        exp_counts[dim] += 1\n",
    "\n",
    "            # normalise boxplot data\n",
    "            for dim in dims:\n",
    "                box_data[dim] /= exp_counts[dim]\n",
    "\n",
    "            key = (original_problem_name, indicator, scalarizer)\n",
    "\n",
    "            box_dim_data[key] = box_data\n",
    "\n",
    "for (\n",
    "    original_problem_name, \n",
    "    indicator, \n",
    "    scalarizer\n",
    "), box_data in box_dim_data.items():\n",
    "\n",
    "    problem_name, prob_dict = mbore.problem_sets.get_problem_dict(\n",
    "        original_problem_name\n",
    "    )\n",
    "    n_methods = len(models)\n",
    "    \n",
    "    with plt.rc_context(plot_settings(ncols=1, nrows=0.8, fontsizebase=10)):\n",
    "\n",
    "        offset_increment = 2\n",
    "        xv = np.linspace(0, 1 - 1 / n_methods, n_methods)\n",
    "        widths = 0.95 * (1 / n_methods)\n",
    "        labels = list(box_data.keys())\n",
    "\n",
    "        fig, ax = plt.subplots()\n",
    "        for offset_idx, key in enumerate(box_data):\n",
    "            bars = ax.bar(\n",
    "                x=xv + (offset_increment * offset_idx),\n",
    "                height=box_data[key],\n",
    "                width=widths,\n",
    "                color=[model_colors[m] for m in models],\n",
    "            )\n",
    "\n",
    "        ax.set_ylim([0, 1])\n",
    "\n",
    "        # set up the bar labels\n",
    "        xx = np.arange(0.325, len(labels) * offset_increment, offset_increment)\n",
    "        ax.set_xticks(xx)\n",
    "        ax.set_xticklabels(labels)\n",
    "        ax.set_title(\n",
    "            f\"{problem_name:s}: {scalar_to_paper[scalarizer]:s}\"\n",
    "        )\n",
    "\n",
    "        ax.set_xlabel('Problem dimensionality')\n",
    "\n",
    "        # create legend\n",
    "        for m in models:\n",
    "            ax.plot(0, 0, label=model_to_paper[m], color=model_colors[m], lw=5)\n",
    "        \n",
    "        ax.legend(\n",
    "            loc=\"upper left\", \n",
    "            ncol=len(models),\n",
    "            handletextpad=0.5, # distance between colour and text\n",
    "            columnspacing=1, # spacing between columns (labels)\n",
    "            borderaxespad=0.05, # spacing from the edge of the plot\n",
    "            frameon=False,\n",
    "        )\n",
    "\n",
    "        ax.xaxis.set_label_coords(0.5, -0.15)\n",
    "\n",
    "        fname = f\"{indicator:s}_{original_problem_name:s}_dim_{scalarizer}.pdf\"\n",
    "        print(fname)\n",
    "        plt.savefig(fname)\n",
    "        plt.close()\n",
    "        plt.show()\n",
    "\n",
    "        gs_compress(fname)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hv_DTLZ_obj_HypI.pdf\n",
      "hv_DTLZ_obj_DomRank.pdf\n",
      "hv_DTLZ_obj_HypCont.pdf\n",
      "hv_DTLZ_obj_ParEGO.pdf\n",
      "igd+_DTLZ_obj_HypI.pdf\n",
      "igd+_DTLZ_obj_DomRank.pdf\n",
      "igd+_DTLZ_obj_HypCont.pdf\n",
      "igd+_DTLZ_obj_ParEGO.pdf\n",
      "hv_WFG_obj_HypI.pdf\n",
      "hv_WFG_obj_DomRank.pdf\n",
      "hv_WFG_obj_HypCont.pdf\n",
      "hv_WFG_obj_ParEGO.pdf\n",
      "igd+_WFG_obj_HypI.pdf\n",
      "igd+_WFG_obj_DomRank.pdf\n",
      "igd+_WFG_obj_HypCont.pdf\n",
      "igd+_WFG_obj_ParEGO.pdf\n",
      "hv_WFG_HD_obj_HypI.pdf\n",
      "hv_WFG_HD_obj_DomRank.pdf\n",
      "hv_WFG_HD_obj_HypCont.pdf\n",
      "hv_WFG_HD_obj_ParEGO.pdf\n",
      "igd+_WFG_HD_obj_HypI.pdf\n",
      "igd+_WFG_HD_obj_DomRank.pdf\n",
      "igd+_WFG_HD_obj_HypCont.pdf\n",
      "igd+_WFG_HD_obj_ParEGO.pdf\n"
     ]
    }
   ],
   "source": [
    "box_obj_data = {}\n",
    "\n",
    "for original_problem_name in problem_names:\n",
    "    if original_problem_name == \"RW\":\n",
    "        continue\n",
    "\n",
    "    savename = f\"{original_problem_name:s}_statstests.npz\"\n",
    "    savepath = os.path.join(final_results_dir, savename)\n",
    "\n",
    "    with np.load(savepath, allow_pickle=True) as fd:\n",
    "        assert original_problem_name == fd[\"original_problem_name\"]\n",
    "        \n",
    "        # per-scalariser results\n",
    "        # td[indicator][scalarizer][problem_id][dim][fdim]\n",
    "        td = fd[\"td\"].item()\n",
    "\n",
    "        # results for each combo of (scalarizer, model)\n",
    "        # tds[indicator][problem_id][dim][fdim]\n",
    "        tds = fd[\"tds\"].item()\n",
    "\n",
    "    problem_name, prob_dict = mbore.problem_sets.get_problem_dict(\n",
    "        original_problem_name\n",
    "    )\n",
    "    total_problems = mbore.problem_sets.get_number_of_problems(prob_dict)\n",
    "\n",
    "    fdims = np.sort(\n",
    "        np.unique(\n",
    "            [\n",
    "                fdim\n",
    "                for problem_id in prob_dict\n",
    "                for _, fdims in prob_dict[problem_id]\n",
    "                for fdim in fdims\n",
    "            ]\n",
    "        )\n",
    "    )\n",
    "    n_fdims = fdims.size\n",
    "    n_models = len(models)\n",
    "\n",
    "    for indicator in [\"hv\", \"igd+\"]:\n",
    "\n",
    "\n",
    "        for scalarizer in scalarizers:\n",
    "\n",
    "            box_data = {fdim: np.zeros(n_models) for fdim in fdims}\n",
    "            exp_counts = {fdim: 0 for fdim in fdims}\n",
    "\n",
    "            for problem_id in prob_dict:\n",
    "                for dim, fdims in prob_dict[problem_id]:\n",
    "                    for fdim in fdims:\n",
    "\n",
    "                        box_data[fdim] += td[indicator][scalarizer][problem_id][\n",
    "                            dim\n",
    "                        ][fdim][\"best_mask\"]\n",
    "                        exp_counts[fdim] += 1\n",
    "\n",
    "            # normalise boxplot data\n",
    "            for fdim in box_data:\n",
    "                box_data[fdim] /= exp_counts[fdim]\n",
    "\n",
    "            key = (original_problem_name, indicator, scalarizer)\n",
    "            box_obj_data[key] = box_data\n",
    "\n",
    "for (\n",
    "    original_problem_name, \n",
    "    indicator, \n",
    "    scalarizer\n",
    "), box_data in box_obj_data.items():\n",
    "\n",
    "    problem_name, prob_dict = mbore.problem_sets.get_problem_dict(\n",
    "        original_problem_name\n",
    "    )\n",
    "    n_methods = len(models)\n",
    "\n",
    "    with plt.rc_context(plot_settings(ncols=1, nrows=0.8, fontsizebase=10)):\n",
    "\n",
    "        offset_increment = 1.5\n",
    "        xv = np.linspace(0, 1 - 1 / n_methods, n_methods)\n",
    "        widths = 0.9 * (1 / n_methods)\n",
    "        labels = list(box_data.keys())\n",
    "\n",
    "        fig, ax = plt.subplots()\n",
    "        for offset_idx, key in enumerate(box_data):\n",
    "            bars = ax.bar(\n",
    "                x=xv + (offset_increment * offset_idx),\n",
    "                height=box_data[key],\n",
    "                width=widths,\n",
    "                color=[model_colors[m] for m in models],\n",
    "            )\n",
    "\n",
    "        ax.set_ylim([0, 1])\n",
    "\n",
    "        # set up the bar labels\n",
    "        xx = np.arange(0.325, len(labels) * offset_increment, offset_increment)\n",
    "        ax.set_xticks(xx)\n",
    "        ax.set_xticklabels(labels)\n",
    "        ax.set_title(\n",
    "            f\"{problem_name:s}: {scalar_to_paper[scalarizer]:s}\"\n",
    "        )\n",
    "\n",
    "        ax.set_xlabel('Number of objectives')\n",
    "\n",
    "        # create legend\n",
    "        for m in models:\n",
    "            ax.plot(0, 0, label=model_to_paper[m], color=model_colors[m], lw=5)\n",
    "        \n",
    "        ax.legend(\n",
    "            loc=\"upper left\", \n",
    "            ncol=len(models),\n",
    "            handletextpad=0.5, # distance between colour and text\n",
    "            columnspacing=1, # spacing between columns (labels)\n",
    "            borderaxespad=0.05, # spacing from the edge of the plot\n",
    "            frameon=False,\n",
    "        )\n",
    "\n",
    "        ax.xaxis.set_label_coords(0.5, -0.20)\n",
    "\n",
    "        fname = f\"{indicator:s}_{original_problem_name:s}_obj_{scalarizer}.pdf\"\n",
    "        print(fname)\n",
    "        plt.savefig(fname)\n",
    "        plt.close()\n",
    "        plt.show()\n",
    "\n",
    "        gs_compress(fname)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58940182",
   "metadata": {},
   "source": [
    "### Timing plots per problem dimensionality (skipping RW problems)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "8a5a96c4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7008ca89790c435dae5b4c12f65b7d7d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/4 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Problem set: DTLZ. 56 total problems\n",
      "Problem set: WFG. 63 total problems\n",
      "Skipping real-world problems\n",
      "Problem set: WFG. 27 total problems\n"
     ]
    }
   ],
   "source": [
    "start_from_idx = 1\n",
    "step = 2\n",
    "\n",
    "for original_problem_name in tqdm.notebook.tqdm(problem_names):\n",
    "\n",
    "    if original_problem_name == \"RW\":\n",
    "        print(\"Skipping real-world problems\")\n",
    "        continue\n",
    "\n",
    "    savename = f\"{original_problem_name:s}.npz\"\n",
    "    savepath = os.path.join(final_results_dir, savename)\n",
    "\n",
    "    with np.load(savepath, allow_pickle=True) as fd:\n",
    "        assert original_problem_name == fd[\"original_problem_name\"]\n",
    "\n",
    "        D = fd['D'].item()\n",
    "\n",
    "    problem_name, prob_dict = mbore.problem_sets.get_problem_dict(\n",
    "        original_problem_name\n",
    "    )\n",
    "    total_problems = mbore.problem_sets.get_number_of_problems(prob_dict)\n",
    "    print(f\"Problem set: {problem_name:s}. {total_problems:d} total problems\")\n",
    "\n",
    "    data = {model: {} for model in models}\n",
    "\n",
    "    for i, model in enumerate(models):\n",
    "        for scalarizer in scalarizers:\n",
    "            for problem_id in prob_dict:\n",
    "                for dim, fdims in prob_dict[problem_id]:\n",
    "                    if dim not in data[model]:\n",
    "                        data[model][dim] = []\n",
    "\n",
    "                    for fdim in fdims:\n",
    "\n",
    "                        Z = D[problem_id][dim][fdim][scalarizer][model]['timing']\n",
    "\n",
    "                        data[model][dim].append(Z)\n",
    "\n",
    "    dims = np.sort(\n",
    "        np.unique(\n",
    "            [\n",
    "                dim\n",
    "                for problem_id in prob_dict\n",
    "                for dim, fdims in prob_dict[problem_id]\n",
    "            ]\n",
    "        )\n",
    "    )\n",
    "\n",
    "    for dim in dims:\n",
    "\n",
    "        x = np.arange(start_from_idx, budget)\n",
    "\n",
    "        with plt.rc_context(plot_settings(ncols=1, nrows=0.8, fontsizebase=10)):\n",
    "            fig, ax = plt.subplots()\n",
    "\n",
    "            for model in data:\n",
    "                Z = np.concatenate(data[model][dim])[:, start_from_idx:]\n",
    "                c = model_colors[model]\n",
    "\n",
    "                low, mid, high = np.percentile(Z, q=[25, 50, 75], axis=0)\n",
    "\n",
    "                ax.plot(x[::step], mid[::step], c=c, alpha=1)\n",
    "                ax.fill_between(x[::step], low[::step], high[::step], alpha=0.2, color=c)\n",
    "\n",
    "            title = f\"Computation time: {problem_name} ($d = {dim}$)\" \n",
    "            ax.set_title(title)\n",
    "            \n",
    "            ax.set_xlim([0, budget])\n",
    "            ax.set_ylim([0, ax.get_ylim()[1]])\n",
    "            ax.set_ylabel(\"Time (seconds)\")\n",
    "            ax.set_xlabel(\"Iteration\")\n",
    "\n",
    "            ax.yaxis.set_label_coords(-0.1, 0.5)\n",
    "            ax.xaxis.set_label_coords(0.5, -0.17)\n",
    "\n",
    "            ticklabels = ax.get_xticklabels()\n",
    "            ticklabels[0].set_ha(\"left\")\n",
    "            ticklabels[-1].set_ha(\"right\")\n",
    "\n",
    "            # create legend\n",
    "            for m in models:\n",
    "                ax.plot(0, 0, label=model_to_paper[m], color=model_colors[m], lw=5)\n",
    "            \n",
    "            ax.legend(\n",
    "                loc=\"upper left\",\n",
    "                ncol=len(models),\n",
    "                handletextpad=0.5, # distance between colour and text\n",
    "                columnspacing=1, # spacing between columns (labels)\n",
    "                borderaxespad=0.05, # spacing from the edge of the plot\n",
    "                frameon=False,\n",
    "            )\n",
    "\n",
    "            fname = f\"{original_problem_name:s}_timing_d={dim:d}.pdf\"\n",
    "            plt.savefig(fname)\n",
    "            plt.close()\n",
    "            plt.show()\n",
    "\n",
    "            gs_compress(fname)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "508db196",
   "metadata": {},
   "source": [
    "### Which model is better for a given scalarisation method? (Table data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "7b6bfc2b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a1f565c9e49e4b0296820ea071632c01",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/4 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DTLZ HypI [36  4 29]\n",
      "DTLZ HypI [40  1 28]\n",
      "DTLZ DomRank [21 11 37]\n",
      "DTLZ DomRank [30  5 36]\n",
      "DTLZ HypCont [36 12 22]\n",
      "DTLZ HypCont [41  8 22]\n",
      "DTLZ ParEGO [13  8 43]\n",
      "DTLZ ParEGO [27  2 42]\n",
      "WFG HypI [37  0 36]\n",
      "WFG HypI [36  1 34]\n",
      "WFG DomRank [36  0 45]\n",
      "WFG DomRank [40  1 35]\n",
      "WFG HypCont [39  0 36]\n",
      "WFG HypCont [38  0 35]\n",
      "WFG ParEGO [ 1  0 63]\n",
      "WFG ParEGO [ 4  2 62]\n",
      "RW HypI [4 0 6]\n",
      "RW HypI [5 0 6]\n",
      "RW DomRank [1 1 8]\n",
      "RW DomRank [2 1 8]\n",
      "RW HypCont [7 0 5]\n",
      "RW HypCont [9 0 3]\n",
      "RW ParEGO [2 0 8]\n",
      "RW ParEGO [2 0 8]\n",
      "WFG_HD HypI [10  7 18]\n",
      "WFG_HD HypI [10  9 18]\n",
      "WFG_HD DomRank [ 5 15 17]\n",
      "WFG_HD DomRank [ 7 16 10]\n",
      "WFG_HD HypCont [18  6  7]\n",
      "WFG_HD HypCont [17  5  6]\n",
      "WFG_HD ParEGO [ 0  4 23]\n",
      "WFG_HD ParEGO [ 0  8 23]\n"
     ]
    }
   ],
   "source": [
    "for original_problem_name in tqdm.notebook.tqdm(problem_names):\n",
    "    savename = f\"{original_problem_name:s}_statstests.npz\"\n",
    "    savepath = os.path.join(final_results_dir, savename)\n",
    "\n",
    "    with np.load(savepath, allow_pickle=True) as fd:\n",
    "        assert original_problem_name == fd[\"original_problem_name\"]\n",
    "        \n",
    "        # per-scalariser results\n",
    "        # td[indicator][scalarizer][problem_id][dim][fdim]\n",
    "        td = fd[\"td\"].item()\n",
    "\n",
    "        # results for each combo of (scalarizer, model)\n",
    "        # tds[indicator][problem_id][dim][fdim]\n",
    "        tds = fd[\"tds\"].item()\n",
    "\n",
    "    problem_name, prob_dict = mbore.problem_sets.get_problem_dict(\n",
    "        original_problem_name\n",
    "    )\n",
    "    total_problems = mbore.problem_sets.get_number_of_problems(prob_dict)\n",
    "    # print(f\"Problem set: {problem_name:s}. {total_problems:d} total problems\")\n",
    "\n",
    "    for scalarizer in scalarizers:\n",
    "\n",
    "        for indicator in ['hv', 'igd+']:\n",
    "\n",
    "            n_models = len(models)\n",
    "\n",
    "            overall_bests = np.zeros(n_models, dtype='int')\n",
    "            c = 0\n",
    "\n",
    "            for problem_id in prob_dict:\n",
    "                for dim, fdims in prob_dict[problem_id]:\n",
    "                    for fdim in fdims:\n",
    "\n",
    "                        overall_bests += td[indicator][scalarizer][problem_id][\n",
    "                            dim\n",
    "                        ][fdim][\"best_mask\"]\n",
    "                        c += 1\n",
    "\n",
    "            print(original_problem_name, scalarizer, overall_bests)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9eab590c",
   "metadata": {},
   "source": [
    "## Combined HV plot for PHC on DTLZ and WFG"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "05f51e71",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 468x288 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "combos = [\n",
    "    ('DTLZ', 'hv', 'HypCont'),\n",
    "    ('WFG', 'hv', 'HypCont')\n",
    "]\n",
    "\n",
    "n_models = len(models)\n",
    "\n",
    "settings = plot_settings(ncols=2, nrows=2, fontsizebase=18)\n",
    "settings['axes.labelsize'] -= 2\n",
    "settings['legend.fontsize'] -= 4\n",
    "\n",
    "with plt.rc_context(settings):\n",
    "    fig, axes = plt.subplots(2, 2, sharey=True)\n",
    "\n",
    "    for i, boxes in enumerate([box_dim_data, box_obj_data]):\n",
    "        for j, key in enumerate(combos):\n",
    "            ax = axes[i, j]\n",
    "\n",
    "            original_problem_name, indicator, scalarizer = key\n",
    "            box_data = boxes[key]\n",
    "            problem_name, _ = mbore.problem_sets.get_problem_dict(\n",
    "                original_problem_name\n",
    "            )\n",
    "\n",
    "            offset_increment = 1.5\n",
    "            xv = np.linspace(0, 1 - 1 / n_models, n_models)\n",
    "            widths = 0.9 * (1 / n_models)\n",
    "            labels = list(box_data.keys())\n",
    "\n",
    "            for offset_idx, key in enumerate(box_data):\n",
    "                bars = ax.bar(\n",
    "                    x=xv + (offset_increment * offset_idx),\n",
    "                    height=box_data[key],\n",
    "                    width=widths,\n",
    "                    color=[model_colors[m] for m in models],\n",
    "                )\n",
    "\n",
    "            # set up the bar labels\n",
    "            xx = np.arange(0.325, len(labels) * offset_increment, offset_increment)\n",
    "            ax.set_xticks(xx)\n",
    "            ax.set_xticklabels(labels)\n",
    "            ax.set_title(\n",
    "                f\"{problem_name:s}: {scalar_to_paper[scalarizer]:s}\"\n",
    "            )\n",
    "\n",
    "            if i == 1:\n",
    "                ax.set_xlabel('Number of objectives')\n",
    "            else:\n",
    "                ax.set_xlabel('Problem dimensionality')\n",
    "            ax.xaxis.set_label_coords(0.5, -0.25)\n",
    "\n",
    "    # create legend\n",
    "    for m in models:\n",
    "        axes[0, 0].plot(0, 0, label=model_to_paper[m], color=model_colors[m], lw=5)\n",
    "    \n",
    "    axes[0, 0].legend(\n",
    "        loc=\"upper left\",\n",
    "        ncol=len(models),\n",
    "        handletextpad=0.5, # distance between colour and text\n",
    "        columnspacing=1, # spacing between columns (labels)\n",
    "        borderaxespad=0.05, # spacing from the edge of the plot\n",
    "        frameon=False,\n",
    "    )\n",
    "\n",
    "\n",
    "    axes[0, 0].set_ylim([0, 1])\n",
    "    fname = 'dtlz_wfg_combined.pdf'\n",
    "    plt.savefig(fname)\n",
    "    plt.show()\n",
    "\n",
    "    gs_compress(fname)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f468803",
   "metadata": {},
   "source": [
    "### Combined timing plot for paper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "7905f0f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# problem, dim, n_obj\n",
    "timing_plot_things = [\n",
    "    (\"WFG\", 10),\n",
    "    (\"WFG_HD\", 20),\n",
    "    (\"WFG_HD\", 50),\n",
    "    (\"WFG_HD\", 100),\n",
    "]\n",
    "\n",
    "\n",
    "timing_data = {\n",
    "    dim: {model:[] for model in models} \n",
    "    for (_, dim)  in timing_plot_things\n",
    "}\n",
    "\n",
    "for (original_problem_name, use_dim) in timing_plot_things:\n",
    "    savename = f\"{original_problem_name:s}.npz\"\n",
    "    savepath = os.path.join(final_results_dir, savename)\n",
    "\n",
    "    with np.load(savepath, allow_pickle=True) as fd:\n",
    "        D = fd['D'].item()\n",
    "\n",
    "    problem_name, prob_dict = mbore.problem_sets.get_problem_dict(\n",
    "        original_problem_name\n",
    "    )\n",
    "\n",
    "    for model in models:\n",
    "        for scalarizer in scalarizers:\n",
    "            for problem_id in prob_dict:\n",
    "                for dim, fdims in prob_dict[problem_id]:\n",
    "                    if dim != use_dim:\n",
    "                        continue\n",
    "\n",
    "                    for fdim in fdims:\n",
    "                        Z = D[problem_id][dim][fdim][scalarizer][model]['timing']\n",
    "                        timing_data[dim][model].append(Z)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "15458bbd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 468x259.2 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "start_from_idx = 1\n",
    "step = 2\n",
    "\n",
    "x = np.arange(start_from_idx, budget)\n",
    "\n",
    "settings = plot_settings(ncols=2, nrows=1.8, fontsizebase=18)\n",
    "settings['axes.labelsize'] -= 2\n",
    "settings['legend.fontsize'] -= 4\n",
    "\n",
    "with plt.rc_context(settings):\n",
    "    fig, axes = plt.subplots(2, 2, sharey=False, sharex=True)\n",
    "\n",
    "    for i, dim in enumerate(timing_data):\n",
    "        ax = axes.flat[i]\n",
    "        \n",
    "        for model in timing_data[dim]:\n",
    "            Z = np.concatenate(timing_data[dim][model])[:, start_from_idx:]\n",
    "            c = model_colors[model]\n",
    "\n",
    "            low, mid, high = np.percentile(Z, q=[25, 50, 75], axis=0)\n",
    "\n",
    "            ax.plot(x[::step], mid[::step], c=c, alpha=1)\n",
    "            ax.fill_between(x[::step], low[::step], high[::step], alpha=0.2, color=c)\n",
    "\n",
    "        title = f\"WFG ($d = {dim}$)\"\n",
    "        ax.set_title(title)\n",
    "\n",
    "    axes[0, 0].set_xlim([0, budget])\n",
    "\n",
    "    for i in range(2):\n",
    "        axes[1, i].set_xlabel('Iteration')\n",
    "        axes[1, i].xaxis.set_label_coords(0.5, -0.25)\n",
    "\n",
    "        ticklabels = axes[1, i].get_xticklabels()\n",
    "        ticklabels[0].set_ha(\"left\")\n",
    "        ticklabels[-1].set_ha(\"right\")\n",
    "        \n",
    "        axes[i, 0].set_ylabel('Time (seconds)')\n",
    "        axes[i, 0].yaxis.set_label_coords(-0.1, 0.5)\n",
    "\n",
    "    # create legend\n",
    "    for m in models:\n",
    "        axes[0, 0].plot(0, 0, label=model_to_paper[m], color=model_colors[m], lw=5)\n",
    "    \n",
    "    axes[0, 0].legend(\n",
    "        loc=\"upper left\",\n",
    "        ncol=len(models),\n",
    "        handletextpad=0.5, # distance between colour and text\n",
    "        columnspacing=1, # spacing between columns (labels)\n",
    "        borderaxespad=0.05, # spacing from the edge of the plot\n",
    "        frameon=False,\n",
    "    )\n",
    "    \n",
    "\n",
    "    fname = 'timing_combined.pdf'\n",
    "    plt.savefig(fname)\n",
    "    plt.show()\n",
    "\n",
    "    gs_compress(fname)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3dfc5014",
   "metadata": {},
   "source": [
    "### Convergence plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "7cf40418",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "97f873d636fa4dc58f5325cea632253d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/112 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "dca0c86a126146f2b1dfddc6c9365933",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/126 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c188a15abdcb4238a11be97d8111ea38",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/20 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e436647b73034de989cbe435255a74cd",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/54 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Don't forget to compress these afterwards!\n"
     ]
    }
   ],
   "source": [
    "from matplotlib.ticker import StrMethodFormatter\n",
    "\n",
    "rw_id_to_name = {\n",
    "    21: \"RE2-4-1\",\n",
    "    24: \"RE2-2-4\",\n",
    "    31: \"RE3-3-1\",\n",
    "    32: \"RE3-4-2\",\n",
    "    34: \"RE3-5-4\",\n",
    "    37: \"RE3-4-7\",\n",
    "    41: \"RE4-7-1\",\n",
    "    42: \"RE4-6-2\",\n",
    "    61: \"RE6-3-1\",\n",
    "    91: \"RE9-7-1\",\n",
    "}\n",
    "\n",
    "settings = plot_settings(ncols=1, nrows=1, fontsizebase=10)\n",
    "settings['legend.fontsize'] -= 2\n",
    "\n",
    "step = 2\n",
    "\n",
    "x = np.arange(budget + 1)\n",
    "\n",
    "for original_problem_name in problem_names:\n",
    "    # if original_problem_name != \"WFG_HD\":\n",
    "    #     continue\n",
    "\n",
    "    savename = f\"{original_problem_name:s}.npz\"\n",
    "    savepath = os.path.join(final_results_dir, savename)\n",
    "\n",
    "    with np.load(savepath, allow_pickle=True) as fd:\n",
    "        D = fd['D'].item()\n",
    "\n",
    "    problem_name, prob_dict = mbore.problem_sets.get_problem_dict(\n",
    "        original_problem_name\n",
    "    )\n",
    "\n",
    "    total = mbore.problem_sets.get_number_of_problems(prob_dict) * 2\n",
    "\n",
    "    pbar = tqdm.notebook.tqdm(total=total)\n",
    "\n",
    "    for problem_id in prob_dict:\n",
    "        for dim, fdims in prob_dict[problem_id]:\n",
    "            for fdim in fdims:\n",
    "                for indicator in ['hv', 'igd+']:\n",
    "                    with plt.rc_context(settings):\n",
    "                        fig, ax = plt.subplots(1, 1)\n",
    "\n",
    "                        for scalarizer in scalarizers:\n",
    "                            ls = scalar_to_ls[scalarizer]\n",
    "                            s_paper_name = scalar_conv_to_paper[scalarizer]\n",
    "\n",
    "                            for model in D[problem_id][dim][fdim][scalarizer]:\n",
    "                                c = model_colors[model]\n",
    "\n",
    "                                paper_model_name = model_to_paper[model]\n",
    "\n",
    "                                label = f\"{paper_model_name} + {s_paper_name}\"\n",
    "\n",
    "                                Z = D[problem_id][dim][fdim][scalarizer][model][indicator]\n",
    "\n",
    "                                lower, mid, upper = np.percentile(Z, [25, 50, 75], axis=0)\n",
    "\n",
    "                                ax.fill_between(\n",
    "                                    x[::step], lower[::step], upper[::step], \n",
    "                                    alpha=0.2, color=c, rasterized=False,\n",
    "                                )\n",
    "                                ax.plot(x[::step], mid[::step], label=label, color=c, linestyle=ls)\n",
    "                                \n",
    "                        if problem_name == \"RW\":\n",
    "                            pn = f\"{rw_id_to_name[problem_id]}\"\n",
    "                        else:\n",
    "                            pn = f\"{problem_name:s}{problem_id:d}\"\n",
    "                        \n",
    "                        name = f\"{indicator.upper()}: {pn} ($d={dim:d}, M={fdim:d}$)\"\n",
    "                        ax.set_title(name)\n",
    "                        \n",
    "                        ax.set_xlim([0, budget])\n",
    "                        \n",
    "                        ax.legend(\n",
    "                            loc='lower right' if indicator == 'hv' else 'upper right',\n",
    "                            ncol=4,\n",
    "                            handletextpad=0.5,\n",
    "                            columnspacing=1,\n",
    "                            borderaxespad=0.05,\n",
    "                            frameon=True,\n",
    "                        )\n",
    "                        \n",
    "                        plt.gca().yaxis.set_major_formatter(StrMethodFormatter('{x:,.3f}'))\n",
    "                        \n",
    "                        fname = f\"conv_{indicator}_{problem_name}{problem_id}_{dim}_{fdim}.pdf\"\n",
    "\n",
    "                        plt.savefig(fname)\n",
    "                        plt.close()\n",
    "                        plt.show()\n",
    "                        pbar.update()\n",
    "    pbar.close()\n",
    "print(\"Don't forget to compress these afterwards!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "cf0b461b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b1ef2bc5c68844659a24ca44a44b4ba5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/312 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import glob\n",
    "files = glob.glob(\"*.pdf\")\n",
    "\n",
    "for fname in tqdm.notebook.tqdm(files):\n",
    "    gs_compress(fname)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "76cfa6b0",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}