Modeling Path Dependent Derivatives Using CUDA Parallel Platform

Transcription

1 Modeling Path Dependent Derivatives Using CUDA Parallel Platform A Thesis Presented in Partial Fulfillment of the Requirements for the Degree Master of Mathematical Sciences in the Graduate School of The Ohio State University By Lance Sterle, B.S. Graduate Program in Mathematical Sciences The Ohio State University 2017 Master s Examination Committee: Dr. Chunsheng Ban, Advisor Dr. Edward Overman

2 c Copyright by Lance Sterle 2017

3 Abstract The pricing of derivative securities with path dependence is governed by stochastic differential equations which rarely have a closed-form, analytic solution. These complex derivatives can be valued used simulation methods known as Monte Carlo methods, which converge slowly and thus require significant computational cost. This thesis demonstrates how the use of the GPU (Graphics Process Unit) can drastically lower the computational cost of these methods. The Longstaff-Schwartz Least Squares Monte Carlo Method is implemented to price American options, and suggestions are made for improving the efficiency of the algorithm. A model for valuing Guaranteed Lifetime Withdrawal Benefit (GLWB) options using Monte Carlo methods is also proposed and implemented in CUDA s parallel environment. Finally, the sensitivity of the GLWB option to various factors and the ramifications for insurance companies who sell this guarantee is discussed. ii

4 Acknowledgments I would like to thank Dr. Ban and Dr. Overman for their time and effort in serving on my committee and editing this thesis. In addition, I would like to thank Mr. Dan Heyer of Nationwide for helping formulate the problems addressed in this thesis. Finallly, I would like to thank my family for their support and encouragement during my time at Ohio State. iii

5 Vita Mayfield High School B.S. Finance Miami University 2015-present Graduate Teaching Associate, Ohio State University Fields of Study Major Field: Mathematical Sciences iv

6 Table of Contents Page Abstract Acknowledgments Vita List of Tables ii iii iv vii List of Figures viii 1. Introduction CUDA Parallel Framework Path Dependent options and CUDA Least Squares Monte Carlo Pricing of American Options Options American Options The Least Squares Monte Carlo Method Summary of the Least Squares Method Least Squares Algorithm Steps Least Squares Implementation in CUDA Explanation of Implementation and Sample Code Comparison to Longstaff-Schwartz Results CPU vs. GPU Efficiency Sampling to Improve Least Squares Efficiency Basis Functions for Least Squares Regression Conclusion v

7 3. Pricing Model for a GLWB Option Annuities and the Guaranteed Liftime Withdrawal Benefit Example GLWB Payout Path Modeling the GLWB option Assumptions Valuation Procedure Vasicek Model for Interest Rates Modeling Mortality using the Gompertz Law Efficiency of GPU Implementation Sensitivity of GLWB Price to Model Parameters Sensitivity to Investor Age Sensitivity to Fund Choice Sensitivity To Interest Rates Final Remarks on Model Inputs Conclusion Bibliography vi

8 List of Tables Table Page 2.1 American Put Option Price Comparison Runtime of GPU/CPU Pricing Codes Price and runtime under various sample sizes Accuracy of various polynomial degrees in pricing American put Sample GLWB Path Computation time for GLWB on GPU and CPU vii

9 List of Figures Figure Page 1.1 Illustration of CPU and GPU Architecture and Optimal Roles [18] Sensitivity of GLWB Price to Investor Age GWLB Price Sensitivity to Asset Allocation GWLB Sensitivity to θ with parameters κ = 0.2, σ r = 0.04, r 0 = GWLB Sensitivity to σ r with parameters κ = 0.2, θ = 0.05, r 0 = GWLB Sensitivity to κ with parameters σ r = 0.04, θ = 0.05, r 0 = GWLB Sensitivity to r 0 with parameters σ r = 0.04, θ = 0.05, κ = viii

10 Chapter 1: Introduction 1.1 CUDA Parallel Framework CUDA is a parallel computing platform and application program interface (API) used to increase computing power by utilizing the graphics processing unit (GPU) [3]. It enables developers that write code in high level languages such as C++ to send certain sections of code to run on the GPU using C-like syntax. NVIDIA GPUs contain thousands of processors tightly packed together, as opposed to the central processing unit (CPU) which has only a few cores. Each of the CPU cores is vastly more powerful than the weak GPU cores in terms of the number of operations it can complete per second. However, for tasks that can be done in parallel the thousands of processors on the GPU combined can significantly outperform the CPU. For this reason, GPUs were created for use in graphics processing, since each pixel on a computer screen can be handled by independent processors to minimize computation time. To run a portion of a program on the GPU, first the code must copy data from the CPU memory to GPU memory. Then, the GPU program must be loaded and executed, caching data on the chip for performance reasons [4]. Finally, the results must be copied from the GPU back to the CPU memory to be further processed or displayed. Tasks that are easily divided into many independent subtasks are prime 1

11 candidates for parallel processing, while tasks that must be done in a sequential order are better suited for CPU processing. Vectorized tasks are ideal for parallel processing as each element can be accessed and processed independently, a fact that is used in implementing the pricing schemes in this thesis. Figure 1.1: Illustration of CPU and GPU Architecture and Optimal Roles [18] When programming a function or script in CUDA, each invocation of the function is assigned to a thread. Each thread is responsible for processing one function call, and threads are organized into larger units called blocks. When invoking a CUDA kernel (the program run on the GPU), the number of blocks that will be used and the number of threads per block must be specified by the user so the kernel can organize these threads accordingly. In the code taken from the implementation file kernel.cu, 2

12 the function GWLB paths GPU is called. The first argument in angled brackets specifies the number of blocks required, the second specifies the number of threads. In this case, the code is organized so that each of the N paths is given its own thread, with threads being organized into blocks of size BLOCK SIZE. Block size should be a multiple of 32 to avoid wasting threads since each block is further organized into warps, which are groups of 32 threads. Most GPUs have a limit of either 512 or 1024 threads per block. GLWB paths GPU << < (N PATHS + BLOCK SIZE 1) / BLOCK SIZE, BLOCK SIZE >> > (N YEARS, N PATHS, withdrawal, p c t a l i v e d, dt, s q r t d t, S0, sigma, sigma sq, mu, r0, r sigma sq, theta, kappa, f l o o r, rands, l i a b i l i t i e s d ) ; CUDA is compatible with most NVIDIA graphics cards produced in the past 5 years, and in my implementation the NVIDIA GeForce 840M model was used for calculations on a laptop with an Intel i5 processor (with 2 cores). All computation times and comparisons given are likely several orders of magnitude faster on a more cutting edge GPU and CPU, and in industry a system of GPU s can be used to speed computations even more dramatically. 1.2 Path Dependent options and CUDA An option without path dependence has a value that depends only on the asset s price at expiration. A path dependent option is an option whose value depends on the path of prices the underlying asset takes as time progresses towards expiration. Generally, the complexity of path dependent options prevents closed-form solutions from being found, so numerical or simulation based techniques must be used to value these 3

13 options. In Monte Carlo simulation, a large number of paths are simulated in order to estimate an expected value through the use of simulated random quantities[15]. However, the convergence rate for these methods is often extremely slow, usually on the order of N, where N is the number of paths [6]. Since each path is assumed to be an independent scenario, Monte Carlo simulation is an ideal candidate to run on the GPU. In CUDA C++, a pointer array can be created on the GPU to store these paths, and by carefully indexing these arrays each thread can be assigned to generate a single path. These computations running simultaneously on the thousands of GPU processors, can be significantly faster than running the paths on the relatively few, powerful processors of the CPU (2 on the Intel i5 used in this implementation). This greater computational speed allows the use of more paths and thus greater accuracy for these Monte Carlo methods. In this paper an American option and Guaranteed Lifetime Withdrawal Benefit (GLWB) option are priced, with the American option receiving moderate computational benefits and the GLWB option receiving significant benefits. 4

14 Chapter 2: Least Squares Monte Carlo Pricing of American Options 2.1 Options A call option gives the investor the right to purchase the underlying asset S at the strike price K at some specified future time T. A put option is similar, but gives the investor the right to sell the asset. European options allow the buyer to exercise the option only at maturity. European options are the subject of the Black-Scholes- Merton formula [1], which prices a European option under assumptions of constant volatility and interest rates with the underlying asset S following Geometric Brownian Motion: ds t = us t dt + σs t dw t where u is the expected return on the asset, σ is the volatility of the asset, and W t is a Brownian Motion. The payoff V T for a European call at expiration time T is the difference between the the strike price K and asset price S T. If this value is negative, the option will not be exercised and the payoff will be 0. The payoff can be expressed as V T = (S T K) + for a call option and V T = (K S T ) + for a put option. An option is considered in-the-money at any time t if its payoff is positive, and out-of-the-money if its payoff is 0. 5

15 To compute the value of an option before expiration, we assume an underlying probability space (Ω, F, P), where Ω is the set of all possible economic outcomes from [0,T], F the sigma algebra of distinct events at time T, and P is a probability measure defined on the elements. Assume the space is augmented with the filtration {F t ; t [0, T ]} generated by asset prices in the economy, and F T = F. With no arbitrage, the Second Fundamental Theorem of Asset pricing implies the existence of a risk-neutral measure. Risk-neutral pricing involves changing from the real-world probability measure P to the risk neutral probability measure P. Under this measure the expected return on the underlying asset is the risk-free rate and the discounted option price is a martingale. The definition for a martingale follows [20]. Definition A stochastic process X t adapted to the filtration F t on the probability space (Ω, F, P) is a martingale with respect to F t if E[X t F s ] = X s for all s, t T and s t. [5]: Thus the European call option can be priced using the risk-neutral pricing formula V t = Ẽ[e T t r sds V T F t ] where r s, the risk-free rate, is an adapted stochastic process. Computing this expectation under the risk-neutral measure gives the Black-Scholes-Merton Formula for pricing a European call option (C(S t )) when the current asset price is S and the current time is t. With no dividends, a constant asset volatility σ and risk-free rate r the formula is [1]: d 1 = r(t t) C(S, t) = N(d 1 )S N(d 2 )Ke ) 1 σ T t [ ln ( S K 6 + (T t) )] (r + σ2 2

16 1 d 2 = σ T t [ ( ) S ln + (T t) K where N is the standard normal distribution. )] (r σ American Options An American option shares the same features as the European option, except the option can be exercised at any time (a European option is only exercised at maturity). At the expiration time T, the option is clearly exercised if it is in-themoney (S T > K for a call option, S T < K for a put). Prior to expiration, the optimal strategy is to compare the value from exercising the option immediately with the expected cash flows from continuing to hold the option, and only exercise if immediate exercise is more valuable [10]. Therefore, one must compute the conditional expected value of holding the option at a given time step in order to make this decision. Unlike with European options there is no closed form solution for computing the expectation under the risk neutral measure. Therefore, to compute this expectation either finite-difference methods or simulation-based techniques must be used. As the option increases in complexity, finite difference techniques become impractical [10]. 2.2 The Least Squares Monte Carlo Method Summary of the Least Squares Method Longstaff and Schwartz devised a technique referred to as the Least Squares Monte Carlo method for evaluating the conditional expectation. First, a large number of asset price paths are simulated. Then, at each time step the expected holding value is estimated using least squares regression as a linear combination of basis functions which depend on the asset price S. The least squares regression minimizes the sum 7

17 of squared errors between the value predicted by the basis functions and the actual holding value for each simulation. The fitted value from this regression provides a direct estimate of the conditional expectation function. By estimating the conditional expectation function for each exercise date, the optimal exercise strategy (whether to hold or exercise at a given date) is completely specified for each path [10] Least Squares Algorithm Steps Assume a partition of N time steps 0 < t 1 < t 2 <... < t N = T. For path i and time t n denote the stock price as S i,tn, the exercise value as EV i,tn, the holding value as HV i,tn and the option price as V i,tn. The algorithm for evaluating the conditional expectation is as follows: 1. Generate simulated paths for the underlying asset price S (Geometric Brownian Motion under the Black-Scholes framework). 2. For each path i the price at expiration time T, V i,t, equals the exercise value EV i,t of the option, where EV i,t = (S i,t K) + for a call and EV i,t = (K S i,t ) + for a put. 3. Calculate the holding value at time t N 1 for each path by discounting the price at time T. HV i,tn 1 = V i,t e r(t t N 1) 4. Calculate the exercise values EV i,tn 1 at time t N 1 as (S tn 1 K) + for a call or (K S tn 1 ) + for a put. 8

18 5. For each in-the-money option, approximate the expected holding value function with a set of m basis functions, φ 1 (S),, φ m (S), using a least squares regression against the holding values of the N 1 time step. Use the coefficients of each basis function computed from the regression (α 1,tN 1,, α m,tn 1 ) to predict the expected hold value of each in-the-money path. The expected holding value of path i at time t N 1 is expressed as a linear combination of basis functions. E[HV i,tn 1 ] = m α j,tn 1 φ j (S i,tn 1 ) j=1 6. If the exercise value exceeds the expected holding value (EV i,tn 1 > E[HV i,tn 1 ]), then the option value equals the exercise value (V i,tn 1 = EV i,tn 1 ). Otherwise, set V i,tn 1 equal to the holding value HV i,tn Recursively run the previous 4 steps until time t = 0. The holding value is the average holding value across all paths, and the option price at t = 0 is the greater of the holding value and the exercise value at time t = Least Squares Implementation in CUDA Explanation of Implementation and Sample Code The Least Squares Monte Carlo method is implemented in CUDA C++, with one version that runs entirely on the CPU and one version that utilizes the GPU to speed the computation. The code models the asset price using Geometric Brownian motion with constant volatility σ and constant risk-free rate r. The SDE of Brownian motion can be solved to obtain a closed form solution using Itô s Lemma: 9

19 Lemma Itô s Lemma Let u t and v t be adapted stochastic processes and X t be a stochastic integral defined as: dx t = u t dt + v t dw t. If f(t, x) C 1 ([0, T ]) C 2 (R), then stochastic process Y t = f(t, X t ) is a stochastic integral with: dy t = f t (t, X t )dt + f x (t, X t )dx t f xx(t, X t )(dx t ) 2 Itô s Lemma can be used to solve for the asset price S t in the Geometric Brownian motion equation. In Geometric Brownian motion u t is a constant u and v t is a constant σ. Applying Itô s Lemma with f(t, S t ) = ln(s t ) we get the stochastic differential equation: d(ln S t ) = 1 S t ds t St 2 (ds t ) 2. Substituting ds t from the Brownian motion equation: d(ln S t ) = 1 S t (us t dt + σs t dw t ) 1 St 2 (us t dt + σs t dw t ) 2. Applying the formal rules dt 2 = 0, dtdw t = 0 and dw 2 t = dt simplifies the products from the (ds t ) 2 terms. This equation can now be expressed in integral form as: T 0 d(ln S t ) = T 0 T (u σ2 2 )dt + σdw t. 0 The first two integrals are deterministic and simple to evaluate, and the second integral follows from the definition of Brownian motion: T 0 σdw t = σw T. 10

20 Exponentiating both sides gives the solution for S T : σ2 (u S T = S 0 e 2 )T +σw T. To find S T given S t, for T t 0, this formula becomes: σ2 (u S T = S t e 2 )(T t)+σ(w T W t). The Brownian increment W T W t is normally distributed with mean 0 and variance T t, thus we can simulate it using random draws from a normal distribution. The normal random numbers are generated using the Mersenne Twister psuedorandom number generator. This widely used psuedo random number generator has a lengthy period ( for this implementation) and thus closely approximates true random numbers [11]. A CPU routine[2] is used to compute the least-squares regression coefficients in the CPU code and in the GPU enhanced code. An efficient GPU least squares solver could lead to further improvements in the implementation, since solving for the regression coefficients at each time step is a computationally expensive portion of the code. The CUDA default GPU solver performed worse than the CPU routine and thus was not used. An example GPU function that represents a piece of the American option pricing code is displayed below. The create paths kernel launches a GPU code for generating asset price paths. The global identifier in front of the function call indicates that it should be run on the GPU. This code performs superior to the CPU code because it assigns each thread a single path so that thousands of paths can be generated simultaneously, whereas the CPU code must compute paths sequentially. The code for generating these paths for pricing the American options is below: 11

21 { } g l o b a l void c r e a t e p a t h s k e r n e l ( int N STEPS, int N PATHS, double dt, double s q r t d t, double S0, double r, double sigma, double sigma sq, double mu, double rands, double paths ) // I d e n t i f i e s the path generated by t h i s thread. // blockdim. x = t h r e a d s per b l o c k int path = blockidx. x blockdim. x + threadidx. x ; // I n s t a n t i a t e p r i c e at t=0 as S0 double S = S0 ; double sigma sq 2 = sigma sq / 2 ; // O f f s e t ensures the thread i s working on the c o r r e c t path int o f f s e t = path ; // Code only runs i f the path number i s v a l i d // Ensures t h a t out o f bounds array a c c e s s e s are not made i f ( path < N PATHS) { } // Generate Asset Prices using Geometric Brownian motion for ( int timestep = 0 ; timestep < N STEPS ; ++timestep, o f f s e t += N PATHS) { S = S exp ( (mu sigma sq 2 ) dt + sigma ( rands [ o f f s e t ] ) ) ; paths [ o f f s e t ] = S ; } s y n c t h r e a d s ( ) ; Due to the massive amount of memory used in the simulations, dynamic memory allocation must be used. Instead of a static array of doubles that would be created on the stack, an array of pointers must be allocated on the heap. The code is passed two pointers, one that points to the location of the random numbers in memory and another that points to the location of where the paths will be stored in memory. The paths are stored in a one-dimensional array first in order of time, then in order of path number (so the first N PATHS entries are the values of the asset at t = 1). Each thread is assigned a path, and each of these threads calls this function. The path variable allows each thread to identify which path it should work on. Each path is assigned to a specific block (identified by blockidx.x) of size blockdim.x and a specific thread within that block (identified by threadidx.x). The if condition ensures that 12

22 any leftover threads assigned an invalid path number do not crash the program by attempting an out of bounds array access. At the end of the function, the threads are instructed to wait until all threads have completed their task with the syncthreads() function. This ensures that 2 threads do not attempt to access the same location in memory, thus preventing the unauthorized mixing of 2 different paths. A regression matrix used to compute the basis function coefficients is generated at each time step. This regression matrix usually has thousands of rows but just a few columns. The function fillstockmatrix() allows each thread to fill in a single row of this matrix in parallel, greatly enhancing the speed as the matrix size grows larger. In addition, the calcexpectedholdvals() function generates a vector containing the expected hold values as described in the previous section, where each entry is given as: m E[HV i,tn 1 ] = α j,tn 1 φ j (S i,tn 1 ). j=1 Since each holding value is generated by a dot product between a vector of coefficients α j,tn 1 and a vector of basis function outputs φ j (S i,tn 1 ), assigning a thread to compute each holding value simultaneously is significantly faster than computing entries sequentially as the CPU must do. The implementation allows the user to choose any number of polynomial basis functions (1, x, x 2...), time steps, paths and market parameters, and works for both put and call options. At each time step, Longstaff and Schwartz chose to use only the in-the-money options to calculate the expected holding values. In this implementation the user can select a smaller sample of those in-the-money paths, which results in faster code without sacrificing accuracy in the examples explored below. 13

23 2.3.2 Comparison to Longstaff-Schwartz Results The results obtained from this implementation mirror the results in the Longstaff- Schwartz paper. Using the Feynman-Kac Formula, a partial differential equation for the price of the American put option can be obtained and used to validate the Monte Carlo solution for this simple example (for more complex options this is often not feasible) [9]. In their paper, Longstaff and Schwartz used an implicit scheme to compute a finite difference solution to the partial differential equation corresponding to the American put price. The implicit finite difference scheme has been proven to be unconditionally stable, accurate and convergent to the PDE solution for the American put option, and can be used to verify the results of the LSMC algorithm [7]. Longstaff and Schwartz limited the number of exercise dates to 50 per year due in part to the computational effort required for each regression. This implementation allows the option to be exercised at any time step during the simulation, with greater computational costs the more exercise dates are chosen. In the original algorithm, all of the in-the-money options are used to estimate the regression coefficients. However, in this implementation a much smaller sample of the in-the-money options is used to generate the regressions, which is discussed in a subsection that follows. Table 2.2 shows the prices generated for a put option with strike price of K = 40, risk-free rate of r = 0.06, time steps of 1 day and a path size of 50,000 to be consistent with the parameters used in the Longstaff-Schwartz paper. Cubic basis functions are used for each regression. They are compared to some results in the Longstaff-Schwartz paper for various changes in expiration time T, volatility σ and current asset price S [10]. 14

24 S T σ GPU Price LS Price Finite Difference Table 2.1: American Put Option Price Comparison Table 2.1 contains prices for one in-the-money option (S = 36), one out-of-themoney option(s = 44), and one at the money option (S = 40). For each of the options shown the price calculated from GPU is within a few cents of the finite difference price calculated in the Longstaff-Schwartz paper. These results are also relatively stable and produce very similar prices each time the code is run despite the random number generation. For example in the first option in Table 2.1 (K = 40, r = 0.06, σ = 0.2, T = 1, S = 36) a 15 trial sample produced a mean of and a standard deviation of In other words, the mean difference between the GPU price and the finite difference price of was less than a cent and the computation was consistent within a few cents for every trial CPU vs. GPU Efficiency The GPU code consistently outperforms the CPU code for any number of paths, with the relatively efficiency increasing as the number of paths increase. The table 15

25 below was generated for a put option with parameters K = 40, r = 0.06, σ = 0.2, T = 1, and 5,000 sample paths to generate each cubic regression. Paths Exercise Dates Least Squares Time CPU Code GPU Code 40, , , , , , Table 2.2: Runtime of GPU/CPU Pricing Codes Table 2.2 shows that the GPU portion of the code runs 7-10 times faster than the CPU portion. It is also seems that the GPU runtime scales linearly at worst with the number of paths run. Memory constraints on the NVIDIA GeForce 840M prevent using 365 exercise dates when the number of paths increases beyond 80,000. With a more advanced GPU or a system of GPUs, larger path sizes than those listed can be used. When modeling with more complex stochastic dynamics, this scalability becomes increasingly important as more computations are needed to compute each step of each path. In additon, for multi-asset systems an increasing number of paths is required to estimate the expectation function (the stochastic integral) and so the increasing efficiency is vital when millions of paths may be needed Sampling to Improve Least Squares Efficiency In the Longstaff-Schwartz algorithm, all in-the-money paths are used to compute the regression function coefficients which estimate the expected holding values[10]. 16

26 For a put option implementation with 80,000 paths, there will likely be 30,000-40,000 in-the-money options for each step, requiring a large matrix and expensive least squares solution for each regression. This implementation investigates the effect of sampling a relatively small number of in-the-money options at each time step. Two approaches are attempted, the first where n in-the-money options are randomly chosen at each step, and the second naive sampling where the first n in-the-money options stored in the array at a given time step are chosen. Interestingly, randomly choosing the sample versus choosing the naive sampling did not change the accuracy of the final price across a wide set of simulations. There was evidence that a small sample ( ) at each step could achieve the a similar level of accuracy to a full regression for the valuation of an American put. Table 2.3 shows an example of an American put with K = 40, r = 0.06, σ = 0.2, T = 1, S = 36 and 365 exercise dates. The No Sampling entry uses all available inthe-money options at each step to perform the regression, and the naive sampling method is used for the other entries. Paths Samples Used Runtime GPU Price Finite Difference Price 80,000 No Sampling , , , , , , Table 2.3: Price and runtime under various sample sizes 17

27 Table 2.3 is representative of results across a variety of option prices, with slightly larger errors for out-of-money options. The evidence suggests that for an American option, a sample as small as in-the-money options for each time step closely approximates the finite difference price. Given that this represents a 4x speedup compared to the algorithm without sampling and that a relatively small number of paths are used, even greater benefits could be derived for a large number of paths or a more complex simulation Basis Functions for Least Squares Regression As mentioned, the function fillstockmatrix creates a regression matrix A (represented as a 1D pointer array) and allows the use of a standard polynomial basis of any degree to estimate the expected holding value. Moreno and Navas [12] suggest that the Least Squares Monte Carlo method is robust to the basis functions used for an American option, and that relatively few basis functions should be used in the regressions at each step. Based on evidence from simulations of in-the-money, at-the-money and out-of-the-money options, the cubic polynomial basis appears to be the best polynomial choice amongst the standard polynomial basis in terms of the trade-off between accuracy and performance. However, beyond the poor performance of the linear basis function the rest of the polynomials performed similarly (less than 1 cent difference in their mean errors and standard deviations). A sample of 15 simulations for each polynomial basis is shown in Table 2.4 to illustrate this. The trials use K = 40, r = 0.06, σ = 0.2, T = 1, S = 36, 365 exercise dates, 50,000 paths and 2,000 samples per regression. 18

28 Degree Runtime Mean Error Standard Deviation of Error Table 2.4: Accuracy of various polynomial degrees in pricing American put Conclusion The implementation of the Least Squares Monte Carlo method in CUDA clearly demonstrates the potential of using parallel computing to significantly improve computational speed. In addition, there is strong evidence that using sampling of the in-the-money options to compute regression coefficients offers a significant increase in computational efficiency without sacrificing accuracy, an implication that could prove especially important for practitioners modeling more complex instruments. 19

29 Chapter 3: Pricing Model for a GLWB Option 3.1 Annuities and the Guaranteed Liftime Withdrawal Benefit A variable annuity is a contract between an insurance company and an investor, in which the investor receives periodic payments from the insurance company[16]. The structure of these payments varies widely, but is generally linked to stock or bond funds chosen by the investor. As of 2007 nearly 95% of these variables annuities contained embedded options that provided customers with financial guarantees[17]. In this thesis, the focus is on an annuity which guarantees periodic payments for the remainder of the investor s life. A Guaranteed Lifetime Withdrawal Benefit (GLWB) is an option that can be attached to a variable annuity. This option guarantees that the investor will be able to withdraw a set percentage of their initial investment every year for the rest of their life from their market account, regardless of market conditions. When the investor dies, any funds left in the account are transferred to their beneficiary. The option allows the investor to benefit from their investment in the variable annuity in favorable market conditions, while giving the protection of a guaranteed income if their investment declines to zero. In this way, the GLWB functions as a put option 20

30 on the performance of the underlying funds chosen in the variable annuity, since its value to the investor becomes greater as the underlying funds decline in value. Given that there are no comparable securities of similar duration traded in the markets and that the payoff may not happen for decades, the pricing can be ambiguous and challenging Example GLWB Payout Path Assume that an investor makes a $100 investment in a variable annuity with a GLWB option and a 10% withdrawal that begins one year after purchase. The investor is guaranteed to receive $10 for the rest of his life regardless of the performance of the fund he has invested in. In this scenario the fund performs extremely poorly in the 3rd and 4th years and has been depleted by the end of year 6. At this point, the insurance company will be responsible for paying $10 a year until the end of the investor s life since the investor does not have sufficient value left in the fund to make the withdrawal. While this is an extreme example, it illustrates the uncertainty for the insurance company in the payout structure of the GLWB. Year Asset % Return Withdrawal Account Before Withdrawal Account After Withdrawal 1 10% % % % % % Table 3.1: Sample GLWB Path 21

31 3.2 Modeling the GLWB option Assumptions The GLWB option will be modeled using several assumptions: 1. The investor makes an investment into a single fund of A 0 dollars at t = The first withdrawal begins one year after the initial investment. 3. Withdrawals of w dollars will only be made at the end of each year from the account of the investor. The withdrawals will be a percentage q of the initial investment A 0 (i.e. w = qa 0 ), and will continue until the amount left in the investor s account reaches 0 (A t = 0). 4. If the account value reaches A t = 0, the insurer will purchase a perpetuity that pays w dollars per year, thus offsetting their liability to pay the investor w dollars per year for the rest of their life. The option is considered exercised at that point and the insurer has no future liabilities. 5. If the investor dies the options expires and any remaining funds are returned to the investor s heir. 6. The fund price S t is a stochastic process and its equation of motion is given by Geometric Brownian Motion under the risk neutral measure: ds t = r t S t dt + σs t dw t where r t is the stochastic risk free rate (specified below) and σ (volatility) is constant. 22

32 7. Interest rates are stochastic and follow the Vasicek interest rate model and the differential equation: dr t = κ(θ r t )dt + σdw t where θ is the long term mean for interest rates, κ is the speed at which interest rates revert to the mean and σ the volatility of interest rates 8. The mortality of investors is governed by the Gompertz law of mortality [8]: λ(a) = αe βa where λ(a) is the probability of death for an individual of age A, α is the age independent mortality rate and β is the age dependent mortality rate Valuation Procedure The payoff for the GLWB option happens at a random time τ when the investor s account value (A τ ) is exhausted. Since we assume end of the year withdrawals, τ is an integer such that A(τ) w 0 but A(t) w 0 for all t < τ. At this time, the insurance company is liable for making payments of w dollars for the rest of the investor s life. Since their remaining lifespan is unknown, to cover the liability in this model the insurer purchases a perpetuity, a financial instrument which pays a annual cash flow forever. The present value of the perpetuity is given by: P V = n=1 w (1 + r τ ) n where w is each payment, and r τ is the discount rate at time τ. This is an infinite geometric series with the closed form solution: P V = w r τ. 23

33 This is the payout at time τ that the insurer must make to purchase the perpetuity. The insurer only needs to purchase the perpetuity if the investor is still alive, so the payout at time τ is: V (τ) = I(τ) w r τ where I(τ) is an indicator function which is 1 if the investor is still alive at time τ, and 0 if not. The structure of the model does not lend itself to a closed-form expression, so the option is be valued via Monte Carlo simulation. A procedure for computing a price in a simulation with N paths is as follows: 1. Start with an investment amount A 0 for each path. 2. Simulate the price of the fund, S t, according to Geometric Brownian motion. The investor account will increase at the same rate of return as the underlying fund. Subtract w dollars from the account at the end of each year. 3. Simulate the stochastic interest rate r t according to the Vasicek model. 4. If A t - w 0, then the insurance company purchases a perpetuity at price w r t, where r t is the interest rate at time t. 5. Weight the price of the perpetuity by the probability that the investor survives until time t, P (t), where P (t) is calculated using the Gomperz law of mortality. 6. Discount this payment back to the present day using the present day interest rate r 0, so that the discounted payment is: e r 0t P (t) w r t. 24

34 7. Take the average of these discounted payments over all N paths to get the price of the GLWB option. The simulation is run for a long time period (50-70 years) so that by the end of the simulation, an investor is guaranteed to either have received a payout or the probability of survival is virtually Vasicek Model for Interest Rates Interest rates directly determine the value of the perpetuity liability generated by the GLWB option. They are simulated using the Vasicek interest rate model [19], an Ornstein Uhlenbeck [14] process which specifies that the instantaneous interest rate follows the stochastic differential equation: dr t = κ(θ r t )dt + σ r dw t where θ is the long term mean for interest rates, κ is the speed at which interest rates revert to the mean, σ r the volatility of interest rates, and W t is a Brownian motion. The Vasicek model is useful since it captures the mean reversion of interest rates. In addition, the Vasicek model has a closed-form expression that can be found by solving the differential equation using Itô s Lemma. However, it allows interest rates to go below zero. This is an generally an undesirable feature when modeling interest rates (at its post crisis low the 10-year US treasury still had a yield of 1.6%). In addition, it will result in negative values for the perpetuity when the rate is negative and near infinite perpetuity values if the rate is near zero. Therefore, an interest rate floor parameter is used in the CUDA implementation. The Vasicek function thus returns the floor in any case where a value lower than the floor is simulated, preventing the aforementioned issues. 25

35 The Vasicek SDE can be solved directly using Itô s Lemma. Choose f as: f(r t, t) = r t e κt. Applying Itô s Lemma results in the SDE: d(r t e κt ) = κr t e κt dt + e κt dr t. Substituting dr t = κ(θ r t )dt + σdw t : d(r t e κt ) = κr t e κt dt + e κt θdt κr t e κt dt + σ r e κt dw t. Expressing the equation in integral form: d(r t e κt ) = e κt (θdt + σ r dw t ). t d(r t e κt ) = t e κs θds + t e κs σ r dw s. Integrating and solving for r t gives the solution: t r t = r 0 e κt + θ(1 e κt ) + σ r e κ(t s) dw s. The solution can easily be adapted to find the change in rates from time t to T, where 0 T t: T r T = r t e κ(t t) + θ(1 e κ(t t) ) + σ r e κ(t s) dw s t Modeling Mortality using the Gompertz Law In the GLWB pricing model proposed the percentage of surviving investors is a key input, as the insurance company s liability is zero if the investor dies. One relatively accurate and simple way to predict the percentage of survivors is by using Gompertz 26

36 Law of Mortality [8] It uses an exponential distribution to predict the mortality rate of an individual: λ(a) = αe βa where A is the age (in years) of the individual, α is the age independent mortality rate and β is the age dependent mortality rate. This model can be re-written as a linear equation using logarithms: ln λ(a) = ln α + βa In linear form, least squares regression can be used to estimate the parameters α and β. Data from the Human Mortality Database is used to estimate the parameters when implementing this model in CUDA [13]. Only data from ages 30 and greater is included when conducting this regression analysis, as mortality rates increase exponentially after age 30 but do not follow this pattern for younger ages. Using data for both sexes from 2016, the least squares solution yields coefficients of β = and α = Using these coefficients, the probability P (t) of surviving t years given a starting age of A can be estimated as: t P (t) = (1 λ(a + i)) i=1 where λ(t) is the mortality rate predicted by Gompertaz Law using α and β from the regression above. In the implementation, the probability of survival in each year is calculated before the simulation and passed as pointer array to each simulated path, eliminating redundant calculations Efficiency of GPU Implementation Pricing the GLWB option benefits greatly from utilizing the GPU. Table 3.2 gives the runtime results for one code that uses the CPU to price the option, and another 27

37 code which uses the GPU to price the option. In these simulations, annual time steps are used and the simulation is run for 70 years: Paths GPU Runtime(s) CPU Runtime(s) GPU Speedup Factor 50, , , , , , ,000, ,000, ,000, Table 3.2: Computation time for GLWB on GPU and CPU The GPU code becomes increasingly more efficient relative to the CPU code as the number of paths used increases, and is 24 times faster than the CPU code when 3,000,000 paths are used. This scalability is important, since funds are often modeled as a basket of stocks, each with its own stochastic equation of motion rather than the single equation demonstrated here. The computational costs can quickly escalate, and this example suggests practitioners can use the power of multiple GPUs simultaneously to create a powerful parallel system for modeling complex, multi-dimensional asset behavior. 3.3 Sensitivity of GLWB Price to Model Parameters Several model parameters have a very strong impact on the price of the GLWB option. As such, the focus is on outlining several parameters that affect the final price the most and the ramifications for the insurer. 28

38 3.3.1 Sensitivity to Investor Age Figure 3.1 expresses the price of a sample GLWB option as a percentage of the initial investment. A simulation length of 70 years with 2, 000, 000 paths is used, along with a 5% annual withdrawal rate. The following parameters are also used: Asset Prices: σ = 0.2 Interest Rates: r 0 = 0.035, θ = 0.05, κ = 0.2, σ r = 0.04, r floor = 0.01 Figure 3.1: Sensitivity of GLWB Price to Investor Age Figure 3.1 shows that there is a roughly linear trend between the age of the investor and the price of the GLWB under this model s assumptions. This data makes an argument for strong price discrimination based on age, as the price for an investor 29

39 at the retirement age (65) is half that of an investor just 15 years younger (6.4% vs. 13.2%). Shah and Bertsimas [17] argue that insurance companies do not charge a sufficient age premium for most guaranteed income options, and this particular model supports the assertion that the GLWB price should be highly sensitive to the age of the investor Sensitivity to Fund Choice Investors generally are given a menu of funds to choose when investing in a variable annuity product. These funds vary in the return they expect to generate and their volatility, allowing consumers to choose more aggressive or conservative asset allocations. Thus fund choice has significant ramifications for the price of the GLWB option. Figure 3.2 is generated using a simulation length of 70 years with 2, 000, 000 paths along with a 5% annual withdrawal rate. Consider a few different theoretical portfolios, which all have the same expected return under the risk neutral measure (the risk free rate) but different volatility. These are demonstrated in Figure 3.2 below. 30

40 Figure 3.2: GWLB Price Sensitivity to Asset Allocation Based on Figure 3.2, it is clear that the volatility of the portfolio has a significant impact on the price of the GLWB option. For low volatility (a less aggressive portfolio allocation) the cost of insuring the GLWB is quite low and does not vary extremely across age. However, for higher volatility (aggressive portfolio allocations) the price of the GLWB is not only higher, but varies more extremely across age cohorts.thus insurers must weigh the combination of asset allocation and investor age in tandem when considering the pricing of a GLWB option. Given the sensitivity it may be more 31

41 appropriate to use a stochastic model for volatility, which will likely be a feature in updated versions of the implementation Sensitivity To Interest Rates In this section 2, 000, 000 paths along with a 5% annual withdrawal rate continue to be used, along with a 1% interest rate floor and the asset price dynamics with σ =

42 Figure 3.3: GWLB Sensitivity to θ with parameters κ = 0.2, σ r = 0.04, r 0 = Figure 3.4: GWLB Sensitivity to σ r with parameters κ = 0.2, θ = 0.05, r 0 =

43 Figure 3.5: GWLB Sensitivity to κ with parameters σ r = 0.04, θ = 0.05, r 0 = Figure 3.6: GWLB Sensitivity to r 0 with parameters σ r = 0.04, θ = 0.05, κ =

44 Based on these figures the following conclusions can be made about the sensitivity of the GLWB option price to various interest rate parameters 1. The theoretical long term interest rate θ assumed by the model has a very small impact on the price of the GLWB option. 2. Interest rate volatility σ r decreases the price of the GLWB option. For very low interest rate volatility, the price reduction is significant, but the price increase with respect to σ r becomes negligible once a certain threshold is passed. Particularly, for older investors the price difference is negligible. 3. A very fast mean-reversion factor κ will decrease the price of the option moderately across most ages. 4. The GLWB option is highly sensitive to the current interest rate r 0, particularly for younger investors. In a low rate environment (like the present day) the GLWB option is a very expensive instrument to insure due to its long duration Final Remarks on Model Inputs Based on the results of the simulations above, the factors which affect GLWB option prices can be ranked into tiers: 1. High impact factors: investor age, portfolio allocation (volatility), current interest rates r 0 2. Moderate impact factors: interest rate volatility σ r, interest rate mean reversion speed κ 3. Low impact factors: theoretical long term mean interest rate θ 35

45 These results suggest the insurance companies should practice significant price discrimination when selling these options. Costs should be multiples higher for younger purchasers (40s and 50s) than those of retirement age (65+). In addition, the investor fund choice should be carefully scrutinized and weighed against their age when deciding how to price the product. In the current low interest rate environment it is possible that insurers are underpricing these guarantees as Shah and Bertsimas suggest [17]. Finally, the wide variety of prices given suggests the high dependency of the GLWB pricing on model assumptions. This means it is possible that the GLWB option is more risky than some insurers and regulators may consider them. 36

46 Chapter 4: Conclusion This thesis explores the potential of CUDA parallel computing technology to drastically reduce the computational time of modeling path dependent options. Models for the American option and Guaranteed Lifetime Withdrawal Benefit (GLWB) option are discussed and implemented. In addition, it is found that factors such as investor longevity, asset allocation and other model assumptions create significant ambiguity in pricing the GLWB options. It is clear that insurers need to be vigilant in assessing these modeling risks and perhaps charge higher prices to reflect the uncertainty of these relatively new instruments. The methods used in this paper can be used to model higher-dimensional asset structures than those explored here, which may improve the accuracy of prices obtained. While the single GPU used in this implementation is useful, a system of more powerful GPUs can be used in practice to model asset dynamics with far more complexity. 37