def test_mcl_rollforward():
mcl = cl.load_sample("mcl")
mcl_prior = mcl[mcl.valuation < mcl.valuation_date]
munich = cl.MunichAdjustment(
paid_to_incurred=[("paid", "incurred")]).fit(mcl_prior)
new = munich.transform(mcl)
cl.Chainladder().fit(new).ultimate_
def test_pipeline():
tri = cl.load_sample('clrd').groupby('LOB').sum()[[
'CumPaidLoss', 'IncurLoss', 'EarnedPremDIR'
]]
tri['CaseIncurredLoss'] = tri['IncurLoss'] - tri['CumPaidLoss']
X = tri[['CumPaidLoss', 'CaseIncurredLoss']]
sample_weight = tri['EarnedPremDIR'].latest_diagonal
dev = [
cl.Development(),
cl.ClarkLDF(),
cl.Trend(),
cl.IncrementalAdditive(),
cl.MunichAdjustment(paid_to_incurred=('CumPaidLoss',
'CaseIncurredLoss')),
cl.CaseOutstanding(paid_to_incurred=('CumPaidLoss',
'CaseIncurredLoss'))
]
tail = [cl.TailCurve(), cl.TailConstant(), cl.TailBondy(), cl.TailClark()]
ibnr = [
cl.Chainladder(),
cl.BornhuetterFerguson(),
cl.Benktander(n_iters=2),
cl.CapeCod()
]
for model in list(itertools.product(dev, tail, ibnr)):
print(model)
cl.Pipeline(
steps=[('dev',
model[0]), ('tail',
model[1]), ('ibnr', model[2])]).fit_predict(
X, sample_weight=sample_weight).ibnr_.sum(
'origin').sum('columns').sum()
def test_mcl_ult():
mcl = cl.load_sample("mcl")
dev = cl.Development().fit_transform(mcl)
cl_traditional = cl.Chainladder().fit(dev).ultimate_
dev_munich = cl.MunichAdjustment(
paid_to_incurred=[("paid", "incurred")]).fit_transform(dev)
cl_munich = cl.Chainladder().fit(dev_munich).ultimate_
def test_mcl_paid():
df = r("MunichChainLadder(MCLpaid, MCLincurred)").rx("MCLPaid")
p = cl.MunichAdjustment(paid_to_incurred=("paid", "incurred")).fit(
cl.Development(sigma_interpolation="mack").fit_transform(
cl.load_sample("mcl")))
xp = p.ldf_.get_array_module()
arr = xp.array(df[0])
assert xp.allclose(arr, p.munich_full_triangle_[0, 0, 0, :, :], atol=1e-5)
def test_mcl_paid():
df = r('MunichChainLadder(MCLpaid, MCLincurred)').rx('MCLPaid')
p = cl.MunichAdjustment(paid_to_incurred=('paid', 'incurred')).fit(
cl.Development(sigma_interpolation='mack').fit_transform(
cl.load_sample('mcl'))).munich_full_triangle_[0, 0, 0, :, :]
xp = cp.get_array_module(p)
arr = xp.array(df[0])
xp.testing.assert_allclose(arr, p, atol=1e-5)
def test_mcl_paid():
df = r('MunichChainLadder(MCLpaid, MCLincurred)').rx('MCLPaid')
p = cl.MunichAdjustment(paid_to_incurred={
'paid': 'incurred'
}).fit(
cl.Development(sigma_interpolation='mack').fit_transform(
cl.load_dataset('mcl'))).munich_full_triangle_[0, 0, 0, :, :]
arr = np.array(df[0])
assert_allclose(arr, p, atol=1e-5)
"""
====================================
Munich Chainladder Correlation Plots
====================================
This example demonstrates how to recreate the the residual correlation plots
of the Munich Chainladder paper.
"""
import chainladder as cl
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
# Fit Munich Model
mcl = cl.load_sample('mcl')
model = cl.MunichAdjustment([('paid', 'incurred')]).fit(mcl)
# Plot Data
fig, ((ax0, ax1)) = plt.subplots(ncols=2, figsize=(15, 5))
# Paid lambda line
pd.DataFrame({
'(P/I)': np.linspace(-2, 2, 2),
'P': np.linspace(-2, 2, 2) * model.lambda_.loc['paid']
}).plot(x='(P/I)', y='P', legend=False, ax=ax0)
# Paid scatter
paid_plot = pd.concat(
(model.resids_['paid'].melt(value_name='P')['P'],
model.q_resids_['paid'].melt(value_name='(P/I)')['(P/I)']),
axis=1).plot(kind='scatter',
def test_mcl_incurred():
df = r('MunichChainLadder(MCLpaid, MCLincurred)').rx('MCLIncurred')
p = cl.MunichAdjustment(paid_to_incurred=[('paid','incurred')]).fit(cl.Development(sigma_interpolation='mack').fit_transform(cl.load_sample('mcl')))
xp = p.ldf_.get_array_module()
arr = xp.array(df[0])
assert xp.allclose(arr, p.munich_full_triangle_[1,0,0,:,:], atol=1e-5)
def test_json_df():
x = cl.MunichAdjustment(paid_to_incurred=('paid',
'incurred')).fit_transform(
cl.load_sample('mcl'))
assert abs(cl.read_json(x.to_json()).lambda_ - x.lambda_).sum() < 1e-5
sample_weight=medmal_prem,
).ibnr_.sum())
@pytest.fixture
def tri(clrd):
tri = clrd.groupby('LOB').sum()[[
'CumPaidLoss', 'IncurLoss', 'EarnedPremDIR'
]]
tri['CaseIncurredLoss'] = tri['IncurLoss'] - tri['CumPaidLoss']
return tri
dev = [
cl.Development, cl.ClarkLDF, cl.Trend, cl.IncrementalAdditive,
lambda: cl.MunichAdjustment(paid_to_incurred=(
'CumPaidLoss', 'CaseIncurredLoss')), lambda: cl.CaseOutstanding(
paid_to_incurred=('CumPaidLoss', 'CaseIncurredLoss'))
]
tail = [cl.TailCurve, cl.TailConstant, cl.TailBondy, cl.TailClark]
ibnr = [
cl.Chainladder, cl.BornhuetterFerguson, lambda: cl.Benktander(n_iters=2),
cl.CapeCod
]
@pytest.mark.parametrize('dev', dev)
@pytest.mark.parametrize('tail', tail)
@pytest.mark.parametrize('ibnr', ibnr)
def test_pipeline(tri, dev, tail, ibnr):
X = tri[['CumPaidLoss', 'CaseIncurredLoss']]
sample_weight = tri['EarnedPremDIR'].latest_diagonal
import chainladder as cl
import seaborn as sns
import matplotlib.pyplot as plt
sns.set_style('whitegrid')
sns.set_palette('muted')
# Load data
mcl = cl.load_dataset('mcl')
# Volume weighted (default) LDFs
dev = cl.Development().fit_transform(mcl)
# Traditional Chainladder
cl_traditional = cl.Chainladder().fit(dev)
# Munich Adjustment
dev_munich = cl.MunichAdjustment(paid_to_incurred={
'paid': 'incurred'
}).fit_transform(dev)
cl_munich = cl.Chainladder().fit(dev_munich)
# Plot data
fig, (ax, ax2) = plt.subplots(ncols=2, sharex=True, figsize=(10, 5))
plot1_data = cl_munich.ultimate_['paid'].to_frame()
plot1_data.columns = ['Paid Ultimate']
plot1_data['Incurred Ultimate'] = cl_munich.ultimate_['incurred'].to_frame()
plot2_data = (cl_munich.ultimate_['paid'] /
cl_munich.ultimate_['incurred']).to_frame()
plot2_data.columns = ['Munich']
plot2_data['Traditional'] = (cl_traditional.ultimate_['paid'] /
cl_traditional.ultimate_['incurred']).to_frame()
plot1_data.plot(kind='bar', ax=ax)
ax.set_ylabel('Ultimate')
