notebooks/optimization-with-price-prediction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1e41494e",
   "metadata": {},
   "source": [
    "## Battery Charging Model \n",
    "Inspired by \"[2] Optimizing the operation of energy storage using a non-linear lithium-ion battery degradation model\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aff79d89",
   "metadata": {},
   "source": [
    "### Objective Functions \n",
    "1. Balances Cost and Degradation (Multi-Objetive Optimization) \\\n",
    "$\\zeta = \\omega{C} + (1 - \\omega)D$ \\\n",
    "$\\boldsymbol{\\omega}$ $\\rightarrow$ weighting factor $[0 \\rightarrow 1]$ \\\n",
    "$\\boldsymbol{D} \\rightarrow$ total degradation in market period $[Ah]$\\\n",
    "$\\boldsymbol{C} \\rightarrow cost $ [\\$]\\\n",
    "2. Aims to minimize cost \\\n",
    "$C = \\sum_t[\\lambda_t \\times (P_t^{dis,m} - P_t^{ch,m})]\\times\\Delta{T}$ \\\n",
    "$\\boldsymbol{C} \\rightarrow $ market clearing price $[\\frac{\\$}{Wh}]$\\\n",
    "$\\boldsymbol{\\lambda_t} \\rightarrow revenue [dollars]$ \\\n",
    "$\\boldsymbol{P_t^{dis,m}} \\rightarrow$ max power input to battery in trading interval $[W]$ \\\n",
    "$\\boldsymbol{P_t^{ch, m}} \\rightarrow$ max power output to battery in trading interval $[W]$ \\\n",
    "$\\boldsymbol{\\Delta{T}} \\rightarrow$ duration of trading interval $[hr]$ \\\n",
    "3. Aims to reduce degradation\n",
    "$D = \\sum_t{d_t}$\\\n",
    "$\\boldsymbol{D} \\rightarrow$ total degradation in market period $[Ah]$\\\n",
    "$\\boldsymbol{d_t} \\rightarrow$ total degradation incurred in each period $[Ah]$\\\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbdc6b2b",
   "metadata": {},
   "source": [
    "### Battery Updates\n",
    "4. Updates the state of the battery\\\n",
    "${SOC} = {SOC}_{t-1} + \\frac{(P_t^{dis,m} - P_t^{ch,m})\\times\\Delta{T}}{V_{nom}I_{1C}}$\\\n",
    "$\\boldsymbol{SOC_t} \\rightarrow$ state of charge, % measure of remaining capacity $[0 \\rightarrow 100]$\\\n",
    "$\\boldsymbol{P_t^{dis,m}} \\rightarrow$ max power output to battery in trading interval $[W]$ \\\n",
    "$\\boldsymbol{P_t^{ch, m}} \\rightarrow$ max power input to battery in trading interval $[W]$ \\\n",
    "$\\boldsymbol{\\Delta{T}} \\rightarrow$ duration of trading interval $[hr]$ \\\n",
    "$\\boldsymbol{V_{nom}} \\rightarrow$ nominal battery voltage $[V]$: The reported or reference voltage of the battery, $[4]$\\\n",
    "$\\boldsymbol{I_{1C}} \\rightarrow$ 1C Current $[A]$:s. A C-rate is a measure of the rate at which a battery is discharged relative to its\n",
    "maximum capacity. A 1C rate means that the discharge current will discharge the entire\n",
    "battery in 1 hour $[4]$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "e89c55f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from numpy.polynomial import Polynomial as P\n",
    "import numdifftools as nd\n",
    "import torch\n",
    "import time\n",
    "import pandas as pd\n",
    "import datetime as dt\n",
    "from scipy import optimize as optimize2\n",
    "\n",
    "\n",
    "# Battery Class Definition Template\n",
    "class Battery():\n",
    "    # Defining global static class variables\n",
    "    global SOC_x, cum_deg_y, i_x, psi_y\n",
    "    \n",
    "    # Cumulative degredation mapping manually determined based on fig 4 in the paper\n",
    "    SOC_x = np.linspace(0.0, 100.0, num=11)\n",
    "    cum_deg_y = np.array([0.0, 39.0, 47.0, 75.0, 75.0, 84.0, 101.0, 160.0, 269.0, 325.0, 372.0])\n",
    "    \n",
    "    # Psi scaling factor using experimental data to linearly interpolate depending on current\n",
    "    i_x = np.array([0.0, 1.0, 2.0])\n",
    "    psi_y = np.array([0.0, 1.0, 1.2956])\n",
    "    \n",
    "    \n",
    "    # Initialize with instance variables for battery charging/degradation\n",
    "    \n",
    "    # SOC --> State of charge [represents measure of remaining capacity in percentage form]\n",
    "    # V_nom --> Nominal Voltage [Volts]\n",
    "    # P_ch_max --> Max power oup\n",
    "    # charging --> boolen: True if charging, False if dissipating\n",
    "    # eta --> Battery inefficiency constant (this is approximation from [2])\n",
    "    def __init__(self):\n",
    "        # Constants\n",
    "        self.V_nom = 3.7            # [Volts] constant nominal operating voltage\n",
    "        self.IC1 = 2.15             # [Amps] constant 1C rate current\n",
    "        self.P_ch_max = 5           # [Watt] --> do research to determine starting value\n",
    "        self.deltaT = 1             # [Hours] Duration of trading interval  \n",
    "        \n",
    "        # Variables\n",
    "        self.SOC = None             # [Percentage] current battery percentage\n",
    "        self.SOC_prev = None        # [Percentage] previous battery percentage\n",
    "        self.d_t1C = None           # [Amp Hours] degredation at 1C charge during one time interval\n",
    "        self.psi_t = None           # [unitless] scaling factor of degredation depending on current\n",
    "        self.d_t = None             # [Amp Hours] total degredation at time interval t\n",
    "        self.P_ch_b = None          # [Watt] current charge power input to battery\n",
    "        self.SOC_penalties = []       # SOC constraint violation penalty\n",
    "        \n",
    "        \n",
    "    def setSOC(self, val):\n",
    "        # Updates the SOC\n",
    "        self.SOC = val\n",
    "        penalty_plus = np.square(np.maximum(val - 100, 0))\n",
    "        penalty_minus = np.square(np.minimum(val, 0))\n",
    "        self.SOC_penalties.append(penalty_plus + penalty_minus)\n",
    "        \n",
    "        #Ensure that SOC lies in between 0 and 100 (constraint 7)\n",
    "        self.SOC = np.maximum(0, self.SOC)\n",
    "        self.SOC = np.minimum(100, self.SOC)\n",
    "              \n",
    "                \n",
    "    def updateSOC(self):\n",
    "        # Updates the SOC from one trading interval to the next    \n",
    "        self.SOC_prev = self.SOC\n",
    "        new_SOC = self.SOC_prev + 100 * ((self.P_ch_b * self.deltaT) / (self.V_nom * self.IC1))\n",
    "        self.setSOC(new_SOC)\n",
    "    \n",
    "    \n",
    "    def getD_t1C(self):\n",
    "        # Calculate d_t1C = abs(delta_t - delta_t-1)\n",
    "        delta1C = np.interp(self.SOC, SOC_x, cum_deg_y)\n",
    "        delta1C_prev = np.interp(self.SOC_prev, SOC_x, cum_deg_y)\n",
    "        d_t1C = np.abs(delta1C - delta1C_prev)\n",
    "        self.d_t1C = d_t1C\n",
    "    \n",
    "\n",
    "    def getPsi(self):\n",
    "        # Calculate i_t and use to determine psi degradation scaling factor\n",
    "        i_t = np.abs(self.P_ch_b) / (self.V_nom * self.IC1)\n",
    "        psi_t = np.interp(i_t, i_x, psi_y)\n",
    "        self.psi_t = psi_t\n",
    "        \n",
    "        \n",
    "    def getD_t(self):\n",
    "        # Calculate d_t as a function of d_t1C and psi_t\n",
    "        d_t = ((self.d_t1C + self.psi_t) / 2) ** 2 - ((self.d_t1C - self.psi_t) / 2) ** 2\n",
    "        self.d_t = d_t\n",
    "        return d_t\n",
    "    \n",
    "    \n",
    "    def calcIter(self, P_t):\n",
    "        # Loops through iteration to calculate d_t given P_t\n",
    "        self.P_ch_b = P_t\n",
    "        self.updateSOC()\n",
    "        self.getD_t1C()\n",
    "        self.getPsi()\n",
    "        d_t = self.getD_t()\n",
    "        return d_t\n",
    "    \n",
    "    \n",
    "    def calcTotal(self, P, SOC_0=50.0, verbose=False):\n",
    "        # Given charging schedule P, calculate final degredation\n",
    "        self.setSOC(SOC_0)\n",
    "        self.SOC_penalties = []\n",
    "        d_ts = []\n",
    "        if verbose:\n",
    "            SOC_ts, d_t1cs, psi_ts = [], [], []\n",
    "        for t in range(len(P)):\n",
    "            d_t = self.calcIter(P[t])\n",
    "            d_ts.append(d_t)\n",
    "            \n",
    "            if verbose:\n",
    "                SOC_ts.append(self.SOC_prev)\n",
    "                d_t1cs.append(self.d_t1C)\n",
    "                psi_ts.append(self.psi_t)\n",
    "        \n",
    "        \n",
    "        d_ts = np.array(d_ts)\n",
    "        D = np.sum(d_ts)\n",
    "        if verbose:\n",
    "            return D, SOC_ts, d_ts, d_t1cs, psi_ts\n",
    "        return D\n",
    "    \n",
    "\n",
    "    def plotPsi(self):\n",
    "        # Plots the psi schedule as a function of i = P / VI\n",
    "        plt.figure(figsize=(8, 4))\n",
    "        plt.plot(i_x, psi_y, marker='D')\n",
    "        plt.xlabel(\"i ($h^{-1}$)\")\n",
    "        plt.ylabel(\"$\\psi$\")\n",
    "        plt.title(\"Degradation Scaling Factor\")\n",
    "        \n",
    "        \n",
    "    def plotCum_Deg(self):\n",
    "        # Plots essentially the same plot as fig 4 in the paper\n",
    "        plt.figure(figsize=(8, 4))\n",
    "        plt.plot(SOC_x, cum_deg_y, marker='D')\n",
    "        plt.xlabel(\"SOC (%)\")\n",
    "        plt.ylabel(\"$\\delta^{1C}$ ($\\mu$Ah)\")\n",
    "        plt.title(\"Cumulative Degredation\")\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "31334b97",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Cost Class Definition Template\n",
    "class Cost():\n",
    "    # Initialize with instance variables for cost model\n",
    "\n",
    "    # eta --> Battery inefficiency constant (this is approximation from [2])\n",
    "    def __init__(self, t=2):\n",
    "        # Constants\n",
    "        self.eta = .95                   # [Constant] Initial guess at inefficiency constant\n",
    "        self.deltaT = 1                  # [Hours] Duration of trading interval\n",
    "        self.prices = 0.20 * np.ones(t)  # [Dollars / kWh] prices of electricity over discrete time intervals\n",
    "        self.c_ts = []\n",
    "    \n",
    "    def calc(self, P):\n",
    "        # calculates cost C given charging schedule P\n",
    "        P = np.where(P > 0.0, P / self.eta, P)\n",
    "        P = np.where(P < 0.0, P * self.eta, P)\n",
    "        self.c_ts = (P * self.prices / 1000) * self.deltaT\n",
    "        C = np.sum(self.c_ts)\n",
    "        return C\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0f0ab8d1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calcPenalty(P, battery, rho, rho_SOC):\n",
    "    # calculate P_max constraint penalty using quadratic penalty method\n",
    "    P_max = battery.P_ch_max\n",
    "    penalty = rho * np.sum(np.square(np.maximum(np.abs(P) - P_max, 0)))\n",
    "    \n",
    "    # calculate SOC constraint penalty\n",
    "    penalty += rho_SOC * np.sum(bat.SOC_penalties)\n",
    "    return penalty\n",
    "\n",
    "\n",
    "def objective(P, SOC_0=50.0, w_C=0.5, rho=1.0, rho_SOC=1.0, verbose=False):\n",
    "    if verbose:\n",
    "        C = cost.calc(P)\n",
    "        D, SOC_ts, d_ts, d_t1cs, psi_ts = bat.calcTotal(P, SOC_0=SOC_0, verbose=True)\n",
    "        cache = P, SOC_ts, d_ts, d_t1cs, psi_ts, bat.SOC_penalties, cost.prices, cost.c_ts, w_C\n",
    "        penalty = calcPenalty(P, bat, rho=rho, rho_SOC=rho_SOC)\n",
    "        objective = (w_C * C * 50000) + (1 - w_C) * D + penalty\n",
    "        return objective, cache\n",
    "    \n",
    "    else:\n",
    "        C = cost.calc(P)\n",
    "        D = bat.calcTotal(P, SOC_0=SOC_0)\n",
    "        penalty = calcPenalty(P, bat, rho=rho, rho_SOC=rho_SOC)\n",
    "        objective = (w_C * C * 50000) + (1 - w_C) * D + penalty\n",
    "        return objective\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "96bf035e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def normalize(g):\n",
    "    length = np.linalg.norm(g)\n",
    "    result = g / length\n",
    "    return result\n",
    "\n",
    "\n",
    "def gradient_descent(lr, n_iter, w_C, rho=1.0, rho_SOC=1.0, beta=0.4, lr_decay=1.0):\n",
    "    P = np.random.uniform(low=-3.0, high=3.0, size=t)\n",
    "#     P = np.ones(t) * 0\n",
    "    v = np.zeros(t)\n",
    "    losses, Ps, grads = [], [], []\n",
    "    g = nd.Gradient(objective, full_output=True)\n",
    "    for i in range(n_iter):\n",
    "        grad, info = g(P, SOC_0=SOC_0, w_C=w_C, rho=rho, rho_SOC=rho_SOC)\n",
    "        v = beta * v - (lr * normalize(grad))\n",
    "        P += v\n",
    "        lr *= lr_decay\n",
    "        \n",
    "        grads.append(grad.copy())\n",
    "        losses.append(info)\n",
    "        Ps.append(P.copy())\n",
    "    losses = [i.f_value for i in losses]\n",
    "    Ps = np.array(Ps)\n",
    "    return P, grads, losses, Ps\n",
    "\n",
    "\n",
    "def optimize(lr, n_iter, w_C, rho, rho_SOC, beta, lr_decay, trials=1):\n",
    "    best_loss = np.inf\n",
    "    best_P = None\n",
    "    best_train_cache = None\n",
    "    \n",
    "    for i in range(trials):\n",
    "        P, grads, losses, Ps = gradient_descent(lr, n_iter, w_C, rho, rho_SOC, beta, lr_decay)\n",
    "        loss = objective(P)\n",
    "        if loss < best_loss:\n",
    "            best_loss = loss\n",
    "            best_P = P\n",
    "            best_train_cache = grads, losses, Ps\n",
    "    return best_P, best_train_cache"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "987f067a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plotLoss(train_cache):\n",
    "    grads, losses, Ps = train_cache\n",
    "    fig, ax = plt.subplots(2, 2, figsize=(20, 2 * 5))\n",
    "    ax[0, 0].plot(losses)\n",
    "    ax[0, 0].set_xlabel(\"Iteration\")\n",
    "    ax[0, 0].set_ylabel(\"Objective Function Value\")\n",
    "    \n",
    "    ax[0, 1].plot(Ps[:, 0])\n",
    "    ax[0, 1].set_xlabel(\"Iteration\")\n",
    "    ax[0, 1].set_ylabel(\"P1 Values (W)\")\n",
    "    \n",
    "    ax[1, 1].plot(Ps[:, 1])\n",
    "    ax[1, 1].set_xlabel(\"Iteration\")\n",
    "    ax[1, 1].set_ylabel(\"P2 Values (W)\")\n",
    "\n",
    "\n",
    "def plotCache(cache):\n",
    "    P, SOC_ts, d_ts, d_t1cs, psi_ts, SOC_penalties, prices, c_ts, w_C = cache\n",
    "    time = np.arange(1, len(P) + 1) * bat.deltaT\n",
    "    \n",
    "    fig, ax = plt.subplots(4, 2, figsize=(20, 4 * 5))\n",
    "    \n",
    "    ax[0, 0].set_title(\"Power Charge Input\")\n",
    "    ax[0, 0].set_ylabel(\"Power (Watts)\")\n",
    "    ax[0, 0].plot(time, np.zeros_like(time), color='k')\n",
    "    ax[0, 0].plot(time, P)\n",
    "    ax[0, 0].set_ylim([-bat.P_ch_max, bat.P_ch_max])\n",
    "    \n",
    "    ax[1, 0].set_title(\"SOC\")\n",
    "    ax[1, 0].set_ylabel(\"SOC (%)\")\n",
    "    ax[1, 0].plot(time, SOC_ts)\n",
    "    ax[1, 0].set_ylim([0, 100])\n",
    "    \n",
    "    ax[2, 0].set_title(\"Energy Prices\")\n",
    "    ax[2, 0].set_ylabel(\"Price ($ / kWh)\")\n",
    "    ax[2, 0].bar(time, prices)\n",
    "    \n",
    "    ax[3, 0].set_title(\"Cost of Energy Consumption\")\n",
    "    ax[3, 0].set_ylabel(\"Cost ($)\")\n",
    "    ax[3, 0].plot(time, c_ts)\n",
    "    ax[3, 0].plot(time, np.zeros_like(time), color='k')\n",
    "    \n",
    "    ax[0, 1].set_title(\"Degredation\")\n",
    "    ax[0, 1].set_ylabel(r'Degredation ($\\mu$Ah)')\n",
    "    ax[0, 1].plot(time, d_ts)\n",
    "    ax[0, 1].set_ylim([0, 200])\n",
    "    \n",
    "    ax[1, 1].set_title(\"Unnormalized Degredation\")\n",
    "    ax[1, 1].set_ylabel(r\"Degredation ($\\mu$Ah)\")\n",
    "    ax[1, 1].plot(time, d_t1cs)\n",
    "    ax[1, 1].set_ylim([0, 300])\n",
    "    \n",
    "    ax[2, 1].set_title(\"Current Dependant Degredation Scaling Factor\")\n",
    "    ax[2, 1].set_ylabel(\"Psi (unitless)\")\n",
    "    ax[2, 1].plot(time, psi_ts)\n",
    "    ax[2, 1].set_ylim([0, 1])\n",
    "    \n",
    "    ax[3, 1].set_title(\"SOC Infeasability Penalty\")\n",
    "    ax[3, 1].set_ylabel(\"Penalty (unitless)\")\n",
    "    ax[3, 1].plot(time, SOC_penalties)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "79ff74c9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 41.51826548576355 seconds ---\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x1440 with 8 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "t = 12\n",
    "w_C = 0.5\n",
    "SOC_0 = 50.0\n",
    "lr = 0.005 * t**0.5\n",
    "rho = 5000.0\n",
    "rho_SOC = 50.0\n",
    "beta = 0.5\n",
    "lr_decay = 0.999\n",
    "n_iter = 300\n",
    "trials = 1\n",
    "\n",
    "cost = Cost(t)\n",
    "bat = Battery()\n",
    "\n",
    "start_time = time.time()\n",
    "\n",
    "final_P, train_cache = optimize(lr, n_iter, w_C, rho, rho_SOC, beta, lr_decay, trials)\n",
    "final_f, cache = objective(final_P, SOC_0=SOC_0, w_C=w_C, rho=rho, rho_SOC=rho_SOC, verbose=True)\n",
    "\n",
    "# train_cache = grads, losses, Ps\n",
    "# cache = P, SOC_ts, d_ts, d_t1cs, psi_ts, SOC_penalties, prices, c_ts, w_C\n",
    "\n",
    "print(\"--- %s seconds ---\" % (time.time() - start_time))\n",
    "\n",
    "\n",
    "plotLoss(train_cache)\n",
    "plotCache(cache)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d20545be",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Max possible degradation:   3555.0\n",
      "Min possible degradation:   0.0\n"
     ]
    }
   ],
   "source": [
    "# Max and min degradation assuming worst and best cases (assuming t=12)\n",
    "print('Max possible degradation:  ', 3555.0)\n",
    "print('Min possible degradation:  ', 0.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "4beaf6b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# train_cache = grads, losses, Ps\n",
    "# cache = P, SOC_ts, d_ts, d_t1cs, psi_ts, SOC_penalties, prices, c_ts, w_C\n",
    "def calcPareto(n_w=5):\n",
    "    start_time = time.time()\n",
    "    w_Cs = np.linspace(0.0, 1.0, num=n_w)\n",
    "    caches = []\n",
    "    for w_C in w_Cs:\n",
    "        final_P, train_cache = optimize(lr, n_iter, w_C, rho, rho_SOC, beta, lr_decay, trials)\n",
    "        final_f, cache = objective(final_P, SOC_0=SOC_0, w_C=w_C, rho=rho, rho_SOC=rho_SOC, verbose=True)\n",
    "        caches.append(cache)\n",
    "    print(\"--- %s seconds ---\" % (time.time() - start_time))\n",
    "    return caches\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "57d5f401",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plotPareto(caches):\n",
    "    Ds, Cs, w_Cs = [], [] , []\n",
    "    for cache in caches:\n",
    "        P, SOC_ts, d_ts, d_t1cs, psi_ts, SOC_penalties, prices, c_ts, w_C = cache\n",
    "        D = np.sum(d_ts)\n",
    "        C = np.sum(c_ts)\n",
    "        Ds.append(D)\n",
    "        Cs.append(C)\n",
    "        w_Cs.append(w_C)\n",
    "        \n",
    "    fig, ax = plt.subplots()\n",
    "    ax.scatter(Ds, Cs)\n",
    "\n",
    "    for i, w_C in enumerate(w_Cs):\n",
    "        ax.annotate(round(w_C, 2), (Ds[i], Cs[i]))\n",
    "        \n",
    "    ax.set_title(\"Pareto Frontier Curve\")\n",
    "    ax.set_ylabel(\"Cost ($)\")\n",
    "    ax.set_xlabel(\"Degradation ($\\mu$Ah)\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d0b3ad32",
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_19928/3132710572.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     15\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     16\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 17\u001b[1;33m \u001b[0mcaches\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcalcPareto\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mn_w\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     18\u001b[0m \u001b[0mplotPareto\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcaches\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_19928/2966988789.py\u001b[0m in \u001b[0;36mcalcPareto\u001b[1;34m(n_w)\u001b[0m\n\u001b[0;32m      6\u001b[0m     \u001b[0mcaches\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      7\u001b[0m     \u001b[1;32mfor\u001b[0m \u001b[0mw_C\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mw_Cs\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 8\u001b[1;33m         \u001b[0mfinal_P\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtrain_cache\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0moptimize\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlr\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mn_iter\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mw_C\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrho\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrho_SOC\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mbeta\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlr_decay\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtrials\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      9\u001b[0m         \u001b[0mfinal_f\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcache\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mobjective\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfinal_P\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mSOC_0\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mSOC_0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mw_C\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mw_C\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrho\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mrho\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrho_SOC\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mrho_SOC\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mverbose\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     10\u001b[0m         \u001b[0mcaches\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcache\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_19928/1704523112.py\u001b[0m in \u001b[0;36moptimize\u001b[1;34m(lr, n_iter, w_C, rho, rho_SOC, beta, lr_decay, trials)\u001b[0m\n\u001b[0;32m     31\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     32\u001b[0m     \u001b[1;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtrials\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 33\u001b[1;33m         \u001b[0mP\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgrads\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlosses\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mPs\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mgradient_descent\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlr\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mn_iter\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mw_C\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrho\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrho_SOC\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mbeta\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlr_decay\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     34\u001b[0m         \u001b[0mloss\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mobjective\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mP\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     35\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mloss\u001b[0m \u001b[1;33m<\u001b[0m \u001b[0mbest_loss\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_19928/1704523112.py\u001b[0m in \u001b[0;36mgradient_descent\u001b[1;34m(lr, n_iter, w_C, rho, rho_SOC, beta, lr_decay)\u001b[0m\n\u001b[0;32m     12\u001b[0m     \u001b[0mg\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnd\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mGradient\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mobjective\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfull_output\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     13\u001b[0m     \u001b[1;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mn_iter\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 14\u001b[1;33m         \u001b[0mgrad\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minfo\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mg\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mP\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mSOC_0\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mSOC_0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mw_C\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mw_C\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrho\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mrho\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrho_SOC\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mrho_SOC\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     15\u001b[0m         \u001b[0mv\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mbeta\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0mv\u001b[0m \u001b[1;33m-\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mlr\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0mnormalize\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mgrad\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     16\u001b[0m         \u001b[0mP\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[0mv\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\miniconda3\\lib\\site-packages\\numdifftools\\core.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(self, x, *args, **kwds)\u001b[0m\n\u001b[0;32m    488\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    489\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0m__call__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 490\u001b[1;33m         \u001b[0mresult\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msuper\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mGradient\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__call__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0matleast_1d\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mravel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    491\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfull_output\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    492\u001b[0m             \u001b[1;32mreturn\u001b[0m \u001b[0mresult\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msqueeze\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mresult\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\miniconda3\\lib\\site-packages\\numdifftools\\core.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(self, x, *args, **kwds)\u001b[0m\n\u001b[0;32m    429\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    430\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0m__call__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 431\u001b[1;33m         \u001b[1;32mreturn\u001b[0m \u001b[0msuper\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mJacobian\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__call__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0matleast_1d\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    432\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    433\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\miniconda3\\lib\\site-packages\\numdifftools\\core.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(self, x, *args, **kwds)\u001b[0m\n\u001b[0;32m    287\u001b[0m         \u001b[1;32mwith\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0merrstate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdivide\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'ignore'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minvalid\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'ignore'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    288\u001b[0m             \u001b[0mresults\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mf_xi\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_derivative\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx_i\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkwds\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 289\u001b[1;33m             \u001b[0mderivative\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minfo\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_extrapolate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mresults\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    290\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfull_output\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    291\u001b[0m             \u001b[1;32mreturn\u001b[0m \u001b[0mderivative\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0minfo\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mf_xi\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0minfo\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\miniconda3\\lib\\site-packages\\numdifftools\\limits.py\u001b[0m in \u001b[0;36m_extrapolate\u001b[1;34m(self, results, steps, shape)\u001b[0m\n\u001b[0;32m    202\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mder1\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m>\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    203\u001b[0m             \u001b[0mder1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0merrors1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msteps\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_wynn_extrapolate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mder1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msteps\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 204\u001b[1;33m         \u001b[0mder\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minfo\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_get_best_estimate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mder1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0merrors1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msteps\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mshape\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    205\u001b[0m         \u001b[1;32mreturn\u001b[0m \u001b[0mder\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minfo\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    206\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\miniconda3\\lib\\site-packages\\numdifftools\\limits.py\u001b[0m in \u001b[0;36m_get_best_estimate\u001b[1;34m(der, errors, steps, shape)\u001b[0m\n\u001b[0;32m    182\u001b[0m     \u001b[1;33m@\u001b[0m\u001b[0mstaticmethod\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    183\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0m_get_best_estimate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mder\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0merrors\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msteps\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mshape\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 184\u001b[1;33m         \u001b[0merrors\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[0m_Limit\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_add_error_to_outliers\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mder\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    185\u001b[0m         \u001b[0midx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_Limit\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_get_arg_min\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0merrors\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    186\u001b[0m         \u001b[0mfinal_step\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msteps\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mflat\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0midx\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\miniconda3\\lib\\site-packages\\numdifftools\\limits.py\u001b[0m in \u001b[0;36m_add_error_to_outliers\u001b[1;34m(der, trim_fact)\u001b[0m\n\u001b[0;32m    165\u001b[0m         \"\"\"\n\u001b[0;32m    166\u001b[0m         \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 167\u001b[1;33m             \u001b[0mmedian\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnanmedian\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mder\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    168\u001b[0m             \u001b[0mp75\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnanpercentile\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mder\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m75\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    169\u001b[0m             \u001b[0mp25\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnanpercentile\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mder\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m25\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python39\\site-packages\\numpy\\core\\overrides.py\u001b[0m in \u001b[0;36mnanmedian\u001b[1;34m(*args, **kwargs)\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python39\\site-packages\\numpy\\lib\\nanfunctions.py\u001b[0m in \u001b[0;36mnanmedian\u001b[1;34m(a, axis, out, overwrite_input, keepdims)\u001b[0m\n\u001b[0;32m   1216\u001b[0m         \u001b[1;32mreturn\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnanmean\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mout\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mout\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkeepdims\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mkeepdims\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1217\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1218\u001b[1;33m     r, k = function_base._ureduce(a, func=_nanmedian, axis=axis, out=out,\n\u001b[0m\u001b[0;32m   1219\u001b[0m                                   overwrite_input=overwrite_input)\n\u001b[0;32m   1220\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0mkeepdims\u001b[0m \u001b[1;32mand\u001b[0m \u001b[0mkeepdims\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_NoValue\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python39\\site-packages\\numpy\\lib\\function_base.py\u001b[0m in \u001b[0;36m_ureduce\u001b[1;34m(a, func, **kwargs)\u001b[0m\n\u001b[0;32m   3700\u001b[0m         \u001b[0mkeepdim\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0ma\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mndim\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   3701\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 3702\u001b[1;33m     \u001b[0mr\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mfunc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   3703\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[0mr\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkeepdim\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   3704\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python39\\site-packages\\numpy\\lib\\nanfunctions.py\u001b[0m in \u001b[0;36m_nanmedian\u001b[1;34m(a, axis, out, overwrite_input)\u001b[0m\n\u001b[0;32m   1093\u001b[0m         \u001b[1;31m# benchmarked with shuffled (50, 50, x) containing a few NaN\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1094\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0ma\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0maxis\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m<\u001b[0m \u001b[1;36m600\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1095\u001b[1;33m             \u001b[1;32mreturn\u001b[0m \u001b[0m_nanmedian_small\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mout\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0moverwrite_input\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1096\u001b[0m         \u001b[0mresult\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mapply_along_axis\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0m_nanmedian1d\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0moverwrite_input\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1097\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mout\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python39\\site-packages\\numpy\\lib\\nanfunctions.py\u001b[0m in \u001b[0;36m_nanmedian_small\u001b[1;34m(a, axis, out, overwrite_input)\u001b[0m\n\u001b[0;32m   1108\u001b[0m     \"\"\"\n\u001b[0;32m   1109\u001b[0m     \u001b[0ma\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mma\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmasked_array\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0misnan\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1110\u001b[1;33m     \u001b[0mm\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mma\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmedian\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0maxis\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0moverwrite_input\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0moverwrite_input\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1111\u001b[0m     \u001b[1;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcount_nonzero\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mm\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmask\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mravel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1112\u001b[0m         warnings.warn(\"All-NaN slice encountered\", RuntimeWarning,\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python39\\site-packages\\numpy\\ma\\extras.py\u001b[0m in \u001b[0;36mmedian\u001b[1;34m(a, axis, out, overwrite_input, keepdims)\u001b[0m\n\u001b[0;32m    706\u001b[0m             \u001b[1;32mreturn\u001b[0m \u001b[0mm\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    707\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 708\u001b[1;33m     r, k = _ureduce(a, func=_median, axis=axis, out=out,\n\u001b[0m\u001b[0;32m    709\u001b[0m                     overwrite_input=overwrite_input)\n\u001b[0;32m    710\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0mkeepdims\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python39\\site-packages\\numpy\\lib\\function_base.py\u001b[0m in \u001b[0;36m_ureduce\u001b[1;34m(a, func, **kwargs)\u001b[0m\n\u001b[0;32m   3700\u001b[0m         \u001b[0mkeepdim\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0ma\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mndim\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   3701\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 3702\u001b[1;33m     \u001b[0mr\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mfunc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   3703\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[0mr\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkeepdim\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   3704\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python39\\site-packages\\numpy\\ma\\extras.py\u001b[0m in \u001b[0;36m_median\u001b[1;34m(a, axis, out, overwrite_input)\u001b[0m\n\u001b[0;32m    728\u001b[0m             \u001b[0masorted\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0ma\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    729\u001b[0m     \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 730\u001b[1;33m         \u001b[0masorted\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msort\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0maxis\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfill_value\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mfill_value\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    731\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    732\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0maxis\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python39\\site-packages\\numpy\\ma\\core.py\u001b[0m in \u001b[0;36msort\u001b[1;34m(a, axis, kind, order, endwith, fill_value)\u001b[0m\n\u001b[0;32m   6905\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   6906\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mMaskedArray\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 6907\u001b[1;33m         a.sort(axis=axis, kind=kind, order=order,\n\u001b[0m\u001b[0;32m   6908\u001b[0m                endwith=endwith, fill_value=fill_value)\n\u001b[0;32m   6909\u001b[0m     \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python39\\site-packages\\numpy\\ma\\core.py\u001b[0m in \u001b[0;36msort\u001b[1;34m(self, axis, kind, order, endwith, fill_value)\u001b[0m\n\u001b[0;32m   5656\u001b[0m             \u001b[1;32mreturn\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   5657\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 5658\u001b[1;33m         sidx = self.argsort(axis=axis, kind=kind, order=order,\n\u001b[0m\u001b[0;32m   5659\u001b[0m                             fill_value=fill_value, endwith=endwith)\n\u001b[0;32m   5660\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python39\\site-packages\\numpy\\ma\\core.py\u001b[0m in \u001b[0;36margsort\u001b[1;34m(self, axis, kind, order, endwith, fill_value)\u001b[0m\n\u001b[0;32m   5490\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   5491\u001b[0m         \u001b[0mfilled\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfilled\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfill_value\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 5492\u001b[1;33m         \u001b[1;32mreturn\u001b[0m \u001b[0mfilled\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0margsort\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0maxis\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0maxis\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkind\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mkind\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0morder\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0morder\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   5493\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   5494\u001b[0m     def argmin(self, axis=None, fill_value=None, out=None, *,\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "t = 12\n",
    "w_C = None\n",
    "SOC_0 = 50.0\n",
    "lr = 0.005 * t**0.5\n",
    "rho = 5000.0\n",
    "rho_SOC = 50.0\n",
    "beta = 0.5\n",
    "lr_decay = 0.999\n",
    "n_iter = 500\n",
    "trials = 1\n",
    "n_w = 5\n",
    "\n",
    "cost = Cost(t)\n",
    "bat = Battery()\n",
    "\n",
    "\n",
    "caches = calcPareto(n_w)\n",
    "plotPareto(caches)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa2af068",
   "metadata": {},
   "outputs": [],
   "source": [
    "plotCache(caches[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d7a77ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "bat = Battery()\n",
    "bat.plotCum_Deg()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "23958cd8",
   "metadata": {},
   "outputs": [],
   "source": [
    "bat.plotPsi()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7de79875",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "aa02036c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parameters x, xi [value for k(x, xi)]\n",
    "# Parametrs l --> Characteristic length\n",
    "def squared_exponential(x, xi, l = 5/4):\n",
    "    rtn = np.exp(-(.75*(x - xi))**2/(2*l**2))\n",
    "    return rtn\n",
    "\n",
    "# Periodic Kernel\n",
    "# # Parameters x, xi [value for k(x, xi)]\n",
    "# Parametrs l --> Characteristic length\n",
    "# Taken from: https://www.cs.toronto.edu/~duvenaud/cookbook/\n",
    "def periodic_kernel(x, xi, l = 2):\n",
    "    a = np.exp(-2*(np.sin(np.pi/24*np.abs(x - xi))**2)/l**2)\n",
    "    return a\n",
    "\n",
    "# Create the kernel matrix from two lists of X and Xpr\n",
    "def kernel_matrix(X, Xpr, w1 = .95, w2 = .05):\n",
    "    j = np.array([w1*squared_exponential(a, b) + w2*periodic_kernel(a,b) for a in X['Days'] for b in Xpr['Days']])\n",
    "    return j.reshape((len(X), len(Xpr)))\n",
    "\n",
    "\n",
    "# Predict the mean based on the data you are predicting from\n",
    "def mean_predict(df, hr):\n",
    "    # This might be unreasonable (how else can we predict mean?)\n",
    "    #df = df[df['Days'] < day]\n",
    "    correct_hour = df[df['hour'] == hr]\n",
    "    return np.mean(correct_hour.AEP_MW)\n",
    "\n",
    "# Sample from the multivariate random normal distributtion\n",
    "# scalar --> a scalar that is manually tuned to give more varied samples (the higher the value, the larger the covariance matrix)\n",
    "def mvnrand(μ, Σ, inflation=1e-6, scalar = 3000000):\n",
    "    #np.random.seed(31)\n",
    "    sigma = Σ + inflation*np.eye(Σ.shape[0])\n",
    "    \n",
    "    x = np.random.multivariate_normal(μ, scalar*sigma, 1)# 100000\n",
    "    return x[0]\n",
    "\n",
    "# Will use this to fit our gaussian process to a sinusoidal output\n",
    "# hours (hours of the day)\n",
    "# avg, ampl, time_offset --> characteristics of a sinusoidal function\n",
    "# Return: Function that fits avg, ampl, time_offset as well as possible\n",
    "def periodic_fit(hours, avg, ampl, time_offset):    \n",
    "    return (avg\n",
    "            + ampl * np.cos((hours + time_offset) * 2 * np.pi / hours.max()))\n",
    "\n",
    "def getGaussianProcess(X, Xpr):\n",
    "    # Use prior 3 days to predict next day\n",
    "    # Form kernels\n",
    "    K_XX = kernel_matrix(X, X)\n",
    "    K_XXpr = kernel_matrix(X, Xpr)\n",
    "    K_XprX = kernel_matrix(Xpr, X)\n",
    "    K_XprXpr = kernel_matrix(Xpr, Xpr)\n",
    "    # Form means\n",
    "    meanX = np.array([mean_predict(X, hr) for hr in X['hour']])\n",
    "    meanXpr = np.array([mean_predict(X, hr) for hr in Xpr['hour']])\n",
    "    # actual y value\n",
    "    y = X['AEP_MW']\n",
    "    mu = meanXpr + K_XprX@np.linalg.inv(K_XX)@(y - meanX)\n",
    "    cov =  K_XprXpr - K_XprX@np.linalg.inv(K_XX)@K_XXpr\n",
    "    \n",
    "    return mu, cov\n",
    "\n",
    "from scipy import optimize\n",
    "\n",
    "# Given the previous H hours of MWh Energy, gives a prediction of the next 24 hours of cost based on risk_aversity\n",
    "# of the customer and utilizing Gaussian Process\n",
    "def getNextNCosts(n, X, H, day = 100, risk_aversity = 50, samples = 10):\n",
    "    # Start at a random day of the year\n",
    "    X = X[X['Days'] < day]\n",
    "    X = X.iloc[-H:]\n",
    "    last_hour_measured = list(X['Days'])[-1]\n",
    "    hours_to_predict = pd.DataFrame()\n",
    "    hours_to_predict['Days'] = list(range(last_hour_measured - 1, last_hour_measured + n - 1))\n",
    "    hours_to_predict['hour'] = np.array(list(X['hour'])[-48:-48+25]) # This needs to be edited\n",
    "    print(hours_to_predict)\n",
    "    print(X)\n",
    "    mu, cov = getGaussianProcess(X, hours_to_predict)\n",
    "    print(mu, cov)\n",
    "    #create the weighting array\n",
    "    y_weight = np.empty(n)\n",
    "    #high pseudo-sd values, meaning less weighting in the fit\n",
    "    y_weight.fill(10)\n",
    "    #low values for point 0 and the last points, meaning more weighting during the fit procedure \n",
    "    y_weight[0] = .1\n",
    "    \n",
    "    worst = None\n",
    "    worst_value = -float('inf')\n",
    "    for i in range(samples):\n",
    "        print(\"hey\")\n",
    "        j = mvnrand(mu, cov)\n",
    "        area = np.trapz(range(len(j)), j)\n",
    "        print('area:', area)\n",
    "        if area > worst_value:\n",
    "            worst_value = area\n",
    "            print('worst')\n",
    "            worst = j  \n",
    "    \n",
    "    plt.figure()\n",
    "    plt.plot(range(-71,1), X['AEP_MW'], 'g')\n",
    "    \n",
    "\n",
    "    res_max, cov_max = optimize2.curve_fit(periodic_fit, list(range(25)),\n",
    "                                      worst, [0, 0, 0], sigma = y_weight)\n",
    "    plt.plot(np.array(range(25)), periodic_fit(np.array(range(25)), *res_max), 'pink')\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "e27da339",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\nico\\AppData\\Local\\Temp/ipykernel_19928/2782767335.py:6: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  df_18['Days'] = range(len(df_18))\n"
     ]
    }
   ],
   "source": [
    "df = pd.read_csv('AEP.csv')\n",
    "df['Date'] = pd.to_datetime(df['Datetime'])\n",
    "df['year'] = pd.DatetimeIndex(df['Date']).year\n",
    "df['hour'] = pd.DatetimeIndex(df['Date']).hour\n",
    "df_18 = df[df['year'] == 2018]\n",
    "df_18['Days'] = range(len(df_18))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c3b7809f",
   "metadata": {},
   "outputs": [],
   "source": [
    "getNextNCosts(25, df_18, 72, 100)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}