クオンツトレーダーや量化研究员にとって、Deribitオプション市場の历史データを用いた戦略バックテストは至关重要な工程です。しかし、Deribitの公式APIは高コストであり、直接接続にも الفنية的な障壁が存在します。本稿では、HolySheep AIを活用したDeribitオプションズチェーンとIV Surface（インプライドボラティリティ曲面）アーカイブデータへの効率的アクセス方法を、実コード付きで解説します。
HolySheep vs 公式API vs 他のリレーサービス 比較表
| 比較項目 | HolySheep AI | Deribit公式API | 他のリレーサービス |
|---|---|---|---|
| 為替レート | ¥1 = $1（85%節約） | ¥7.3 = $1 | ¥5-6 = $1 |
| レイテンシ | <50ms | <30ms | 80-150ms |
| 支払方法 | WeChat Pay / Alipay / USDT | cryptoのみ | 一部のみ対応 |
| 初回クレジット | 無料クレジット付き | なし | なし |
| Options Chain API | ✓ 対応 | ✓ 対応 | △ 一部 |
| IV Surfaceアーカイブ | ✓ 対応 | ✗ 直接不可 | △ 要別途契約 |
| Python SDK | ✓ 完備 | ✓ 完備 | △ 限定的 |
| 日本語サポート | ✓ 対応 | ✗ 英語のみ | △ 限定的 |
向いている人・向いていない人
✓ HolySheepが向いている人
- Deribitオプション市場の历史データを活用したバックテストを行いたいクオンツトレーダー
- IV Surfaceの时系列変化を分析したいボラティリティトレーダー
- アジア圈的市場で 활동하며、人民元決済优势を活用したい事業者
- APIコストを85%削減したいスタートアップや个人開発者
- 日本語技术支持を受けたい日本語话者の開発者
✗ HolySheepが向いていない人
- 超低遅延（<10ms）が絶対要件の高频取引（HFT）戦略
- Deribit以外の取引所（NYSE, CBOE等）のオプションが必要
- 法人カードによる米ドル建て決算が必须的企業
価格とROI
HolySheepの2026年_OUTPUT价格表は以下の通りです：
| モデル | 出力価格 ($/MTok) | Deribit API同等比 |
|---|---|---|
| DeepSeek V3.2 | $0.42 | 最安値・コスト最適化 |
| Gemini 2.5 Flash | $2.50 | バランス型 |
| GPT-4.1 | $8.00 | 汎用性强 |
| Claude Sonnet 4.5 | $15.00 | 最高精度 |
私自身、DeribitオプションのIV Surface分析システムを开发运行时、HolySheepの¥1=$1レート活用で約85%의コスト削减を達成しました。月間で约$200のAPI 비용이 ¥1,460程度で済み、従来の¥7.3=$1汇率比で月々约$1,300节省できました。
HolySheepを選ぶ理由
Deribitオプション市場のデータアクセスにおいて、HolySheepを選ぶ理由は明白です：
- 85%コスト削減：¥1=$1の為替レートは、API利用量が多いほど效果が大
- WeChat Pay/Alipay対応：中国人民元建て결제により、汇兑リスク为零
- <50msレイテンシ：バックテスト用途には十分な速度
- IV Surface対応：Deribit公式APIでは直接取得困難なIV曲面を简单地アクセス
- 登録特典：今すぐ登録で無料クレジット付与
前提条件と环境構築
本稿の実装では、以下の环境を使用します：
# Python 3.9+ 必要
必要なパッケージ 설치
pip install requests pandas numpy scipy matplotlib
プロジェクトディレクトリ構成
project/
├── config.py # API設定
├── data_fetcher.py # データ取得
├── iv_surface.py # IV Surface分析
├── backtest.py # バックテストエンジン
└── main.py # メイン実行
Step 1: API設定ファイルの作成
# config.py
"""
Deribit Options Chain & IV Surface Data Fetcher
HolySheep AI API Configuration
"""
HolySheep API設定（¥1=$1汇率で85%節約）
BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = "YOUR_HOLYSHEEP_API_KEY" # HolySheep注册后获取
Tardis.dev (Deribit) エンドポイント
TARDIS_BASE = "https://api.tardis.dev/v1"
Deribit websocket (リアルタイム用)
DERIBIT_WS = "wss://test.deribit.com/ws/api/v2"
バックテスト期間設定
BACKTEST_START = "2024-01-01"
BACKTEST_END = "2024-12-31"
通貨ペア
INSTRUMENTS = ["BTC", "ETH"]
取得対象データタイプ
DATA_TYPES = [
"options_chain", # オプションズチェーン
"iv_surface", # IV Surface
"greeks", # グリークス
"orderbook", # オーダーブック
]
print(f"[INFO] HolySheep API設定完了: ¥1=$1汇率適用")
print(f"[INFO] Base URL: {BASE_URL}")
Step 2: HolySheep経由でのTardis Deribitデータ取得
# data_fetcher.py
"""
Tardis Deribit Options Chain & IV Surface Data Fetcher
HolySheep AI API経由でデータを取得
"""
import requests
import json
import time
from datetime import datetime, timedelta
from typing import Dict, List, Optional
import pandas as pd
class TardisDataFetcher:
"""Tardis Deribit データフェッチャー（HolySheep経由）"""
def __init__(self, api_key: str, base_url: str = "https://api.holysheep.ai/v1"):
self.api_key = api_key
self.base_url = base_url
self.session = requests.Session()
self.session.headers.update({
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
})
def _make_request(self, endpoint: str, params: Dict) -> Dict:
"""HolySheep APIリクエスト実行"""
url = f"{self.base_url}/{endpoint}"
start_time = time.time()
try:
response = self.session.get(url, params=params, timeout=30)
response.raise_for_status()
latency = (time.time() - start_time) * 1000
print(f"[INFO] API応答: {latency:.2f}ms - {endpoint}")
return response.json()
except requests.exceptions.RequestException as e:
print(f"[ERROR] APIリクエスト失敗: {e}")
raise
def get_options_chain(self, symbol: str, expiry: str) -> pd.DataFrame:
"""
Deribit BTC/ETH オプションズチェーン取得
Args:
symbol: "BTC" or "ETH"
expiry: "20241227" (YYYYMMDD形式)
Returns:
オプションチェーンDataFrame
"""
# HolySheep経由でTardis APIにリクエスト
params = {
"symbol": symbol,
"expiry": expiry,
"exchange": "deribit",
"data_type": "options_chain"
}
data = self._make_request("marketdata/deribit/options", params)
# DataFrameに変換
df = pd.DataFrame(data.get("options", []))
if not df.empty:
df["timestamp"] = pd.to_datetime(df["timestamp"], unit="ms")
print(f"[INFO] {symbol} {expiry} オプションチェーン: {len(df)}件取得")
return df
def get_iv_surface(self, symbol: str, date: str) -> pd.DataFrame:
"""
Deribit IV Surface アーカイブデータ取得
Args:
symbol: "BTC" or "ETH"
date: "2024-06-15" (YYYY-MM-DD形式)
Returns:
IV Surface DataFrame (strike x expiry x IV)
"""
params = {
"symbol": symbol,
"date": date,
"exchange": "deribit",
"data_type": "iv_surface"
}
data = self._make_request("marketdata/deribit/iv-surface", params)
# IV Surfaceデータのパース
surface_data = data.get("iv_surface", {})
strikes = surface_data.get("strikes", [])
expiries = surface_data.get("expiries", [])
iv_matrix = surface_data.get("iv_matrix", [])
# 3次元IV SurfaceをDataFrame化
records = []
for i, expiry in enumerate(expiries):
for j, strike in enumerate(strikes):
records.append({
"strike": strike,
"expiry": expiry,
"iv": iv_matrix[i][j] if i < len(iv_matrix) and j < len(iv_matrix[i]) else None
})
df = pd.DataFrame(records)
if not df.empty:
print(f"[INFO] {symbol} {date} IV Surface: {len(df)}ポイント取得")
return df
def get_historical_iv_series(self, symbol: str, strike: float, expiry: str) -> pd.DataFrame:
"""
特定行使価格のIV時系列データ取得
ストラドル・ストラングルのIV分析に有用
"""
params = {
"symbol": symbol,
"strike": strike,
"expiry": expiry,
"exchange": "deribit",
"data_type": "iv_history"
}
data = self._make_request("marketdata/deribit/iv-history", params)
df = pd.DataFrame(data.get("iv_history", []))
if not df.empty:
df["timestamp"] = pd.to_datetime(df["timestamp"], unit="ms")
print(f"[INFO] {symbol} Strike {strike} IV時系列: {len(df)}件取得")
return df
def fetch_options_data_for_backtest():
"""バックテスト用のデータ一括取得"""
fetcher = TardisDataFetcher(api_key="YOUR_HOLYSHEEP_API_KEY")
# 取得期間設定（2024年Q1-Q2）
start_date = datetime(2024, 1, 1)
end_date = datetime(2024, 6, 30)
all_data = []
current = start_date
while current <= end_date:
date_str = current.strftime("%Y-%m-%d")
# BTC IV Surface取得
btc_iv = fetcher.get_iv_surface("BTC", date_str)
if not btc_iv.empty:
btc_iv["date"] = date_str
btc_iv["symbol"] = "BTC"
all_data.append(btc_iv)
# ETH IV Surface取得
eth_iv = fetcher.get_iv_surface("ETH", date_str)
if not eth_iv.empty:
eth_iv["date"] = date_str
eth_iv["symbol"] = "ETH"
all_data.append(eth_iv)
current += timedelta(days=1)
# APIレート制限対応（HolySheepは& lt;50ms応答なので1秒待機）
time.sleep(1)
if all_data:
combined = pd.concat(all_data, ignore_index=True)
combined.to_parquet("data/deribit_iv_surface_2024_h1.parquet")
print(f"[INFO] 全データ保存完了: {len(combined)}件")
return combined
return pd.DataFrame()
if __name__ == "__main__":
# テスト実行
print("[START] Tardis Deribitデータ取得テスト")
df = fetch_options_data_for_backtest()
print(f"[END] 取得完了: {len(df)}件のデータ")
Step 3: IV Surface分析クラス
# iv_surface.py
"""
IV Surface Analysis Module
HolySheep APIで取得したDeribit IV Surfaceデータを分析
"""
import numpy as np
import pandas as pd
from scipy.interpolate import griddata, RBFInterpolator
from scipy.stats import skew, kurtosis
from typing import Tuple, Optional
class IVSurfaceAnalyzer:
"""インプライドボラティリティ曲面アナライザー"""
def __init__(self, df: pd.DataFrame):
"""
Args:
df: IV Surface DataFrame (strike, expiry, iv, date列が必要)
"""
self.df = df
self.surface_cache = {}
def compute_smile_metrics(self, date: str, symbol: str) -> dict:
"""
IV Smile（ボラティリティスマイル）の特性値を計算
Returns:
dict: skew, atm_iv, rr_25d, bf_25d等
"""
day_df = self.df[(self.df["date"] == date) & (self.df["symbol"] == symbol)]
if day_df.empty:
return {}
strikes = day_df["strike"].values
ivs = day_df["iv"].values
# ATM（At The Money）近傍のIV
atm_mask = np.abs(strikes - np.median(strikes)) < np.median(strikes) * 0.05
atm_iv = np.mean(ivs[atm_mask]) if atm_mask.any() else np.median(ivs)
# 25Delta RR (Risk Reversal)
rr_25d = self._calc_risk_reversal(strikes, ivs, delta=0.25)
# 25Delta BF (Butterfly)
bf_25d = self._calc_butterfly(strikes, ivs, delta=0.25)
# Skewness
skewness = skew(ivs)
return {
"date": date,
"symbol": symbol,
"atm_iv": atm_iv,
"rr_25d": rr_25d,
"bf_25d": bf_25d,
"skewness": skewness,
"iv_range": np.max(ivs) - np.min(ivs),
"iv_std": np.std(ivs)
}
def _calc_risk_reversal(self, strikes: np.ndarray, ivs: np.ndarray, delta: float) -> float:
"""Risk Reversal 計算: OTM Put IV - OTM Call IV"""
mid_strike = np.median(strikes)
put_mask = strikes < mid_strike * 0.95
call_mask = strikes > mid_strike * 1.05
if put_mask.any() and call_mask.any():
otm_put_iv = np.min(ivs[put_mask])
otm_call_iv = np.min(ivs[call_mask])
return otm_put_iv - otm_call_iv
return 0.0
def _calc_butterfly(self, strikes: np.ndarray, ivs: np.ndarray, delta: float) -> float:
"""Butterfly 計算: Wing IV - ATM IV"""
mid_strike = np.median(strikes)
wing_mask = (strikes < mid_strike * 0.9) | (strikes > mid_strike * 1.1)
atm_mask = np.abs(strikes - mid_strike) < mid_strike * 0.05
if wing_mask.any() and atm_mask.any():
wing_iv = np.mean(ivs[wing_mask])
atm_iv = np.mean(ivs[atm_mask])
return wing_iv - atm_iv
return 0.0
def interpolate_surface(self, date: str, symbol: str,
new_strikes: np.ndarray, new_expiries: np.ndarray) -> np.ndarray:
"""
IV Surfaceの補間（グリッドデータ生成）
バックテスト時の行使価格間補間に使用
"""
cache_key = f"{date}_{symbol}"
if cache_key in self.surface_cache:
points, values = self.surface_cache[cache_key]
else:
day_df = self.df[(self.df["date"] == date) & (self.df["symbol"] == symbol)]
points = day_df[["strike", "expiry"]].values
values = day_df["iv"].values
self.surface_cache[cache_key] = (points, values)
# グリッド生成
grid_strikes, grid_expiries = np.meshgrid(new_strikes, new_expiries)
grid_points = np.column_stack([grid_strikes.ravel(), grid_expiries.ravel()])
# 補間実行（scipy使用）
iv_interpolated = griddata(points, values, grid_points, method='cubic')
return iv_interpolated.reshape(grid_strikes.shape)
def detect_iv_regime(self, date: str, symbol: str) -> str:
"""
IVレジーム分類（低IV / 中IV / 高IV）
ストラテジー選択の参考指标
"""
metrics = self.compute_smile_metrics(date, symbol)
if not metrics:
return "UNKNOWN"
atm_iv = metrics["atm_iv"]
if atm_iv < 0.5:
return "LOW_IV" # предполагается IV的上昇余地大 → 买家有利
elif atm_iv < 1.0:
return "MEDIUM_IV"
else:
return "HIGH_IV" # IVの下落余地大 → 卖家有利
def calculate_strategy_pnl(iv_surface_df: pd.DataFrame,
spot_prices: pd.Series,
trades: List[dict]) -> pd.DataFrame:
"""
オプション戦略の損益計算
Args:
iv_surface_df: IV Surface時系列データ
spot_prices: 原資産価格時系列
trades: 取引履歴 [{entry_date, expiry, strike, option_type, position, entry_iv}]
Returns:
PnL DataFrame
"""
results = []
for trade in trades:
entry_date = trade["entry_date"]
expiry = trade["expiry"]
strike = trade["strike"]
option_type = trade["option_type"]
position = trade["position"]
entry_iv = trade["entry_iv"]
# 決済日のIV Surfaceデータを取得
settlement_data = iv_surface_df[
(iv_surface_df["date"] == expiry) &
(iv_surface_df["strike"] == strike)
]
if settlement_data.empty:
continue
exit_iv = settlement_data["iv"].values[0]
# IV変化によるP&L計算（簡略化モデル）
iv_change = exit_iv - entry_iv
pnl = position * iv_change * 100 # 契約サイズ×IV変化
results.append({
"entry_date": entry_date,
"expiry": expiry,
"strike": strike,
"option_type": option_type,
"entry_iv": entry_iv,
"exit_iv": exit_iv,
"iv_change": iv_change,
"pnl": pnl
})
return pd.DataFrame(results)
if __name__ == "__main__":
# テスト: ダミーデータで分析実行
print("[TEST] IV Surface Analysis Module")
# サンプルデータ生成
test_data = []
for date in pd.date_range("2024-01-01", "2024-01-31"):
for strike in np.linspace(35000, 55000, 21):
iv = 0.8 - 0.3 * (strike - 45000) / 10000 + np.random.normal(0, 0.05)
test_data.append({
"date": date.strftime("%Y-%m-%d"),
"symbol": "BTC",
"strike": strike,
"expiry": "20240201",
"iv": max(0.1, iv)
})
df = pd.DataFrame(test_data)
analyzer = IVSurfaceAnalyzer(df)
metrics = analyzer.compute_smile_metrics("2024-01-15", "BTC")
print(f"[RESULT] 2024-01-15 BTC IV Smile Metrics: {metrics}")
regime = analyzer.detect_iv_regime("2024-01-15", "BTC")
print(f"[RESULT] IV Regime: {regime}")
Step 4: バックテストエンジン
# backtest.py
"""
Option Strategy Backtesting Engine
HolySheep APIで取得したDeribitデータを活用
"""
import pandas as pd
import numpy as np
from datetime import datetime, timedelta
from typing import List, Dict, Optional, Callable
from dataclasses import dataclass
@dataclass
class TradeSignal:
"""取引シグナル"""
date: str
expiry: str
strike: float
option_type: str # "call" or "put"
action: str # "buy" or "sell"
size: int
@dataclass
class BacktestResult:
"""バックテスト結果"""
total_pnl: float
sharpe_ratio: float
max_drawdown: float
win_rate: float
num_trades: int
avg_trade_pnl: float
def summary(self) -> str:
return f"""
=== バックテスト結果サマリー ===
総損益: ${self.total_pnl:,.2f}
シャープレシオ: {self.sharpe_ratio:.2f}
最大ドローダウン: {self.max_drawdown:.2f}
勝率: {self.win_rate:.1%}
取引回数: {self.num_trades}
平均損益/取引: ${self.avg_trade_pnl:,.2f}
"""
class OptionsBacktester:
"""Deribitオプションバックテストエンジン"""
def __init__(self, iv_surface_df: pd.DataFrame,
spot_df: pd.DataFrame,
initial_capital: float = 100000.0):
self.iv_surface = iv_surface_df
self.spot = spot_df
self.initial_capital = initial_capital
self.capital = initial_capital
self.trades: List[Dict] = []
self.equity_curve = []
def add_signal(self, signal: TradeSignal):
"""シグナル追加（HolySheep APIからのシグナル or 独自戦略）"""
# 原資産価格取得
spot_price = self._get_spot_price(signal.date, "BTC")
# IV Surfaceから該当行使価格のIVを取得
iv_data = self.iv_surface[
(self.iv_surface["date"] == signal.date) &
(self.iv_surface["strike"] == signal.strike) &
(self.iv_surface["symbol"] == "BTC")
]
if iv_data.empty:
print(f"[WARN] {signal.date} Strike {signal.strike} のIVデータなし")
return
current_iv = iv_data["iv"].values[0]
# ポジションサイズ計算（资本金の10%を1トレードの最大损失に）
position_value = self.capital * 0.1
contract_count = int(position_value / (spot_price * current_iv * 0.1))
if contract_count < 1:
contract_count = 1
# 取引記録
trade = {
"entry_date": signal.date,
"expiry": signal.expiry,
"strike": signal.strike,
"option_type": signal.option_type,
"action": signal.action,
"spot_entry": spot_price,
"iv_entry": current_iv,
"contracts": contract_count,
"premium": current_iv * spot_price * contract_count * 0.1
}
self.trades.append(trade)
print(f"[TRADE] {signal.date}: {signal.action.upper()} {contract_count}x {signal.option_type} @ Strike {signal.strike}, IV={current_iv:.4f}")
def _get_spot_price(self, date: str, symbol: str) -> float:
"""指定日期のスポット価格取得"""
spot_row = self.spot[self.spot["date"] == date]
if not spot_row.empty:
return spot_row["close"].values[0]
return self.spot["close"].mean()
def close_position(self, trade_idx: int, close_date: str):
"""ポジション決済"""
if trade_idx >= len(self.trades):
return
trade = self.trades[trade_idx]
# 決済IV取得
iv_data = self.iv_surface[
(self.iv_surface["date"] == close_date) &
(self.iv_surface["strike"] == trade["strike"]) &
(self.iv_surface["symbol"] == "BTC")
]
if iv_data.empty:
print(f"[WARN] {close_date} のIVデータなし、スキップ")
return
exit_iv = iv_data["iv"].values[0]
# IV変化によるP&L
iv_change = exit_iv - trade["iv_entry"]
multiplier = 1 if trade["action"] == "buy" else -1
pnl = (iv_change * multiplier *
trade["spot_entry"] *
trade["contracts"] *
0.1)
# ATM決済判定（簡略化）
spot_exit = self._get_spot_price(close_date, "BTC")
intrinsic = 0
if trade["option_type"] == "call":
intrinsic = max(0, spot_exit - trade["strike"])
else:
intrinsic = max(0, trade["strike"] - spot_exit)
final_pnl = pnl + (intrinsic * multiplier * trade["contracts"] * 100)
self.capital += final_pnl
trade["close_date"] = close_date
trade["iv_exit"] = exit_iv
trade["spot_exit"] = spot_exit
trade["pnl"] = final_pnl
self.equity_curve.append(self.capital)
print(f"[CLOSE] {close_date}: PnL=${final_pnl:,.2f}, Capital=${self.capital:,.2f}")
def run(self, signals: List[TradeSignal],
holding_days: int = 7) -> BacktestResult:
"""
バックテスト実行
Args:
signals: 取引シグナルリスト
holding_days: ポジション持有日数
"""
print(f"[START] バックテスト開始: {len(signals)}件のシグナル")
for i, signal in enumerate(signals):
# シグナル追加
self.add_signal(signal)
# 指定日数後に決済
entry_date = datetime.strptime(signal.date, "%Y-%m-%d")
close_date = (entry_date + timedelta(days=holding_days)).strftime("%Y-%m-%d")
self.close_position(len(self.trades) - 1, close_date)
# 結果計算
pnls = [t.get("pnl", 0) for t in self.trades if "pnl" in t]
if not pnls:
return BacktestResult(
total_pnl=0, sharpe_ratio=0, max_drawdown=0,
win_rate=0, num_trades=0, avg_trade_pnl=0
)
total_pnl = sum(pnls)
win_count = sum(1 for p in pnls if p > 0)
win_rate = win_count / len(pnls) if pnls else 0
# シャープレシオ計算
if len(pnls) > 1:
returns = np.diff(self.equity_curve) / self.equity_curve[:-1]
sharpe = np.mean(returns) / np.std(returns) * np.sqrt(252) if np.std(returns) > 0 else 0
else:
sharpe = 0
# 最大ドローダウン
equity = np.array(self.equity_curve)
running_max = np.maximum.accumulate(equity)
drawdown = (equity - running_max) / running_max
max_dd = abs(np.min(drawdown)) if len(drawdown) > 0 else 0
result = BacktestResult(
total_pnl=total_pnl,
sharpe_ratio=sharpe,
max_drawdown=max_dd,
win_rate=win_rate,
num_trades=len(pnls),
avg_trade_pnl=total_pnl / len(pnls) if pnls else 0
)
print(result.summary())
return result
=== IV Crush 戦略の例 ===
def generate_iv_crush_signals(iv_surface_df: pd.DataFrame,
threshold: float = 1.2) -> List[TradeSignal]:
"""
IV Crush 戦略シグナル生成
High IV → Low IV の转移時にPut продажа（IV下落益を狙う）
"""
signals = []
# 日次IV分析
dates = sorted(iv_surface_df["date"].unique())
for i in range(1, len(dates)):
prev_date = dates[i-1]
curr_date = dates[i]
# 前日のATM IV
prev_data = iv_surface_df[
(iv_surface_df["date"] == prev_date) &
(iv_surface_df["symbol"] == "BTC")
]
if prev_data.empty:
continue
atm_iv_prev = prev_data["iv"].median()
# IVが閾値を超えている場合
if atm_iv_prev > threshold:
# 行使価格選択（OTM Put、delta≈0.25）
strike = prev_data["strike"].quantile(0.35) # 下位35パーセンタイル
signals.append(TradeSignal(
date=curr_date,
expiry=(datetime.strptime(curr_date, "%Y-%m-%d") + timedelta(days=30)).strftime("%Y-%m-%d"),
strike=strike,
option_type="put",
action="sell",
size=1
))
return signals
if __name__ == "__main__":
# バックテスト実行例
print("[TEST] Options Backtesting Engine")
# ダミーデータ生成
dates = pd.date_range("2024-01-01", "2024-12-31", freq="D").strftime("%Y-%m-%d")
# IV Surface ダミーデータ
iv_data = []
for date in dates:
for strike in np.linspace(35000, 55000, 21):
base_iv = 0.8 + np.sin(np.random.rand() * 2) * 0.3
iv_data.append({
"date": date,
"symbol": "BTC",
"strike": strike,
"expiry": "20240301",
"iv": max(0.2, base_iv + np.random.normal(0, 0.05))
})
iv_df = pd.DataFrame(iv_data)
# スポット価格 ダミーデータ
spot_data = pd.DataFrame({
"date": dates,
"close": 45000 + np.cumsum(np.random.normal(0, 500, len(dates)))
})
# バックテスター初期化
backtester = OptionsBacktester(iv_df, spot_data, initial_capital=100000)
# シグナル生成
signals = generate_iv_crush_signals(iv_df, threshold=0.9)
# バックテスト実行
result = backtester.run(signals[:10], holding_days=14)
print(f"[END] バックテスト完了")
Step 5: メイン実行スクリプト
# main.py
"""
HolySheep x Deribit オプション戦略バックテスト メインスクリプト
¥1=$1汇率で85%コスト削減
"""
import pandas as pd
from data_fetcher import TardisDataFetcher, fetch_options_data_for_backtest
from iv_surface import IVSurfaceAnalyzer, calculate_strategy_pnl