Việc backtest chiến lược options trên Deribit đòi hỏi dữ liệu chất lượng cao: Greeks (delta, gamma, vega, theta), lịch sử giao dịch tick-by-tick, và L2 order book. Bài viết này sẽ hướng dẫn chi tiết cách sử dụng Tardis Machine — công cụ phổ biến nhất để thu thập dữ liệu Deribit — kèm theo mã nguồn Python có thể chạy ngay. Đặc biệt, tôi sẽ so sánh hiệu quả chi phí khi kết hợp Tardis với các mô hình AI (như tính toán Greeks bằng mô hình Black-Scholes tự động hóa) để bạn có cái nhìn toàn diện trước khi đưa ra quyết định đầu tư.

Tại sao Deribit là sàn chọn lọc cho Options Backtesting?

Deribit là sàn giao dịch options BTC/ETH lớn nhất thế giới với khối lượng hợp đồng options perp và futures cao nhất. Ưu điểm nổi bật:

Tardis Machine — Giải pháp thu thập dữ liệu Deribit

Tardis Machine là dịch vụ cung cấp dữ liệu thị trường historical và real-time từ nhiều sàn crypto, bao gồm Deribit. Với Tardis, bạn có thể tải về:

Cài đặt và cấu hình Tardis SDK

# Cài đặt Tardis SDK
pip install tardis-dev


Hoặc sử dụng tardis-machine CLI

pip install "tardis-machine[cli]"

Tải dữ liệu Deribit Options - Trades và Greeks

import asyncio
from tardis.devices import Device
from tardis.interface import Tardis
from datetime import datetime, timedelta
import pandas as pd


Cấu hình Tardis với API key

TARDIS_API_KEY = "your_tardis_api_key"

async def download_deribit_options_trades(
    symbol: str = "BTC-28MAR25-95000-C",  # BTC Call Option
    start_date: datetime = datetime(2025, 1, 1),
    end_date: datetime = datetime(2025, 3, 28)
):
    """
    Tải dữ liệu giao dịch options Deribit bao gồm Greeks
    """
    tardis = Tardis(api_key=TARDIS_API_KEY)
    
    # Cấu hình dataset
    dataset_config = {
        "exchange": "deribit",
        "kind": "options",
        "symbol": symbol,
        "channels": ["trades", "greeks"],
        "start_time": start_date.isoformat(),
        "end_time": end_date.isoformat(),
    }
    
    async with Device(dataset_config) as device:
        trades_data = []
        greeks_data = []
        
        async for message in device.messages():
            if message["type"] == "trade":
                trades_data.append({
                    "timestamp": message["timestamp"],
                    "price": message["price"],
                    "amount": message["amount"],
                    "side": message["side"],
                    "iv": message.get("mark_iv"),  # Implied Volatility
                    "delta": message.get("greeks", {}).get("delta"),
                    "gamma": message.get("greeks", {}).get("gamma"),
                    "vega": message.get("greeks", {}).get("vega"),
                    "theta": message.get("greeks", {}).get("theta"),
                })
            
            if message["type"] == "greeks":
                greeks_data.append({
                    "timestamp": message["timestamp"],
                    "underlying_price": message["underlying_price"],
                    "mark_price": message["mark_price"],
                    "mark_iv": message["mark_iv"],
                    "delta": message["delta"],
                    "gamma": message["gamma"],
                    "vega": message["vega"],
                    "theta": message["theta"],
                    "rho": message["rho"],
                })
    
    return pd.DataFrame(trades_data), pd.DataFrame(greeks_data)


Chạy download

trades_df, greeks_df = asyncio.run(download_deribit_options_trades())


Lưu thành CSV cho backtesting

trades_df.to_csv("deribit_options_trades.csv", index=False)
greeks_df.to_csv("deribit_greeks.csv", index=False)

print(f"Đã tải {len(trades_df)} trades và {len(greeks_df)} snapshots Greeks")
print(f"Khoảng thời gian: {trades_df['timestamp'].min()} đến {trades_df['timestamp'].max()}")

Tải L2 Order Book Deribit Options

import asyncio
from tardis.devices import Device
from datetime import datetime
import pandas as pd
import json

async def download_deribit_l2_orderbook(
    symbol: str = "BTC-28MAR25-95000-C",
    start_date: datetime = datetime(2025, 2, 1),
    end_date: datetime = datetime(2025, 2, 2),
    frequency: str = "100ms"  # Tần suất snapshot
):
    """
    Tải dữ liệu L2 Order Book cho Deribit Options
    Dùng cho phân tích thanh khoản và slippage estimation
    """
    tardis = Device({
        "exchange": "deribit",
        "kind": "options",
        "symbol": symbol,
        "channels": ["book_L2_100ms"],  # Level 2 với 100ms snapshot
        "start_time": start_date.isoformat(),
        "end_time": end_date.isoformat(),
    }, api_key=TARDIS_API_KEY)
    
    orderbook_snapshots = []
    
    async with tardis:
        async for message in tardis.messages():
            if message["type"] == "book_L2_100ms":
                snapshot = {
                    "timestamp": message["timestamp"],
                    "bids": json.dumps(message["bids"][:10]),  # Top 10 bids
                    "asks": json.dumps(message["asks"][:10]),  # Top 10 asks
                    "best_bid": message["bids"][0][0] if message["bids"] else None,
                    "best_ask": message["asks"][0][0] if message["asks"] else None,
                    "spread": (message["asks"][0][0] - message["bids"][0][0]) if message["bids"] and message["asks"] else None,
                    "bid_depth_10": sum([b[1] for b in message["bids"][:10]]),
                    "ask_depth_10": sum([a[1] for a in message["asks"][:10]]),
                }
                orderbook_snapshots.append(snapshot)
    
    df = pd.DataFrame(orderbook_snapshots)
    
    # Tính toán spread statistics
    df["mid_price"] = (df["best_bid"] + df["best_ask"]) / 2
    df["spread_pct"] = df["spread"] / df["mid_price"] * 100
    
    return df


Tải order book data

ob_df = asyncio.run(download_deribit_l2_orderbook())


Phân tích thanh khoản

print(f"Tổng số snapshots: {len(ob_df)}")
print(f"Spread TB: {ob_df['spread_pct'].mean():.4f}%")
print(f"Spread max: {ob_df['spread_pct'].max():.4f}%")
print(f"Bid depth TB: {ob_df['bid_depth_10'].mean():.4f}")

ob_df.to_csv("deribit_l2_orderbook.csv", index=False)

Xây dựng hệ thống Volatility Backtesting với dữ liệu Deribit

Sau khi có dữ liệu từ Tardis, bước tiếp theo là xây dựng backtesting engine để test chiến lược options. Phần quan trọng nhất là tính toán Greeks và so sánh với Greeks thực tế từ Deribit để validate mô hình.

import numpy as np
from scipy.stats import norm
from typing import Tuple

class BlackScholesGreeks:
    """
    Tính toán Greeks sử dụng Black-Scholes model
    So sánh với dữ liệu Greeks từ Deribit để validation
    """
    
    @staticmethod
    def d1(S: float, K: float, T: float, r: float, sigma: float) -> float:
        """Tính d1 trong công thức Black-Scholes"""
        if T <= 0 or sigma <= 0:
            return np.nan
        return (np.log(S / K) + (r + 0.5 * sigma ** 2) * T) / (sigma * np.sqrt(T))
    
    @staticmethod
    def d2(S: float, K: float, T: float, r: float, sigma: float) -> float:
        """Tính d2 trong công thức Black-Scholes"""
        if T <= 0 or sigma <= 0:
            return np.nan
        return BlackScholesGreeks.d1(S, K, T, r, sigma) - sigma * np.sqrt(T)
    
    @staticmethod
    def call_price(S: float, K: float, T: float, r: float, sigma: float) -> float:
        """Tính giá Call theo Black-Scholes"""
        d1 = BlackScholesGreeks.d1(S, K, T, r, sigma)
        d2 = BlackScholesGreeks.d2(S, K, T, r, sigma)
        return S * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
    
    @staticmethod
    def put_price(S: float, K: float, T: float, r: float, sigma: float) -> float:
        """Tính giá Put theo Black-Scholes"""
        d1 = BlackScholesGreeks.d1(S, K, T, r, sigma)
        d2 = BlackScholesGreeks.d2(S, K, T, r, sigma)
        return K * np.exp(-r * T) * norm.cdf(-d2) - S * norm.cdf(-d1)
    
    @staticmethod
    def greeks(S: float, K: float, T: float, r: float, sigma: float, option_type: str = "call") -> dict:
        """
        Tính toán tất cả Greeks
        S: Giá underlying
        K: Strike price
        T: Thời gian đến expiration (năm)
        r: Risk-free rate
        sigma: Implied volatility
        """
        if T <= 0 or sigma <= 0:
            return {"delta": 0, "gamma": 0, "vega": 0, "theta": 0, "rho": 0}
        
        d1 = BlackScholesGreeks.d1(S, K, T, r, sigma)
        d2 = BlackScholesGreeks.d2(S, K, T, r, sigma)
        
        if option_type == "call":
            delta = norm.cdf(d1)
            rho = K * T * np.exp(-r * T) * norm.cdf(d2) / 100
        else:  # put
            delta = norm.cdf(d1) - 1
            rho = -K * T * np.exp(-r * T) * norm.cdf(-d2) / 100
        
        gamma = norm.pdf(d1) / (S * sigma * np.sqrt(T))
        vega = S * norm.pdf(d1) * np.sqrt(T) / 100
        theta = (-S * norm.pdf(d1) * sigma / (2 * np.sqrt(T)) 
                - r * K * np.exp(-r * T) * (norm.cdf(d2) if option_type == "call" else norm.cdf(-d2))) / 365
        
        return {
            "delta": delta,
            "gamma": gamma,
            "vega": vega,
            "theta": theta,
            "rho": rho
        }


class VolatilityBacktester:
    """
    Volatility Backtesting Engine sử dụng dữ liệu Deribit từ Tardis
    """
    
    def __init__(self, trades_df: pd.DataFrame, greeks_df: pd.DataFrame, ob_df: pd.DataFrame):
        self.trades = trades_df
        self.greeks = greeks_df
        self.orderbook = ob_df
        self.bs = BlackScholesGreeks()
    
    def validate_greeks(self, S: float, K: float, T: float, r: float = 0.05) -> pd.DataFrame:
        """
        So sánh Greeks từ Deribit với tính toán Black-Scholes
        """
        results = []
        
        for _, row in self.greeks.iterrows():
            # Sử dụng IV thực tế từ Deribit
            sigma = row.get("mark_iv", 0.5)
            
            # Tính Greeks theo BS
            bs_greeks = self.bs.greeks(
                S=row["underlying_price"],
                K=K,
                T=T,
                r=r,
                sigma=sigma,
                option_type="call"
            )
            
            results.append({
                "timestamp": row["timestamp"],
                "deribit_delta": row.get("delta"),
                "bs_delta": bs_greeks["delta"],
                "delta_error": abs(row.get("delta", 0) - bs_greeks["delta"]),
                "deribit_gamma": row.get("gamma"),
                "bs_gamma": bs_greeks["gamma"],
                "gamma_error": abs(row.get("gamma", 0) - bs_greeks["gamma"]),
                "deribit_vega": row.get("vega"),
                "bs_vega": bs_greeks["vega"],
                "vega_error": abs(row.get("vega", 0) - bs_greeks["vega"]),
            })
        
        return pd.DataFrame(results)
    
    def calculate_volatility_surface(self) -> pd.DataFrame:
        """
        Xây dựng Volatility Surface từ dữ liệu Deribit
        """
        # Group by strike và maturity để tính IV surface
        surface_data = self.greeks.groupby(["strike", "expiration"]).agg({
            "mark_iv": ["mean", "std", "min", "max"],
            "delta": "mean",
            "gamma": "mean",
        }).reset_index()
        
        return surface_data
    
    def backtest_straddle_strategy(
        self, 
        entry_iv_percentile: float = 0.3,
        exit_iv_percentile: float = 0.7,
        holding_days: int = 7
    ) -> dict:
        """
        Backtest chiến lược Straddle trên IV mean reversion
        """
        trades = []
        position = None
        
        for idx, row in self.greeks.iterrows():
            current_iv = row["mark_iv"]
            iv_percentile = self.calculate_iv_percentile(current_iv)
            
            if position is None and iv_percentile <= entry_iv_percentile:
                # Enter long straddle
                position = {
                    "entry_time": row["timestamp"],
                    "entry_iv": current_iv,
                    "entry_price_call": row.get("call_price", 0),
                    "entry_price_put": row.get("put_price", 0),
                }
            
            elif position is not None:
                holding_days_passed = (row["timestamp"] - position["entry_time"]).days >= holding_days
                iv_reached = iv_percentile >= exit_iv_percentile
                
                if holding_days_passed or iv_reached:
                    pnl = (row["mark_price"] - position["entry_price"]) / position["entry_price"]
                    trades.append({
                        **position,
                        "exit_time": row["timestamp"],
                        "exit_iv": current_iv,
                        "pnl_pct": pnl
                    })
                    position = None
        
        return {"trades": trades, "summary": self.calculate_strategy_metrics(trades)}



Sử dụng Backtester

backtester = VolatilityBacktester(trades_df, greeks_df, ob_df)
validation_results = backtester.validate_greeks(S=95000, K=95000, T=0.1, r=0.05)
print("Greeks Validation Results:")
print(validation_results.describe())

Bảng so sánh: Tardis Machine vs Đối thủ

Tiêu chí Tardis Machine Deribit API (chính thức) CoinAPI Bitquery
Giá tháng (Basic) $99/tháng Miễn phí (rate limit 10 req/s) $79/tháng $149/tháng
Giá gói Pro $299/tháng N/A $399/tháng $499/tháng
Dữ liệu Greeks ✅ Đầy đủ ✅ Real-time ⚠️ Hạn chế ❌ Không
L2 Order Book ✅ 100ms snapshots ✅ WebSocket ✅ Có ✅ Có
Historical depth 3 năm 1 tháng 10 năm 2 năm
Latency ~200ms ~20ms ~500ms ~300ms
Export format JSON, CSV, Parquet JSON JSON, CSV GraphQL
Phương thức thanh toán Card, Wire crypto Card, Crypto Card, Wire
Phù hợp Backtesting chuyên nghiệp Trading real-time Multi-exchange data On-chain analysis

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

✅ Nên sử dụng Tardis Machine + HolySheep AI khi:

❌ Không phù hợp khi:

Giá và ROI - Phân tích Chi phí cho Options Backtesting

Giải pháp Giá/tháng API AI (xử lý data) Tổng chi phí ROI dự kiến
Tardis + HolySheep AI $99 + $8 GPT-4.1 $8/MTok ~$150-200 ⭐⭐⭐⭐⭐ Cao nhất
Tardis + OpenAI $99 + $50 GPT-4o ~$15/MTok ~$300-400 ⭐⭐⭐ Trung bình
Deribit API + Claude Miễn phí + $75 Claude 3.5 $15/MTok ~$200-300 ⭐⭐⭐⭐ Khá
CoinAPI + Gemini $79 + $25 Gemini 2.5 $2.50/MTok ~$150 ⭐⭐⭐⭐ Tốt

Tính toán ROI thực tế cho Options Backtesting

Giả sử bạn cần xử lý 10 triệu rows dữ liệu Deribit options để train model:

Vì sao nên kết hợp Tardis với HolySheep AI?

Trong quá trình xây dựng hệ thống backtesting options, tôi đã thử nghiệm nhiều combo. Điểm yếu lớn nhất là chi phí API khi cần xử lý lượng lớn dữ liệu Greeks và tính toán volatility surface. HolySheep AI giải quyết vấn đề này với:

Mã kết nối HolySheep AI cho Options Analysis

import requests
import json

HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"

def analyze_options_greeks_with_ai(
    symbol: str,
    greeks_data: dict,
    model: str = "deepseek-v3.2"  # Model rẻ nhất, hiệu quả cao
) -> dict:
    """
    Sử dụng HolySheep AI để phân tích Greeks và đề xuất chiến lược
    Chi phí chỉ $0.42/MTok với DeepSeek V3.2
    """
    prompt = f"""
    Phân tích dữ liệu Options Deribit cho {symbol}:
    
    Greeks hiện tại:
    - Delta: {greeks_data.get('delta')}
    - Gamma: {greeks_data.get('gamma')}
    - Vega: {greeks_data.get('vega')}
    - Theta: {greeks_data.get('theta')}
    - Implied Volatility: {greeks_data.get('mark_iv')}
    
    Giá Underlying: {greeks_data.get('underlying_price')}
    Strike: {greeks_data.get('strike')}
    
    Hãy đề xuất:
    1. Đánh giá rủi ro delta, gamma
    2. Chiến lược delta-neutral nếu có
    3. Khuyến nghị hedge sử dụng futures
    """
    
    response = requests.post(
        f"{HOLYSHEEP_BASE_URL}/chat/completions",
        headers={
            "Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
            "Content-Type": "application/json"
        },
        json={
            "model": model,
            "messages": [{"role": "user", "content": prompt}],
            "temperature": 0.3,
            "max_tokens": 1000
        }
    )
    
    result = response.json()
    return {
        "analysis": result["choices"][0]["message"]["content"],
        "usage": result.get("usage", {}),
        "model": model,
        "cost": result["usage"]["total_tokens"] / 1_000_000 * 0.42  # $0.42/MTok
    }


Ví dụ sử dụng

sample_greeks = {
    "delta": 0.55,
    "gamma": 0.002,
    "vega": 0.15,
    "theta": -0.05,
    "mark_iv": 0.72,
    "underlying_price": 95000,
    "strike": 95000
}

analysis = analyze_options_greeks_with_ai("BTC-28MAR25-95000-C", sample_greeks)
print(f"Phân tích: {analysis['analysis']}")
print(f"Chi phí API: ${analysis['cost']:.4f}")

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

Lỗi 1: Tardis API Rate Limit khi tải dữ liệu lớn

Mô tả lỗi: Khi cố tải dữ liệu historical dài ( > 6 tháng), Tardis trả về lỗi 429 Too Many Requests.

# ❌ SAI - Gây rate limit ngay lập tức
async def download_all_data():
    async with Device(config) as device:
        async for msg in device.messages():  # Tải tất cả một lần
            process(msg)


✅ ĐÚNG - Download theo chunk với retry logic

import asyncio
import aiohttp

async def download_with_retry(
    config: dict,
    max_retries: int = 3,
    chunk_days: int = 7  # Tải theo từng tuần
):
    """Download dữ liệu Tardis theo chunk để tránh rate limit"""
    
    start = datetime.fromisoformat(config["start_time"])
    end = datetime.fromisoformat(config["end_time"])
    current = start
    all_data = []
    
    while current < end:
        chunk_end = min(current + timedelta(days=chunk_days), end)
        
        for attempt in range(max_retries):
            try:
                chunk_config = {
                    **config,
                    "start_time": current.isoformat(),
                    "end_time": chunk_end.isoformat(),
                }
                
                async with Device(chunk_config) as device:
                    chunk_data = []
                    async for msg in device.messages():
                        chunk_data.append(msg)
                    
                    all_data.extend(chunk_data)
                    print(f"✓ Downloaded chunk: {current} → {chunk_end}, {len(chunk_data)} records")
                    break
                    
            except Exception as e:
                if attempt < max_retries - 1:
                    wait_time = 2 ** attempt  # Exponential backoff
                    print(f"⚠ Retry {attempt+1} sau {wait_time}s...")
                    await asyncio.sleep(wait_time)
                else:
                    print(f"❌ Lỗi chunk {current}: {e}")
        
        current = chunk_end
    
    return all_data

Lỗi 2: Greeks từ Deribit không khớp với Black-Scholes

Mô tả lỗi: Khi validate Greeks, chênh lệch giữa Deribit Greeks và BS Greeks lên tới 10-20%.

# ❌ SAI - Không tính đến discrete dividends và funding
def naive_bs_delta(S, K, T, r, sigma):
    d1 = (np.log(S/K) + (r + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
    return norm.cdf(d1)  # Không chính xác cho futures options


✅ ĐÚNG - Sử dụng futures options pricing model

def futures_options_delta(
    F: float,      # Futures price (Deribit dùng futures price)
    K: float,      # Strike
    T: float,      # Time to expiry (years)
    r: float,      # Risk-free rate
    b: float,      # Cost of carry (có thể âm cho crypto)
    sigma: float,  # Volatility
    option_type: str = "call"
) -> float:
    """
    Black-76 Model cho Futures Options (Deribit sử dụng model này)
    Đây là lý do Greeks không khớp với Black-Scholes thông thường
    """
    if T <= 0 or sigma <= 0:
        return 0.0
    
    d1 = (np.log(F/K) + (b + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
    d2 = d1 - sigma * np.sqrt(T)
    
    if option_type == "call":
        return np.exp((b - r) * T) * norm.cdf(d1)
    else:
        return np.exp((b - r) * T) * (norm.cdf(d1) - 1)

def validate_deribit_greeks_accurate(deribit_greeks: pd.DataFrame) -> pd.DataFrame:
    """
    Validate Greeks với Black-76 model (khớp với Deribit)
    """
    results = []
    
    for _, row in deribit_greeks.iterrows():
        F = row["underlying_price"]  # Futures price
        K = row["strike"]
        T = row

Tài nguyên liên quan
Bài viết liên quan