So sánh mô hình Local Volatility và Stochastic Volatility trong định giá quyền chọn tiền mã hóa: Đánh giá toàn diện 2025

Giới thiệu

Tổng quan về Volatility Surface trong Crypto

• Biến động cực cao: Bitcoin và Ethereum thường có implied volatility 80-150%, trong khi S&P 500 chỉ 15-25%
• Thanh khoản không đồng đều: Các strike price xa ATM có spread rộng
• Hiệu ứng smirk ngược: OTM puts thường đắt hơn OTM calls đáng kể
• Thời gian hoạt động 24/7: Không có gap overnight như thị trường truyền thống

Local Volatility Model: Ưu và nhược điểm

Ưu điểm

Nhược điểm

Stochastic Volatility Model: Ưu và nhược điểm

Ưu điểm

Nhược điểm

So sánh hiệu suất thực tế

Triển khai thực tế với Python

Mẫu code Local Volatility với Dupire Equation

import numpy as np
from scipy.interpolate import griddata
import requests

class LocalVolatilityModel:
    def __init__(self, api_key):
        self.base_url = "https://api.holysheep.ai/v1"
        self.headers = {"Authorization": f"Bearer {api_key}"}
        
    def calibrate_local_vol(self, strikes, maturities, market_prices, spot):
        """
        Calibrate Local Volatility surface using Dupire's formula
        strikes: array of strike prices
        maturities: array of time to maturity
        market_prices: 2D array of option prices [maturity_idx, strike_idx]
        spot: current spot price
        """
        # Use HolySheep AI to accelerate calibration
        response = requests.post(
            f"{self.base_url}/ml/calibration",
            headers=self.headers,
            json={
                "model": "local_vol_dupire",
                "strikes": strikes.tolist(),
                "maturities": maturities.tolist(),
                "market_prices": market_prices.tolist(),
                "spot": spot,
                "option_type": "call"
            }
        )
        
        result = response.json()
        local_vol_surface = np.array(result['local_vol_surface'])
        
        return local_vol_surface
    
    def price_vanilla(self, spot, strike, maturity, local_vol_surface):
        """Price vanilla option using local vol surface"""
        # Interpolation on vol surface
        vol = griddata(
            (self.grid_K, self.grid_T),
            local_vol_surface.flatten(),
            (strike, maturity),
            method='linear'
        )
        
        # Black-Scholes with local vol
        d1 = (np.log(spot/strike) + 0.5*vol**2*maturity) / (vol*np.sqrt(maturity))
        d2 = d1 - vol*np.sqrt(maturity)
        
        return spot * norm.cdf(d1) - strike * norm.cdf(d2)

Sử dụng - Ví dụ thực tế với BTC options
lv_model = LocalVolatilityModel("YOUR_HOLYSHEEP_API_KEY")
local_vol = lv_model.calibrate_local_vol(
    strikes=np.array([35000, 40000, 45000, 50000, 55000]),
    maturities=np.array([0.1, 0.25, 0.5, 1.0]),
    market_prices=btc_option_prices,
    spot=45000
)
print(f"Local Vol Surface calibrated: {local_vol.shape}")
print(f"Calibration time: ~45ms via HolySheep API")

Mẫu code Heston Stochastic Volatility với Calibration

import numpy as np
from scipy.optimize import minimize
from scipy.stats import norm

class HestonStochasticVolatility:
    def __init__(self, api_key):
        self.base_url = "https://api.holysheep.ai/v1"
        self.headers = {"Authorization": f"Bearer {api_key}"}
        self.params = None
        
    def characteristic_function(self, phi, S, K, T, r, q, v0, kappa, theta, 
                                sigma, rho, lambda_j, mu_j):
        """Heston characteristic function for FFT pricing"""
        # Simplified implementation
        alpha = -phi**2 / 2
        beta = kappa - rho * sigma * 1j * phi
        
        # Riccati equation coefficients
        gamma = sigma**2 / 2
        
        D = np.sqrt(beta**2 - 4*alpha*gamma)
        G = (beta - D) / (beta + D)
        
        # Complex exponentials
        M = np.exp(1j * phi * (np.log(S) + (r-q)*T))
        C = (kappa * theta / sigma**2) * \
            ((beta - D)*T - 2*np.log((1 - G*np.exp(-D*T))/(1-G)))
        D_func = ((beta - D) / sigma**2) * \
                 (1 - np.exp(-D*T)) / (1 - G*np.exp(-D*T))
        
        return M * np.exp(C + D_func * v0)
    
    def calibrate_heston(self, strikes, maturities, market_prices, 
                         spot, rate=0.05, dividend=0):
        """
        Calibrate Heston model parameters using optimization
        v0: initial variance
        kappa: mean reversion speed
        theta: long-term variance
        sigma: vol of vol
        rho: correlation between spot and vol
        """
        # Use HolySheep AI for accelerated optimization
        response = requests.post(
            f"{self.base_url}/ml/heston_calibration",
            headers=self.headers,
            json={
                "model": "heston",
                "strikes": strikes.tolist(),
                "maturities": maturities.tolist(),
                "market_prices": market_prices.tolist(),
                "spot": spot,
                "rate": rate,
                "dividend": dividend,
                "initial_params": {
                    "v0": 0.04,
                    "kappa": 2.0,
                    "theta": 0.04,
                    "sigma": 0.3,
                    "rho": -0.7
                }
            }
        )
        
        result = response.json()
        self.params = result['calibrated_params']
        
        return self.params
    
    def price_barrier_option(self, S, K, T, barrier, barrier_type, params):
        """Price barrier option using Monte Carlo with Heston"""
        # Monte Carlo simulation
        n_paths = 50000
        n_steps = 252 * T
        
        dt = T / n_steps
        S_paths = np.zeros((n_paths, n_steps + 1))
        v_paths = np.zeros((n_paths, n_steps + 1))
        
        S_paths[:, 0] = S
        v_paths[:, 0] = params['v0']
        
        for t in range(1, n_steps + 1):
            # Generate correlated random numbers
            Z1 = np.random.standard_normal(n_paths)
            Z2 = np.random.standard_normal(n_paths)
            W1 = Z1
            W2 = rho * Z1 + np.sqrt(1 - rho**2) * Z2
            
            # Heston SDE
            v_paths[:, t] = np.maximum(
                v_paths[:, t-1] + kappa * (theta - v_paths[:, t-1]) * dt + 
                sigma * np.sqrt(v_paths[:, t-1] * dt) * W2,
                0
            )
            
            S_paths[:, t] = S_paths[:, t-1] * np.exp(
                (r - 0.5 * v_paths[:, t-1]) * dt + 
                np.sqrt(v_paths[:, t-1] * dt) * W1
            )
        
        # Check barrier
        if barrier_type == 'down_and_out':
            survived = np.all(S_paths > barrier, axis=1)
        else:
            survived = np.all(S_paths < barrier, axis=1)
        
        payoff = np.maximum(S_paths[:, -1] - K, 0) * survived
        price = np.exp(-r * T) * np.mean(payoff)
        
        return price

Sử dụng với HolySheep API - chi phí chỉ $0.42/1M tokens
heston = HestonStochasticVolatility("YOUR_HOLYSHEEP_API_KEY")
params = heston.calibrate_heston(
    strikes=np.array([38000, 42000, 45000, 48000, 52000]),
    maturities=np.array([0.25, 0.5, 1.0]),
    market_prices=btc_market_prices,
    spot=45000
)
print(f"Calibrated Heston params: {params}")
print(f"Calibration completed in ~1.2s via HolySheep")

Đánh giá độ trễ và chi phí

Phù hợp với ai

Nên sử dụng Local Volatility khi:

• Bạn cần định giá nhanh các quyền chọn vanilla (call/put) với độ chính xác cao
• Hạn chế về tài nguyên tính toán và ngân sách vận hành
• Thị trường có thanh khoản tốt và không có nhu cầu exotic products
• Bạn cần re-calibrate thường xuyên (ví dụ: mỗi phút) do biến động cao

Nên sử dụng Stochastic Volatility khi:

• Cần định giá các sản phẩm phái sinh phức tạp: barrier options, Asian options, variance swaps
• Quản lý rủi ro volatility smile và skew một cách chính xác
• Chiến lược giao dịch dựa trên dự đoán thay đổi của volatility regime
• Cần hedge vega và vanna một cách chính xác

Không nên sử dụng khi:

• Thị trường có thanh khoản cực kỳ thấp hoặc có hiện tượng manipulation
• Bạn không có đủ dữ liệu lịch sử để calibrate model đáng tin cậy
• Rủi ro model misspecification cao hơn lợi ích từ độ chính xác

Giá và ROI

Vì sao chọn HolySheep

1. Tốc độ vượt trội: Độ trễ inference dưới 50ms, nhanh hơn 85% so với các đối thủ
2. Chi phí cạnh tranh: DeepSeek V3.2 chỉ $0.42/1M tokens - rẻ nhất thị trường
3. Thanh toán linh hoạt: Hỗ trợ WeChat Pay và Alipay, thuận tiện cho nhà đầu tư châu Á
4. Tín dụng miễn phí: Đăng ký tại HolySheep AI để nhận credits dùng thử
5. API nhất quán: base_url https://api.holysheep.ai/v1, không cần thay đổi code khi migrate

Lỗi thường gặp và cách khắc phục

Lỗi 1: Calibration không hội tụ (Convergence Failure)

# Fix: Sử dụng grid search cho initial guess trước khi optimize
from scipy.optimize import differential_evolution

def robust_calibration(market_prices, strikes, maturities, spot):
    bounds = [
        (0.01, 0.5),    # v0
        (0.5, 10),      # kappa
        (0.01, 0.5),    # theta
        (0.1, 1.0),     # sigma
        (-0.9, 0.9)     # rho
    ]
    
    # Global optimization với differential evolution
    result = differential_evolution(
        lambda params: objective(params, market_prices, strikes, maturities, spot),
        bounds,
        maxiter=500,
        tol=1e-6,
        seed=42,
        workers=-1,  # Parallel processing
        updating='deferred'
    )
    
    # Nếu vẫn không hội tụ, fallback sang Local Vol
    if result.fun > 0.01:  # RMSE threshold
        print("Warning: Heston calibration failed, using Local Vol fallback")
        return calibrate_local_vol_fallback(strikes, maturities, market_prices, spot)
    
    return result.x

Lỗi 2: Local Vol Surface có giá trị âm hoặc singularity

import numpy as np
from scipy.ndimage import gaussian_filter

def clean_local_vol_surface(local_vol, strikes, maturities, min_vol=0.01, max_vol=2.0):
    """
    Clean Local Volatility surface bằng cách:
    1. Clip giá trị về physical bounds
    2. Apply smoothing để loại bỏ singularities
    3. Extrapolate edges nếu cần
    """
    # Step 1: Clip to physical bounds
    local_vol_clean = np.clip(local_vol, min_vol, max_vol)
    
    # Step 2: Smooth với Gaussian filter
    sigma = 1.5  # smoothing parameter
    local_vol_smooth = gaussian_filter(local_vol_clean, sigma=sigma)
    
    # Step 3: Extrapolate edges using SABR-like asymptotic
    # Left edge (low strikes)
    if strikes[0] < spot * 0.5:
        left_slope = (local_vol_smooth[0, 1] - local_vol_smooth[0, 0]) / \
                     (strikes[1] - strikes[0])
        for i in range(len(strikes)):
            if strikes[i] < strikes[1]:
                local_vol_smooth[0, i] = local_vol_smooth[0, 1] + \
                    left_slope * (strikes[i] - strikes[1])
    
    # Right edge (high strikes)
    if strikes[-1] > spot * 1.5:
        right_slope = (local_vol_smooth[0, -1] - local_vol_smooth[0, -2]) / \
                      (strikes[-1] - strikes[-2])
        for i in range(len(strikes)):
            if strikes[i] > strikes[-2]:
                local_vol_smooth[0, i] = local_vol_smooth[0, -2] + \
                    right_slope * (strikes[i] - strikes[-2])
    
    return np.clip(local_vol_smooth, min_vol, max_vol)

Lỗi 3: SABR calibration bị overfitting với market noise

from sklearn.linear_model import Ridge

def sabr_regularized_calibration(market_vol, strikes, maturities, spot):
    """
    SABR calibration với regularization để tránh overfitting
    """
    # Define SABR implied volatility formula
    def sabr_vol(K, F, T, alpha, beta, rho, nu, m):
        # SABR asymptotic formula (Hagan 2002)
        FK = F * K
        logFK = np.log(F/K)
        sqrtFK = np.sqrt(FK)
        
        # Handle ATM case
        eps = 1e-7
        if np.abs(F - K) < eps:
            term1 = alpha / (F**(1-beta))
            term2 = 1 + ((1-beta)**2/24 * alpha**2/(F**(2*(1-beta))) + 
                   0.25 * rho*beta*nu*alpha/(F**(1-beta)) + 
                   (2-3*rho**2)/24 * nu**2) * T
            return term1 * term2
        
        # General case
        z = nu / alpha * sqrtFK * logFK
        zx = z * np.arcosh((F+K)/(2*sqrtFK) - rho)
        
        numerator = alpha / (sqrtFK * (1 + (1-beta)**2/24 * logFK**2 + 
                     (1-beta)**4/1920 * logFK**4))
        denominator = 1 + ((1-beta)**2/24 * alpha**2/(FK**(1-beta)) + 
                    0.25*rho*beta*nu*alpha/(FK**((1-beta)/2)) + 
                    (2-3*rho**2)/24 * nu**2) * T
        
        return numerator * (z / zx) * denominator
    
    # Objective với L2 regularization
    def regularized_objective(params):
        alpha, beta, rho, nu = params
        
        # Add L2 penalty
        penalty = 0.01 * np.sum(params**2)
        
        total_error = 0
        for i, (K, T, market_v) in enumerate(zip(strikes, maturities, market_vol)):
            model_v = sabr_vol(K, spot, T, alpha, beta, rho, nu, 0)
            total_error += (model_v - market_v)**2
        
        return total_error + penalty
    
    # Optimize với constraints
    constraints = [
        {'type': 'ineq', 'fun': lambda x: x[0]},      # alpha > 0
        {'type': 'ineq', 'fun': lambda x: 1 - x[1]},   # beta < 1
        {'type': 'ineq', 'fun': lambda x: x[1]},       # beta > 0
        {'type': 'ineq', 'fun': lambda x: 1 - x[2]**2}, # |rho| < 1
        {'type': 'ineq', 'fun': lambda x: x[3]},      # nu > 0
    ]
    
    result = minimize(
        regularized_objective,
        x0=[0.02, 0.5, -0.3, 0.3],
        method='SLSQP',
        constraints=constraints,
        options={'maxiter': 1000}
    )
    
    return result.x