Version 2.0.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# VERSION 2.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib qt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{28: ['B0025', 'B0026', 'B0027', 'B0028'],\n",
      " 40: ['B0029', 'B0030', 'B0031', 'B0032'],\n",
      " 47: ['B0038', 'B0039', 'B0040'],\n",
      " 67: ['B0041'],\n",
      " 72: ['B0045', 'B0046', 'B0047', 'B0048'],\n",
      " 112: ['B0042', 'B0043', 'B0044'],\n",
      " 132: ['B0018'],\n",
      " 168: ['B0005', 'B0006', 'B0007'],\n",
      " 197: ['B0033', 'B0034', 'B0036']}\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.model_selection import train_test_split\n",
    "from pprint import pprint\n",
    "from sklearn.linear_model import LinearRegression\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",
    "    'B0033', 'B0034', 'B0036', 'B0038', 'B0039', 'B0040', 'B0041', 'B0042', 'B0043', 'B0044', 'B0045', 'B0046', \n",
    "    'B0047', 'B0048'\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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "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": [
    "## Considering All the Compatible Batteries Together"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluation: Clubbing Compatible Batteries\n",
      "+--------------------------------------+--------+-------+-------+----------+\n",
      "| Compatible Batteries                 | Cycles | MAE   | RMSE  | R2 Score |\n",
      "+--------------------------------------+--------+-------+-------+----------+\n",
      "| ['B0005', 'B0006', 'B0007']          | 168    | 0.013 | 0.015 | 0.995    |\n",
      "+--------------------------------------+--------+-------+-------+----------+\n",
      "| ['B0018']                            | 132    | 0.002 | 0.003 | 1.000    |\n",
      "+--------------------------------------+--------+-------+-------+----------+\n",
      "| ['B0025', 'B0026', 'B0027', 'B0028'] | 28     | 0.005 | 0.008 | 0.990    |\n",
      "+--------------------------------------+--------+-------+-------+----------+\n",
      "| ['B0029', 'B0030', 'B0031', 'B0032'] | 40     | 0.008 | 0.009 | 0.982    |\n",
      "+--------------------------------------+--------+-------+-------+----------+\n",
      "| ['B0033', 'B0034', 'B0036']          | 197    | 0.033 | 0.060 | 0.939    |\n",
      "+--------------------------------------+--------+-------+-------+----------+\n",
      "| ['B0038', 'B0039', 'B0040']          | 47     | 0.139 | 0.207 | 0.818    |\n",
      "+--------------------------------------+--------+-------+-------+----------+\n",
      "| ['B0041']                            | 67     | 0.007 | 0.010 | 1.000    |\n",
      "+--------------------------------------+--------+-------+-------+----------+\n",
      "| ['B0042', 'B0043', 'B0044']          | 112    | 0.336 | 0.369 | 0.739    |\n",
      "+--------------------------------------+--------+-------+-------+----------+\n",
      "| ['B0045', 'B0046', 'B0047', 'B0048'] | 72     | 0.050 | 0.105 | 0.906    |\n",
      "+--------------------------------------+--------+-------+-------+----------+\n"
     ]
    }
   ],
   "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",
    "results = Texttable()\n",
    "results.add_row(['Compatible Batteries', 'Cycles', 'MAE', 'RMSE', 'R2 Score' ])\n",
    "\n",
    "# iterate over all the battery sets\n",
    "for bs_cmpt in bs_compt:\n",
    "    # getting data for a given set\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",
    "    # 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]]))\n",
    "    X = np.array(X)\n",
    "    y = np.array(capacity)\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",
    "# printing results\n",
    "print(f'Evaluation: Clubbing Compatible Batteries\\n{results.draw()}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Considering One Battery at a time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluation: Considering Individual Battery\n",
      "+---------+--------+-------+-------+----------+\n",
      "| Battery | Cycles | MAE   | RMSE  | R2 Score |\n",
      "+---------+--------+-------+-------+----------+\n",
      "| B0005   | 168    | 0.000 | 0.000 | 1.000    |\n",
      "+---------+--------+-------+-------+----------+\n",
      "| B0006   | 168    | 0.002 | 0.003 | 1.000    |\n",
      "+---------+--------+-------+-------+----------+\n",
      "| B0007   | 168    | 0.002 | 0.003 | 1.000    |\n",
      "+---------+--------+-------+-------+----------+\n",
      "| B0018   | 132    | 0.002 | 0.003 | 1.000    |\n",
      "+---------+--------+-------+-------+----------+\n",
      "| B0025   | 28     | 0.003 | 0.003 | 0.952    |\n",
      "+---------+--------+-------+-------+----------+\n",
      "| B0026   | 28     | 0.008 | 0.011 | 0.994    |\n",
      "+---------+--------+-------+-------+----------+\n",
      "| B0027   | 28     | 0.003 | 0.005 | 0.787    |\n",
      "+---------+--------+-------+-------+----------+\n",
      "| B0028   | 28     | 0.000 | 0.001 | 0.999    |\n",
      "+---------+--------+-------+-------+----------+\n",
      "| B0029   | 40     | 0.005 | 0.006 | 0.978    |\n",
      "+---------+--------+-------+-------+----------+\n",
      "| B0030   | 40     | 0.004 | 0.005 | 0.986    |\n",
      "+---------+--------+-------+-------+----------+\n",
      "| B0031   | 40     | 0.005 | 0.006 | 0.966    |\n",
      "+---------+--------+-------+-------+----------+\n",
      "| B0032   | 40     | 0.000 | 0.000 | 1.000    |\n",
      "+---------+--------+-------+-------+----------+\n",
      "| B0033   | 197    | 0.020 | 0.034 | 0.984    |\n",
      "+---------+--------+-------+-------+----------+\n",
      "| B0034   | 197    | 0.014 | 0.022 | 0.950    |\n",
      "+---------+--------+-------+-------+----------+\n",
      "| B0036   | 197    | 0.000 | 0.001 | 1.000    |\n",
      "+---------+--------+-------+-------+----------+\n",
      "| B0038   | 47     | 0.102 | 0.274 | 0.298    |\n",
      "+---------+--------+-------+-------+----------+\n",
      "| B0039   | 47     | 0.145 | 0.189 | 0.888    |\n",
      "+---------+--------+-------+-------+----------+\n",
      "| B0040   | 47     | 0.041 | 0.064 | 0.977    |\n",
      "+---------+--------+-------+-------+----------+\n",
      "| B0041   | 67     | 0.007 | 0.010 | 1.000    |\n",
      "+---------+--------+-------+-------+----------+\n",
      "| B0042   | 112    | 0.445 | 0.478 | 0.515    |\n",
      "+---------+--------+-------+-------+----------+\n",
      "| B0043   | 112    | 0.342 | 0.387 | 0.672    |\n",
      "+---------+--------+-------+-------+----------+\n",
      "| B0044   | 112    | 0.320 | 0.355 | 0.708    |\n",
      "+---------+--------+-------+-------+----------+\n",
      "| B0045   | 72     | 0.018 | 0.022 | 0.800    |\n",
      "+---------+--------+-------+-------+----------+\n",
      "| B0046   | 72     | 0.058 | 0.077 | 0.111    |\n",
      "+---------+--------+-------+-------+----------+\n",
      "| B0047   | 72     | 0.019 | 0.021 | 0.909    |\n",
      "+---------+--------+-------+-------+----------+\n",
      "| B0048   | 72     | 0.082 | 0.256 | -18.821  |\n",
      "+---------+--------+-------+-------+----------+\n"
     ]
    }
   ],
   "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",
    "results = Texttable()\n",
    "results.add_row(['Battery', 'Cycles', 'MAE', 'RMSE', 'R2 Score' ])\n",
    "\n",
    "# iterate over all the battery sets\n",
    "for b in bs_all:\n",
    "    # getting data for a given set\n",
    "    bs = [ b ]\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",
    "    # 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]]))\n",
    "    X = np.array(X)\n",
    "    y = np.array(capacity)\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([ bs[0], str(Cycles[bs[0]]['count']), diff, rmse, accuracy ])\n",
    "    \n",
    "# printing results\n",
    "print(f'Evaluation: Considering Individual Battery\\n{results.draw()}')"
   ]
  },
  {
   "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
}