Version 4 RUL multiple_models-Copy1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Version 03 -> Pred RUL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: texttable in /home/yash/anaconda3/lib/python3.8/site-packages (1.6.3)\n",
      "3.8.5\n"
     ]
    }
   ],
   "source": [
    "!pip install texttable\n",
    "from platform import python_version\n",
    "print(python_version())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{132: ['B0018'], 168: ['B0005', 'B0006', 'B0007']}\n"
     ]
    }
   ],
   "source": [
    "# importing required libraries\n",
    "from scipy.io import loadmat\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from pprint import pprint as pp\n",
    "from sklearn.pipeline import make_pipeline\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "from pprint import pprint\n",
    "from sklearn.linear_model import LinearRegression, Ridge, Lasso, BayesianRidge, ARDRegression, SGDRegressor\n",
    "from texttable import Texttable\n",
    "import math\n",
    "from sklearn.metrics import r2_score\n",
    "\n",
    "# getting the battery data\n",
    "# bs_all = [\n",
    "#     'B0005', 'B0006', 'B0007', 'B0018', 'B0025', 'B0026', 'B0027', 'B0028', 'B0029', 'B0030', 'B0031', 'B0032', \n",
    "#     'B0042', 'B0043', 'B0044', 'B0045', 'B0046', \n",
    "#     'B0047', 'B0048'\n",
    "# ]\n",
    "bs_all = [\n",
    "    'B0005', 'B0006', 'B0007', 'B0018'\n",
    "]\n",
    "ds = {}\n",
    "for b in bs_all:\n",
    "    ds[b] = loadmat(f'DATA/{b}.mat')\n",
    "    \n",
    "types = {}\n",
    "times = {}\n",
    "ambient_temperatures = {}\n",
    "datas = {}\n",
    "\n",
    "for b in bs_all:\n",
    "    x = ds[b][b][\"cycle\"][0][0][0]\n",
    "    ambient_temperatures[b] = x['ambient_temperature']\n",
    "    types[b] = x['type']\n",
    "    times[b] = x['time']\n",
    "    datas[b] = x['data']\n",
    "\n",
    "# clubbing all the compatible batteries together\n",
    "# Batteries are compatible if they were recorded under similar conditions\n",
    "# And their data size match up\n",
    "bs_compt = {}\n",
    "\n",
    "for b in bs_all:\n",
    "    sz = 0\n",
    "    for j in range(datas[b].size):\n",
    "        if types[b][j] == 'discharge':\n",
    "            sz += 1\n",
    "    if bs_compt.get(sz):\n",
    "        bs_compt[sz].append(b)\n",
    "    else: \n",
    "        bs_compt[sz] = [ b ]\n",
    "pp(bs_compt)\n",
    "BSSS = bs_compt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "## CRITICAL TIME POINTS FOR A CYCLE\n",
    "## We will only these critical points for furthur training\n",
    "\n",
    "## TEMPERATURE_MEASURED\n",
    "## => Time at highest temperature\n",
    "\n",
    "## VOLTAGE_MEASURED\n",
    "## => Time at lowest Voltage\n",
    "\n",
    "## VOLTAGE_LOAD\n",
    "## => First time it drops below 1 volt after 1500 time\n",
    "\n",
    "def getTemperatureMeasuredCritical(tm, time):\n",
    "    high = 0\n",
    "    critical = 0\n",
    "    for i in range(len(tm)):\n",
    "        if (tm[i] > high):\n",
    "            high = tm[i]\n",
    "            critical = time[i]\n",
    "    return critical\n",
    "\n",
    "def getVoltageMeasuredCritical(vm, time):\n",
    "    low = 1e9\n",
    "    critical = 0\n",
    "    for i in range(len(vm)):\n",
    "        if (vm[i] < low):\n",
    "            low = vm[i]\n",
    "            critical = time[i]\n",
    "    return critical\n",
    "\n",
    "def getVoltageLoadCritical(vl, time):\n",
    "    for i in range(len(vl)):\n",
    "        if (time[i] > 1500 and vl[i] < 1):\n",
    "            return time[i]\n",
    "    return -1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MODEL\n",
    "* Considering 1 Cycle for RUL estimation\n",
    "\n",
    "## Features\n",
    "* [CP1, CP2, CP3, Capacity] -> RUL\n",
    "\n",
    "## Remaining Useful Life\n",
    "* n = number of cycles above threshold\n",
    "* RUL of Battery after (cycle x) = (1 - (x / n)) * 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "## X: Features\n",
    "## y: RUL\n",
    "## x: no. of cycles to merge\n",
    "def merge(X, y, x):\n",
    "    XX = []\n",
    "    yy = []\n",
    "    \n",
    "    sz = len(X)\n",
    "    for i in range(sz - x + 1):\n",
    "        curr = []\n",
    "        for j in range(x):\n",
    "            for a in X[i + j]:\n",
    "                curr.append(a)\n",
    "        XX.append(curr)\n",
    "#         val = 0\n",
    "#         for j in range(x):\n",
    "#             val += y[i + j]\n",
    "#         val /= x\n",
    "        yy.append(y[i + x - 1])\n",
    "        \n",
    "    return XX, yy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Data Structure\n",
    "    # Cycles[battery][param][cycle]\n",
    "    # Cycles[battery][Capacity][cycle]\n",
    "\n",
    "Cycles = {}\n",
    "params = ['Temperature_measured', 'Voltage_measured', 'Voltage_load', 'Time']\n",
    "\n",
    "rmses = []\n",
    "\n",
    "for bs_cmpt in bs_compt:\n",
    "    rmses.append([])\n",
    "\n",
    "# iterate over the merge hyper parameter\n",
    "for xx in range(1, 10):\n",
    "\n",
    "    results = Texttable()\n",
    "    results.add_row(['Compatible Batteries', 'Cycles', 'MAE', 'RMSE', 'R2 Score' ])\n",
    "    \n",
    "    loc = 0\n",
    "    \n",
    "    # iterate over all the battery sets\n",
    "    for bs_cmpt in bs_compt:\n",
    "        # getting data for a given set\n",
    "\n",
    "        # y contains RUL after current cycle\n",
    "        # model will train for y\n",
    "        y = []\n",
    "\n",
    "        bs = bs_compt[bs_cmpt]\n",
    "        for b in bs:\n",
    "            Cycles[b] = {}\n",
    "            for param in params:\n",
    "                Cycles[b][param] = []\n",
    "                for j in range(datas[b].size):\n",
    "                    if types[b][j] == 'discharge':\n",
    "                        Cycles[b][param].append(datas[b][j][param][0][0][0])\n",
    "\n",
    "            cap = []\n",
    "            for j in range(datas[b].size):\n",
    "                if types[b][j] == 'discharge':\n",
    "                    cap.append(datas[b][j]['Capacity'][0][0][0][0])\n",
    "            Cycles[b]['Capacity'] = np.array(cap)\n",
    "            Cycles[b]['count'] = len(Cycles[b][params[0]])\n",
    "\n",
    "            effective_cycle_count = 0\n",
    "            for x in Cycles[b]['Capacity']:\n",
    "                if (x < 1.4):\n",
    "                    break\n",
    "                effective_cycle_count += 1\n",
    "\n",
    "            for i in range(len(Cycles[b]['Capacity'])):\n",
    "                if (i < effective_cycle_count):\n",
    "                    y.append((1 - ((i + 1) / effective_cycle_count)) * 100)\n",
    "                else:\n",
    "                    y.append(0)\n",
    "\n",
    "        # preparing data for regression model\n",
    "        temperature_measured = []\n",
    "        voltage_measured = []\n",
    "        voltage_load = []\n",
    "        capacity = []\n",
    "\n",
    "        for b in bs:        \n",
    "            for c in Cycles[b]['Capacity']:\n",
    "                capacity.append(c)\n",
    "            for i in range(Cycles[b]['count']):\n",
    "                temperature_measured.append(getTemperatureMeasuredCritical(Cycles[b]['Temperature_measured'][i], Cycles[b]['Time'][i]))\n",
    "                voltage_measured.append(getVoltageMeasuredCritical(Cycles[b]['Voltage_measured'][i], Cycles[b]['Time'][i]))\n",
    "                voltage_load.append(getVoltageLoadCritical(Cycles[b]['Voltage_load'][i], Cycles[b]['Time'][i]))\n",
    "\n",
    "        # creating the model\n",
    "        X = []\n",
    "        for i in range(len(temperature_measured)):\n",
    "            X.append(np.array([temperature_measured[i], voltage_measured[i], voltage_load[i], capacity[i]]))\n",
    "    #     X.append(np.array(capacity))\n",
    "        X = np.array(X)\n",
    "        y = np.array(y)\n",
    "        \n",
    "        # merge cycles\n",
    "        X, y = merge(X, y, xx)\n",
    "\n",
    "        # creating train test split\n",
    "        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)\n",
    "\n",
    "        # fitting the model\n",
    "        regressor = LinearRegression()\n",
    "        regressor.fit(X_train, y_train)\n",
    "\n",
    "        # test\n",
    "        y_pred = regressor.predict(X_test)\n",
    "\n",
    "        # model evaluation\n",
    "        diff = 0\n",
    "        total = 0\n",
    "        rmse = 0\n",
    "        for i in range(len(y_test)):\n",
    "            diff += abs(y_test[i] - y_pred[i])\n",
    "            rmse += ((y_test[i] - y_pred[i]) * (y_test[i] - y_pred[i]))\n",
    "            total += y_test[i]\n",
    "        diff /= len(y_test)\n",
    "        total /= len(y_test)\n",
    "        rmse = math.sqrt(rmse / len(y_test))\n",
    "    #     accuracy = ((total - diff) / total) * 100\n",
    "        accuracy = r2_score(y_test, y_pred)\n",
    "\n",
    "        # Adding evaluation to result array to print in a table\n",
    "        results.add_row([ str(bs), str(Cycles[bs[0]]['count']), diff, rmse, accuracy ])\n",
    "        \n",
    "        rmses[loc].append(rmse)\n",
    "        loc += 1\n",
    "\n",
    "    # printing results\n",
    "#     print(f'Evaluation: Clubbing Compatible Batteries for cycle param: {xx}\\n{results.draw()}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print(rmses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for rm in rmses:\n",
    "    plt.plot(range(1, len(rm) + 1), rm)\n",
    "    plt.ylabel(\"Error\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def removeFromGroup(x):\n",
    "    loc = 0\n",
    "    y = {}\n",
    "    for a in x:\n",
    "        for b in x[a]:\n",
    "            y[loc] = [ b ]\n",
    "            loc += 1\n",
    "    return y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: scikit-elm in /home/yash/anaconda3/lib/python3.8/site-packages (0.21a0)\n",
      "Requirement already satisfied: scipy in /home/yash/anaconda3/lib/python3.8/site-packages (from scikit-elm) (1.5.2)\n",
      "Requirement already satisfied: scikit-learn in /home/yash/anaconda3/lib/python3.8/site-packages (from scikit-elm) (0.23.2)\n",
      "Requirement already satisfied: numpy in /home/yash/anaconda3/lib/python3.8/site-packages (from scikit-elm) (1.19.2)\n",
      "Requirement already satisfied: threadpoolctl>=2.0.0 in /home/yash/anaconda3/lib/python3.8/site-packages (from scikit-learn->scikit-elm) (2.1.0)\n",
      "Requirement already satisfied: joblib>=0.11 in /home/yash/anaconda3/lib/python3.8/site-packages (from scikit-learn->scikit-elm) (0.17.0)\n",
      "Requirement already up-to-date: pyswarm in /home/yash/anaconda3/lib/python3.8/site-packages (0.6)\n",
      "Requirement already satisfied, skipping upgrade: numpy in /home/yash/anaconda3/lib/python3.8/site-packages (from pyswarm) (1.19.2)\n"
     ]
    }
   ],
   "source": [
    "!pip install scikit-elm\n",
    "!pip install --upgrade pyswarm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|          | 0/40 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[  1.         241.17417324]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[  1.         654.47252337]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[  1.         758.03338547]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  2%|▎         | 1/40 [06:44<4:22:49, 404.35s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[  1.         463.76677774]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[  1.         491.89155856]\n",
      "Stopping search: Swarm best position change less than 1e-08\n",
      "[1.e+05 1.e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[  1.         821.53790896]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  5%|▌         | 2/40 [12:14<4:02:03, 382.21s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[  1.         508.71479191]\n",
      "Stopping search: Swarm best position change less than 1e-08\n",
      "[ 1. 10.]\n",
      "Stopping search: Swarm best position change less than 1e-08\n",
      "[1.e+05 1.e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[3.65773170e+04 1.25842888e+01]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  8%|▊         | 3/40 [15:41<3:23:12, 329.54s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[115.95390337 767.21781795]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[ 93.62135941 240.5641288 ]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[63322.97960472    79.52687511]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[9.64098243e+04 2.03144449e+01]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 10%|█         | 4/40 [17:45<2:40:46, 267.96s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[  1.         190.48187795]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[  1.         319.62759194]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[9.20144576e+04 1.67587308e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[5.43956988e+04 1.87513481e+01]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 12%|█▎        | 5/40 [19:38<2:09:04, 221.27s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: Swarm best position change less than 1e-08\n",
      "[   1. 1000.]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[214.92208918 176.20256591]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[9.95388213e+04 2.40869760e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[7.10083819e+04 2.12364125e+01]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 15%|█▌        | 6/40 [22:33<1:57:32, 207.43s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[  1.         576.63512424]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[268.29506378 823.47290569]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[8.20912476e+04 1.49441270e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[5338.25327994  400.77230459]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 18%|█▊        | 7/40 [28:35<2:19:38, 253.88s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[  1.         421.21745823]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[256.58846144 303.10143634]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[8.67956862e+04 2.40366523e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[61944.58381592   232.73381352]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 20%|██        | 8/40 [32:11<2:09:19, 242.49s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[  1.         599.80719006]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[448.98833767 711.98524116]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[96033.47180724   315.46464995]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[50445.4164644    338.07879341]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 22%|██▎       | 9/40 [37:20<2:15:33, 262.37s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[  1.         269.67330066]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[308.301603   590.61957522]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[6.33090010e+04 4.30733126e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[66350.98971252   118.67230847]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 25%|██▌       | 10/40 [41:34<2:09:57, 259.91s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[  1.         505.48297631]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[69.30728405 86.5543112 ]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[41374.7914552     47.81670356]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[40132.53132223   203.57817194]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 28%|██▊       | 11/40 [43:53<1:48:05, 223.65s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[6.20256000e+04 3.77518983e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[  1.        499.2079841]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[58836.06645456   243.9455528 ]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[91799.26474941   201.89455885]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 30%|███       | 12/40 [48:42<1:53:32, 243.29s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[  1.         608.63836236]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[  1.         217.07300556]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[5.85520651e+04 5.46593436e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[85066.51729799   963.34445157]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 32%|███▎      | 13/40 [55:29<2:11:31, 292.26s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[  1.        260.8912159]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[  1.         199.96434264]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[94675.55660884   301.17537854]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[100000.            730.46950423]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 35%|███▌      | 14/40 [1:01:38<2:16:38, 315.34s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[  1.         616.65430248]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[  1.         195.65822554]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[94723.11997121   173.97937874]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[89946.89155109   944.34403199]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 38%|███▊      | 15/40 [1:08:37<2:24:21, 346.47s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[  1.         250.89259698]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[ 51.86700525 781.3834172 ]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[5.37977136e+04 3.93128290e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[44334.03573989   409.99073156]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 40%|████      | 16/40 [1:13:49<2:14:26, 336.10s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[5.80584442e+04 1.62767758e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[147.05427847 423.88331786]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[8.54612490e+04 6.60477416e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[80425.04529221   750.91134884]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 42%|████▎     | 17/40 [1:21:24<2:22:35, 371.96s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[  1.         474.62130987]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[395.9081183  731.39952547]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[76745.91725399    97.13969202]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[56219.16500351   453.2719349 ]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 45%|████▌     | 18/40 [1:27:18<2:14:23, 366.53s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[  1.         241.21196884]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[181.98777939 566.3759468 ]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[82319.66534839   111.00452436]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[53366.90813968   607.1493755 ]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 48%|████▊     | 19/40 [1:33:31<2:08:55, 368.36s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[  1.         250.39960625]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[153.02353165 543.92400163]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[90260.56975272   123.16702189]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[37531.67783226   361.75337162]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 50%|█████     | 20/40 [1:37:58<1:52:42, 338.12s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[7.71494161e+04 1.00000000e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[182.41238632 481.36901907]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[97746.32646895   123.38345426]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[50081.53079102   583.60527165]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 52%|█████▎    | 21/40 [1:44:11<1:50:18, 348.36s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[1687.98227952  507.79634485]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[150.91820213 451.47709281]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[81767.77866976   208.04636815]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[45797.86189061   310.36274688]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 55%|█████▌    | 22/40 [1:50:48<1:48:56, 363.16s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[  1.         632.02037657]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[ 78.9791837  242.06511928]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[98053.39052658   401.62786258]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[72585.39529677   977.60423662]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 57%|█████▊    | 23/40 [2:01:46<2:07:56, 451.56s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[5.8677362e+04 1.0000000e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[2.96008902e+04 1.49173624e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[6.99023062e+04 1.17252877e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[72874.1504955    592.64196413]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 60%|██████    | 24/40 [2:08:37<1:57:06, 439.17s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[37102.84421189    37.97540734]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[ 55.50915314 223.98442584]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[81277.77987469   260.59561722]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[40635.72669016   630.91503222]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 62%|██████▎   | 25/40 [2:16:18<1:51:28, 445.89s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[7.99361167e+04 2.88826845e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[160.44942768 888.24056992]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[90735.77697163   558.84092351]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[54787.01629187   611.44168184]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 65%|██████▌   | 26/40 [2:29:27<2:08:03, 548.84s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[ 54.68445036 431.67461427]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[4.17137199e+04 1.96458432e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[88491.94794881   231.5016125 ]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[88087.60979325   531.55124104]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 68%|██████▊   | 27/40 [2:33:42<1:39:48, 460.63s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[6.86387054e+04 1.28747672e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[185.45472042 597.81914237]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[98726.21426004   292.86724487]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[60475.58853524   592.97611372]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 70%|███████   | 28/40 [2:40:31<1:29:02, 445.24s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[6.76695091e+04 1.71836907e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[207.88364384 567.24695535]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[100000.   1000.]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[49638.33543837   702.26843472]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 72%|███████▎  | 29/40 [2:52:28<1:36:32, 526.55s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[6.28891367e+04 2.07412826e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[314.82722769 418.30991478]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[5.94310980e+04 1.78673402e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[43251.10245517  1000.        ]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 75%|███████▌  | 30/40 [3:01:27<1:28:23, 530.33s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[5.71996752e+04 1.14826202e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[ 97.02807453 529.60481067]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[95433.83608029   889.84146232]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[27936.00160193   444.8676675 ]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 78%|███████▊  | 31/40 [3:10:47<1:20:53, 539.31s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[9.53907223e+04 1.74756424e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[7.26643222e+04 3.77817703e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[91543.24418606   545.83949234]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[32820.93220607   729.70855206]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 80%|████████  | 32/40 [3:17:48<1:07:11, 503.98s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[9.31882959e+04 1.22327443e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[391.82144485 961.15874495]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[91256.54232065   177.3675286 ]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[61469.90629707   694.29486353]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 82%|████████▎ | 33/40 [3:27:23<1:01:15, 525.07s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[7.72659349e+04 2.10673008e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[5.68648042e+04 3.17345041e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[83712.20181637   104.34014104]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[60413.22847573   875.00855838]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 85%|████████▌ | 34/40 [3:34:33<49:39, 496.54s/it]  "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[5.18937202e+04 1.09867074e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[1732.43708305  264.91696223]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[70131.27961635   501.12123345]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[39812.83038951   698.66531899]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 88%|████████▊ | 35/40 [3:41:42<39:41, 476.25s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[2.28269944e+04 1.43905238e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[243.53458777 259.82044525]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[64145.78840227   521.09427685]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[54794.58733125   737.48210665]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 90%|█████████ | 36/40 [3:49:05<31:05, 466.31s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[3.46644594e+04 1.00000000e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[5.69189648e+04 3.11199031e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[99231.99585967   248.85994056]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[55532.99242176   814.01611345]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 92%|█████████▎| 37/40 [3:56:00<22:32, 450.96s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[6.42702230e+04 5.24507872e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[7.89930051e+04 4.03144710e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[76773.51090111   211.54539933]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[87203.68143554   883.03779515]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 95%|█████████▌| 38/40 [4:03:37<15:05, 452.72s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[4.09779248e+04 1.96444425e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[4.9795638e+04 1.0000000e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[80052.4176749    384.78212381]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[83202.60843312   977.61174059]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 98%|█████████▊| 39/40 [4:12:40<07:59, 479.77s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[7.07689505e+04 2.79593621e+01]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[43923.043915    178.4570475]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[96502.4871424    405.80138942]\n",
      "Stopping search: maximum iterations reached --> 100\n",
      "[74330.877782     837.12277996]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 40/40 [4:20:34<00:00, 390.87s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping search: maximum iterations reached --> 100\n",
      "[6.71535145e+04 2.98788748e+01]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "## Data Structure\n",
    "    # Cycles[battery][param][cycle]\n",
    "    # Cycles[battery][Capacity][cycle]\n",
    "\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from tqdm import tqdm    \n",
    "    \n",
    "Cycles = {}\n",
    "params = ['Temperature_measured', 'Voltage_measured', 'Voltage_load', 'Time']\n",
    "\n",
    "# remove batteries from group\n",
    "bs_compt = BSSS\n",
    "bs_compt = removeFromGroup(bs_compt)\n",
    "\n",
    "\n",
    "rmses = []\n",
    "rmses_train = []\n",
    "\n",
    "for bs_cmpt in bs_compt:\n",
    "    rmses.append([bs_compt[bs_cmpt][0]])\n",
    "    rmses_train.append([bs_compt[bs_cmpt][0]])\n",
    "    \n",
    "\n",
    "hyper_params = []\n",
    "    \n",
    "# iterate over the merge hyper parameter\n",
    "for xx in tqdm(range(1, 41)):\n",
    "\n",
    "    results = Texttable()\n",
    "    results.add_row([ 'Compatible Batteries', 'Cycles', 'MAE', 'RMSE', 'R2 Score' ])\n",
    "    \n",
    "    loc = 0\n",
    "    \n",
    "    # iterate over all the battery sets\n",
    "    for bs_cmpt in bs_compt:\n",
    "        # getting data for a given set\n",
    "\n",
    "        # y contains RUL after current cycle\n",
    "        # model will train for y\n",
    "        y = []\n",
    "\n",
    "        bs = bs_compt[bs_cmpt]\n",
    "        for b in bs:\n",
    "            Cycles[b] = {}\n",
    "            for param in params:\n",
    "                Cycles[b][param] = []\n",
    "                for j in range(datas[b].size):\n",
    "                    if types[b][j] == 'discharge':\n",
    "                        Cycles[b][param].append(datas[b][j][param][0][0][0])\n",
    "\n",
    "            cap = []\n",
    "            for j in range(datas[b].size):\n",
    "                if types[b][j] == 'discharge':\n",
    "                    cap.append(datas[b][j]['Capacity'][0][0][0][0])\n",
    "            Cycles[b]['Capacity'] = np.array(cap)\n",
    "            Cycles[b]['count'] = len(Cycles[b][params[0]])\n",
    "\n",
    "            effective_cycle_count = 0\n",
    "            for x in Cycles[b]['Capacity']:\n",
    "                if (x < 1.4):\n",
    "                    break\n",
    "                effective_cycle_count += 1\n",
    "\n",
    "            for i in range(len(Cycles[b]['Capacity'])):\n",
    "                if (i < effective_cycle_count):\n",
    "                    y.append((1 - ((i + 1) / effective_cycle_count)) * 100)\n",
    "                else:\n",
    "                    y.append(0)\n",
    "\n",
    "        # preparing data for regression model\n",
    "        temperature_measured = []\n",
    "        voltage_measured = []\n",
    "        voltage_load = []\n",
    "        capacity = []\n",
    "\n",
    "        for b in bs:        \n",
    "            for c in Cycles[b]['Capacity']:\n",
    "                capacity.append(c)\n",
    "            for i in range(Cycles[b]['count']):\n",
    "                temperature_measured.append(getTemperatureMeasuredCritical(Cycles[b]['Temperature_measured'][i], Cycles[b]['Time'][i]))\n",
    "                voltage_measured.append(getVoltageMeasuredCritical(Cycles[b]['Voltage_measured'][i], Cycles[b]['Time'][i]))\n",
    "                voltage_load.append(getVoltageLoadCritical(Cycles[b]['Voltage_load'][i], Cycles[b]['Time'][i]))\n",
    "\n",
    "        # creating the model\n",
    "        X = []\n",
    "        for i in range(len(temperature_measured)):\n",
    "            X.append(np.array([temperature_measured[i], voltage_measured[i], voltage_load[i], capacity[i]]))\n",
    "    #     X.append(np.array(capacity))\n",
    "        X = np.array(X)\n",
    "        y = np.array(y)\n",
    "        \n",
    "        # merge cycles\n",
    "        X, y = merge(X, y, xx)\n",
    "\n",
    "        # creating train test split\n",
    "        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)\n",
    "        \n",
    "        ############## ------------------ MODEL ------------------- ####################\n",
    "        \n",
    "        ### Liner Regression with Ridge Regularization ###\n",
    "#         regressor = Ridge(alpha=0.5)\n",
    "#         regressor.fit(X_train, y_train)\n",
    "#         y_pred = regressor.predict(X_test)\n",
    "#         y_pred_train = regressor.predict(X_train)\n",
    "        \n",
    "        \n",
    "        ### ARDRegresssor ###\n",
    "#         regressor = ARDRegression()\n",
    "#         regressor.fit(X_train, y_train)\n",
    "#         y_pred = regressor.predict(X_test)\n",
    "#         y_pred_train = regressor.predict(X_train)\n",
    "        \n",
    "    \n",
    "        ### Bayes Model ###\n",
    "#         regressor = BayesianRidge()\n",
    "#         regressor.fit(X_train, y_train)\n",
    "#         y_pred = regressor.predict(X_test)\n",
    "#         y_pred_train = regressor.predict(X_train)\n",
    "        \n",
    "    \n",
    "        ## ELM Regressor with pso ###\n",
    "        from skelm import ELMRegressor\n",
    "        from pyswarm import pso\n",
    "        \n",
    "        def objective(aaa):\n",
    "            estimator = ELMRegressor(alpha = aaa[0], \n",
    "                                 n_neurons = aaa[1], \n",
    "                                 ufunc='relu', \n",
    "                                 include_original_features = False)\n",
    "        \n",
    "            estimator.fit(X_train, y_train)\n",
    "            y_pred = estimator.predict(X_test)\n",
    "            y_pred_train = estimator.predict(X_train)\n",
    "            \n",
    "            rmse = 0\n",
    "            for i in range(len(y_test)):\n",
    "                rmse += ((y_test[i] - y_pred[i]) * (y_test[i] - y_pred[i]))\n",
    "            rmse = math.sqrt(rmse / len(y_test))\n",
    "            \n",
    "            return rmse\n",
    "        \n",
    "        # bounds for hyper param\n",
    "        lb = [1, 10]\n",
    "        ub = [1e5, 1000]\n",
    "        \n",
    "        # optimizing\n",
    "        xopt, fopt = pso(objective, lb, ub)\n",
    "        print(xopt)\n",
    "        \n",
    "        hyper_params.append(xopt)\n",
    "        \n",
    "        estimator = ELMRegressor(alpha = xopt[0], \n",
    "                                 n_neurons = xopt[1], \n",
    "                                 ufunc='relu', \n",
    "                                 include_original_features = False)\n",
    "        \n",
    "        estimator.fit(X_train, y_train)\n",
    "        y_pred = estimator.predict(X_test)\n",
    "        y_pred_train = estimator.predict(X_train)\n",
    "\n",
    "\n",
    "        ### Decision Tree ###\n",
    "#         from sklearn import tree\n",
    "#         regressor = tree.DecisionTreeRegressor()\n",
    "#         regressor.fit(X_train, y_train)\n",
    "#         y_pred = regressor.predict(X_test)\n",
    "#         y_pred_train = regressor.predict(X_train)\n",
    "\n",
    "#         ### Random Forest Regressor ### (BEST)\n",
    "#         regressor = RandomForestRegressor(max_depth =10, random_state= 0)\n",
    "#         regressor.fit(X_train, y_train)\n",
    "#         y_pred = regressor.predict(X_test)\n",
    "#         y_pred_train = regressor.predict(X_train)\n",
    "        \n",
    "        ############# ----------------- MODEL -------------------- #####################\n",
    "\n",
    "        # model evaluation\n",
    "        diff = 0\n",
    "        total = 0\n",
    "        rmse = 0\n",
    "        for i in range(len(y_test)):\n",
    "            diff += abs(y_test[i] - y_pred[i])\n",
    "            rmse += ((y_test[i] - y_pred[i]) * (y_test[i] - y_pred[i]))\n",
    "            total += y_test[i]\n",
    "        diff /= len(y_test)\n",
    "        total /= len(y_test)\n",
    "        rmse = math.sqrt(rmse / len(y_test))\n",
    "        accuracy2 = ((total - diff) / total) * 100\n",
    "        accuracy = r2_score(y_test, y_pred)\n",
    "\n",
    "        # Adding evaluation to result array to print in a table\n",
    "#         results.add_row([ str(bs), str(Cycles[bs[0]]['count']), diff, rmse, accuracy, accuracy2 ])\n",
    "        \n",
    "        rmses[loc].append(rmse)\n",
    "        \n",
    "        #### adding rmses of the train\n",
    "        rmse_train = 0\n",
    "        for i in range(len(y_train)):\n",
    "            rmse_train += ((y_train[i] - y_pred_train[i]) * (y_train[i] - y_pred_train[i]))\n",
    "        rmse_train = math.sqrt(rmse_train / len(y_train))\n",
    "        rmses_train[loc].append(rmse_train)\n",
    "        loc += 1\n",
    "\n",
    "    # printing results\n",
    "#     print(f'Evaluation: Clubbing Compatible Batteries for cycle param: {xx}\\n{results.draw()}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minima Test: 2.707364917809226, Merge: 22\n",
      "Minima Train: 1.7808343756843918, Merge: 31\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minima Test: 6.0054530032164175, Merge: 40\n",
      "Minima Train: 1.7838643053600816, Merge: 40\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minima Test: 1.260004865426181, Merge: 40\n",
      "Minima Train: 0.43305201260295595, Merge: 40\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAD5CAYAAAAgGF4oAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAA8pElEQVR4nO3dd3xb1fn48c+RLFmSbXkkjp3tOAnZZDaDQMImbCijzFKgQCltoRvab+evtP1+yyhQRqFl07BX2RsSyHIG2TvOjke8ZGtL5/fHlbxi2fKUYj/v10svSVdX0vF9Jc89eu45z1Faa4QQQvQdpkQ3QAghRM+SwC+EEH2MBH4hhOhjJPALIUQfI4FfCCH6GAn8QgjRx6R01wcrpR4HzgFKtdYTI9tygBeAAqAYuFRrXdnWZ/Xv318XFBR0V1OFEKJXWrlyZbnWOrf5dtVd4/iVUvOAWuDpRoH//4AKrfVflVK3A9la61+29VkzZszQRUVF3dJOIYTorZRSK7XWM5pv77ZUj9b6C6Ci2ebzgacij58CLuiu7xdCCNGyns7x52mtDwJE7gf08PcLIUSfl7QXd5VSNyqlipRSRWVlZYlujhBC9Bo9HfhLlFIDASL3pbF21Fo/qrWeobWekZt7xLUJIYQQHdTTgf9N4JrI42uAN3r4+4UQos/rtsCvlFoILAHGKKX2KaWuB/4KnKaU2gacFnkuhBCiB3XbOH6t9eUxXjqlu75TCCFE25L24m5S2PIeVO9LdCuEEKJLSeCPRWt44SpY/miiWyKEEF1KAn8s/joIB8BbneiWCCFEl5LAH4uvJnLvSmw7hBCii0ngjyUa8CXwCyF6GQn8sXilxy+E6J0k8MciqR4hRC8lgT+W+lRPTWLbIYQQXUwCfyzS4xdC9FIS+GNpfHG3mxarEUKIRJDAH0v04m44CEFvYtsihBBdSAJ/LI1TPJLuEUL0IhL4Y2l8UVcCvxCiF5HAH0uTwC8je4QQvYcE/lgk1SOE6KUk8MfirQFHP+OxBH4hRC8igT8WnwucgxoeCyFELyGBPxafC5yDGx4LIUQvIYE/Fl9No8AvF3eFEL2HBP6WhEPgr4W0XDBZpMcvhOhVJPC3JBrobU5IzZDAL4ToVSTwtyQa6FMzJPALIXodCfwtaRL4nRL4hRC9igT+lkQv5qZKqkcI0ftI4G9JfY8/GvhlVI8QoveQwN8Sb7VxLxd3hRC9kAT+lsjFXSFELyaBvyWRQH/DC1vYXqMk8AshehUJ/C3x1aBRfLijjmKX2ViBK+hPdKuEEKJLSOBvic+FtmYAispQqrHNX5vQJgkhRFeRwN8Sbw1BawYAFUGbsU1G9gghegkJ/C3x1RAwpwFQ5rdGtkmeXwjRO0jgb4nPhTcS+Ev9lvptQgjRG0jgb4mvBo9yAHDQK4FfCNG7JCTwK6V+rJTaoJRar5RaqJSyJaIdMflc1GIE/opgav02IYToDXo88CulBgM/AmZorScCZuCynm5Hq7w1uLAD4NLGCaDdF3cPrYPHF4C/rosbJ4QQnZOoVE8KYFdKpQAO4ECC2tEyn4vqkBH4ayMngHb3+PcshT1LoGJnFzdOCCE6p8cDv9Z6P3AXsAc4CFRrrT/o6XbEFApA0ENFyIrZpHCTiqYDs3c9lca9u6Lr2yiEEJ2QiFRPNnA+MAIYBKQppa5qYb8blVJFSqmisrKynmtgJMCXB2wMy3EAiqAlvf2BPxrwoycAIYRIEolI9ZwK7NJal2mtA8CrwHHNd9JaP6q1nqG1npGbm9tzrYvk8ssCVgr7G0M6/ea0jvf4PdLjF0Ikl0QE/j3AbKWUQymlgFOATQloR8u8RuA/5E2lMNcI/F6To/0Xdz3S4xdCJKdE5PiXAS8Dq4B1kTY82tPtiCnSs6/WNvKcNjJSU3Arh+T4hRC9RkoivlRr/Tvgd4n47jZFAnyttpPtsJKdZjVG9kiOXwjRS8jM3eYiKR0XDnLSrGQ7LNToDgT++hy/BH4hRHKRwN9cJPDXajvZaVayHFaqQ7b2Bf5wGLxVxmNJ9QghkowE/uYiAd6FnRyHlZw0q1GTvz2B31cNOmw8lh6/ECLJSOBvzltDWKXgxUpOupUsh4XDgVRjIZZwKL7PiPbyLQ4ZzimESDoS+JvzufCZHVjNZtKsZnIcVg4H27kKl6fKuM8pNHr8WndLU4UQoiMk8Dfnq8Gt0shOs6CUIivNWl+pM+50T7SXn1MI4aBU9hRCJBUJ/M35XNQpB9kOY+WtHIeVWt3OQm3RvH6/kZHnku4RQiQPCfzN+VzUajs5aUbgz3ZY2l+hM5rjzxnZ9LkQQiQBCfzNeaupDhtDOQGyHFZc9T3+OMs2RHv8OSOaPhdCiCQggb85n4vKUCr9IoE/JzpzN/JaXDwVYMuEtEhxOQn8QogkIoG/Ge2r4XDQVp/jz3JYOpbjt+cYt+hzIYRIEhL4m/O5qKUhx2+zmAlZ0+tfi4u7AuzZYM9qeC6EEElCAn9jQR8q5MelG3L8AFa703jQnh6/IwfMFkh1yqgeIURSkcDfmLdRgTZHQ+B3ptnwqnbU6/FEevxg9Pol1SOESCIS+BtrVKAtp1GPPyfNGqnJ345RPdH8vj1HUj1CiKQigb+xZiWZo7Kik7ji6fGHguCtbujxO3Kkxy+ESCoS+BuLLsKCnSyHpX5zjsNCjY4z1eOtNu4d0R5/tuT4hRBJRQJ/Y5HAHkxJw2Yx12/OclipCtvQ3jhSPdEgX5/jl1SPECK5SOBvLBLYTfbMJpuzHRZqtYOQN44efzStY2/U4/dWx1/SWQghupkE/sYiPf7UtKwmm6Pr7sbV43c36/E7cgDdkAISQogEk8DfmM8IzqnpzXv8Rr0e5W9Hj9/RKNXTeLsQQiSYBP7GfC58WHCmpTfZHK3XY/bXtr2oyhE5/si95PmFEElCAn9jkZLMjWftQkO9HkUYAu7WP8NTCcoEqZFfDdHRPTKyRwiRJCTwNxLyVFPTbPIWGKmeuCt0uivAlgWmyKGN9vgl1SOESBIS+BsJuKupxV5fmTPKYTXjMcW5/GK0Tk+UpHqEEElGAn8jIU81Lu04osevlILUDONJW2UbGtfpAaP3j5JUjxAiaUjgb8zbtCRzYyZbnBU6G9fpASPlI4XahBBJRAJ/Y34XLuzkpFmOeCklOqmrzRx/ZdMeP8jsXSFEUpHA30iK34VLO47I8QNY0trR43fk4PIGeH75HrTWUqhNCJFUJPBHaY0lWEcddrJaCPy26Gze1gJ/0A9+F9izeWPNAW5/dR3bS2ulUJsQIqlI4I8KuDERImDJwGxSR7zsSM8CINxa2QZvlXFvz2b34ToADtV4I6ke6fELIZKDBP6oSE9eW9NbfNmZkY5PWwjUtVJzp1Gdnj0VxkSvQ9XeSI9fAr8QIjlI4I+KBH6V6mzx5WyHBRd2fO5WAn99nZ4c9lR4ACip8Ro5fr/LSAUJIUSCJSTwK6WylFIvK6U2K6U2KaXmJKIdTURLMjsyW3w5O7IKV7DVwG/0+LUtm73RHn+Nt2GUTzQVJIQQCZSoHv99wHta67HAZGBTgtrRIDIxy2KPEfgjhdpazfFHevzVKoNaXxCAQ9U+mb0rhEgqKT39hUopJzAP+A6A1toPJDwHor3VKI4syRyV7bBwEDu6tcVYIoF9jycVgBSTakj1gIzsEUIkhUT0+AuBMuAJpdRqpdS/lFJpCWhHE97IRVt7ek6Lr2enxVGT31MBphSKXcZhnTQks2mqRy7wCiGSQCICfwowDXhYaz0VqANub76TUupGpVSRUqqorKys2xvldVUB4HBmtfh6RmoKbuyYA7WxPyRSrmFvpXFh9xsFOZTX+gikSqpHCJE8EhH49wH7tNbLIs9fxjgRNKG1flRrPUNrPSM3N7fbG+WtNXrjzszsFl9XSuFLSccSrIv9Ie6K+jH8uRmpFPRLQ2soD0V+0EiPXwiRBHo88GutDwF7lVJjIptOATb2dDuaC7ircetUstIdMfcJWdJJDbUS+CPlGvZUuBmW4yA/08j1H/SYwZQiOX4hRFJI1KieHwLPKaXWAlOAPyeoHfWCnuqYlTmjtDUDCwEI+lrewWMUaNtb4WFYjoM8pw2AkhqfFGoTQiSNHh/VA6C1XgPMSMR3x6K9LlzazoBWAr+yZUAtxmSvlNQjd/BUEsqfzIFqD0NzHORHAn/9BV5J9QghkoDM3I1QPhe1OEhPjX0ubKjJH2Msv7uCWpWO1jAsx1jQxWo2GYFfKnQKIZJEq4FfKfUjpdTQnmpMIpn9LrzmNGO1rRiiNfl1S5O4Ah4IejisjVo/w/s5UEoxwJlKSbVXUj1CiKTRVo///wHLlFKLlFLfV0p1//CaBEkJ1hJIaX06gTUyucvTUqG2SG++NGBcHB6WY9znO22RHL+keoQQyaGtwL8TGIJxApgObFRKvaeUukYpldHtretBqaFagiktV+aMitbkr6tuIYBHgvp+n43UFBO56cY1gLxMW2T2rtTkF0Ikh7YCv9Zah7XWH2itrwcGAQ8BCzBOCr2GLewmHKMyZ5Qjwxjj76ltIfBH0ji73akMzXFgitT0z3faOFTjRdtzIOg1UkJCCJFAbQX+JglvrXVAa/2m1vpyYFj3NauHhcM48KBSW/8Rk56ZBYC3turIFyM9/u211vo0D0CeMxW3P4TXEjmpSJ5fCJFgbQX+b8V6QWvda7quIZ8LExpTjMqcURmZRh2fgLuFi7uRNM7WmpRmgd8Y0lkVTm+ynxBCJEqr4/i11lsBlFJ5wGBAAwe01iU90LYeU1NVQTaQYm891ZOd4SSgzQQ9sS/u7vPZGdoo8EfH8peFHAxstJ8QQiRKq4FfKTUFeATIBPZHNg9RSlUB39dar+rW1vUQV/VhsgFrdEH1GJwOKzXYCXta6PG7KwibU/HSNNWTnxmZxBVwcGxkPyGESKS2Zu4+CdzUqKAaAEqp2cATGIuoHPVqq6sAsGdktbqf2aRwK3v9Mo1NeCrxWTIBxfB+R6Z69vvs9fsJIUQitZXjT2se9AG01kuBhNfQ7ypulxGMo6N2WuM1paH8LZRm9lTiNhsXh4dmNwR+m8VMlsPC7sjiLJLjF0IkWls9/neVUm8DTwN7I9uGAt8G3uvOhvUkb50R+KMXb1vjM6eREmw58FfpDHIzUrFbzU1eynfa2OcCUuyS6hFCJFxbF3d/pJQ6Ezgf4+Kuwqin/6DW+p0eaF+P8Edm4mZktR34gylp2Pwtj+M/HM5ukt+PynNGJnHZs8FT1dnmCiFEp7RZnVNr/S7wbg+0JWFCbiPw29q4uAsQsmSQ6t135AueSg4FBrcY+POdNjYerIGcHEn1CCESrq1RPSnA9cAFNBrOCbwB/FtrHejuBvaEcLTomjWOKhSpGdir3U23aY32VHCg2VDOqLxMG+W1PsKDszHJxV0hRIK11eN/BqgC/oCR4gGjds81wLO0MsHrqOJz4VZ2HKY4qlTbMkjHg8cfasjlB9yokJ9Knc7oGD1+rcGX4sRetb2LGy+EEO3TVuCfprUe02zbPmCpUmprN7Wpx5n9LjymdGIvutggxebEoXwcqHVjz4n8QohcsK0ivclQzqjoEoy1Zid2SfUIIRKsrS5upVLqEqVU/X5KKZNS6ltAr8lZmAO1BMzxjU5NcRhlHaqqGgXwSPqmSqfHvLgL4CLd2FfrTrZYCCE6rq3AfxlwMVCilNqqlNoGHAK+GXmtV0gN1RK0tF6SOcqaZgT+usikL6D+gm2dKaO+HHNj0cB/OJwO4WDLE8CEEKKHtDWcs5hIHl8p1Q9QWuvyHmhXj/EGQji0m5B1QFz7O9KzAKhzNfrBE+nx2zJz68sxN5bjsGIxK0pDkV8VngqwtV4XSAghukubwzmVUpkY9fcHA1opdQB4X2td1c1t6xFV7gDpeKCNksxR9pZq8kdy/M7slhcoM5kUAzJsHPI3KtuQXdDhNgshRGe0tebut4FVwImAA6NMw0nAyshrR72KOj8Zyt1mSeao9Ewj8PtqGyp06kiPP6d/Xsz35Wfa2OsxUj4ye1cIkUht9fh/DUxv3rtXSmUDyzBKORzVKt1+huOhpo2SzFHRBdcD7obA760pR+tUBvaPXesn32lj936r8UTG8gshEiieFbhaGoISptnqXEerCpebNOXD6oivxx9NCYW8DaWZ3dXlVNLyiJ6oPKeN7bUS+IUQiddWj/9OYJVS6gMairQNA07DWID9qFdbUwVAahyVOSM7Ao1m+wIBVznVuuUx/FH5makc9NvBhqR6hBAJ1WqPX2v9FDAD+BzwAX7gM2CG1vrJ7m5cT6irMXrf9shonTZZ0gijMPkaAn/YXUGlTm9Sjrm5PKeNICmELOnS4xdCJFQ8Rdoqgeejz5VS/THKOPQKvkhJZnOcF3cxmfCZHJga1eQ3+yrxpAw+ohxzY9ElGAPWLMwye1cIkUBtjeqZrZT6TCn1qlJqqlJqPbAeY0LXgp5pYvfyRUoyxzucE8DfrCZ/aqCGkK31VFF0CUZPilN6/EKIhGqrx/8P4FcYa+5+ApyptV6qlBoLLKQXLMYSdFcZD1Ljn1AVtKRj87rxB8NYzYr0sAuTo/XAX1+2QWWQLTl+IUQCtTWqJ0Vr/YHW+iXgUGTJRbTWm7u/aT2jfuH0dgT+sCWddDxUuf343dWkEMKa0b/V90SXYKwiXWryCyESqq3AH2702NPstaSvNLav0s1baw+0vlO0bk47Uj2kZpChPFS4/ZSUHATAkdnyrN3G8jJslIfSJNUjhEiotlI9k5VSNRhj9u2Rx0Se27q1ZV3gng+28t+1BxiS7WDK0KwjXtdaY/K7wEy7Ar+yOUmnmPK6AHVlhxgKZPVru9ZPXqaN0jKHsfxiOASm2BeDhRCiu7Q1nNOstXZqrTO01imRx9Hnlp5qZEf99tzxDMiwcctzq6h2H7lYWJ0/hF27CWMCa3xlmQFS7E7SlYdKt5/K8kMA9MvNb/N9+c5U9vvsgAZvdZv7CyFEd4hjyamjV5bDyj+umEqpy8vPXv4a3awOfmWdnwzcRklmFf9EZIsjk3SMwO+qKDW+Kyd2nZ6ofKeN/b7IDyVJ9wghEiRhgV8pZVZKrVZKvdWd3zN1WDa3nzmODzeW8PiXxU1eO1znJ0N5CFnakd8HUtMyyVAequp8eGvKADCl5bT5vrxMGxU6UvdfRvYIIRIkkT3+W4FNPfFF180t4LTxefz13U2s2VtVv72yzt+uksxR0VW4al3VBGojAdzedsmHfKeN6mjglx6/ECJBEhL4lVJDgLOBf/XQ93HXxZOPyPdXRFI9yta+wB89UXhdlShPJT6TA8xtX/LIc9qoJBr4pccvhEiMRPX4/w78gqbDRbtVpsPCg1dOa5Lvr3T7SVcezPFW5oyKBP6yw4dxhGvwW7Pielt+po1K3XSBdiGE6Gk9HviVUucApVrrlW3sd6NSqkgpVVRWVtYl3z1laBZ3NMr3V9T5cSpPfY39uEUme5WUlZFNLTqONA8YSzB6zWlolKR6hBAJk4ge/1zgPKVUMUbxt5OVUs8230lr/ajWeobWekZubtuTo+J17dwCTh+fx1/e2cTi7eVkKA+qHbN2gfoevy1cR5aqxZzWL663mUyK/hkO3OYMSfUIIRKmxwO/1voOrfUQrXUBcBnwidb6qp76fqUUf7t4MvmZNtbuq+7Qxd3o/ul4yKKW1Iz4Aj8Y6Z4apDSzECJxevU4foJ+KNl4xOZMh4V/XDENhzlEKv521ekBGgK/8pBjqiMlvR2B32mjUqdLjl8IkTAJDfxa68+01ud02xe8+UN4+rwWg+yUoVk89q0xxhNbxwK/kzoyqItrKGfUAGcqZaE0tKR6hBAJ0rt7/Mf9wAj6H/62xZfnDokMwWxvqsdq7D9IVWAmDPa2J29F5TttHA6nod2S6hFCJEbvDvz5k4zgv/oZKF585Ov1lTnb2eM3pxAy2xmqjHIN7enx52faqNLpaEn1CCESpHcHfoD5t0PWcPjvbRD0NX2tIyWZI8LWDIaocuOJI/4ef57TCPzmQC2EjiwcJ4QQ3a33B36rA865Bw5vg0X3NH3NG12Epf2BP8XhZLT1sPGkPT3+JrN3Jd0jhOh5vT/wA4w6FSZdAovuhrItDdujPX5bOydwASo1A0t03d325PgjqR5ARvYIIRKibwR+gDP+YtTc/+9tEI5UivB1vMff5D3t6PHbLGYC0RIP0uPvU77aUc5X28sT3Qwh+lDgT8+F0/8Ee76C1U8b23ztX2+3XuP32LPa9VZzdNy/DOnsE3zBEH/870aueGwZNz2zklpfMNFNEn1c3wn8AFOvgoITjOGdrhIj1WOyQEpq+z8r2uO3ZbZ7CcVUZzTwS4+/t9tVXsdFD3/F41/uYsGEfFy+IC8X7U10s0Qf17cCv1Jwzr0Q8MB7txsXd1Mz2rX6Vr1o4G9Hfj8qLbowu+T4e7XXV+/nnPsXsbfCw6NXT+eRq6czZWgWTy3ZTTis2/4AIbpJ3wr8AP1Hw7yfw4ZXYduH7Z+1G1Uf+OPP70dlZ+UQ0GbCdYc79t0iqdX5gvzspa+57YU1jB/k5N1bT+D0CcaazNfOLWBXeR2fbS3tsfb4g2F+/+YGzn1gMd5AqMe+VySvvhf4AebeBv3HQPWejl3YhYb3tWMMf1Relp0q0vC4JPD3NhsP1HDuPxbzyqp9/OjkUSy8YTaDsuz1r581aSB5zlSeaLYMaHcpdXm58l9LefKrYtbtr2bRNrm4LPpq4E+xwrn3GY9T2z+U03hfx3v8+U4bVToDv0v+E/Ymi7eVc8FDX1LrDfLcd2fxk9PHkGJu+l/MYjZx9ezhLNpWzrYSV7e2Z/WeSs59YDHr9ldz9yWTyXJYeHvtgW79TnF06JuBH2D4HDj9Tph6ZcfeHx3V04Ecf3QJxnCd5Ph7k5dW7sVpS+GdW0/guJH9Y+53+cxhWFNMPPFVcbe15fnle/jWP5diTTHx6s1zuWj6EM4Yn89Hm0ol3SP6cOAHo47PlCs69t5O9PjzIouuKxnV06sUFVcyc0QO/dNbHyXWLz2VC6YM4tVV+6hy+7u0Db5giF+9to7bX13HrMIc/vuD4xk/yOiknH3sQGp9Qb7Y2jUr2omjV98O/J3RiRx/vzQr1SqdFJ8E/t7iYLWH/VUepg+P79/DtXNH4A2EeX5F1w3tLKnxcvmjS/nPsj3cfOJInrx2JlkOa/3rc0b2I9th4e11B7vsO8XRSQJ/R3Ui1WMyKUqsw3EGymD3ki5umEiEomLjJD5jeHy/AMcNdDKnsB9Pf1VMMBTu9PfvOezmnAcWs/mQiwevmMYvF4zFbGo6TNliNnHGhHw+2lgi6Z4+TgJ/R+VNhDP+DGMWdOjti7Mv4LCpP7zzMwi1PZNTa83hWh8rd1fwUtFe7vlwK5sP1XTou0XXW7m7ErvFXJ9Wice1cws4UO3l/Q0lnf7+P761EY8/xGvfn8vZxw6Mud/Zxw6kzh/ic0n39GkpiW7AUctkgjm3dPjt2VlZ3FP5He4suYuvX7+X7QWXE9KacFjX35fX+ik+XMeucuPm8jY9QXyw4RBv/+iEI3p2oucV7a5g8tBMLOb4+1KnjMtjaI6dJ77c1WqwbsuibWV8tKmEXy4Yy5j81ocnzymMpHvWHuSMyNwC0fdI4E+QkbnpPLBuKmdZJjBx7T1cu2IIFTTtLSoFgzLtFOamccGUwRT0T2NEfwcj+qezdl8Vtz6/hheL9nL5zGEJ+isEGBO2Nh10cfP8ke16n9mkuGZOAX96exPr9lUzaUj7hxYHQ2H+31sbGZbj4LrjC9rcP8VsYsHEfN5YcwBvIITN0r5yI6J3kMCfILeeMprzJg/CWjkQ54un8/m0L6g69W7MJoXZpDApRYYtJeZ/zIJ+Dp5dupu7P9jCOccOJMNm6eG/QESt2VtFKKyZXtD+EV6XfmMo9364lSe+3MU935rS7vf/Z/ketpbU8shV00lNiS+Inz1pEAuX7+WzLWUsmJj4Xn+1J8DSnYeZMjSLPKct0c3pEyTHnyApZhOj8zIYPnY6atb3yNi4kKHuTQzKspPntJGbkdpqb0wpxf+cPZ7yWj8PfrqjB1sumisqrkQpmDas/YHfabNw8fQh/HftAUpd3na9t8rt554PtzKnsB9nTMiL+32zC3PISbMmxeieQCjMDU8XcdMzK5n154+Z/7dP+cXLX/PKyn3srXAnunm9lvT4k8H8X8K6l+Cdn8J3PzGuH8Rh8tAsvjl1MI8v3sWVs4YxNMcR91dWewJk2uVXQlco2l3BMQMyOnw8rzmugKeW7Oa5pXv48WnHxP2+v3+0jRpPgN+eOx7VjkKDKZHRPW+s2Z/wdM+f3trI8l0V/PqscSgFy3ZV8P6GEl4s2gfA4Cw7M0fkMGGQk37pVrIdVnLSGu4dVnO7/nZhkMCfDGxOY62AV28wFoaffk3cb/35gjG8s/4gf313Mw9eOa3N/bXW/PmdTfx78S4evmr6UXeB7401+3ll1X7+fc2Mdl1I7S6hsGb1nirOmzKow59RmJvOyWMH8Nyy3Xz/pJFxpWy2l7p4ZuluLps5jHED219o8JxjB7Jw+R4+21LKgokdv7DcGS+u2MtTS3Zz47xCbphXCMB3TygkHNZsKXGxfFcFy3Yd5outZby2en+Ln2E1m8hOs3DjvJFcf/yInmz+UU0Cf7KYdAkUPQ4f/R7GnRv3xLCBmXZumjeS+z7exneKK/hGQevve+izHTy2aBdOWwo/eWENr90yl2PyOliorocFQmH+993NHKj28tbaA1w4dUiim8SWQy5qfcG4x+/Hcu3cAq7+93JeLNrH1bOHt7qv1po/vrUJh9XMT9vxC6GxWSNy6Jdm5a21B+MK/MFQGJNSmLpoBNmqPZX8z+vrOWF0f35xxpgmr5lMinEDnYwb6OSa4wrQWlPlDlDp9lPpDlBZ56fC7aeyznj+2ZZSHvp0O9+eMzwpOgNHAzlKyUIpOOtv4K2CT+9s11tvml9InjOV//fWxlbrvD+zdDd/e38LF0wZxHu3zcORmsINTxd1edmA7vLmmgMcqPaSYUvh4c92JEVN+5W7jXpLbZ1w23L8qP5MHZbFb15fz+/eWI/HH3uC1adbSvliaxm3njKafm2Uh4glxWzijIn5fLK5tNXvAthf5eHkuz/nl6+s7dB3NVda4+V7z6wkP9PGA5dPPaKQXXNKKbLTrBTmpjN9eDanjs/j0hlDuWn+SG4/cyw/O30Mh+v8fL5F5ibESwJ/MsmfBN/4rtHzP/h13G9zWFP4xRljWbuvmtfXtPyT+I01+/ntG+s5ZewA/nbJZAZl2XnkqukcrPLyw4Wru2T2aHcKhzWPfL6DMXkZ/OG8CWwtqeWTzT1X0z6Wot2VDMhIZUi2ve2dW6GUYuENs7l2rpHvP/v+Razec2RJD38wzJ/e2kRh/zS+PaegU995zqSBuP0hPtsS+zgervVx9b+XsafCzUsr97Fmb1WnvtMXDPG9Z43lJx/99vQmJSU6av6YXPqnW3l55b5Of1ZfIYE/2Zz0a6MMxDs/Bx1/j/bCqYM5dkgm//feFtz+phO9Pt1cyk9f/JpvFOTw4JXT6n8OTx+ezZ8unMiibeX89d3NXfpndLWPN5eyrbSWm08cybmTBzE4y85Dn21Ht+MYtcXlDfDW2gNHHL/WFBVXMqMgu0suMNosZn537gT+891Z+IJhLnr4K+7+YAv+YMNJ+eklxewsr+PXZ4/DmtK5/75GQTkrb8UY3VPrC/KdJ1ZwoMrDE9d+g/7pVv789qYOH3OtNb97YwOr9lRx9yWTGZvfwUWQmrGYTZw/ZTAfby6hsu7o+PWaaBL4k409C079PexdBovvgdr4fr6aTMbwzkM1Xh79Ymf99hXFFXzv2ZWMHZjBv66ZccQIjktnDOU7xxXwr8W7eCVJe0xaax7+bDuDs+ycc+xALGYTN80vZNWeKlYUd77Q3bYSF795fT2z//wxP/jPau7/eHtc7ztU7W1XYbZ4HTeqP+/edgLfnDaEBz7ZzoUPfcmWQy4O1/q47+NtzDsml5PHDuj090RH93yy6ch0jzcQ4oanith0sIaHr5zOSWMG8OPTjmF5cQUfbOxYiYlnl+3h+RV7+cFJozhzUtdeUL54+hACIc2bX8t6A/GQwJ+MplwJw4+Hj/8Id42C+6fB67fAqqehfFvMXwIzR+Rw1qR8/vn5Tg5Ve9lwoJrrnlzB4Gw7T107E6c5BLsWwSd/gle+Czs+Aa359dnjmFPYjzteW9fpn/LdYUVxJav2VHHjvML6fPAl04fSL83KQ5/FF6SbC4bCvLf+EFc8tpTT7v2CF4r2smDiQGYX5vDCij1xFTEriuT3O3thtyVOm4W7LpnMo1dP51C1l3MfWMx1T67A7Q/xm7PHddkQxrOPHYgnEOLTRumeYCjMjxauZsnOw9x1yWROipxkvjVjKKMGpPPXdzcTaGdqcPmuCv7w5gZOHjugXUNW4zVuoJPxA528sio5Oy/JRkb1JCOTCb79OuxfBXuWGL3/Le/AmmeN1x39YOhsGDAWnIMhcyhkDoHMIdy+YBwfbSzl9lfXsnFfBTMtxdxzbA2Zr94Le5ZC0AvKZFQXXfcSDJmJZf4vefCKEzjvwS+56Zki/vuD4xnQwgxKrTU7yupYtusw+U4bJ48d0CNjqB/+bDs5aVYunTG0fpvdaubauQXc9cFWNh6oibs4WkWdn4XL9/Dc0t0cqPYyKNPGLxaM4VszhtIvPZWvdpRzxWPL+O/XB7ik0fe1pKi4/YXZ2uv0CflMG57Nr19bx/sbSvjOcQWM7sJRWLNG9KN/upW31x7krEkD0Vpzx6vr+GBjCb8/dzwXTB1cv2+K2cQdZ47l+qeKWLh8T9zXGPZVuvn+cysZluPg75dN6bbaUhdPH8If39rI1hLXUTNSLVEk8CcrswWGzTJuYPTyy7cZJ4I9S42Twbb3Idw0Hz0s1cliZy47dqYy0VxMRsgNXwIDJsCM62DEPBh+HKTYYPWzsPheeO4icgZNY+H8H3L623ZuenYlz984G6vZxM7yOpbsOMzSnYdZurOC8lpf/XedOm4Afzx/YpM1ZbvapoM1fLqljJ+edgx2a9M01dVzCnjk85088vkO7r98apufVVxex8WPfEV5rZ+5o/rxu/MmcMrYAU1Glcwp7MfoAek8taSYi6cPafXE1pHCbB3RPz2VR66aztf7qhnfgTH7rTGbFAsm5vPKyv24/UHu/XArL63cx62njOY7c48cF3/y2AHMKezH3z/axgVTB+Nso1RIZZ2fax5fjj8Y5tFvz2hz/844f8og/vzOJl5ZuY87zhrXbd/TG6iuvDjWXWbMmKGLiooS3YzkEw5BbQlU72tyC1Tu5eD+3aQPm0zOxFOhYB6k57b8GUE/fL0QFt0NVbupzhrPz0vP4EDeSZTUBihzGYE+z5nKnMJ+zC7sx8wROXyyuZS7P9iK2aT45YIxXDlreJeN8W7s1udX89HGEr66/RQyHUcGjb+8s4nHFu3k05+dyPB+aTE/53Ctj4se/opqT4Bnrp/FxMGxC6I9s3Q3v3l9Pa/cfBzTY6Rx6nxBjv3DB9w8fyQ/azYO/WizZMdhLn9sKSeM7s+ibeVcM2c4vz9vQsyT3vr91ZzzwGJuPnEkv1wwNubnevwhrvzXUtYfqOHZ62cxc0TXXgtpyQ1PF7FmbxVLbj+5zWGifYFSaqXWekbz7dLjP5qZzOAcZNyGzqzfbAHirteZYjVmCk+5Ata+SOaiu3jUei87q17m69zzYN6lTB03muH9HE0CQWFuOmdMyOdXr63jN29s4PU1B/jfiyYxakDX/cTeW+HmrbUHuW5uQYtBH+C640fwxJfFPPrFTu68cFKL+3j8Ia5/qoiD1V7+c8PsVoM+wDenDub/3t3M00uKYwb+zhRmSzbR5SIXbSvnvMmD+N25sYM+wMTBmVw4dTD/XryLq2YPZ3ALv/iCoTA/XLiKNXureOjK6T0S9AEumjaEDzeWsGh7OSeN6fwF8N5KTonCYLYYC8/fsgIu/CeFA3O5sPRBLvz0VAo+vgm19f0jFowZmuPg6etmcvclk9lRVstZ9y3mvo+2NRl+2BmPLdqJScH1xxfG3CfPaeOi6YN5aeW+FouchcKaHy5czdf7qrj/8qkxA3ljaakpXDxjCO+sOxizcFpnCrMlG7NJceupo7l85jDuumRyXL/cor9y7n5/yxGvaa35n9fX89GmUv5w/sQerQB68tgBZDssMqa/DT0e+JVSQ5VSnyqlNimlNiilbu3pNohWmFNg8mVw46dw8xKYdZOxPOTCb8G94+HD30LZ1vrdlVJcNH0IH/1kPgsm5nPvR1s554FFPPbFTl5fvZ8vt5eztcRFZZ2/XTNty2t9vLBiLxdOHUx+Zuulem+aN5JgKMzji4ubbNda87s31/PRphL+cN6EdtUlunr2cAIhzfPLW14Tt7OF2ZLN1bOH85dvTop7bsDgLDvXHz+CV1fvZ/3+6iav3fvRNp5fsZcfnjyqzfITXc2aYozp/3BjCdXuQI9+99EkEameIPBTrfUqpVQGsFIp9aHWemMC2iJakzcezrgTTvkdbPsA1jwHX/0DvrwP+o+BvAn1t/4DxnP/ZVM4f8ogfvvGBu58Z9MRH5diUvRPTyXPmcpZkwZy+axhMS/2PfllMf5QmBvntb24SUH/NM6cNJDnlhpFzqKf+cjnO3l26R5uml/Y7lmuhbnpzD8ml+eW7ebmE0c2uYDbFYXZeoObTxzJCyv2cufbm/jPDbNQSvHs0t3c//E2Lp0xhJ90w7DNeFw8fQhPflXMf9ce4KoePvEcLXo88GutDwIHI49dSqlNwGBAAn+ySrHCuHOMm6sE1r0IxV/C/iLY8GrDftYMTskbz8kTxuMZcSoHB8yjLHKBuLzWR5nLuO0sr+Mv727mH59s5/JZw7h2bgEDMxvyxLW+IE8vKeaM8fmMGpAeVxNvnj+St9ce5Jklu7nlpFG8vno///veZs6bPIhfnhH7AmRrrjluONc9WcT7Gw5xzrENQT5amO0bvSC/3xlOm4VbTxnN797cwKdbSvEHdX1ZkD9fOClh5ZInDHIyJi+DV1btk8AfQ0Iv7iqlCoCpwLJEtkO0Q0YeHPdD4wbgrYGyzVCyHko2QulG1PpXcax8gpE5hYyceZNx4djWtHe8fn81//xiJ/9atJPHF+/ivCmDuHFeIWPznSxctocab5DvnRj/UoYTB2cy75hcnvhyF+MHOvn5y18zuzCHv11ybIdHG80/ZgDDchw8/dXuJoF/Zf3ErZ65YJnMrpg1jCe/KuY3r2+grNbH5KFZ/OOKaQkdUaOU4uLpQ7jznU3sKKtlZG58nYe+JGHDOZVS6cDnwJ1a61dbeP1G4EaAYcOGTd+9e3cPt1B0WCgAm96EpY/AvuVgzYCpV8GsGyGn6YXavRVu/r14Fy+s2IsnEGL+MblsOljDqAHp/OeG2e362uiwRKVg9IB0XvrecZ3OwT/2xU7ufGcT7/zohPqJWrc+v5olOw6z7FenyCIgwPsbDnHTMyspzE3j5e8dR05a5wuvdVapy8ucv3zCTfMK+UUrQ07bUuX28/nWMoblOBib7zxiLkmyizWcMyGBXyllAd4C3tda39PW/jKO/yi2f6VxAtjwqjHv4JgFxgXjguONkUQRlXV+nl26m6eWFFNe6+eZ62dywugYcw9i0Fpz6T+XsLfCw6vfP65LJpZVuwPM+stHXDBlMH+96FgA5v71EyYPzeShK6d3+vN7A62NGjmzC/sl1Zq51z25go0Havjy9pM7NFu4ss7P5Y8tZfMhFwAmBSP6pzF+UCbjBmYwfqCT8YOcDMhInr+5uaQJ/MroIj0FVGitb4vnPRL4e4Gag1D0byh6AtzlYLbCgHFGKer8Y437vIl4zWnsKKtlwqDWx9rHUuczhpympXZdFvOOV9fy2ur9LL3jFLyBMLP/8jG/OWe8rPiU5N5ee5Bb/rOqQ52IGm+AKx9bxpYSF3//llFmYuOBGjYerGHTwRr2VXrq95042MkjV01nSHb8S5/2lGSawDUXuBpYp5RaE9n2K631Owloi+gpzoFw8v/ACT+Dre/CgdVwaB1sec8oHRFhyy5gwqCpMO0aKDzRWKCmHboy4EddPbuAhcv38lLRPgZmGb277ijMJrrWKeMGkGk3xvS3J/DX+YJc+8QKNh+q4Z9XT+fkscZC9o2HA1e7A2w6VMPafVU88Ml2LnjwSx799ox2z+sIh3W3zHhvSyJG9SwGJDHaV1lsMOFC4wZGDSLXIeMkcGitcV+8GDa8ZtQXmnMLTLoYUjq20lRXGD/IycyCHJ5eWszJYwZ0e2E20TVsFjPnTh7Iyyv3UeMNxFUnyBsIccPTRazeU8mDV0yrD/rNZToszI6UMDl57ACue7KIyx5dyl2XTOa8yW0P8w2Ewjz1VTH3fbSN608YwW2n9uzQV5m5KxJLKePXwDGnw7yfwaVPwY83wPkPGa+/8X34+yT44m/grkhYM685roC9FR5eKNrbI4XZRNe4ePpQvIEwP3lhDRsOVLe6rz8Y5uZnV7Jk52HuvnRy3GsGjBqQweu3zGXykEx+tHA19320rdXFapbuPMzZ9y/iT29vIt2Wwn0fb2PxtvJ2/V2dJf96RfJJSTXKR9z8JVz9mpH//+RPcM94eOvHUN6xGvydcfqEPPKcqXgDYRnGeRSZPCST204dzZIdhzn7/sV854nlLNt5+IjAHAyFufX51Xy6pYw7L5jEhVOHtOt7ctKsPPvdWXxz6mDu/WgrP35hzRFrOpTWeLnt+dVc9uhS3P4Qj317Bh//dD4jc9P58Ytr6gsi9gSpzimODqWbYMmDsPYFY3TQjOvgpF+Bo+eC8P0fb+OeD7fyxLXfkAJgR5lqd4Bnl+3m8cW7OFznZ9qwLG4+cRSnRBaZ+elLX/Pa6v389pzxXNeJi/Zaax76bAd/e38L04dn88+rp5Nlt/DUkt3c++FW/MEw35tfyM0njqofGrr5UA3n/eNLZo3I4alrZ3Zpzj9pRvV0hAR+Ua+2FD7/X2NB+tQMOPEOY4F6c/fXzKnzBXmpaC9XzR4uJX+PUt5AiJeK9vLPL3ayr9LD6AHpFPRP48ONJfz8jDHcctKoLvmed9Yd5McvrCE3I5X01BQ2H3Jx4phcfn/uBAr6H1k+/Nmlu/mf19dz+5lj+d78+CcutkUCv+hdSjbC+3fAzs+g/zFwxp9h9GmJbpU4SgRDYd5ed5CHP9vB5kMufnDSqC5fV+HrvVV89+kirGYTvz13PKePz4s54U9rzfefW8WHG0t48XtzuqzqqwR+0ftoDVvfg/d/BRU7YdRpxgkgNzHFwcTRR2vNngo3w3Ic3TIL2+MPYTapuKqeVnsCnHXfIpSCt390QpdUfo0V+OX3qjh6KQVjzoTvL4PT/2QsR/nwHGMh+ZVPQtmWmAvTCwFGXZ/h/dK6rfSG3WqOu9R1pt3CA1dM5VC1l9tfWdvqyKDOkh6/6D1qy+Czv8DG18F92Nhmz4Fhs43b0NkwaEpC5wQI0ZZHPt/BX9/dzJ8umNjp6qKS6hF9h9ZweEejhemXwuHIEFBzKuRPhLzILX+isaaArWMlIoToauGw5ponlrNsVwVv3DKXcQM7PllQAr/o22rLjBPAnqVw8GujjLSnsuH1zGHGSWDAeEjLhdR0sKYbI4dSMyKP08GebTwXohuVuXycdf8iMu0W3vzBXBzWjhVZSKZaPUL0vPRcGHeucYNIqYiDcGg9lKyDkg3G463vgW5tzWAFw+fCxG/C+AsgrV9PtF70MbkZqdx76RSueWI5i7aVt2vZ0HhIj1+IxoJ+8LnA7wJfLfhrI/eR51V7jGsI5VtBmWHkSTDxIhh7tqSLRJfbW+FmaE7Hq35KqkeIrqK1kSpa/4pxq9pjlJkefbrxi2LgZOg32li4XogEklSPEF1Fqcg6ApOMhej3r4R1LxsVRTe/ZexjtkLu2MhF5Oii9BONlFNHad3uMtVCtER6/EJ0lXDIqClUutEoL12ywbjVHmrYJz3f+EUQvQ2aAs7BRwb0oB9KNxjrFhxYDftXG2sbF86HeT83hqcK0QZJ9QiRKHXlkZPAeuOEcGANlG9puIjs6GecBPKPNa4vHFht7BvyG6/bs2HQNMgZYfyqcB+G4ccbZaw7sFiN6Dsk8AuRTPxu42RwcI1xO/A1lG0Ci8M4CQyeBoOmGres4Q3B3V8HK5+Cr+43RiUNnm78AjhmgZwAxBEk8AuR7IJ+MKWAKY4p/kEfrHkOFt9rXFzOmwhzfgDZw41JaimNbzbjmoPFASnW7v87RNKQwC9EbxQKGBeWF99jDDFtiyXNSB3Zs8Ge1ehxtpFKGnkyZA3r9maLniGjeoTojcwWmHI5HHupcW3A5zKuDQS9xi+IoNe4hfxGeslbZcxYjt7Ktxr37goIB4zP7D8GRp1i3IbPBYs9oX+i6HoS+IXoDUxmGHJExy5+Whsnge0fGbcV/4alDxlpouFzYdSpMOQb0H+U8etAHNUk8AshjAvDuWOM25xbjF8Hu78yTgI7PjYWvYly9If+o6HfqMj9aOM+Z2R81ydEwkngF0IcyeqA0acaN4CqvcYQ0/JtcHibseD91vdg9TMN73H0g8KTjOsEI08C56DEtF20SQK/EKJtWUON25gzm273VBklr8s2w64vYMcnsP5l47UB4xtOAsOOM65HBNwQ8DS69xhDVMMBY9RR9GZt9DglVYaqdjEZ1SOE6DrhsDHjeMcnsP1jY02E6ES0jlIm47pC1rDIbXiz+6FgPXIBcyGjeoQQPcFkaqhjNPfWhmsF+1YYcxQs9sjN0XBvdRivRX8F+N2Rx27j10DAA+7ySLppI2x5D0K+pt9rz4HMIZA5NHI/uOG5c7BxYjClGL86TCnGxfA+TAK/EKL7NL9W0BXCYagrNSauVe2Bqt1Qvc+4Ve6C4kXgq2njQ1SjE4HFWGQn1WkssmOL3EefW9ONE4UyNdzqn5uNx6aUZieWRo9TbA0L+1jTIvfpCa3eKoFfCHF0MZkgI9+4DZ3Z8j7eaqjeb5wMavZBwGtcRwgHIRQ07qPPg37jl4Wv2pgH4a6Ayt3GycPnMn55dIcUW+SXiKXRyUQ1PcEoM5z7dxh+XNd+dZd+mhBCJANbpnHLG9/5zwqHjYJ6Ogw61PA4HGq4b3wiCTV7HPQ0LOrjr2u497kiF7aDkc/Vjb6n0edb0zv/NzQjgV8IIVpjMgG9a35C7/prhBBCtEkCvxBC9DES+IUQoo9JSOBXSi1QSm1RSm1XSt2eiDYIIURf1eOBXyllBh4EzgTGA5crpbrg0rsQQoh4JKLHPxPYrrXeqbX2A88D5yegHUII0SclIvAPBvY2er4vsk0IIUQPSETgb6nM3hGV4pRSNyqlipRSRWVlZT3QLCGE6BsSMYFrHzC00fMhwIHmO2mtHwUeBVBKlSmldsf4vP5AeVc3sotI2zpG2tYx0raOS+b2daZtw1va2ONlmZVSKcBW4BRgP7ACuEJrvaGDn1fUUtnRZCBt6xhpW8dI2zoumdvXHW3r8R6/1jqolPoB8D5gBh7vaNAXQgjRfgmp1aO1fgd4JxHfLYQQfV1vmLn7aKIb0AppW8dI2zpG2tZxydy+Lm/bUbH0ohBCiK7TG3r8Qggh2uGoDvzJXPNHKVWslFqnlFqjlEroSvFKqceVUqVKqfWNtuUopT5USm2L3GcnUdt+r5TaHzl2a5RSZyWobUOVUp8qpTYppTYopW6NbE/4sWulbQk/dkopm1JquVLq60jb/hDZngzHLVbbEn7cGrXRrJRarZR6K/K8y4/bUZvqidT82QqchjE3YAVwudZ6Y0IbFqGUKgZmaK0TPjZYKTUPqAWe1lpPjGz7P6BCa/3XyEkzW2v9yyRp2++BWq31XT3dnmZtGwgM1FqvUkplACuBC4DvkOBj10rbLiXBx04ppYA0rXWtUsoCLAZuBb5J4o9brLYtIAn+zQEopX4CzACcWutzuuP/6tHc45eaP3HSWn8BVDTbfD7wVOTxUxhBo8fFaFtS0Fof1Fqvijx2AZswyosk/Ni10raE04bayFNL5KZJjuMWq21JQSk1BDgb+FejzV1+3I7mwJ/sNX808IFSaqVS6sZEN6YFeVrrg2AEEWBAgtvT3A+UUmsjqaCEpKEaU0oVAFOBZSTZsWvWNkiCYxdJV6wBSoEPtdZJc9xitA2S4LgBfwd+AYQbbevy43Y0B/64av4k0Fyt9TSM8tO3RFIaIj4PAyOBKcBB4O5ENkYplQ68Atymta5JZFuaa6FtSXHstNYhrfUUjJIsM5VSExPRjpbEaFvCj5tS6hygVGu9sru/62gO/HHV/EkUrfWByH0p8BpGaiqZlETyxNF8cWmC21NPa10S+c8ZBh4jgccukgd+BXhOa/1qZHNSHLuW2pZMxy7SnirgM4wcelIct6jGbUuS4zYXOC9yffB54GSl1LN0w3E7mgP/CmC0UmqEUsoKXAa8meA2AaCUSotccEMplQacDqxv/V097k3gmsjja4A3EtiWJqL/yCMuJEHHLnIh8N/AJq31PY1eSvixi9W2ZDh2SqlcpVRW5LEdOBXYTHIctxbblgzHTWt9h9Z6iNa6ACOefaK1voruOG5a66P2BpyFMbJnB/DrRLenUbsKga8jtw2JbhuwEOPnawDjl9L1QD/gY2Bb5D4nidr2DLAOWBv5Rz8wQW07HiN9uBZYE7mdlQzHrpW2JfzYAccCqyNtWA/8NrI9GY5brLYl/Lg1a+eJwFvdddyO2uGcQgghOuZoTvUIIYToAAn8QgjRx0jgF0KIPkYCvxBC9DES+IUQoo+RwC+EEH2MBH4hhOhjJPALIUQf8/8B+xeQXOdJXnIAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minima Test: 3.7085264564733005, Merge: 12\n",
      "Minima Train: 0.9159877777151173, Merge: 22\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hyper Parameters: [array([  1.        , 241.17417324]), array([  1.        , 654.47252337]), array([  1.        , 758.03338547]), array([  1.        , 463.76677774]), array([  1.        , 491.89155856]), array([1.e+05, 1.e+01]), array([  1.        , 821.53790896]), array([  1.        , 508.71479191]), array([ 1., 10.]), array([1.e+05, 1.e+01]), array([3.65773170e+04, 1.25842888e+01]), array([115.95390337, 767.21781795]), array([ 93.62135941, 240.5641288 ]), array([63322.97960472,    79.52687511]), array([9.64098243e+04, 2.03144449e+01]), array([  1.        , 190.48187795]), array([  1.        , 319.62759194]), array([9.20144576e+04, 1.67587308e+01]), array([5.43956988e+04, 1.87513481e+01]), array([   1., 1000.]), array([214.92208918, 176.20256591]), array([9.95388213e+04, 2.40869760e+01]), array([7.10083819e+04, 2.12364125e+01]), array([  1.        , 576.63512424]), array([268.29506378, 823.47290569]), array([8.20912476e+04, 1.49441270e+01]), array([5338.25327994,  400.77230459]), array([  1.        , 421.21745823]), array([256.58846144, 303.10143634]), array([8.67956862e+04, 2.40366523e+01]), array([61944.58381592,   232.73381352]), array([  1.        , 599.80719006]), array([448.98833767, 711.98524116]), array([96033.47180724,   315.46464995]), array([50445.4164644 ,   338.07879341]), array([  1.        , 269.67330066]), array([308.301603  , 590.61957522]), array([6.33090010e+04, 4.30733126e+01]), array([66350.98971252,   118.67230847]), array([  1.        , 505.48297631]), array([69.30728405, 86.5543112 ]), array([41374.7914552 ,    47.81670356]), array([40132.53132223,   203.57817194]), array([6.20256000e+04, 3.77518983e+01]), array([  1.       , 499.2079841]), array([58836.06645456,   243.9455528 ]), array([91799.26474941,   201.89455885]), array([  1.        , 608.63836236]), array([  1.        , 217.07300556]), array([5.85520651e+04, 5.46593436e+01]), array([85066.51729799,   963.34445157]), array([  1.       , 260.8912159]), array([  1.        , 199.96434264]), array([94675.55660884,   301.17537854]), array([100000.        ,    730.46950423]), array([  1.        , 616.65430248]), array([  1.        , 195.65822554]), array([94723.11997121,   173.97937874]), array([89946.89155109,   944.34403199]), array([  1.        , 250.89259698]), array([ 51.86700525, 781.3834172 ]), array([5.37977136e+04, 3.93128290e+01]), array([44334.03573989,   409.99073156]), array([5.80584442e+04, 1.62767758e+01]), array([147.05427847, 423.88331786]), array([8.54612490e+04, 6.60477416e+01]), array([80425.04529221,   750.91134884]), array([  1.        , 474.62130987]), array([395.9081183 , 731.39952547]), array([76745.91725399,    97.13969202]), array([56219.16500351,   453.2719349 ]), array([  1.        , 241.21196884]), array([181.98777939, 566.3759468 ]), array([82319.66534839,   111.00452436]), array([53366.90813968,   607.1493755 ]), array([  1.        , 250.39960625]), array([153.02353165, 543.92400163]), array([90260.56975272,   123.16702189]), array([37531.67783226,   361.75337162]), array([7.71494161e+04, 1.00000000e+01]), array([182.41238632, 481.36901907]), array([97746.32646895,   123.38345426]), array([50081.53079102,   583.60527165]), array([1687.98227952,  507.79634485]), array([150.91820213, 451.47709281]), array([81767.77866976,   208.04636815]), array([45797.86189061,   310.36274688]), array([  1.        , 632.02037657]), array([ 78.9791837 , 242.06511928]), array([98053.39052658,   401.62786258]), array([72585.39529677,   977.60423662]), array([5.8677362e+04, 1.0000000e+01]), array([2.96008902e+04, 1.49173624e+01]), array([6.99023062e+04, 1.17252877e+01]), array([72874.1504955 ,   592.64196413]), array([37102.84421189,    37.97540734]), array([ 55.50915314, 223.98442584]), array([81277.77987469,   260.59561722]), array([40635.72669016,   630.91503222]), array([7.99361167e+04, 2.88826845e+01]), array([160.44942768, 888.24056992]), array([90735.77697163,   558.84092351]), array([54787.01629187,   611.44168184]), array([ 54.68445036, 431.67461427]), array([4.17137199e+04, 1.96458432e+01]), array([88491.94794881,   231.5016125 ]), array([88087.60979325,   531.55124104]), array([6.86387054e+04, 1.28747672e+01]), array([185.45472042, 597.81914237]), array([98726.21426004,   292.86724487]), array([60475.58853524,   592.97611372]), array([6.76695091e+04, 1.71836907e+01]), array([207.88364384, 567.24695535]), array([100000.,   1000.]), array([49638.33543837,   702.26843472]), array([6.28891367e+04, 2.07412826e+01]), array([314.82722769, 418.30991478]), array([5.94310980e+04, 1.78673402e+01]), array([43251.10245517,  1000.        ]), array([5.71996752e+04, 1.14826202e+01]), array([ 97.02807453, 529.60481067]), array([95433.83608029,   889.84146232]), array([27936.00160193,   444.8676675 ]), array([9.53907223e+04, 1.74756424e+01]), array([7.26643222e+04, 3.77817703e+01]), array([91543.24418606,   545.83949234]), array([32820.93220607,   729.70855206]), array([9.31882959e+04, 1.22327443e+01]), array([391.82144485, 961.15874495]), array([91256.54232065,   177.3675286 ]), array([61469.90629707,   694.29486353]), array([7.72659349e+04, 2.10673008e+01]), array([5.68648042e+04, 3.17345041e+01]), array([83712.20181637,   104.34014104]), array([60413.22847573,   875.00855838]), array([5.18937202e+04, 1.09867074e+01]), array([1732.43708305,  264.91696223]), array([70131.27961635,   501.12123345]), array([39812.83038951,   698.66531899]), array([2.28269944e+04, 1.43905238e+01]), array([243.53458777, 259.82044525]), array([64145.78840227,   521.09427685]), array([54794.58733125,   737.48210665]), array([3.46644594e+04, 1.00000000e+01]), array([5.69189648e+04, 3.11199031e+01]), array([99231.99585967,   248.85994056]), array([55532.99242176,   814.01611345]), array([6.42702230e+04, 5.24507872e+01]), array([7.89930051e+04, 4.03144710e+01]), array([76773.51090111,   211.54539933]), array([87203.68143554,   883.03779515]), array([4.09779248e+04, 1.96444425e+01]), array([4.9795638e+04, 1.0000000e+01]), array([80052.4176749 ,   384.78212381]), array([83202.60843312,   977.61174059]), array([7.07689505e+04, 2.79593621e+01]), array([43923.043915 ,   178.4570475]), array([96502.4871424 ,   405.80138942]), array([74330.877782  ,   837.12277996]), array([6.71535145e+04, 2.98788748e+01])]\n"
     ]
    }
   ],
   "source": [
    "for i in range(len(rmses)):\n",
    "    rm = rmses[i]\n",
    "    rm_train = rmses_train[i]\n",
    "    \n",
    "    mn = 100000\n",
    "    mn_train = 100000\n",
    "    loc, loc_train = -1, -1\n",
    "    for i in range(1, len(rm)):\n",
    "        if (mn > rm[i]):\n",
    "            mn = rm[i]\n",
    "            loc = i\n",
    "        \n",
    "        if (mn_train > rm_train[i]):\n",
    "            mn_train = rm_train[i]\n",
    "            loc_train = i\n",
    "            \n",
    "    print(f\"Minima Test: {mn}, Merge: {loc}\")\n",
    "    print(f\"Minima Train: {mn_train}, Merge: {loc_train}\")\n",
    "    \n",
    "    fig, ax = plt.subplots()\n",
    "    ax.plot(range(1, len(rm)), rm[1:])\n",
    "    ax.plot(range(1, len(rm)), rm_train[1:])\n",
    "    plt.ylabel(rm[0])\n",
    "    plt.show()\n",
    "print(f\"Hyper Parameters: {hyper_params}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}