By Osmo Jauri and Timo Penttilä
Timo Penttilä Osmo Jauri
Contract-level Monte Carlo is the new normal for the insurance industry. In this article we demonstrate how it works in practice.
Traditionally contract-level Monte Carlo simulation has been considered computationally too slow for large portfolios. On the other hand, it would offer great advantages:
- No simplifications: All products work as in reality.
- No replicating portfolios: All is done contract-by-contract.
- No option theory needed: Embedded options are priced inside Monte Carlo.
Monte Carlo simulation offers more complete information since all variables carry full probability distributions. Results are more reliable due to reduced model risk. When we incorporate asset-side valuations and hedging strategies into the model, one model can apply to many tasks: financial planning, actuarial modeling, product development and ALM/risk management. It can offer significant economic benefits, particularly when building an internal model and complying with regulatory requirements.
To achieve these benefits many have been using shortcuts, grouping of contracts and a mixture of deterministic and stochastic valuation techniques. On the other hand, prudent management of model risk has a clear message: The less you assume, the less you have to explain. Grouping of contracts with embedded options will, in practice, replace a portfolio of options with one option and that operation carries substantial model risk. If that can be avoided, there is no need to proof the justification, and we know that cash-flow risk is correctly shown. Equally, it is hard to control the model risk when you combine deterministic and stochastic modeling. In this article we study an approach where no compromises are made and all valuations are based on future cash-flow simulations created at a contract level. But is it too heavy to run?
High-speed simulation is created by combining two different technologies: distributed computing and advanced software design.
Distributed computing provides high computational capacity by dividing tasks among several cores, CPUs and workstations, inside a workstation, on a LAN or cloud service. Cloud services offer high-performance computer cluster power at potentially lower cost, because the user defines the number of CPU-cores he wishes to use and pays by core-hours spent. In other words one pays for the processing power used but not for time when the cluster is idle, as when you set up your own internal cluster. The expense is the same for taking one core for 100 hours or 100 cores for one hour.
Modern tools offer several concepts to ease model building and help to speed up computations. Modeling work can be simplified by using rule-based, object-oriented modeling. When we create our model based on rules and objects, our model becomes easy to use, document and audit, in contrast to algorithm and procedure-based models. Simulations can be executed in vector form instead of “for loops,” and intelligent algorithms can minimize unnecessary work by detecting differences between products.
How Does It Work in Practice?
We present two real-life cases, where we apply contract-level Monte Carlo to real-life insurance portfolios. Both models are built on pure stochastic modeling at a contract/customer level. We run the models both locally on workstations and in a cloud service for comparison. Accordingly, we receive full probability distributions for all variables for all time steps. Desired analysis can be built on those, like valuation of liabilities or effects of external shocks. Also EU Solvency 2 style MCEV/SCR can be based on that.
Case A—Life Insurance
Case A is a life insurance company with 50,000 contracts, including traditional risk policies and savings-based products. The model was set up to run for 60 years with changing time steps, starting with one-month steps and running 12-month steps in the end. All products and cash flows were defined as in real life, accounting for all fees and other cash flows. Customer behavior was specified through stochastic lapses and premiums. Policyholders were simulated to have disability and death risks. Economic scenarios were read from a separate source.
Figure 1. Overview of Case A Life Insurance Product Model
Summary of model structure and execution time are in Table 1 below.
Case B—Motor Vehicle Insurance
Case B is a property and casualty (P&C) company where motor vehicle insurance portfolio was analyzed. Contracts were traffic insurance contracts, covering all damages the policyholder causes to the opposite party plus damages to their own vehicle. The model structure was set according to company preferences, and in this case the model covered seven different types of claims with correlation structure, all seven claim types having stochastic size and three having also stochastic time frame (see Figure 2).
Figure 2. Overview of Case B Motor Vehicle Insurance Model
Simulation model and simulation time are shown in Table 1 below.
Table 1. Summary of Models and Execution Times
Does It Run in a Cloud?
In theory, when we increase the number of cores (n), the price of computation remains the same, while calendar time spent gets shorter (1/n). In practice this is not true: There are increased data transfers between cores and there are parts of software code that cannot be distributed among cores. When we associate a small number of cores, the computations are close to linear with factor one. When we tested a 64-core cloud against a two-core workstation, the computation time came down 93 to 94 percent, while our 1/n formula forecasts a cutoff of 96 percent.
When we associate thousands of cores, the loss in efficiency may grow in importance. We cannot specify optimal core recommendations; performance depends on the products analyzed, data communication within—and the hardware used on—the cloud, not to mention one's personal preference between time and money. However, you can test it fairly easily.
Increasing simulation rounds does not increase computation time proportionately. Our experience shows that by multiplying simulation rounds from 1,000 to 10,000, the computation time will increase by a factor of 2 to 4 depending on product mix, both on cloud service and local workstations.
How Were the Models Built?
In both cases we defined all relevant product and technical specifications in the models. In practice, creating an insurance business model required four definitions:
- Product terms. Products were defined as agreements of exchanging cash flows when given circumstances are met by using object-oriented modeling language.
- Random variables and processes. This includes customer behavior and claim processes and was done partly by using object-oriented modeling and partly by writing rules as MATLAB sentences.
- Company balance sheet formulas and technical specifications. In our examples we used mark-to-market valuations.
- Decision-making rules. These affect the course of a simulation by making path-dependent decisions. In Case A we applied rules for dividends and benefits.
In addition, we imported economic scenarios and contract details policy by policy.
We run these tests by using mSII modeling software developed by Model IT Ltd. There is only one version that works for life, health and non-life products. mSII has been built by using MATLAB from MathWorks and runs on top of MATLAB. It is designed to support distributed computing. mSII has been tested using both Microsoft's Azure and MathWorks/MATLAB Distributed Computing Server/Amazon EC2 cloud. Results referred here are based from testing EC2 cloud service.
Using EC2 through ready-made MATLAB functionality is easy. One needs to use MATLAB Parallel Computing Toolbox to connect to MATLAB Distributed Computing Server and that will connect to EC2 cloud. Creating a 64-core or 256-core computation server takes only a few minutes, so start-up and shut-down times do not eat up your budget.
In this article we demonstrated that contract-level Monte Carlo is applicable to real-life modeling. By using distributed computing and cloud services, requested performance can be reached with low costs. Perhaps the new normal for the insurance industry is to expect powerful results quickly and with low costs.
Osmo Jauri, Dr.Tech., M.Sc. (Econ.), and Timo Penttilä, DBA (Finance), work for Model IT Ltd. Model IT specializes in insurance and asset management solutions. Osmo can be reached at Osmo.Jauri@modelit.fi. Timo can be reached at firstname.lastname@example.org.