American·Exotic 옵션 가격결정: 조기행사와 경로의존성 모델링

조기행사와 경로의존성이 가격결정을 바꾸는 지점

기초자산 (S)가 GBM 가정 아래 (dS/S = (r−q)dt + σ dW)를 따른다면, 옵션 가치는 위험중립 측도에서의 기대 할인 현가로 계산한다. 이를 이산화한 뒤 트리, 유한차분, 몬테카를로 기법으로 평가할 수 있다.

American 옵션은 만기 이전에도 행사할 수 있다. 따라서 각 시점에서 조기행사 가치와 계속 보유할 때의 가치를 비교하는 임계 경계가 생긴다. 비배당 주식의 American 콜은 일반적으로 조기행사가 비최적이다.

Exotic 옵션은 계약 조건에 경로 특성이 들어간다. Barrier 옵션은 장벽에 닿는지 여부로 계약이 성립하거나 소멸하며, Knock-in과 Knock-out으로 구분된다. 연속 또는 이산 모니터링 방식, 그리고 브라운 브리지 보정이 가격에 영향을 준다. Asian 옵션은 산술 또는 기하 평균을 기준으로 페이오프를 정하므로 변동성 민감도는 낮아질 수 있지만 헤징은 더 어려워진다.

American 옵션에서는 Binomial 트리와 LSM이 대표적이다. Binomial은 역귀환으로 조기행사를 비교하는 방식이고, LSM은 시뮬레이션 경로에서 회귀로 조건부 기대가치를 근사해 행사 여부를 정한다.

입력값과 알고리즘 선택

평가 입력에는 (S0), (K), (r), (q), (σ), (T), 모니터링 스텝 (N)이 포함된다. 실제 확장에서는 배당·금리 커브와 변동성 구조의 평면·스마일을 반영해야 하며, 동일한 (σ)와 곡선을 써 캘리브레이션의 일관성을 유지해야 한다.

소형 문제에서는 구조가 명료하고 조기행사를 직접 확인할 수 있는 Binomial이 적합하다. 고차원 또는 경로의존 문제가 커지면 LSM이 더 확장하기 쉽다. Barrier와 Asian 옵션은 Monte Carlo를 기본으로 두고, Barrier에는 브리지 보정, Asian에는 분산 감소 기법을 함께 적용한다.

벡터화, 배치 처리, GPU 가속은 (O(Npaths×Nsteps))의 선형 확장성을 위한 기반이다. 운영 환경에서는 난수 시드 재현성, 실패 경로와 NaN 감지, 로깅과 체크포인트도 평가 절차에 포함한다.

가격 산출에서 검증까지의 흐름

⤢✕

방법	성능(시간)	확장성	일관성(정확도)	안정성	운영 편의
Binomial 트리	소~중 규모 우수	스텝 증가 시 O(N^2) 제약	조기행사 정확	구조적 안정성 높음	구현·검증 용이
LSM MC	대규모 경로 병렬에 강함	선형 확장, GPU 적합	회귀 기저 의존	회귀 불안정 위험	범용성 높음
MC(Barrier/Asian)	중	선형 확장	이산화/브리지에 민감	장벽 근처 민감	구현 단순, 정교화 필요

이산화와 회귀 오차를 다루는 방법

Barrier 옵션은 시간 이산화 바이어스에 특히 민감하다. 브라운 브리지 보정을 사용하고 (T/dt)가 충분히 커지도록 스텝 수를 늘려야 한다.

LSM은 회귀 기저 선택과 과적합 방지가 핵심이다. 라게르 같은 직교 기저, 정규화, QR 또는 정규화 회귀, L2 정규화를 사용할 수 있다. 대칭 난수, 저분산 시퀀스, 공분산 일치 테스트로 경로 품질도 확인한다.

유효성 검증에서는 ITM 표본 수 임계값, (R^2), 조건수를 모니터링한다. 무배당 콜처럼 조기행사가 비최적인 상황도 별도 점검 대상이다.

정밀도와 비용의 균형은 상품에 따라 다르다. Barrier는 스텝 증가가 지배적인 효과를 낸다. Asian은 경로 수 증가와 컨트롤 베리엇을 함께 쓰는 방식이 권장된다. LSM의 기저 수는 과소모형 편향과 과적합 분산 사이의 선택이며, 3~5개 다항·라게르 혼합을 권장한다. 시드를 고정하고 K-fold 리샘플로 신뢰구간을 보고하면 재현성과 샘플 다양성을 함께 다룰 수 있다.

벡터화, 행렬 연속 메모리 레이아웃, 단정도·배정도 선택, GPU·멀티프로세스는 구현 단계의 주요 판단 항목이다.

평가가 필요한 상품과 리스크 업무

주식형 American 풋의 헤지와 실사에서는 변동성이 급등할 때 조기행사 경계를 추적하고 헤지 감마를 관리한다. Autocall과 KO 구조화채권은 장벽 모니터링 빈도와 리베이트를 반영한 뒤 리스크 시나리오를 배치 평가한다. 원자재 Asian 옵션에서는 평균 기반 가격 안정화와 장기 헤지·익스포저 측정이 VaR/XVA와 연결된다.

Python으로 구현하는 Binomial, LSM, Monte Carlo

전제조건: Python 3.10+, numpy 1.23+, 옵션: numba/GPU 미사용 단일 스레드 참조 구현. 위험중립 드리프트 r−q 적용.

# python 3.10+, numpy 1.23+
import numpy as np

def american_binomial(S0, K, r, q, sigma, T, steps, option='put'):
    dt = T / steps
    u = np.exp(sigma * np.sqrt(dt))
    d = 1 / u
    disc = np.exp(-r * dt)
    p = (np.exp((r - q) * dt) - d) / (u - d)
    # 노드 가격
    S = S0 * (u ** np.arange(steps, -1, -1)) * (d ** np.arange(0, steps + 1))
    # 만기 페이오프
    if option == 'call':
        V = np.maximum(S - K, 0.0)
    else:
        V = np.maximum(K - S, 0.0)
    # 역귀환
    for n in range(steps - 1, -1, -1):
        S = S0 * (u ** np.arange(n, -1, -1)) * (d ** np.arange(0, n + 1))
        V = disc * (p * V[:n+1] + (1 - p) * V[1:n+2])
        exercise = (S - K) if option == 'call' else (K - S)
        V = np.maximum(V, exercise)
    return float(V[0])

def _simulate_paths(S0, r, q, sigma, T, steps, paths, antithetic=True, seed=42):
    rng = np.random.default_rng(seed)
    dt = T / steps
    drift = (r - q - 0.5 * sigma**2) * dt
    vol = sigma * np.sqrt(dt)
    m = paths // 2 if antithetic else paths
    Z = rng.standard_normal(size=(m, steps))
    if antithetic:
        Z = np.vstack([Z, -Z])
    S = np.empty((Z.shape[0], steps + 1))
    S[:, 0] = S0
    for t in range(1, steps + 1):
        S[:, t] = S[:, t-1] * np.exp(drift + vol * Z[:, t-1])
    return S

def american_lsm(S0, K, r, q, sigma, T, steps, paths, option='put', seed=42):
    S = _simulate_paths(S0, r, q, sigma, T, steps, paths, antithetic=True, seed=seed)
    dt = T / steps
    disc = np.exp(-r * dt)
    # 페이오프
    if option == 'call':
        payoff = np.maximum(S - K, 0.0)
    else:
        payoff = np.maximum(K - S, 0.0)
    V = payoff[:, -1].copy()
    for t in range(steps - 1, 0, -1):
        itm = payoff[:, t] > 0
        X = S[itm, t]
        if X.size >= 3:  # 최소 표본
            Y = V[itm] * disc
            # 기저: [1, S, S^2]
            A = np.vstack([np.ones_like(X), X, X**2]).T
            # QR로 안정화된 최소제곱
            Q, R = np.linalg.qr(A)
            beta = np.linalg.solve(R, Q.T @ Y)
            continuation = (beta[0] + beta[1] * X + beta[2] * X**2)
            exercise_val = payoff[itm, t]
            exercise_now = exercise_val > continuation
            V[itm] = np.where(exercise_now, exercise_val, Y)
            V[~itm] = V[~itm] * disc
        else:
            V = V * disc
    price = np.exp(-r * 0.0) * np.mean(V)  # t0
    stderr = np.std(V) / np.sqrt(V.size)
    return float(price), float(stderr)

def barrier_option_mc(S0, K, H, r, q, sigma, T, steps, paths, option='call',
                      barrier='up-and-out', rebate=0.0, seed=42):
    S = _simulate_paths(S0, r, q, sigma, T, steps, paths, antithetic=True, seed=seed)
    crossed = None
    if 'up' in barrier:
        crossed = np.max(S, axis=1) >= H
    else:
        crossed = np.min(S, axis=1) <= H
    if 'out' in barrier:
        alive = ~crossed
    else:
        alive = crossed
    ST = S[:, -1]
    payoff = np.where(option == 'call', np.maximum(ST - K, 0.0), np.maximum(K - ST, 0.0))
    payoff = np.where(alive, payoff, rebate)
    price = np.exp(-r * T) * np.mean(payoff)
    stderr = np.exp(-r * T) * np.std(payoff) / np.sqrt(payoff.size)
    return float(price), float(stderr)

def asian_option_mc(S0, K, r, q, sigma, T, steps, paths, option='call',
                    average='arithmetic', seed=42):
    S = _simulate_paths(S0, r, q, sigma, T, steps, paths, antithetic=True, seed=seed)
    if average == 'geometric':
        A = np.exp(np.mean(np.log(S[:, 1:]), axis=1))
    else:
        A = np.mean(S[:, 1:], axis=1)
    payoff = np.where(option == 'call', np.maximum(A - K, 0.0), np.maximum(K - A, 0.0))
    price = np.exp(-r * T) * np.mean(payoff)
    stderr = np.exp(-r * T) * np.std(payoff) / np.sqrt(payoff.size)
    return float(price), float(stderr)

if __name__ == "__main__":
    S0, K, r, q, sigma, T = 100.0, 100.0, 0.03, 0.0, 0.2, 1.0
    # Binomial American put
    print("American Put (Binomial):", american_binomial(S0, K, r, q, sigma, T, steps=500, option='put'))
    # LSM American put
    p, se = american_lsm(S0, K, r, q, sigma, T, steps=50, paths=100_000, option='put', seed=7)
    print(f"American Put (LSM): {p:.4f} ± {1.96*se:.4f}")
    # Up-and-Out Barrier Call
    pb, seb = barrier_option_mc(S0, K, H=120, r=r, q=q, sigma=sigma, T=T, steps=252, paths=200_000,
                                option='call', barrier='up-and-out', rebate=0.0, seed=11)
    print(f"UO Barrier Call: {pb:.4f} ± {1.96*seb:.4f}")
    # Arithmetic Asian Call
    pa, sea = asian_option_mc(S0, K, r, q, sigma, T, steps=252, paths=200_000,
                              option='call', average='arithmetic', seed=13)
    print(f"Asian Call (Arithmetic): {pa:.4f} ± {1.96*sea:.4f}")

LSM의 무배당 콜은 조기행사가 비최적이므로 European 가격과의 차이가 미미해야 한다. 이를 회귀 이상치 탐지 지표로 활용할 수 있다. Barrier 근접 구간에서는 스텝 수를 국소적으로 늘리는 Adaptive time-stepping을 고려한다. 신뢰구간은 95% CI = 가격 ± 1.96×표준오차로 보고한다.

브리지 보정과 LSM 안정화는 동일 경로수 대비 경험치 기준으로 Barrier/조기행사 바이어스를 20~~60% 축소할 수 있으며, 모델·파라미터에 의존한다. LSM과 MC를 병렬화하면 노드 수 증가 없이 경로 수를 선형으로 확장할 수 있고, GPU 적용 시 5~~20배 가속을 기대할 수 있다. 재현성, 모니터링, 오류 격리는 야간 배치 실패율 감소와 디버깅 시간 단축으로 이어진다.