vnf_web.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.simplefilter(action='ignore', category=FutureWarning)\n",
    "\n",
    "import os\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import joblib\n",
    "import time\n",
    "\n",
    "from sklearn.base import BaseEstimator\n",
    "from sklearn.model_selection import KFold, train_test_split, cross_val_score, GridSearchCV\n",
    "from sklearn.linear_model import LinearRegression, Ridge\n",
    "from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor\n",
    "from sklearn.svm import SVR\n",
    "from sklearn.neural_network import MLPRegressor\n",
    "from sklearn.preprocessing import LabelEncoder, StandardScaler, PolynomialFeatures\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.metrics import mean_squared_error\n",
    "\n",
    "sns.set(font_scale=1.1, style='white')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "class FixedModel(BaseEstimator):\n",
    "    \"\"\"\n",
    "    sklearn model of the fixed model, \n",
    "    always allocating/predicting a fixed, pre-defined amount of resources.\n",
    "    For use in sklearn functions like k-fold CV\n",
    "    \"\"\"\n",
    "    def __init__(self, fixed_value):\n",
    "        self.fixed_value = fixed_value\n",
    "        \n",
    "    def fit(self, X, y):\n",
    "        \"\"\"There's nothing to fit here\"\"\"\n",
    "        return self\n",
    "    \n",
    "    def predict(self, X):\n",
    "        \"\"\"Always 'predict' the specified fixed value\"\"\"\n",
    "        n_samples = X.shape[0]\n",
    "        return [self.fixed_value for _ in range(n_samples)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function for processing and simplifying the dataset\n",
    "def select_and_rename(df, mapping):\n",
    "    \"\"\"\n",
    "    Helper: Selects columns of df using the keys of the mapping dict.\n",
    "    It renames the columns to the values of the mappings dict.\n",
    "    \"\"\"\n",
    "    # select subset of columns\n",
    "    dff = df[list(mapping.keys())]\n",
    "    # rename \n",
    "    for k, v in mapping.items():\n",
    "        dff.rename(columns={k: v}, inplace=True)\n",
    "    return dff\n",
    "\n",
    "def replaceSize(df):\n",
    "    df[\"size\"] = df[\"size\"].str.replace(\"ab -c 1 -t 60 -n 99999999 -e /tngbench_share/ab_dist.csv -s 60 -k -i http://20.0.0.254:8888/\", \"small\")\n",
    "    df[\"size\"] = df[\"size\"].str.replace(\"ab -c 1 -t 60 -n 99999999 -e /tngbench_share/ab_dist.csv -s 60 -k http://20.0.0.254:8888/bunny.mp4\", \"big\")\n",
    "    df[\"size\"] = df[\"size\"].str.replace(\"ab -c 1 -t 60 -n 99999999 -e /tngbench_share/ab_dist.csv -s 60 -k -i -X 20.0.0.254:3128 http://40.0.0.254:80/\", \"small\")\n",
    "    df[\"size\"] = df[\"size\"].str.replace(\"ab -c 1 -t 60 -n 99999999 -e /tngbench_share/ab_dist.csv -s 60 -k -X 20.0.0.254:3128 http://40.0.0.254:80/bunny.mp4\", \"big\")\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\stefan\\git-repos\\work\\ai\\venv\\lib\\site-packages\\pandas\\core\\frame.py:4133: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  errors=errors,\n"
     ]
    }
   ],
   "source": [
    "# Load data from path\n",
    "web1 = pd.read_csv(\"vnf_data/csv_experiments_WEB1.csv\")\n",
    "web2 = pd.read_csv(\"vnf_data/csv_experiments_WEB2.csv\")\n",
    "web3 = pd.read_csv(\"vnf_data/csv_experiments_WEB3.csv\")\n",
    "\n",
    "# do processing, renaming and selection\n",
    "mapping = {\n",
    "    \"param__func__mp.input__cmd_start\": \"size\",\n",
    "    \"metric__mp.input.vdu01.0__ab_transfer_rate_kbyte_per_second\": \"Max. throughput [kB/s]\",\n",
    "}\n",
    "\n",
    "mapping01 = mapping.copy()\n",
    "mapping01[\"param__func__de.upb.lb-nginx.0.1__cpu_bw\"] = \"CPU\"\n",
    "mapping01[\"param__func__de.upb.lb-nginx.0.1__mem_max\"] = \"Memory\"\n",
    "\n",
    "mapping02 = mapping.copy()\n",
    "mapping02[\"param__func__de.upb.lb-haproxy.0.1__cpu_bw\"] = \"CPU\"\n",
    "mapping02[\"param__func__de.upb.lb-haproxy.0.1__mem_max\"] = \"Memory\"\n",
    "\n",
    "mapping03 = mapping.copy()\n",
    "mapping03[\"param__func__de.upb.px-squid.0.1__cpu_bw\"] = \"CPU\"\n",
    "mapping03[\"param__func__de.upb.px-squid.0.1__mem_max\"] = \"Memory\"\n",
    "\n",
    "web1 = select_and_rename(web1, mapping01)\n",
    "web2 = select_and_rename(web2, mapping02)\n",
    "web3 = select_and_rename(web3, mapping03)\n",
    "\n",
    "web1 = replaceSize(web1)\n",
    "web2 = replaceSize(web2)\n",
    "web3 = replaceSize(web3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# select sub-datasets with small and large flows\n",
    "# and with specific memory\n",
    "mem = 128\n",
    "\n",
    "web1_small = web1.loc[(web1[\"size\"] == \"small\") & (web1[\"Memory\"] == mem)]\n",
    "web1_small = web1_small[[\"Max. throughput [kB/s]\", \"CPU\"]]\n",
    "web1_big = web1.loc[(web1[\"size\"] == \"big\")  & (web1[\"Memory\"] == mem)]\n",
    "web1_big = web1_big[[\"Max. throughput [kB/s]\", \"CPU\"]]\n",
    "\n",
    "web2_small = web2.loc[(web2[\"size\"] == \"small\")  & (web2[\"Memory\"] == mem)]\n",
    "web2_small = web2_small[[\"Max. throughput [kB/s]\", \"CPU\"]]\n",
    "web2_big = web2.loc[(web2[\"size\"] == \"big\")  & (web2[\"Memory\"] == mem)]\n",
    "web2_big = web2_big[[\"Max. throughput [kB/s]\", \"CPU\"]]\n",
    "\n",
    "web3_small = web3.loc[(web3[\"size\"] == \"small\")  & (web3[\"Memory\"] == mem)]\n",
    "web3_small = web3_small[[\"Max. throughput [kB/s]\", \"CPU\"]]\n",
    "web3_big = web3.loc[(web3[\"size\"] == \"big\")  & (web3[\"Memory\"] == mem)]\n",
    "web3_big = web3_big[[\"Max. throughput [kB/s]\", \"CPU\"]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": "(20, 2)"
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 20 measurements per CPU config from 0.1 to 1.0\n",
    "web1_small[web1_small[\"CPU\"] == 0.5].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add 20 \"measurements\" at 0 CPU and throuhgput\n",
    "num_measures = 20\n",
    "measures = [0 for _ in range(num_measures)]\n",
    "\n",
    "web1_small = web1_small.append(pd.DataFrame({'Max. throughput [kB/s]': measures, 'CPU': measures}), ignore_index=True)\n",
    "web1_big = web1_big.append(pd.DataFrame({'Max. throughput [kB/s]': measures, 'CPU': measures}), ignore_index=True)\n",
    "web2_small = web2_small.append(pd.DataFrame({'Max. throughput [kB/s]': measures, 'CPU': measures}), ignore_index=True)\n",
    "web2_big = web2_big.append(pd.DataFrame({'Max. throughput [kB/s]': measures, 'CPU': measures}), ignore_index=True)\n",
    "web3_small = web3_small.append(pd.DataFrame({'Max. throughput [kB/s]': measures, 'CPU': measures}), ignore_index=True)\n",
    "web3_big = web3_big.append(pd.DataFrame({'Max. throughput [kB/s]': measures, 'CPU': measures}), ignore_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# rename\n",
    "nginx = web1_small\n",
    "haproxy = web2_small\n",
    "squid = web3_small"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY0AAAETCAYAAADKy1riAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3XlcVGX///HXrAwIueCOIriX2g1Igmi5liJquWXd6q1Zaa5ppSaapuWSd5l3hd3p7TfLun+paZm7ubVoZChu3ZlboogruIAwMMv5/UFzYgBxVGZY/DwfDx9yrnNmznUGmDfnXGeuj0ZRFAUhhBDCBdqS7oAQQoiyQ0JDCCGEyyQ0hBBCuExCQwghhMskNIQQQrhMQkMIIYTLJDSEEEK4TEJDCCGEyyQ0hBBCuExCQwghhMv0Jd2B4mA2mzl8+DDVqlVDp9OVdHeEEKJMsNlsXLp0iebNm2MymVx6TLkIjcOHDzNgwICS7oYQQpRJn3/+OeHh4S5tWy5Co1q1akDugdesWbOEeyOEEGXD+fPnGTBggPoe6opyERqOS1I1a9akTp06JdwbIYQoW27nsr4MhAshhHCZhIYQQgiXSWgIIYRwmYSGEEIIl5WLgfCiWCwWkpOTMZvNJd2Vcs1kMlGnTh0MBkNJd0UI4UblPjSSk5Px8/MjKCgIjUZT0t0plxRFITU1leTkZIKDg0u6O0IINyr3l6fMZjP+/v4SGG6k0Wjw9/eXszlxT1AU5ab/2+12AOx2OzabDZvNprbn5OSo7YqiYLPZsNvt2O12FEVR/+XfT2nj0TONJUuWkJSUxMyZMwusu3DhAhMnTuTgwYPUq1ePefPm0bhx42LZrwSG+8lrXPalLJuG+fSvBdpNgc2oPajg7+y9aMXhdWTmZOJt8CbLksU/Qvry6f4v8TF4s+3kLuyKnVq+1TmWdgoNoNVo8TF4cz07HTu5IaBBQ/3KgSRdSUbRKFQw+JBjt1DHryaNqtangtGHfs1i+CRxJT5GH55s3r1kDzofj4SGxWLhww8/5MMPP6Rfv36FbvPaa68REhLC4sWLWb58OZMnT2bVqlWe6J4QQtySoihk5mSy4dgOgirV4dTVZP536RinriYTWDGAK+ZrANywZGFTbH8+yEZOtsX5eVA4cSXJscD1nAwAjl9J4viVJKIbdWDpvhVsPL6TyJpRxK3czy+/nedKeg46DSjk/pEWXMuPrJzc/fR8uAFdWwd54mXwzOWpOXPmcPjwYfr371/o+oyMDHbv3s2wYcMwGo0MGjSICxcucOLECU90r8QkJyfTpEkTvv76a6f21atX8+yzzxb52JiYGA4ePOjO7ol7RMqyaZyc1afQswwA8+lfOTmrDynLpnm4Z6WLRqNhcGg/ujXqwKmryQDq/6evnaVrw/bUqxiA1W69q/1sPLZDDYwfN1RkU3wSqdeysdsVLDYFq03BYrVz9Mw1zlzI4MyFDOK+PMCmn07d5RG6xiOhMWLECBYtWoS/v3+h60+fPo2/vz8VKlRQ2wIDA8t9aDjMmTOH1NTU23rM+vXrefDBB93UIyFEYRzBUZhnwp7krcdii21fdSytsFhdH9fYfTCl2PZdFI+Exq0mw8rMzCwwLa/JZCIrK8ud3SoVjEYjrVu3LnScx2az8cYbbxAeHk6PHj2YPXs2r776KgAdO3Zk//79/PzzzwwYMICJEycSGhpKz549OXz4MABjx45l0qRJAFy8eJGIiAgSExM9d3CiTKg9aCb1p6zCFNis0PWmwGbUn7JKxjXIvUT1SeLKQtd9vG8Fk7bMLrZ9JRv2YNC7PlYY9WDtYtt3UUrF3VMmk4mcnBynNrPZjI+PTwn16C9HTqWxcttRjpxKc9s+XnvtNeLj49m6datT++eff05iYiJbtmxhwYIFrFu3rtDHJyQkEBkZyc8//0xERARvv/02AFOmTGH79u0cOHCAmTNn8sQTTxAaGuq24xCiPHMEhmNMA1D/D6wYwKbjO0m6dha99u6GiqMbdSC6YXviz++mbbdrdI2sh39FL7RaDQadBr1Og0GvpXHditSt4UvdGr6M6vs3j41plIrPadSrV4/Lly+TlZWFt7c3kHvJKigoqET7deRUGlP+vQur1Y5er2XWC21oGlSl2Pfj7+/P5MmTef3112nVqpXavnnzZoYOHUqVKlWoUqUK/fr148KFCwUeX6lSJXr37g1Aly5d2L59OwA1atRg3LhxjBkzBi8vL/75z38We99F+SFnEkXTaDT4GH3o1qgD3gZvHqjWyOnuqfTsjGK9e8qxvyfbhZTsgedTKkLDz8+PiIgI4uLiGDt2LMuXL6dSpUo0bNiwRPt16MRlrFY7dgWsVjuHTlx2S2gAPPHEE6xbt4633nqLli1bAnD58mVq1KihblOrVq1CQ6Ny5crq13q93un+7u7duzNnzhz+/ve/q4EshLgzTzbvjqIoaDQa9f/Bof3QaDT0+3OdVqtVP3sBoNVqURQFq9Wq/n46tnHcqp73lnXH147nLW1K9PJUaGgoCQkJAMyePZvffvuNyMhIvv76axYsWFDiL1iLBlXR67VoNaDXa2nRoKpb9zdz5kw2btxIfHw8kHumkDckCguMW5k/fz5t27blq6++umduLBDCnfK/0ef9X6vNfUvVarXodDp0Op3abjQa1XaNRoNOp0Or1aLVatFoNOq//PspbTx6pjFmzBin5byDstWrV2fJkiWe7M4tNQ2qwqwX2nDoxGVaNKjqtrMMh9q1azN+/HjefPNN2rZtS0xMDEuXLqVNmzZcv36dVatWERUV5fLzJSYmsmnTJjZs2MAXX3zB9OnTWbZsWan9YRRClH6lYiC8NGsaVIV+nRq7PTAcBgwYQFhYGAB9+/blgQceoFOnTowZM4bw8HCXJwS0Wq1MmzaNMWPG4O/vz/PPP8+FCxf48ssv3dl9IUQ5p1FK6wQntyE5OZlOnTqxbdu2AuVef/vtN+6///4S6tnd+e2336hZs6Y6ZvHuu+9itVqZMGFCCfescGX5tRbiXlTUe+fNyJlGKbZt2zbefPNNLBYL586dY926dURGRpZ0t4QQ9zAJjVJsyJAhWCwWoqKi6NevH/379+fhhx8u6W4JIe5hpeKWW1E4X19f3nvvvZLuhhBCqORMQwghhMskNIQQQrhMQkMIIYTLJDSEEEK4TEJDCCFuk6MWuONjbjabTV12zDPlWLZarVgsudX7rFYrVqtVnZvKUS+8rNQHB7l7qkQ1adKEH3/80aneyPr16/niiy9YtmyZ2pacnEznzp0ZM2YMo0aNUtt//vlnBg8e7DQRYbVq1Rg9ejQ9e/b0zEGIcuNmNcLRaKkfW3gNiXvR9O3zybJk0bL2g2RZsjDpvPj25I8E+NXAqtj448oZtBoN9SsFcupaMtm2v8o+aNGos91W8roPq91GltVMcOW6NKoSRAWvCqW6PjhIaJQJX3/9Nd27d2fVqlWMGDFCnRQNICgoiE2bNqnLhw8fZtCgQTRt2pTGjRuXRHeFKLfsdjtZlixOXU0mNfMq6TkZGLQGLHYLJ66YsfxZ6tWmwNG0k+Q/X7DnabmafV39+njaKY6nnSK6YXuWJq5k47EdRNaM4s2P4/nfyTQys63otRp0Oi0GnQZzjh1fHz3+93nzaEQ9j9XSALk8dUspy6aVeG3kNWvWMHToUO677z52795d5LbNmzenQYMGnDhxgtWrV/PMM88QHR1Njx49UBSFzz//nI4dOxIZGcmECRNIT0/HbrfTr18/9TMhR44cITw8nGPHjhESEkJycrL6/C+++CIrVqxw6/EKz7pVjXAUOydn9eHk7MLLnN5LtFotcx+dTFClOqTnZABgsVv+/N+5NvidXGDaeHynGhjfr/Pj58MXSM+0YLMpZFvsZJqtXLthIdtiI/VaNkfPXPVofXCQ0ChxXbt2JTw8XP03ZcoUp/UJCQl4eXnxwAMP0KtXryLfsG02Gz/++CN//PGHWj/8l19+YcGCBfy///f/iI+P56OPPmLRokVs374dm83GzJkz0Wq1vPHGGyxdupQzZ84wZcoUxo4dS6NGjXj44YfVioLZ2dns3r2bzp07u+8FEaKUcwSHO9WxtMJmd302ak/VBwe5PHVTjrMLx19fjuXirm62adOmQsc0HNasWaNW5evZsycLFiwgLS2NKlVyZ91NSkoiPDxc3b5u3brMnj2bgIAAABo2bEiTJk0A2LBhA0899ZRa3GrChAk8+uijzJ07l6ZNm/LUU08xYMAAAgICGDhwIJAbal988QVDhgzhxx9/5IEHHlD3LcoHx8+0jGm4xm638+q3c9y6j2TDHnRaP5eDw1P1wUFCo1TLzs5m48aNAHz00Udq21dffcWzzz4L5JbKzTumkZ+/v7/69blz59Rp1wFq1qyJzWYjNTWV6tWr06tXL5YsWcKzzz6rjpu0b9+eqVOncuXKFbZs2UKXLl2K/TiFKCscgXHqajJ+Rl+nMQ2DVu90iUrD7V+iim7YHjQaNh7bwSPdo8g82ajUjWlIaNxE3r++8i570tatW6lfv77T/FPfffcdS5cuVUPjdlSrVo1z586pyykpKWi1WipWrAjAvHnz6Nq1K//+97/p0aMHVapUoUKFCkRFRbFz505++OGHUjstu7h7UiP81rRaLd4Gb4Iq1XHr3VMa+LM+eOmb1VpCoxT7+uuviY6OpmbNmmpbz549mTt3rlom93bExMQQGxvLY489RkBAAO+88w7t27fHy8uL9evX88cff7B+/XpmzJjB3LlzmTdvHpB7ieqjjz6ifv36VK3q3pK3QpR2Mzq+hN1uV2t/O+qD63Q6p89tOOqBOz6LYTAY1M9vOEq8Op7HobTXBwcZCL+l2oNmlshfYJcuXWL37t0FLgd5e3vTsWNHVq68/WvMbdu2Zfjw4QwbNoy2bdtit9t58803uX79OnPmzGHKlCl4eXnxyiuvsHPnTn766ScAOnTowOnTp+XSlBB/crzRO97YdTqduqzRaNDr9eqyXq9XK27q9Xr0er0aGo564WWlPjhI5T7hArvdTrt27fjyyy+pUaPGTbeT11qIsuVOKvfJ5SlRpLNnz/Ltt9/SuHHjIgNDCHFvkNAQRYqLi+OHH37gP//5T0l3RQhRCkhoiCLNnj27pLsghChFZCBcCCGEyyQ0hBBCuExCQwghhMskNIQQQrhMQkMIIYTLPBIaCQkJxMTEEBISwsiRI8nIyCiwzZEjR+jTpw9hYWH07t2bgwcPeqJrJe7EiRM899xzhIWF0bJlS55//nlOnDhxx883bdo0Pv7440LXNWnShEuXLt3xcwshcuX/TLTdbldLwDq+dkwZYrPZsNvtWCwWtcyrY3oRxxQjecvH5l0ujdx+y21WVhZjx45lzpw5REREEBsbS1xcHJMmTXLabuLEiQwdOpTHH3+c5cuXM2HCBDZv3uzu7hXJMa/MzZbvls1m4/nnn2f48OH8+9//xm638/HHH/P888+zefNmdeqB2zFzpkw6J+5MYVOja7x8CH5l2U0ecW9acXgdmTmZ6vxQyw+tZd3vWzHpvajtV4OU9Atk5mRhU+xU9PLjhjWTHFtuoSaDRk/H4CiOpZ0i6VoyNsWODi11KtVmbudX+fTAKo5eOsHlrCvUvq8mMzq+VMJHW5DbQyM+Pp6AgADatWsHwOjRoxk4cGCB0Dhz5oyaslqtFi8vL3d3rUj5fzAURSn2ur1XrlwhJSWFbt26qXPVDBs2jLNnz5Kens7evXuZO3cu6enpjBgxgvnz53Po0CFWr17N+vXrWbJkCYDT8quvvkr9+vUZNmwYCQkJTJ8+nXPnzjF48OBi6bMQ9zJFUcjMyWTDsR0A/COkLwlnD5BtyyHblsONnEysik3d/kr2NafHWxQrm09+79Rmw07S1WSGffOqWg0Q4MZZLX0nf4PdDlabglGvpXY1Xww6LbWrVeBaRg71AypSwdtAiwZVaRrkmTo3bg+NpKQkgoKC1OXAwEBSU1O5evUqlSpVUtufeeYZJk+erE6a98knn7i7azeV/wdjcGg/PklcyYZjO+jWqEOxnXFUrVqVFi1a0L9/f5544gkiIyNp1qwZM2fO5MKFC0ycOJGFCxfyt7/9jVdeeeW2nttsNjN27FgmT55Mly5d1BlrhcjvpsWXACU7k5Oz+sgZx580Gg2DQ3PL3m44tkN9j6hXMYCka2edAsMVvgYfMiyZAE6BYb/hR/qvEeStyJFtsfNHSm5d8aNnrgKQePQSGsBg0DLrhTYeCQ63j2ncuHEDb29vddkx46PZbHbaTq/X8/7777N//35eeeUVxo0bR3Z2tru7VyjHD0a3Rh3YcGwH/VeMVAOjuKcs/vjjj4mOjmbt2rX069ePtm3b8t///pfvvvuOsLAwWrdujY+PDy+++OJtPe++ffu477776NGjB0ajkXHjxpXqmTOFKCvyBofDW4/F3tFzLX688D/msn9tjatvzwpgtdo5dOLyHfXhdrk9NLy9vZ3e/K1WKxaLxSlIDh48yNatW3n00UcxGo0MGDAAo9HIL7/84u7u3VRhPxjumOPe19eXMWPGsHbtWn766SfGjh3LW2+9xdWrV6levbq6Xd26dW/reR3V+PLux8/Pr9j6LcqP2oNmUn/KKkyBzQqs03j5UH/KKjnLyMNxqTqvSVvubLqd59dMLLTdq9lPgGuD4RpAr9fSooFnat24PTSCg4NJSkpSl5OSkqhcubJaLQ5yy5BaLBanxznmnS8phf1gfJK4ssBdE3dj/fr19Ov3VzBVqVKFp59+moiICHJycjh//ry6Lu9dT1qtFpvtr9Pg69evF3juqlWrOj3ebDYXeteaEMJ1jvcFx5WHL/rFqZemAPQa3W09n+PSFICf0Vf9WlshHb+Qn/EyajDoNWg04GXQElz7PhrXrUT7sABCG1ejT4eGDOp2v8cuTYEHxjQiIyOJjY1l27ZttGnThoULFxIdHe20TUhICMnJyaxevZonnniCb775huvXr/Pggw+6u3uFyv+DkXdMA4rvjCMyMpLXX3+dRYsW0adPHypWrMj+/fs5dOgQI0aM4LPPPuO7776jdevWvP/+++rj6taty6FDhzh37hx6vZ7ly5dTu7ZzYfmWLVuSnZ3NihUr6NWrFx988EGpvo1PlDwp93prGo0GH6OP06Xq8IC/cT7jUvHfPVWtOjMG9SzhIy7I7aHh7e1NXFwc06dPZ8KECURFRfHyyy+TkpJCTEwM69evp3bt2sTFxfHWW28xa9YsGjZsyEcffYSPj4+7u1eown4wHJeqfIw+xXaJyt/fn2XLlvHOO++waNEirFYrDRs25J///CehoaHExcXx+uuvk5qaSrdu3dTHhYWF0adPH5544gkqVapEjx49SExMdHpuo9FIXFwcU6ZMYc6cOfTu3dvpxgMhxJ15snl3p5th+rfoQb9mMUDuVYC8n9fQ6/XYbDY0Gg02m02t1OdY73iM467RIX++zziWSyOp3FcEd39O43YkJycTHR3NoUOHSmT/rpDKfUKULXdSua90RlkpkT8g5O4jIcS9TkJDCCGEyyQ0yog6deqU6ktTQoh7g4SGEEIIl90ToVEOxvpLPXmNhbg3lPvQMJlMpKamypuaGymKQmpqKiaTqaS7IoRws5L7yLWH1KlTh+TkZKkj4WYmk8nlW/aEEGVXuQ8Ng8FAcHBwSXdDCCHKhXJ/eUoIIUTxkdAQQohC5B8HdSzfrN1R5tUxmajVasVut5OTk+NU/tXRnrf06832WRqV+8tTQgjXnZzVp0DbvViA6WaVO/+4mkxwpToF2vecPUB6dgY5Ngu+Rh8C/Gpy4sppLPa/Zu82aPX4GX25np2BXcmdj+o+Lz8i64RSwasC/ZrFFHt1UHeQ0BBCiDyKqtwZVKlOoe1+Rl+ybTkApOfc4EjqiQLPa7FbSTNfzbsjrpivsfH4TqIbtmdp4ko2HttBZM0o3vw4nv+dTCPTbMGugFarwdekx6DXUbeGL6Ah6sHadG0d5O6XowAJDSFEoWcYDvdaydeblXTt1qgD/wjpy6f7vyzQPuhvfXh161ySribf0T43Ht8JQGTNKL5f54fNfsFpvc2mcO2GBbBw+Vpu1dPEo7l3hHo6OGRMQwgh8rlZ5U6tVltou06n461HJ9/1futYWmGzuz4x6u6DKXe9z9sloSGEoP6UVdSfsqrQdfdiydebVe602+2FtttsNiZ9O+eu95ts2INO6/pgeNSDtW+9UTGTy1NCCJFHUZU7/3fpGKeuJhdo/yHpF9Jz7ryccnTD9qDRsPHYDh7pHkXmyUYypiGEKP1udrZxLymqcucfeQIjb/ueswfIsRnv+u4pDbnVQZ9sF1kSh+4SCQ0hhMgnf0lXR0A4brPN3z4k7Em1fKuiKOh0OqxWK1qtFqvVil6vV8u/Otodj8/7v2MfpZmEhhBCFOJmlTtv1p6/prden/v2ajQandY72l3ZZ2kkA+FCCCFcJqEhhBDCZRIaQgghXCahIYQQwmUSGkIIIVwmoSGEEMJlEhpCCCFcJqEhhBDCZRIaQgghXOaR0EhISCAmJoaQkBBGjhxJRkbBib3S0tIYM2YMERERdOnShR9++METXRNClDOOEqqKoqglVR0lVh0lVx0lWG02m9ru2LawMqziL26fRiQrK4uxY8cyZ84cIiIiiI2NJS4ujkmTJjltN378eJo2bcquXbv4+eefefHFF9m1axdeXl7u7qIQ4k8nZ/cDxe7UVpaKL604vI79535FURTSsq5yn8mPc9cukKNY0OKYBkSLTbGpj9FqtKAogIZ6FQNIzbqCTqvD36cyIbWalerSqyXB7aERHx9PQEAA7dq1A2D06NEMHDjQKTRSUlI4cuQI//nPf9Dr9bRp04bPPvusTMzDIoQoHRRF4UZOJsfTTqltV8zX1K/t/HnmkCcwAOxqSCr8ce2M02MbVQlymqDQnY6cSmN7whmOJKVyMS0Lq82OXQFvLx05ltw+NqhTkfZhdUnPzKFFg6o0Dari9n7l5/bQSEpKIigoSF0ODAwkNTWVq1evUqlSJQCOHDlCcHAw8+fPZ82aNVSvXp3XXntNnehLCOFehZ1hOJSVcq8ajYYhf05VvvHPUqx3I7phe4aEPemxwIj9cBcWa8HvQd62X0+m8evJNDSAwaBl1gttPB4cbh/TuHHjBt7e3uqyXq/HYDBgNpvVtvT0dA4ePEjlypXZuXMnw4YNY/To0aSnp7u7e0KIciRvcNwtTwUGwKETlwsNjJtRAKvVzqETl93XqZtwe2h4e3uTnZ2tLlutViwWi1OQGAwGfHx8eP755zEajXTr1o2qVaty8OBBd3dPCAHUj12ZW4BJU/AtoSyVe1UUhaX5yrHeqaX7VnhsMLxFg6oY9K6/HWsAvV5LiwZV3depm3D75ang4GC2bNmiLiclJVG5cmUqVqyotgUFBWE2m7FYLOolKccdDEII4QpHYBTHpSmAjcd3Ap4542gaVIXZI9rImAZAZGQksbGxbNu2jTZt2rBw4UKio6Odtrn//vsJDAzk3Xff5ZVXXmHTpk2kpaURHh7u7u4JIfKoH1s8f6WXBI1GQwWjDw3/HLwujrunKnhV8NglqqZBVUokBG6X20PD29ubuLg4pk+fzoQJE4iKiuLll18mJSWFmJgY1q9fT+3atVm8eDHTpk0jIiKCmjVr8sEHH2AymdzdPSFEOfJk8+70axajLjvufLLZbGi1WrXkak5ODnq9Xl1vt9vRarWFlnMVzjxS7jUsLIy1a9c6tfn6+pKYmKguBwQEsGTJEk90RwhRjuV9o3d87Six6ii5mv/OzLylWiUoiibTiAghhHCZhIYQQgiXSWgIIYRwWZFjGpMnTy7Q5uXlRa1atYiOjiYwMNBtHRNCCFH6FHmm4efnV+CfTqdj7969PPHEE+zbt89T/RRCCFEKFHmmERsbe9N1X3/9Ne+++y7LlpX+T4kKIYQoHnc8phEdHc2RI0eKsy9CCCFKuTsODS8vL5nmQwgh7jF3HBq7du2SgXAhhLjHFDmm8emnnxZos9lsnD17ljVr1vD666+7q19CiFLAMb2G3V5w2m6r1YrRaHQqk6rT6dRpO3Q6nUzJUQ4VGRrffvttgTYvLy9q1qzJe++9R+vWrd3WMSHKo5Rl0zCf+Q2N0YRXjWDMp38FcqcfV7IzczfSaNX12Rf+AMCrRjAAtQfN9Fhfp2+fT5YlCy+dF6eunqGadxUuZaUBkG3LAaBx5WBOXD3tNAFgcMW6JKefQ6vRYtJ7oUFD1QpVpHRqOVFkaMidUULcm+x2O1mWLE5dTcagNWCxW0jOOF9gu6NX/ijQlrdkqiNcrmZfp5F/sMdKp5YFR06lcejEZfx8jOw9coGTZ6/hZdRRtaKJX/9Iw2Kx4+ujp2XTGqRcvoFBryWwxn10DK9borPhapRbjGavWLGCo0ePEhERwaOPPuqpft2W5ORkOnXqxLZt26hTp05Jd0eIAhxnGDcrqeoqU2AzwDNnHHa7nVe/ncOpq8l3/VzRjTowJLSfBMafjpxKY8q/c8u73u79RAa9ltkjiqfM6528dxY5EL5w4ULee+89Ll26xNSpU1m6dOldd1IIUTZotVrmPlpwVog7IYHh7NCJy1jvIDCg5Mq8OhR5eWr16tV89tlnBAUFsW/fPqZPn86QIUM81DUhyg/HmUFZGtNwnGkUh6WJKyU48mjRoCp6vfaOzjRKqsyruv+iVl65coWgoCAAQkJCOH++4DVNIUT5k/fSlGNM4244SrBKcORqGlSFWS+0KZNjGkWGRt7hDkdVKyHEnfPkmcLd0Gq1eBu8CapUp9junqpg9JH3kDzylnft2jqoZDtzGzxSuU8IUfbM6PiSfE5DFFBkaGRnZzN69Gh1OTMz02kZ4IMPPnBPz4QQJc5RBjVvOVQHR8lUxzqdTqeuc5RXlaAof4oMjREjRjgtN23a1K2dEUIIUboVGRqjR49m3759nDx5kr59+wKQk5PD8OHDGTVqFOHh4R7ppBBCiNKhyM9p/PLLLzz77LOkpqaqbTk5OdStW5fnnnuOvXv3ur2DQgghSo8iQ+ODDz4gNjaW4cOHq22+vr7MnDmTF198UcYzhBDRIr70AAAeOklEQVTiHlNkaBw5coRevXoVuu6pp57if//7n1s6JYQQonS643oajjsnhBBC3DuKDI0HHniAH374odB13333nfppcSGEEPeGIkNj6NChTJ06le3bt2Oz5X7i02azsX37dqZNmybzUAkhxD2myFtuH374YcaPH8+kSZOwWCxUrFiRq1evYjKZePnll4mOjvZUP4UQQpQCt5xGpG/fvnTv3p3ExETS0tKoVq0aoaGhGAwGT/RPiHLNMc2GY543xxm9oijodDqsVisajQaNRoNWq0VRFHUeOCloJEqCS3NPmUymuyrtmpCQwPTp0zl79ixRUVHMmzcPX1/fQrc9efIkjz/+ONu3b6datWp3vE9Rfpyc3U8tXqTx8gH4axpxB40WU937y8yEgAArDq8jMycTb4M3B87/j+Rr5zDbsot8jFFnQIuWmCadyLJk4WP0kRKqwqPcPmFhVlYWY8eOZc6cOURERBAbG0tcXByTJk0qsK3dbmfq1Knk5OS4u1tClChFUcjMyWTDsR3UqxhA0rWzLj0ux5Y7RfmeM4mcST9Ht0Yd5IyjDMlb4jU9Mwc/HyPLNv6P6zdyv6/+Fb3wMRm4r4IRPx8jlf286BgeWKJToefn9tCIj48nICCAdu3aAblTkwwcOLDQ0Pj000954IEH5JPmAnA+w3AocIahrrBjPv0rJ2f3KxNnHBqNhsGh/QDY8GetidvhCIzBUp+izFBLvFrsKIAGyF9/KfVaNqnXnM82v91zmjkj25aa4Ljjz2m4KikpyenW3MDAQFJTU7l69arTdmfOnGHlypWMHz/e3V0SolTIGxx3QgKjbFFLvP657GrBPptNKdHyrvm5/Uzjxo0beHt7/7VDvR6DwYDZbFbbFEVh6tSpTJo0iQoVKri7S6KMqB+7Eii/YxqKovBJ4so7fvwniSslOMoQtcRrEWcahdHpNCVa3jU/t4eGt7c32dl/nW5ZrVYsFotTkCxfvpzq1avzyCOPuLs7QpQKjsC43TENh7p+tdTLWhIcZUP+Eq8ypnETwcHBbNmyRV1OSkqicuXKVKxYUW379ttvSUxMdJpqvWvXrnz00Ucy/bpQzzjKE41Gg4/Rh26NOuBt8MagM9zW3VOt6obSwtIUHymhWqbkLfHqUJZKvYIHQiMyMpLY2Fi2bdtGmzZtWLhwYYEPBS5ZssRpuUmTJmzatEluuRXl2pPNu6t3Pjlum5XPaYjSzu0D4d7e3sTFxbFgwQKioqLIzs7m5ZdfJiUlhdDQUFJSUtzdBSFKrbz1szUaDXq9Xh3302q1GI1GDAYDer0erVar1uDO+1ghPMntZxoAYWFhrF271qnN19eXxMTEQrf//fffPdEtIYQQt8ntZxpCCCHKDwkNIYQQLpPQEEII4TIJDSGEEC6T0BBCCOEyCQ0hhBAuk9AQQgjhMgkNIYQQLpPQEEII4TKPfCJciJKiKAp2ux273a7O5eSg1+ux2WxotVp1PichRNEkNMRNpSybhvn0r86NZahuxYrD61h3ZOstZ44FMOm86N60s9TbFuIWJDREuaQoCunmDJcCA8BsyybdnCEzxxYTRy1sR/GgVTuOkXbNTAVvPb/+kUaOxY4GqORnpGN4IJlmK6CUutoRoiAJDVFAoWcYDmWkFrdGo2Foy/4AbD7x3S2379KgHUNb9pfAKAaOWthWqx2tVoOigM1esEadAlxJz2HVjuNqW2mrhy0KkoFwUW7lDY5bkcAoPo5a2HYlt751YYFxM6WtHrYoSEJDFFB70EzqT1mFKbBZwZUaLabAZtSPXVlqzzIcFEXh//Yud2nb/9u7HEVx/c1N3JyjFrZWk1vfWqd1PYxLWz1sUZBcnhLlkiMwXLk0BX9dwpIzjruXtxa2jGmUPxIa4qZK+5lEUTQaDX4mX0w6L5fvnvIz+UpgFJP8tbCnPBNRgr0RxUlCQ5RbTzbvTr9mMfI5DSGKkYSGKNc0Gg06nQ6dTgeA0Wh0Wq/VyrCeELdDfmOEEEK4TEJDCCGEyyQ0hBBCuExCQwghhMskNIQQQrhMQkMIIYTLJDSEEEK4TEJDCCGEyyQ0hBBCuMwjoZGQkEBMTAwhISGMHDmSjIyMAtvs27eP3r17ExYWRq9evdi3b58nuiZug2MWWEVRMJvNZGVlYbfb1WWz2Yzdbi/hXgoh3Mnt04hkZWUxduxY5syZQ0REBLGxscTFxTFp0iR1G7PZzOjRo5k+fTqPPvoomzZtYtSoUezYsQOTyeTuLpZJJ2f3A+WvN2hTYDO3TjC44vA6MnMy8TZ4s+p/G9T2CjpvWtUOYceZn9S2+6s1YkbHl9zWFyFEyXF7aMTHxxMQEEC7du0AGD16NAMHDnQKjYsXL9K2bVu6dOkCQLdu3ZgxYwZnzpyhUaNG7u6iuAVFUcjMyWTDsR3U8qnutO6GLcspMACuZ6Zjt9vL7bxOR06lsT3hDEeSUrmYloXVZifbkhvgep2Gxx9pwJDuhdQiEaIccHtoJCUlERQUpC4HBgaSmprK1atXqVSpkto2b948dZuDBw+SnZ1N3bp13d29Mif/GYaD+fSvnJzVxy1nHBqNhsGh/QDYcGxHkdsGVKjJO91eK9eBEfvhLizWwi/DWW2KWr5UgkOUR27/zb5x4wbe3t7qsl6vx2AwYDabC93+3LlzvPjii4wbN04uTZUieYOjKOU5MCC3lOnNAiOv3YfOeaA3Qnie23+7vb29yc7+qwiO1WrFYrE4BYnDiRMnePrpp+nZsydDhgxxd9fKpPqxK6k/ZRVonL91psBm1J+yym3jGoqi8Eniyltu9/KGN8r1YHiLBlUx6G/9axPVopYHeiOE57k9NIKDg0lKSlKXk5KSqFy5MhUrVnTa7tdff2XAgAEMHjyY8ePHu7tb4jY4AqOwMY38zt44X66Do2lQFWaPaEN06yCCa/tRwaTHy/DXr5Fep6FPh4ZyaUqUW24f04iMjCQ2NpZt27bRpk0bFi5cSHR0tNM2169fZ/jw4YwZM4YBAwa4u0vlQv3YW//VX1w0Gg0+Rh+6Nerg0t1T9/n4letLVPlLmQpxL9Eojpvv3Wjfvn1Mnz6ds2fPEhUVxdy5c7l+/ToxMTGsX7+eXbt2MXXqVHx8fJwe98knn/Dggw/e8vmTk5Pp1KkT27Zto06dOu46jHueoihoNBoURSE7OxtFUfDy8kKj0aiXII1GY7kODCHKkzt57/RIudewsDDWrl3r1Obr60tiYiIA/fr1o1+/Ww+yipLlqKGt0WgK3KQgNy0IcW+QPwmFEEK4TEJDCCGEyyQ0hBBCuExCQwghhMskNIQQQrhMQkMIIYTLJDSEEEK4TEJDCCGEyyQ0hBBCuExCo5Qwm81OZXDzLwshRGngkWlE7iUpy6ZhPv0r4HoJ1ieXj1C//r+Yf6LX6/nHmr9m+l3R/8Pi76gQQtwBCY0Slr8Y1dD1Ewpsk5GRga+vr0f6k1vK9DT7j13i3OVMtb19WAAvDwj3SB+EEKWXhEYxyXuG4eBKCVaTycSnj7/rdGaR1//F/NOjgTF54Y9YbQUnPt657yyABIcQ9zgZ0ygFHMGRnycDA3JLmdoKCQyHvUcueqwvQojSSUKjmNQeNJP6U1ZhCvyrYpurJVjNZnOhZxpD10/w6GB4iwZV0ek0N13fsmnRVfuEEOWfhEYJu1lgOHgyOJoGVWHOyLZEt65HrarOBbFkTEMIATKmUexcuVsqr/zFiwq7e8qTl6iklKkQoigSGqXAiv4fYjabsVqtakB8+vi7TstCCFEaSGiUElI+VQhRFsiYhhBCCJdJaAghhHCZhIYQQgiXSWgIIYRwmYSGEEIIl0loCCGEcJmEhhBCCJdJaAghhHCZhIYQQgiXeSQ0EhISiImJISQkhJEjRxY6Ad/x48fp27cvISEhDBw4kPPnz3uia6rLly8XuSyEEMIDoZGVlcXYsWOZOHEi8fHxmEwm4uLinLZRFIVx48bRt29f9uzZQ4sWLZg9e7a7u6Z6cvkIRm57jT2z+nByVh8uX77MyG2vOZVhFUII4YHQiI+PJyAggHbt2mEymRg9ejRr1qxx2ubYsWNcuXKFp556CqPRyJgxY9i5c6dHpgTPe0bxdoNqXFJgxNbXCl0vhBD3OreHRlJSEkFBQepyYGAgqampXL161WmbevXqqcs+Pj5UrlyZpKQkd3ePqlWr8srxi6AooNHwTqPqaDSAorCw0xtUrVrV7X0QQoiywu2hcePGDby9vdVlvV6PwWDAbDbfdBvIneU1KyvL3d0DoCrw8vFLTm0vH78kgSGEEPm4PTS8vb3Jzs5Wl61WKxaLxSkk8m8DuRXtfHycq8e5y33DP+Lths6lTN9uWF0uTQkhRD5uD43g4GCny0xJSUlUrlyZihUr3nSbzMxMUlNTCQwMdHf31EFvxyWpl49ddFypYuS21yQ4hBAiD7eHRmRkJElJSWzbtg2z2czChQuJjo522qZx48b4+fnx+eefk5OTwwcffEBUVJRHqtblvQS1sPObRExdxYed3yh0vRBC3Os8cnkqLi6OBQsWEBUVRXZ2Ni+//DIpKSmEhoaSkpICwPvvv88333xDREQEhw8f5o033rjFMxefFf0/dBr0rlq1Kgs7vcGK/h96rA9CCFEWeKTca1hYGGvXrnVq8/X1JTExUV1u0KABy5cv90R3CpX/jELOMIQQoiCZRkQIIYTLJDSEEEK4TEJDCCGEyyQ0hBBCuExCQwghhMskNIQQQrjMI7fcupvNZgPweA0OIYQoyxzvmY73UFeUi9C4dCl3ssEBAwaUcE+EEKLsuXTpktNM40XRKIqiuLk/bmc2mzl8+DDVqlVDp9OVdHeEEKJMsNlsXLp0iebNm2MymVx6TLkIDSGEEJ4hA+FCCCFcJqEhhBDCZRIaQgghXCahIYQQwmUSGkIIIVwmoSGEEMJlEhpCCCFcJqHxp4SEBGJiYggJCWHkyJFkZGSUdJfc6q233qJFixaEhoYSGhpK3759Afjvf/9L27Zteeihh3jnnXfU7a1WK6+99hrh4eG0a9eODRs2lFTXi8WSJUuYNm2aurxlyxY6duxIaGgokydPxmKxqOv+9a9/ERERQevWrfn000/V9oyMDEaPHk1oaChdunTh559/9ugxFIf8r8PYsWN58MEH1Z+LsWPHquvK6+uwfft2unXrRsuWLRkwYAAnTpwA7ux34cKFCwwePJjQ0FCeeOIJjh496vHjcTtFKJmZmUrr1q2VnTt3KllZWcr48eOVuXPnlnS33OqZZ55Rdu7c6dR24MABpW3btkpSUpJy/vx5JTo6WtmxY4eiKIqyePFiZfDgwUpGRoayd+9epVWrVkpaWloJ9Pzu5OTkKP/617+Upk2bKq+99pqiKIpy7tw55aGHHlIOHTqkXL9+XRk4cKDy2WefKYqiKBs2bFC6d++uXL58WTl+/LjSpk0b5ffff1cURVFef/11ZcKECUp2drayZcsWpW3btorFYimxY7sdhb0OiqIojz32mHLs2LEC25fX18HxvU9ISFCsVquyePFiJSYm5o5/F55//nll/vz5SnZ2tvLpp58qvXv3LsGjcw850wDi4+MJCAigXbt2mEwmRo8ezZo1a0q6W271+++/07hxY6e2jRs30rNnTwIDA6lRowb/+Mc/+PrrrwHYsGEDzzzzDBUqVCAsLIw2bdqwcePGkuj6XZkzZw6HDx+mf//+atvWrVuJioqiefPm+Pn5MWzYMPW4N27cyNNPP42/vz8NGjSgV69e6s/Gxo0bGT58OEajkUcffZTatWuza9euEjmu21XY65CVlcX58+cJCgoqsH15fR3OnTtHnz59aNmyJTqdjqeffppjx46xbt262/5dyMjIYPfu3QwbNgyj0cigQYO4cOGCeuZSXkhoAElJSU6/KIGBgaSmpnL16tWS65QbpaWlceXKFV5//XUiIyMZPHgwf/zxB6dOnXJ6HerVq6f+wCclJREcHKyuCwwM5OTJk57u+l0bMWIEixYtwt/fX20r6rhPnTpV4LhPnDjBtWvXuHLlitMkb2XpNSnsdTh27Bgmk4khQ4bQunVrRo0apU4GWl5fh9DQUCZNmqQuf//99wQEBHDmzJnb/l04ffo0/v7+VKhQwWmdhEY5dOPGDby9vdVlvV6PwWDAbDaXYK/cJy0tjVatWjF69Gi+//57WrVqpY7j5H0dvLy81NcgMzPTaUIzk8lEVlaWx/t+t6pVq1agLTMz87aO22w2k5mZicFgQK/XO60rK6/JzV6HkJAQ3njjDbZv346/v7/6hlpeX4e8jhw5wuuvv86rr7562z8TWVlZBdrzritPJDQAb29vsrOz1WWr1YrFYnH6oSlPGjZsyNKlS2nRogVGo5GRI0dy8eJFvLy8nF6H7Oxs9TUwmUxO68xmc7l5ffJ///Med/51juM2mUxYrVanOgRmsxkfHx/PdbyYRUZG8tFHHxEcHIy3tzcvvfQSP/30k3rM5fl1SEhIYPDgwYwfP57HHnusyJ+Jm/0umEwmcnJynJ63LL4WtyKhAQQHB5OUlKQuJyUlUblyZSpWrFiCvXKf/fv388UXX6jLdrsdm81GtWrVOH36tNqe97JNcHCw07r8p+hlWf7v/62OOygoSP35OHPmTIF1ZdV3333ndCdQTk4OOp0OvV5frl+H77//nhdeeIHp06fz1FNPAQW/7678LtSrV4/Lly87nVmcPn26TL0WrpDQIPcvrKSkJLZt24bZbGbhwoVER0eXdLfcxmQyMW/ePA4ePIjFYmHBggXcf//9PPXUU6xevZo//viDixcvsmzZMvV16Nq1K4sWLSIjI4PExER27dpFp06dSvhIikenTp348ccf2b9/P+np6SxevNjpuJctW8bFixc5efIkX3/9tdO6Dz74ALPZzNatW0lOTiYiIqIkD+Wu2O12Zs+eTVJSEllZWbz99ttER0ej1+vL7etw5swZxo0bx7x58+jWrZva3rVr19v+XfDz8yMiIoK4uDhycnJYtmwZlSpVomHDhiV1eO5R0rdvlRZ79+5VunfvroSGhiqjRo1S0tPTS7pLbvXVV18pHTt2VEJCQpShQ4cqKSkpiqIoyn//+1+lXbt2SqtWrZR3331X3T47O1uZPn260qpVK6VDhw7K5s2bS6rrxeK9995zutX022+/VTp37qy0bNlSmTp1qnrLqN1uV9577z2lTZs2SlRUlHorrqIoSnp6uvLiiy8qLVu2VLp27ar88ssvHj+Ou5X/dVi0aJHy8MMPKyEhIcrYsWOV69evK4pSfl+H+fPnK02aNFFCQkKc/l2+fPmOfhcuXLigDB06VAkNDVV69+5d6O3LZZ0UYRJCCOEyuTwlhBDCZRIaQgghXCahIYQQwmUSGkIIIVwmoSGEEMJlEhpCCCFcJqEhyr28n1Yu78xmM5cvXy7pbohyTEJDuFWTJk1o3rx5oTMGd+nShSZNmrh1/59//jlz58516s9vv/3m1n3eys8//0x4eLhbnnvgwIHs37+/0HWDBg2iefPm9O7dm+TkZJo0acL169cLbLd69Wruv/9+tRBTaGgovXr14qeffnLazm6306FDB27cuFHo/mw2G6GhoTRr1oxZs2bd/cGJUkFCQ7hdhQoV2Lx5s1PbgQMH1Gm33SktLY176fOraWlpRa5/5ZVXWL169S2fp3HjxiQmJpKYmMjevXvp378/o0aNcgqZAwcO0KBBA6epwPPS6XQkJibSo0eP2zsIUapJaAi369q1K+vWrXNqW7NmDV26dHFq27x5M3369KFVq1Y89NBDatnV1NRUWrduzbJly4DckpqtWrVi06ZNRe538+bNfPTRR+zcuZOePXuq7Zs2bSI6OprQ0FDGjx+vTjD36quvMm7cODp27EiXLl2wWCzs3r2bPn36EBYWRo8ePZz22bFjR7Zu3aouv//++4wcORIAi8XCzJkzeeihh+jcuTOLFy92Oquy2+0sWLCARx55RJ2vKO/zxsXF0bFjR1q2bMnEiRPVv+bz7gNwOmMYNWoUKSkpvPTSSyxevLjI1yYvm83G+PHjGTBgQKFnDVqtlj59+mA2mzl16pTavn37djp27AjAokWL1GMZMGAABw8edHn/omyR0BBuFx0dzYEDB7hw4QKQ+4a6ZcsWYmJi1G3Onj3LxIkTmTx5Mnv27OHLL79kx44dbN26FX9/f9544w3effddUlJSmDx5Mo8++ihdu3Ytcr9dunRh+PDhtG/fnm+++UZt37dvHytWrGDz5s3s3bvX6S/v+Ph4Pv/8c7788ktOnTrF8OHDefbZZ9mzZw+xsbFMnjyZvXv33vKYFy5cyP79+1m/fj3Lly93ChfIreGSnZ3N9u3bef/993n//fc5fvy4uv6bb77hk08+UScAfOutt265z7i4OGrXrs38+fN5/vnnb7k95IZXbGwsly5dYvHixYWeNdhsNlauXEnNmjVp2rSp2r5jxw46duzI4cOHWbJkCStWrOCnn36iVatWzJ8/36X9i7JHQkO4XcWKFWnbti3r168H4IcffqBZs2ZOVeOqVavGunXrCA8PJz09nbS0NCpXrszFixcB6Ny5M4899hh///vfOXv2LFOmTLnj/owcORI/Pz+qV6/OQw89RHJysrquVatW1KpVCz8/P9avX09ERATdunVDr9fTunVrevTowVdffXXLfXzzzTcMHz6c6tWr4+/vz5gxY5zW6/V6xo8fj16vp1WrVlStWtWpHy+88AJ169alcuXKjB49Wn3tituMGTOIj49n0aJFTnUfjh49Snh4OOHh4fztb39jxowZPPXUUxiNRiD35gKj0UjNmjWpUKECN27cYPXq1Zw4cYIxY8awdOlSt/RXlDwJDeERPXv2VC9RffPNNzz++ONO6w0GA6tWraJt27b06tWLjz/+mOzsbKfxiKeffppz587x2GOP3VVhm0qVKjnt12q1qsvVq1dXv05LS6N27dpOj61Tpw7nzp275T4uXLhAzZo11eVatWo5rff29lbfgAGMRqNTPwIDA9Wva9SoQUZGhlsqSZ47d4709HR++eUXp/bGjRuTkJBAQkIChw4d4ssvv+SLL75Qw2Dbtm106NAByK0vERcXx549e+jduzcdO3Zk5cqVxd5XUTpIaAiP6NChA6dPn+bgwYMkJCQUqMWxfv161q5dy6pVq9i6dSvvvfcevr6+6nqr1crMmTPp0aMHn332Gb///rtb+qnRaNSva9WqxdmzZ53WnzlzhqpVqwK51/rzVmrLe4dYrVq1nMLFcWnOVXm3T0lJoVKlSphMJrRaLRaLpdB93om4uDjGjRvHtGnTyMjIKHQbjUZDixYt6NKlC7t27QKcxzMuXrxIlSpVWLp0KXv27OHFF19k6tSpLoWrKHskNIRHeHl58dhjjzF58mTat2+Pl5eX0/r09HR0Oh1GoxGLxcKyZcv4/fff1TfIhQsXkpOTw5w5c/jHP/7BxIkTC5TWLIzRaCQ9Pf2O+tytWzcSEhLYsGEDNpuNn376ibVr16p3AwUFBbFx40aysrI4evSo0x1ivXv3ZtGiRVy6dIkrV66wcOHC29r34sWLuXjxIqmpqcTFxdGrVy8g96/6xMRETp48SWZmJh9//LHT4wwGw20dr8FgYODAgVSrVo158+bddDtHkbKwsDCuX7/O2bNnadasGQAnTpzgueee4+jRo3h7e+Pv74/RaCw35YCFMwkN4TE9evTg+PHjBS5NAfTq1YsHHniAzp0788gjjxAfH0/37t05duwYhw4dYvHixcyaNQuDwcCoUaPIycnh/fffB+C5555j2rRphe6zffv2JCUl0a5du9vub7169Vi4cCH/+c9/CA8PZ8aMGcyYMYO2bdsCMGnSJC5dukRUVBTTpk2jT58+6mOfffZZHnjgAbp06UK/fv1o1qwZBoPB5X03a9aMgQMH0rVrV5o1a8ZLL70E5I7txMTE8PTTT9OtWzdat27t9LjevXszY8aM2xqI1mq1vPHGG6xevZr4+Hggd0wj7+c0Bg8eTNeuXRk2bBjff/89Dz/8sPr41q1bM3z4cIYPH05ISAhz587l3XffdboMKMoPKcIkhBscOHCAoKAgtc78d999x5QpU/jxxx9v+diOHTsSGxtL586di7VPgwYNolOnTgwZMqRYn/dWXn31Vfz8/O7q5gVReuhLugNClEerVq0iKyuLWbNmYTab+fTTT53+OheirJLLU0K4wfjx48nOzubhhx+mc+fOVK1aldjY2JLuFm+//Ta9e/f2yL4c04isXbvWI/sTniGXp4QQQrhMzjSEEEK4TEJDCCGEyyQ0hBBCuExCQwghhMskNIQQQrjs/wOKAbkbXT/L4wAAAABJRU5ErkJggg==\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# proper plotting of VNF data for paper\n",
    "# only use data with small flows\n",
    "def plot_vnf_data():\n",
    "    sns.set(font_scale=1.1, style='white')\n",
    "    fig, ax = plt.subplots()\n",
    "    plt.scatter(nginx['Max. throughput [kB/s]'], nginx['CPU'], label='Nginx', marker='.')\n",
    "    plt.scatter(haproxy['Max. throughput [kB/s]'], haproxy['CPU'], label='HAProxy', marker='+')\n",
    "    plt.scatter(squid['Max. throughput [kB/s]'], squid['CPU'], label='Squid', marker='x')\n",
    "\n",
    "    # labels\n",
    "    ax.set_xlabel('Max. throughput [kB/s]')\n",
    "    ax.set_ylabel('CPU')\n",
    "    plt.legend()\n",
    "    \n",
    "    fig.savefig(f'plots/web_vnf_data.pdf', bbox_inches='tight')\n",
    "    \n",
    "plot_vnf_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cross_validation_rmse(model, X, y, vnf_name, k=5, save_model=False):\n",
    "    \"\"\"Do k-fold CV and return the avg RMSE on the validation set. Train and save the model.\"\"\"\n",
    "    scores = cross_val_score(model, X, y, scoring=\"neg_mean_squared_error\", cv=k)\n",
    "    rmse = np.sqrt(-scores)\n",
    "    name = type(model).__name__\n",
    "    print(f\"CV RMSE of {name}: {rmse.mean()} (+/-{rmse.std()})\")  \n",
    "    if save_model:\n",
    "        model.fit(X, y)\n",
    "        joblib.dump(model, f'ml_models/{vnf_name}/{name}.joblib')\n",
    "    return rmse \n",
    "\n",
    "def tune_hyperparams(model, X, y, params):\n",
    "    \"\"\"Do grid search CV for hyperparam tuning and return CV RMSE\"\"\"\n",
    "    grid_search = GridSearchCV(model, params, cv=5, scoring=\"neg_mean_squared_error\")\n",
    "    grid_search.fit(X, y)   \n",
    "    return grid_search.best_estimator_\n",
    "\n",
    "def barplot_rmse(scores, labels, data_name):\n",
    "    \"\"\"bar plot comparing the RMSE of the different algorithms\"\"\"\n",
    "    sns.set(font_scale=1.1, style='white')\n",
    "    assert len(scores) == len(labels)\n",
    "    \n",
    "    # preparation\n",
    "    rmse_mean = [s.mean() for s in scores]\n",
    "    rmse_std = [s.std() for s in scores]\n",
    "    x = np.arange(len(labels))\n",
    "\n",
    "    # plot\n",
    "    fig, ax = plt.subplots() #figsize = (8, 6))\n",
    "    plt.barh(x, rmse_mean, color='grey', xerr=rmse_std, capsize=5)\n",
    "\n",
    "    # labels\n",
    "    ax.set_xlabel('RMSE')\n",
    "    ax.set_yticks(x)\n",
    "    ax.set_yticklabels(labels)\n",
    "    \n",
    "    fig.savefig(f'plots/{data_name}_rmse.pdf', bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_eval_models(X, y, vnf_name, tune_params=False):\n",
    "    \"\"\"Create, tune, eval, and return all ML models\"\"\"\n",
    "    # prepare models\n",
    "    labels = ['Linear', 'Ridge', 'SVR', 'Forest', 'Boosting', 'MLP', 'Fixed']\n",
    "    models = [LinearRegression(), Ridge(), SVR(), RandomForestRegressor(), \n",
    "              GradientBoostingRegressor(), MLPRegressor(max_iter=1500), \n",
    "              FixedModel(fixed_value=0.8)]\n",
    "    \n",
    "    # params for tuning\n",
    "    params_ridge = {'alpha': [0.1, 1, 10]}\n",
    "    params_svr = {'kernel': ['linear', 'poly', 'rbf'], 'C': [1, 10, 100], \n",
    "                  'epsilon': [0.001, 0.01, 0.1]}\n",
    "    params_forest = {'n_estimators': [10, 100, 200]}\n",
    "    params_boosting = {'learning_rate': [0.01, 0.1, 0.3], 'n_estimators': [10, 100, 200]}\n",
    "    params_mlp = {'hidden_layer_sizes': [(64,), (128,), (256)], 'alpha': [0.001, 0.0001, 0.00001],\n",
    "                  'learning_rate_init': [0.01, 0.001, 0.0001]}\n",
    "    params = [{}, params_ridge, params_svr, params_forest, params_boosting, params_mlp, {}]\n",
    "    \n",
    "    # tune, train, eval\n",
    "    if tune_params:\n",
    "        models = [tune_hyperparams(models[i], X, y, params[i]) for i in range(len(models))]\n",
    "    rmse = [cross_validation_rmse(model, X, y, vnf_name, save_model=True) for model in models]\n",
    "    \n",
    "    # plot\n",
    "    if tune_params:\n",
    "        barplot_rmse(rmse, labels, f'{vnf_name}_tuned')\n",
    "    else:\n",
    "        barplot_rmse(rmse, labels, f'{vnf_name}_default')\n",
    "        \n",
    "    return models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prepare_data(data, vnf_name):\n",
    "    \"\"\"Split return data\"\"\"\n",
    "    X = data[['Max. throughput [kB/s]']]\n",
    "    y = data['CPU']\n",
    "    X = X.fillna(X.median())\n",
    "\n",
    "    scaler = MinMaxScaler()\n",
    "    scaler.fit(X)\n",
    "    os.makedirs(f'ml_models/{vnf_name}', exist_ok=True)\n",
    "    joblib.dump(scaler, f'ml_models/{vnf_name}/scaler.joblib')\n",
    "    \n",
    "    return X, y, scaler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict_plot_all(models, scaler, X, y, vnf_name):\n",
    "    \"\"\"Given a list of models, fit all to the data, save model, and plot their predictions\"\"\"\n",
    "    sns.set(font_scale=1.1, style='white')\n",
    "    \n",
    "    models = [models[0], models[2], models[3], models[6]]\n",
    "    labels = ['Linear', 'SVR', 'Boosting', 'Fixed']\n",
    "    markers = ['x', 'v', '^', '+']\n",
    "    colors = ['blue', 'orange', 'red', 'green']\n",
    "    \n",
    "    fig, ax = plt.subplots()    \n",
    "    plt.scatter(X, y, label='True', marker='o', color='black', s=50)\n",
    "    X = scaler.transform(X)\n",
    "    times = []\n",
    "    for i, model in enumerate(models):\n",
    "        # train model\n",
    "        name = type(model).__name__\n",
    "        model.fit(X, y)\n",
    "        os.makedirs(f'ml_models/{vnf_name}', exist_ok=True)\n",
    "        # predict and plot data\n",
    "        X_plot = pd.DataFrame({'Max. Throughput [kB/s]': np.arange(200, 2500, 50)})\n",
    "        X_plot_scaled = scaler.transform(X_plot)\n",
    "        start = time.time()\n",
    "        y_pred = model.predict(X_plot_scaled)\n",
    "        times.append(start - time.time())\n",
    "        plt.scatter(X_plot, y_pred, label=labels[i], marker=markers[i])\n",
    "\n",
    "    plt.xlabel('Traffic Load [kB/s]')\n",
    "    plt.ylabel('CPU')\n",
    "    plt.tick_params(axis='both', direction='inout', length=5, bottom=True, left=True, right=True, top=True)\n",
    "    plt.legend()\n",
    "    # save, avoid cutting off labels\n",
    "    plt.tight_layout()\n",
    "    fig.savefig(f'plots/{vnf_name}_model_comparison.pdf')\n",
    "    \n",
    "    # return prediction times\n",
    "    return times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "# vnf_name = 'nginx'\n",
    "# X, y, scaler = prepare_data(nginx, vnf_name)\n",
    "\n",
    "# # CV without scaling and hyperparam tuning\n",
    "# train_eval_models(X, y, vnf_name, tune_params=False)\n",
    "# # with scaling, but without hyperparam tuning\n",
    "# train_eval_models(scaler.transform(X), y, vnf_name, tune_params=False)\n",
    "# # with scaling and tuning\n",
    "# models = train_eval_models(scaler.transform(X), y, vnf_name, tune_params=True)\n",
    "\n",
    "# predict_plot_all(models, scaler, X, y, vnf_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "# vnf_name = 'squid'\n",
    "# X, y, scaler = prepare_data(squid, vnf_name)\n",
    "\n",
    "# # CV without scaling and hyperparam tuning\n",
    "# train_eval_models(X, y, vnf_name, tune_params=False)\n",
    "# # with scaling, but without hyperparam tuning\n",
    "# train_eval_models(scaler.transform(X), y, vnf_name, tune_params=False)\n",
    "# # with scaling and tuning\n",
    "# # this takes really long; not sure why\n",
    "# models = train_eval_models(scaler.transform(X), y, vnf_name, tune_params=True)\n",
    "\n",
    "# predict_plot_all(models, scaler, X, y, vnf_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "def barplot_compare_rmse(scores_default, scores_tuned, labels, data_name):\n",
    "    \"\"\"\n",
    "    bar plot comparing the RMSE of the different algorithms also compare against tuned version of algorithms    \n",
    "    \"\"\"\n",
    "    sns.set(font_scale=1.1, style='white')\n",
    "    assert len(scores_default) == len(scores_tuned) == len(labels)\n",
    "    \n",
    "    x = np.arange(len(labels))\n",
    "    width = 0.35\n",
    "\n",
    "    # plot\n",
    "    fig, ax = plt.subplots() # prev: figsize = (8, 5))\n",
    "    \n",
    "    # default\n",
    "    rmse_mean = [s.mean() for s in scores_default]\n",
    "    rmse_std = [s.std() for s in scores_default]\n",
    "    # 95% CI (not bootstrapped like seaborn does): https://en.wikipedia.org/wiki/Confidence_interval#Basic_steps\n",
    "    ci95 = [1.96 * std / np.sqrt(len(rmse_std)) for std in rmse_std]\n",
    "    ax.bar(x - width/2, rmse_mean, width, yerr=ci95, capsize=5, color='gray', label='Default')\n",
    "    \n",
    "    # same for tuned version\n",
    "    rmse_mean = [s.mean() for s in scores_tuned]\n",
    "    rmse_std = [s.std() for s in scores_tuned]\n",
    "    # 95% CI (not bootstrapped like seaborn does): https://en.wikipedia.org/wiki/Confidence_interval#Basic_steps\n",
    "    ci95 = [1.96 * std / np.sqrt(len(rmse_std)) for std in rmse_std]\n",
    "    ax.bar(x + width/2, rmse_mean, width, yerr=ci95, capsize=5, color='lightgray', label='Tuned')\n",
    "        \n",
    "    # labels\n",
    "    ax.set_ylabel('RMSE')\n",
    "    ax.set_xticks(x)\n",
    "    ax.set_xticklabels(labels)\n",
    "    ax.tick_params(axis='both', direction='inout', length=5, bottom=False, left=True, right=True, top=False)\n",
    "    ax.legend()\n",
    "    \n",
    "    fig.savefig(f'plots/{data_name}_rmse.pdf', bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_tune_eval_models(X, y, vnf_name):\n",
    "    \"\"\"Create, tune, eval, and return all ML models - compare default vs tuned performance\"\"\"\n",
    "    # prepare models and rmse without tuning\n",
    "    labels = ['Linear', 'Ridge', 'SVR', 'Forest', 'Boosting', 'MLP', 'Fixed']\n",
    "    models_default = [LinearRegression(), Ridge(), SVR(), RandomForestRegressor(), \n",
    "              GradientBoostingRegressor(), MLPRegressor(max_iter=1500), \n",
    "              FixedModel(fixed_value=0.8)]\n",
    "    rmse_default = [cross_validation_rmse(model, X, y, vnf_name, save_model=False) for model in models_default]\n",
    "    \n",
    "    # hyperparam tuning\n",
    "    params_ridge = {'alpha': [0.1, 1, 10]}\n",
    "    params_svr = {'kernel': ['poly', 'rbf'], 'C': [1, 10, 100], \n",
    "                  'epsilon': [0.001, 0.01, 0.1]}\n",
    "    params_forest = {'n_estimators': [10, 100, 200]}\n",
    "    params_boosting = {'learning_rate': [0.01, 0.1, 0.3], 'n_estimators': [10, 100, 200]}\n",
    "    params_mlp = {'hidden_layer_sizes': [(64,), (128,), (256)], 'alpha': [0.001, 0.0001, 0.00001],\n",
    "                  'learning_rate_init': [0.01, 0.001, 0.0001]}\n",
    "    params = [{}, params_ridge, params_svr, params_forest, params_boosting, params_mlp, {}]\n",
    "\n",
    "    models_tuned = [tune_hyperparams(models_default[i], X, y, params[i]) for i in range(len(labels))]\n",
    "#     models_tuned = [tune_hyperparams(models_default[i], X, y, {}) for i in range(len(labels))]\n",
    "    rmse_tuned = [cross_validation_rmse(model, X, y, vnf_name, save_model=True) for model in models_tuned]\n",
    "    \n",
    "    # plot and compare\n",
    "    barplot_compare_rmse(rmse_default, rmse_tuned, labels, f'{vnf_name}_default-tuned')\n",
    "        \n",
    "    return models_tuned"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CV RMSE of LinearRegression: 0.19651294327683955 (+/-0.0770302015503735)\n",
      "CV RMSE of Ridge: 0.19747963738692514 (+/-0.07374557483743582)\n",
      "CV RMSE of SVR: 0.23843849102511663 (+/-0.03133600651863603)\n",
      "CV RMSE of RandomForestRegressor: 0.1544186506720129 (+/-0.04566173409977426)\n",
      "CV RMSE of GradientBoostingRegressor: 0.15532875692425963 (+/-0.04397880798814986)\n",
      "CV RMSE of MLPRegressor: 0.20690428180788495 (+/-0.07598079094190109)\n",
      "CV RMSE of FixedModel: 0.38153965300099446 (+/-0.21077830340877302)\n",
      "CV RMSE of LinearRegression: 0.19651294327683955 (+/-0.0770302015503735)\n",
      "CV RMSE of Ridge: 0.19747963738692514 (+/-0.07374557483743582)\n",
      "CV RMSE of SVR: 0.1829420132476261 (+/-0.08049356087609329)\n",
      "CV RMSE of RandomForestRegressor: 0.1523560777807378 (+/-0.04203026966747045)\n",
      "CV RMSE of GradientBoostingRegressor: 0.14334186263227305 (+/-0.0379499323771591)\n",
      "CV RMSE of MLPRegressor: 0.17355377473628966 (+/-0.06294255153363573)\n",
      "CV RMSE of FixedModel: 0.38153965300099446 (+/-0.21077830340877302)\n"
     ]
    },
    {
     "data": {
      "text/plain": "[0.0, 0.0, -0.015516519546508789, 0.0]"
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "vnf_name = 'nginx'\n",
    "X, y, scaler = prepare_data(nginx, vnf_name)\n",
    "X_scaled = scaler.transform(X)\n",
    "\n",
    "models = train_tune_eval_models(X_scaled, y, vnf_name)\n",
    "predict_plot_all(models, scaler, X, y, vnf_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CV RMSE of LinearRegression: 0.1007619172166632 (+/-0.048577241001214605)\n",
      "CV RMSE of Ridge: 0.09846542319497902 (+/-0.054905281452056726)\n",
      "CV RMSE of SVR: 0.1137247301735937 (+/-0.05484824766626287)\n",
      "CV RMSE of RandomForestRegressor: 0.1455038603264367 (+/-0.05878303166665511)\n",
      "CV RMSE of GradientBoostingRegressor: 0.14996980486497263 (+/-0.06365586377074277)\n",
      "CV RMSE of MLPRegressor: 0.10995078838090278 (+/-0.0530018834422286)\n",
      "CV RMSE of FixedModel: 0.38153965300099446 (+/-0.21077830340877302)\n",
      "CV RMSE of LinearRegression: 0.1007619172166632 (+/-0.048577241001214605)\n",
      "CV RMSE of Ridge: 0.10041876270886689 (+/-0.049194687501504145)\n",
      "CV RMSE of SVR: 0.08072140672886818 (+/-0.05972576935870195)\n",
      "CV RMSE of RandomForestRegressor: 0.14678998688976538 (+/-0.06171937756559354)\n",
      "CV RMSE of GradientBoostingRegressor: 0.13021697559496673 (+/-0.056544387699958544)\n",
      "CV RMSE of MLPRegressor: 0.09954138128380731 (+/-0.059572043597513134)\n",
      "CV RMSE of FixedModel: 0.38153965300099446 (+/-0.21077830340877302)\n"
     ]
    },
    {
     "data": {
      "text/plain": "[0.0, 0.0, -0.03138613700866699, 0.0]"
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "vnf_name = 'squid'\n",
    "X, y, scaler = prepare_data(squid, vnf_name)\n",
    "X_scaled = scaler.transform(X)\n",
    "\n",
    "models = train_tune_eval_models(X_scaled, y, vnf_name)\n",
    "predict_plot_all(models, scaler, X, y, vnf_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}