test_pol_sb3.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sb_value_function_kwargs import fc_policy_kwargs, cnn_policy_kwargs, linear_policy_kwargs\n",
    "from environments.stable_baselines_env import StableBaselineEnv\n",
    "from environments.stable_baselines_env_linear import StableBaselineEnvLinear\n",
    "from environments.stable_baselines_env_linear_history import StableBaselineEnvLinearHistory\n",
    "from environments.stable_baselines_env_history import StableBaselineEnvHistory\n",
    "from stable_baselines3 import DQN, PPO\n",
    "from stable_baselines3.common.env_checker import check_env\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm import tqdm\n",
    "from scipy import stats"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Experiments 2 and 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'request_streams.mixed_ff_bad_wf_good.MixedFFBadWFGood'>\n",
      "Using cuda device\n",
      "Wrapping the env with a `Monitor` wrapper\n",
      "Wrapping the env in a DummyVecEnv.\n",
      "Box(0, 256, (1, 267), int32)\n",
      "{'policy_class': <class 'stable_baselines3.dqn.policies.DQNPolicy'>, 'device': device(type='cuda'), 'verbose': 1, 'policy_kwargs': {'activation_fn': <class 'torch.nn.modules.activation.ReLU'>, 'net_arch': [32, 32]}, 'num_timesteps': 0, '_total_timesteps': 0, '_num_timesteps_at_start': 0, 'seed': None, 'action_noise': None, 'start_time': 0.0, 'learning_rate': 0.0001, 'tensorboard_log': None, '_last_obs': None, '_last_episode_starts': None, '_last_original_obs': None, '_episode_num': 0, 'use_sde': False, 'sde_sample_freq': -1, '_current_progress_remaining': 1.0, '_stats_window_size': 100, 'ep_info_buffer': None, 'ep_success_buffer': None, '_n_updates': 0, '_custom_logger': False, 'env': <stable_baselines3.common.vec_env.dummy_vec_env.DummyVecEnv object at 0x000001C9E9897790>, '_vec_normalize_env': None, 'observation_space': Box(0, 256, (1, 267), int32), 'action_space': Discrete(3), 'n_envs': 1, 'buffer_size': 1000000, 'batch_size': 32, 'learning_starts': 100, 'tau': 1.0, 'gamma': 1, 'gradient_steps': 1, 'optimize_memory_usage': False, 'replay_buffer': <stable_baselines3.common.buffers.ReplayBuffer object at 0x000001C9E9897730>, 'replay_buffer_class': <class 'stable_baselines3.common.buffers.ReplayBuffer'>, 'replay_buffer_kwargs': {}, '_episode_storage': None, 'train_freq': TrainFreq(frequency=4, unit=<TrainFrequencyUnit.STEP: 'step'>), 'use_sde_at_warmup': False, 'exploration_initial_eps': 1.0, 'exploration_final_eps': 0.05, 'exploration_fraction': 0.1, 'target_update_interval': 10000, '_n_calls': 0, 'max_grad_norm': 10, 'exploration_rate': 0.0, 'lr_schedule': <function get_schedule_fn.<locals>.<lambda> at 0x000001C9AE929430>, 'policy': DQNPolicy(\n",
      "  (q_net): QNetwork(\n",
      "    (features_extractor): FlattenExtractor(\n",
      "      (flatten): Flatten(start_dim=1, end_dim=-1)\n",
      "    )\n",
      "    (q_net): Sequential(\n",
      "      (0): Linear(in_features=267, out_features=32, bias=True)\n",
      "      (1): ReLU()\n",
      "      (2): Linear(in_features=32, out_features=32, bias=True)\n",
      "      (3): ReLU()\n",
      "      (4): Linear(in_features=32, out_features=3, bias=True)\n",
      "    )\n",
      "  )\n",
      "  (q_net_target): QNetwork(\n",
      "    (features_extractor): FlattenExtractor(\n",
      "      (flatten): Flatten(start_dim=1, end_dim=-1)\n",
      "    )\n",
      "    (q_net): Sequential(\n",
      "      (0): Linear(in_features=267, out_features=32, bias=True)\n",
      "      (1): ReLU()\n",
      "      (2): Linear(in_features=32, out_features=32, bias=True)\n",
      "      (3): ReLU()\n",
      "      (4): Linear(in_features=32, out_features=3, bias=True)\n",
      "    )\n",
      "  )\n",
      "), 'q_net': QNetwork(\n",
      "  (features_extractor): FlattenExtractor(\n",
      "    (flatten): Flatten(start_dim=1, end_dim=-1)\n",
      "  )\n",
      "  (q_net): Sequential(\n",
      "    (0): Linear(in_features=267, out_features=32, bias=True)\n",
      "    (1): ReLU()\n",
      "    (2): Linear(in_features=32, out_features=32, bias=True)\n",
      "    (3): ReLU()\n",
      "    (4): Linear(in_features=32, out_features=3, bias=True)\n",
      "  )\n",
      "), 'q_net_target': QNetwork(\n",
      "  (features_extractor): FlattenExtractor(\n",
      "    (flatten): Flatten(start_dim=1, end_dim=-1)\n",
      "  )\n",
      "  (q_net): Sequential(\n",
      "    (0): Linear(in_features=267, out_features=32, bias=True)\n",
      "    (1): ReLU()\n",
      "    (2): Linear(in_features=32, out_features=32, bias=True)\n",
      "    (3): ReLU()\n",
      "    (4): Linear(in_features=32, out_features=3, bias=True)\n",
      "  )\n",
      "), 'batch_norm_stats': [], 'batch_norm_stats_target': [], 'exploration_schedule': <function get_linear_fn.<locals>.func at 0x000001C9E9893820>}\n"
     ]
    }
   ],
   "source": [
    "\n",
    "#Note ff_bad is the same as bf_good\n",
    "\n",
    "\n",
    "\n",
    "# #experiment 2 graph a\n",
    "# policy_kwargs = fc_policy_kwargs\n",
    "# history_len = 0\n",
    "# allocator_name = \"wf_good\"\n",
    "# net_name = \"fc\"\n",
    "# env = StableBaselineEnvHistory(allocator=allocator_name, page_size=256, history_len=history_len)\n",
    "# model = DQN(\"MlpPolicy\", env, verbose=1, policy_kwargs=policy_kwargs, learning_rate=0.0001, device=\"cuda\", gamma=1)\n",
    "\n",
    "# #experiment 2 graph b \n",
    "# policy_kwargs = linear_policy_kwargs\n",
    "# history_len = 0\n",
    "# allocator_name = \"wf_good\"\n",
    "# net_name = \"linear\"\n",
    "# env = StableBaselineEnvLinearHistory(allocator=allocator_name, page_size=256, history_len=history_len)\n",
    "# model = DQN(\"MlpPolicy\", env, verbose=1, policy_kwargs=policy_kwargs, learning_rate=0.0001, device=\"cuda\", gamma=1)\n",
    "\n",
    "\n",
    "#Note ff_bad is the same as bf_good\n",
    "\n",
    "#experiment 2 graph c\n",
    "# policy_kwargs = fc_policy_kwargs\n",
    "# history_len = 0\n",
    "# allocator_name = \"ff_bad\"\n",
    "# net_name = \"fc\"\n",
    "# env = StableBaselineEnvHistory(allocator=allocator_name, page_size=256, history_len=history_len)\n",
    "# model = DQN(\"MlpPolicy\", env, verbose=1, policy_kwargs=policy_kwargs, learning_rate=0.0001, device=\"cuda\", gamma=1)\n",
    "\n",
    "# #experiment 2 graph d\n",
    "\n",
    "# policy_kwargs = linear_policy_kwargs\n",
    "# history_len = 0\n",
    "# allocator_name = \"ff_bad\"\n",
    "# net_name = \"linear\"\n",
    "# env = StableBaselineEnvLinearHistory(allocator=allocator_name, page_size=256, history_len=history_len)\n",
    "# model = DQN(\"MlpPolicy\", env, verbose=1, policy_kwargs=policy_kwargs, learning_rate=0.0001, device=\"cuda\", gamma=1)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# #experiment 3 graph a\n",
    "policy_kwargs = fc_policy_kwargs\n",
    "history_len = 10\n",
    "allocator_name = \"mixed_ff_bad_wf_good\"\n",
    "net_name = \"fc\"\n",
    "env = StableBaselineEnvHistory(allocator=allocator_name, page_size=256, history_len=history_len)\n",
    "model = DQN(\"MlpPolicy\", env, verbose=1, policy_kwargs=policy_kwargs, learning_rate=0.0001, device=\"cuda\", gamma=1)\n",
    "\n",
    "# # experiment 3 graph b\n",
    "\n",
    "# policy_kwargs = linear_policy_kwargs\n",
    "# history_len = 10\n",
    "# allocator_name = \"mixed_ff_bad_wf_good\"\n",
    "# net_name = \"linear\"\n",
    "# env = StableBaselineEnvLinearHistory(allocator=allocator_name, page_size=256, history_len=history_len)\n",
    "# model = DQN(\"MlpPolicy\", env, verbose=1, policy_kwargs=policy_kwargs, learning_rate=0.0001, device=\"cuda\", gamma=1)\n",
    "\n",
    "\n",
    "#model attributes\n",
    "print(env.observation_space)\n",
    "print(model.__dict__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mean_confidence_interval(data, confidence=0.95):\n",
    "    n = data.shape[0]\n",
    "    mean, std_err = np.mean(data), np.std(data) / np.sqrt(n)\n",
    "    interval = std_err * stats.t.ppf((1 + confidence) / 2, n - 1)\n",
    "    return mean - interval, mean + interval, mean"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Training & Rollout of policy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "63a3b5640c114bdcad912b14fbc315c0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using cuda device\n",
      "Wrapping the env with a `Monitor` wrapper\n",
      "Wrapping the env in a DummyVecEnv.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\lawso\\AppData\\Local\\Programs\\Python\\Python38\\lib\\site-packages\\stable_baselines3\\common\\buffers.py:241: UserWarning: This system does not have apparently enough memory to store the complete replay buffer 2.15GB > 1.97GB\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 99%|█████████▉| 99/100 [00:19<00:00,  5.04it/s]"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2608a520e4bc483194f53c264278cbf0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\lawso\\AppData\\Local\\Programs\\Python\\Python38\\lib\\site-packages\\stable_baselines3\\common\\buffers.py:241: UserWarning: This system does not have apparently enough memory to store the complete replay buffer 2.15GB > 1.20GB\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20.63200000000005\n",
      "Using cuda device\n",
      "Wrapping the env with a `Monitor` wrapper\n",
      "Wrapping the env in a DummyVecEnv.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [02:24<00:00,  1.45s/it]\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4828fe19ec874a3fac0e1eeb0fe8fd3b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\lawso\\AppData\\Local\\Programs\\Python\\Python38\\lib\\site-packages\\stable_baselines3\\common\\buffers.py:241: UserWarning: This system does not have apparently enough memory to store the complete replay buffer 2.15GB > 0.96GB\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20.387000000000043\n",
      "Using cuda device\n",
      "Wrapping the env with a `Monitor` wrapper\n",
      "Wrapping the env in a DummyVecEnv.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [03:29<00:00,  2.09s/it]\n",
      "100%|██████████| 100/100 [00:29<00:00,  2.65it/s]"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f0d5eed693e4478a8947b3baf4fe8b8f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "19.30300000000005\n",
      "Using cuda device\n",
      "Wrapping the env with a `Monitor` wrapper\n",
      "Wrapping the env in a DummyVecEnv.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [02:59<00:00,  1.79s/it]\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fda5a5c083494da1a85e9c639426df39",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "19.009000000000057\n",
      "Using cuda device\n",
      "Wrapping the env with a `Monitor` wrapper\n",
      "Wrapping the env in a DummyVecEnv.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [02:37<00:00,  1.57s/it]\n",
      "100%|██████████| 100/100 [00:27<00:00,  5.44it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20.410000000000043\n",
      "Model confidence interval: [19.12987526 20.76652474 19.9482    ]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "([<matplotlib.axis.XTick at 0x1ca50aeaf70>,\n",
       "  <matplotlib.axis.XTick at 0x1ca50aeaf40>,\n",
       "  <matplotlib.axis.XTick at 0x1ca50aeaa30>],\n",
       " [Text(0, 0, 'best fit'), Text(1, 0, 'worst fit'), Text(2, 0, 'first fit')])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "avg_return_per_session = []\n",
    "action_counts_per_session = []\n",
    "training_steps = 50000\n",
    "for train_and_rollout in range(5):\n",
    "    model = DQN(\"MlpPolicy\", env, verbose=1, policy_kwargs=policy_kwargs, learning_rate=0.0001, device=\"cuda\", gamma=1)\n",
    "    model.learn(total_timesteps=training_steps, log_interval=training_steps, progress_bar=True)\n",
    "    num_actions = 3\n",
    "    obs, info = env.reset()\n",
    "    i = 0\n",
    "    rewards = []\n",
    "    curr_reward = 0\n",
    "    action_counts = [0] * num_actions\n",
    "    total=100\n",
    "    pbar = tqdm(total = total)\n",
    "    while i < total:\n",
    "        action, _states = model.predict(obs, deterministic=True)\n",
    "        action_counts[action] += 1\n",
    "        #print(action)\n",
    "        obs, reward, terminated, truncated, info = env.step(action)\n",
    "        if reward != .1 and reward != 0:\n",
    "            print(reward)\n",
    "        #print(reward != 1)\n",
    "        curr_reward += reward\n",
    "        if terminated or truncated:\n",
    "            pbar.update(1)\n",
    "            obs, info = env.reset()\n",
    "            i += 1\n",
    "            rewards.append(curr_reward)\n",
    "            curr_reward = 0\n",
    "\n",
    "    print(np.mean(rewards))\n",
    "    avg_return_per_session.append(np.mean(rewards))\n",
    "    action_counts_per_session.append(action_counts)\n",
    "\n",
    "model_conf_int = mean_confidence_interval(np.array(avg_return_per_session))\n",
    "model_conf_int = np.array(model_conf_int)\n",
    "\n",
    "print(f\"Model confidence interval: {model_conf_int}\")\n",
    "\n",
    "action_counts_per_session = np.array(action_counts_per_session)\n",
    "action_counts_per_session = np.sum(action_counts_per_session, axis=0)\n",
    "action_counts_per_session = action_counts_per_session / np.sum(action_counts_per_session)\n",
    "\n",
    "plt.bar(np.arange(3), action_counts_per_session)\n",
    "plt.title(f\"High-level action frequences of using {net_name} network and history len {history_len} on {allocator_name} allocator\")\n",
    "plt.xticks(np.arange(3), [\"best fit\", \"worst fit\", \"first fit\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Baselines (best fit, worst fit, first fit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 3/3 [00:02<00:00,  1.02it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(4.373565959132608, 8.154434040867418, 6.264000000000013), (4.672393394244692, 8.24560660575533, 6.459000000000011), (0.9139149527580862, 1.1280850472419142, 1.0210000000000001)]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "conf_ints_baselines = []\n",
    "for allocator in tqdm(range(3)):\n",
    "    obs, info = env.reset()\n",
    "    i = 0\n",
    "    rewards = []\n",
    "    curr_reward = 0\n",
    "    while i < 100:\n",
    "        #action, _states = model.predict(obs, deterministic=True)\n",
    "        #print(action)\n",
    "        obs, reward, terminated, truncated, info = env.step(allocator)\n",
    "        if reward != .1 and reward != 0:\n",
    "            print(reward)\n",
    "        #print(reward != 1)\n",
    "        curr_reward += reward\n",
    "        if terminated or truncated:\n",
    "            obs, info = env.reset()\n",
    "            i += 1\n",
    "            rewards.append(curr_reward)\n",
    "            curr_reward = 0\n",
    "\n",
    "    #print(allocator, mean_confidence_interval(np.array(rewards)))\n",
    "\n",
    "    conf_ints_baselines.append(mean_confidence_interval(np.array(rewards)))\n",
    "\n",
    "print(conf_ints_baselines)\n",
    "conf_ints_baselines = np.array(conf_ints_baselines)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#create a bar graph with the confidence intervals\n",
    "import os\n",
    "all_conf_ints = np.vstack((model_conf_int, conf_ints_baselines))\n",
    "\n",
    "plt.bar(x=np.arange(4), height=all_conf_ints[:,2], yerr=all_conf_ints[:, 2] - all_conf_ints[:, 0])\n",
    "plt.title(f\"Average return over 100 episodes for \\\"{allocator_name}\\\" alloc sequences \\n with 95% confidence intervals, using {net_name} network and history len {history_len} \\n {training_steps} training steps\")\n",
    "plt.xticks(np.arange(4), [\"our policy\", \"best fit\", \"worst fit\", \"first fit\"])\n",
    "\n",
    "out_dir = f\"results/{allocator_name}\"\n",
    "os.makedirs(out_dir, exist_ok=True)\n",
    "plt.ylim(top=max(all_conf_ints[:,1]) + 5)\n",
    "plt.savefig(os.path.join(out_dir, f\"{allocator_name}_{net_name}_{history_len}_{training_steps}.png\"), bbox_inches = \"tight\")\n",
    "np.savetxt(os.path.join(out_dir, f\"{allocator_name}_{net_name}_{history_len}_{training_steps}.txt\"), all_conf_ints) #in order of model, best fit, worst fit, first fit"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.17"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}