Monte Carlo simulation basics in NumPy - Mini Project: Build & Apply

Monte Carlo Simulation Basics

📖 Scenario: Imagine you want to estimate the chance of rolling a total of 7 with two dice. Instead of calculating all possibilities, you can simulate rolling dice many times and see how often you get 7.

🎯 Goal: You will build a simple Monte Carlo simulation using numpy to estimate the probability of rolling a sum of 7 with two dice.

📋 What You'll Learn

Use numpy to generate random dice rolls

Simulate rolling two dice many times

Count how many times the sum is exactly 7

Calculate the estimated probability

Print the final probability

💡 Why This Matters

🌍 Real World

Monte Carlo simulations are used in finance, science, and engineering to estimate probabilities and risks when exact math is difficult.

💼 Career

Data scientists use Monte Carlo methods to model uncertainty and make predictions based on random sampling.

1

Create dice roll simulation data

Import numpy as np and create a variable called rolls that simulates rolling two dice 10000 times using np.random.randint(1, 7, size=(10000, 2)).

NumPy

# Import numpy and create the dice rolls array
# Your code here

Hint

Use np.random.randint to generate random integers from 1 to 6 for two dice, 10000 times.

2

Set the target sum for the dice

Create a variable called target_sum and set it to 7 to represent the sum we want to check for.

NumPy

import numpy as np
rolls = np.random.randint(1, 7, size=(10000, 2))
# Set the target sum to 7
# Your code here

Hint

Just assign the number 7 to a variable named target_sum.

3

Calculate how many rolls sum to the target

Create a variable called count_target that counts how many rows in rolls have a sum equal to target_sum. Use np.sum and boolean indexing with rolls.sum(axis=1) == target_sum.

NumPy

import numpy as np
rolls = np.random.randint(1, 7, size=(10000, 2))
target_sum = 7
# Count how many rolls sum to 7
# Your code here

Hint

Use rolls.sum(axis=1) to get sums of each roll, then compare to target_sum, then sum the True values.

4

Calculate and print the estimated probability

Calculate the estimated probability by dividing count_target by the total number of rolls (10000). Store it in probability. Then print the probability with print(probability).

NumPy

import numpy as np
rolls = np.random.randint(1, 7, size=(10000, 2))
target_sum = 7
count_target = np.sum(rolls.sum(axis=1) == target_sum)
# Calculate and print the probability
# Your code here

Hint

Divide count_target by 10000 and print the result. The output should be a decimal number close to 0.17.

Practice

1. What is the main purpose of a Monte Carlo simulation in data science?

easy

A. To create visual charts

B. To sort data quickly

C. To estimate results using random sampling

D. To clean missing data

Solution

1. Step 1: Understand Monte Carlo simulation basics

   Monte Carlo simulation uses random sampling to estimate results when exact calculation is hard.

2. Step 2: Identify the main purpose

   It helps estimate outcomes by simulating many random scenarios.

3. Final Answer:

   To estimate results using random sampling -> Option C

4. Quick Check:

   Monte Carlo = random sampling estimation [OK]

Hint: Monte Carlo = random sampling for estimation [OK]

Common Mistakes:

• Confusing Monte Carlo with data sorting
• Thinking it cleans data
• Assuming it creates charts

2. Which numpy function is commonly used to generate random samples for Monte Carlo simulations?

easy

A. numpy.random.rand()

B. numpy.array()

C. numpy.mean()

D. numpy.sort()

Solution

1. Step 1: Identify numpy functions for randomness

   numpy.random.rand() generates random numbers between 0 and 1, useful for sampling.

2. Step 2: Compare with other options

   numpy.array() creates arrays, numpy.mean() calculates average, numpy.sort() sorts data; none generate random samples.

3. Final Answer:

   numpy.random.rand() -> Option A

4. Quick Check:

   Random samples = numpy.random.rand() [OK]

Hint: Random samples come from numpy.random.rand() [OK]

Common Mistakes:

• Choosing numpy.array() instead of random function
• Confusing mean or sort with random sampling
• Using functions that don't generate randomness

3. What is the output of this code snippet?

import numpy as np
np.random.seed(0)
samples = np.random.rand(5)
mean_val = np.mean(samples)
print(round(mean_val, 2))

medium

A. 0.50

B. 0.57

C. 0.60

D. 0.45

Solution

1. Step 1: Generate 5 random samples with seed 0

   Using np.random.seed(0) fixes randomness. np.random.rand(5) produces [0.5488135, 0.71518937, 0.60276338, 0.54488318, 0.4236548].

2. Step 2: Calculate mean and round

   Sum = 2.83530423, mean = 0.567060846, round(mean_val, 2) = 0.57.

3. Final Answer:

   0.57 -> Option B

4. Quick Check:

   Mean of samples = 0.57 [OK]

Hint: Seed fixes random values; mean rounds to 0.57 [OK]

Common Mistakes:

• Not setting seed causing different outputs
• Rounding incorrectly
• Calculating sum or mean wrongly

4. Identify the error in this Monte Carlo simulation code:

import numpy as np
samples = np.random.rand(1000)
result = sum(samples) / 100
print(result)

medium

A. Using np.random.rand() instead of np.random.randint()

B. Not setting random seed

C. Missing np.mean() function

D. Dividing by 100 instead of number of samples

Solution

1. Step 1: Check calculation of average

   sum(samples) sums 1000 values, but dividing by 100 underestimates average.

2. Step 2: Correct divisor

   To get average, divide sum by 1000 (number of samples), not 100.

3. Final Answer:

   Dividing by 100 instead of number of samples -> Option D

4. Quick Check:

   Average = sum / number of samples [OK]

Hint: Divide sum by sample count, not fixed number [OK]

Common Mistakes:

• Dividing by wrong number
• Confusing random functions
• Ignoring seed importance

5. You want to estimate the probability that a random point inside a 1x1 square falls within a circle of radius 0.5 centered at (0.5, 0.5) using Monte Carlo simulation. Which numpy code correctly estimates this probability?

hard

A. points = np.random.rand(10000, 2)
dist = np.sqrt((points[:,0]-0.5)**2 + (points[:,1]-0.5)**2)
prob = np.sum(dist <= 0.5) / 10000
print(prob)

B. points = np.random.rand(10000)
dist = np.sqrt((points-0.5)**2)
prob = np.sum(dist <= 0.5) / 10000
print(prob)

C. points = np.random.rand(2, 10000)
dist = np.sqrt((points[:,0]-0.5)**2 + (points[:,1]-0.5)**2)
prob = np.sum(dist <= 0.5) / 10000
print(prob)

D. points = np.random.randint(0, 1, (10000, 2))
dist = np.sqrt((points[:,0]-0.5)**2 + (points[:,1]-0.5)**2)
prob = np.sum(dist <= 0.5) / 10000
print(prob)

Solution

1. Step 1: Generate 2D points inside 1x1 square

   np.random.rand(10000, 2) creates 10000 points with x,y in [0,1].

2. Step 2: Calculate distance from center (0.5,0.5)

   Distance formula sqrt((x-0.5)^2 + (y-0.5)^2) applied to each point.

3. Step 3: Count points inside circle and estimate probability

   Count points with distance ≤ 0.5, divide by total points for probability.

4. Final Answer:

   np.random.rand(10000, 2) with column indexing for coordinates -> Option A

5. Quick Check:

   2D points + distance check = probability [OK]

Hint: Use 2D random points and distance formula [OK]

Common Mistakes:

• Using 1D points instead of 2D
• Wrong shape for points array
• Using randint instead of rand for floats