Final Selection from different methods (Origin Period Wise)

[muhammadshamsherkhan2002]

I hope that You are fine and perfect.

Please go through the attached excel sheet.

While using chainladder-python library, we may construct the Ultimate & IBNR based on different methods available in the library. Such as:

• Paid Chain ladder Calculation by using chainladder model.
• Paid BF Calculation by using BornhuetterFerguson (BF) model.
• Paid ELR Calculation by using Benktander(apriori=1.0, n_iters=0) model.

I would like to ask you that there is any provision in the library to construct 'paid selected' (highlighted with yellow color in the excel), in which ultimate & ibnr is being selected from the different methods (period wise). I mean that chainladder method for the first 3 origin periods, BF method for the next 2 origin periods and ELR method for the last 3 origin periods.

Please guide me in this regards.

Kindly note that we used separate sample_weights for paid BF & paid ELR respectively in our calculation (in excel sheet).

Final Selection - Working Sheet.xlsx

[jbogaardt]

Yes, the VotingChainladder is intended to provide a user selected average of different methods.

[kennethshsu]

Also available in the tutorial. :)

[muhammadshamsherkhan2002]

Thanks for kind reply.

Please correct me on my understanding, if I am wrong. Please go through the code below,

I calculated the ultimate while utilizing CL, BF, ELR and VotingChainladder models accordingly as:

import pandas as pd
import numpy as np
import chainladder as cl
import matplotlib.pyplot as plt

comauto = cl.load_sample("clrd").groupby("LOB").sum().loc["comauto"]

####################CL Model####################

cl_model = cl.Chainladder().fit(comauto["CumPaidLoss"])
cl_model.ultimate_

CL_Ultimate
1988   626,097
1989   678,931
1990   727,569
1991   727,452
1992   762,823
1993   827,144
1994   907,048
1995   935,913
1996   956,074
1997   1,043,704

####################BF Model####################

bf_model = cl.BornhuetterFerguson(apriori=1.00)
sample_weight_bf = (comauto["EarnedPremNet"].latest_diagonal *. 75) //sample weight for BF
bf_model.fit(comauto["CumPaidLoss"], sample_weight=sample_weight_bf)
bf_model.ultimate_

BF_Ultimate
1988   626,097
1989   679,224
1990   728,363
1991   729,927
1992   767,610
1993   833,686
1994   918,582
1995   954,377
1996   985,280
1997   1,031,637

####################ELR Model####################

elr_model = cl.Benktander(apriori=1.00, n_iters=0)
sample_weight_elr = (comauto["EarnedPremNet"].latest_diagonal * .60) //separate sample weight for ELR
elr_model.fit(X=comauto["CumPaidLoss"],sample_weight=sample_weight_elr)
elr_model.ultimate_

ELR_Ultimate
1988   548,182
1989   578,557
1990   632,413
1991   673,772
1992   702,161
1993   728,208
1994   785,872
1995   801,749
1996   814,960
1997   821,901

####################Voting Chainladder Model####################

estimators = [("cl", cl_model), ("bf", bf_model), ("bk", elr_model)]
//Please clarify that for voting chainladder, could we use different sample weight rather than mentioned in library tutorial?
sample_weight_vot = cl_model.fit(comauto["CumPaidLoss"]).ultimate_ * 0 + (float(cl_model.fit(comauto["CumPaidLoss"]).ultimate_.sum())/10) //sample weight as per tutorial
OR
sample_weight_vot = sample_weight_bf //BF sample weight
OR
sample_weight_vot = sample_weight_elr //ELR sample weight
OR
sample_weight_vot = sample_weight_elr , sample_weight_bf //Both BF & ELR sample weight at the same time

model_weights = np.array([[1, 0, 0]] * 4 + [[0, 1, 0]] * 3 + [[0, 0, 1]] * 3)
vot_mod = cl.VotingChainladder(estimators=estimators,weights=model_weights) //estimators and model weight here
vot_mod.fit(paid_claim, sample_weight=sample_weight_vot) **//sample weight here
vot_mod.ultimate_

Voting_Ultimate
1988   626,097
1989   678,931
1990   727,569
1991   727,452
1992   765,175
1993   826,525
1994   893,602
1995   819,275
1996   819,275
1997   819,275
​
In voting chainladder above, I have some confusion that (as per my knowledge, might be wrong):

• if estimator is cl_model and model_weight = 1 for first 4 origin periods.
  the voting_ultimate should be as same as appeared in CL Model (with bold origin periods). (currently, it is happening in the tutorial).

• if estimator is bf_model and model_weight = 1 for next 3 origin periods.
  then the voting_ultimate should be as same as appeared in BF Model (with bold origin periods). (currently, not happening b/c of different sample weight being used in the tutorial).

• if estimator is elr_model and model_weight = 1 for last 3 origin periods.
  then the voting_ultimate should be as same as appeared in ELR Model (with bold origin periods). (currently, not happening b/c of different sample weight being used in the tutorial).

How could we achieve (highlighted yellow) as mentioned in attached working sheet with sample data. Please answer in detail.

Final Selection - Working Sheet.xlsx

[kennethshsu]

I think you got two options, if you want to use varying sample weights:

1. You can set sample_weight = comauto["EarnedPremNet"].latest_diagonal , and use varying a-priori: ELR with 0.60, and BF with 0.75.
2. You can put everything in a-priori (basically the product vector of premium and your varying a priori loss ratio by method), and just set all sample_weights to a vector of 1s.

Maybe @jbogaardt knows a better way.

[jbogaardt]

Unfortunately, you cannot encode the information you'd like to in to VotingChainladder. As you've discovered, you cannot have more than one VotingChainladder.sample_weight. The Benktander.apriori itself doesn't support vectors of aprioris as far as I know.

Perhaps an actuarial question back you way - Why would an actuary choose different apriori expectations between BornhuetterFerguson and ELR method? They both measure the same thing; specifically the actuary's prior belief in the ultimate before seeing the loss data.

[muhammadshamsherkhan2002]

You are right but it is a requirement which forwarded to us by the actuary team. The team here consider BornhuetterFerguson and ELR method separately and give the different apriori for both.

[jbogaardt]

I didn't expect this to work, but @kennethshsu's suggestion of pushing a vector into the apriori assumption does work:

import chainladder as cl
raa = cl.load_sample('raa')
expectation = raa.latest_diagonal * 0 + 50000 # Some random expectation
ones = expectation * 0 +  1 # sample_weight as a vector of 1s
cl.BornhuetterFerguson(apriori=expectation).fit(raa, sample_weight=ones).ultimate_

Conceivably you could use his second suggestion. Fair warning though, unintended "features" like this may fail in more complex workflows.

[kennethshsu]

@jbogaardt, thinking about this more, and looking at this from the actuarial side, doesn't it make more sense that the apriori is completely captured by the apriori parameter, sample_weight should (most of the time) be a vector of 1s? When I am thinking about BF, I know to pass in a vector of expected losses, which can come from premium and expected loss ratio, but the actual input of BF is only the vector of apriori, not two vectors.

I guess a better question might be, why is apriori inside the method, but 1sample_weight` is only required when using .fit()?

[jbogaardt]

This is a good question and an important one. We adopt sklearn conventions for our estimators. Hyperparameters/assumptions are model features that can be set in the absence of any data. Per sklearn conventions, they belong in model initialization. The data belongs in the fit method. These are strict rules, but conformity to them is tremendously beneficial in terms of project stability and roadmapping. However, these rules also forces us to be very deliberate in classifying input from the user as assumptions or data. This has been the hardest part of developing on this project for me.

Your question as I'd restate it for library usage: Is the actuary's prior belief an assumption or is it data or is it both?
The chainladder package takes the position that it is an ultimate ratio (assumption) times exposure (data) and splits them apart. This makes swapping between different models easy (a major goal of the sklearn API). Consider the requirements of the CapeCod:

# A key design goal is the ability to swap out models on the same data
model1 = cl.BornhuetterFerguson(apriori=0.6).fit(X, sample_weight=sample_weight)
model2 = cl.CapeCod(trend=0, decay=0.75).fit(X, sample_weight=sample_weight)

Since CapeCod needs the exposure base (clearly data), the BornhuetterFerguson method should leverage that as a commonality and take a narrower position on what it treats as an assumption.

[kennethshsu]

And thanks @jbogaardt, good answer, makes sense!

[muhammadshamsherkhan2002]

Dear @kennethshsu,
Please find sample code below as requested.

import pandas as pd
import numpy as np
import chainladder as cl
import matplotlib.pyplot as plt

comauto = cl.load_sample("clrd").groupby("LOB").sum().loc["comauto"]

####################CL Model####################
cl_model = cl.Chainladder().fit(comauto["CumPaidLoss"])
cl_model.ultimate_

CL_Ultimate
1988    626,097
1989    678,931
1990    727,569
1991    727,452
1992    762,823
1993    827,144
1994    907,048
1995    935,913
1996    956,074
1997    1,043,704
####################BF Model####################
bf_model = cl.BornhuetterFerguson(apriori=1.00)
sample_weight_bf = (comauto["EarnedPremNet"].latest_diagonal *. 75) //sample weight for BF
bf_model.fit(comauto["CumPaidLoss"], sample_weight=sample_weight_bf)
bf_model.ultimate_

BF_Ultimate
1988    626,097
1989    679,224
1990    728,363
1991    729,927
1992    767,610
1993    833,686
1994    918,582
1995    954,377
1996    985,280
1997    1,031,637
####################ELR Model####################
elr_model = cl.Benktander(apriori=1.00, n_iters=0)
sample_weight_elr = (comauto["EarnedPremNet"].latest_diagonal * .60) //separate sample weight for ELR
elr_model.fit(X=comauto["CumPaidLoss"],sample_weight=sample_weight_elr)
elr_model.ultimate_

ELR_Ultimate
1988    548,182
1989    578,557
1990    632,413
1991    673,772
1992    702,161
1993    728,208
1994    785,872
1995    801,749
1996    814,960
1997    821,901
####################Voting Chainladder Model####################
estimators = [("cl", cl_model), ("bf", bf_model), ("bk", elr_model)]

sample_weight_vot = sample_weight_bf //BF method as sample weight here

model_weights = np.array([[1, 0, 0]] * 4 + [[0, 1, 0]] * 3 + [[0, 0, 1]] * 3)

vot_mod = cl.VotingChainladder(estimators=estimators, weights = model_weights) //estimators and model weight here

vot_mod.fit(paid_claim, sample_weight=sample_weight_vot) **//one sample weight here. Currently, we could not provide more than one sample weight in voting chainladder.
vot_mod.ultimate_

Paid Selected Ultimate (yellow highlighted in excel)
1988   626,097    //value same as in excel sheet - CL Model
1989   678,931    //value same as in excel sheet - CL Model
1990   727,569    //value same as in excel sheet - CL Model
1991   727,452    //value same as in excel sheet - CL Model
1992   767,610    //value same as in excel sheet - BF Model
1993   833,686    //value same as in excel sheet - BF Model
1994   918,582    //value same as in excel sheet - BF Model
1995   1,002,187    //value not same as in excel sheet - for ELR Model
1996   1,018,700    //value not same as in excel sheet - for ELR Model
1997   1,027,376    //value not same as in excel sheet - for ELR Model

My question is that how will I achieve the same result as mentioned in the attached excel sheet (paid selected - highlighted yellow). Any workaround here for achieving this. please explain with sample code, if available.

Final Selection - Working Sheet.xlsx

[kennethshsu]

You didn't setup your a-prioris and sample weights correctly.

import pandas as pd
import numpy as np
import chainladder as cl
import matplotlib.pyplot as plt

comauto = cl.load_sample("clrd").groupby("LOB").sum().loc["comauto"]

cl_model = cl.Chainladder().fit(comauto["CumPaidLoss"])

bf_model = cl.BornhuetterFerguson(apriori=0.75)
bf_model.fit(comauto["CumPaidLoss"], sample_weight=comauto["EarnedPremNet"].latest_diagonal)

elr_model = cl.Benktander(apriori=0.60, n_iters=0)
elr_model.fit(X=comauto["CumPaidLoss"],sample_weight=comauto["EarnedPremNet"].latest_diagonal)

estimators = [("cl", cl_model), ("bf", bf_model), ("bk", elr_model)]
model_weights = np.array([[1, 0, 0]] * 4 + [[0, 1, 0]] * 3 + [[0, 0, 1]] * 3)
vot_mod = cl.VotingChainladder(estimators=estimators, weights = model_weights)
vot_mod.fit(comauto["CumPaidLoss"], sample_weight=comauto["EarnedPremNet"].latest_diagonal)
vot_mod.ultimate_

[muhammadshamsherkhan2002]

Dear Friends,

I am very very thankful to you all. I got the same result as I had in the excel sheet by your kind support and help.

Your support is highly be appreciable. :)

[kennethshsu]

Excellent, glad it was useful!