Mở đầu — Câu chuyện thực chiến từ quỹ phòng hộ crypto ở Singapore

Tối thứ Sáu giữa tháng 3/2025, tôi nhận được tin nhắn Slack từ quant lead: "ETH vol đang bất thường, mặt smile bị xé ở khu vực put wing. Em có thể tái dựng IV surface từ Deribit trong 24 giờ không?". Đó là đêm tôi bắt đầu dự án xây dựng pipeline Python kéo historical options chain trực tiếp từ Deribit, làm sạch, fit một mặt phẳng SVI mượt, rồi dùng mô hình ngôn ngữ để phát hiện arbitrage. Bài viết này là phiên bản tổng hợp lại toàn bộ quy trình, kèm mã chạy được và những cạm bẫy tôi đã trả giá bằng 6 tiếng debug.

Bối cảnh thị trường thực tế tại thời điểm viết bài: ETH spot dao động quanh $3,450, ATM IV 30 ngày ở mức 62,3% annualized, put wing 25-delta skew về phía -12 vol points. Khối lượng ETH options trên Deribit tuần đó đạt $480 triệu notional, trong đó quyền chọn vĩnh viễn (perpetual-style options) chiếm khoảng 8% — đủ lớn để trở thành một nhóm thanh khoản riêng cần tách pipeline.

1. Vì sao bề mặt IV quan trọng trong trading crypto derivatives

2. Chuẩn bị dữ liệu Deribit Historical Options Chain

Bước đầu tiên là kéo chuỗi quyền chọn lịch sử (historical options chain) qua REST API công khai của Deribit. Bạn không cần key cho dữ liệu OHLC, mark price, và implied volatility; chỉ cần key khi muốn lấy trade-by-trade. Đoạn mã dưới đây xây dựng bảng instrument, lọc theo đáo hạn 7-180 ngày, rồi truy vấn vol lịch sử theo giờ.

import requests
import pandas as pd
import numpy as np
from datetime import datetime, timedelta

BASE = "https://www.deribit.com/api/v2"

def fetch_eth_instruments(currency="ETH", kind="option"):
    """Lấy danh sách toàn bộ ETH options đang niêm yết."""
    r = requests.get(f"{BASE}/get_instruments",
                     params={"currency": currency, "kind": kind, "expired": "false"},
                     timeout=10)
    r.raise_for_status()
    return pd.DataFrame([
        {
            "instrument": i["instrument_name"],
            "strike": i["strike"],
            "expiry_ms": i["expiration_timestamp"],
            "type": i["option_type"],
            "tick_size": i["tick_size"],
        }
        for i in r.json()["result"]
    ])

def fetch_historical_volatility(instrument: str,
                                start_ms: int,
                                end_ms: int,
                                resolution: str = "60"):
    """Trả về IV lịch sử theo từng khung (giờ)."""
    r = requests.get(f"{BASE}/get_historical_volatility",
                     params={"instrument_name": instrument,
                             "start_timestamp": start_ms,
                             "end_timestamp": end_ms,
                             "resolution": resolution},
                     timeout=15)
    r.raise_for_status()
    data = r.json()["result"]
    return pd.DataFrame({
        "ts": [datetime.utcfromtimestamp(d[0]/1000) for d in data],
        "iv": [d[1] / 100 for d in data],   # Deribit trả %, chia 100
    })


--- Pipeline thực thi ---

df_inst = fetch_eth_instruments()
now_ms = int(datetime.now().timestamp() * 1000)
df_inst["days_to_expiry"] = (df_inst["expiry_ms"] - now_ms) / (1000 * 86400)
df_liquid = df_inst[(df_inst["days_to_expiry"] >= 7) &
                    (df_inst["days_to_expiry"] <= 180)].copy()
print(f"Số instrument thanh khoản: {len(df_liquid)}")  # Thường 320-450 instruments

Kết quả thực tế ở thời điểm tôi chạy: 387 instruments còn đáo hạn trong khoảng 7-180 ngày, đủ dày để fit một bề mặt 9 mức đáo hạn × 41 strike.

3. Tính implied volatility từng-quyền-chọn với py_vollib

Dữ liệu IV lịch sử từ Deribit chỉ là IV của underlying, không phải IV từng strike. Để dựng surface bạn cần bootstrap IV cho mỗi (K, T) từ mark price. py_vollib hỗ trợ Black-Scholes ngược, đủ tốt cho ETH vì không có dividend yield.

from py_vollib.black_scholes_merton import implied_volatility as bsm_iv
from py_vollib.black_scholes_merton.greeks.analytical import delta as bsm_delta

def calc_iv_row(market_price, S, K, t_years, r, flag):
    """Trả về IV hoặc NaN nếu hội tụ thất bại."""
    try:
        return bsm_iv.implied_volatility(
            price=market_price, S=S, K=K, t=t_years, r=r, flag=flag)
    except Exception:
        return np.nan

def fetch_mark_snapshot(instrument: str):
    """Lấy mark price, underlying, và Greeks thời điểm hiện tại."""
    r = requests.get(f"{BASE}/ticker",
                     params={"instrument_name": instrument}, timeout=10)
    j = r.json()["result"]
    return {
        "mark": j["mark_price"],
        "underlying": j["underlying_price"],
        "iv_mark": j["mark_iv"] / 100,
        "index_price": j["index_price"],
        "best_ask": j["best_ask_price"],
        "best_bid": j["best_bid_price"],
        "open_interest": j.get("open_interest", 0),
    }


Ví dụ: ETH-27JUN25-3500-C khi spot = 3.450, t = 28/365, r = 0.045

snap = fetch_mark_snapshot("ETH-27JUN25-3500-C")
iv_calc = calc_iv_row(market_price=snap["mark"], S=snap["underlying"],
                      K=3500, t_years=28/365, r=0.045, flag='c')
print(f"Mark: ${snap['mark']}, IV Deribit: {snap['iv_mark']*100:.2f}%, "
      f"IV py_vollib: {iv_calc*100:.2f}%, OI: {snap['open_interest']}")

Kết quả mẫu: Mark: $128.45, IV Deribit: 61.85%, IV py_vollib: 61.92%

Chênh lệch giữa IV do Deribit trả và IV tính ngược từ mark price thường <0,1 vol point. Nếu chênh >0,5%, nhiều khả năng bạn đang dùng sai flag (call/put) hoặc sai rate r — đây là lỗi thường gặp nhất.

4. Fit mặt SVI (Stochastic Volatility Inspired) cho từng slice T

SVI là tham số hóa 5-chiều được Gatheral đề xuất, fit rất tốt bề mặt ETH vì có thể mô hình hóa skew sâu và wing nặng — hai hiện tượng đặc trưng của crypto. Công thức mỗi slice T:

w(k) = a + b * (rho*(k - m) + sqrt((k - m)^2 + sigma^2))

Trong đó:
- k = log(K / F)         (log-moneyness)
- w = sigma^2 * T        (total variance)
- a, b, rho, m, sigma    là 5 tham số cần fit

Ràng buộc arbitrage-free cần: a + b*sigma*sqrt(1 - rho^2) >= 0
                                b >= 0, |rho| < 1, sigma > 0

Đoạn code dưới đây fit SVI cho từng slice đáo hạn bằng SciPy:

from scipy.optimize import minimize

def svi_slice(k, a, b, rho, m, sigma):
    return a + b * (rho * (k - m) + np.sqrt((k - m)**2 + sigma**2))

def fit_one_slice(strikes, ivs, T, F):
    """Fit SVI cho một slice T. Trả về dict tham số."""
    k = np.log(np.array(strikes) / F)
    w = np.array(ivs)**2 * T
    # Điểm khởi đầu từ ATM IV
    x0 = [np.median(w), 0.5, -0.3, 0.0, 0.2]
    bounds = [(-2, 2), (0.01, 5), (-0.999, 0.999), (-3, 3), (0.01, 3)]

    def loss(p):
        a, b, rho, m, sigma = p
        w_model = svi_slice(k, a, b, rho, m, sigma)
        # Phạt nặng nếu butterfly arbitrage bị vi phạm
        penalty = 0
        g = b*(rho + (k - m)/np.sqrt((k - m)**2 + sigma**2))  # dw/dk
        if (g[:-1] * g[1:] < 0).any():  # đổi dấu -> calendar issue
            penalty = 10
        return np.mean((w_model - w)**2) + penalty

    res = minimize(loss, x0=x0, bounds=bounds, method="L-BFGS-B")
    return {"a": res.x[0], "b": res.x[1], "rho": res.x[2],
            "m": res.x[3], "sigma": res.x[4],
            "rmse_bps": np.sqrt(res.fun)*1e4,
            "T": T}


Sample output cho T = 28 ngày:


{'a': 0.0412, 'b': 0.5821, 'rho': -0.4102, 'm': 0.0185,


 'sigma': 0.1822, 'rmse_bps': 6.3, 'T': 0.0767}

RMSE ~6,3 bps vol tức là mô hình tái tạo bề mặt thị trường với sai số dưới 0,07 vol point — đủ chính xác để re-mark portfolio ở mức PnL < $50 trên notional $10 triệu. Quy trình sau đó là lắp ráp 9 slice, rồi nội suy giữa các slice bằng spline để có bề mặt 3D liên tục.

5. Dùng HolySheep AI để phát hiện arbitrage tự động

Sau khi có bề mặt SVI, bạn cần một trợ lý LLM để đọc các tín hiệu bất thường và đề xuất chiến lược rebalance. Trong dự án của tôi, tôi dùng HolySheep AI qua OpenAI-compatible endpoint, tận dụng DeepSeek V3.2 vì giá chỉ $0,42 / 1M token — phù hợp chạy batch job hàng giờ mà không lo cháy budget.

import openai

client = openai.OpenAI(
    base_url="https://api.holysheep.ai/v1",
    api_key="YOUR_HOLYSHEEP_API_KEY"
)

def arb_report(slice_meta: dict, anomalies: list):
    """Gửi báo cáo 1 slice có anomaly tới HolySheep để nhận diễn giải."""
    prompt = f"""Bạn là quant trader crypto. Bề mặt IV ETH slice T={slice_meta['T']*365:.1f} ngày
vừa phát hiện {len(anomalies)} điểm bất thường.

SVI params: a={slice_meta['a']:.4f}, b={slice_meta['b']:.4f},
rho={slice_meta['rho']:.4f}, m={slice_meta['m']:.4f},
sigma={slice_meta['sigma']:.4f}, RMSE={slice_meta['rmse_bps']:.1f} bps.

Anomalies (strike, market_iv, model_iv, residual_sigma):
{anomalies[:8]}

Hãy:
1. Phân loại arbitrage (vertical/horizontal/butterfly nếu có).
2. Đề xuất chiến lược rebalance bằng options đơn giản.
3. Đánh giá mức độ khẩn cấp (cao/trung bình/thấp).
Trả lời ngắn gọn dưới 200 từ, tiếng Việt."""

    rsp = client.chat.completions.create(
        model="deepseek-v3.2",   # Rẻ nhất, phù hợp batch job
        messages=[{"role": "user", "content": prompt}],
        max_tokens=350,
        temperature=0.2,
    )
    return rsp.choices[0].message.content


Kết quả thực tế (rút gọn):


"Put wing 25-delta có chênh 3.2 sigma, đặc trưng của tail hedge sau CPI shock.


 Đề xuất: SHORT 3500P / LONG 3200P calendar spread..."

Độ trễ quan sát được trong back-to-back test 100 request liên tiếp tới HolySheep: trung vị 47ms, P95 89ms (dữ liệu benchmark nội bộ tháng 4/2025). Đây là lý do tôi chuyển từ OpenAI sang HolySheep — chênh lệch độ trễ trung bình lên tới 7×.

Bảng so sánh chi phí vận hành pipeline AI

Giả định: pipeline chạy 24 giờ/ngày, mỗi giờ tốn khoảng 120K token input + 80K token output, tổng cộng 4,8 triệu token/ngày ≈ ~144 triệu token/tháng.

Nền tảng Model Input $/MTok Output $/MTok Chi phí/tháng (144M tok hỗn hợp 60/40) Độ trễ P50 Thanh toán
HolySheep AI DeepSeek V3.2 $0,42 $1,68 ~$116 ~47ms Alipay/WeChat/PayPal
HolySheep AI Gemini 2.5 Flash $2,50 $10,00 ~$774 ~180ms Alipay/WeChat/PayPal
OpenAI GPT-4.1 $8,00 $32,00 ~$2.765 ~320ms Credit card
Anthropic Claude Sonnet 4.5 $15,00 $75,00 ~$6.480 ~410ms Credit card
Google Gemini 2.5 Flash (direct) $2,50 $10,00 ~$774 ~180ms Credit card

Nhận xét từ bảng: Với cùng workload, OpenAI tốn gấp 23,8× và Anthropic gấp 55,8× so với DeepSeek V3.2 qua HolySheep. Tỷ giá ¥1 = $1 của HolySheep còn giúp người dùng Trung Quốc tiết kiệm thêm 85%+ so với các gói USD thông thường — đây là đòn bẩy chi phí rất lớn cho team quy mô vừa.

Phù hợp / không phù hợp với ai?

Phù hợp với