Extracted main text — title through conclusion, appendix excluded. This is what our citation measures are computed over, published so the extraction can be checked by eye.
94,248 characters · 18 sections · 44 citation commands
Micro-level Reserving for General Insurance Claims using a Long Short-Term Memory Network
\affil[1]{\'{E}cole d'actuariat, Universit\'{e} Laval, Qu\'{e}bec, Canada}
\affil[2]{Institut intelligence et donn\'{e}es, Qu\'{e}bec, Canada}
Keywords: Individual claim features, Individual claim reserving, Deep learning, Large claims, Recurrent neural networks.
Predicting outstanding liabilities is essential to ensure an insurance company's solvency. The reserving exercise consists in accurately estimating future loss payments that will be made on incurred claims. Traditional macro-level loss reserving methods rely on simple assumptions and run-off triangles with claim informations summarized by occurrence and development periods. This results in a loss of the individual claim characteristics, which may limit the robustness of these models, particularly in situations where portfolio mix or claim characteristics are evolving over time. For an overview of aggregate reserving models, see, e.g., england2002stochastic or wuthrich2008stochastic. Recently, researchers have proposed various micro-level loss reserving approaches that use detailed individual claims information in order to improve prediction accuracy. Their main advantage consists in yielding the predicted outstanding loss of each claim based on its individual development and characteristics. Several individual models, in continuous or discrete-time, have been proposed in the literature. Pioneer work by arjas1989claims, norberg1993prediction, norberg1999prediction, and haastrup1996claims set the stage for micro-level reserving. See, e.g., charpentier2016macro for an econometric comparison between some aggregate and individual reserving models.
In recent years, individual models have attracted interest, and many contributions achieved promising results. taylor2008individual used a discrete-time framework to model individual claim developments, based on claim payments and incurred losses. zhao2009semiparametric investigated the occurrence time and the reporting delay for individual claims using semi-parametric models with covariates, then zhao2010applying extended this study by incorporating a dependence structure. pigeon2013individual, pigeon2014individual proposed a parametric individual reserving model using the multivariate skew-normal distribution for claim payments, in discrete time. In a continuous-time framework, antonio2014micro present a semi-parametric individual reserving model including detailed information on the payment rate. All these granular models are parametric or semi-parametric, based on fixed structural forms and can potentially be over-parametrized.
Machine learning techniques are highly flexible for handling structured and unstructured data. It is thus no surprise that they are gaining in popularity as building blocks of individual loss reserving models. Many recent contributions showed how machine learning can improve an individual reserving model's prediction accuracy. wuthrich2018machine used regression trees to predict the number of payments. Tree-based techniques like ExtraTrees and XGBoost have been applied to predict outstanding individual losses, see, e.g., baudry2019machine and duval2019individual.
With the growth of individual claims data collection, storage and improved computing power, it becomes interesting to consider sophisticated forms of machine learning, such as deep neural networks (NNs). The latter require few restrictions and assumptions, incorporate complex non-linear trends, and have high predictive performance. NNs with various architectures have recently been applied to individual claims loss prediction. wuthrich2018machine and taylor2019loss surveyed recent developments in individual reserving models involving NNs. gabrielli2020neuralembd proposed to initialize the NN with a regression model, such as an over-dispersed Poisson, to better align with traditional actuarial practice. gabrielli2020individual structured a single NN carrying out simultaneous regression and classification tasks to predict expected payments. Summaries of the claim history are the inputs of his network, whereas delong2020neural used entire claim histories in their NN to predict the joint development of claim occurence and individual payments. Building on this work, delong2021collective construct several NNs to estimate reserves for both reported and incurred but not reported claims with smaller architectures, thus reducing the computation time.
Another way to consider past claim histories is through recurrent neural networks (RNN), a popular class of NNs introduced by hopfield1982neural. RNNs are constructed by stacking multiple copies of the same network, allowing information to be passed from one step to the successive network. Figure (ref) shows a typical representation of a RNN, with dynamic input $\boldsymbol{X}_t$ and output $\boldsymbol{h}_t$ at period $t$, for $t=1,\ldots,n$. By construction, RNNs consider relevant features to extract temporal dependencies. However, in basic RNNs, it is challenging to capture long-term dependencies, that are useful to understand claim development, because of the multiplicative gradient that can grow exponentially. To avoid exploding gradient, hochreiter1997long introduced Long Short-Term Memory (LSTM) networks, a class of RNNs. The LSTM module has a complex architecture with multiple layers interacting in a special way, and characterized by repeatedly updating memory cells. For several sequential information processing tasks, LSTM networks showed competitive results over simpler RNNs. For more details on LSTMs, see, e.g., sundermeyer2012lstm, graves2013generating and weninger2015speech. In the individual reserving litterature, kuo2020individual proposed a multi-period bayesian mixture density network based on LSTMs. Unfortunately, this model does not improve the accuracy of predictions compared to the classic chain-ladder.
In this paper, we develop a new individual loss reserving model applicable for any individual claims dataset with long-tailed development. We focus on the Reported, But Not yet Settled (RBNS) claims by modeling the development of their future payments. Our model involves an LSTM network which performs two tasks in order to predict expected future payments: a classification to determine the probability of payment or recovery in a given period, and a regression to predict the incremental payment or recovery, given that it is non-zero in a period. A loss-balancing technique allows the simultaneous learning of these two network tasks; the LSTM loss could be adapted to learn more than two tasks and predict several stochastic variables, if required. We implement the model and explore its performance on both a simulated and a real complex dataset. We compare the prediction accuracy with that of a chain-ladder model, similarly as what is done in recent contributions on individual reserving see, e.g., delong2020neural and delong2021collective. Also, to improve the prediction of large incremental payments, we design a reserving approach that combines the LSTM output and a generalized Pareto distribution. We study its performance on the real dataset.
Compared to gabrielli2020individual, our network is recurrent and uses exact individual claim histories instead of summarized past information. Our model has the advantage of making predictions for the entire future development rather than only yielding an ultimate value. In the case studies presented in Sections (ref) and (ref), our network outperforms the results obtained with the aggregate chain-ladder, which is an improvement over the model developed in kuo2020individual.
The remainder of the paper is organized as follows. In Section (ref), we introduce the notation, the architecture and the training process of our individual loss reserving model. Sections (ref) and (ref) present the experiments conducted on a simulated and a real detailed claim dataset, respectively. For these case studies, we explain the model construction, choose the loss function, analyze results and compare them with those of chain-ladder. Also, we describe our reserving approach for large claims in Section (ref) and we illustrate it on real data. We conclude in Section (ref) and provide additional details on the simulated data, real data pre-processing and extreme value model in three Appendices.
In Section (ref), we introduce the notation for a generic detailed insurance claims dataset. We then present the architecture and training of our LSTM network in Sections (ref) and (ref), respectively.
We consider a dataset of $m$ reported general insurance claims. Each claim has a lifetime development; a typical example is depicted in Figure (ref). A claim occurring within the policy period is usually declared to the insurer with a reporting delay. There may also be an opening lag, which is the delay between the reporting and opening dates. At opening time, specific features about the claim are known, such as the date of occurrence, reporting delay, age of the claimant (body injury insurance), or type of dwelling (home insurance). We denote by $\boldsymbol{S}_{k}$ the set including this static information for claim $k$, for $k=1, \ldots,m$. Over a claim lifetime, several loss payments and recoveries may be made at different time intervals before closure. A claim can be reopened and then closed again. Throughout this settlement process, we observe additional claim characteristics.
We consider discrete-time claim developments, as the exact daily modeling is too granular and involves weekly variations that are immaterial for reserving. The development periods are of equal length and may be, e.g., months, quarters, or years. We also assume that all claims are fully settled at the end of an ultimate period $n$. For claim $k$, we denote by $\boldsymbol{D}_{k,j}$ the set of dynamic information known at period $j$, for $j=1, \ldots,n$. This may include the incremental payment or recovery $Y_{k,j}$, the claim status (whether the claim is open or not), and the number of claimants related to claim $k$.
The reserving problem amounts to estimating the outstanding payments for incurred claims at a given evaluation date $T^{*}$. The claims have a different number of known development periods at $T^{*}$ depending on their occurrence date. Assume that for claim $k$, we have observed $t_k \leq n$ development periods at $T^*$, as illustrated in Figure (ref). The entire dataset can be represented as
Among the set of dynamic variables, we propose to focus on the prediction of the occurrence and amounts of incremental payments. From now on, a non-zero payment can be positive or negative, as it represents the sum of all cash flows that occured in a development period, including payments, recoveries and subrogations. However, a claim may have a large number of development periods without payment or even an ultimate payment equal to $\$0$. Thus, we define the payment indicator $I_{k,j}=\mathbbm{1}_{\{Y_{k,j} \neq 0\}}$, where $\mathbbm{1}_{\{Y_{k,j} \neq 0\}}=1$ if $Y_{k,j} \neq 0$, and $0$ otherwise. The indicator $I_{k,j}$ will be used in our model to assess the probability of having a non-zero payment. The individual reserve $R_{k}$ is the sum of the incremental payments forecasted for the periods $\{t_{k}+1, \ldots, n\}$, and is expressed as
which also corresponds to the ultimate loss payment minus the cumulative paid amount at period $t_k$.
In Section (ref), we present our individual reserve approach to estimate $R_k$, for $k=1, \ldots, m$, but we first need to split the full dataset into training, validation, and testing datasets. We use the training dataset, denoted by $\mathcal{T}$, to find the model parameters (weights) that will be confirmed using the validation dataset $\mathcal{V}$. We want to stress that our entire methodology is applicable for a training and validation set containing solely information that is known prior to the evaluation date $T^*$. Therefore, an insurer could use it as is for setting the reserves at the current evaluation date. After the training process, we use the testing dataset that includes information beyond $T^*$, to verify the model accuracy. This was possible here as the evaluation date was set in the past.
For claim $k \in\{1, \ldots, m\}$, let $\hat{p}_{k,j}$ be the predicted probability of non-zero payment or recovery in period $j\in\{1, \ldots, n\}$, and $\hat{Y}_{k,j}$ the corresponding predicted amount given that it is non-zero. We define the predicted expected incremental payment for claim $k$ in period $j$ by the product $\hat{p}_{k,j} \times \hat{Y}_{k,j}$. At the evaluation date $T^*$, the insurer must predict future payments illustrated in blue in Figure (ref). We propose an individual reserving approach to estimate $R_k$ with
The reserving problem thus amounts to the prediction of the pairs $\{(\hat{p}_{k,j},\hat{Y}_{k,j}):j=t_k+1, \ldots, n\}$. To achieve this goal, we introduce the LSTM network depicted in Figure (ref), where we drop the claim index $k$ and keep only the time index $j$ for simplicity. Since we study RBNS claims, at least one development period is known for each claim, so the LSTM network contains $n-1$ modules. At step $j$, we provide the network with the input vector $\boldsymbol{X}_{k,j}=\{\boldsymbol{C}_{k,0},\ \boldsymbol{D}_{k,j}\}$ which is the concatenation of $\boldsymbol{D}_{k,j}$, the dynamic information at period $j$, and the static context $\boldsymbol{C}_{k,0}$. In the following, we first explain the construction of $\boldsymbol{C}_{k,0}$ and the payment pre-processing within $\boldsymbol{D}_{k,j}$ to form $\boldsymbol{X}_{k,j}$. Then, we describe how inputs are fed to each module as in Figure (ref) and we explain the resulting outputs.
\tikzset{sigmoid/.style={path picture= {
} } }
\tikzset{ neuron/.style={shape=circle,draw,inner sep= 0pt,minimum size = 1.3 em, node distance = 10ex and 1 em,fill=white}, every loop/.style={min distance=10mm,looseness=5}, dot/.style={shape=circle,minimum size=1mm, inner sep=0pt, fill=black, node distance= 1ex and 2 em }, group/.style={rectangle,draw, inner sep=1pt,rounded corners,minimum height= 3.5em,minimum width=15.5 em, node distance= 1ex and 1em}, conn/.style={draw,-latex'}
}
The static features known at the opening date provide a context for the claim and may inform us on its development. The set $\boldsymbol{S}_k$ may include quantitative and/or categorical variables. Each of these types of variables must be prepared differently. Figure (ref) illustrates the static feature engineering used in this paper. The $q$ quantitative variables are scaled and each of the $p$ categorical variables is indexed using a defined dictionary, then passed to an embedding layer. The latter maps each level of categorical variable $\boldsymbol{S}_{k,i}$ to an $\ell_{i}$-dimensional vector, where $\ell_{i}>1$ is a hyper-parameter that depends on the number of modalities and $i=1,\ldots,p$ (see, e.g., yin2018dimensionality). After transformation, the static variables are concatenated and then passed to a linear layer for dimension reduction. We obtain the $k$th claim's context $C_{k,0}$, a vector of dimension $c$, where $c>1$ is a hyper-parameter. Note that we choose to recall the context at each step of the LSTM in Figure (ref) to strengthen the network, as the latter will keep only the relevant information through its particular internal memory cells.
The set of dynamic features $\boldsymbol{D}_{k,j}$ is composed of the occurrence and amounts of incremental payments, as well as two dynamic variables, namely the development period $j$ and the indicator of whether the period $j$ is observed $r_{k,j}=\mathbbm{1}_{\{j \leq t_k\}}$. Recall that all the LSTM modules have an identical construction with exactly the same weights, so these two deterministic inputs will provide the network with information on the development period being considered. The incremental payments are centered and scaled for the training, validation, and testing datasets as follows
with mean $\mu_{\mathcal{T}}$ and scale $\sigma_{\mathcal{T}}$ computed from all payments (positive and negative) in the training dataset. For our model, we set $\boldsymbol{D}_{k,j}=\{ j,\ r_{k,j}, \ I_{k,j},\ Y_{k,j}^{*}\}$, for $j=1, \ldots, t_k$. Note that one could include the claim status as a dynamic input, but that means it has to be an extra task for the network. To reduce the model complexity, we ignored this information. In our data, a claim may re-open and close again within a developement period only to allow a payment, so the status closed at the end of two successive periods does not imply that there is no payment in between.
Now that we have presented the construction of the inputs $\boldsymbol{X}_{k,j}$, for $j=1, \ldots, t_k$, we recall Figure (ref) to explain the network flow. At period $j$, the vector $\boldsymbol{X}_{k,j}$ passes through the LSTM module whose specific architecture (see, e.g., yu2019review) leads to the hidden state vector $\boldsymbol{h}_{k,j}$. We deduce from it the pair of predictions $(\hat{p}_{k,j+1},\hat{Y}_{k,j+1}^{*})$ for the next period $j+1$ as follows. The vector $\boldsymbol{h}_{k,j}$ is passed, in parallel, to a linear layer yielding the payment $\hat{Y}_{k,j+1}^{*}$, and to another linear layer, then a sigmoid neuron, to obtain the predicted probability $\hat{p}_{k,j+1}$. Mathematically, we have
with $\boldsymbol{h}_{k,j}^{\top}$ the transpose of $\boldsymbol{h}_{k,j}$, $\boldsymbol{\beta}$ and $\boldsymbol{\beta}^{\prime}$ two vectors of learnable weights, and $a$ and $a^\prime$ are constants associated to the two linear layers. Here, it is appropriate to use a linear layer for the regression task as we predict the (scaled) payment or recovery, so we allow for negative payments. The entire network's output is the set $\lbrace(\hat{p}_{k,j}, \hat{Y}_{k,j}^{*}), \ j=2, \ldots, n\rbrace$, from which we can retrieve the predictions for the future periods $\lbrace(\hat{p}_{k,j}, \hat{Y}_{k,j}), j=t_k+1, \ldots, n\rbrace$. Moreover, for time step $j$, the target is the pair $(I_{k,j}, Y_{k,j}^{*})$ only if it is observed before the evaluation date. Otherwise, it is an empty pair. We will explain in Section (ref) how the network's optimization is carried out with missing targets.
An important point is how the network deals with the missing values in the inputs to ensure information propagation. At the first step, the input $\boldsymbol{X}_{k,1}$ is observed and provided to the first LSTM module. From $\boldsymbol{h}_{k,1}$, we obtain the predicted pair $(\hat{p}_{k,2}, \hat{Y}_{k,2}^{*})$ for the second development period. Moving to the second step, if $t_k<2$, then $I_{k,2}$ and $Y_{k,2}^{*}$ are missing values in the input $\boldsymbol{X}_{k,2}$. They are imputed by the predicted expected values, $\hat{p}_{k,2}$ and $\hat{p}_{k,2}\times \hat{Y}_{k,2}^{*}$, respectively. Otherwise, when $t_k\geq 2$, we keep $\boldsymbol{X}_{k,2}$ as actual observed values. We proceed in the same manner for the other periods until time $n-1$. In Figure (ref), orange dotted lines indicate this replacement process for the inputs. Thus, our network, which is of fixed length, may process sequences with different lengths.
In this section, we describe the training process, the network's two tasks, and the balanced loss function. Also, we explain the regularization techniques and metrics used.
The learning process consists in determining the optimal network weights that minimize an appropriate loss function. We update weights with a stochastic gradient descent at each epoch, relying on all mini-batches obtained by randomly splitting the training dataset. The mini-batch size is a hyper-parameter denoted $b$, and an epoch refers to a complete iteration through all mini-batches. At the end of each epoch, we evaluate the loss function on the validation dataset to measure the network generalization capabilities. Furthermore, given that we produce at each time period the prediction of two variables, our network performs two tasks simultaneously.
The first task is a binary classification with target $I_{k,j}$, indicating whether the claim $k$ has a non-zero payment in period $j$, for $k=1, \ldots, m$ and $j=2, \ldots, n$. The indicator takes value in $\{0,1\}$, so we choose the binary cross-entropy as loss function. For each mini-batch, the loss is defined as the weighted sum of cross-entropy losses per development period. For a given period, the loss calculation involves only observations with non-missing target $I_{k,j}$. As we move forward through the development periods, we get fewer observed data, and hence we need to weigh the sum by the number of available observations. The cross-entropy loss for a mini-batch can be expressed as
with $\boldsymbol{\hat{p}}=\{\hat{p}_{k,j}:k=1, \ldots, b, j=2, \ldots, n\}$ and to only use observations with known target, we set $$\delta_{k,j} = \left\{
\right. $$
The second task is a regression for the non-zero incremental payments $Y_{k,j}$. The regression loss is defined by a function $f$ that can either be the squared error $f(Y^{*},\hat{Y}^{*})=f_{SE}(Y^{*},\hat{Y}^{*})=(Y^{*}-\hat{Y}^{*})^2$ or the absolute error $f(Y^{*},\hat{Y}^{*})=f_{AE}(Y^{*},\hat{Y}^{*})=|Y^{*}-\hat{Y}^{*}|$. The choice of function $f$ depends on the dataset and the dispersion of payment distribution. If the payments were only positive, we could consider, e.g., the gamma deviance, but here we allow for recoveries. For a given mini-batch, we evaluate the regression loss $RL$ as a weighted sum of development period loss functions $f$, with
where $\boldsymbol{\hat{Y}^{*}}=\{\hat{Y}_{k,j}^{*}:k=1, \ldots, b, j=2, \ldots, n\}$ and to only use non-zero observed targets, we set $$\tilde{\delta}_{k,j} = \left\{
\right. $$ We recall that $Y_{k,j}^{*} =-\mu_{\mathcal{T}}/\sigma_{\mathcal{T}}$ correponds to the case of a zero payment, when $I_{k,j} =0$.
Our LSTM can learn well both tasks since they share informative features, which may induce more robust regularization and boost performance. However, for training, we must define a single loss function in terms of losses ((ref)) and ((ref)). Multi-task network loss functions are often taken to be linear in the individual task losses. For example, the loss in gabrielli2020individual is a weighted sum of the individual losses such that they lie on the same scale. Nevertheless, when learning regression and classification simultaneously, we should ensure that both tasks are given equal consideration to prevent the easier one from dominating. To this end, several robust automatic loss balancing techniques were proposed; for an overview of multi-task learning approaches, see, e.g., ruder2017overview.
For training our network, we use the task-dependent uncertainty weighting technique proposed in kendall2018multi. This approach allows the optimal weighting of losses with different units or scales and can be applied to combine classification and regression tasks. The multi-task optimization objective is defined as a Gaussian likelihood with task-dependent uncertainty. kendall2018multi illustrated the performance of their loss balancing technique through a multi-task network learning visual scene, which outperformed a separate training of the same tasks.
In several training experiments, our multi-task LSTM network outperforms separate learning of the classification and regression tasks. We observed a difference in optimization challenge and measurement scale between the losses (ref) and (ref). In addition to using the task-dependent uncertainty, we introduce a scale hyper-parameter $\alpha$ applied to the classification loss to reduce the difference with the regression loss and improve tasks learning. Hence, the Gaussian likelihood function is
with $\sigma_1^2$ and $\sigma_2^2$ corresponding to the regression and classification uncertainties, respectively. Note that we could set $\alpha=1$ if the tasks loss functions lie on similar scales. The optimization problem can be expressed, in terms of the LSTM network weights vector $\boldsymbol{W}$, as
We now explain several strategies used to improve the network training. Moving forward in periods as illustrated in Figure (ref), we apply a procedure inspired by the teacher forcing technique to accelerate the training process (see, e.g., williams1989learning,drossos2019language). According to a probability function that is exponentially increasing over epochs, at each time period we randomly choose whether to replace the observed pair $(I_{k,j},\ Y_{k,j}^{*})$ within the input $\boldsymbol{X}_{k,j}$ with the predictions from the previous period $(\hat{p}_{k,j},\ \hat{p}_{k,j}\times\hat{Y}_{k,j}^{*})$. This improves the ability of the network to predict correctly late periods even when there are imprecise inputs in early periods. Through several training experiments, we find that replacing the observed values with the expected ones outperforms the replacement with simulated values. Orange dotted lines in Figure (ref) represent the replacement procedure, which is similar to the missing values imputation. We use stochastic gradient descent with an initial learning rate $l_r$, that we drop by a factor when there is no improvement in the validation loss for $r_p$ epochs. The training process is stopped early when the validation loss does not improve for $t_{es}$ epochs, and then we obtain the optimal weights.
Our network loss function ((ref)) does not have a simple interpretation. We are thus interested in some metrics to evaluate the model's performance. For classification, we use the ROC (Receiver Operating Characteristic) curve with observations grouped by development period and the associated AUROC (Area Under the ROC). The higher the AUROC, the better the model distinguishes between having a payment or not. Other metrics are presented in Sections (ref) and (ref).
In this section, we evaluate our individual loss reserving model performance on fully developed micro-level simulated data. This allows us to compare the predictive outstanding loss estimates with their actual values. One advantage of using simulated data is research reproducibility; the complete code for this case study is available from the authors upon request. Moreover, we conduct a comparative analysis between our model and the aggregate chain-ladder approach.
Using NNs, gabrielli2018individual developed a stochastic generator of non-life insurance individual claim histories, based on a real property and casualty insurance dataset. The exact setup used for the generator is provided in Appendix (ref).
The simulated dataset contains $998,807$ claims with occurrence dates between years 1994 and 2005. For claim $k$, several static characteristics are contained in vector $\boldsymbol{S}_k$, for instance, claim number, accident year, claimant age, line of business, and injured body part. Through the yearly claim development, we know the incremental payments and indicators denoting whether the claim is open or closed. These two dynamic informations are reported at the end of each development year $j=1,\ldots, 12$, and claims are assumed to be fully developed after $n=12$ years.
For our reserving model, we focus on the predictions of the occurrence and amounts of incremental payments (or recoveries). Hence, we drop claim status and keep the payment information within the dynamic vectors, with $\boldsymbol{D}_{k,j}=\{ j,\ r_{k,j},\ I_{k,j},\ Y_{k,j}^{*}\}$, for $j=1, \ldots, t_k$, and $k=1,\ldots,m$. However, we recall that it is possible to add a learning task to our NN to predict claim status. Table (ref) lists the static and dynamic variables used in our reserving model and their pre-processing. Note that the simulated claims have some realistic features such as negative payments representing recoveries (0.3%), late reporting, reopenings (0.3%), and settlement at zero (28%). However, the data contain only few covariates to properly describe the characteristics of claims, which may harm the performance of micro-level reserving techniques.
We set $T^*=2005$ as the evaluation year. To train our reserving model, we keep only claims reported before $T^*$ and hide payments made beyond $T^{*}$. Hence, we retain $m=991,904$ claims leading to a deletion of only 0.7% of them. This small percentage is due to the fact that 92% of claims are reported during their first development year. Also, claims close on average after 1.5 year. Therefore, we expect to forecast few future non-zero outstanding payments. We stratify the claims into training (60%), validation (20%), and testing (20%) datasets. The hidden payments associated to each of the three datasets made after $T^*$ are used later to assess the network's performance.
We carried out the same preliminary analysis on both training and validation datasets to assess the split homogeneity. Among the available static information in $\{\boldsymbol{S}_{k}:k=1, \ldots, m\}$, we analyze the categorical covariates to index their categories and set the hyper-parameters of the embedding layers $\ell_1$, $\ell_2$ and $\ell_3$. Figure (ref)(\subref{cc}) depicts the frequency of claim code. We identify 51 categories with labels in $\{1, \ldots, 53\}$. For the injured body part, we observe 46 categories in the barplot illustrated in Figure (ref)(\subref{inj_part}), with labels within $\{10, \ldots, 99\}$. Both figures show almost the same probability distribution for each variable for training and validation datasets, which confirm the similarity of the two datasets structures. The third categorical variable is the line of business with four categories and empirical frequency almost identical to the probability distribution given in Table (ref).
Due to the ultimate development period being $12$ years, we set $n=12$ in our LSTM network depicted in Figure (ref) and outputting the set of pairs $\{(\hat{p}_{k,j}, \hat{Y}^{*}_{k,j}), j=2, \ldots, 12\}$. Since we do not observe large claims or high variance for incremental payments and we model recoveries, we choose the squared error function $f=f_{SE}$ in regression loss ((ref)) and LSTM network loss function ((ref)). After the pre-processing of variables described in Table (ref), we train our net using the training dataset. We perform several experiments to set the hyper-parameters on the validation dataset. The optimal model performance is obtained with the hyper-parameter combination given in Table (ref).
To determine the scale hyper-parameter $\alpha$ in loss function ((ref)), we train our network with $\alpha \in \{0.1, 0.2, \dots, 2.5\}$. The choice of this grid is based on our training experiments. To set the best value, we need to compare the predictions with the actual payments while using only the information known at evaluation time $T^*=2005$. We explain in the following how to do so. We set the end of the year 2003 as our reference date, denoted $T^{**}$ and, for claim $k$, we define $t_{k}^{**}=t_k-(T^{*}-T^{**})$ as the number of development periods observed at $T^{**}$, as illustrated in Figure (ref). In the new validation dataset $\mathcal{V}$, we select the claims for which at least one development year is observed at $T^{**}$, i.e., $t_k^{**}>0$, leading to a loss of 18% of the observations.
Our choice of hyper-parameter $\alpha$ is based on two performance metrics. First, the ratio of the aggregate predicted over the aggregate observed between $T^{**}$ and $T^{*}$ is
The second is the ratio of the aggregate ultimate assuming the ultimate time is $T^*$, given by
In the training experiments, we observe that both ratios have a non-monotonic relationship with $\alpha$. LSTMs trained with $\alpha \in\{0.2, 0.6, 0.8\}$ outperform the other networks on the validation subset. The ratios given in Table (ref) are closest to one in the case $\alpha=0.2$, which is what we select.
To assess our LSTM network efficiency, we use the validation and testing datasets. The latter has not contributed to the training process in any way, and the network will see it for the first time. In the following, we analyze the prediction accuracy at both the aggregate and individual levels. Also, we compare the results of the LSTM with those of the aggregate chain-ladder model.
Using the payments that were previously hidden and $\mathcal{D}$ being either the validation or testing dataset, we evaluate the ratios of the aggregate reserve and ultimate given, respectively, by
Note that actual reserve refers to the actual outstanding payments between $T^{*}$ and $n$, while actual ultimate corresponds to the observed total paid over $n$ periods. Table (ref) presents the ratios evaluated with the predictions of the LSTM and chain-ladder. For the validation dataset, we obtain very similar results with both models. For the testing dataset, the chain-ladder underestimates the reserve by 2% while our model overstates it by 3.9%. Both models perform well on the ultimate with ratios very close to one. However, the LSTM has the advantage of producing individual predictions. Moreover, the characteristics of the simulated data are very close to the chain-ladder hypotheses, which explains these results. Section (ref) presents a case study with real data where we observe a more important difference between the performance of these models.
At the individual level, we proceed to investigate the performance on the classification and regression tasks. Figure (ref) depicts the boxplot of the predicted probability of payment in terms of the observed indicator, for periods $j\in \{2, 3, 5, 9\}$ from left to right, for validation and testing datasets. As the claim development progresses, we better predict $\Pr(I_{k,j}=0)$ compared to $\Pr(I_{k,j}=1)$. This is due to the short average lifetime of claims, 1.5 year, which implies a large proportion of zero values for the indicator $\{I_{k,j}, j=3, \ldots, n\}$. Figure (ref) illustrates the ROC curves for periods $j\in \{2, 3, 5, 9\}$. The closer the curve is to point $(0, 1)$, the better the model distinguishes between categories. We once again observe an improvement of LSTM probability predictions over periods.
We illustrate in Figure (ref) the scatterplots of incremental predicted payments, only for non-zero observed payments as that is how we train the regression task. We observe that the majority of points are close to the diagonal, which reflects the precision of predictions. In period $j=2$, some predictions are close to zero whatever the value of the observed; this is expected as, in that case, the LSTM knows only one development period. The predictions improve as development progresses. From the LSTM output $\{(\hat{p}_{k,j}, \hat{Y}_{k,j}^{*}),j=2,\ldots,n\}$, we compute the expected individual reserve $\hat{R}_{k}=\sum_{j=t_k+1}^{n} \hat{p}_{k,j}\times\hat{Y}_{k,j}$. Figure (ref) presents the scatterplots of $\hat{R}_{k}$ in terms of the observed reserves $R_k$ per line of business. In general, the predictions of our network are satisfying. We note a few cases of over or under-estimation and a difference in claim sizes by line of business.
In this section, we illustrate our procedure on a real individual claims dataset provided by a large Canadian insurance company. First, we provide a brief description of the data. Then, we explain how we adapt our reserving model to the data and we describe the training process. As some extreme payments are hard to capture with NNs, we propose a large claim forecasting procedure. Our reserve estimates are compared with those obtained with the aggregate chain-ladder method.
We consider a real general insurance individual claims dataset from a Canadian insurance company. The detailed dataset relates to auto insurance policies and contains bodily injury claims that occurred from January $1^{\text{st}}$, 2006 to August $31^{\text{st}}$, 2010. There are $m=53,677$ claimants associated to $41,916$ distinct claims. Note that we implicitly consider the dependence between claimants of the same claim through common covariates such as vehicle characteristics, and number of claimants.
From the reporting date, each claim's development is described through a monthly evolution of its individual information, divided into two categories. First, the static characteristics of claimant file $k$ are contained in a vector $\boldsymbol{S}_k$, for $k=1,\ldots,m$. This may include information on the claim (date, location, driver experience), the claimant (age, gender), and the vehicle (age, number of cylinders). The second category groups dynamic information, for instance, the number of claimants, the nature and number of injuries and the payment. Tables (ref) and (ref) list the static and dynamic features used in our model.
First, we pre-process the real dataset. We correct wrong entries, e.g., an accident date greater than the reporting date. To deal with missing values, we apply a multiple imputation by chained equations (MICE), using the $\textsf{R}$ package mice (van2015package). For categorical variables with many modalities (e.g., postal code), this procedure is computationally intensive. We hence apply the MICE approach to only ten of the 17 available variables with missing values, and we drop the other ones. See Table (ref) for a description of the variable pre-processing.
We set the evaluation date $T^*$ as August $31^{\text{st}}$, 2010. By analyzing the development of claimant files closed as of $T^*$, we observe that their lifetime is on average three months and they have a 0.3% probability of reopening. The probability of a claimant file lasting longer than 45 months is very low. Therefore, we are interested in studying only the first 45 months of claimant file development, i.e., we set $n = 45$ for our LSTM. This development censorship allows to have enough observations for the network to train on the last period predictions. Also, we hide all information observed beyond $T^*$, then stratify the dataset into training (60%), validation (20%), and testing (20%) datasets. The same exploratory analyses are carried out on the training and validation datasets, and the dataset split seems homogeneous, as seen in Figure (ref).
The real dataset has several features in common with the simulated dataset discussed in Section (ref). In both, we observe reopenings, and around 30% of claimants files settled without any payment even though they may remain open for several periods. However, compared to the simulated dataset, the real data has the advantage of having a monthly (rather than yearly) detailed development with a greater number of dynamic features (other than incremental payments). If we wanted to include the future development of these features in the network, it would imply an additionnal task. To avoid adding complexity, we consider the evolution of dynamic claimant file characteristics other than the payments until $T^*$ and then keep the last observed value for the remaining development months. Thus, we take advantage of this information to improve the network predictions for the first development months.
The number of observed targets used to learn the classification and regression tasks differs and may impact the complexity of the optimization of functions ((ref)) and ((ref)). For the training and validation datasets, Figure (ref) illustrates two frequency distributions. The first one, in light color, is related to observed zero incremental payments per development month. The second distribution, in dark, relates only to non-zero incremental payments among all observed payments employed to compute the regression loss ((ref)). The concatenation of the two colors corresponds to the distribution of observed indicators $ I_ {k, j} $, for $ j = 1, \ldots, t_k $, used to compute the classification loss ((ref)). There are fewer observations within both datasets to train the regression task than the classification. This is expected given the large percentage of claimant files settled without any payment.
To investigate in details the incremental payments, we depict in Figure (ref) error bars representing the standard deviation around the mean for the non-zero payments, per development month. We observe huge variances for some periods indicating the presence of extremely large payments. Recall that we did not observe extreme claims in the simulated dataset from Section (ref). We propose in Section (ref) an approach to handle large payments.
Large or catastrophic claims are extreme events leading to very high payments and can be modeled using Extreme Value Theory (EVT). Given a high threshold $u>0$, EVT allows to model the conditional distribution of the excess loss over $u$ with a generalized Pareto distribution (GPD) as limiting distribution. For a general introduction to EVT, see, e.g., coles2001introduction.
Using only the training dataset, we consider $\boldsymbol{Y}=\{Y_{k,j}:Y_{k,j}\neq 0 , j=1, \ldots, t_k, \ k=1, \ldots, m\}$ the vector of non-zero incremental payments known at the evaluation date. We aim to model the tail behavior of $\boldsymbol{Y}$ using EVT. We set a sufficiently high threshold $u$, and estimate the parameters of the GPD associated to the random excess $(Y_{k,j}-u|Y_{k,j}>u)$. Then, we verify that the empirical behavior of $\boldsymbol{Y}$ can be described by the selected GPD.
To choose a threshold $u$, we use the mean excess plot, and $u$ is selected as the lowest threshold for which the curve becomes approximately linear. Based on the detailed analysis provided in Appendix (ref), we set $u = 32,000$. With the selected threshold, we estimate the GPD parameters by maximum likelihood through a numerical optimization with the $\textsf{R}$ package ismev (ismev). We obtain shape $\hat{\sigma}=0.957851$ and scale $\hat{\lambda}=14,044$. Therefore, $\hat{E}[Y_{k,j}-u|Y_{k,j}>u]=\hat{\lambda}/(1-\hat{\sigma})=333,199$, i.e., given that a payment exceeds the threshold $u=32,000$, it will cost on average \$365,199. The goodness-of-fit of the estimated GPD is verified in Appendix (ref).
Now that we have the expected excess amount, we move to accurately estimating the probability that a payment exceeds $u$. Note that we have only 0.5% of available non-zero payments $\boldsymbol{Y}$ above the threshold $u=32,000$. In addition to the development period as a predictive variable, an analysis of the payment history, inspired by cote2021bayesian, revealed that it is less likely to observe large payments after multiple consecutive periods without payment. We use a generalized linear model (GLM) for the probability of large payment knowing the development period and the number of previous months without payment. Given the few observations (sometimes less than five) exceeding $u$ for some development periods, we group months in quarter periods and also merge development months 39 to 45. We keep the first month apart given its particular behavior. Figure (ref) depicts the predicted relative probabilities of large payment obtained with our GLM, per development month. The number of previous periods without payment is represented using the color scale; as it increases (colder color), the probability of extreme payment decreases. Fitted probabilities of extreme payments also increase with development month.
The large claims analysis developed in this section confirms our interpretation of Figure (ref). In addition, in the first training experiments on the real data, we found important discrepancies between the predicted and observed payments, most likely resulting from the considerable variance. Therefore, we propose to censor payments in order to reduce variance and improve learning. In that case, the LSTM prediction are interpreted as the conditional expected payment given that it does not exceed the threshold $u$, and expressed, for claimant file $k$ and period $j=t_k+1,\ldots,n$, by
We now aim to investigate an adjustment to the network's prediction to take into account the possibility that the payment is large. For claimant file $k$ and period $j$, we have
with $\hat{\Pr}\left(Y_{k,j}>u\right)$ the probability of exceedance $u$ obtained with our GLM in function of the development period and the number of previous months without payment. The latter covariate is approximated based on the LSTM predictions as explained in Section (ref).
If we consider ((ref)) instead of ((ref)) for all forecasted payments, we may overstate the reserve as we illustrate in Section (ref). Through an in-depth analysis of the results obtained for the training and validation datasets, we propose applying the adjustment given by ((ref)) for selected observations with greater probability of being large if the network was fed with uncensored payments. To do so, for the training dataset, we analyze the distribution of predictions $\hat{Y}_{k,j}$ of large censored payments $Y_{k,j}$, to choose a threshold $\zeta$ and we formulate the incremental payment prediction as follows
delong2020neural also use a GPD for large claims with periodic parameter estimation. However, since their neural net is not recurrent, at each period, they randomly select a proportion of observations with a high propensity to generate large claims according to some key features and estimate the prediction outside the network. The choice of the percentage and key features is very sensitive and requires a good knowledge about the claims nature. In our recurrent network, the prediction process is linked from period to period and considers the claimant file past development. According to our observations, it is more efficient to set a threshold $\zeta$ instead of a percentage to adjust large claim predictions. Unlike delong2020neural, we use a GLM to evaluate the probability of large claims based on some dynamic covariates.
Using censored payments $\min\left(Y_{k,j}, \ u\right)$, we train our LSTM network to learn optimal weights and predict the individual reserve accurately. Due to the difference in the number of observations used to compute functions ((ref)) and ((ref)), we note a greater difficulty to learn the regression task than the classification one during our training experiments. Indeed, throughout the first epochs, we may observe a large difference between a prediction $\hat{Y}_{k,j}$ and its target $Y_{k,j}$. To reduce the regression loss scale values and make them closer to cross-entropy values, we choose the absolute error function $f_{AE}$ instead of the squared error $f_{SE}$ in losses ((ref)) and ((ref)).
After several LSTM training experiments, we set the hyper-parameter combination, given in Table (ref), that optimizes the model performance. Compared to the LSTM network fitted to the simulated dataset in Section (ref), the real data has inputs $\boldsymbol{X}_{k,j}$, $j=1, \ldots, n-1$, of higher dimension due to a greater number of dynamic features. Thus, we increased the size of the hidden state $\boldsymbol{h}_{k,j} $, for $j=1, \ldots, n-1$, to avoid losing information and enhance network performance. Note that a higher dimension requires more memory during the training process. Moreover, according to the dataset characteristics presented in Section (ref), when the mini-batch size is too small, the network will see a non-zero payment with low probability, particularly for the last development months. Hence, we choose a batch size of 1024 to have enough targets to learn the regression task and enough mini-batches per epoch to train our model.
To set the hyper-parameter $\alpha$ without using the information after the evaluation date $T^*$, i.e., August $31^{\text{st}}$, 2010, we follow the same approach used in Section (ref) on the simulated dataset. We set May $31^{\text{st}}$, 2010, as a reference date, denoted $T^{**}$. We select the claimant files from the validation dataset with at least three months of development observed at $T^{**}$ such that $t_k^{**}>0$, leading to a loss of 20% of the observations. We evaluate the metric ratios $RR(T^{**},T^*)$ and $RU(T^{**},T^*)$ on this validation subset. Again, our results show no monotonic relationship between these ratios and $\alpha$. LSTMs trained with either $\alpha$ equal to 0.5 or 1.5 lead to ratios very close to one and outperform the other trained networks. Both choices produce a very similar performance at the aggregate level. At the individual level, on the validation subset, we note an overestimation of the small actual outstanding payments for the model with $\alpha=1.5$. Thus, we choose $\alpha=0.5$.
In this section, we assess the efficiency of our LSTM network trained with censored payments based on the validation and testing datasets. First, we evaluate the accuracy of predictions at the aggregate level and then we compare it to the aggregate chain-ladder model. Second, at the individual level, we investigate the performance of the regression and classification tasks. Note that all computations in this section are made only with payments censored at $u=32,000$.
Tables (ref) presents the ratios of the aggregate reserve and ultimate obtained with both LSTM and chain-ladder. The expressions based on censored payments are given, respectively, by
Note that the chain-ladder development factors are estimated using the censored training dataset. For validation and testing datasets, our network outperforms the chain-ladder with ratios very close to one. The chain-ladder overstates the reserve by more than 10%. Thus, our model can better capture claim trends, which leads to a more accurate forecast using individual information.
Figure (ref) presents boxplots of the predicted probability of payment, equivalently the probability that the indicator $I_{k,j}$ takes value 1 or 0 for periods $j\in \{2, 5,10,20,30,40\}$. For validation and testing datasets, we observe that we better predict $\Pr(I_{k,2}=0)$ compared to $\Pr(I_{k,2}=1)$. As the claimant file process progresses and the network learns the development, we note an improvement in the prediction of probabilities. However, there are very few payments to be made in last development months leading to an unbalanced dataset with a large presence of zero values for indicators. This can bias the interpretation of the boxplots for last periods.
The ROC curves for the classification are shown in Figure (ref) for periods $j\in\{2,5,10,20,30,40\}$, for both validation and testing datasets. As for Figure (ref), we observe that the more the network knows the claimant file's history, the better is the prediction performance. Besides, to better evaluate the classification task without the impact of unbalanced observations, we use the AUROC per development period illustrated as a curve in Figure (ref). We note an improvement during the first ten development periods, followed by a decrease in prediction accuracy. It is most probably due to the number of observations available for training. We can improve the network's performance by providing more observations, as in the simulated dataset studied in Section (ref).
Now, we move on to analyze the predicted payments. We illustrate in Figure (ref) the scatterplots of incremental predicted payments for non-zero observed payments in the testing dataset. Moving forward in the development, we note an improvement in the prediction accuracy with points closer to the diagonal. On the other hand, beyond month 20, there is an underestimation of large observed payments, but, as discussed in Section (ref), few observations are available to train the regression task for the latest developments.
By multiplying the predictions of the regression and classification tasks, we obtain the expected payments $\hat{p}_{k,j}\times \hat{Y}_{k,j}$. They are presented for some periods in terms of the observed in Figure (ref). We note an overestimation of zero payments for period $j=2$. After month 20, we have an underestimation of the large observed payments and an overestimation of zero payments. By summing the expected incremental payments $\hat{p}_{k,j}\times\hat{Y}_{k,j}$ over future periods, we deduce the censored reserve $\hat{R}_{k}^{c}=\sum_{j=t_k+1}^{n} \hat{p}_{k,j}\times\hat{Y}_{k,j}$ for claimant file $k$. Figure (ref) illustrates the scatterplots of $\hat{R}_{k}^{c}$ versus the observed censored reserves given by $R^{c}_k=\sum_{j=t_k+1}^{n}I_{k,j}\times \min \left(Y_{k,j},\ u\right)$. Most of the points are close to the diagonal with a few over or under-estimation for large claims.
In the following, we adjust the LSTM outputs, presented in Section (ref), using the procedure described in Section (ref) which considers large claims. For the training dataset, Table (ref) presents the mean, the standard deviation and some quantiles of the LSTM predictions associated to large observed payments censored at \$32,000. The values in Table (ref) are much smaller than the target $u=32,000$. Indeed, the model prediction is like an expectation of observed incremental payments. Since there are few censored observations, the network tends to understate them. If we had not censored the payments, the discrepancies would have been even greater.
From Table (ref), we can see the order of magnitude of the threshold $\zeta$. We propose to apply Eq. (ref) according to different thresholds $\zeta$, and to compare the adjusted predictions with the uncensored observed payments. Note that in the GLM prediction of the probability of exceedance for future periods, the number of previous periods without payments is approximated as follows when it is unobserved. If $\hat{p}_{k,j}\times \hat{Y}_{k,j}$ is close to the mean of LSTM predicted amounts associated with the actual observed zero in the training dataset, then the period $j$ is considered without payment. For the training, validation and testing datasets, Tables (ref) and (ref) present the ratio of the aggregate reserve and ultimate, respectively, for several $\zeta$ values. Both are computed from the adjusted predictions and the uncensored observed payments as follows:
When $ \zeta = 0 $, Eq. (ref) amounts to adjusting the network outputs to consider large payments occurence for all positive predictions $\hat{Y}_{k,j} $. Unfortunately, this approach grossly overestimates payments, especially for small ones. For $\zeta = \infty $, no adjustment is applied and the network predictions are compared to the actual uncensored payments. Obviously, the ratios are very small since our predictions underestimate large payments that the network has never seen during its training. In addition, we set three values of $\zeta $ that are reasonable based on Table (ref). For $\zeta=2000$, the ratios are closer to one compared to $\zeta = 0$, but we still overestimate. Applying Eq. (ref) with $\zeta=3000$, we underestimate the aggregate reserve by 10% for the three datasets. We obtain the best results for threshold $\zeta=2500$, where the ratios of the aggregate reserve and ultimate are very close to one.
Moreover, we compute the ratios using the chain-ladder method, with development factors evaluated from the uncensored training dataset. According to Table (ref), the chain-ladder overestimates the aggregate reserve by 30%. Our LSTM model with adjustment for large payments using threshold $\zeta=2500$ outperforms the chain-ladder on the aggregate results and has the advantage of yielding individual reserves.
In this paper, we propose an individual reserving model based on an LSTM network and a large claim forecasting procedure. Our model has the advantage of being easily adaptable to the structure of any claim dataset with detailed development and of flexibly incorporating large claims. Our procedure involves only the information available at the current evaluation date. Our network shows accurate predictions and outperforms the chain-ladder model in the two case studies carried out with a simulated and a real dataset.
In forthcoming research work, we are interested in adding other tasks to the network while ensuring a balanced optimization of the loss functions, and in considering model uncertainty. Also, we could further investigate the hyper-parameter selection procedure to enhance network performance, study the uncertainty of predictions and enhance the procedure for handling large claims.
The authors sincerely thank Christopher Blier-Wong, Julien Fagnan, Luc Lamontagne, Fran\c cois Laviolette, \'{E}tienne Marceau and Fr\'{e}d\'{e}rik Paradis for useful discussions. The authors gratefully acknowledge financial support from the Natural Sciences and Engineering Research Council of Canada (CRDPJ 515901-17, Cossette: RGPIN-2017-04273, C\^{o}t\'{e}: RGPIN-2019-04190) and the Big Data Research Center at Universit\'{e} Laval. We also thank an anonymous insurance company for providing the data.
The authors declare none.