R Academy · Lektion

Grundlagen der Monte-Carlo-Simulation

Schätzen Sie π und andere Größen durch wiederholte Zufallsstichproben

Grundlagen der Monte-Carlo-Simulation ist eine kostenlose R Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des R Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist Monte Carlo?

Bei einer Monte-Carlo-Simulation werden wiederholt Zufallsstichproben gezogen, um Größen zu schätzen, die analytisch nur schwer zu berechnen sind. Benannt nach dem Casino in Monaco wird diese Methode in der Finanzwirtschaft, Physik, Statistik und KI für Integration, Optimierung und Inferenz eingesetzt.

# 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)

Pi mit Zufallspunkten schätzen

Die klassische Monte-Carlo-Demonstration: Platzieren Sie Punkte zufällig in einem Einheitsquadrat. Der Anteil der Punkte innerhalb des Einheitskreises schätzt π/4. Für n → ∞ konvergiert die Schätzung gegen π.

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))

Erwartungswerte schätzen

Monte-Carlo-Integration: E[f(X)] ≈ (1/n) Σ f(Xᵢ), wobei X₁,...,Xₙ unabhängig und identisch verteilte Ziehungen sind. Um g(x) von a bis b zu integrieren, ziehen Sie x aus Uniform(a,b); dann gilt 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() für wiederholte Simulationen

replicate(n, expr) ist die integrierte R-Funktion zum n-maligen Ausführen einer Simulation und Sammeln der Ergebnisse. Für einfache Simulationen ist sie übersichtlicher als eine for-Schleife und gibt einen Vektor oder eine Matrix zurück.

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)

Demonstration des Gesetzes der großen Zahlen

Das Gesetz der großen Zahlen besagt, dass der Stichprobenmittelwert für wachsendes n gegen den wahren Mittelwert konvergiert. Wenn Sie diese Konvergenz in R beobachten, wird deutlich, warum Monte Carlo funktioniert und wie schnell sich Schätzungen stabilisieren.

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 increases

Varianzreduktion: Antithetische Variablen

Verwenden Sie gleichverteilte Stichproben u und ihre Komplementwerte (1-u) als antithetisches Paar. Ihre negative Korrelation reduziert die Varianz des Schätzers bei gleicher Anzahl von Funktionsauswertungen um bis zu 50 %.

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)

Kontrollvariablen

Eine Kontrollvariable ist eine Funktion mit bekanntem Erwartungswert, die mit dem Zielwert korreliert. Ziehen Sie sie – skaliert – ab, um die Varianz zu reduzieren. Ein klassisches Beispiel ist die Schätzung von E[f(X)] mithilfe des korrelierten g(X), dessen Mittelwert bekannt ist.

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 zur Wahrscheinlichkeitsschätzung

Monte-Carlo-Methoden eignen sich besonders gut zum Schätzen komplexer Wahrscheinlichkeiten, die analytisch nicht handhabbar sind. Simulieren Sie den Zufallsprozess viele Male und berechnen Sie den Anteil der Durchläufe, in denen das Ereignis eintritt.

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')
}

Geometrische Brownsche Bewegung simulieren

Aktienkurse werden häufig als geometrische Brownsche Bewegung modelliert: S(t+dt) = S(t) * exp((μ - σ²/2)dt + σ√dt * Z), wobei Z~N(0,1) gilt. Monte Carlo erzeugt Preispfade für die Optionsbewertung.

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))

Monte-Carlo-Bewertung von Optionen

Bewerten Sie eine europäische Call-Option mithilfe von Monte Carlo: Simulieren Sie viele Aktienendkurse, berechnen Sie die Auszahlungen max(S_T - K, 0) und diskontieren Sie anschließend die durchschnittliche Auszahlung mit 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), ']')

Konvergenzrate von MC

Monte-Carlo-Methoden konvergieren mit der Rate O(1/√n): Um den Fehler zu halbieren, benötigen Sie viermal so viele Stichproben. Der Standardfehler der MC-Schätzung beträgt σ/√n, wobei σ die Standardabweichung des Integranden ist.

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)
)

Kurze Überprüfung

Testen Sie Ihr Verständnis der Grundlagen von Monte-Carlo-Simulationen.

Zusammenfassung: Grundlagen von Monte Carlo

Die wichtigsten Punkte: Monte-Carlo-Methoden schätzen Größen, indem sie über viele Zufallsstichproben mitteln. Verwenden Sie replicate() für wiederholte Simulationen. Das Gesetz der großen Zahlen garantiert die Konvergenz. Der Fehler skaliert mit 1/√n – vervierfachen Sie die Anzahl der Stichproben, um den Fehler zu halbieren. Verfahren zur Varianzreduktion (antithetische Variablen, Kontrollvariablen) verbessern die Effizienz ohne zusätzliche Stichproben. Anwendungen sind Integration, Wahrscheinlichkeitsschätzung, Optionsbewertung und Simulation.

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))

Häufig gestellte Fragen

Ist die Lektion „Grundlagen der Monte-Carlo-Simulation“ kostenlos?

Ja — der vollständige Text von „Grundlagen der Monte-Carlo-Simulation“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des R Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Grundlagen der Monte-Carlo-Simulation“?

Schätzen Sie π und andere Größen durch wiederholte Zufallsstichproben Du übst R Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um R Academy zu starten?

Keine Vorkenntnisse erforderlich. R Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Grundlagen der Monte-Carlo-Simulation“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser R Academy-Lektion Code schreiben und ausführen?

Ja. Jede R Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu R Academy