Fundamentos de la simulación de Monte Carlo
Estime pi y otras cantidades mediante muestreo aleatorio repetido.
Fundamentos de la simulación de Monte Carlo es una lección gratuita de R Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de R Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de R Academy incluye 4 lecciones en total.
¿Qué es Monte Carlo?
La simulación de Monte Carlo utiliza muestreos aleatorios repetidos para estimar cantidades difíciles de calcular analíticamente. Recibe su nombre del casino de Mónaco y se utiliza en finanzas, física, estadística e IA para integración, optimización e inferencia.
# Core idea: approximate deterministic quantities
# using random sampling and the Law of Large Numbers
# Example: estimate probability that sum of two dice > 8
set.seed(42)
n <- 10000
die1 <- sample(1:6, n, replace = TRUE)
die2 <- sample(1:6, n, replace = TRUE)
total <- die1 + die2
# Monte Carlo estimate
mc_estimate <- mean(total > 8)
cat('MC estimate P(sum > 8):', mc_estimate, '\n')
# Exact probability
exact <- sum(outer(1:6, 1:6, '+') > 8) / 36
cat('Exact probability:', exact)Estimación de Pi con puntos aleatorios
La demostración clásica de Monte Carlo consiste en colocar puntos aleatoriamente en un cuadrado unitario. La fracción que cae dentro del círculo unitario estima π/4. Cuando n → ∞, la estimación converge a π.
set.seed(42)
n <- 100000
# Random points in [-1, 1] x [-1, 1] unit square
x <- runif(n, -1, 1)
y <- runif(n, -1, 1)
# Check if inside unit circle: x^2 + y^2 <= 1
inside <- (x^2 + y^2) <= 1
# Pi estimate: fraction inside * area of square
pi_estimate <- 4 * mean(inside)
cat('Pi estimate:', pi_estimate, '\n')
cat('True pi:', pi, '\n')
cat('Error:', abs(pi_estimate - pi))Estimación del valor esperado
Integración de Monte Carlo: E[f(X)] ≈ (1/n) Σ f(Xᵢ), donde X₁,...,Xₙ son extracciones iid. Para integrar g(x) de a a b: extraiga x de Uniform(a,b); entonces E[g(X)] ≈ (b-a) * mean(g(samples)).
set.seed(42)
# Estimate integral of sin(x) from 0 to pi
# Exact value = 2
n <- 50000
x_samples <- runif(n, min = 0, max = pi)
integrand_vals <- sin(x_samples)
# MC estimate = (b-a) * mean(f(x))
mc_integral <- pi * mean(integrand_vals) # (pi - 0) * mean
cat('MC estimate of integral:', mc_integral, '\n')
cat('Exact value: 2\n')
cat('Error:', abs(mc_integral - 2), '\n')
# Standard error of the estimate
se <- pi * sd(integrand_vals) / sqrt(n)
cat('Standard error:', se)replicate() para simulaciones repetidas
replicate(n, expr) es la función integrada de R para ejecutar una simulación n veces y recopilar los resultados. Es más clara que un bucle for para simulaciones sencillas y devuelve un vector o una matriz.
set.seed(42)
# Simulate sample mean of 30 N(0,1) draws
# Repeat 10000 times to study sampling distribution
sample_means <- replicate(10000, {
x <- rnorm(30) # sample of 30
mean(x) # compute mean
})
# Central Limit Theorem: sample mean ~ N(0, 1/sqrt(30))
mean(sample_means) # ~0
sd(sample_means) # ~1/sqrt(30) = 0.183
# 95% CI width
diff(quantile(sample_means, c(0.025, 0.975)))
# Compare to theoretical
2 * 1.96 / sqrt(30)Demostración de la ley de los grandes números
La ley de los grandes números establece que la media muestral converge a la media verdadera a medida que aumenta n. Observar esta convergencia en R demuestra por qué funciona Monte Carlo y con qué rapidez se estabilizan las estimaciones.
set.seed(42)
# Rolling a fair die: true mean = 3.5
n_max <- 10000
rolls <- sample(1:6, n_max, replace = TRUE)
cumulative_means <- cumsum(rolls) / seq_along(rolls)
# Show convergence at different sample sizes
ns <- c(10, 100, 1000, 5000, 10000)
results <- data.frame(
n = ns,
mean = cumulative_means[ns],
error = abs(cumulative_means[ns] - 3.5)
)
print(results)
# Error decreases as n increasesReducción de la varianza: variables antitéticas
Utilice muestras uniformes u y sus complementos (1-u) como un par antitético. Su correlación negativa reduce la varianza del estimador hasta un 50 % con el mismo número de evaluaciones de la función.
set.seed(42)
n <- 1000
# Standard MC: estimate E[exp(U)] where U~Uniform(0,1)
# True value = e - 1 = 1.718282
u <- runif(n)
mc_std <- mean(exp(u))
# Antithetic variates: use u AND 1-u
u_anti <- runif(n/2)
mc_anti <- mean((exp(u_anti) + exp(1 - u_anti)) / 2)
cat('True value:', exp(1) - 1, '\n')
cat('Standard MC:', mc_std, '\n')
cat('Antithetic MC:', mc_anti, '\n')
# Variance comparison
var_std <- var(exp(runif(10000)))
var_anti <- var((exp(runif(5000)) + exp(1 - runif(5000)))/2)
cat('Variance ratio (anti/std):', var_anti/var_std)Variables de control
Una variable de control es una función con esperanza conocida y correlacionada con la variable objetivo. Réstela, escalada adecuadamente, para reducir la varianza. Ejemplo clásico: estimar E[f(X)] utilizando g(X), que está correlacionada y cuya media es conocida.
set.seed(42)
n <- 5000
# Estimate E[exp(U)] where U~Uniform(0,1)
# True: e - 1 = 1.71828
# Control variate: g(U) = U, E[U] = 0.5
u <- runif(n)
f_vals <- exp(u) # target
g_vals <- u # control variate
# Optimal coefficient c = -Cov(f,g)/Var(g)
c_star <- -cov(f_vals, g_vals) / var(g_vals)
# Control variate estimator
mc_cv <- mean(f_vals + c_star * (g_vals - 0.5))
cat('Standard MC:', mean(f_vals), '\n')
cat('Control variate MC:', mc_cv, '\n')
cat('True value:', exp(1) - 1)
# Variance reduction factor
var(f_vals) / var(f_vals + c_star * (g_vals - 0.5))Monte Carlo para la estimación de probabilidades
Monte Carlo es especialmente eficaz para estimar probabilidades complejas que resultan intratables analíticamente. Simule el proceso aleatorio muchas veces y calcule la fracción de ocasiones en las que ocurre el evento.
set.seed(123)
# Birthday problem: P(at least 2 people share birthday)
# in a group of n people
birtday_collision <- function(n_people) {
birthdays <- sample(1:365, n_people, replace = TRUE)
length(birthdays) != length(unique(birthdays))
}
# Estimate for groups of size 10, 23, 50
sizes <- c(10, 23, 50)
for (sz in sizes) {
p <- mean(replicate(5000, birt_day_collision <- {
bd <- sample(1:365, sz, replace = TRUE)
length(bd) != length(unique(bd))
}))
cat('n =', sz, ': P(collision) ~', round(p, 3), '\n')
}Simulación del movimiento browniano geométrico
Los precios de las acciones suelen modelarse mediante el movimiento browniano geométrico: S(t+dt) = S(t) * exp((μ - σ²/2)dt + σ√dt * Z), donde Z~N(0,1). Monte Carlo genera trayectorias de precios para valorar opciones.
set.seed(42)
S0 <- 100 # initial price
mu <- 0.05 # annual drift
sigma <- 0.2 # annual volatility
T <- 1 # 1 year
n_steps <- 252 # daily steps
dt <- T / n_steps
# Simulate one price path
Z <- rnorm(n_steps)
log_returns <- (mu - 0.5 * sigma^2) * dt + sigma * sqrt(dt) * Z
price_path <- S0 * exp(cumsum(log_returns))
cat('Final price:', round(price_path[n_steps], 2), '\n')
cat('Min price:', round(min(price_path), 2), '\n')
cat('Max price:', round(max(price_path), 2))Valoración de opciones mediante MC
Valore una opción de compra europea mediante Monte Carlo: simule muchos precios finales de la acción, calcule los pagos max(S_T - K, 0) y, después, descuente el pago medio mediante e^(-rT).
set.seed(42)
S0 <- 100; K <- 105; r <- 0.05; sigma <- 0.2; T <- 1
n_sim <- 50000
# Final stock prices under risk-neutral measure
Z <- rnorm(n_sim)
ST <- S0 * exp((r - 0.5 * sigma^2) * T + sigma * sqrt(T) * Z)
# Call option payoff
payoff <- pmax(ST - K, 0)
# Discounted expected payoff
call_price <- exp(-r * T) * mean(payoff)
se <- exp(-r * T) * sd(payoff) / sqrt(n_sim)
cat('Call price:', round(call_price, 4), '\n')
cat('95% CI: [', round(call_price - 1.96*se, 4),
',', round(call_price + 1.96*se, 4), ']')Tasa de convergencia de MC
Monte Carlo converge a una tasa O(1/√n): reducir el error a la mitad requiere 4× más muestras. El error estándar de la estimación de MC es σ/√n, donde σ es la desviación estándar del integrando.
set.seed(42)
# Demonstrate MC convergence for pi estimation
estimate_pi <- function(n) {
x <- runif(n, -1, 1)
y <- runif(n, -1, 1)
4 * mean(x^2 + y^2 <= 1)
}
# Sample sizes: powers of 10
ns <- 10^(1:5)
estimates <- sapply(ns, function(n) {
set.seed(42)
estimate_pi(n)
})
data.frame(
n = ns,
pi_estimate = round(estimates, 5),
error = round(abs(estimates - pi), 5)
)Comprobación rápida
Compruebe su comprensión de los fundamentos de la simulación de Monte Carlo.
Resumen: fundamentos de Monte Carlo
Ideas clave: Monte Carlo estima cantidades calculando el promedio de muchas muestras aleatorias. Utilice replicate() para realizar simulaciones repetidas. La ley de los grandes números garantiza la convergencia. El error se escala como 1/√n: multiplique por cuatro las muestras para reducir el error a la mitad. Las técnicas de reducción de la varianza (variables antitéticas y variables de control) mejoran la eficiencia sin utilizar más muestras. Aplicaciones: integración, estimación de probabilidades, valoración de opciones y simulación.
set.seed(42)
# Monte Carlo template:
# 1. Define simulation function
simulate_once <- function() {
x <- runif(1, -1, 1)
y <- runif(1, -1, 1)
(x^2 + y^2) <= 1
}
# 2. Replicate many times
n <- 10000
results <- replicate(n, simulate_once())
# 3. Estimate quantity of interest
pi_mc <- 4 * mean(results)
# 4. Quantify uncertainty
se <- 4 * sd(results) / sqrt(n)
cat('Pi:', pi_mc, '+/-', round(1.96*se, 4))Preguntas frecuentes
¿La lección «Fundamentos de la simulación de Monte Carlo» es gratis?
Sí — el texto completo de «Fundamentos de la simulación de Monte Carlo» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de R Academy, actualiza a CoddyKit PRO. El curso de R Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Fundamentos de la simulación de Monte Carlo»?
Estime pi y otras cantidades mediante muestreo aleatorio repetido. Practicas R Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar R Academy?
No se requiere experiencia previa. R Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.
¿Cuánto tiempo toma la lección «Fundamentos de la simulación de Monte Carlo»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de R Academy?
Sí. Cada lección de R Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- set.seed() y reproducibilidad
- Generación de distribuciones aleatorias
- Fundamentos de la simulación de Monte Carlo
- Remuestreo bootstrap en R