RStudio Guide

To get started, click on the 'workspace' folder in the bottom right pane of RStudio. Click on the file entitled "Step 1...". You may want to drag the console pane to be smaller so that you have more room to work. You'll complete each task for Step 1 in that R Markdown file. Remember, you must run the cells with the play button at the top right of each cell for a task before moving onto the next task in the R Markdown file. Continue until you have completed all tasks in this step. Then when you are ready to move onto the next step, you'll come back and click on the file for the next step until you have completed all tasks in all steps of the lab.

Implementing Basic Monte Carlo Simulations

To review the concepts covered in this step, please refer to the Understanding Monte Carlo Basics module of the Implementing Monte Carlo Method in R course.

Understanding the basics of Monte Carlo simulations is important because it forms the foundation for more complex simulations and data analysis. This step will involve creating a simple Monte Carlo simulation in R, using the sample and replicate functions and defining probability distributions.

Let's dive into the world of Monte Carlo simulations! In this step, you'll be creating a basic Monte Carlo simulation in R. The goal is to familiarize yourself with the replicate function and understand how to define probability distributions. You'll be creating a simulation that estimates the probability of specific dice rolls. This will give you a hands-on experience of how Monte Carlo simulations can be used to estimate probabilities.

Task 1.1: Define the Probability Distribution

Create a function roll_two_dice that simulates the roll of two six-sided dice and returns the sum.

roll_two_dice <- function() {
  # Generate a random number between 1 and 6 for each die
  die1 <- sample(1:6, 1)
  die2 <- sample(1:6, 1)
  
  # Return the sum of the two dice
  return(die1 + die2)
}

Task 1.2: Run the Monte Carlo Simulation

Now that we have defined our function, we can run our Monte Carlo simulation. Set a seed to make the simulation replicable. Use the replicate function to simulate the roll of two dice 10000 times, and store the results in a variable results.

set.seed(123)
results <- replicate(10000, roll_two_dice())

Task 1.3: Calculate the Probability

Finally, we can calculate the probability of rolling an eight by counting the number of times we rolled an eight and dividing by the total number of rolls. Store this probability in a variable prob and print it.

prob <- sum(results == 8) / length(results)
print(prob)

Generating Predictions with Monte Carlo

To review the concepts covered in this step, please refer to the Making Predictions with Monte Carlo module of the Implementing Monte Carlo Method in R course.

Generating predictions with Monte Carlo simulations is important because it allows us to make informed decisions based on a range of possible outcomes. This step will involve creating a random walk in R, simulating multiple time series with the Monte Carlo method, and calculating confidence intervals for predictions.

Ready to take your Monte Carlo simulations to the next level? In this step, you'll be generating predictions using Monte Carlo simulations. The goal is to create a random walk in R, simulate multiple time series with the Monte Carlo method, and calculate confidence intervals for your predictions. This will give you a practical understanding of how Monte Carlo simulations can be used for making predictions.

Task 2.1: Create a Random Walk

Create a function called create_random_walk that creates a single random walk in R. The walk should with an initial value, then add or subtract 1 (with equal probability) at each step for a given number of steps. Use the function to create a random walk with a starting value of 100 and 500 steps (i.e., 501 total values including the starting value).

create_random_walk <- function(x, n_steps) {
  random_steps <- sample(c(1, -1), n_steps, replace = TRUE)
  walk <- cumsum(c(x, random_steps))
  return(walk)
}

set.seed(123)
create_random_walk(x = 100, n_steps = 500)

Task 2.2: Simulate Multiple Time Series with Monte Carlo Method

Using the function from the previous task and a for loop, simulate 1000 random walks. Store the results in a matrix with each row representing a different simulation.

n_sims <- 1000
n_steps <- 500

simulations <- matrix(nrow = n_sims, ncol = n_steps+1)
for (i in 1:n_sims) {
  simulations[i, ] <- create_random_walk(x = 100, n_steps = n_steps)
}

Task 2.3: Calculate Confidence Intervals for Predictions

The provided code creates a function to calculate a confidence interval that encompasses 95% of the simulated values. Apply this function over the simulations and store the result in a matrix. Print out the confidence interval for the value at the 25th step and the 50th step.

# Provided code
calc_95_ci <- function(x) {
  quantile(x, probs = c(0.025, 0.975))
}

# Calculate the 95% confidence interval at each step
ci_matrix <- apply(simulations, 2, calc_95_ci)

# Print the CI at the 25th and 50th step
print(ci_matrix[,25+1])
print(ci_matrix[,50+1])

Using Monte Carlo for Value at Risk

To review the concepts covered in this step, please refer to the Using Monte Carlo for Value at Risk module of the Implementing Monte Carlo Method in R course.

Understanding how to use Monte Carlo simulations for Value at Risk (VaR) is important because it provides a method for estimating the potential losses in an investment portfolio. This step will involve preparing data to estimate VaR, simulating VaR with Monte Carlo, and modifying assumptions in the Monte Carlo approach.

Time to put your Monte Carlo skills to work in the world of finance! In this step, you'll be using Monte Carlo simulations to estimate Value at Risk (VaR). The goal is to prepare data for VaR estimation, simulate VaR with Monte Carlo, and learn how to modify assumptions in the Monte Carlo approach. This will give you a real-world application of Monte Carlo simulations in the field of finance.

Task 3.1: Load the Data

Use the provided code to simulate a stock price over time. Plot the data over time as a line.

# Provided code to simulate data
set.seed(123)
stock <- data.frame(
  price = 100 * cumprod(1 + 0.0005 + 0.01*rnorm(365)) ,
  day = 1:365
)

# Plot the stock price over time
plot(stock$day, stock$price, type='l')

Task 3.2: Prepare the Data

Calculate the daily change in stock price and save it as a column called daily_change. Then calculate the daily return and save that as a column called daily_return. Remove the first row, where the daily return is unknown.

# Calculate the daily change
stock$daily_change <- c(NA, diff(stock$price))

# Calculate the daily return
stock$daily_return <- stock$daily_change / stock$price

# Remove NA rows
stock <- stock[-1,]

Task 3.3: Simulate VaR with Monte Carlo

Now let's simulate Value at Risk (VaR) using a Monte Carlo simulation. Create a function that simulates the next day's returns. This function should start with the average daily_return and then add the standard deviation of the daily_return, multipled by a random value from a normal distribution.

Replicate the function 1000 times to create a simulated distribution of returns. Calculate the VaR based on simulated data and the last available stock price.

set.seed(123)
n_sims <- 1000
return_func <- function(){
  mean(stock$daily_return) + sd(stock$daily_return) * rnorm(1)
}
returns <- replicate(n_sims, return_func())
VaR <- tail(stock$price, 1) * quantile(returns, 0.05)
print(VaR)

Task 3.4: Modify Assumptions in the Monte Carlo Approach

The assumptions in the Monte Carlo approach can be modified to see how they affect the results. Try doubling the standard deviation of the returns distribution in your simulation to see how it affects the VaR.

set.seed(123)
return_func_double_sd <- function(){
  mean(stock$daily_return) + 2 * sd(stock$daily_return) * rnorm(1)
}
returns_double_sd <- replicate(n_sims, return_func_double_sd())
VaR_double_sd <- tail(stock$price, 1) * quantile(returns_double_sd, 0.05)
print(VaR_double_sd)

Utilizing Monte Carlo for A/B Testing

To review the concepts covered in this step, please refer to the Utilizing MC for A/B Testing module of the Implementing Monte Carlo Method in R course.

Applying Monte Carlo simulations in A/B testing is important because it provides a robust method for comparing two or more groups. This step will involve conducting an A/B test using the Monte Carlo approach and comparing two distributions using the Monte Carlo method.

Let's explore how Monte Carlo simulations can be used in A/B testing! In this step, you'll be conducting an A/B test using the Monte Carlo approach. The goal is to compare two distributions using the Monte Carlo method. This will give you a practical understanding of how Monte Carlo simulations can be used in A/B testing to make data-driven decisions.

Task 4.1: Calculate Means and Standard Deviations from a Small Dataset

Use the data function to load the npk dataset, which comes standard with R. This small dataset contains an experiment done on the growth of peas. Calculate the mean yield of peas when Nitrogen was used (N = 1) versus when it was not used (N = 0). Then calculate the standard deviation for the yield when Nitrogen was used versus when it was not used. Save these values as mean_N_1, sd_N_1, mean_N_0 and sd_N_0.

data(npk)
mean_N_1 <- mean(npk[npk$N == 1,"yield"])
sd_N_1 <- sd(npk[npk$N == 1,"yield"])
mean_N_0 <- mean(npk[npk$N == 0,"yield"])
sd_N_0 <- sd(npk[npk$N == 0,"yield"])

Task 4.2: Conduct an A/B Test Using the Monte Carlo Approach

Now conduct an A/B test using the Monte Carlo approach. Generate two sets of simulated data representing the two different groups (Nitrogren vs. No Nitrogen) using the means and standard deviations from the previous task. Generate 1000 observations for each group. Based on your simulation, calculate the probability of the Nitrogren group having a higher yield value.

set.seed(123)
N_1 <- rnorm(1000, mean_N_1, sd_N_1)
N_0 <- rnorm(1000, mean_N_0, sd_N_0)

# Probability of Nitrogen group being higher
sum(N_1 > N_0) / 1000