Microsoft – Morgan Stanley Finance Contest

Final Report Endeavor Team

2011/10/28

1. Introduction

In this project, we intend to design an efficient framework that can estimate the price of options.

The price of the options is of great importance for option investors. Based on our assumptions, if

the price of the option estimated is more valuable, it is more likely to have a tidy profit from it.

The economic module we used in the framework is well-known Monte Carlo module. And as we

know, there are various types of options including Asian options, knock-in or knock-out options,

and lookback options. Although these options are somewhat different in definition, during

computing the price, the module and the method used are similar so that a well-designed

program can reduce most redundancy. The rest of our paper is organized as follows. In Section 2,

we introduce the algorithm we use, and our improvement of the classical algorithm. Section 3

shows the implement of the algorithm which is divided as the server and client part, and by

utilizing the polymorphism of C#, the codes are more brief and readable. The risk assessment is

listed in Section 4, and the way to choose options according to the prices estimated is given.

Section 5 gives the parallel performance of our test. Finally, we conclude our experience in this

contest.

2. Algorithm

2.1 Monte Carlo Method

In mathematical finance, a Monte Carlo option model uses Monte Carlo methods to calculate the

value of an option with multiple sources of uncertainty or with complicated features.

In terms of theory, Monte Carlo valuation relies on risk neutral valuation. The price of the option

is its discounted expected value; see risk neutrality and Rational pricing: Risk Neutral Valuation.

The technique applied then, is (1) to generate several thousand possible (but random) price paths

for the underlying via simulation, and (2) to then calculate the associated exercise value (i.e.

"payoff") of the option for each path. (3) These payoffs are then averaged and (4) discounted to

today. This result is the value of the option.

An option on equity may be modelled with one source of uncertainty: the price of the underlying

stock in question. Here the price of the underlying instrument is usually modelled such that it

follows a geometric Brownian motion with constant drift and volatility . So, where is found via a

random sampling from a normal distribution; see further under Black-Scholes. (Since the

underlying random process is the same, for enough price paths, the value of a european option

here should be the same as under Black Scholes).

Simulation can similarly be used to value options where the payoff depends on the value of

multiple underlying assets such as a Basket option or Rainbow option. Here, correlation between

assets is likewise incorporated.

As can be seen, Monte Carlo Methods are particularly useful in the valuation of options with

multiple sources of uncertainty or with complicated features, which would make them difficult to

value through a straightforward Black-Scholes-style or lattice based computation. The technique

is thus widely used in valuing path dependent structures like lookback and Asian options and in

real options analysis. Additionally, as above, the model is not limited as to the probability

distribution assumed.

2.2 The method of simulation of Brownian motion

2.2.1 Initial Method

Figure 1 gives the method of simulation of geometric Brownian motion by the binomial model.

p = erΔt − d

u − d (1)

u = eσ√Δt (2)

d = e−σ√Δt (3)

Sd

Su

S

p

1-p

Figure 1 Binomial Model

We can see, when the random number is bigger than p we get a new price Su , others we get Sd .

And from formulation (1), (2), (3), we see that when Δt is infinitely small, and n is infinitely large,

the simulation is similar to the geometric Brownian motion.

2.2.2 Improved Method

The initial method of simulation has a disadvantage that the value calculated by each step is

discrete (e.g. we do 100 step but get 101 discrete values) . So when n is not large enough, we

cannot simulate geometric Brownian motion well. To overcome this shortage, we think a better

version.

First Step:

We use 12 uniform distribution of 0-1 to generate a standard normal distribution value.

Let ε1, ε2, … , εn, … be independent, and each of them is meets [0, 1] uniformly distribution, so

ε1 + ε2 + ⋯ + εn can be considered as normal variables. Generally, we take a small n that can

meet requirement. In the Monte Carlo method, we take n as 12 in normal cases. And use the

following formula to get a new random number sequence.

ηk = ∑ ε12(k−1)+i − 612i=1 , k = 1,2, … (4)

Where ηk is a random number in the normal distribution, and ε12(k−1)+i is a random number

which subjects to a 0-1 uniform distribution. The code is implemented as Figure 2.

Second Step:

We map the standard normal distribution to a log normal distribution (i.e. geometric Brownian

motion) as the following formulation:

public double gaussDistribution(Random rand)

{

double sum = 0;

for (int i = 0; i < 12; i++)

sum += rand.NextDouble();

return sum - 6.0;

}

Figure 2 Gaussian distribution generated by 0-1 uniform distribution

S(t + Δt) = S(t)e[(μ−1

2σ2)t+σηΔt] (5)

Where every S (t + Δt) is a continuous variable, rather than a discrete binomial value in binomial

model. The code is implemented as Figure 3.

3. Implement

3.1 Server Design

As there are many types of options which have similar way to compute the prices, it is instinctive

to build a parent class and all the real options inherit from the parent class. The most critical and

the only diverse function of the framework is to compute the price of the option, which can be

overridden by the child classed. By doing this, the polymorphism of the object-oriented language

can be fully utilized and lots of redundancy can be reduced. The class diagram of our design is as

shown in Figure 1.

The variables that decide the types of the options should be paid attention to. When typeId is 1,

it is an Asian Option. The price of the option is computed by the average price from buying the

option to expiry. When typeId is 2, it is a knock-in or knock-out option. This kind of option is

valid or invalid once the price reaches some threshold. Otherchoice in this type determine which

one it is. When typeId is 3, it is a lookback option. The price is computed according to the

maximum or minimum of the price. Another four variables that decide the computation diversity

are isCall, isFixed, isUp and isAverage, which record whether the option is a call, fixed, up (if it is

knock-in or knock-out option) option and whether arithmetic average of geometric average

should be used.

public double nextPrice(double curPrice, Random rand, double sigma, double

interest, double deltaT)

{

return Math.Exp(deltaT * (interest - 0.5 * Math.Pow(sigma, 2)) + sigma *

Math.Pow(deltaT, 0.5) * gaussDistribution(rand));

}

Figure 3 Simulation of geometric Brownian motion

+BasedOptions()+compute_price() : double+Log()+gaussDistribution() : double+nextPrice() : double

#typeId : int#dayNum : int#interest : double#initial : double#exercise : double#up : double#down : double#deltaT : double#threshold : double#isCall : bool#isfixed : bool#isUp : bool#isAverage : int#otherChoice : int#var : double#brownApproxiMethod : int#sigma : double

BasedOptions

+AsianOption()+compute_price() : double

AsianOption

+KnockInOutOption()+compute_price() : double

KnockInOutOption

+LookBackOption()+compute_price() : double

LookBackOption

Figure 4. Class diagram of the server design

The only function we overridden is the critical one, compute_price(), where somewhat different

computation of various options is implemented. Then, the interface exposed to the client only

needs one function, where 3 steps are needed. First, according to the typeId, create the

corresponding instance. Then, invoke the compute_price() function of instance.

Figure 5. Pseudo code of the function exposed to client

public double ComputeOption(int typeId…){

BasedOptions op;

switch(typeId){

case 1:

op = new AsianOption(typeId,

dayNum, …);

break;

…}

return op.compute_price(runs, periods, clientId);

}

3.2 Client Design

Since server has encapsulate the function we should use, so in the client, the major work is to

create the session, read the data, send request to the server, and get the response. Once the

client send request to the server, the server will invoke the ComputeOpiton function and

compute the price. Here, we support continuously process several options. Meanwhile, to utilize

the multi cores on the server, for every option, we send clientNum requests, and each request

processes part of the total runs and works on a unique core. In reduceOptionPrice, the prices

from all the cores are collected and the function computes the final price. The process is similar

to famous map-reduce process.

Figure 6. Pseudo code of client

Main:

CreateSession

path[0] = @"C:\ContestData\1027-A.csv";

path[1]=…;

using(new client()){

for (int optionsId = 0; optionsId < OptionsNum; optionsId++){

readData(path[optionsId]);

mapOptionsPrice(session, client, optionsId);

}

client.EndRequests();

}

using(new client()){

for (int optionsId = 0; optionsId < OptionsNum; optionsId++){

reduceOptionsPrice(client, optionsId); }

}

session.Close();

mapOptionsPrice: Send Request to Server

for (int clientId = 0; clientId < ClientNum; clientId++){

ComputeOptionRequest request = new ComputeOptionRequest(…);

client.SendRequest<ComputeOptionRequest>(request, ctx);

}

reduceOptionsPrice: Get response from server

foreach (BrokerResponse<ComputeOptionResponse> response in

client.GetResponses<ComputeOptionResponse>()){

price += response.Result.ComputeOptionResult;

}

price = price/ClientNum;

Today we have done two things. First is to reconstruct the codes. Second is to use a new

approach to measure the risk of options. We call it variance normalization method.

4. Risk Assessment

On the first day of this contest, we considered little about the risk of options and just evaluate an

option by the theoretical expectation payoff. However, when our team analyzed the first day data,

we discovered that some high fair value options also accompanied with high risk (such as option

B2). So we attempted to find some data which can describe the risk of Options.

On the second day, we use the sample variance to describe the risk. At each run of the Monte

Carlo method, we can get a fair value of a specific path. So we collected the samples and

calculated the degree of dispersion. This is an intuitive idea, because the more discrete of the fair

value the more uncertainty of the result. People are always risk aversion, so the uncertainty is the

negative impact of the options. But the results are not satisfactory, because the sample variance

not only describes the uncertainty of the fair value but also affected by the price of premium. So

it's hard to use this parameter to describe the uncertainty of two different options.

On fourth day, we improved our approach based on the sample variance method. And we call it

variance normalization method. We first normalized the sample fair value by the expectation fair

value and then calculate the variance with the normalized data. This method can eliminate the

effects of the premium price.

Figure 1 is the statistical result of Monte Carlo algorithm which runs 15 million times. Standard

Deviation is 0.0031, so the risk is less.

Figure 4 Product A-1 in Day 4 Standard Deviation

0

1

2

3

4

5

log(

n)

fair value - premium

0.00

0.05

0.10

0.15

0.20

0.25

0.30

0.35

Figure 5 gives Product A-2 in Day 4 Standard Deviation, and the standard deviation is 0.0034, so

there is more risk in A-2.

Figure 5 Product A-2 in Day 4 Standard Deviation

5. Parallel Performance

In this contest, parallel programing contest, parallel performance is a key point of the final result.

So, we make some tests to get a best parameter of our algorithm.

As Figure 6 shows, because the limits of cores we can use, more request per loop does not get

more efficient work. And 32 request every loop gets the least time, so we choose this parameter.

Figure 6 Parallel Number of Time Table

More parameters is listed in Figure 7.

0

1

2

3

4

5

6

log(

n)

fair value - premium

0

0.05

0.1

0.15

0.2

0.25

0.3

0.35

0

20

40

60

80

100

120

140

160

180

4 8 16 32 64 128

Tim

e(s

ecs

)

Core Number

Number of request 32

Number of total runs 5000000

Number of every cores runs 1000

Figure 7 More Parameters

6. Conclude

Thanks for the finance contest held improvement by Microsoft and Morgan Stanley, we learned

lots of options information and technology of parallel programming these days. We conclude our

experience of the contest day as following.

Day1: not included risk Assessment.

Day2: assess the risk by the variance, but the drawback is that the variance is affected by the

mean (i.e. the higher the option price, the greater the variance).

Day3: Normalize variance to evaluate the risk. This method solve the above shortage. The

specific method is that every sample is divided by the expected first, which makes the expected

value to 1, and then get the variance of the processed data.

∑(

xiE(x)

−1)2

N−1i=1N (6)

Day4: Reconstruct our code and make it more readable.

Day5: Write the final report, and conclude our experience in this contest.