plots.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "import os\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "from pathlib import Path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_experiment_dataframe(experiment_csv_folder_path):\n",
    "    path = experiment_csv_folder_path\n",
    "    # or unix / linux / mac path\n",
    "\n",
    "    # Get the files from the path provided in the OP\n",
    "    files = Path(path).glob('*.csv')  # .rglob to get subdirectories\n",
    "\n",
    "    # for f in files:\n",
    "    #     print(f.stem)\n",
    "\n",
    "\n",
    "    dfs = list()\n",
    "    for f in files:\n",
    "        data = pd.read_csv(f, index_col=\"id\", header=0)\n",
    "        # .stem is method for pathlib objects to get the filename w/o the extension\n",
    "        data['file'] = f.stem\n",
    "        dfs.append(data)\n",
    "\n",
    "    exp_df = pd.concat(dfs, ignore_index=False)\n",
    "    exp_df['setting'] = 'W' + exp_df['warmup_epochs'].astype(str) + \"-INT\" + exp_df['interval_epochs'].astype(str)\n",
    "    return exp_df\n",
    "\n",
    "\n",
    "def get_top_n_settings(experiment_dataframe, n=5):\n",
    "\n",
    "    #standard deviation is rounded to 3 decimal places\n",
    "    means = experiment_dataframe.groupby(['warmup_epochs', 'interval_epochs'])[\n",
    "        'best_accuracy'].mean().round(3)\n",
    "\n",
    "    list_of_settings = []\n",
    "    for setting, i in means.nlargest(n).items():\n",
    "        list_of_settings.append(setting)\n",
    "    return list_of_settings\n",
    "\n",
    "\n",
    "def output_latex_table_content(experiment_dataframe, output_file_name):\n",
    "\n",
    "    #standard deviation is rounded to 3 decimal places\n",
    "    means = experiment_dataframe.groupby(['warmup_epochs', 'interval_epochs'])[\n",
    "        'best_accuracy'].mean().round(3)\n",
    "    stds = experiment_dataframe.groupby(['warmup_epochs', 'interval_epochs'])[\n",
    "        'best_accuracy'].std().round(3)\n",
    "\n",
    "    table_values = means.astype(str) + \"$\\pm$\" + stds.astype(str)\n",
    "\n",
    "    warmups = [10, 15, 20, 30, 40, 60]\n",
    "    intervals = [1, 5, 8, 10, 15, 30]\n",
    "    table_latex_string = \"\"\n",
    "    for warmup in warmups:\n",
    "        table_latex_string += f\"{warmup}\"\n",
    "        for interval in intervals:\n",
    "            table_latex_string += \"& \" + f\"{table_values[warmup][interval]}\"\n",
    "            if interval == 30:\n",
    "                table_latex_string += \" \\\\\\\\ \\n\"\n",
    "\n",
    "    with open(output_file_name, \"w\") as text_file:\n",
    "        text_file.write(table_latex_string)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# baselines statistics\n",
    "def get_baselines_stats(baseline_csvs_folder_path):\n",
    "\n",
    "    path = baseline_csvs_folder_path\n",
    "\n",
    "    # Get the files from the path provided in the OP\n",
    "    files = Path(path).glob('*.csv')  # .rglob to get subdirectories\n",
    "\n",
    "\n",
    "    dfs = list()\n",
    "    for f in files:\n",
    "        data = pd.read_csv(f, index_col=\"id\", header=0)\n",
    "        # .stem is method for pathlib objects to get the filename w/o the extension\n",
    "        data['file'] = f.stem\n",
    "        dfs.append(data)\n",
    "\n",
    "    baselines_df = pd.concat(dfs, ignore_index=False)\n",
    "    baselines_df['setting'] = \"vanilla\"\n",
    "\n",
    "\n",
    "    #standard deviation is rounded to 3 decimal places\n",
    "    baselines_means = baselines_df.groupby(['dataset', 'model'])[\n",
    "        'best_accuracy'].mean().round(3)\n",
    "    baselines_stds = baselines_df.groupby(['dataset', 'model'])[\n",
    "        'best_accuracy'].std().round(3)\n",
    "    return baselines_df, baselines_means, baselines_stds\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_plot_df(model, dataset, experiment_df, baselines_df, number_of_experiments=5):    \n",
    "    plot_df = baselines_df[(baselines_df[\"model\"] == model) & (\n",
    "        baselines_df[\"dataset\"] == dataset)]\n",
    "    top_settings = get_top_n_settings(experiment_df, n=number_of_experiments)\n",
    "    for (warmup, interval) in top_settings:\n",
    "        setting_df = experiment_df[(experiment_df['warmup_epochs'] == warmup) & (experiment_df['interval_epochs'] == interval)]\n",
    "        plot_df = plot_df.append(setting_df)\n",
    "    return plot_df\n",
    "    # sns.set_style(\"whitegrid\")\n",
    "    # box_plot = sns.boxplot(data=plot_df, x=\"setting\",\n",
    "    #                     y=\"best_accuracy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_plot(model, dataset, experiment_folder_path):\n",
    "\n",
    "    exp_df = get_experiment_dataframe(experiment_folder_path)\n",
    "    baselines_df, baselines_means, baselines_stds = get_baselines_stats(\n",
    "        \"PaperCSVs/Baselines\")\n",
    "    sns.set_style(\"whitegrid\")\n",
    "    plot_df = get_plot_df(model, dataset, experiment_df=exp_df, baselines_df=baselines_df, )\n",
    "    box_plot = sns.boxplot(data=plot_df, x=\"setting\",\n",
    "                           y=\"best_accuracy\", \n",
    "                           showmeans=True,\n",
    "                           meanprops={\n",
    "                               \"marker\": \"s\", \"markerfacecolor\": \"white\", \"markeredgecolor\": \"blue\"}\n",
    "                           )\n",
    "\n",
    "    filename = experiment_folder_path.partition(\"/\")[2] + \".pdf\"\n",
    "    box_plot.get_figure().savefig(filename)\n",
    "    del box_plot\n",
    "    # return plot_df\n",
    "\n",
    "# offset from median for display\n",
    "# vertical_offset = exp_df['best_accuracy'].median() * 0.05\n",
    "\n",
    "# for xtick in box_plot.get_xticks():\n",
    "#     box_plot.text(xtick,mean_values[xtick] + 0.003 , [xtick], \n",
    "#             horizontalalignment='center',size='x-small',color='b',weight='semibold')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_of_workload_paths = [\"PaperCSVs/CIFAR10-ResNet18-Blocks-Variance\",\n",
    "                          \"PaperCSVs/CIFAR10-ResNet18-Stripes-Average\",\n",
    "                          \"PaperCSVs/CIFAR10-ResNet18-Stripes-Variance\",\n",
    "                          \"PaperCSVs/CIFAR10-ResNet34-Stripes-Variance\",\n",
    "                          \"PaperCSVs/CIFAR100-ResNet34-Stripes-Variance\",\n",
    "                          ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_14940/2311284029.py:7: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  plot_df = plot_df.append(setting_df)\n",
      "/tmp/ipykernel_14940/2311284029.py:7: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  plot_df = plot_df.append(setting_df)\n",
      "/tmp/ipykernel_14940/2311284029.py:7: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  plot_df = plot_df.append(setting_df)\n",
      "/tmp/ipykernel_14940/2311284029.py:7: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  plot_df = plot_df.append(setting_df)\n",
      "/tmp/ipykernel_14940/2311284029.py:7: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  plot_df = plot_df.append(setting_df)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Figure 5 (1)\n",
    "\n",
    "path = \"PaperCSVs/CIFAR10-ResNet18-Stripes-Variance\"\n",
    "draw_plot(\"resnet18\", \"cifar10\", path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_14940/2311284029.py:7: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  plot_df = plot_df.append(setting_df)\n",
      "/tmp/ipykernel_14940/2311284029.py:7: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  plot_df = plot_df.append(setting_df)\n",
      "/tmp/ipykernel_14940/2311284029.py:7: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  plot_df = plot_df.append(setting_df)\n",
      "/tmp/ipykernel_14940/2311284029.py:7: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  plot_df = plot_df.append(setting_df)\n",
      "/tmp/ipykernel_14940/2311284029.py:7: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  plot_df = plot_df.append(setting_df)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Figure 5 (2)\n",
    "\n",
    "path = \"PaperCSVs/CIFAR10-ResNet18-Stripes-Average\"\n",
    "draw_plot(\"resnet18\", \"cifar10\", path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_14940/2311284029.py:7: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  plot_df = plot_df.append(setting_df)\n",
      "/tmp/ipykernel_14940/2311284029.py:7: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  plot_df = plot_df.append(setting_df)\n",
      "/tmp/ipykernel_14940/2311284029.py:7: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  plot_df = plot_df.append(setting_df)\n",
      "/tmp/ipykernel_14940/2311284029.py:7: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  plot_df = plot_df.append(setting_df)\n",
      "/tmp/ipykernel_14940/2311284029.py:7: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  plot_df = plot_df.append(setting_df)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Figure 5 (3)\n",
    "\n",
    "path = \"PaperCSVs/CIFAR10-ResNet18-Blocks-Variance\"\n",
    "draw_plot(\"resnet18\", \"cifar10\", path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_14940/2311284029.py:7: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  plot_df = plot_df.append(setting_df)\n",
      "/tmp/ipykernel_14940/2311284029.py:7: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  plot_df = plot_df.append(setting_df)\n",
      "/tmp/ipykernel_14940/2311284029.py:7: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  plot_df = plot_df.append(setting_df)\n",
      "/tmp/ipykernel_14940/2311284029.py:7: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  plot_df = plot_df.append(setting_df)\n",
      "/tmp/ipykernel_14940/2311284029.py:7: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  plot_df = plot_df.append(setting_df)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Figure 5 (4)\n",
    "\n",
    "path = \"PaperCSVs/CIFAR10-ResNet34-Stripes-Variance\"\n",
    "draw_plot(\"resnet34\", \"cifar10\", path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_14940/2311284029.py:7: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  plot_df = plot_df.append(setting_df)\n",
      "/tmp/ipykernel_14940/2311284029.py:7: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  plot_df = plot_df.append(setting_df)\n",
      "/tmp/ipykernel_14940/2311284029.py:7: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  plot_df = plot_df.append(setting_df)\n",
      "/tmp/ipykernel_14940/2311284029.py:7: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  plot_df = plot_df.append(setting_df)\n",
      "/tmp/ipykernel_14940/2311284029.py:7: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  plot_df = plot_df.append(setting_df)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Figure 5 (5)\n",
    "path = \"PaperCSVs/CIFAR100-ResNet34-Stripes-Variance\"\n",
    "draw_plot(\"resnet34\", \"cifar100\", path)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ONLY RUN THIS CELL IF YOU WANT TO FETCH RESULTS FROM YOUR WANDB PROJECT\n",
    "# in that case, replace the folder name, regex, etc. with your own settings\n",
    "import wandb\n",
    "\n",
    "api = wandb.Api(timeout=19)\n",
    "entity_project_string = \"YOUR_WORKSPACE/YOUR_PROJECT\"\n",
    "\n",
    "\n",
    "def get_wandb_csv(folder_name=None, experiment_names_regex=None, baseline=False):\n",
    "    # CHANGE THE REGEX HERE\n",
    "    experiment_names_regex = experiment_names_regex\n",
    "\n",
    "    # apparently returns in order of recency\n",
    "    # 31 runs -> 9.1 seconds\n",
    "    runs = api.runs(\n",
    "        path=entity_project_string,\n",
    "        filters={'display_name': {\"$regex\": experiment_names_regex}}\n",
    "    )\n",
    "\n",
    "    dict_accuracies = {}\n",
    "    dict_configs = {}\n",
    "    for run in runs:\n",
    "        list_acc = []\n",
    "        list_configs = [run.config[k] for k in ['warmup_epochs', 'interval_epochs',\n",
    "                                                'measure', 'heuristic', 'model', 'dataset']]  # to double check correct hyperparams\n",
    "        if run.state == \"finished\":\n",
    "            for i, row in run.history(keys=[\"test_accuracy\"]).iterrows():\n",
    "                list_acc.append(row[\"test_accuracy\"])\n",
    "            dict_accuracies[run.id] = list_acc\n",
    "            dict_configs[run.id] = list_configs\n",
    "\n",
    "    dict_best_accuracy = {}\n",
    "\n",
    "    for run_id in dict_accuracies:\n",
    "        accuracies = dict_accuracies[run_id]\n",
    "        best_accuracy = max(accuracies)\n",
    "        # +1 for epoch numbering\n",
    "        print(\n",
    "            f\"Best Accuracy for {run_id} is {max(accuracies)} at epoch {accuracies.index(best_accuracy)+1}\")\n",
    "    \n",
    "    if baseline:\n",
    "        csv_file_name = folder_name + \"/\" + \\\n",
    "            experiment_names_regex.partition(\"###T100-\")[0] + \".csv\"\n",
    "    else:\n",
    "        shortened_name = experiment_names_regex.partition(\"###T100-\")[2][:-1]\n",
    "        shortened_name = shortened_name.partition(\n",
    "            \"IG5-\")[0] + shortened_name.partition(\"IG5-\")[2]\n",
    "        csv_file_name = folder_name + \"/\" + shortened_name + \".csv\"\n",
    "\n",
    "    num_epochs = len(list_acc)\n",
    "\n",
    "    header = [f\"epoch_{i}\" for i in range(1, num_epochs+1)]\n",
    "\n",
    "    header.insert(0, 'id')\n",
    "    header = header+['best_accuracy', 'best_epoch'] + ['warmup_epochs',\n",
    "                                                       'interval_epochs', 'measure', 'heuristic', 'model', 'dataset']\n",
    "\n",
    "    \n",
    "    with open(csv_file_name, mode='x') as csv_file:\n",
    "        csv_writer = csv.writer(\n",
    "            csv_file, delimiter=',', quotechar='\"', quoting=csv.QUOTE_MINIMAL)\n",
    "\n",
    "        # write the header\n",
    "        csv_writer.writerow(header)\n",
    "\n",
    "        for run_id in dict_accuracies:\n",
    "            accuracies = dict_accuracies[run_id]\n",
    "            config = dict_configs[run_id]\n",
    "            best_accuracy = max(accuracies)\n",
    "            best_epoch = accuracies.index(best_accuracy) + 1\n",
    "            # +1 for epoch numbering\n",
    "            row = [run_id] + accuracies + [best_accuracy, best_epoch] + config\n",
    "            csv_writer.writerow(row)\n",
    "\n",
    "master_folder_name = \"PaperCSVs\"\n",
    "experiment_group = \"CIFAR100-ResNet34-Stripes-Variance\"\n",
    "base_regex = \"c100-resnet34###T100-\"\n",
    "\n",
    "warmups = [10, 15, 20, 30, 40, 60]\n",
    "intervals = [1, 5, 8, 10, 15, 30]\n",
    "\n",
    "list_regexes = []\n",
    "\n",
    "for warmup in warmups:\n",
    "    for interval in intervals:\n",
    "        list_regexes.append(base_regex+f\"W{warmup}-IG5-INT{interval}-\")\n",
    "\n",
    "# print(list_regexes)\n",
    "# len(list_regexes)\n",
    "\n",
    "if not os.path.exists(master_folder_name):\n",
    "    os.mkdir(master_folder_name)\n",
    "\n",
    "if not os.path.exists(master_folder_name+\"/\"+experiment_group):\n",
    "    os.mkdir(master_folder_name+\"/\"+experiment_group)\n",
    "\n",
    "for regex in list_regexes:\n",
    "    get_wandb_csv(folder_name=master_folder_name+\"/\" +\n",
    "                  experiment_group, experiment_names_regex=regex)\n",
    "\n",
    "# get baseline (vanilla) CSVs\n",
    "vanilla_regexes = [\"c10-vanilla-resnet18-batch256###T100-\",\n",
    "                   \"c10-vanilla-resnet34-total100###T100-\",\n",
    "                   \"c100-vanilla-resnet34-total100###T100-\",\n",
    "                   ]\n",
    "\n",
    "if not os.path.exists(\"Baselines\"):\n",
    "    os.mkdir(\"Baselines\")\n",
    "\n",
    "for regex in vanilla_regexes:\n",
    "    get_wandb_csv(folder_name=\"Baselines\", experiment_names_regex=regex, baseline=True)\n",
    "    "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pytorch",
   "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.8.13"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "31d4df3a9243ade48cc0110b4d1858354c8f7f5e18c5809ccbf3e110de45b2f6"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}