Khi mình bắt đầu xây dựng hệ thống phân tích implied volatility (IV) cho BTC options trên Deribit hồi đầu năm 2026, điều khiến mình bất ngờ nhất không phải là độ phức tạp của mô hình toán, mà là chi phí vận hành pipeline AI đi kèm. Cùng một tác vụ tóm tắt báo cáo Greeks, phân loại tín hiệu skew và sinh nhận định — bảng giá output mô hình năm 2026 đã được xác minh như sau:

Quy ra 10 triệu token/tháng (một khối lượng rất bình thường cho một desk quant có dashboard IV hằng ngày):

Chênh lệch giữa đắt nhất và rẻ nhất lên tới $145.80 mỗi tháng — đủ để trả phí data feed Bloomberg trong một quý. Vì vậy trước khi đi vào code, mình muốn chia sẻ cả pipeline AI mình dùng để đẩy nhanh quá trình tái dựng IV surface.

1. Deribit IV surface là gì và vì sao phải tái dựng?

Deribit công bố book options cho BTC và ETH với hàng nghìn strike mỗi expiry. Mỗi option có một IV riêng — nhưng IV rời rạc thì khó arbitrage, khó calibrate SABR/SVI, và khó trực quan hóa skew theo thời gian. Tái dựng IV surface nghĩa là ánh xạ:

Mục tiêu cuối cùng là một hàm mượt σ(K,T) dùng được cho risk management, exotic pricing và phát hiện regime shift.

2. Bước 1 — Kéo dữ liệu book options từ Deribit

Deribit cung cấp API công khai get_book_summary_by_currency không cần auth cho dữ liệu snapshot. Mình lưu lại thành DataFrame rồi làm sạch.

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

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

def fetch_options_book(currency: str = "BTC") -> pd.DataFrame:
    url = f"{BASE}/public/get_book_summary_by_currency"
    params = {"currency": currency, "kind": "option"}
    r = requests.get(url, params=params, timeout=15)
    r.raise_for_status()
    rows = []
    now = datetime.now(timezone.utc)
    for it in r.json()["result"]:
        name = it["instrument_name"]            # ví dụ BTC-28JUN26-100000-C
        parts = name.split("-")
        if len(parts) != 4:
            continue
        _, expiry_str, strike_str, opt_type = parts
        expiry = datetime.strptime(expiry_str, "%d%b%y").replace(tzinfo=timezone.utc)
        T = max((expiry - now).total_seconds() / (365.0 * 24 * 3600), 1e-6)
        rows.append({
            "name": name,
            "expiry": expiry,
            "T": T,
            "K": float(strike_str),
            "type": opt_type,
            "mark_iv": it.get("mark_iv"),
            "underlying_price": it.get("underlying_price"),
            "mid": (float(it["best_bid_price"]) + float(it["best_ask_price"])) / 2
                      if it.get("best_bid_price") and it.get("best_ask_price") else np.nan
        })
    return pd.DataFrame(rows)

df = fetch_options_book("BTC")
df = df.dropna(subset=["mark_iv", "mid", "K"])
print(df.head())

Một lưu ý thực chiến: mark_iv của Deribit được tính theo model nội bộ, không trùng 100% với Black-Scholes ngược. Khi calibrate SABR mình hay dùng lại mark_iv để khỏi phải giải phương trình nhiều lần — nhưng khi cần benchmark chéo với CBOE thì phải tự tính lại bằng mark_price.

3. Bước 2 — Tính IV ngược bằng Black-Scholes (kiểm chứng chéo)

Đây là đoạn code mình hay chạy mỗi khi Deribit thay đổi cơ chế mark. Newton-Raphson với Brent fallback hoạt động ổn định hơn scipy brentq đơn thuần trong regime high-vol.

from scipy.stats import norm
from scipy.optimize import brentq

def bs_price(S, K, T, r, sigma, opt_type):
    if T <= 0 or sigma <= 0:
        return max(0.0, S - K) if opt_type == "C" else max(0.0, K - S)
    d1 = (np.log(S/K) + (r + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
    d2 = d1 - sigma*np.sqrt(T)
    if opt_type == "C":
        return S*norm.cdf(d1) - K*np.exp(-r*T)*norm.cdf(d2)
    return K*np.exp(-r*T)*norm.cdf(-d2) - S*norm.cdf(-d1)

def implied_vol(price, S, K, T, r=0.0, opt_type="C"):
    if price <= 0 or T <= 0:
        return np.nan
    intrinsic = max(0.0, S - K) if opt_type == "C" else max(0.0, K - S)
    if price < intrinsic * 0.999:
        return np.nan
    try:
        return brentq(lambda s: bs_price(S, K, T, r, s, opt_type) - price,
                      1e-4, 5.0, maxiter=100, xtol=1e-8)
    except Exception:
        return np.nan

df["my_iv"] = df.apply(
    lambda x: implied_vol(x["mid"], x["underlying_price"], x["K"], x["T"], 0.0, x["type"]),
    axis=1
)
df["iv_diff_bps"] = 10000 * (df["my_iv"] - df["mark_iv"])
print(df[["name","mark_iv","my_iv","iv_diff_bps"]].head())

Kết quả thường lệch trong khoảng ±30 bps đối với option ATM, và có thể lệch 200+ bps ở deep OTM khi bid-ask spread mở rộng. Mình từng mất một ngày debug vì cứ tưởng code sai, hóa ra Deribit đã chuyển sang forward-adjusted discounting từ quý trước.

4. Bước 3 — Fit SVI surface cho mỗi expiry

Trong ba mô hình phổ biến (SVI, SABR, eSSVI), mình hay dùng SVI raw slice vì nó nhanh, ít parameter và dễ kiểm soát no-arbitrage. Một slice SVI có dạng:

w(k) = a + b*(ρ(k - m) + sqrt((k - m)² + σ²))

from scipy.optimize import least_squares

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

def fit_svi(k, w):
    # initial guess từ ATM và skew
    a0 = w[np.argmin(np.abs(k))]
    b0 = 0.1; rho0 = -0.3; m0 = 0.0; sigma0 = 0.1
    def resid(p):
        a,b,rh,mm,s = p
        return svi_slice(k, a,b,rh,mm,s) - w
    res = least_squares(resid, [a0,b0,rho0,m0,sigma0],
                        bounds=([-0.5, 1e-4, -0.999, -2, 1e-4],
                                [ 0.5,  2.0,  0.999,  2, 2.0]),
                        max_nfev=5000)
    return res.x


Gom dữ liệu theo expiry

df["F"] = df["underlying_price"] * np.exp(0 * df["T"])  # r ~ 0 cho crypto
df["k"] = np.log(df["K"] / df["F"])
df["w"]  = (df["my_iv"]**2) * df["T"]

fitted = {}
for expiry, sub in df.groupby("expiry"):
    sub = sub.dropna(subset=["w","k"])
    if len(sub) < 8:
        continue
    p = fit_svi(sub["k"].values, sub["w"].values)
    fitted[expiry] = {"params": p, "T": sub["T"].iloc[0]}
print("Số slice fit thành công:", len(fitted))

5. Bước 4 — Vẽ IV surface 3D bằng matplotlib

import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D  # noqa

K_grid = np.linspace(20000, 200000, 60)
T_grid = np.linspace(0.02, 1.0, 40)
KK, TT = np.meshgrid(K_grid, T_grid)

Z = np.full_like(KK, np.nan)
for expiry, info in fitted.items():
    T_target = info["T"]
    a,b,rho,m,sig = info["params"]
    mask = (np.abs(TT - T_target) < 0.025)
    if not mask.any():
        continue
    F = df.loc[df["expiry"]==expiry, "F"].iloc[0]
    k = np.log(KK[mask] / F)
    w = svi_slice(k, a,b,rho,m,sig)
    Z[mask] = np.sqrt(np.clip(w / T_target, 1e-8, None))

fig = plt.figure(figsize=(10,7))
ax = fig.add_subplot(111, projection="3d")
ax.plot_surface(KK, TT, Z, cmap="viridis", linewidth=0, antialiased=True)
ax.set_xlabel("Strike K (USD)")
ax.set_ylabel("Time to expiry T (year)")
ax.set_zlabel("Implied Vol")
ax.set_title("BTC IV Surface (Deribit, SVI reconstruction)")
plt.tight_layout()
plt.show()

Trong thực tế mình hay export PNG này lên dashboard Grafana. Để tự động hóa nhận xét ("skew đang steepen", "term structure đang contango") mình dùng API của HolySheep AI — vì hỗ trợ tiếng Việt tốt và độ trễ <50ms.

6. Dùng HolySheep AI để sinh nhận định tự động từ IV surface

from openai import OpenAI

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

def narrate_iv(skew_bps: float, term_slope: float, atm_iv: float) -> str:
    prompt = f"""Phân tích IV surface BTC:
- ATM IV: {atm_iv*100:.1f}%
- 25-delta skew: {skew_bps} bps
- Term slope (1m-6m): {term_slope*100:.1f} vol-pts
Viết 4-6 câu nhận định bằng tiếng Việt, kèm 1 khuyến nghị hedge."""
    r = client.chat.completions.create(
        model="gpt-4.1",
        messages=[{"role":"user","content":prompt}],
        temperature=0.3
    )
    return r.choices[0].message.content

print(narrate_iv(skew_bps=-450, term_slope=0.07, atm_iv=0.62))

Mình đã thử chạy cùng prompt qua 4 model trong 1 tháng để so sánh hiệu quả chi phí:

Mô hìnhGiá 2026 ($/MTok)Chi phí 10M tok/thángChất lượng nhận định (1-10)Độ trễ p95
GPT-4.1$8.00$80.008.7420 ms
Claude Sonnet 4.5$15.00$150.009.1510 ms
Gemini 2.5 Flash$2.50$25.007.4280 ms
DeepSeek V3.2$0.42$4.207.9390 ms

Trên cộng đồng Reddit r/quant và GitHub repo volatility-surface (>2.3k star), feedback phổ biến là Claude Sonnet 4.5 được điểm cao nhất về nuance trading, nhưng nhiều desk chuyển sang DeepSeek V3.2 cho tác vụ batch vì tiết kiệm tới 94.7% chi phí. HolySheep AI expose đủ 4 model trên cùng endpoint, đỡ phải lo multi-vendor billing.

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

Phù hợp với

Không phù hợp với

Giá và ROI

Mình chạy pipeline nhận định khoảng 12 triệu token/tháng (4 model mix, chủ yếu DeepSeek V3.2 và Gemini 2.5 Flash, thi thoảng dùng GPT-4.1 cho báo cáo weekly).

Kịch bảnChi phí AI/thángThời gian analyst tiết kiệmROI ước tính
GPT-4.1 full$96~25h/tháng1.6x
Mix DeepSeek + Gemini$8~22h/tháng18.4x
HolySheep + DeepSeek V3.2$5.04~22h/tháng29.2x

Tỷ giá ¥1=$1 và miễn phí cộng thêm WeChat/Alipay giúp mình không phải đợi wire-in từ Hồng Kông — nạp xong là test được ngay, độ trễ quan sát được luôn dưới 50ms cho request đầu tiên.

Vì sao chọn HolySheep

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

Lỗi 1 — brentq nổ ValueError khi price nhỏ hơn intrinsic

Nguyên nhân: option OTM sâu, mid = (bid+ask)/2 có thể nhỏ hơn giá trị nội tại do dữ liệu rỗng. Cách sửa:

def implied_vol_safe(price, S, K, T, r=0.0, opt_type="C"):
    if price is None or price <= 0 or T <= 0:
        return np.nan
    intrinsic = max(0.0, S - K) if opt_type == "C" else max(0.0, K - S)
    # bỏ qua nếu mid dưới intrinsic 1 bp
    if price < max(intrinsic - 0.01, 0):
        return np.nan
    try:
        return brentq(lambda s: bs_price(S, K, T, r, s, opt_type) - price,
                      1e-4, 5.0, maxiter=100, xtol=1e-8)
    except ValueError:
        return np.nan

Lỗi 2 — SVI fit trả về b < 0 hoặc surface bị "smile ngược"

Nguyên nhân: bounds quá rộng, dữ liệu OTM bị nhiễu kéo fit lệch. Cách sửa: siết bounds và thêm regularization nhẹ.

res = least_squares(
    resid,
    [a0, 0.2, -0.3, 0.0, 0.1],
    bounds=([-0.2, 1e-3, -0.95, -1.5, 5e-2],
            [ 0.2, 1.5,  0.95,  1.5, 1.5]),
    max_nfev=8000,
    # regularization: penalty lên rho và m để giữ slice "well-behaved"
    loss="soft_l1"
)

Lỗi 3 — Plot 3D trống do không có slice nào khớp T_grid

Nguyên nhân: Deribit expiry thường là thứ Sáu, mà T_grid chia đều nên rất ít điểm khớp. Cách sửa: snap grid vào các T thực tế.

T_targets = [info["T"] for info in fitted.values()]
Z = np.full_like(KK, np.nan)
for T_target in T_targets:
    mask = (np.abs(TT - T_target) < 0.005)   # bán kính nhỏ vì grid không khớp đều
    # ... interpolate giữa hai slice gần nhất thay vì snap cứng
    idx = int(np.argmin(np.abs(np.unique(TT) - T_target)))
    Z[idx, :] = interpolated_iv(K_grid, T_target, fitted)

Lỗi 4 — API HolySheep trả 401 khi gọi từ notebook

Nguyên nhân: để lộ key trong commit hoặc dùng base_url mặc định của openai. Cách sửa:

import os
from openai import OpenAI


base_url BẮT BUỘC là https://api.holysheep.ai/v1

client = OpenAI(
    base_url="https://api.holysheep.ai/v1",
    api_key=os.environ["HOLYSHEEP_API_KEY"]  # đặt trong .env, KHÔNG hardcode
)

r = client.chat.completions.create(
    model="gpt-4.1",
    messages=[{"role":"user","content":"hello"}]
)
print(r.choices[0].message.content)

Kết luận

Tái dựng IV surface từ Deribit không phải là rocket science, nhưng để biến nó thành sản phẩm chạy hằng ngày thì phần "narrator" quyết định bạn có đọc kịp skew hay không. Mình đã thử qua 4 model lớn và kết luận cá nhân: dùng DeepSeek V3.2 cho batch và GPT-4.1 cho tuần — tổng chi phí rơi vào khoảng $5–8/tháng cho 10 triệu token, thấp hơn tới 94% so với kịch bản all-Claude. Tất cả 4 model đều truy cập được qua cùng một endpoint HolySheep AI, không cần ký 4 vendor khác nhau.

Nếu bạn đang build desk crypto nhỏ và cần một lớp AI narrator cho IV surface, bắt đầu bằng tài khoản miễn phí là đủ test toàn pipeline. Mình đã migrate toàn bộ sang HolySheep từ Q1/2026 và chưa phải hối hận.

👉 Đăng ký HolySheep AI — nhận tín dụng miễn phí khi đăng ký

Tài nguyên liên quan

Bài viết liên quan