experiments/analysis/analysis_test.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load the tests to compare"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "availeble tests:\n",
      " [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17]\n",
      "tests_types:\n",
      " ['DQN', 'DQN', 'DQN', 'DQN', 'DQN', 'DQN', 'DQN', 'DQN', 'DQN', 'DQN', 'DQN', 'DQN', 'DQN', 'DQN', 'DQN', 'DQN', 'DQN', 'DQN']\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import os\n",
    "import sys\n",
    "import json\n",
    "import pickle\n",
    "import pandas as pd\n",
    "\n",
    "# get an absolute path to the directory that contains parent files\n",
    "project_dir = globals()['_dh'][0]\n",
    "sys.path.append(os.path.normpath(os.path.join(project_dir, '..', '..')))\n",
    "\n",
    "from experiments.utils.constants import TESTS_RESULTS_PATH\n",
    "series = 22\n",
    "start_test = 0\n",
    "end_test = 18\n",
    "tests_ids = [i for i in range(start_test, end_test)]\n",
    "tests_names = [i for i in range(start_test, end_test)]\n",
    "\n",
    "tests = {}\n",
    "\n",
    "\n",
    "for test_id, test_name in zip(tests_ids, tests_names):\n",
    "    test_path = os.path.join(\n",
    "        TESTS_RESULTS_PATH,\n",
    "        'series',\n",
    "        str(series),\n",
    "        'tests',\n",
    "        str(test_id))\n",
    "    with open(os.path.join(test_path, 'info.json')) as cf:\n",
    "        info = json.loads(cf.read())\n",
    "    with open(os.path.join(test_path, 'episodes.pickle'), 'rb') as input_file:\n",
    "        episodes = pickle.load(input_file)\n",
    "    tests.update({test_name: {\n",
    "        'info': info,\n",
    "        'episodes': episodes\n",
    "    }})\n",
    "test_types = [test['info']['algorithm'] for _, test in tests.items()]\n",
    "print(\"availeble tests:\\n {}\\ntests_types:\\n {}\".format(\n",
    "    list(tests.keys()),\n",
    "    test_types))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# All Stats of a test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tests entry structure:\n",
      "dict_keys(['info', 'episodes'])\n",
      "tests entry info structure:\n",
      "dict_keys(['type_env', 'series', 'cluster_id', 'workload_id', 'workload_id_test', 'checkpoint', 'experiment_str', 'experiments', 'episode_length', 'num_episodes', 'algorithm', 'penalty_consolidated', 'num_workers'])\n",
      "tests entry episodes info:\n",
      "Index(['action', 'raw_obs', 'num_consolidated', 'num_overloaded',\n",
      "       'scheduling_timestep', 'scheduling_success', 'reward_illegal',\n",
      "       'reward_u', 'reward_c', 'reward_cv', 'reward_v', 'reward_g', 'reward_p',\n",
      "       'u', 'c', 'cv', 'v', 'g', 'p', 'reward'],\n",
      "      dtype='object')\n"
     ]
    }
   ],
   "source": [
    "test_id = 0\n",
    "episdoe_id = 0\n",
    "print(f'tests entry structure:\\n{tests[test_id].keys()}')\n",
    "print(f\"tests entry info structure:\\n{tests[test_id]['info'].keys()}\")\n",
    "print(f\"tests entry episodes info:\\n{tests[test_id]['episodes'][episdoe_id].columns}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Extracting necessary stats of all tests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_stats = []\n",
    "for test_id in range(start_test, end_test):\n",
    "    # TODO check for correctness\n",
    "    num_consolidated_episodes_average = [episode['num_consolidated'].mean() for episode in tests[test_id]['episodes']]\n",
    "    num_consolidated_test_average = sum(num_consolidated_episodes_average) / len(num_consolidated_episodes_average)\n",
    "\n",
    "    num_overloaded_episodes_average = [episode['num_overloaded'].mean() for episode in tests[test_id]['episodes']]\n",
    "    num_overloaded_test_average = sum(num_overloaded_episodes_average) / len(num_overloaded_episodes_average)\n",
    "\n",
    "    scheduling_success_episodes_average = [episode['scheduling_success'].mean() for episode in tests[test_id]['episodes']]\n",
    "    scheduling_success_test_average = sum(scheduling_success_episodes_average) / len(scheduling_success_episodes_average)\n",
    "\n",
    "    reward_illegal_episodes_average = [episode['reward_illegal'].mean() for episode in tests[test_id]['episodes']]\n",
    "    reward_illegal_test_average = sum(reward_illegal_episodes_average) / len(reward_illegal_episodes_average)\n",
    "\n",
    "    reward_u_episodes_average = [episode['reward_u'].mean() for episode in tests[test_id]['episodes']]\n",
    "    reward_u_test_average = sum(reward_u_episodes_average) / len(reward_u_episodes_average)\n",
    "\n",
    "    reward_c_episodes_average = [episode['reward_c'].mean() for episode in tests[test_id]['episodes']]\n",
    "    reward_c_test_average = sum(reward_c_episodes_average) / len(reward_c_episodes_average)\n",
    "\n",
    "    reward_c_episodes_average = [episode['reward_cv'].mean() for episode in tests[test_id]['episodes']]\n",
    "    reward_c_test_average = sum(reward_c_episodes_average) / len(reward_c_episodes_average)\n",
    "\n",
    "    reward_v_episodes_average = [episode['reward_v'].mean() for episode in tests[test_id]['episodes']]\n",
    "    reward_v_test_average = sum(reward_v_episodes_average) / len(reward_v_episodes_average)\n",
    "\n",
    "    reward_g_episodes_average = [episode['reward_g'].mean() for episode in tests[test_id]['episodes']]\n",
    "    reward_g_test_average = sum(reward_g_episodes_average) / len(reward_g_episodes_average)\n",
    "\n",
    "    reward_p_episodes_average = [episode['reward_p'].mean() for episode in tests[test_id]['episodes']]\n",
    "    reward_p_test_average = sum(reward_p_episodes_average) / len(reward_p_episodes_average)\n",
    "\n",
    "    cv_episodes_average = [episode['cv'].mean() for episode in tests[test_id]['episodes']]\n",
    "    cv_test_average = sum(cv_episodes_average) / len(cv_episodes_average)\n",
    "\n",
    "    reward_episodes_average = [episode['reward'].mean() for episode in tests[test_id]['episodes']]\n",
    "    reward_test_average = sum(reward_episodes_average) / len(reward_episodes_average)\n",
    "\n",
    "\n",
    "    final_stats.append({\n",
    "        'test_id': test_id,\n",
    "        'checkpoint': tests[test_id]['info']['checkpoint'],\n",
    "        # TODO where is workload id\n",
    "        'cluster_id': tests[test_id]['info']['cluster_id'],\n",
    "        'workload_id': tests[test_id]['info']['workload_id'],\n",
    "        'workload_id_test': tests[test_id]['info']['workload_id_test'],\n",
    "        'experiments': tests[test_id]['info']['experiments'],\n",
    "        'episode_length': tests[test_id]['info']['episode_length'],\n",
    "        'num_episodes': tests[test_id]['info']['num_episodes'],\n",
    "        'penalalty_consolidated': tests[test_id]['info']['penalty_consolidated'],\n",
    "        'consolidated': num_consolidated_test_average,\n",
    "        'scheduling_success_test_average': scheduling_success_test_average,\n",
    "        'reward_g_test_average': reward_g_test_average,\n",
    "        'reward_u_test_average': reward_u_test_average,\n",
    "        'variance': cv_test_average\n",
    "    })\n",
    "\n",
    "final_stats_df = pd.DataFrame(final_stats)\n",
    "final_stats_df['test_types'] = test_types\n",
    "# final_stats_df.loc[df['penalalty_consolidated']]\n",
    "\n",
    "# TODO add the following information to the table (from the info.json file)\n",
    "# - penatly_latency\n",
    "# - penalty_conslidation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'type_env': 'sim-scheduler',\n",
       " 'series': 121,\n",
       " 'cluster_id': 18,\n",
       " 'workload_id': 0,\n",
       " 'workload_id_test': 3,\n",
       " 'checkpoint': 300,\n",
       " 'experiment_str': 'DQN_SimSchedulerEnv_4b07c_00000_0_2023-02-16_22-57-31',\n",
       " 'experiments': 2,\n",
       " 'episode_length': 1000,\n",
       " 'num_episodes': 5,\n",
       " 'algorithm': 'DQN',\n",
       " 'penalty_consolidated': 1,\n",
       " 'num_workers': 4}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_id = 2\n",
    "tests[test_id]['info']"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# compare tests - tables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_stats_df = final_stats_df.sort_values(by=['test_types', 'test_id', 'experiments']).reset_index(drop=True)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# compare tests - plots"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>test_id</th>\n",
       "      <th>checkpoint</th>\n",
       "      <th>cluster_id</th>\n",
       "      <th>workload_id</th>\n",
       "      <th>workload_id_test</th>\n",
       "      <th>experiments</th>\n",
       "      <th>episode_length</th>\n",
       "      <th>num_episodes</th>\n",
       "      <th>penalalty_consolidated</th>\n",
       "      <th>consolidated</th>\n",
       "      <th>scheduling_success_test_average</th>\n",
       "      <th>reward_g_test_average</th>\n",
       "      <th>reward_u_test_average</th>\n",
       "      <th>variance</th>\n",
       "      <th>test_types</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>13</td>\n",
       "      <td>300</td>\n",
       "      <td>6</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>1000</td>\n",
       "      <td>5</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.6172</td>\n",
       "      <td>0.1756</td>\n",
       "      <td>0.327345</td>\n",
       "      <td>4.228089e+26</td>\n",
       "      <td>7.448921e+50</td>\n",
       "      <td>DQN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>14</td>\n",
       "      <td>300</td>\n",
       "      <td>6</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>1000</td>\n",
       "      <td>5</td>\n",
       "      <td>0.75</td>\n",
       "      <td>1.6734</td>\n",
       "      <td>0.1554</td>\n",
       "      <td>0.300418</td>\n",
       "      <td>3.706243e+26</td>\n",
       "      <td>6.211699e+50</td>\n",
       "      <td>DQN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>12</td>\n",
       "      <td>300</td>\n",
       "      <td>6</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>1000</td>\n",
       "      <td>5</td>\n",
       "      <td>1.00</td>\n",
       "      <td>3.5976</td>\n",
       "      <td>0.1168</td>\n",
       "      <td>0.244855</td>\n",
       "      <td>3.056775e+26</td>\n",
       "      <td>6.533025e+50</td>\n",
       "      <td>DQN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4</td>\n",
       "      <td>300</td>\n",
       "      <td>8</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>1000</td>\n",
       "      <td>5</td>\n",
       "      <td>0.00</td>\n",
       "      <td>2.0116</td>\n",
       "      <td>0.1858</td>\n",
       "      <td>0.358916</td>\n",
       "      <td>4.207320e+26</td>\n",
       "      <td>5.259708e+50</td>\n",
       "      <td>DQN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>5</td>\n",
       "      <td>300</td>\n",
       "      <td>8</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>1000</td>\n",
       "      <td>5</td>\n",
       "      <td>0.75</td>\n",
       "      <td>3.8446</td>\n",
       "      <td>0.1552</td>\n",
       "      <td>0.316682</td>\n",
       "      <td>3.741439e+26</td>\n",
       "      <td>5.513594e+50</td>\n",
       "      <td>DQN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>300</td>\n",
       "      <td>8</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>1000</td>\n",
       "      <td>5</td>\n",
       "      <td>1.00</td>\n",
       "      <td>5.5740</td>\n",
       "      <td>0.1332</td>\n",
       "      <td>0.291623</td>\n",
       "      <td>3.244145e+26</td>\n",
       "      <td>5.209433e+50</td>\n",
       "      <td>DQN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>16</td>\n",
       "      <td>300</td>\n",
       "      <td>10</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>1000</td>\n",
       "      <td>5</td>\n",
       "      <td>0.00</td>\n",
       "      <td>2.1500</td>\n",
       "      <td>0.1872</td>\n",
       "      <td>0.361200</td>\n",
       "      <td>1.453957e+22</td>\n",
       "      <td>3.102819e+43</td>\n",
       "      <td>DQN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>17</td>\n",
       "      <td>300</td>\n",
       "      <td>10</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>1000</td>\n",
       "      <td>5</td>\n",
       "      <td>0.75</td>\n",
       "      <td>5.6730</td>\n",
       "      <td>0.1376</td>\n",
       "      <td>0.301863</td>\n",
       "      <td>1.452504e+22</td>\n",
       "      <td>3.102816e+43</td>\n",
       "      <td>DQN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>15</td>\n",
       "      <td>300</td>\n",
       "      <td>10</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>1000</td>\n",
       "      <td>5</td>\n",
       "      <td>1.00</td>\n",
       "      <td>8.3926</td>\n",
       "      <td>0.0908</td>\n",
       "      <td>0.238982</td>\n",
       "      <td>6.271024e+18</td>\n",
       "      <td>1.330946e+37</td>\n",
       "      <td>DQN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    test_id  checkpoint  cluster_id  workload_id  workload_id_test  \\\n",
       "13       13         300           6            0                 3   \n",
       "14       14         300           6            0                 3   \n",
       "12       12         300           6            0                 3   \n",
       "4         4         300           8            0                 3   \n",
       "5         5         300           8            0                 3   \n",
       "3         3         300           8            0                 3   \n",
       "16       16         300          10            0                 3   \n",
       "17       17         300          10            0                 3   \n",
       "15       15         300          10            0                 3   \n",
       "\n",
       "    experiments  episode_length  num_episodes  penalalty_consolidated  \\\n",
       "13            1            1000             5                    0.00   \n",
       "14            2            1000             5                    0.75   \n",
       "12            0            1000             5                    1.00   \n",
       "4             1            1000             5                    0.00   \n",
       "5             2            1000             5                    0.75   \n",
       "3             0            1000             5                    1.00   \n",
       "16            1            1000             5                    0.00   \n",
       "17            2            1000             5                    0.75   \n",
       "15            0            1000             5                    1.00   \n",
       "\n",
       "    consolidated  scheduling_success_test_average  reward_g_test_average  \\\n",
       "13        0.6172                           0.1756               0.327345   \n",
       "14        1.6734                           0.1554               0.300418   \n",
       "12        3.5976                           0.1168               0.244855   \n",
       "4         2.0116                           0.1858               0.358916   \n",
       "5         3.8446                           0.1552               0.316682   \n",
       "3         5.5740                           0.1332               0.291623   \n",
       "16        2.1500                           0.1872               0.361200   \n",
       "17        5.6730                           0.1376               0.301863   \n",
       "15        8.3926                           0.0908               0.238982   \n",
       "\n",
       "    reward_u_test_average      variance test_types  \n",
       "13           4.228089e+26  7.448921e+50        DQN  \n",
       "14           3.706243e+26  6.211699e+50        DQN  \n",
       "12           3.056775e+26  6.533025e+50        DQN  \n",
       "4            4.207320e+26  5.259708e+50        DQN  \n",
       "5            3.741439e+26  5.513594e+50        DQN  \n",
       "3            3.244145e+26  5.209433e+50        DQN  \n",
       "16           1.453957e+22  3.102819e+43        DQN  \n",
       "17           1.452504e+22  3.102816e+43        DQN  \n",
       "15           6.271024e+18  1.330946e+37        DQN  "
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "selected = final_stats_df[(final_stats_df['cluster_id'] == 17) | (final_stats_df['cluster_id'] == 21) | (final_stats_df['cluster_id'] == 22)].sort_values(by=['cluster_id', 'consolidated'])\n",
    "selected.loc[selected['cluster_id'] == 21, 'cluster_id'] = 6\n",
    "selected.loc[selected['cluster_id'] == 17, 'cluster_id'] = 8\n",
    "selected.loc[selected['cluster_id'] == 22, 'cluster_id'] = 10\n",
    "selected = selected.sort_values(by=['cluster_id'])\n",
    "# selected.loc[selected['experiments'] == 0, 'cluster_id'] = 'Consolidation'\n",
    "# selected.loc[selected['experiments'] == 1, 'cluster_id'] = 'Fairness'\n",
    "# selected.loc[selected['experiments'] == 2, 'cluster_id'] = 'Balance'\n",
    "selected"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Fairness</th>\n",
       "      <th>Balance</th>\n",
       "      <th>Consolidation</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th># nodes</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>six</th>\n",
       "      <td>0.61</td>\n",
       "      <td>1.67</td>\n",
       "      <td>3.59</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>eight</th>\n",
       "      <td>2.00</td>\n",
       "      <td>3.80</td>\n",
       "      <td>5.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ten</th>\n",
       "      <td>2.10</td>\n",
       "      <td>5.60</td>\n",
       "      <td>8.30</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         Fairness  Balance  Consolidation\n",
       "# nodes                                  \n",
       "six          0.61     1.67           3.59\n",
       "eight        2.00     3.80           5.50\n",
       "ten          2.10     5.60           8.30"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_cons_plot = pd.DataFrame([], columns=['# nodes', 'Fairness', 'Balance', 'Consolidation'])\n",
    "to_append = pd.DataFrame({'# nodes': [\"six\"], 'Fairness': [0.61], 'Balance': [1.67], 'Consolidation': [3.59]})\n",
    "df_cons_plot = df_cons_plot.append(to_append)\n",
    "to_append = pd.DataFrame({'# nodes': [\"eight\"], 'Fairness': [2], 'Balance': [3.8], 'Consolidation': [5.5]})\n",
    "df_cons_plot = df_cons_plot.append(to_append)\n",
    "to_append = pd.DataFrame({'# nodes': [\"ten\"], 'Fairness': [2.1], 'Balance': [5.6], 'Consolidation': [8.3]})\n",
    "df_cons_plot = df_cons_plot.append(to_append)\n",
    "\n",
    "df_cons_plot.set_index('# nodes', inplace=True)\n",
    "\n",
    "df_cons_plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "plt.figure(figsize=(12, 8))  # Increase figure size for better visibility\n",
    "\n",
    "# Define width of bars\n",
    "bar_width = 0.3\n",
    "\n",
    "# Define index for positioning bars\n",
    "index = np.arange(len(df_cons_plot.index))\n",
    "\n",
    "# Define colors for the bars\n",
    "colors = ['#1f77b4', '#ff7f0e', '#2ca02c']\n",
    "\n",
    "# Define hatch patterns for each objective\n",
    "hatches = ['//', '+', '\\/']\n",
    "\n",
    "# Plot the bar plot for each objective separately with different hatch patterns\n",
    "for i, column in enumerate(df_cons_plot.columns):\n",
    "    plt.bar(index + i * bar_width, df_cons_plot[column], bar_width, label=column, color=colors[i], edgecolor='black', alpha=0.7, hatch=hatches[i])\n",
    "\n",
    "plt.title(\"Consolidation Test\", fontsize=20)  # Larger title font size\n",
    "plt.xlabel(\"Number of Nodes\", fontsize=20)  # Larger x-label font size\n",
    "plt.ylabel(\"Average Number of Consolidated Servers\", fontsize=20)  # Larger y-label font size\n",
    "plt.xticks(index + bar_width * len(df_cons_plot.columns) / 2, df_cons_plot.index, fontsize=12)  # Larger x-ticks font size\n",
    "plt.yticks(fontsize=12)  # Larger y-ticks font size\n",
    "plt.legend(loc='center left', bbox_to_anchor=(1, 0.5), fontsize=14)  # Larger legend font size\n",
    "plt.tight_layout()\n",
    "plt.savefig('test-average-consolidation.pdf', bbox_inches='tight')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Fairness</th>\n",
       "      <th>Balance</th>\n",
       "      <th>Consolidation</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th># nodes</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>six</th>\n",
       "      <td>0.32</td>\n",
       "      <td>0.30</td>\n",
       "      <td>0.24</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>eight</th>\n",
       "      <td>0.36</td>\n",
       "      <td>0.32</td>\n",
       "      <td>0.29</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ten</th>\n",
       "      <td>0.36</td>\n",
       "      <td>0.30</td>\n",
       "      <td>0.23</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         Fairness  Balance  Consolidation\n",
       "# nodes                                  \n",
       "six          0.32     0.30           0.24\n",
       "eight        0.36     0.32           0.29\n",
       "ten          0.36     0.30           0.23"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_g_plog = pd.DataFrame([], columns=['# nodes', 'Fairness', 'Balance', 'Consolidation'])\n",
    "to_append = pd.DataFrame({'# nodes': [\"six\"], 'Fairness': [0.32], 'Balance': [0.30], 'Consolidation': [0.24]})\n",
    "df_g_plog = df_g_plog.append(to_append)\n",
    "to_append = pd.DataFrame({'# nodes': [\"eight\"], 'Fairness': [0.36], 'Balance': [0.32], 'Consolidation': [0.29]})\n",
    "df_g_plog = df_g_plog.append(to_append)\n",
    "to_append = pd.DataFrame({'# nodes': [\"ten\"], 'Fairness': [0.36], 'Balance': [0.30], 'Consolidation': [0.23]})\n",
    "df_g_plog = df_g_plog.append(to_append)\n",
    "\n",
    "df_g_plog.set_index('# nodes', inplace=True)\n",
    "\n",
    "df_g_plog"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "plt.figure(figsize=(12, 8))  # Increase figure size for better visibility\n",
    "\n",
    "# Define width of bars\n",
    "bar_width = 0.3\n",
    "\n",
    "# Define index for positioning bars\n",
    "index = np.arange(len(df_g_plog.index))\n",
    "\n",
    "# Define colors for the bars\n",
    "colors = ['#1f77b4', '#ff7f0e', '#2ca02c']\n",
    "\n",
    "# Define hatch patterns for each objective\n",
    "hatches = ['//', '+', '\\/']\n",
    "\n",
    "# Plot the bar plot for each objective separately with different hatch patterns\n",
    "for i, column in enumerate(df_g_plog.columns):\n",
    "    plt.bar(index + i * bar_width, df_g_plog[column], bar_width, label=column, color=colors[i], edgecolor='black', alpha=0.7, hatch=hatches[i])\n",
    "\n",
    "plt.title(\"Fairness Reward Test\", fontsize=20)  # Larger title font size\n",
    "plt.xlabel(\"Number of Nodes\", fontsize=20)  # Larger x-label font size\n",
    "plt.ylabel(\"Reward g Value\", fontsize=20)  # Larger y-label font size\n",
    "plt.xticks(index + bar_width * len(df_g_plog.columns) / 2, df_g_plog.index, fontsize=12)  # Larger x-ticks font size\n",
    "plt.yticks(fontsize=12)  # Larger y-ticks font size\n",
    "plt.legend(loc='center left', bbox_to_anchor=(1, 0.5), fontsize=14)  # Larger legend font size\n",
    "plt.tight_layout()\n",
    "plt.savefig('test-average-g.pdf', bbox_inches='tight')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.0 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.8.0"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "0e2adeafa4d8ea8b56364dfeb24ca99374007784e59d4b40ac8f07b769210312"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}