From ed6641abdcdf9407fa7e6c57521c6e8f930d73ef Mon Sep 17 00:00:00 2001 From: John Bogaardt Date: Sat, 29 Feb 2020 19:19:31 -0700 Subject: [PATCH] added stochastic tutorial --- chainladder/__init__.py | 2 +- docs/tutorials/stochastic-tutorial.ipynb | 1854 ++++++++++++++++++++++ setup.py | 2 +- 3 files changed, 1856 insertions(+), 2 deletions(-) create mode 100644 docs/tutorials/stochastic-tutorial.ipynb diff --git a/chainladder/__init__.py b/chainladder/__init__.py index b033cd26..fb1f87c9 100644 --- a/chainladder/__init__.py +++ b/chainladder/__init__.py @@ -11,4 +11,4 @@ def array_backend(array_backend='numpy'): from chainladder.methods import * # noqa (API Import) from chainladder.workflow import * # noqa (API Import) -__version__ = '0.5.3' +__version__ = '0.5.4' diff --git a/docs/tutorials/stochastic-tutorial.ipynb b/docs/tutorials/stochastic-tutorial.ipynb new file mode 100644 index 00000000..ce3a52ba --- /dev/null +++ b/docs/tutorials/stochastic-tutorial.ipynb @@ -0,0 +1,1854 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Stochastic methods\n", + "### Getting started\n", + "All exercises rely on chainladder v0.5.4 and later. Also, this notebook uses `statsmodels` for comparison purposes." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'0.5.4'" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import chainladder as cl\n", + "import seaborn as sns\n", + "sns.set_style('whitegrid')\n", + "%matplotlib inline\n", + "cl.__version__" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### MackChainladder Intro\n", + "\n", + "Like the basic `Chainladder` method, the `MackChainladder` is entirely specified by its development pattern selections. In fact, it is the basic `Chainladder` with a few extra features. Let's explore this a bit more with the Workers' Compensation industry triangle." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tri = cl.load_dataset('clrd').groupby('LOB').sum().loc['wkcomp', ['CumPaidLoss', 'EarnedPremNet']]\n", + "cl.Chainladder().fit(tri['CumPaidLoss']).ultimate_ == \\\n", + "cl.MackChainladder().fit(tri['CumPaidLoss']).ultimate_" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's create a Mack Model." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "mack = cl.MackChainladder().fit(tri['CumPaidLoss'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "MackChainladder has the following additional fitted features that the deterministic `Chainladder` does not.\n", + "\n", + "1. `full_std_err_`: The full standard error\n", + "2. `total_process_risk_`: The total process error\n", + "3. `total_parameter_risk_`: The total parameter error\n", + "4. `mack_std_err_`: The total prediction error by origin period\n", + "5. `total_mack_std_err_`: The total prediction error across all origin periods\n", + "\n", + "Notice these are all measures of uncertainty, but where do they come from? Let's start by examining the `link_ratios` underlying the triangle" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Origin1224
1988285,804638,532
1989307,720684,140
1990320,124757,479
1991347,417793,749
1992342,982781,402
1993342,385743,433
1994351,060750,392
1995343,841768,575
1996381,484736,040
" + ], + "text/plain": [ + " 12 24\n", + "1988 285804.0 638532.0\n", + "1989 307720.0 684140.0\n", + "1990 320124.0 757479.0\n", + "1991 347417.0 793749.0\n", + "1992 342982.0 781402.0\n", + "1993 342385.0 743433.0\n", + "1994 351060.0 750392.0\n", + "1995 343841.0 768575.0\n", + "1996 381484.0 736040.0" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tri_first_lags = tri[tri.development<=24][tri.origin<'1997']['CumPaidLoss']\n", + "tri_first_lags" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A simple average link-ratio can be directly computed as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2.2066789527531494" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tri_first_lags.link_ratio.to_frame().mean().values[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Verifying that this ties to our `Development` object:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2.2066789527531494" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cl.Development(average='simple').fit(tri['CumPaidLoss']).ldf_.to_frame().values[0, 0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### A linear regression framework\n", + "\n", + "Mack noticed that this estimate for an LDF is really just a linear regression fit. For the case of the `simple` average, it is a weighted regression where the weight is set to $\\left (\\frac{1}{X} \\right )^{2}$.\n", + "\n", + "With the regression framework in hand, we get much more information about our LDF estimate than just the coefficient." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\jbogaard\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\scipy\\stats\\stats.py:1450: UserWarning: kurtosistest only valid for n>=20 ... continuing anyway, n=9\n", + " \"anyway, n=%i\" % int(n))\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
WLS Regression Results
Dep. Variable: y R-squared (uncentered): 0.997
Model: WLS Adj. R-squared (uncentered): 0.997
Method: Least Squares F-statistic: 2887.
Date: Sat, 29 Feb 2020 Prob (F-statistic): 1.60e-11
Time: 19:18:37 Log-Likelihood: -107.89
No. Observations: 9 AIC: 217.8
Df Residuals: 8 BIC: 218.0
Df Model: 1
Covariance Type: nonrobust
\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
coef std err t P>|t| [0.025 0.975]
x1 2.2067 0.041 53.735 0.000 2.112 2.301
\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
Omnibus: 7.448 Durbin-Watson: 1.177
Prob(Omnibus): 0.024 Jarque-Bera (JB): 2.533
Skew: -1.187 Prob(JB): 0.282
Kurtosis: 4.058 Cond. No. 1.00


Warnings:
[1] Standard Errors assume that the covariance matrix of the errors is correctly specified." + ], + "text/plain": [ + "\n", + "\"\"\"\n", + " WLS Regression Results \n", + "=======================================================================================\n", + "Dep. Variable: y R-squared (uncentered): 0.997\n", + "Model: WLS Adj. R-squared (uncentered): 0.997\n", + "Method: Least Squares F-statistic: 2887.\n", + "Date: Sat, 29 Feb 2020 Prob (F-statistic): 1.60e-11\n", + "Time: 19:18:37 Log-Likelihood: -107.89\n", + "No. Observations: 9 AIC: 217.8\n", + "Df Residuals: 8 BIC: 218.0\n", + "Df Model: 1 \n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "x1 2.2067 0.041 53.735 0.000 2.112 2.301\n", + "==============================================================================\n", + "Omnibus: 7.448 Durbin-Watson: 1.177\n", + "Prob(Omnibus): 0.024 Jarque-Bera (JB): 2.533\n", + "Skew: -1.187 Prob(JB): 0.282\n", + "Kurtosis: 4.058 Cond. No. 1.00\n", + "==============================================================================\n", + "\n", + "Warnings:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "\"\"\"" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import statsmodels.api as sm\n", + "import numpy as np\n", + "y = tri_first_lags.to_frame().values[:, 1]\n", + "X = tri_first_lags.to_frame().values[:, 0]\n", + "\n", + "model = sm.WLS(y, X, weights=(1/X)**2)\n", + "results = model.fit()\n", + "results.summary()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "By toggling the weights of our regression, we can handle the most common types of averaging used in picking loss development factors." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Does this work for simple?\n", + "True\n", + "Does this work for volume-weighted average?\n", + "True\n", + "Does this work for regression average?\n", + "True\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\users\\jbogaard\\documents\\bitbucket\\chainladder-python\\chainladder\\utils\\weighted_regression.py:49: RuntimeWarning: invalid value encountered in true_divide\n", + " (xp.nansum(w*x*x, axis)-xp.nanmean(x, axis)*xp.nansum(w*x, axis)))\n" + ] + } + ], + "source": [ + "print('Does this work for simple?')\n", + "print(round(cl.Development(average='simple').fit(tri_first_lags).ldf_.to_frame().values[0, 0], 8) == \\\n", + " round(sm.WLS(y, X, weights=(1/X)**2).fit().params[0],8))\n", + "print('Does this work for volume-weighted average?')\n", + "print(round(cl.Development(average='volume').fit(tri_first_lags).ldf_.to_frame().values[0, 0], 8) == \\\n", + " round(sm.WLS(y, X, weights=(1/X)).fit().params[0],8))\n", + "print('Does this work for regression average?')\n", + "print(round(cl.Development(average='regression').fit(tri_first_lags).ldf_.to_frame().values[0, 0], 8) == \\\n", + " round(sm.OLS(y, X).fit().params[0],8))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This regression framework is what the `Development` estimator uses to set development patterns. Although we discard the information in deterministic approaches, `Development` has two useful statistics for estmating reserve variability, both of which come from the regression framework. The stastics are `std_err_` and `sigma_` and they are used by the `MackChainladder` estimator to determine the prediction error of our reserves." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "dev = cl.Development(average='simple').fit(tri['CumPaidLoss'])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Origin12-2424-3636-4848-6060-7272-8484-9696-108108-120
(All)0.04110.01200.00510.00370.00330.00330.00420.00680.0032
" + ], + "text/plain": [ + " 12-24 24-36 36-48 48-60 60-72 72-84 84-96 96-108 108-120\n", + "(All) 0.041066 0.012024 0.005101 0.003734 0.003303 0.003337 0.00419 0.006831 0.003222" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dev.std_err_" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Origin12-2424-3636-4848-6060-7272-8484-9696-108108-120
(All)0.12320.03400.01350.00910.00740.00670.00730.00970.0032
" + ], + "text/plain": [ + " 12-24 24-36 36-48 48-60 60-72 72-84 84-96 96-108 108-120\n", + "(All) 0.123197 0.034009 0.013495 0.009146 0.007386 0.006673 0.007257 0.00966 0.003222" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dev.sigma_" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since the regression framework is weighted, we can easily turn on/off any observation we want using the dropping capabilities of the `Development` estimator. Dropping link ratios not only affects the `ldf_` and `cdf_`, but also the `std_err_` and `sigma` of the regression.\n", + "\n", + "Here we eliminate the 1988 valuation from our triangle, which is identical to eliminating the first observation from our 12-24 regression fit." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Does this work for dropping observations?\n", + "True\n" + ] + } + ], + "source": [ + "print('Does this work for dropping observations?')\n", + "print(round(cl.Development(average='volume', drop_valuation='1988') \\\n", + " .fit(tri['CumPaidLoss']).std_err_.to_frame().values[0, 0], 8) == \\\n", + " round(sm.WLS(y[1:], X[1:], weights=(1/X[1:])).fit().bse[0],8))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With `sigma_` and `std_err_` in hand, Mack goes on to develop recursive formulas to estimate `parameter_risk_` and `process_risk_`." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Origin12243648607284961081209999
198800000000000
19890000000005,2515,251
1990000000009,52011,18311,183
199100000005,98411,62913,16113,161
19920000004,5887,46812,25213,64813,648
1993000004,0375,9818,18712,25913,50213,502
199400004,1635,9807,5559,50313,30214,50614,506
19950004,9216,7368,1379,44611,11814,50215,62015,620
1996008,82411,28912,89514,10115,19016,51319,14120,09020,090
1997014,49921,07524,74927,09328,65729,90731,16433,10333,89733,897
" + ], + "text/plain": [ + " 12 24 36 48 60 72 84 96 108 120 9999\n", + "1988 0.0 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000\n", + "1989 0.0 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 5251.180091 5251.180091\n", + "1990 0.0 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 9519.597764 11182.642025 11182.642025\n", + "1991 0.0 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 5983.826435 11629.056593 13161.494851 13161.494851\n", + "1992 0.0 0.000000 0.000000 0.000000 0.000000 0.000000 4587.550645 7467.757613 12251.618351 13648.337451 13648.337451\n", + "1993 0.0 0.000000 0.000000 0.000000 0.000000 4036.584426 5980.685134 8186.842405 12258.771773 13502.229704 13502.229704\n", + "1994 0.0 0.000000 0.000000 0.000000 4162.542848 5980.464847 7554.693620 9503.083404 13302.246384 14505.513836 14505.513836\n", + "1995 0.0 0.000000 0.000000 4920.825234 6735.780467 8137.402853 9445.571257 11118.249482 14501.741876 15619.795959 15619.795959\n", + "1996 0.0 0.000000 8823.893815 11288.653535 12894.776869 14100.808340 15189.795391 16513.301328 19140.782034 20089.868162 20089.868162\n", + "1997 0.0 14499.310582 21075.422823 24748.584403 27093.408297 28657.082880 29907.337622 31164.059421 33102.891878 33896.767821 33896.767821" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mack.parameter_risk_" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Assumption of Independence\n", + "The Mack model makes a lot of assumptions about independence (i.e. covariance between random processes is 0). This means many of the Variance estimates in the `MackChainladder` model follow the form of $Var(A+B) = Var(A)+Var(B)$.\n", + "\n", + "Notice the sqaure of `mack_std_err_` is simply the sum of the sqaures of `parameter_risk_` and `process_risk_`." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter risk and process risk are independent?\n", + "True\n" + ] + } + ], + "source": [ + "print('Parameter risk and process risk are independent?')\n", + "print(round(mack.mack_std_err_**2, 4) == round(mack.parameter_risk_**2 + mack.process_risk_**2, 4))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This independence assumption applies to variance of each origin period." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total Parameter and process risk across origin periods is independent?\n", + "True\n" + ] + } + ], + "source": [ + "print('Total Parameter and process risk across origin periods is independent?')\n", + "print(round(mack.total_process_risk_**2, 4) == round((mack.process_risk_**2).sum('origin'), 4))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Independence is also assumed to apply to the overall standard error of reserves, `total_mack_std_err_`." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(mack.total_process_risk_**2 + mack.total_parameter_risk_**2).to_frame().values[0, -1] == \\\n", + "(mack.total_mack_std_err_**2).values[0,0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This over-reliance on independence is one of the weaknesses of the `MackChainladder` method. Nevertheless, if the data align with this assumption, then `total_mack_std_err_` is a reasonable esimator of reserve variability.\n", + "\n", + "### Mack Reserve Variability\n", + "The `mack_std_err_` at ultimate is the reserve variability at for each `origin`" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Origin9999
19880
19897,313
199017,838
199121,814
199223,847
199325,283
199428,465
199533,172
199650,244
199799,027
" + ], + "text/plain": [ + " 9999\n", + "1988 0.000000\n", + "1989 7312.634869\n", + "1990 17838.223062\n", + "1991 21813.683826\n", + "1992 23847.273221\n", + "1993 25282.602592\n", + "1994 28465.249566\n", + "1995 33171.832916\n", + "1996 50243.750958\n", + "1997 99026.911753" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mack.mack_std_err_[mack.mack_std_err_.development==mack.mack_std_err_.development.max()]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "These are probably easier to see in the `summary_` of the `MackChainladder` model." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
OriginLatestIBNRUltimateMack Std Err
19881,241,71501,241,7150
19891,308,70613,3211,322,0277,313
19901,394,67542,2101,436,88517,838
19911,414,74779,4091,494,15621,814
19921,328,801119,7091,448,51023,847
19931,187,581167,1921,354,77325,283
19941,114,842260,4011,375,24328,465
1995962,081402,4031,364,48433,172
1996736,040636,8341,372,87450,244
1997340,1321,056,3351,396,46799,027
" + ], + "text/plain": [ + " Latest IBNR Ultimate Mack Std Err\n", + "1988 1241715.0 0.000000e+00 1.241715e+06 0.000000\n", + "1989 1308706.0 1.332126e+04 1.322027e+06 7312.634869\n", + "1990 1394675.0 4.221037e+04 1.436885e+06 17838.223062\n", + "1991 1414747.0 7.940888e+04 1.494156e+06 21813.683826\n", + "1992 1328801.0 1.197087e+05 1.448510e+06 23847.273221\n", + "1993 1187581.0 1.671916e+05 1.354773e+06 25282.602592\n", + "1994 1114842.0 2.604007e+05 1.375243e+06 28465.249566\n", + "1995 962081.0 4.024025e+05 1.364484e+06 33171.832916\n", + "1996 736040.0 6.368335e+05 1.372874e+06 50243.750958\n", + "1997 340132.0 1.056335e+06 1.396467e+06 99026.911753" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mack.summary_" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_data = mack.summary_.to_frame()\n", + "g = plot_data[['Latest', 'IBNR']] \\\n", + " .plot(kind='bar', stacked=True,\n", + " yerr=pd.DataFrame({'latest': plot_data['Mack Std Err']*0,\n", + " 'IBNR': plot_data['Mack Std Err']}),\n", + " ylim=(0, None), title='Mack Chainladder Ultimate')\n", + "g.set_xlabel('Accident Year')\n", + "g.set_ylabel('Loss');" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "dist = pd.Series(np.random.normal(mack.ibnr_.sum(),\n", + " mack.total_mack_std_err_.values[0, 0], size=10000))\n", + "dist.plot(\n", + " kind='hist', bins=50,\n", + " title=f\"\"\"Normally distributed IBNR estimate with a mean of {'{:,}'.format(round(mack.ibnr_.sum(),0))[:-2]}\"\"\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### ODP Bootstrap Model\n", + "\n", + "The `MackChainladder` focused on a regression framework for determining the variability of reserve estimates. An alternative approach is to use statistical bootstrapping or sampling from a triangle with replacement to simulate new triangles.\n", + "\n", + "Bootstrapping imposes less model constraints than the `MackChainladder` which allows for greater applicability in different scenarios. Sampling new triangles can be accomplished through the `BootstrapODPSample` estimator. This estimator will take a single triangle and simulate new ones from it.\n", + "\n", + "Notice how easy it is to simulate 10,000 new triangles from an existing triangle by accessing the `resampled_triangles_` attribute." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "samples = cl.BootstrapODPSample(n_sims=10000).fit(tri['CumPaidLoss']).resampled_triangles_" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Alternatively, we could use `BootstrapODPSample` to transform our triangle into a resampled set." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "samples = cl.BootstrapODPSample(n_sims=10000).fit_transform(tri['CumPaidLoss'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The notion of the ODP Bootstrap is that as our simulations approach infinity, we should expect our mean simulation to converge on the basic `Chainladder` estimate of of reserves.\n", + "\n", + "Let's apply the basic chainladder to our original triangle and also to our simulated triangles to see whether this holds true." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Percentage difference in estimate using original triangle and BootstrapODPSample is -0.0\n" + ] + } + ], + "source": [ + "difference = round(1 - cl.Chainladder().fit(samples).ibnr_.sum('origin').mean() / \\\n", + " cl.Chainladder().fit(tri['CumPaidLoss']).ibnr_.sum())\n", + "print(f\"Percentage difference in estimate using original triangle and BootstrapODPSample is {difference}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Using deterministic methods with Bootstrap samples\n", + "Our `samples` is just another triangle object with all the functionality of a regular triangle. This means we can apply any functionality we want to our `samples` including any deterministic methods we learned about previously." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Triangle Summary
Valuation:1997-12
Grain:OYDY
Shape:(10000, 1, 10, 10)
Index:[LOB]
Columns:[CumPaidLoss]
" + ], + "text/plain": [ + "Valuation: 1997-12\n", + "Grain: OYDY\n", + "Shape: (10000, 1, 10, 10)\n", + "Index: ['LOB']\n", + "Columns: ['CumPaidLoss']" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "samples" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Pipeline(memory=None,\n", + " steps=[('dev',\n", + " Development(average='simple', drop=None, drop_high=None,\n", + " drop_low=None, drop_valuation=None, n_periods=-1,\n", + " sigma_interpolation='log-linear')),\n", + " ('tail', TailConstant(decay=0.5, tail=1.05))],\n", + " verbose=False)" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pipe = cl.Pipeline([\n", + " ('dev', cl.Development(average='simple')),\n", + " ('tail', cl.TailConstant(1.05))])\n", + "pipe.fit(samples)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now instead of a single `cdf_` vector, we have 10,000." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Triangle Summary
Valuation:1997-12
Grain:OYDY
Shape:(10000, 1, 10, 9)
Index:[LOB]
Columns:[CumPaidLoss]
" + ], + "text/plain": [ + "Valuation: 1997-12\n", + "Grain: OYDY\n", + "Shape: (10000, 1, 10, 9)\n", + "Index: ['LOB']\n", + "Columns: ['CumPaidLoss']" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pipe.named_steps.dev.cdf_" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This allows us to look at the varibility of any fitted property used in our prior tutorials." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "12-24 LDF of original Triangle: 2.2067\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "orig_dev = cl.Development(average='simple').fit(tri['CumPaidLoss'])\n", + "resampled_ldf = pipe.named_steps.dev.ldf_\n", + "print(f\"12-24 LDF of original Triangle: {round(orig_dev.ldf_.values[0,0,0,0],4)}\")\n", + "pd.Series(resampled_ldf.values[:, 0, 0, 0]).plot(\n", + " kind='hist', bins=100,\n", + " title='Age 12-14 LDF distribution using Bootstrap');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Comparison between Bootstrap and Mack\n", + "We should even be able to approximate some of the Mack parameters calculated using the regression framework." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "mack_vs_bs = resampled_ldf[resampled_ldf.origin == resampled_ldf.origin.max()].std('index').to_frame().append(\n", + " orig_dev.std_err_.to_frame()).T\n", + "mack_vs_bs.columns = ['Mack', 'Bootstrap']\n", + "mack_vs_bs.plot(kind='bar', title='Mack Regression Framework LDF Std Err vs Bootstrap Simulated LDF Std Err');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "While the `MackChainladder` produces statistics about the mean and variance of reserve estimates, those have to be fit to a distribution using MLE, MoM, etc to see the range of outcomes of reserves. With `BootstrapODPSample` based fits, we can use the empirical distribution directly if we choose to." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "99%-ile of reserve estimate is 3,151,387.0\n" + ] + } + ], + "source": [ + "ibnr = cl.Chainladder().fit(samples).ibnr_.sum('origin')\n", + "ibnr_99 = ibnr.quantile(0.99).to_frame().values[0,0]\n", + "print(f\"99%-ile of reserve estimate is {'{:0,}'.format(round(ibnr_99,0))}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's see how the `MackChainladder` reserve distribution compares to the `BootstrapODPSample` reserve distribution." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "ax = ibnr.plot(kind='hist', bins=50, alpha=0.9, color='yellow').plot()\n", + "dist.plot(kind='hist', bins=50, alpha=0.3, color='blue', title='Mack vs Bootstrap Variability');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Expected loss methods with Bootstrap\n", + "\n", + "So far, we've only applied the multiplicative methods (i.e. basic chainladder) in a stochastic context. It is possible to use an expected loss method like the `BornhuetterFerguson`. \n", + "\n", + "To do this, we will need an exposure vector." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
OriginEarnedPremNet
19881,691,130
19891,797,930
19901,880,315
19912,064,835
19922,189,448
19932,482,657
19942,594,787
19952,616,831
19962,420,655
19972,207,902
" + ], + "text/plain": [ + " EarnedPremNet\n", + "1988 2e+06\n", + "1989 2e+06\n", + "1990 2e+06\n", + "1991 2e+06\n", + "1992 2e+06\n", + "1993 2e+06\n", + "1994 3e+06\n", + "1995 3e+06\n", + "1996 2e+06\n", + "1997 2e+06" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tri['EarnedPremNet'].latest_diagonal" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We don't necessarily need to simulate new premiums, because they aren't stochastic, but we will need to align it with our simulated triangles. We do this by repeating our premium vector for each simluated triangle using the `broadcast_axis` method of the `Triangle` class. This method projects the axis of our samples onto our premium vector, repeating premium values until our shapes are aligned." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Triangle Summary
Valuation:1997-12
Grain:OYDY
Shape:(10000, 1, 10, 1)
Index:[LOB]
Columns:[EarnedPremNet]
" + ], + "text/plain": [ + "Valuation: 1997-12\n", + "Grain: OYDY\n", + "Shape: (10000, 1, 10, 1)\n", + "Index: ['LOB']\n", + "Columns: ['EarnedPremNet']" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "prem_samples = tri['EarnedPremNet'].latest_diagonal.broadcast_axis('index', samples.index)\n", + "prem_samples" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `BornhuetterFerguson` method takes an apriori assumption which itself can be considered to be drawn from a Random process." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Simulate aprioris using numpy\n", + "apriori_mu = 0.65\n", + "apriori_sigma = .10\n", + "aprioris = np.random.normal(apriori_mu, apriori_sigma, 10000)\n", + "pd.Series(aprioris).plot(kind='hist', bins=50, title='Distribution of Aprioris');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Recall that the `BornhuetterFerguson` apriori needs to be a constant, so we cannot use it directly. But we can exploit the fact the the premium vector and the apriori are multiplicative and embed our resampled apriori directly into our premium vector. We will modify the premium triangle using `numpy`." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Triangle Summary
Valuation:1997-12
Grain:OYDY
Shape:(10000, 1, 10, 1)
Index:[LOB]
Columns:[EarnedPremNet]
" + ], + "text/plain": [ + "Valuation: 1997-12\n", + "Grain: OYDY\n", + "Shape: (10000, 1, 10, 1)\n", + "Index: ['LOB']\n", + "Columns: ['EarnedPremNet']" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "prem_samples.values = (prem_samples.values * aprioris.reshape(10000,-1)[..., np.newaxis, np.newaxis])\n", + "prem_samples" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now our premium vector is stochastic." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "prem_samples.sum('origin').plot(kind='hist', bins=50, title=\"Premium x Apriori\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With these components, fitting the `BornhuetterFerguson` or any other expected loss method is straight forward and looks just like its deterministic counterpart." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "bf = cl.BornhuetterFerguson().fit(samples, sample_weight=prem_samples)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can use our knowledge of `Triangle` manipulation to grab most things we would want out of our model" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "# Grab completed triangle replacing simulated known data with actual known data\n", + "full_triangle = bf.full_triangle_ - bf.X_ + \\\n", + " tri['CumPaidLoss'].broadcast_axis('index', samples.index)\n", + "\n", + "# Limiting to the current year for plotting\n", + "current_year = full_triangle[full_triangle.origin==full_triangle.origin.max()].to_frame().T" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As expected, plotting the expected development of our full triangle over time from the Bootstrap `BornhuetterFerguson` model fans out to greater uncertainty the farther we get from our valuation date." + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the data\n", + "current_year.iloc[:, :200].reset_index(drop=True).plot(\n", + " color='green', legend=False, alpha=0.1,\n", + " title='Current Accident Year Expected Development Distribution', grid=True);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Recap\n", + "- The Mack method approaches stochastic reserving from a regression point of view
\n", + "- Bootstrap methods approach stochastic reserving from a simulation point of view
\n", + "- Where they assumptions of each model are not violated, they produce resonably consistent estimates of reserve variability
\n", + "- Mack does impose more assumptions (i.e. constraints) on the reserve estimate making the Bootstrap approach more suitable in a broader set of applciations
\n", + "- Both methods converge to their corresponding deterministic point estimates
" + ] + } + ], + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/setup.py b/setup.py index 029be813..ad076b6a 100644 --- a/setup.py +++ b/setup.py @@ -9,7 +9,7 @@ descr = "Chainladder Package - P&C Loss Reserving package " name = 'chainladder' url = 'https://github.com/casact/chainladder-python' -version='0.5.3' # Put this in __init__.py +version='0.5.4' # Put this in __init__.py data_path = '' setup(