MultiChainLadder: Multivariate Chain Ladder Models
In edalmoro/ChainLadderQuantileV1: Statistical Methods and Models for Claims Reserving in General Insurance

Description Usage Arguments Details Value Note Author(s) References See Also Examples

The function MultiChainLadder implements multivariate methods to forecast insurance loss payments based on several cumulative claims development triangles. These methods are multivariate extensions of the chain ladder technique, which develop several correlated triangles simultaneously in a way that both contemporaneous correlations and structural relationships can be accounted for. The estimated conditional Mean Square Errors (MSE) are also produced.

MultiChainLadder(Triangles, fit.method = "SUR", delta = 1,
  int = NULL, restrict.regMat = NULL, extrap = TRUE, 
  mse.method = "Mack", model = "MCL", ...)
    
MultiChainLadder2(Triangles, mse.method = "Mack", last = 3, 
  type = c("MCL", "MCL+int", "GMCL-int", "GMCL"), ...)

`Triangles`	a list of cumulative claims triangles of the same dimensions.
`fit.method`	the method used to fit the multivariate regression in each development period. The default is `"SUR"` - seemingly unrelated regressions. When `"OLS"` (Ordinary Least Squares) is used, this is the same as developing each triangle separately.
`delta`	parameter for controlling weights. It is used to determine the covariance structure D(Y_{i,k}^{δ/2})Σ_k D(Y_{i,k}^{δ/2}). The default value `1` means that the variance is proportional to the cumulative loss from the previous period.
`int`	a numeric vector that indicates which development periods have intercepts specified. This only takes effect for `model = "GMCL"`. The default `NULL` means that no intercepts are specified.
`restrict.regMat`	a list of matrix specifying parameter restriction matrix for each period. This is only used for `model = "GMCL"`. The default value `NULL` means no restriction is imposed on the development matrix. For example, if there are 3 triangles, there will be 9 parameters in the development matrix for each period if `restrict.regMat = NULL`. See `systemfit` for how to specify the appropriate parameter constraints.
`extrap`	a logical value indicating whether to use Mack's extrapolation method for the last period to get the residual variance estimation. It only takes effect for `model = "MCL"`. If the data are trapezoids, it is set to be `FALSE` automatically and a warning message is given.
`mse.method`	method to estimate the mean square error. It can be either `"Mack"` or `"Independence"`, which are the multivariate generalization of Mack's formulas and the conditional re-sampling approach, respectively.
`model`	the structure of the model to be fitted. It is either `"MCL"` or `"GMCL"`. See details below.
`last`	an integer. The `MultiChainLadder2` function splits the triangles into 2 parts internally (see details below), and the `last` argument indicates how many of the development periods in the tail go into the second part of the split. The default is `3`.
`type`	the type of the model structure to be specified for the first part of the split model in `MultiChainLadder2`. `"MCL"`- the multivariate chain ladder with diagonal development matrix; `"MCL+int"`- the multivariate chain ladder with additional intercepts; `"GMCL-int"`- the general multivariate chain ladder without intercepts; and `"GMCL"` - the full general multivariate chain ladder with intercepts and non-diagonal development matrix.
`...`	arguments passed to `systemfit`.

This function implements multivariate loss reserving models within the chain ladder framework. Two major models are included. One is the Multivariate Chain Ladder (MCL) model proposed by Prohl and Schmidt (2005). This is a direct multivariate generalization of the univariate chain ladder model in that losses from different triangles are assumed to be correlated but the mean development in one triangle only depends on its past values, not on the observed values from other triangles. In contrast, the other model, the General Multivariate Chain Ladder (GMCL) model outlined in Zhang (2010), extends the MCL model by allowing development dependencies among different triangles as well as the inclusion of regression intercepts. As a result, structurally related triangles, such as the paid and incurred loss triangles or the paid loss and case reserve triangles, can be developed together while still accounting for the potential contemporaneous correlations. While the MCL model is a special case of the GMCL model, it is programmed and listed separately because: a) it is an important model for its own sake; b) different MSE methods are only available for the MCL model; c) extrapolation of the residual variance estimation can be implemented for the MCL model, which is considerably difficult for the GMCL model.

We introduce some details of the GMCL model in the following. Assume N triangles are available. Denote Y_{i,k}=(Y^{(1)}_{i,k}, … ,Y^{(N)}_{i,k}) as an N \times 1 vector of cumulative losses at accident year i and development year k, where (n) refers to the n-th triangle. The GMCL model in development period k (from development year k to year k+1) is:

Y_{i,k+1}=A_k + B_k \cdot Y_{i,k}+ε_{i,k},

where A_k is a column of intercepts and B_k is the N \times N development matrix. By default, MultiChainLadder sets A_k to be zero. This behavior can be changed by appropriately specifying the int argument. Assumptions for this model are:

E(ε_{i,k}|Y_{i,1},…,Y_{i,I+1-k})=0.

cov(ε_{i,k}|Y_{i,1},…,Y_{i,I+1-k})=Σ_{ε_{i,k}}=D(Y_{i,k}^{δ/2})Σ_k D(Y_{i,k}^{δ/2}).

\mbox{losses of different accident years are independent}.

ε_{i,k} \, \mbox{are symmetrically distributed}.

The GMCL model structure is generally over-parameterized. Parameter restrictions are usually necessary for the estimation to be feasible, which can be specified through the restrict.regMat argument. We refer the users to the documentation for systemfit for details and the demo of the present function for examples.

In particular, if one restricts the development matrix to be diagonal, the GMCL model will reduce to the MCL model. When non-diagonal development matrix is used and the GMCL model is applied to paid and incurred loss triangles, it can reflect the development relationship between the two triangles, as described in Quarg and Mack (2004). The full bivariate model is identical to the "double regression" model described by Mack (2003), which is argued by him to be very similar to the Munich Chain Ladder (MuCL) model. The GMCL model with intercepts can also help improve model adequacy as described in Barnett and Zehnwirth (2000).

Currently, the GMCL model only works for trapezoid data, and only implements mse.method = "Mack". The MCL model allows an additional mse estimation method that assumes independence among the estimated parameters. Further, the MCL model using fit.method = "OLS" will be equivalent to running univariate chain ladders separately on each triangle. Indeed, when only one triangle is specified (as a list), the MCL model is equivalent to MackChainLadder.

The GMCL model allows different model structures to be specified in each development period. This is generally achieved through the combination of the int argument, which specifies the periods that have intercepts, and the restrict.regMat argument, which imposes parameter restrictions on the development matrix.

In using the multivariate methods, we often specify separate univariate chain ladders for the tail periods to stabilize the estimation - there are few data points in the tail and running a multivariate model often produces extremely volatile estimates or even fails. In this case, we can use the subset operator "[" defined for class triangles to split the input data into two parts. We can specify a multivariate model with rich structures on the first part to reflect the multivariate dependencies, and simply apply multiple univariate chain ladders on the second part. The two models are subsequently joined together using the Join2Fits function. We can then invoke the predict and Mse methods to produce loss predictions and mean square error estimations. They can further be combined via the JoinFitMse function to construct an object of class MultiChainLadder. See the demo for such examples.

To facilitate such a split-and-join process for most applications, we have created the function MultiChainLadder2. This function splits the data according to the last argument (e.g., if last = 3, the last three periods go into the second part), and fits the first part according to the structure indicated in the type argument. See the 'Arguments' section for details.

MultiChainLadder returns an object of class MultiChainLadder with the following slots:

`model`	the model structure used, either `"MCL"` or `"GMCL"`
`Triangles`	input triangles of cumulative claims that are converted to class `triangles` internally.
`models`	fitted models for each development period. This is the output from the call of `systemfit`.
`coefficients`	estimated regression coefficients or development parameters. They are put into the matrix format for the GMCL model.
`coefCov`	estimated variance-covariance matrix for the regression coefficients.
`residCov`	estimated residual covariance matrix.
`fit.method`	multivariate regression estimation method
`delta`	the value of delta
`mse.ay`	mean square error matrix for each accident year
`mse.ay.est`	estimation error matrix for each accident year
`mse.ay.proc`	process error matrix for each accident year
`mse.total`	mean square error matrix for all accident years combined
`mse.total.est`	estimation error matrix for all accident years combined
`mse.total.proc`	process error matrix for all accident years combined
`FullTriangles`	the forecasted full triangles of class `triangles`
`int`	intercept indicators

When MultiChainLadder or MultiChainLadder2 fails, the most possible reason is that there is little or no development in the tail periods. That is, the development factor is 1 or almost equal to 1. In this case, the systemfit function may fail even for fit.method = "OLS", because the residual covariance matrix Σ_k is singular. The simplest solution is to remove these columns using the "[" operator and fit the model on the remaining part.

Also, we recommend the use of MultiChainLadder2 over MultiChainLadder. The function MultiChainLadder2 meets the need for most applications, is relatively easy to use and produces more stable but very similar results to MultiChainLadder. Use MultiChainLadder only when non-standard situation arises, e.g., when different parameter restrictions are needed for different periods. See the demo for such examples.

Wayne Zhang actuary_zhang@hotmail.com

Buchwalder M, Bühlmann H, Merz M, Wüthrich M.V (2006). The mean square error of prediction in the chain ladder reserving method (Mack and Murphy revisited), ASTIN Bulletin, 36(2), 521-542.

Prohl C, Schmidt K.D (2005). Multivariate chain-ladder, Dresdner Schriften zur Versicherungsmathematik.

Mack T (1993). Distribution-free calculation of the standard error, ASTIN Bulletin, 23, No.2.

Mack T (1999). The standard error of chain ladder reserve estimates: recursive calculation and inclusion of a tail factor, ASTIN Bulletin, 29, No.2, 361-366.

Merz M, Wüthrich M (2008). Prediction error of the multivariate chain ladder reserving method, North American Actuarial Journal, 12, No.2, 175-197.

Zhang Y (2010). A general multivariate chain ladder model.Insurance: Mathematics and Economics, 46, pp. 588-599.

Zhang Y (2010). Prediction error of the general multivariate chain ladder model.

# This shows that the MCL model using "OLS" is equivalent to 
# the MackChainLadder when applied to one triangle 

data(GenIns)
(U1 <- MackChainLadder(GenIns, est.sigma = "Mack"))
(U2 <- MultiChainLadder(list(GenIns), fit.method = "OLS"))

# show plots 
parold <- par(mfrow = c(2, 2))
plot(U2, which.plot = 1:4)
plot(U2, which.plot = 5)
par(parold)


# For mse.method = "Independence", the model is equivalent 
# to that in Buchwalder et al. (2006)

(B1 <- MultiChainLadder(list(GenIns), fit.method = "OLS", 
    mse.method = "Independence"))

# use the unbiased residual covariance estimator 
# in Merz and Wuthrich (2008)
(W1 <- MultiChainLadder2(liab, mse.method = "Independence", 
    		control = systemfit::systemfit.control(methodResidCov = "Theil"))) 

## Not run: 
# use the iterative residual covariance estimator
for (i in 1:5){
  W2 <- MultiChainLadder2(liab, mse.method = "Independence", 
      control = systemfit::systemfit.control(
      methodResidCov = "Theil", maxiter = i))
  print(format(summary(W2)@report.summary[[3]][15, 4:5], 
          digits = 6, big.mark = ","))    
}

# The following fits an MCL model with intercepts for years 1:7
# and separate chain ladder models for the rest periods
f1 <- MultiChainLadder2(auto, type = "MCL+int")

# compare with the model without intercepts through residual plots
f0 <- MultiChainLadder2(auto, type = "MCL")

parold <- par(mfrow = c(2, 3), mar = c(3, 3, 2, 1))
mt <- list(c("Personal Paid", "Personal Incured", "Commercial Paid"))
plot(f0, which.plot = 3, main = mt)
plot(f1, which.plot = 3, main = mt)
par(parold)

## summary statistics
summary(f1, portfolio = "1+3")@report.summary[[4]]


# model for joint development of paid and incurred triangles 
da <- auto[1:2]
# MCL with diagonal development
M0 <- MultiChainLadder(da)
# non-diagonal development matrix with no intercepts
M1 <- MultiChainLadder2(da, type = "GMCL-int")
# Munich Chain Ladder
M2 <- MunichChainLadder(da[[1]], da[[2]])
# compile results and compare projected paid to incurred ratios
r1 <- lapply(list(M0, M1), function(x){
          ult <- summary(x)@Ultimate
          ult[, 1] / ult[, 2]
      })
names(r1) <- c("MCL", "GMCL")
r2 <- summary(M2)[[1]][, 6]
r2 <- c(r2, summary(M2)[[2]][2, 3])
print(do.call(cbind, c(r1, list(MuCl = r2))) * 100, digits = 4)


## End(Not run)

# To reproduce results in Zhang (2010) and see more examples, use:
## Not run: 
 demo(MultiChainLadder)

## End(Not run)