rl_Visualization.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#-------------------------------------------------------------------------------------------------------------------------------\n",
    "# IMPORT PACKAGES\n",
    "#-------------------------------------------------------------------------------------------------------------------------------\n",
    "%matplotlib inline\n",
    "\n",
    "import numpy as np\n",
    "import os\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "import pandas as pd\n",
    "from matplotlib.pyplot import cm\n",
    "from tqdm import tnrange, tqdm_notebook\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#-------------------------------------------------------------------------------------------------------------------------------\n",
    "# Functions\n",
    "#-------------------------------------------------------------------------------------------------------------------------------\n",
    "def moving_average(numbers, window_size):\n",
    "    i = 0\n",
    "    moving_averages = []\n",
    "    while i < len(numbers) - window_size + 1:\n",
    "        this_window = numbers[i : i + window_size]\n",
    "\n",
    "        window_average = sum(this_window) / window_size\n",
    "        moving_averages.append(window_average)\n",
    "        i += 1\n",
    "    return moving_averages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "FileNotFoundError",
     "evalue": "[Errno 2] No such file or directory: 'C:/Users/Michael Dawson/Documents/Github/Research/rl_loop/2021-12-13--20-08-18/test_params.csv'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
      "Input \u001b[0;32mIn [3]\u001b[0m, in \u001b[0;36m<cell line: 35>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     32\u001b[0m path \u001b[38;5;241m=\u001b[39m os\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39mjoin(parent_directory,program_name,sub_directory)\n\u001b[1;32m     34\u001b[0m \u001b[38;5;66;03m# Read in test parameters\u001b[39;00m\n\u001b[0;32m---> 35\u001b[0m test_params \u001b[38;5;241m=\u001b[39m \u001b[43mpd\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mread_csv\u001b[49m\u001b[43m(\u001b[49m\u001b[43mos\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpath\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mjoin\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpath\u001b[49m\u001b[43m,\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtest_params.csv\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43mindex_col\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m     37\u001b[0m \u001b[38;5;66;03m# Read in data from CSV into Pandas Dataframe\u001b[39;00m\n\u001b[1;32m     38\u001b[0m metadata \u001b[38;5;241m=\u001b[39m pd\u001b[38;5;241m.\u001b[39mread_csv(os\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39mjoin(path,\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmetadata.csv\u001b[39m\u001b[38;5;124m\"\u001b[39m),index_col\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m)\n",
      "File \u001b[0;32m~/Jupyter/lib/python3.8/site-packages/pandas/util/_decorators.py:311\u001b[0m, in \u001b[0;36mdeprecate_nonkeyword_arguments.<locals>.decorate.<locals>.wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    305\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(args) \u001b[38;5;241m>\u001b[39m num_allow_args:\n\u001b[1;32m    306\u001b[0m     warnings\u001b[38;5;241m.\u001b[39mwarn(\n\u001b[1;32m    307\u001b[0m         msg\u001b[38;5;241m.\u001b[39mformat(arguments\u001b[38;5;241m=\u001b[39marguments),\n\u001b[1;32m    308\u001b[0m         \u001b[38;5;167;01mFutureWarning\u001b[39;00m,\n\u001b[1;32m    309\u001b[0m         stacklevel\u001b[38;5;241m=\u001b[39mstacklevel,\n\u001b[1;32m    310\u001b[0m     )\n\u001b[0;32m--> 311\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m~/Jupyter/lib/python3.8/site-packages/pandas/io/parsers/readers.py:680\u001b[0m, in \u001b[0;36mread_csv\u001b[0;34m(filepath_or_buffer, sep, delimiter, header, names, index_col, usecols, squeeze, prefix, mangle_dupe_cols, dtype, engine, converters, true_values, false_values, skipinitialspace, skiprows, skipfooter, nrows, na_values, keep_default_na, na_filter, verbose, skip_blank_lines, parse_dates, infer_datetime_format, keep_date_col, date_parser, dayfirst, cache_dates, iterator, chunksize, compression, thousands, decimal, lineterminator, quotechar, quoting, doublequote, escapechar, comment, encoding, encoding_errors, dialect, error_bad_lines, warn_bad_lines, on_bad_lines, delim_whitespace, low_memory, memory_map, float_precision, storage_options)\u001b[0m\n\u001b[1;32m    665\u001b[0m kwds_defaults \u001b[38;5;241m=\u001b[39m _refine_defaults_read(\n\u001b[1;32m    666\u001b[0m     dialect,\n\u001b[1;32m    667\u001b[0m     delimiter,\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    676\u001b[0m     defaults\u001b[38;5;241m=\u001b[39m{\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdelimiter\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m,\u001b[39m\u001b[38;5;124m\"\u001b[39m},\n\u001b[1;32m    677\u001b[0m )\n\u001b[1;32m    678\u001b[0m kwds\u001b[38;5;241m.\u001b[39mupdate(kwds_defaults)\n\u001b[0;32m--> 680\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_read\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilepath_or_buffer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m~/Jupyter/lib/python3.8/site-packages/pandas/io/parsers/readers.py:575\u001b[0m, in \u001b[0;36m_read\u001b[0;34m(filepath_or_buffer, kwds)\u001b[0m\n\u001b[1;32m    572\u001b[0m _validate_names(kwds\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnames\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m))\n\u001b[1;32m    574\u001b[0m \u001b[38;5;66;03m# Create the parser.\u001b[39;00m\n\u001b[0;32m--> 575\u001b[0m parser \u001b[38;5;241m=\u001b[39m \u001b[43mTextFileReader\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilepath_or_buffer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    577\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m chunksize \u001b[38;5;129;01mor\u001b[39;00m iterator:\n\u001b[1;32m    578\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m parser\n",
      "File \u001b[0;32m~/Jupyter/lib/python3.8/site-packages/pandas/io/parsers/readers.py:933\u001b[0m, in \u001b[0;36mTextFileReader.__init__\u001b[0;34m(self, f, engine, **kwds)\u001b[0m\n\u001b[1;32m    930\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moptions[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhas_index_names\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m kwds[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhas_index_names\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[1;32m    932\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles: IOHandles \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m--> 933\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_engine \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_make_engine\u001b[49m\u001b[43m(\u001b[49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mengine\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m~/Jupyter/lib/python3.8/site-packages/pandas/io/parsers/readers.py:1217\u001b[0m, in \u001b[0;36mTextFileReader._make_engine\u001b[0;34m(self, f, engine)\u001b[0m\n\u001b[1;32m   1213\u001b[0m     mode \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mrb\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m   1214\u001b[0m \u001b[38;5;66;03m# error: No overload variant of \"get_handle\" matches argument types\u001b[39;00m\n\u001b[1;32m   1215\u001b[0m \u001b[38;5;66;03m# \"Union[str, PathLike[str], ReadCsvBuffer[bytes], ReadCsvBuffer[str]]\"\u001b[39;00m\n\u001b[1;32m   1216\u001b[0m \u001b[38;5;66;03m# , \"str\", \"bool\", \"Any\", \"Any\", \"Any\", \"Any\", \"Any\"\u001b[39;00m\n\u001b[0;32m-> 1217\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles \u001b[38;5;241m=\u001b[39m \u001b[43mget_handle\u001b[49m\u001b[43m(\u001b[49m\u001b[43m  \u001b[49m\u001b[38;5;66;43;03m# type: ignore[call-overload]\u001b[39;49;00m\n\u001b[1;32m   1218\u001b[0m \u001b[43m    \u001b[49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1219\u001b[0m \u001b[43m    \u001b[49m\u001b[43mmode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1220\u001b[0m \u001b[43m    \u001b[49m\u001b[43mencoding\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mencoding\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1221\u001b[0m \u001b[43m    \u001b[49m\u001b[43mcompression\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mcompression\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1222\u001b[0m \u001b[43m    \u001b[49m\u001b[43mmemory_map\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmemory_map\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1223\u001b[0m \u001b[43m    \u001b[49m\u001b[43mis_text\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mis_text\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1224\u001b[0m \u001b[43m    \u001b[49m\u001b[43merrors\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mencoding_errors\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mstrict\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1225\u001b[0m \u001b[43m    \u001b[49m\u001b[43mstorage_options\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mstorage_options\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1226\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1227\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m   1228\u001b[0m f \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles\u001b[38;5;241m.\u001b[39mhandle\n",
      "File \u001b[0;32m~/Jupyter/lib/python3.8/site-packages/pandas/io/common.py:789\u001b[0m, in \u001b[0;36mget_handle\u001b[0;34m(path_or_buf, mode, encoding, compression, memory_map, is_text, errors, storage_options)\u001b[0m\n\u001b[1;32m    784\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(handle, \u001b[38;5;28mstr\u001b[39m):\n\u001b[1;32m    785\u001b[0m     \u001b[38;5;66;03m# Check whether the filename is to be opened in binary mode.\u001b[39;00m\n\u001b[1;32m    786\u001b[0m     \u001b[38;5;66;03m# Binary mode does not support 'encoding' and 'newline'.\u001b[39;00m\n\u001b[1;32m    787\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m ioargs\u001b[38;5;241m.\u001b[39mencoding \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m ioargs\u001b[38;5;241m.\u001b[39mmode:\n\u001b[1;32m    788\u001b[0m         \u001b[38;5;66;03m# Encoding\u001b[39;00m\n\u001b[0;32m--> 789\u001b[0m         handle \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mopen\u001b[39;49m\u001b[43m(\u001b[49m\n\u001b[1;32m    790\u001b[0m \u001b[43m            \u001b[49m\u001b[43mhandle\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    791\u001b[0m \u001b[43m            \u001b[49m\u001b[43mioargs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    792\u001b[0m \u001b[43m            \u001b[49m\u001b[43mencoding\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mioargs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mencoding\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    793\u001b[0m \u001b[43m            \u001b[49m\u001b[43merrors\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43merrors\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    794\u001b[0m \u001b[43m            \u001b[49m\u001b[43mnewline\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m    795\u001b[0m \u001b[43m        \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    796\u001b[0m     \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    797\u001b[0m         \u001b[38;5;66;03m# Binary mode\u001b[39;00m\n\u001b[1;32m    798\u001b[0m         handle \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mopen\u001b[39m(handle, ioargs\u001b[38;5;241m.\u001b[39mmode)\n",
      "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'C:/Users/Michael Dawson/Documents/Github/Research/rl_loop/2021-12-13--20-08-18/test_params.csv'"
     ]
    }
   ],
   "source": [
    "#-------------------------------------------------------------------------------------------------------------------------------\n",
    "# LOGISTICS\n",
    "#-------------------------------------------------------------------------------------------------------------------------------\n",
    "# Define parts of file location\n",
    "parent_directory = 'C:/Users/Michael Dawson/Documents/Github/Research'\n",
    "program_name = \"rl_loop\"\n",
    "# sub_directory = '2021-11-23--23-27-54'\n",
    "# sub_directory = '2021-11-24--08-57-57'\n",
    "# sub_directory = '2021-11-24--12-46-57'\n",
    "# sub_directory = '2021-11-27--11-57-32'\n",
    "# sub_directory = '2021-12-03--18-04-01'\n",
    "# sub_directory = '2021-12-11--09-48-52'\n",
    "# sub_directory = '2021-12-12--16-18-14'\n",
    "# sub_directory = '2021-12-12--18-14-52'\n",
    "# sub_directory = '2021-12-12--18-47-11'\n",
    "# sub_directory = '2021-12-12--19-17-45'\n",
    "# sub_directory = '2021-12-12--19-48-36'\n",
    "# sub_directory = '2021-12-12--21-05-11'\n",
    "# sub_directory = '2021-12-12--22-27-03' #good\n",
    "# sub_directory = '2021-12-12--22-45-58'\n",
    "# sub_directory = '2021-12-13--16-29-41' #verif\n",
    "# sub_directory = '2021-12-13--17-51-24' #new train?\n",
    "# sub_directory = '2021-12-13--18-38-18'\n",
    "# sub_directory = '2021-12-13--19-42-12'\n",
    "sub_directory = '2021-12-13--20-08-18' #actually good train\n",
    "# sub_directory = '2021-12-13--20-23-38'\n",
    "# sub_directory = '2021-12-13--20-39-02' #verify\n",
    "# sub_directory = '2021-12-13--21-00-28' #incep verify\n",
    "\n",
    "\n",
    "# Combine parts of file location\n",
    "path = os.path.join(parent_directory,program_name,sub_directory)\n",
    "\n",
    "# Read in test parameters\n",
    "test_params = pd.read_csv(os.path.join(path,\"test_params.csv\"),index_col=0)\n",
    "\n",
    "# Read in data from CSV into Pandas Dataframe\n",
    "metadata = pd.read_csv(os.path.join(path,\"metadata.csv\"),index_col=0)\n",
    "\n",
    "# Read in q table\n",
    "q_table = pd.read_csv(os.path.join(path,\"q_table.csv\"),index_col=0)\n",
    "\n",
    "# Read in data from testing spreadsheet\n",
    "df = {}\n",
    "for i in tnrange(0,len(metadata.index),leave=False):\n",
    "    df[i] = pd.read_excel(os.path.join(path,\"data.xlsx\"),index_col=0,sheet_name=\"Test{}\".format(i+1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#-------------------------------------------------------------------------------------------------------------------------------\n",
    "# Settings\n",
    "#-------------------------------------------------------------------------------------------------------------------------------\n",
    "threshold = test_params['threshold'].tolist()[0]\n",
    "moving_average_window = test_params['moving_average_window'].tolist()[0]\n",
    "end_of_detections = test_params['stop'].tolist()[0]\n",
    "start_temp = test_params['start_temp'].tolist()[0]\n",
    "net = test_params['net'].tolist()[0]\n",
    "\n",
    "if net==1: net='MobileNetV1-SSD'\n",
    "if net==2: net='MobileNetV1-PPN'\n",
    "if net==3: net='MobileNetV2-SSD'\n",
    "if net==4: net='InceptionV2-SSD'\n",
    "\n",
    "numberOfGoalAdjustmentVariants = len(pd.unique(metadata['all_la_records']))\n",
    "numberOfInitialGoalVariants = len(pd.unique(metadata['all_ll_records']))\n",
    "\n",
    "plt.style.use('default')\n",
    "matplotlib.rcParams['mathtext.fontset'] = 'stix'\n",
    "matplotlib.rcParams['font.family'] = 'STIXGeneral'\n",
    "matplotlib.rcParams['font.size'] = 16\n",
    "plt.rcParams['figure.dpi'] = 100\n",
    "\n",
    "colors = cm.plasma(np.linspace(0, 1, len(metadata['all_la_records'])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "# #-------------------------------------------------------------------------------------------------------------------------------\n",
    "# # SUMMARY STATISTICS AND GRAPHS\n",
    "# #-------------------------------------------------------------------------------------------------------------------------------\n",
    "# # Plot all temps vs time in grid plot\n",
    "# fig, axs = plt.subplots(nrows=numberOfInitialGoalVariants,ncols=numberOfGoalAdjustmentVariants, sharey='row', sharex='col')\n",
    "# fig.set_figwidth(numberOfGoalAdjustmentVariants*8)\n",
    "# fig.set_figheight(numberOfInitialGoalVariants*5)\n",
    "# fig.set_dpi(200)\n",
    "# for i in tnrange(0,numberOfInitialGoalVariants,desc='lg',leave=False) :\n",
    "#     for j in tnrange(0, numberOfGoalAdjustmentVariants,desc='la',leave=False) :\n",
    "#         iterator = j+i*numberOfGoalAdjustmentVariants        \n",
    "#         color = colors[iterator]\n",
    "#         working_df = df[iterator]\n",
    "#         length = len(working_df['temps'])\n",
    "\n",
    "#         graphing_times = np.linspace(working_df['times_loopLength'][0],\n",
    "#                                      working_df['times_loopLength'][length-1],\n",
    "#                                      int(working_df['times_loopLength'][length-1]))\n",
    "#         graphing_times = graphing_times.tolist()\n",
    "#         graphing_temp = []\n",
    "#         graphing_temp.append(0)\n",
    "#         for x in working_df['times_loopLength']:\n",
    "#             for y in graphing_times:\n",
    "#                 if x >= y and y > graphing_times[len(graphing_temp)-1]:\n",
    "#                     graphing_times_index = graphing_times.index(y)\n",
    "#                     temp_time_index = working_df.index[working_df['times_loopLength']==x].tolist()        \n",
    "#                     graphing_temp.append(working_df['temps'][temp_time_index[0]])\n",
    "                    \n",
    "#         axs[i,j].step(working_df['times_temp'],\n",
    "#                               working_df['temps'],\n",
    "#                               label=\"CPU Temperature\",\n",
    "#                               color=color,\n",
    "#                               alpha=0.5\n",
    "#                              )\n",
    "        \n",
    "#         m_a_x = range(math.floor(moving_average_window/2),math.floor(moving_average_window/2)+\n",
    "#                       len(moving_average(graphing_temp,moving_average_window)))\n",
    "#         m_a_y = moving_average(graphing_temp,moving_average_window)\n",
    "#         axs[i,j].plot(m_a_x,m_a_y,     \n",
    "#                                   color=color,\n",
    "#                                   alpha=1,\n",
    "#                                   label= '{} Second Average'.format(moving_average_window)\n",
    "#                                  )\n",
    "        \n",
    "# #         axs[i,j].step(working_df['times_temp'],\n",
    "# #                       working_df['temps2']/10,\n",
    "# #                       label=\"GPU Temperature\",\n",
    "# #                       color='green',\n",
    "# #                       alpha=0.5,\n",
    "# #                       zorder=100\n",
    "# #                      )\n",
    "\n",
    "#         axs[i,j].legend(loc='lower right')\n",
    "#         axs[i,j].set_ylim([40,90])\n",
    "\n",
    "# #             for x in switch_record:\n",
    "# #                 \n",
    "# #                 if net_record[times_temp.index(x)] == 1 :\n",
    "# #                     axs[0].axvline(x-0.2, color='r')\n",
    "# #                     axs[0].text(x + 0.2,5,net_1_name,rotation=90)\n",
    "# #                 if net_record[times_temp.index(x)] == 2 :\n",
    "# #                     axs[0].axvline(x-0.2, color='c')\n",
    "# #                     axs[0].text(x + 0.2,5,net_2_name,rotation=90)\n",
    "# #                 if net_record[times_temp.index(x)] == 3 :\n",
    "# #                     axs[0].axvline(x-0.2, color='m')\n",
    "# #                     axs[0].text(x + 0.2,5,net_3_name,rotation=90)\n",
    "# #                 if net_record[times_temp.index(x)] == 4 :\n",
    "# #                     axs[0].axvline(x-0.2, color='y')\n",
    "# #                     axs[0].text(x + 0.2,5,net_4_name,rotation=90)\n",
    "                \n",
    "#         axs[i,j].axhline(y=threshold, color='red',alpha=0.3)\n",
    "#         axs[i,j].axhline(y=start_temp, color='red',alpha=0.3)\n",
    "#         axs[i,j].axvline(end_of_detections, color='red',alpha=0.3)\n",
    "# #         axs[i,j].text(end_of_detections+1,5,'End Detections',rotation=90,color='k')\n",
    "\n",
    "\n",
    "#         if j == 0 : axs[i,j].set_ylabel('Temperature [$^\\circ$C]' + \" ; $lg$: \" + \n",
    "#                                         str(metadata['all_ll_records'][iterator]))\n",
    "#         if i == numberOfInitialGoalVariants-1: axs[i,j].set_xlabel('Time [s] ; $la$: {}'.format(\n",
    "#                                                                    metadata['all_la_records'][iterator]))\n",
    "        \n",
    "#         axs[i,j].grid()\n",
    "\n",
    "# # Save plot\n",
    "# plot3_path = os.path.join(path, \"All_Temps_net_{}.png\".format(net))\n",
    "# plt.savefig(plot3_path,bbox_inches=\"tight\",dpi=400)\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# metadata['all_la_records'][iterator]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "#---------- Plot tri-plot for all tests ----------\n",
    "# Temp\n",
    "fig, axs = plt.subplots(nrows=3,ncols=1, sharey='row', sharex='col')\n",
    "fig.set_figwidth(16)\n",
    "fig.set_figheight(16)\n",
    "temp = []\n",
    "for i in tnrange(0,numberOfInitialGoalVariants,leave=False, desc='lg') :\n",
    "    for j in tnrange(0, numberOfGoalAdjustmentVariants,leave=False, desc='GAC') :\n",
    "        iterator=j+i*numberOfGoalAdjustmentVariants\n",
    "        color = colors[iterator]\n",
    "\n",
    "        working_df = df[iterator]\n",
    "        length = len(working_df['temps'])\n",
    "\n",
    "        graphing_times = np.linspace(working_df['times_loopLength'][0],\n",
    "             working_df['times_loopLength'][length-1], \n",
    "             int(working_df['times_loopLength'][length-1]))\n",
    "        graphing_times = graphing_times.tolist()\n",
    "        graphing_temp = []\n",
    "        graphing_temp.append(0)\n",
    "        for x in working_df['times_loopLength']:\n",
    "            for y in graphing_times:\n",
    "                if x >= y and y > graphing_times[len(graphing_temp)-1]:\n",
    "                    graphing_times_index = graphing_times.index(y)\n",
    "\n",
    "                    temp_time_index = working_df.index[working_df['times_loopLength']==x].tolist()\n",
    "                    graphing_temp.append(working_df['temps'][temp_time_index[0]])\n",
    "                    \n",
    "        axs[0].step(working_df['times_temp'],working_df['temps'], \n",
    "                    label=\"Test {}\".format(j+i*numberOfGoalAdjustmentVariants),\n",
    "                    color=color,\n",
    "                    alpha=0.5\n",
    "                   )\n",
    "        axs[0].plot(range(math.floor(moving_average_window/2),math.floor(moving_average_window/2) +\n",
    "                          len(moving_average(graphing_temp,moving_average_window))),\n",
    "                    moving_average(graphing_temp,moving_average_window),\n",
    "                    label= \"Test {}; {} Second Average\".format(j+i*numberOfGoalAdjustmentVariants+1,moving_average_window),\n",
    "                    color=color,\n",
    "                    alpha=1)\n",
    "\n",
    "        # Loops\n",
    "        graphing_loopLength = []\n",
    "        graphing_loopLength.append(0)\n",
    "        for x in working_df['times_loopLength']:\n",
    "            for y in graphing_times:\n",
    "                if x >= y and y > graphing_times[len(graphing_loopLength)-1]:\n",
    "                    graphing_times_index = graphing_times.index(y)\n",
    "                    loopLength_time_index = working_df.index[working_df['times_loopLength']==x].tolist()\n",
    "                    graphing_loopLength.append(working_df['loopLength_record'][loopLength_time_index[0]])\n",
    "\n",
    "        axs[1].step(working_df['times_loopLength'],\n",
    "                    working_df['loopLength_record'], \n",
    "                    color=color, \n",
    "                    alpha=0.5\n",
    "                   )\n",
    "        axs[1].step(working_df['times_loopLength'],\n",
    "                    working_df['loopLength_goal'], \n",
    "                    alpha=0.3,\n",
    "                    color=color\n",
    "                   )\n",
    "        axs[1].plot(range(math.floor(moving_average_window/2),math.floor(moving_average_window/2)+\n",
    "                          len(moving_average(graphing_loopLength,moving_average_window))),\n",
    "                    moving_average(graphing_loopLength,moving_average_window), \n",
    "                    color=color,\n",
    "                    alpha=1\n",
    "                   )   \n",
    "        \n",
    "        # CPU\n",
    "        graphing_cpu = []\n",
    "        graphing_cpu.append(0)\n",
    "        for x in working_df['times_loopLength']:\n",
    "            for y in graphing_times:\n",
    "                if x >= y and y > graphing_times[len(graphing_cpu)-1]:\n",
    "                    graphing_times_index = graphing_times.index(y)\n",
    "                    cpu_time_index = working_df.index[working_df['times_loopLength']==x].tolist()\n",
    "                    graphing_cpu.append(working_df['cpu_record'][cpu_time_index[0]])\n",
    "\n",
    "        axs[2].step(working_df['times_temp'],working_df['cpu_record'],color=color,alpha=0.5)\n",
    "        axs[2].plot(range(math.floor(moving_average_window/2),math.floor(moving_average_window/2)+\n",
    "            len(moving_average(graphing_cpu,moving_average_window))),\n",
    "            moving_average(graphing_cpu,moving_average_window), color=color, alpha=1)\n",
    "\n",
    "        \n",
    "        \n",
    "#             for x in switch_record:\n",
    "#                 \n",
    "#                 if net_record[times_temp.index(x)] == 1 :\n",
    "#                     axs[0].axvline(x-0.2, color='r')\n",
    "#                     axs[0].text(x + 0.2,5,net_1_name,rotation=90)\n",
    "#                 if net_record[times_temp.index(x)] == 2 :\n",
    "#                     axs[0].axvline(x-0.2, color='c')\n",
    "#                     axs[0].text(x + 0.2,5,net_2_name,rotation=90)\n",
    "#                 if net_record[times_temp.index(x)] == 3 :\n",
    "#                     axs[0].axvline(x-0.2, color='m')\n",
    "#                     axs[0].text(x + 0.2,5,net_3_name,rotation=90)\n",
    "#                 if net_record[times_temp.index(x)] == 4 :\n",
    "#                     axs[0].axvline(x-0.2, color='y')\n",
    "#                     axs[0].text(x + 0.2,5,net_4_name,rotation=90)\n",
    "\n",
    "axs[0].set_ylim([40,90])\n",
    "axs[0].axhline(y=start_temp, color='red',alpha=0.3)\n",
    "axs[0].axhline(y=threshold, color='red',alpha=0.3)\n",
    "axs[0].axvline(end_of_detections, color='red',alpha=0.3)\n",
    "axs[0].set_ylabel('Temperature [$^\\circ$C]')\n",
    "axs[0].set_title('Temperature (Network: {})'.format(net))\n",
    "axs[0].grid()\n",
    "\n",
    "axs[1].set_ylim([0,5])        \n",
    "axs[1].set_ylabel('Loop Length [s]')\n",
    "axs[1].set_title('Loop Length (Network: {})'.format(net))\n",
    "axs[1].grid()\n",
    "\n",
    "axs[2].set_ylim([0,100])        \n",
    "axs[2].set_ylabel('CPU Usage [%]')\n",
    "axs[2].set_xlabel('Time [s]')\n",
    "axs[2].set_title('CPU Usage (Network: {})'.format(net))\n",
    "axs[2].grid()\n",
    "\n",
    "\n",
    "fig.legend(loc='center left', bbox_to_anchor=(0.9, 0.5))\n",
    "# axs[0].legend()\n",
    "\n",
    "# Save plot\n",
    "plot4_path = os.path.join(path, \"Combined_color_net_{}.png\".format(net))\n",
    "plt.savefig(plot4_path,bbox_inches=\"tight\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(10,6))\n",
    "plt.scatter(df[0]['times_temp'].tolist(),df[0]['action_record'].tolist())\n",
    "# fig = plt.figure(figsize=(10,6))\n",
    "# sns.histplot(df[0]['action_record'].tolist())\n",
    "# df[0]['action_record'].tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fig = plt.figure(figsize=(10,6))\n",
    "# sns.heatmap(qtable.pivot('Temperature','Loop Length',''))\n",
    "# q_table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (1873917840.py, line 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  Input \u001b[0;32mIn [4]\u001b[0;36m\u001b[0m\n\u001b[0;31m    for i in len(q_table)\u001b[0m\n\u001b[0m                         ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "# q_table['']\n",
    "vis_q_table = pd.DataFrame(q_table[['Temperature','Loop Length']])\n",
    "for i in len(q_table)\n",
    "    if q_table[['Linear Up','Linear Down','Linear','Nothing']].max(axis=1) == q_table[['Linear Up','Linear Down','Linear','Nothing']].min(axis=1)\n",
    "    q_table = q_table.replace([])\n",
    "vis_q_table['Action'] = q_table[['Linear Up','Linear Down','Linear','Nothing']].idxmax(axis=1)\n",
    "vis_q_table = vis_q_table.replace(['Linear Up','Linear Down','Linear','Nothing'],[1,2,3,4])\n",
    "# print(vis_q_table)\n",
    "sns.heatmap(vis_q_table.pivot('Temperature','Loop Length','Action'))\n",
    "policy_map_path = os.path.join(path, \"policy_map.png\")\n",
    "plt.savefig(policy_map_path,bbox_inches=\"tight\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean_cpu = []\n",
    "mean_loopLength_record = []\n",
    "mean_temp = []\n",
    "temp_error = []\n",
    "first_temp = []\n",
    "for i in tnrange(0,numberOfInitialGoalVariants,leave=False) :\n",
    "    for j in tnrange(0, numberOfGoalAdjustmentVariants,leave=False) :\n",
    "        iterator = j+i*numberOfGoalAdjustmentVariants\n",
    "        working_df = df[iterator]\n",
    "        mean_cpu.append(working_df['cpu_record'].mean())\n",
    "        mean_loopLength_record.append(working_df['loopLength_record'].mean())\n",
    "        mean_temp.append(working_df['temps'].mean())\n",
    "        temp_error.append((working_df['temps'].sub(threshold)).pow(2).mean())\n",
    "#         first_temp.append(working_df['temps'][0])\n",
    "        \n",
    "mean_record = {'mean_cpu':mean_cpu,\n",
    "               'mean_loopLength_record':mean_loopLength_record,\n",
    "               'mean_temp':mean_temp,\n",
    "               'temp_error':temp_error,\n",
    "#                'first_temp':first_temp\n",
    "              }\n",
    "mean_record_df = pd.DataFrame.from_dict(mean_record)\n",
    "means_and_meta_df = metadata.join(mean_record_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sns.histplot(data=means_and_meta_df, x=\"first_temp\", kde=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# matplotlib.rcParams['font.size'] = 16\n",
    "\n",
    "# from mpl_toolkits.mplot3d import Axes3D\n",
    "\n",
    "# fig = plt.figure(figsize=(6,6))\n",
    "# ax = plt.axes(projection='3d')\n",
    "\n",
    "# x = metadata['all_ll_records']\n",
    "# y = metadata['all_la_records']\n",
    "# z = means_and_meta_df['mean_temp']\n",
    "\n",
    "# ax.scatter3D(x,y,z,c=z,cmap='plasma',linewidth=0.5)\n",
    "# ax.set_xlabel('$lg$')\n",
    "# ax.set_ylabel('$la$')\n",
    "# ax.set_zlabel('Mean Temperature [$^\\circ$C]')\n",
    "# plt.xticks(np.linspace(0, max(x), numberOfInitialGoalVariants))\n",
    "# plt.yticks(np.linspace(0, max(y), numberOfGoalAdjustmentVariants))\n",
    "\n",
    "# plot5_path = os.path.join(path, \"scatter_net_{}.png\".format(net))\n",
    "# plt.savefig(plot5_path,bbox_inches=\"tight\",dpi=400)\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fig = plt.figure(figsize=(6,6))\n",
    "\n",
    "# ax = plt.axes(projection='3d')\n",
    "# ax.plot_trisurf(x, y, z,cmap='plasma', edgecolor='none')\n",
    "# ax.set_xlabel('$lg$')\n",
    "# ax.set_ylabel('$la$')\n",
    "# ax.set_zlabel('Mean Temperature [$^\\circ$ C]')\n",
    "# plt.xticks(np.linspace(0, max(x), numberOfInitialGoalVariants))\n",
    "# plt.yticks(np.linspace(0, max(y), numberOfGoalAdjustmentVariants))\n",
    "# ax.view_init(30, -30)\n",
    "\n",
    "\n",
    "# plot6_path = os.path.join(path, \"topology_net_{}.png\".format(net))\n",
    "# plt.savefig(plot6_path,bbox_inches=\"tight\",dpi=400)\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "index = means_and_meta_df['temp_error'].idxmin()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# #---------- Plot tri-plot for all tests ----------\n",
    "\n",
    "# # Temp\n",
    "# fig, axs = plt.subplots(nrows=3,ncols=1, sharey='row', sharex='col')\n",
    "# fig.set_figwidth(16)\n",
    "# fig.set_figheight(16)\n",
    "# temp = []\n",
    "# for i in tnrange(0,numberOfInitialGoalVariants,leave=False) :\n",
    "#     for j in tnrange(0, numberOfGoalAdjustmentVariants,leave=False) :\n",
    "#         iterator = j+i*numberOfGoalAdjustmentVariants\n",
    "#         zorder = iterator\n",
    "        \n",
    "#         if iterator == 10 :\n",
    "#             color = 'blue'\n",
    "#             zorder = 1000\n",
    "#         else :\n",
    "#             color = 'gray'\n",
    "\n",
    "#         working_df = df[iterator]\n",
    "#         length = len(working_df['temps'])\n",
    "\n",
    "#         graphing_times = np.linspace(working_df['times_loopLength'][0],\n",
    "#                                      working_df['times_loopLength'][length-1], \n",
    "#                                      int(working_df['times_loopLength'][length-1]))\n",
    "#         graphing_times = graphing_times.tolist()\n",
    "#         graphing_temp = []\n",
    "#         graphing_temp.append(0)\n",
    "#         for x in working_df['times_loopLength']:\n",
    "#             for y in graphing_times:\n",
    "#                 if x >= y and y > graphing_times[len(graphing_temp)-1]:\n",
    "#                     graphing_times_index = graphing_times.index(y)\n",
    "\n",
    "#                     temp_time_index = working_df.index[working_df['times_loopLength']==x].tolist()\n",
    "#                     graphing_temp.append(working_df['temps'][temp_time_index[0]])\n",
    "                    \n",
    "#         axs[0].step(working_df['times_temp'],working_df['temps'], \n",
    "#                     label=\"Test {} ; GAC: {} ; $lg$: {}\".format(\n",
    "#                         iterator+1,\n",
    "#                         metadata['all_la_records'][iterator],\n",
    "#                         metadata['all_ll_records'][iterator]),\n",
    "#                     color=color,\n",
    "#                     alpha=0.3,\n",
    "#                     zorder=zorder\n",
    "#                    )\n",
    "#         axs[0].plot(range(math.floor(moving_average_window/2),math.floor(moving_average_window/2)\n",
    "#                     + len(moving_average(graphing_temp,moving_average_window))),\n",
    "#                     moving_average(graphing_temp,moving_average_window),\n",
    "#                     color=color,\n",
    "#                     label= \"Test {} ; {} Second Average\".format(iterator+1,moving_average_window),\n",
    "#                     alpha=1,\n",
    "#                     zorder=zorder\n",
    "#                    )\n",
    "\n",
    "#         graphing_loopLength = []\n",
    "#         graphing_loopLength.append(0)\n",
    "#         for x in working_df['times_loopLength']:\n",
    "#             for y in graphing_times:\n",
    "#                 if x >= y and y > graphing_times[len(graphing_loopLength)-1]:\n",
    "#                     graphing_times_index = graphing_times.index(y)\n",
    "#                     loopLength_time_index = working_df.index[working_df['times_loopLength']==x].tolist()\n",
    "#                     graphing_loopLength.append(working_df['loopLength_record'][loopLength_time_index[0]])\n",
    "\n",
    "#         axs[1].step(working_df['times_loopLength'], working_df['loopLength_record'],\n",
    "#                     color=color, \n",
    "#                     alpha=0.5,\n",
    "#                     zorder=zorder\n",
    "#                    )\n",
    "#         axs[1].step(working_df['times_loopLength'], working_df['loopLength_goal'], \n",
    "#                     alpha=1,\n",
    "#                     color=color,\n",
    "#                     zorder=zorder\n",
    "#                    )\n",
    "# #         axs[1].plot(range(math.floor(moving_average_window/2),math.floor(moving_average_window/2)\n",
    "# #                           +len(moving_average(graphing_loopLength,moving_average_window))),\n",
    "# #                     moving_average(graphing_loopLength,moving_average_window), \n",
    "# #                     color=color,\n",
    "# #                     zorder=zorder,\n",
    "# #                     alpha=1\n",
    "# #                    )\n",
    "\n",
    "#         graphing_cpu = []\n",
    "#         graphing_cpu.append(0)\n",
    "#         for x in working_df['times_loopLength']:\n",
    "#             for y in graphing_times:\n",
    "#                 if x >= y and y > graphing_times[len(graphing_cpu)-1]:\n",
    "#                     graphing_times_index = graphing_times.index(y)\n",
    "#                     cpu_time_index = working_df.index[working_df['times_loopLength']==x].tolist()\n",
    "#                     graphing_cpu.append(working_df['cpu_record'][cpu_time_index[0]])\n",
    "\n",
    "#         axs[2].step(working_df['times_temp'],working_df['cpu_record'],\n",
    "#                     color=color,\n",
    "#                     alpha=0.3,\n",
    "#                     zorder=zorder\n",
    "#                    )\n",
    "#         axs[2].plot(range(math.floor(moving_average_window/2),math.floor(moving_average_window/2)+\n",
    "#                     len(moving_average(graphing_cpu,moving_average_window))),\n",
    "#                     moving_average(graphing_cpu,moving_average_window), \n",
    "#                     color=color, \n",
    "#                     alpha=1,\n",
    "#                     zorder=zorder\n",
    "#                    )\n",
    "\n",
    "\n",
    "# axs[0].set_ylim([40,90])\n",
    "# axs[0].axhline(y=start_temp, color='red',alpha=0.3)\n",
    "# axs[0].axhline(y=threshold, color='red',alpha=0.3)\n",
    "# axs[0].axvline(end_of_detections, color='red',alpha=0.3)\n",
    "# axs[0].text(end_of_detections+1,5,'End Detections',rotation=90,color='k')\n",
    "# axs[0].set_ylabel('Temperature [$^\\circ$C]')\n",
    "# axs[0].set_title('Temperature (Network: {})'.format(net))\n",
    "# axs[0].grid()\n",
    "\n",
    "# axs[1].set_ylim([0,3])        \n",
    "# axs[1].set_ylabel('Loop Length [s]')\n",
    "# axs[1].set_title('Loop Length (Network: {})'.format(net))\n",
    "# axs[1].grid()\n",
    "\n",
    "# axs[2].set_ylim([0,100])        \n",
    "# axs[2].set_ylabel('CPU Usage [%]')\n",
    "# axs[2].set_xlabel('Time [s]')\n",
    "# axs[2].set_title('CPU Usage (Network: {})'.format(net))\n",
    "# axs[2].grid()\n",
    "\n",
    "# # fig.legend(loc='center left', bbox_to_anchor=(0.9, 0.5))\n",
    "\n",
    "# # Save plot\n",
    "# plot7_path = os.path.join(path, \"Combined_gray_net_{}.png\".format(net))\n",
    "# plt.savefig(plot7_path,bbox_inches=\"tight\",dpi=400)\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from sklearn.decomposition import PCA\n",
    "# X = pd.DataFrame()\n",
    "# for i in tnrange(0,numberOfInitialGoalVariants,leave=False) :\n",
    "#     for j in tnrange(0, numberOfGoalAdjustmentVariants,leave=False) :\n",
    "#         working_df = df[iterator]\n",
    "#         length = len(working_df['temps'])\n",
    "#         q = pd.DataFrame(working_df.mean())        \n",
    "#         X = X.append(q.T,ignore_index=True)\n",
    "        \n",
    "# from sklearn import preprocessing\n",
    "# data_scaled = pd.DataFrame(preprocessing.scale(X),columns = X.columns) \n",
    "# pca = PCA(n_components=4)\n",
    "# pca.fit_transform(X)\n",
    "\n",
    "# # Dump components relations with features:\n",
    "# # print(pd.DataFrame(pca.components_,columns=data_scaled.columns,index = ['PC-1','PC-2','PC-3','PC-4']))\n",
    "\n",
    "# fig = plt.figure()\n",
    "# PC_values = np.linspace(1,pca.n_components_,pca.n_components,endpoint=True)\n",
    "# plt.plot(PC_values, pca.explained_variance_ratio_, 'ro-', linewidth=2)\n",
    "# plt.title('Scree Plot (Network: {})'.format(net))\n",
    "# plt.xlabel('Principal Component')\n",
    "# plt.ylabel('Proportion of Variance Explained')\n",
    "\n",
    "# plot8_path = os.path.join(path, \"scree_net_{}.png\".format(net))\n",
    "# plt.savefig(plot8_path,bbox_inches=\"tight\",dpi=400)\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sns.heatmap(means_and_meta_df.corr())\n",
    "# plot9_path = os.path.join(path, \"mean_corr_heatmap_net_{}.png\".format(net))\n",
    "# plt.savefig(plot9_path,bbox_inches=\"tight\",dpi=400)\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# means_and_meta_df['results'] = 10* (1/means_and_meta_df['mean_loopLength_record']) * 1/(means_and_meta_df[\"mean_cpu\"]/100) \n",
    "# # means_and_meta_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# matplotlib.rcParams['font.size'] = 12\n",
    "\n",
    "# pivoted = means_and_meta_df.pivot('all_la_records','all_ll_records','results')\n",
    "# pivoted = pivoted.T\n",
    "# axs = plt.axes()\n",
    "# sns.heatmap(pivoted,\n",
    "#             annot=True,\n",
    "#             cmap='plasma',\n",
    "#             fmt='.4g',\n",
    "#             cbar_kws={'label': '(10x) FPS per fraction of CPU use ',\"orientation\": \"horizontal\"}\n",
    "#            )\n",
    "# axs.set_title('Image Processing Efficiency (Network: {})'.format(net))\n",
    "# axs.set_ylabel('Initial Loop Length [s]')\n",
    "# axs.set_xlabel('Loop Length Adjustment Coef. [s/$^\\circ$C]')\n",
    "# plot10_path = os.path.join(path, \"results_net_{}.png\".format(net))\n",
    "# plt.savefig(plot10_path,bbox_inches=\"tight\",dpi=400)\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#---------- Plot tri-plot for all tests ----------\n",
    "colors = cm.plasma(np.linspace(0, 1, 4))\n",
    "# Temp\n",
    "fig, axs = plt.subplots(nrows=1,ncols=1, sharey='row', sharex='col')\n",
    "fig.set_figwidth(6)\n",
    "fig.set_figheight(4)\n",
    "temp = []\n",
    "count = 0\n",
    "for i in tnrange(0,1,leave=False) :\n",
    "    for j in tnrange(0,1,leave=False) :\n",
    "# for i in tnrange(0,1,leave=False) :\n",
    "#     for j in tnrange(0,1,leave=False) :\n",
    "        iterator = j+i*numberOfGoalAdjustmentVariants\n",
    "        zorder = iterator\n",
    "        color = colors[count]\n",
    "\n",
    "        working_df = df[iterator]\n",
    "        length = len(working_df['temps'])\n",
    "\n",
    "        graphing_times = np.linspace(working_df['times_loopLength'][0],\n",
    "                                     working_df['times_loopLength'][length-1], \n",
    "                                     int(working_df['times_loopLength'][length-1]))\n",
    "        graphing_times = graphing_times.tolist()\n",
    "        graphing_temp = []\n",
    "        graphing_temp.append(0)\n",
    "        for x in working_df['times_loopLength']:\n",
    "            for y in graphing_times:\n",
    "                if x >= y and y > graphing_times[len(graphing_temp)-1]:\n",
    "                    graphing_times_index = graphing_times.index(y)\n",
    "\n",
    "                    temp_time_index = working_df.index[working_df['times_loopLength']==x].tolist()\n",
    "                    graphing_temp.append(working_df['temps'][temp_time_index[0]])\n",
    "                    \n",
    "        axs.step(working_df['times_temp'],working_df['temps'], \n",
    "#                     label=\"Test {} ; $la$: {} ; $lg$: {}\".format(\n",
    "#                         iterator+1,\n",
    "#                         metadata['all_la_records'][iterator],\n",
    "#                         metadata['all_ll_records'][iterator]),\n",
    "                    color=color,\n",
    "                    alpha=0.3,\n",
    "                    zorder=zorder\n",
    "                   )\n",
    "        axs.plot(range(math.floor(moving_average_window/2),math.floor(moving_average_window/2)\n",
    "                    + len(moving_average(graphing_temp,moving_average_window))),\n",
    "                    moving_average(graphing_temp,moving_average_window),\n",
    "                    color=color,\n",
    "#                     label= \"Test {} ; {} Second Average\".format(iterator+1,moving_average_window),\n",
    "                    label=\"Test {}\".format(\n",
    "                        iterator+1),                    \n",
    "                    alpha=1,\n",
    "                    zorder=zorder\n",
    "                   )\n",
    "        count += 1\n",
    "\n",
    "axs.set_ylim([50,90])\n",
    "axs.axhline(y=threshold, color='red',alpha=0.3,label='Desired Temperature')\n",
    "# axs.text(end_of_detections+1,5,'End Detections',rotation=90,color='k')\n",
    "axs.set_ylabel('Temperature [$^\\circ$C]')\n",
    "axs.set_title('{} Temperature'.format(net))\n",
    "axs.grid()\n",
    "axs.legend(loc='lower center', bbox_to_anchor=(0.5, -0.5))\n",
    "\n",
    "axs.set_xlabel('Time [s]')\n",
    "\n",
    "\n",
    "\n",
    "# Save plot\n",
    "plot11_path = os.path.join(path, \"TempEffectOfMetareasoning_net_{}.png\".format(net))\n",
    "plt.savefig(plot11_path,bbox_inches=\"tight\",dpi=400)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "colors = cm.plasma(np.linspace(0, 1, 4))\n",
    "fig, axs = plt.subplots(nrows=1,ncols=1, sharey='row', sharex='col')\n",
    "fig.set_figwidth(6)\n",
    "fig.set_figheight(4)\n",
    "temp = []\n",
    "count = 0\n",
    "for i in tnrange(0,1,leave=False) :\n",
    "    for j in tnrange(0,1,leave=False) :\n",
    "        \n",
    "        iterator = j+i*numberOfGoalAdjustmentVariants\n",
    "        zorder = iterator\n",
    "        color = colors[count]\n",
    "\n",
    "        working_df = df[iterator]\n",
    "        length = len(working_df['temps'])\n",
    "        \n",
    "        graphing_loopLength = []\n",
    "        graphing_loopLength.append(0)\n",
    "        for x in working_df['times_loopLength']:\n",
    "            for y in graphing_times:\n",
    "                if x >= y and y > graphing_times[len(graphing_loopLength)-1]:\n",
    "                    graphing_times_index = graphing_times.index(y)\n",
    "                    loopLength_time_index = working_df.index[working_df['times_loopLength']==x].tolist()\n",
    "                    graphing_loopLength.append(working_df['loopLength_record'][loopLength_time_index[0]])\n",
    "\n",
    "        axs.step(working_df['times_loopLength'], working_df['loopLength_record'],\n",
    "                    color=color, \n",
    "                    alpha=1,\n",
    "                    zorder=zorder,\n",
    "                    label=\"Test {}\".format(\n",
    "                        iterator+1),\n",
    "                   )\n",
    "        axs.step(working_df['times_loopLength'], working_df['pause_time_record'], \n",
    "                    alpha=0.5,\n",
    "                    color=color,\n",
    "                    zorder=zorder,\n",
    "                    label= \"Test {}; Pause Length\".format(iterator+1),\n",
    "                   )        \n",
    "        count +=1\n",
    "        \n",
    "# axs[1].set_ylim([0,3])        \n",
    "axs.set_ylabel('Loop Duration [s]')\n",
    "axs.set_title('{} Loop Duration'.format(net))\n",
    "axs.grid()\n",
    "axs.set_xlabel('Time [s]')\n",
    "axs.legend(loc='lower center', bbox_to_anchor=(0.5, -0.5))\n",
    "\n",
    "# Save plot\n",
    "plot12_path = os.path.join(path, \"LoopEffectOfMetareasoning_net_{}.png\".format(net))\n",
    "plt.savefig(plot12_path,bbox_inches=\"tight\",dpi=400)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "colors = cm.plasma(np.linspace(0, 1, 4))\n",
    "fig, axs = plt.subplots(nrows=1,ncols=1, sharey='row', sharex='col')\n",
    "fig.set_figwidth(6)\n",
    "fig.set_figheight(4)\n",
    "temp = []\n",
    "count = 0\n",
    "for i in tnrange(0,1,leave=False) :\n",
    "    for j in tnrange(0,1,leave=False) :\n",
    "        iterator = j+i*numberOfGoalAdjustmentVariants\n",
    "        zorder = iterator\n",
    "        color = colors[count]\n",
    "\n",
    "        working_df = df[iterator]\n",
    "        length = len(working_df['temps'])\n",
    "        \n",
    "        graphing_cpu = []\n",
    "        graphing_cpu.append(0)\n",
    "        for x in working_df['times_loopLength']:\n",
    "            for y in graphing_times:\n",
    "                if x >= y and y > graphing_times[len(graphing_cpu)-1]:\n",
    "                    graphing_times_index = graphing_times.index(y)\n",
    "                    cpu_time_index = working_df.index[working_df['times_loopLength']==x].tolist()\n",
    "                    graphing_cpu.append(working_df['cpu_record'][cpu_time_index[0]])\n",
    "\n",
    "        axs.step(working_df['times_temp'],working_df['cpu_record'],\n",
    "                    color=color,\n",
    "                    alpha=0.3,\n",
    "                    zorder=zorder,\n",
    "#                     label=\"Test {} ; $la$: {} ; $lg$: {}\".format(\n",
    "#                         iterator+1,\n",
    "#                         metadata['all_la_records'][iterator],\n",
    "#                         metadata['all_ll_records'][iterator]),\n",
    "                   )\n",
    "        axs.plot(range(math.floor(moving_average_window/2),math.floor(moving_average_window/2)+\n",
    "                    len(moving_average(graphing_cpu,moving_average_window))),\n",
    "                    moving_average(graphing_cpu,moving_average_window), \n",
    "                    color=color, \n",
    "                    alpha=1,\n",
    "                    zorder=zorder,\n",
    "#                     label= \"Test {} ; {} Second Average\".format(iterator+1,moving_average_window),\n",
    "                    label=\"Test {}\".format(\n",
    "                        iterator+1),                    \n",
    "                   )\n",
    "        count += 1\n",
    "        \n",
    "axs.set_ylim([0,100])        \n",
    "axs.set_ylabel('CPU Usage [%]')\n",
    "axs.set_xlabel('Time [s]')\n",
    "axs.set_title('{} CPU Usage'.format(net))\n",
    "axs.grid()\n",
    "axs.legend(loc='lower center', bbox_to_anchor=(0.5, -0.8))\n",
    "\n",
    "# Save plot\n",
    "plot13_path = os.path.join(path, \"CPUEffectOfMetareasoning_net_{}.png\".format(net))\n",
    "plt.savefig(plot13_path,bbox_inches=\"tight\",dpi=400)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import mean_squared_error\n",
    "# mask = means_and_meta_df['all_la_records']>0\n",
    "X = means_and_meta_df[['all_la_records','all_ll_records']].to_numpy()\n",
    "y = means_and_meta_df['temp_error'].to_numpy()\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "     X, y, test_size=0.4, random_state=3)\n",
    "\n",
    "reg = LinearRegression().fit(X_train, y_train)\n",
    "\n",
    "matplotlib.rcParams['font.size'] = 16\n",
    "fig = plt.figure(figsize=(6,6))\n",
    "ax = plt.axes(projection='3d')\n",
    "x = X_train[:,0]\n",
    "y = X_train[:,1]\n",
    "z = y_train\n",
    "ax.scatter3D(x,y,z,c='blue',s=50,label='Train')\n",
    "x = X_test[:,0]\n",
    "y = X_test[:,1]\n",
    "z = y_test\n",
    "ax.scatter3D(x,y,z,c='red',s=50,label='Test')\n",
    "# plt.xticks(np.linspace(0, max(x), numberOfInitialGoalVariants))\n",
    "# plt.yticks(np.linspace(0, max(y), numberOfGoalAdjustmentVariants))\n",
    "\n",
    "\n",
    "x = np.linspace(0,0.1,5)\n",
    "y = np.linspace(0,2,5)\n",
    "xx, yy = np.meshgrid(x,y)\n",
    "X_working = np.hstack([xx.flatten().reshape(-1,1),yy.flatten().reshape(-1,1)])\n",
    "z = reg.predict(X_working)\n",
    "ax.scatter3D(xx,yy,z,label='Predict',color='green')\n",
    "\n",
    "ax.set_ylabel('lg')\n",
    "ax.set_xlabel('la')\n",
    "ax.set_zlabel('Temperature Error [($^\\circ$C)$^2$]')\n",
    "plt.legend()\n",
    "plt.show()\n",
    "\n",
    "print(\"Train MSE: {}\".format(mean_squared_error(y_train,reg.predict(X_train))))\n",
    "print(\"Test MSE: {}\".format(mean_squared_error(y_test,reg.predict(X_test))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import LinearRegression\n",
    "df_mask=df[2]['times_temp']>=100\n",
    "X = df[2][df_mask]['times_temp'].to_numpy().reshape(-1,1).astype(np.float32)\n",
    "X_train = np.hstack([X,np.exp(-X)])\n",
    "y = df[2][df_mask]['cpu_record'].to_numpy().astype(np.float32)\n",
    "reg = LinearRegression().fit(X_train, y/100)\n",
    "y_pred = reg.predict(X_train)\n",
    "\n",
    "pause = df[2][df_mask]['pause_time_record'].to_numpy().reshape(-1,1).astype(np.float32)\n",
    "# print(pause.flatten())\n",
    "# from scipy.integrate import odeint\n",
    "# def model(T,t):\n",
    "#     k1 = 0.025\n",
    "#     Tss = 80\n",
    "#     Tamb = 22\n",
    "#     dTdt = -k1 * (T - Tamb) + 1.55\n",
    "# #     d2Tdt2 = \n",
    "#     return dTdt\n",
    "\n",
    "# T0 = 50\n",
    "# t = X.flatten()\n",
    "# T = odeint(model,T0,t)\n",
    "\n",
    "# from scipy.integrate import odeint\n",
    "# def model(C,t):\n",
    "#     k1 = 0.8\n",
    "#     dCdt = -k1*(1/(t)) + 0.0025\n",
    "#     return dCdt\n",
    "\n",
    "# C0 = 0.9\n",
    "# t = X.flatten()\n",
    "# C= odeint(model,C0,t)\n",
    "\n",
    "# np.exp(-k*pause[i])\n",
    "\n",
    "# plt.plot(t,C,label='DEQ',c='green')\n",
    "plt.scatter(X,y/100,label='Data',c='red')\n",
    "plt.scatter(X,y_pred,label='LOBF')\n",
    "plt.legend() \n",
    "print(reg.coef_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "df_mask=df[0]['times_temp']<300\n",
    "X = df[0][df_mask]['times_temp'].to_numpy().reshape(-1,1).astype(np.float32)\n",
    "y = df[0][df_mask]['temps'].to_numpy().reshape(-1,1).astype(np.float32)\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "     X, y, test_size=0.4, random_state=0)\n",
    "\n",
    "# plt.scatter(X_train,y_train, label=\"Train\", c='Blue', s=20, edgecolors='none')\n",
    "# plt.scatter(X_test,y_test, label=\"Test\", c='Red', s=20, edgecolors='none')\n",
    "\n",
    "x = metadata['all_ll_records']\n",
    "y = metadata['all_la_records']\n",
    "z = means_and_meta_df['mean_temp']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Net(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size):\n",
    "        super(Net, self).__init__()  \n",
    "        # Fully-Connected Layer: 1 (input data) -> 5 (hidden node)\n",
    "        self.fc1 = nn.Linear(input_size, hidden_size)  \n",
    "        \n",
    "        # Non-Linear Layer\n",
    "        self.sigmoid1 = nn.Sigmoid()\n",
    "        # You can try other kinds as well\n",
    "        # self.relu = nn.ReLU()\n",
    "        # self.elu = nn.ELU()\n",
    "        \n",
    "        self.fc2 = nn.Linear(hidden_size,hidden_size)\n",
    "        self.sigmoid2 = nn.Sigmoid()\n",
    "        \n",
    "        # Fully-Connected Layer: 5 (hidden node) -> 1 (output)\n",
    "        self.fc3 = nn.Linear(hidden_size, 1) \n",
    "        \n",
    "    \n",
    "    # Forward pass builds the model prediction from the inputs\n",
    "    def forward(self, x):                              \n",
    "        out = self.fc1(x)\n",
    "        out = self.sigmoid1(out)\n",
    "        out = self.fc2(out)\n",
    "        out = self.sigmoid2(out)\n",
    "        out = self.fc3(out)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Build the network -- is it not trained yet\n",
    "model = Net(input_size=1, hidden_size=4)\n",
    "\n",
    "# What Loss function should we use? MSE!\n",
    "criterion = nn.MSELoss()\n",
    "\n",
    "# What Optimization procedure should we use?\n",
    "learning_rate = 0.05\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, weight_decay=0.001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Train the model\n",
    "\n",
    "# Convert numpy arrays to torch tensors\n",
    "inputs = torch.from_numpy(X_train)\n",
    "targets = torch.from_numpy(y_train)\n",
    "\n",
    "num_epochs = 5000\n",
    "for epoch in range(num_epochs):\n",
    "\n",
    "    ## Do Forward pass\n",
    "    # Make predictions\n",
    "    outputs = model(inputs)\n",
    "    # Compute the loss function\n",
    "    loss = criterion(outputs, targets)\n",
    "    \n",
    "    ## Update the model\n",
    "    # Reset the optimizer gradients\n",
    "    optimizer.zero_grad()\n",
    "    # Compute the gradient of the loss function\n",
    "    loss.backward()\n",
    "    # Do an optimization step\n",
    "    optimizer.step()\n",
    "    \n",
    "    # Print the loss\n",
    "    if (epoch+1) % 200 == 0:\n",
    "        print ('Epoch [{:4}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot the graph\n",
    "plt.scatter(X_train, y_train, label='Data',s=10)\n",
    "predicted = model(torch.from_numpy(np.linspace(0,300).reshape(-1,1).astype(np.float32))).detach().numpy()\n",
    "plt.plot(np.linspace(0,300), predicted, label='Prediction',color='orange')\n",
    "plt.legend(loc='lower right')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "a = np.arange(55,91,1)\n",
    "b = np.linspace(0,5,51)\n",
    "c = np.array(np.meshgrid(a, b)).T.reshape(-1,2)\n",
    "d = np.zeros((5,1)).repeat(len(c),1).T\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "round(0.74,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = np.array((0,10,20,30,40,50,60))\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y= int(np.where(z == max(z[2:5]))[0])\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rand = np.random.uniform(2,6)\n",
    "print(rand)\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "possibleTemps = np.arange(45,91,1)\n",
    "possibleLLs = np.around(np.linspace(0,5,51),1)\n",
    "states = np.array(np.meshgrid(possibleTemps, possibleLLs)).T.reshape(-1,2)\n",
    "print(states)\n",
    "actions = np.zeros((4,1)).repeat(len(states),1).T\n",
    "print(actions)\n",
    "q_table = np.hstack((states,actions))\n",
    "print(q_table)\n",
    "\n",
    "q_table_df = pd.DataFrame(q_table, columns = ['Temperature','Loop Length','Linear','Boosted Linear','Quadratic','Nothing'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q_table_df.iloc[(258)].tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stateID = [50, 0.3]\n",
    "q_row_index = q_table_df.index[(q_table_df['Temperature'] == 55.0) & (q_table_df['Loop Length'] == 0.3)].tolist()[0]\n",
    "print(q_row_index)\n",
    "q_row = q_table_df.iloc[[q_row_index]].to_numpy()[0]\n",
    "print(q_row)\n",
    "action = np.argwhere(q_row == np.max(q_row[2:]))[0][0] # 2, 3, 4, or 5 (because 0, 1 are state id)\n",
    "print(action)\n",
    "\n",
    "print(max(q_row[2:]))\n",
    "print(sum(q_row[2:]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "60995f486619ddad088d69c456fe48b82cf26db14cbc31a3a2043a057c51c38f"
  },
  "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.8.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}