analyze_loans.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from loan_analysis.loan import AmortizingLoan\n",
    "from loan_analysis.interest import (\n",
    "    IBORProcess,\n",
    "    IBORGaussianProccess,\n",
    "    get_loan_rates)\n",
    "from loan_analysis.summary import Summary\n",
    "\n",
    "from loan_analysis.utils import (\n",
    "    plot_summary,\n",
    "    plot_repayments,\n",
    "    plot_mean_pm_std,\n",
    "    plot_mean_and_95_percentile)\n",
    "    \n",
    "import ipywidgets as ipyw"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usage of the loan_analysis module comes in 3 steps:  \n",
    "\n",
    "1. setting an `AmortizingLoan` with an initial principal and a termination time\n",
    "2. instantiating an `IBORProcess` (such as `IBORGaussianProcess`) from which to sample Euribor traces, and fitting it to historical data  \n",
    "3. running the simulation and using the `Summary` class to analyse the results\n",
    "\n",
    "The following cell gives a demonstration of how to put this all together:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8eabb54f912645ffa15f17a67347d838",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(HBox(children=(FloatText(value=1000.0, description='initial_principal'), IntText(value=400, des…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# simulations will have a signature something like this\n",
    "def run_simulation_demo(\n",
    "    loan: AmortizingLoan,\n",
    "    ibor_process: IBORProcess,\n",
    "    num_simulations: int=1000\n",
    "    ) -> Summary:\n",
    "    return Summary(\n",
    "        values=np.random.randn(num_simulations),\n",
    "        name=\"This Is Just A Demonstration\")\n",
    "\n",
    "# they can be wrapped in interactive tools with globals\n",
    "# to minimize recomputation like this\n",
    "loan = None\n",
    "ibor_process = None\n",
    "summary = None\n",
    "def widget_function_demo(\n",
    "    initial_principal,\n",
    "    full_term,\n",
    "    num_simulations,\n",
    "    historical_ibor,\n",
    "    plot_hist,\n",
    "    plot_cdf,\n",
    "    plot_kde,\n",
    "    var_percent,\n",
    "    ):\n",
    "    global loan\n",
    "    global ibor_process\n",
    "    global summary\n",
    "    recompute_summary = False\n",
    "    if loan is None:\n",
    "        print(\"initialising loan\")\n",
    "        loan = AmortizingLoan(\n",
    "            initial_principal=initial_principal,\n",
    "            full_term=full_term)\n",
    "        recompute_summary = True\n",
    "    elif (loan.initial_principal != initial_principal)\\\n",
    "        or (loan.full_term != full_term):\n",
    "        print(\"re-initialising loan\")\n",
    "        loan = AmortizingLoan(\n",
    "            initial_principal=initial_principal,\n",
    "            full_term=full_term)\n",
    "        recompute_summary = True\n",
    "    if ibor_process is None:\n",
    "        print(\"initialising ibor_process\")\n",
    "        ibor_process = IBORGaussianProccess(historical_ibor)\n",
    "        recompute_summary = True\n",
    "    elif len(ibor_process.historical_ibor) != len(historical_ibor):\n",
    "        print(\"re-initialising ibor_process\")\n",
    "        ibor_process = IBORGaussianProccess(historical_ibor)\n",
    "        recompute_summary = True\n",
    "    if summary is None or recompute_summary:\n",
    "        print(\"computing summary\")\n",
    "        summary = run_simulation_demo(loan, ibor_process, num_simulations)\n",
    "    elif len(summary.values) != num_simulations:\n",
    "        print(\"re-computing summary\")\n",
    "        summary = run_simulation_demo(loan, ibor_process, num_simulations)\n",
    "    # print(\"DEMONSTRATION RESULT\")\n",
    "    fig = plt.figure(figsize=(12,5))\n",
    "    plot_summary(\n",
    "        summary,\n",
    "        plot_cdf=plot_cdf,\n",
    "        plot_kde=plot_kde,\n",
    "        plot_hist=plot_hist,\n",
    "        var_percent=var_percent,\n",
    "        ax=plt.gca())\n",
    "    plt.show()\n",
    "\n",
    "widget = ipyw.interactive(\n",
    "    widget_function_demo,\n",
    "    initial_principal=ipyw.FloatText(value=1000),\n",
    "    full_term=ipyw.IntText(value=400),\n",
    "    num_simulations=ipyw.IntText(value=100),\n",
    "    plot_hist=ipyw.Checkbox(value=True),\n",
    "    plot_kde=ipyw.Checkbox(value=False),\n",
    "    plot_cdf=ipyw.Checkbox(value=True),\n",
    "    var_percent=ipyw.FloatSlider(value=5., min=0., max=100., step=0.5),\n",
    "    historical_ibor=ipyw.fixed(np.cumsum(np.random.rand(100))))\n",
    "\n",
    "commands = ipyw.HBox(\n",
    "    children=widget.children[:-1],\n",
    "    # layout={'flex-flow': 'flex-wrap'},\n",
    "    layout=ipyw.Layout(flex_flow='row wrap')\n",
    "    )\n",
    "display(ipyw.VBox([commands, widget.children[-1]]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Euribor Curves\n",
    "\n",
    "Okay, so now let's load our historical euribor and fit a `IBORGaussianProcess` model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c77654517fb74cf1a44a47cff9ef2425",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Button(description='Press to Run', style=ButtonStyle(button_color='lightgreen', font_weight='bo…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "historical_euribor = pd.read_csv('euribor_1999_2016_12month.csv')\n",
    "euribor_process = IBORGaussianProccess(\n",
    "    historical_ibor=historical_euribor.rate.values/100,\n",
    "    autocorrelation_maxlag=100,\n",
    "    kernel_type=\"laplace\")\n",
    "\n",
    "\n",
    "def widget_function_euribor(\n",
    "    kernel_type=\"laplace\",\n",
    "    maxlag=100,\n",
    "    num_samples=2,\n",
    "    min_rate=0.,\n",
    "):\n",
    "    global euribor_process\n",
    "    if euribor_process.kernel_type != kernel_type \\\n",
    "    or euribor_process.autocorrelation_maxlag != maxlag:\n",
    "        euribor_process = IBORGaussianProccess(\n",
    "            historical_ibor=historical_euribor.rate.values/100,\n",
    "            autocorrelation_maxlag=maxlag,\n",
    "            kernel_type=kernel_type)\n",
    "    samples = euribor_process.sample_ibor_curve(\n",
    "        number_of_months=len(euribor_process.historical_ibor),\n",
    "        num_samples=num_samples,\n",
    "        initial_value=euribor_process.historical_ibor[0])\n",
    "    samples[samples < min_rate] = min_rate\n",
    "    fig = plt.figure(figsize=(12,4))\n",
    "    plt.plot(\n",
    "        euribor_process.historical_ibor,\n",
    "        color='black', lw=4, label='historical data')\n",
    "    for i in range(num_samples):\n",
    "        plt.plot(\n",
    "            samples[:,i],\n",
    "            label='samples' if i == 0 else None)\n",
    "    plt.legend(loc=\"upper left\")\n",
    "    plt.title(\"Sampled 12month Euribor Curves\")\n",
    "    plt.show()\n",
    "\n",
    "widget = ipyw.interactive(\n",
    "    widget_function_euribor,\n",
    "    _interactive__options={'manual':True, 'manual_name':\"Press to Run\"},\n",
    "    kernel_type=ipyw.Dropdown(\n",
    "        options=['laplace', 'gaussian', 'mixture'],\n",
    "        description=\"kernel type\",\n",
    "        layout=ipyw.Layout(width=\"200px\")),\n",
    "    num_samples=ipyw.IntText(\n",
    "        value=2, min=0,\n",
    "        description=\"no. samples\",\n",
    "        layout=ipyw.Layout(width=\"150px\")),\n",
    "    maxlag=ipyw.IntText(\n",
    "        value=100, min=1,\n",
    "        description=\"max lag\",\n",
    "        layout=ipyw.Layout(width=\"150px\")),\n",
    "    min_rate=ipyw.FloatText(\n",
    "        value=0.,\n",
    "        description=\"min rate\",\n",
    "        layout=ipyw.Layout(width=\"150px\"))\n",
    "        )\n",
    "widget.manual_button.style.button_color = 'lightgreen'\n",
    "widget.manual_button.style.font_weight = 'bold'\n",
    "\n",
    "commands = ipyw.HBox(\n",
    "    children=widget.children[:-2],\n",
    "    layout=ipyw.Layout(flex_flow='row wrap'))\n",
    "display(ipyw.VBox([widget.children[-2], commands, widget.children[-1]]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What's going on here? It's a rather crude implementation of a Gaussian process. Instead of maximising the (log-)marginal likelihood (as explained [in this book](http://gaussianprocess.org/gpml/chapters/RW.pdf), for example), it fits a kernel to the autocorrelation of the data.  \n",
    "\n",
    "The historical data (shown in black) has certain autocorrelations in it which we can call $\\rho(t_1,t_2) = \\rho(|t_2-t_1|)$, and a standard deviation $\\sigma$.  \n",
    "\n",
    "In `IBORGaussianProcess` the code fits either a Laplace kernel\n",
    "\n",
    "$$\\kappa^\\text{laplace}_\\tau(|t_2-t_1|)=\\exp(-\\tau\\,|t_2-t_1|)$$\n",
    "\n",
    "or a Gaussian kernel\n",
    "\n",
    "$$\\kappa^\\text{gaussian}_\\tau(|t_2-t_1|) = \\exp(-\\tau\\,(t_2-t_1)^2)$$\n",
    "\n",
    "or a $3$-parameter mixture\n",
    "\n",
    "$$\\kappa^\\text{mixture}_{\\tau_1,\\tau_2,p}(|t_2-t_1|) =p\\kappa^\\text{gaussian}_{\\tau_1}(|t_2-t_1|) + (1-p)\\kappa^\\text{laplace}_{\\tau_2}(|t_2-t_1|)$$\n",
    "\n",
    "to $\\rho(t_1,t_2)$ by minimising the weighted mean squared error:  \n",
    "\n",
    "$$\n",
    "\\tau^* = \\argmin_{\\tau} \\sum_{\\Delta t =0}^\\text{max lag} (n-\\Delta t)\\left( \\kappa_\\tau(\\Delta t) - \\rho(\\Delta t) \\right)^2\n",
    "$$\n",
    "\n",
    "where $n$ is the number of observed historical Euribor rates. The weights are there to capture how the variance of the estimator or the true correlations shrinks in proportion to $1/(n-\\Delta t)$ by the Law of Large Numbers.\n",
    "\n",
    "These kernels can then be used to sample Gaussian processes, which are scaled by $\\sigma$ and are then shifted to have a desired initial value, in this case the same as the historical data.\n",
    "\n",
    "These samples are new estimates of Euribor curves with similar autocorrelations and standard deviation to those observed in the historical data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Repayment Schedules\n",
    "\n",
    "For a given interest rate and principal amount, how much will be paid in interest?\n",
    "\n",
    "First we look at the case of a fixed interest."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "bdf28ccceb4f4d65996713f6b1b76783",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(HBox(children=(VBox(children=(FloatSlider(value=231500.0, description='amount borrowed', max=40…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def widget_function_timecourse(\n",
    "    initial_principal=231500.,\n",
    "    full_term=37*12,\n",
    "    fixed_interest_percent=3.286\n",
    "    ):\n",
    "    loan = AmortizingLoan(\n",
    "        initial_principal=initial_principal,\n",
    "        full_term=full_term)\n",
    "    monthly_payment = loan.get_amortized_payment_amount(fixed_interest_percent/100)\n",
    "    interest_rates_constant = np.full(loan.full_term, fixed_interest_percent/100)\n",
    "    loan.pay_interest_rates(interest_rates_constant)\n",
    "    fig = plt.figure(figsize=(12,4))\n",
    "    plot_repayments(loan)\n",
    "    plt.title(f\"Calculated Monthly Cost: {monthly_payment:.2f} euros\")\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "widget = ipyw.interactive(\n",
    "    widget_function_timecourse,\n",
    "    initial_principal=ipyw.FloatSlider(\n",
    "        min=0., max=400000., value=231500., step=1000.,\n",
    "        description=\"amount borrowed\"),\n",
    "    full_term=ipyw.IntSlider(\n",
    "        value=37*12, min=1, max=40*12, step=1,\n",
    "        description=\"no. months\"),\n",
    "    fixed_interest_percent=ipyw.FloatSlider(\n",
    "        value=3.286, min=0., max=20., step=0.01,\n",
    "        description=\"interest %\", readout_format='.3f')\n",
    "    )\n",
    "principal_text = ipyw.FloatText(\n",
    "    value=231500.)\n",
    "ipyw.link((principal_text, \"value\"), (widget.children[0], \"value\"))\n",
    "full_term_text = ipyw.IntText(\n",
    "    value=37*12)\n",
    "ipyw.link((full_term_text, \"value\"), (widget.children[1], \"value\"))\n",
    "interest_text = ipyw.FloatText(\n",
    "    value=3.286)\n",
    "ipyw.link((interest_text, \"value\"), (widget.children[2], \"value\"))\n",
    "top_row_list = [principal_text, full_term_text, interest_text]\n",
    "vboxes = [ipyw.VBox(list(xy)) for xy in zip(widget.children, top_row_list)]\n",
    "\n",
    "top_row = ipyw.HBox(\n",
    "    vboxes,\n",
    "    layout=ipyw.Layout(flex_flow='row wrap'))\n",
    "display(ipyw.VBox([\n",
    "    top_row,\n",
    "    widget.children[-1]]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What happens if the interest rates are *flexible*, locked to the Euribor process from before?\n",
    "\n",
    "**Note: TODO:** some weird error seems to arise when the full term is not a fixed number of years."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ebddde4bb3b8449ebd2fc416330e3e28",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Button(description='Press to Run', style=ButtonStyle(button_color='lightgreen', font_weight='bo…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def widget_function_timecourse_stochastic(\n",
    "    initial_principal=231500.,\n",
    "    number_of_years=37,\n",
    "    initial_interest_percentage=3.286,\n",
    "    spread_percentage=1.,\n",
    "    kernel_type=\"laplace\",\n",
    "    maxlag=100,\n",
    "    num_samples=2,\n",
    "    minimum_ibo_rate_percent=0.,\n",
    "    individual_plots=True,\n",
    "    fill_percent=95.\n",
    "):\n",
    "    global euribor_process\n",
    "    if euribor_process is None:\n",
    "        euribor_process = IBORGaussianProccess(\n",
    "            historical_ibor=historical_euribor.rate.values/100,\n",
    "            autocorrelation_maxlag=maxlag,\n",
    "            kernel_type=kernel_type)\n",
    "    elif euribor_process.kernel_type != kernel_type \\\n",
    "    or euribor_process.autocorrelation_maxlag != maxlag:\n",
    "        euribor_process = IBORGaussianProccess(\n",
    "            historical_ibor=historical_euribor.rate.values/100,\n",
    "            autocorrelation_maxlag=maxlag,\n",
    "            kernel_type=kernel_type)\n",
    "    interest_rate_curves = euribor_process.sample_ibor_curve(\n",
    "        number_of_months=number_of_years*12,\n",
    "        num_samples=num_samples,\n",
    "        initial_value=euribor_process.historical_ibor[0])\n",
    "    interest_rate_curves += initial_interest_percentage/100 - interest_rate_curves[0,:]\n",
    "    # rectify\n",
    "    interest_rate_curves[interest_rate_curves < minimum_ibo_rate_percent/100] = minimum_ibo_rate_percent/100\n",
    "    loan_rates = get_loan_rates(\n",
    "        interest_rate_curves,\n",
    "        spread=spread_percentage/100,\n",
    "        renew_every=12\n",
    "        )\n",
    "    loan = AmortizingLoan(\n",
    "        initial_principal=initial_principal,\n",
    "        full_term=number_of_years*12)\n",
    "    # monthly_payment = loan.get_amortized_payment_amount(fixed_interest_percent/100)\n",
    "    # interest_rates_constant = np.full(loan.full_term, fixed_interest_percent/100)\n",
    "    fig, axes = plt.subplots(2,1,figsize=(12,8))\n",
    "    # ax = plt.gca()\n",
    "    ax = axes[0]\n",
    "    if individual_plots:\n",
    "        for i in range(num_samples):\n",
    "            loan.reset()\n",
    "            loan.pay_interest_rates(loan_rates[:,i])\n",
    "            ax = plot_repayments(\n",
    "                loan,\n",
    "                colour_interest=f\"C{i}\",\n",
    "                colour_principal=f\"C{i}\",\n",
    "                show_legend= i==0,\n",
    "                ax=ax)\n",
    "    else:\n",
    "        interest_payments = np.zeros((number_of_years*12, num_samples))\n",
    "        principal_payments = np.zeros((number_of_years*12, num_samples))\n",
    "        for i in range(num_samples):\n",
    "            loan.reset()\n",
    "            loan.pay_interest_rates(loan_rates[:,i])\n",
    "            interest_payments[:,i] = np.cumsum(loan.interests_paid)\n",
    "            principal_payments[:,i] = np.cumsum(loan.principal_reductions)\n",
    "        ax.axhline(initial_principal, ls=\":\", color='black')\n",
    "        ax = plot_mean_and_95_percentile(\n",
    "            principal_payments,\n",
    "            colour=\"C1\",\n",
    "            label=\"cumulative principal paid\",\n",
    "            percentile=100.-fill_percent,\n",
    "            ax=ax)\n",
    "        ax = plot_mean_and_95_percentile(\n",
    "            interest_payments,\n",
    "            colour=\"C0\",\n",
    "            label=\"cumulative interest paid\",\n",
    "            percentile=100.-fill_percent,\n",
    "            ax=ax)\n",
    "        ax.set_xlabel(\"Month\")\n",
    "        ax.set_ylabel(\"Cumulative Payment (euros)\")\n",
    "        ax.grid(\":\")\n",
    "        ax.legend(loc=\"upper left\")\n",
    "    if individual_plots:\n",
    "        for i in range(num_samples):\n",
    "            axes[1].plot(\n",
    "                interest_rate_curves[:,i],\n",
    "                label='ibor rate' if i == 0 else None,\n",
    "                color=f\"C{i}\")\n",
    "            axes[1].plot(\n",
    "                loan_rates[:,i],\n",
    "                label='loan rate' if i == 0 else None,\n",
    "                ls=\"--\",\n",
    "                color=f\"C{i}\")\n",
    "            axes[1].legend(loc=\"upper left\")\n",
    "    else:\n",
    "        ax = axes[1]\n",
    "        ax = plot_mean_and_95_percentile(\n",
    "            interest_rate_curves,\n",
    "            colour=\"C1\",\n",
    "            label=\"ibor rates\",\n",
    "            percentile=100.-fill_percent,\n",
    "            ax=ax)\n",
    "        ax = plot_mean_and_95_percentile(\n",
    "            loan_rates,\n",
    "            colour=\"C0\",\n",
    "            label=\"loan rates\",\n",
    "            percentile=100.-fill_percent,\n",
    "            ax=ax)\n",
    "        axes[1].legend(loc=\"upper left\")\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "# widget_function_timecourse_stochastic()\n",
    "widget = ipyw.interactive(\n",
    "    widget_function_timecourse_stochastic,\n",
    "    _interactive__options={'manual':True, 'manual_name':\"Press to Run\"},\n",
    "    initial_principal=ipyw.FloatSlider(\n",
    "        min=0., max=400000., value=231500., step=1000.,\n",
    "        description=\"amount borrowed\"),\n",
    "    number_of_years=ipyw.IntSlider(\n",
    "        value=37, min=1, max=40, step=1,\n",
    "        description=\"no. years\"),\n",
    "    initial_interest_percentage=ipyw.FloatSlider(\n",
    "        value=0.992, min=0., max=20., step=0.01,\n",
    "        description=\"initial %\", readout_format='.3f'),\n",
    "    spread_percentage=ipyw.FloatSlider(\n",
    "        value=1.0, min=0., max=20., step=0.01,\n",
    "        description=\"spread %\", readout_format='.3f'),\n",
    "    kernel_type=ipyw.Dropdown(\n",
    "        options=['laplace', 'gaussian', 'mixture'],\n",
    "        description=\"kernel type\",\n",
    "        layout=ipyw.Layout(width=\"200px\")),\n",
    "    num_samples=ipyw.IntText(\n",
    "        value=2, min=0,\n",
    "        description=\"no. samples\",\n",
    "        layout=ipyw.Layout(width=\"150px\")),\n",
    "    maxlag=ipyw.IntText(\n",
    "        value=100, min=1,\n",
    "        description=\"max lag\",\n",
    "        layout=ipyw.Layout(width=\"150px\")),\n",
    "    minimum_ibo_rate_percent=ipyw.FloatText(\n",
    "        value=0.,\n",
    "        description=\"min ibor %\",\n",
    "        layout=ipyw.Layout(width=\"150px\")),\n",
    "    individual_plots=ipyw.Checkbox(\n",
    "        value=True, description=\"plot individual traces\"),\n",
    "    fill_percent=ipyw.FloatSlider(\n",
    "        value=95., min=0., max=100., description=\"fill %\")\n",
    "    )\n",
    "widget.manual_button.style.button_color = 'lightgreen'\n",
    "widget.manual_button.style.font_weight = 'bold'\n",
    "principal_text = ipyw.FloatText(\n",
    "    value=231500.)\n",
    "ipyw.link((principal_text, \"value\"), (widget.children[0], \"value\"))\n",
    "years_text = ipyw.IntText(\n",
    "    value=37)\n",
    "ipyw.link((years_text, \"value\"), (widget.children[1], \"value\"))\n",
    "interest_text = ipyw.FloatText(\n",
    "    value=0.992)\n",
    "ipyw.link((interest_text, \"value\"), (widget.children[2], \"value\"))\n",
    "spread_text = ipyw.FloatText(\n",
    "    value=1.)\n",
    "ipyw.link((spread_text, \"value\"), (widget.children[3], \"value\"))\n",
    "top_row_list = [principal_text, years_text, interest_text, spread_text]\n",
    "vboxes = [ipyw.VBox(list(xy)) for xy in zip(widget.children, top_row_list)]\n",
    "\n",
    "top_row = ipyw.HBox(\n",
    "    vboxes,\n",
    "    layout=ipyw.Layout(flex_flow='row wrap'))\n",
    "ipyw.VBox([\n",
    "    widget.manual_button,\n",
    "    ipyw.HBox(\n",
    "        [*widget.children[4:-2]],\n",
    "        layout=ipyw.Layout(flex_flow='row wrap')),\n",
    "    top_row,\n",
    "    widget.children[-1]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Distributions\n",
    "\n",
    "Next let's look at distributions of amounts paid and of maximum payments, or how often $p\\%$ of payments are above an amount $x$.\n",
    "\n",
    "Then we move onto more complex payment schedules, like starting with fixed payments, or paying above the asked amount."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e7991aac8d49434f989c1b293d522135",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Button(description='Press to Run', style=ButtonStyle(button_color='lightgreen', font_weight='bo…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: this cell can be neatened, and probably made interactive\n",
    "from typing import Callable, Union, Optional\n",
    "\n",
    "loan = None\n",
    "def run_simulation(\n",
    "    num_simulations: int=1000,\n",
    "    maxlag: int=100,\n",
    "    kernel_type: str='laplace',\n",
    "    # number_of_years: int=37,\n",
    "    initial_interest_percentage: float=0.992,\n",
    "    minimum_ibo_rate_percent: float=-10.,\n",
    "    spread_percentage: float=1.,\n",
    "    # initial_principal: float=231500.,\n",
    "    summary_functional: Callable[[AmortizingLoan],Union[np.ndarray,float]]=lambda loan: np.sum(loan.payments_made),\n",
    "    summary_name: Optional[str]=None\n",
    "    ) -> Summary:\n",
    "    global euribor_process\n",
    "    global loan\n",
    "    if euribor_process is None:\n",
    "        euribor_process = IBORGaussianProccess(\n",
    "            historical_ibor=historical_euribor.rate.values/100,\n",
    "            autocorrelation_maxlag=maxlag,\n",
    "            kernel_type=kernel_type)\n",
    "    elif euribor_process.kernel_type != kernel_type \\\n",
    "    or euribor_process.autocorrelation_maxlag != maxlag:\n",
    "        euribor_process = IBORGaussianProccess(\n",
    "            historical_ibor=historical_euribor.rate.values/100,\n",
    "            autocorrelation_maxlag=maxlag,\n",
    "            kernel_type=kernel_type)\n",
    "    interest_rate_curves = euribor_process.sample_ibor_curve(\n",
    "        number_of_months=loan.full_term,\n",
    "        num_samples=num_simulations,\n",
    "        initial_value=euribor_process.historical_ibor[0])\n",
    "    interest_rate_curves += initial_interest_percentage/100 - interest_rate_curves[0,:]\n",
    "    # rectify\n",
    "    interest_rate_curves[interest_rate_curves < minimum_ibo_rate_percent/100] = minimum_ibo_rate_percent/100\n",
    "    loan_rates = get_loan_rates(\n",
    "        interest_rate_curves,\n",
    "        spread=spread_percentage/100,\n",
    "        renew_every=12\n",
    "        )\n",
    "    summary_values = []\n",
    "    for i in range(num_simulations):\n",
    "        loan.reset()\n",
    "        loan.pay_interest_rates(loan_rates[:,i])\n",
    "        summary_values.append(summary_functional(loan))\n",
    "    return Summary(\n",
    "        values=summary_values,\n",
    "        name=summary_name)\n",
    "\n",
    "\n",
    "summary = None\n",
    "FUNCTIONALS = dict(\n",
    "    total_spent=lambda loan: np.sum(loan.payments_made),\n",
    "    highest_payment=lambda loan: np.max(loan.payments_made),\n",
    "    percentile_95_payment=lambda loan: np.percentile(loan.payments_made, 95)\n",
    ")\n",
    "def widget_function_distribution(\n",
    "    initial_principal=231500.,\n",
    "    number_of_years=37,\n",
    "    initial_interest_percentage=3.286,\n",
    "    spread_percentage=1.,\n",
    "    var_percent=5.,\n",
    "    kernel_type=\"laplace\",\n",
    "    maxlag=100,\n",
    "    num_samples=100,\n",
    "    minimum_ibo_rate_percent=0.,\n",
    "    summary_variable='total_spent',\n",
    "    plot_cdf=True,\n",
    "    plot_kde=False,\n",
    "    plot_hist=True,\n",
    "    # individual_plots=True,\n",
    "    # fill_percent=95.\n",
    "):\n",
    "\n",
    "    global euribor_process\n",
    "    global summary\n",
    "    global loan\n",
    "    # recompute_summary = False\n",
    "    recompute_summary = True  # always recompute\n",
    "    if euribor_process is None:\n",
    "        euribor_process = IBORGaussianProccess(\n",
    "            historical_ibor=historical_euribor.rate.values/100,\n",
    "            autocorrelation_maxlag=maxlag,\n",
    "            kernel_type=kernel_type)\n",
    "        recompute_summary = True\n",
    "    elif euribor_process.kernel_type != kernel_type \\\n",
    "    or euribor_process.autocorrelation_maxlag != maxlag:\n",
    "        euribor_process = IBORGaussianProccess(\n",
    "            historical_ibor=historical_euribor.rate.values/100,\n",
    "            autocorrelation_maxlag=maxlag,\n",
    "            kernel_type=kernel_type)\n",
    "        recompute_summary = True\n",
    "    if loan is None:\n",
    "        loan = AmortizingLoan(\n",
    "            initial_principal=initial_principal,\n",
    "            full_term=number_of_years*12)\n",
    "        recompute_summary = True\n",
    "    elif loan.initial_principal != initial_principal \\\n",
    "    or loan.full_term != number_of_years*12:\n",
    "        loan = AmortizingLoan(\n",
    "            initial_principal=initial_principal,\n",
    "            full_term=number_of_years*12)\n",
    "        recompute_summary = True\n",
    "    \n",
    "    summary_functional = FUNCTIONALS.get(summary_variable)\n",
    "    # if summary is None:\n",
    "    #     recompute_summary = True\n",
    "    # elif len(summary.values) != num_samples:\n",
    "    #     recompute_summary = True\n",
    "    # elif summary.name != summary_variable:\n",
    "    #     recompute_summary = True\n",
    "    if recompute_summary:\n",
    "        summary = run_simulation(\n",
    "            num_simulations=num_samples,\n",
    "            maxlag=maxlag,\n",
    "            kernel_type=kernel_type,\n",
    "            # number_of_years=number_of_years,\n",
    "            initial_interest_percentage=initial_interest_percentage,\n",
    "            minimum_ibo_rate_percent=minimum_ibo_rate_percent,\n",
    "            spread_percentage=spread_percentage,\n",
    "            # initial_principal=initial_principal,\n",
    "            summary_functional=summary_functional,\n",
    "            summary_name=summary_variable)\n",
    "\n",
    "    fig = plt.figure(figsize=(12,5))\n",
    "    plot_summary(\n",
    "        summary,\n",
    "        plot_cdf=plot_cdf,\n",
    "        plot_kde=plot_kde,\n",
    "        plot_hist=plot_hist,\n",
    "        var_percent=var_percent,\n",
    "        ax=plt.gca())\n",
    "    plt.grid(ls=\":\")\n",
    "    plt.show()\n",
    "\n",
    "widget = ipyw.interactive(\n",
    "    widget_function_distribution,\n",
    "    _interactive__options={'manual':True, 'manual_name':\"Press to Run\"},\n",
    "    initial_principal=ipyw.FloatSlider(\n",
    "        min=0., max=400000., value=231500., step=1000.,\n",
    "        description=\"amount borrowed\"),\n",
    "    number_of_years=ipyw.IntSlider(\n",
    "        value=37, min=1, max=40, step=1,\n",
    "        description=\"no. years\"),\n",
    "    initial_interest_percentage=ipyw.FloatSlider(\n",
    "        value=0.992, min=0., max=20., step=0.01,\n",
    "        description=\"initial %\", readout_format='.3f'),\n",
    "    spread_percentage=ipyw.FloatSlider(\n",
    "        value=1.0, min=0., max=20., step=0.01,\n",
    "        description=\"spread %\", readout_format='.3f'),\n",
    "    var_percent=ipyw.FloatSlider(value=5., min=0., max=100., step=0.5),\n",
    "    kernel_type=ipyw.Dropdown(\n",
    "        options=['laplace', 'gaussian', 'mixture'],\n",
    "        description=\"kernel type\",\n",
    "        layout=ipyw.Layout(width=\"200px\")),\n",
    "    num_samples=ipyw.IntText(\n",
    "        value=100, min=0,\n",
    "        description=\"no. samples\",\n",
    "        layout=ipyw.Layout(width=\"150px\")),\n",
    "    maxlag=ipyw.IntText(\n",
    "        value=100, min=1,\n",
    "        description=\"max lag\",\n",
    "        layout=ipyw.Layout(width=\"150px\")),\n",
    "    minimum_ibo_rate_percent=ipyw.FloatText(\n",
    "        value=0.,\n",
    "        description=\"min ibo %\",\n",
    "        layout=ipyw.Layout(width=\"150px\")),\n",
    "    summary_variable=ipyw.Dropdown(options=FUNCTIONALS.keys()),\n",
    "    plot_hist=ipyw.Checkbox(value=True),\n",
    "    plot_kde=ipyw.Checkbox(value=False),\n",
    "    plot_cdf=ipyw.Checkbox(value=True),\n",
    "    )\n",
    "widget.manual_button.style.button_color = 'lightgreen'\n",
    "widget.manual_button.style.font_weight = 'bold'\n",
    "principal_text = ipyw.FloatText(\n",
    "    value=231500.)\n",
    "ipyw.link((principal_text, \"value\"), (widget.children[0], \"value\"))\n",
    "years_text = ipyw.IntText(\n",
    "    value=37)\n",
    "ipyw.link((years_text, \"value\"), (widget.children[1], \"value\"))\n",
    "interest_text = ipyw.FloatText(\n",
    "    value=0.992)\n",
    "ipyw.link((interest_text, \"value\"), (widget.children[2], \"value\"))\n",
    "spread_text = ipyw.FloatText(\n",
    "    value=1.)\n",
    "ipyw.link((spread_text, \"value\"), (widget.children[3], \"value\"))\n",
    "var_text = ipyw.FloatText(\n",
    "    value=5.)\n",
    "ipyw.link((var_text, \"value\"), (widget.children[4], \"value\"))\n",
    "top_row_list = [principal_text, years_text, interest_text, spread_text, var_text]\n",
    "vboxes = [ipyw.VBox(list(xy)) for xy in zip(widget.children, top_row_list)]\n",
    "\n",
    "top_row = ipyw.HBox(\n",
    "    vboxes,\n",
    "    layout=ipyw.Layout(flex_flow='row wrap'))\n",
    "ipyw.VBox([\n",
    "    widget.manual_button,\n",
    "    ipyw.HBox(\n",
    "        [*widget.children[len(top_row_list):-2]],\n",
    "        # [*widget.children[4:-1]],\n",
    "        layout=ipyw.Layout(flex_flow='row wrap')),\n",
    "    top_row,\n",
    "    widget.children[-1]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Other Stuff..\n",
    "\n",
    "* use bqplot instead of matplotlib, or even bokeh, for more interactive plots\n",
    "* use scikit-learn gaussian process regressor, or fit with maximum likelihood ([see this book](http://gaussianprocess.org/gpml/chapters/RW.pdf))  \n",
    "  * learn more about Gaussian processes for machine learning\n",
    "* create SDE models of interest rate curves"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.7 ('phd')",
   "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.9.7"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "c708af387089916f0f004324f3f4834242443884ac7953c2e0e4b2b7f68a63cf"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}