For our illustration, I will use Amazon Web Services (AWS) with Elastic MapReduce (EMR) and parallelize the Monte Carlo simulation using a MapReduce model. Note, however, that it can be implemented on any Hadoop cloud platform.

The bank will upload the client portfolio data into cloud storage (S3); develop MapReduce using the existing algorithms; and use EMR on-demand additional nodes to execute the MapReduce in parallel, write back the results to S3, and release EMR resources.

The bank loads the client portfolio data into the high-end risk data platform and applies programming iterations in parallel for the configured number of iterations. For each portfolio and iteration, they take the current Asset price and apply the following function for a variety of random variables:

The asset price will fluctuate for each iteration. The following is an example with 15 iterations when the starting price is 10€:

For a large number of iterations, the asset price will follow a normal pattern. As shown in the following figure, the value at risk at 99 percent is 0.409€, which is defined as a 1 percent probability that the asset price will fall more than 0.409€ after 300 days. So, if a client holds 100 units of the asset price in his portfolio, the VaR is 40.9€ for his portfolio.

The results are only an estimate, and their accuracy is the square root of the number of iterations, which means 1,000 iterations will make it 10 times more accurate. The iterations could be anywhere from the hundreds of thousands to millions, and even with powerful and expensive computers, the iterations could take more than 20 hours to complete.

In summary, they will parallelize the processing using MapReduce and reduce the processing time to less than an hour.

First, they will have to upload the client portfolio data into Amazon S3. Then they will apply the same algorithm, but using MapReduce programs and with a very large number of parallel iterations using Amazon EMR, and write back the results to S3.

It is a classic example of elastic capacity—the customer data can be partitioned and each partition can be processed independently. The execution time will drop almost linearly with the number of parallel executions. They will spawn hundreds of nodes to accommodate hundreds of iterations in parallel and release resources as soon as the execution is complete.

The following diagram is courtesy of the AWS website. I recommend you visit http://aws.amazon.com/elasticmapreduce/ for more details.

Rewrite the existing simulation programs into Map and Reduce programs and upload them into S3. The functional logic will remain the same; you just need to rewrite the code using the MapReduce framework, as shown in the following template, and compile it as MapReduce-0.0.1-VarRiskSimulationAWS.jar.

The mapper logic splits the client portfolio data into partitions and applies iterative simulations for each partition. The reducer logic aggregates the mapper results, value, and risk.

package com.hadoop.Var.MonteCarlo;

import <java libraries>;
import <org.apache.hadoop libraries>;

public class VarMonteCarlo{

  public static void main(String[] args) throws Exception{
    if (args.length < 2) {
      System.err.println("Usage: VAR Monte Carlo <input path> <output path>");
      System.exit(-1);
    }
    Configuration conf = new Configuration();
    Job job = new Job(conf, "VaR calculation");
    job.setJarByClass(VarMonteCarlo.class);

    job.setMapperClass(VarMonteCarloMapper.class);
    job.setReducerClass(VarMonteCarloReducer.class);
    job.setMapOutputKeyClass(Text.class);
    job.setMapOutputValueClass(Text.class);
    job.setOutputKeyClass(Text.class);
    job.setOutputValueClass(RiskArray.class);
    FileInputFormat.addInputPath(job, new Path(args[1]));
    FileOutputFormat.setOutputPath(job, new Path(args[2]));
    job.waitForCompletion(true);
  }

  public static class VarMonteCarloMapper extends Mapper<LongWritable, Text, Text, Text>{
     <Implement your algorithm here>
  }

  public static class VarMonteCarloReducer extends Reducer<Text, Text, Text, RiskArray> {
    <Implement your algorithm here>
  }
}

Once the Map and Reduce code is developed, please follow these steps:

You can download the simulation results from the Amazon S3 output bucket for further analysis with local tools.

In this case, you should be able to simply download the data locally, as the result volume may be relatively low.