Michael Brenndoerfer | Data & AI, Private Equity, Technology

Michael Brenndoerfer

Variance Reduction Techniques in Simulation › Computational Efficiency Comparison

Michael BrenndoerferDecember 3, 20252 min read

Quantitative FinanceAll chapters

Part 6 of 15Numerical Methods for Derivative Pricing

Chapter 35Variance Reduction Techniques in Simulation › Computational Efficiency Comparison

Reading section 8 of 12 · Computational Efficiency Comparison · 2 minSection 8 of 12 · 2 min

Section 8 of 12 · 2 min read

Variance Reduction Techniques in Simulation › Computational Efficiency ComparisonOne section · Sections in this chapter8 / 12 ↓

Sections in this chapter12

Reading tools Definitions & inline links

Choose your expertise level to adjust how many terms are explained. Beginners see more tooltips, experts see fewer to maintain reading flow. Hover over underlined terms for instant definitions.

Article links

Make inline references clickable

When choosing a variance reduction technique, we must consider variance reduction alongside computational overhead. Some methods (like delta-based control variates) require additional calculations that increase the cost per simulation.

In[33]:

Code

import time


def benchmark_method(method_func, n_runs=5, **kwargs):
    """Benchmark a pricing method's execution time."""
    times = []
    for _ in range(n_runs):
        start = time.time()
        method_func(**kwargs)
        times.append(time.time() - start)
    return np.mean(times), np.std(times)

In[34]:

Code

# Benchmark each method
n_bench = 100000
params = {
    "S0": S0,
    "K": K,
    "T": T,
    "r": r,
    "sigma": sigma,
    "n_simulations": n_bench,
}


# Standard MC
def run_standard():
    return monte_carlo_european_call(**params, antithetic=False)


t_std, _ = benchmark_method(run_standard)
_, se_std = run_standard()


# Antithetic
def run_antithetic():
    return monte_carlo_european_call(**params, antithetic=True)


t_av, _ = benchmark_method(run_antithetic)
_, se_av = run_antithetic()


# Control Variate
def run_cv():
    return monte_carlo_call_control_variate(**params)


t_cv, _ = benchmark_method(run_cv)
res_cv = run_cv()
se_cv = res_cv["se_cv"]


# Stratified
def run_strat():
    return monte_carlo_call_stratified(**params, n_strata=1000)


t_strat, _ = benchmark_method(run_strat)
_, se_strat = run_strat()

Out[35]:

Console

Computational Efficiency Analysis
=================================================================
Method               Time (ms)    Std Error    VRF        Efficiency
-----------------------------------------------------------------
Standard MC              3.43     0.04659      1.00x      1.00x
Antithetic               1.81     0.03288      2.01x      3.80x
Control Variate          5.14     0.01774      6.90x      4.60x
Stratified               8.29     0.04654      1.00x      0.41x

The efficiency metric accounts for both variance reduction and computational cost. A method with high VRF but also high computational overhead may not be the most efficient choice.