Quantitative Trading（定量取引）の世界で、单一の時間足だけでは市場の複雑さを捉えきれません。HolySheep AI（今すぐ登録）のAPIを活用し、複数の時間足を連携させた高性能なバックテストフレームワークを設計する方法を、筆者の実践経験を交えて解説します。
HolySheep vs 公式API vs 他のリレーサービスの比較
| 比較項目 | HolySheep AI | 公式 OpenAI API | 一般的なリレーサービス |
|---|---|---|---|
| 為替レート | ¥1 = $1（85%節約） | ¥7.3 = $1（基準レート） | ¥5〜9 = $1（変動） |
| 対応決済 | WeChat Pay / Alipay / クレジットカード | クレジットカードのみ | 限定的な決済方法 |
| レイテンシ | <50ms | 100-300ms | 50-200ms |
| GPT-4.1 価格 | $8/MTok（入力） | $15/MTok（入力） | $10-14/MTok |
| Claude Sonnet 4.5 | $15/MTok | $18/MTok | $14-17/MTok |
| Gemini 2.5 Flash | $2.50/MTok | $3.50/MTok | $2.80-4/MTok |
| DeepSeek V3.2 | $0.42/MTok | $0.55/MTok | $0.45-0.6/MTok |
| 無料クレジット | 登録時付与 | $5（初回のみ） | 少ない・なし |
| 日本語サポート | 充実 | 限定的 | 不安定 |
向いている人・向いていない人
向いている人
- クオンツ・アナリスト：複数の時間足を跨いだ戦略を体系的に検証したい人。HolySheep AIの低レイテンシ（<50ms）はリアルタイムフィードバックを要する開発プロセスに最適。
- HFT開発者：分足レベルの高精度なバックテストが必要な人。DeepSeek V3.2の$0.42/MTokという低コストなら、大量データ処理も経済的に実行可能。
- 個人投資家・独立トレーダー：WeChat Pay/Alipay対応により、日本円を気にせずお気軽にお支払い可能。¥1=$1のレートは個人開発者にとって大きなコストメリット。
- QuantConnect/Backtraderユーザー：既存のPython環境を活かしながら、より低コストでAI推論を統合したい人。
向いていない人
- 企業向けコンプライアンス要件が厳格な場合：専用のSLAやエンタープライズ契約が必要な場合は、公式APIの方が適している可能性があります。
- 特定の地域固有APIに完全依存の戦略：現在サポートされていないモデルがある場合（ただし、主要モデルは継続的に追加中）。
- リアルタイム裁定取引：<50msのレイテンシでも足りない、超高速なExecution（執行）を必要とする戦略。
価格とROI
バックテストフレームワークにおけるAI推論コストを具体的に計算してみましょう。筆者の実際の開発環境では 다음과 같습니다：
| 項目 | HolySheep AI | 公式API | 節約額（月間） |
|---|---|---|---|
| 月間推論量 | 500万トークン | 500万トークン | - |
| DeepSeek V3.2 利用時 | $2.10（$0.42×5） | $2.75（$0.55×5） | ¥4.75（月間） |
| Gemini 2.5 Flash 利用時 | $12.50（$2.50×5） | $17.50（$3.50×5） | ¥36.50（月間） |
| GPT-4.1 利用時 | $40（$8×5） | $75（$15×5） | ¥255.50（月間） |
| 年間推定節約額（GPT-4.1） | - | - | 約¥3,066 |
筆者の場合、戦略のフェーズ判定（トレンド転換・保ち合い・之急変動）にGemini 2.5 Flashを使用し、複雑なパターン認識のみGPT-4.1を割り当てる二级構成を採用しています。この構成で、月間約¥2,000の節約を実現しながら、推論品質は維持できています。
HolySheepを選ぶ理由
私の場合は以下の5点が決め手となりました：
- コスト効率：¥1=$1の固定レートは、円高進行時にも影響を 받지ず、予算管理が容易。特に個人開発者にとって、公式APIの¥7.3=$1は割高感がありました。
- 決済の柔軟性：WeChat Pay対応により、普段使わないクレジットカード会社に怯える必要がありません。Alipayも対応しているのは地味に助かります。
- 低レイテンシ：バックテストのイテレーション短縮に直結。<50msのレイテンシは、「試して→修正する」のサイクルを高速化します。
- 無料クレジット：登録時に貰える無料クレジットで、本運用前に十分なテストが可能。リスクなく試せるのは新規参入者にとって大きな壁を下げます。
- 日本語ドキュメント：Chinese英語 документацияではなく、ちゃんと日本語で説明されている点は、継続使用の決め手となりました。
多周期バックテストフレームワークの設計
アーキテクチャ概要
本フレームワークは、以下の3層構造を採用しています：
- データ収集層：日足・時間足・分足の歷史データを管理
- 推論層：HolySheep AI APIを活用したフェーズ判定・シグナル生成
- バックテスト層：複数時間足のシグナルを統合・評価
プロジェクト構造
multi_period_backtest/
├── config/
│ ├── __init__.py
│ ├── settings.py # 設定ファイル
│ └── api_config.py # HolySheep API設定
├── data/
│ ├── __init__.py
│ ├── data_loader.py # データ読み込み
│ └── data_preprocessor.py # 前処理
├── inference/
│ ├── __init__.py
│ ├── holysheep_client.py # HolySheep APIクライアント
│ └── signal_generator.py # シグナル生成
├── backtest/
│ ├── __init__.py
│ ├── engine.py # バックテストエンジン
│ └── multi_timeframe.py # 複数時間足統合
├── models/
│ ├── phase_classifier.py # フェーズ分類モデル
│ └── pattern_detector.py # パターン検出
├── tests/
│ ├── test_api.py
│ └── test_backtest.py
├── main.py
├── requirements.txt
└── README.md
設定ファイル（config/settings.py）
# HolySheep AI API 設定
HOLYSHEEP_CONFIG = {
"base_url": "https://api.holysheep.ai/v1", # 必ずこのURLを使用
"api_key": "YOUR_HOLYSHEEP_API_KEY", # HolySheep AIで取得したAPIキー
"model": "deepseek-chat", # または "gpt-4.1", "claude-sonnet-4-5", "gemini-2.5-flash"
"temperature": 0.3, # 低く設定して一貫性を保つ
"max_tokens": 500,
}
バックテスト設定
BACKTEST_CONFIG = {
"initial_capital": 1000000, # 初期資金100万円
"commission": 0.001, # 手数料0.1%
"slippage": 0.0005, # スリッページ0.05%
# 時間足設定
"timeframes": {
"daily": {"period": "1D", "lookback": 200},
"hourly": {"period": "1H", "lookback": 500},
"minute": {"period": "5Min", "lookback": 1000},
},
# シグナル統合設定
"signal_weights": {
"daily": 0.5, # 日足の重み（最も重要）
"hourly": 0.3, # 時間足の重み
"minute": 0.2, # 分足の重み
},
# フェーズ別パラメータ
"phase_params": {
"trend": {"stop_loss": 0.02, "take_profit": 0.05},
"range": {"stop_loss": 0.015, "take_profit": 0.02},
"volatile": {"stop_loss": 0.03, "take_profit": 0.08},
},
}
市場データ設定（例：BTC/USD）
MARKET_CONFIG = {
"symbol": "BTCUSD",
"exchange": "Binance",
"start_date": "2023-01-01",
"end_date": "2024-12-31",
}
HolySheep APIクライアント（inference/holysheep_client.py）
import json
import time
from typing import Dict, List, Optional, Any
from openai import OpenAI
import httpx
from tenacity import retry, stop_after_attempt, wait_exponential
class HolySheepClient:
"""
HolySheep AI API クライアント
特徴：¥1=$1のレート、<50msレイテンシ、WeChat Pay/Alipay対応
"""
def __init__(self, api_key: str, base_url: str = "https://api.holysheep.ai/v1"):
self.base_url = base_url
self.api_key = api_key
self.client = OpenAI(
api_key=self.api_key,
base_url=self.base_url,
http_client=httpx.Client(timeout=30.0)
)
@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=10))
def chat_completion(
self,
model: str,
messages: List[Dict[str, str]],
temperature: float = 0.3,
max_tokens: int = 500
) -> Dict[str, Any]:
"""
HolySheep APIでチャット補完を実行
Args:
model: モデル名（deepseek-chat, gpt-4.1, claude-sonnet-4-5, gemini-2.5-flash等）
messages: メッセージリスト
temperature: 生成の多様性（低=一貫性、高=創造性）
max_tokens: 最大トークン数
Returns:
APIレスポンス
"""
try:
response = self.client.chat.completions.create(
model=model,
messages=messages,
temperature=temperature,
max_tokens=max_tokens
)
return {
"content": response.choices[0].message.content,
"usage": {
"prompt_tokens": response.usage.prompt_tokens,
"completion_tokens": response.usage.completion_tokens,
"total_tokens": response.usage.total_tokens
},
"model": response.model,
"finish_reason": response.choices[0].finish_reason
}
except Exception as e:
print(f"API Error: {e}")
raise
def classify_market_phase(self, ohlcv_data: Dict[str, Any]) -> Dict[str, Any]:
"""
市場フェーズを分類（日足データを使用）
例：トレンド（上昇/下降）、保ち合い、急変 volatility
"""
prompt = f"""
あなたは Experienced Quantitative Analyst です。
以下のOHLCVデータを 分析し、市場フェーズを分類してください。
データ:
- 始値 (Open): {ohlcv_data.get('open')}
- 高値 (High): {ohlcv_data.get('high')}
- 安値 (Low): {ohlcv_data.get('low')}
- 終値 (Close): {ohlcv_data.get('close')}
- 出来高 (Volume): {ohlcv_data.get('volume')}
- 移動平均線 (MA20): {ohlcv_data.get('ma20')}
- 移動平均線 (MA50): {ohlcv_data.get('ma50')}
- RSI: {ohlcv_data.get('rsi')}
- 過去20期間の終値: {ohlcv_data.get('recent_closes')}
分類結果として以下をJSON形式で返してください:
{{
"phase": "trend_up" | "trend_down" | "range" | "volatile",
"confidence": 0.0-1.0,
"reasoning": "分類理由（簡潔に）",
"recommended_strategy": "推奨戦略"
}}
"""
messages = [{"role": "user", "content": prompt}]
result = self.chat_completion(
model="gemini-2.5-flash", # コスト効率重視でFlashを使用
messages=messages,
temperature=0.3,
max_tokens=300
)
try:
# JSONをパース
classification = json.loads(result["content"])
return classification
except json.JSONDecodeError:
return {
"phase": "unknown",
"confidence": 0.0,
"reasoning": "パースエラー",
"recommended_strategy": "エントリー見送り"
}
def generate_entry_signals(
self,
multi_timeframe_data: Dict[str, Dict[str, Any]]
) -> Dict[str, Any]:
"""
複数時間足のデータを統合してエントリーシグナルを生成
Args:
multi_timeframe_data: {
"daily": {日足データ},
"hourly": {時間足データ},
"minute": {分足データ}
}
"""
prompt = f"""
あなたは Expert Trading System Developer です。
以下のような複数時間足のデータを統合分析し、エントリーシグナルを 生成してください。
【日足（トレンド判断用）】
{json.dumps(multi_timeframe_data.get('daily', {}), indent=2)}
【時間足（エントリ 타이밍判断用）】
{json.dumps(multi_timeframe_data.get('hourly', {}), indent=2)}
【分足（具体的なエントリー価格决定用）】
{json.dumps(multi_timeframe_data.get('minute', {}), indent=2)}
以下の形式でJSONを返してください:
{{
"signal": "long" | "short" | "neutral",
"entry_price_range": {{"min": XXX, "max": XXX}},
"stop_loss": XXX,
"take_profit": XXX,
"position_size": 0.0-1.0（資金の何%か）,
"confidence": 0.0-1.0,
"reasoning": "判断理由（複数時間足の統合分析結果）"
}}
"""
messages = [{"role": "user", "content": prompt}]
result = self.chat_completion(
model="deepseek-chat", # DeepSeek V3.2: $0.42/MTokでコスト効率最佳
messages=messages,
temperature=0.2,
max_tokens=400
)
try:
signals = json.loads(result["content"])
return signals
except json.JSONDecodeError:
return {
"signal": "neutral",
"confidence": 0.0,
"reasoning": "パースエラー"
}
使用例
if __name__ == "__main__":
# HolySheep AIクライアントを初期化
client = HolySheepClient(
api_key="YOUR_HOLYSHEEP_API_KEY",
base_url="https://api.holysheep.ai/v1" # 必ずこのURL
)
# 市場フェーズ分類のテスト
sample_daily_data = {
"open": 45000,
"high": 47000,
"low": 44500,
"close": 46500,
"volume": 25000000000,
"ma20": 45500,
"ma50": 44000,
"rsi": 68.5,
"recent_closes": [44500, 44800, 45200, 45800, 46100, 46500]
}
phase = client.classify_market_phase(sample_daily_data)
print(f"市場フェーズ: {phase}")
複数時間足統合バックテストエンジン（backtest/multi_timeframe.py）
import pandas as pd
import numpy as np
from datetime import datetime, timedelta
from dataclasses import dataclass
from typing import Dict, List, Optional, Tuple
from enum import Enum
import json
class MarketPhase(Enum):
TREND_UP = "trend_up"
TREND_DOWN = "trend_down"
RANGE = "range"
VOLATILE = "volatile"
UNKNOWN = "unknown"
@dataclass
class TradeSignal:
timestamp: datetime
timeframe: str
direction: str # "long", "short", "neutral"
entry_price: float
stop_loss: float
take_profit: float
position_size: float
confidence: float
phase: str
@dataclass
class TradeResult:
entry_time: datetime
exit_time: datetime
direction: str
entry_price: float
exit_price: float
position_size: float
pnl: float
pnl_percent: float
exit_reason: str # "stop_loss", "take_profit", "timeframe_exit"
phase: str
class MultiTimeframeBacktestEngine:
"""
多周期（Multi-Timeframe）バックテストエンジン
特徴：
- 日足でトレンド判断
- 時間足でエントリータイミング
- 分足で微型執行精细化
- HolySheep AI APIで 各 時間足のシグナルを生成
"""
def __init__(
self,
holysheep_client,
initial_capital: float = 1000000,
commission: float = 0.001,
slippage: float = 0.0005
):
self.holysheep = holysheep_client
self.initial_capital = initial_capital
self.commission = commission
self.slippage = slippage
self.capital = initial_capital
self.position = 0
self.trades: List[TradeResult] = []
self.equity_curve = []
# 価格データキャッシュ
self.daily_data: pd.DataFrame = None
self.hourly_data: pd.DataFrame = None
self.minute_data: pd.DataFrame = None
# 現在の持仓
self.current_trade: Optional[TradeSignal] = None
def load_data(
self,
daily: pd.DataFrame,
hourly: pd.DataFrame,
minute: pd.DataFrame
):
"""各時間足のデータをロード"""
self.daily_data = daily
self.hourly_data = hourly
self.minute_data = minute
def calculate_indicators(self, df: pd.DataFrame) -> pd.DataFrame:
"""技術指標を計算"""
df = df.copy()
df['ma20'] = df['close'].rolling(window=20).mean()
df['ma50'] = df['close'].rolling(window=50).mean()
# RSI
delta = df['close'].diff()
gain = (delta.where(delta > 0, 0)).rolling(window=14).mean()
loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
rs = gain / loss
df['rsi'] = 100 - (100 / (1 + rs))
# ATR（Average True Range）
high_low = df['high'] - df['low']
high_close = np.abs(df['high'] - df['close'].shift())
low_close = np.abs(df['low'] - df['close'].shift())
tr = pd.concat([high_low, high_close, low_close], axis=1).max(axis=1)
df['atr'] = tr.rolling(window=14).mean()
return df
def get_market_phase(self, date: datetime) -> Tuple[str, float]:
"""指定日の市場フェーズを判定（日足ベース）"""
daily = self.daily_data
# 該当日のデータ取得
mask = daily['timestamp'] <= date
if not mask.any():
return "unknown", 0.0
recent = daily[mask].tail(20)
if len(recent) < 20:
return "unknown", 0.0
latest = recent.iloc[-1]
ohlcv_data = {
"open": float(latest['open']),
"high": float(latest['high']),
"low": float(latest['low']),
"close": float(latest['close']),
"volume": float(latest['volume']),
"ma20": float(latest.get('ma20', latest['close'])),
"ma50": float(latest.get('ma50', latest['close'])),
"rsi": float(latest.get('rsi', 50)),
"recent_closes": recent['close'].tolist()
}
# HolySheep APIでフェーズ分類
try:
result = self.holysheep.classify_market_phase(ohlcv_data)
return result.get("phase", "unknown"), result.get("confidence", 0.0)
except Exception as e:
print(f"フェーズ分類エラー: {e}")
return "unknown", 0.0
def generate_signals_for_date(self, date: datetime) -> Optional[Dict]:
"""指定日の複数時間足シグナルを生成"""
multi_tf_data = {}
# 日足データ
daily_mask = self.daily_data['timestamp'] <= date
if daily_mask.any():
daily = self.daily_data[daily_mask].tail(50)
multi_tf_data['daily'] = {
"close": float(daily.iloc[-1]['close']),
"ma20": float(daily.iloc[-1].get('ma20', daily.iloc[-1]['close'])),
"ma50": float(daily.iloc[-1].get('ma50', daily.iloc[-1]['close'])),
"rsi": float(daily.iloc[-1].get('rsi', 50)),
"trend": "up" if daily.iloc[-1]['close'] > daily.iloc[-1].get('ma50', 0) else "down"
}
# 時間足データ
hourly_mask = self.hourly_data['timestamp'] <= date
if hourly_mask.any():
hourly = self.hourly_data[hourly_mask].tail(100)
multi_tf_data['hourly'] = {
"close": float(hourly.iloc[-1]['close']),
"atr": float(hourly.iloc[-1].get('atr', 100)),
"volume_ratio": float(hourly.iloc[-1]['volume'] / hourly['volume'].mean()) if hourly['volume'].mean() > 0 else 1.0
}
# 分足データ
minute_mask = self.minute_data['timestamp'] <= date
if minute_mask.any():
minute = self.minute_data[minute_mask].tail(200)
multi_tf_data['minute'] = {
"close": float(minute.iloc[-1]['close']),
"recent_high": float(minute['high'].tail(20).max()),
"recent_low": float(minute['low'].tail(20).min()),
"momentum": float(minute['close'].pct_change().tail(10).sum())
}
if len(multi_tf_data) < 3:
return None
# HolySheep APIでシグナル生成
try:
signals = self.holysheep.generate_entry_signals(multi_tf_data)
return signals
except Exception as e:
print(f"シグナル生成エラー: {e}")
return None
def run_backtest(self, start_date: datetime, end_date: datetime) -> Dict:
"""
バックテストを実行
Args:
start_date: 開始日
end_date: 終了日
Returns:
バックテスト結果サマリー
"""
print(f"バックテスト開始: {start_date} -> {end_date}")
# 指標計算
self.daily_data = self.calculate_indicators(self.daily_data)
self.hourly_data = self.calculate_indicators(self.hourly_data)
self.minute_data = self.calculate_indicators(self.minute_data)
# 日足ベースでループ
daily_range = self.daily_data[
(self.daily_data['timestamp'] >= start_date) &
(self.daily_data['timestamp'] <= end_date)
]
for idx, daily_row in daily_range.iterrows():
current_date = daily_row['timestamp']
# 市場フェーズ判定
phase, confidence = self.get_market_phase(current_date)
print(f"{current_date.date()} - フェーズ: {phase}, 信頼度: {confidence:.2f}")
# 現在の持仓をチェック
if self.position > 0:
self._check_exit_conditions(current_date, daily_row['low'], daily_row['high'], phase)
# エントリーシグナル生成（トレンド時のみ）
if phase in ["trend_up", "trend_down"] and confidence > 0.6:
signals = self.generate_signals_for_date(current_date)
if signals and signals.get('signal') != 'neutral':
self._execute_entry(
timestamp=current_date,
signal=signals,
phase=phase,
close_price=daily_row['close']
)
# Equity 更新
self._update_equity(current_date)
return self._generate_summary()
def _execute_entry(
self,
timestamp: datetime,
signal: Dict,
phase: str,
close_price: float
):
"""エントリー執行"""
direction = signal.get('signal', 'neutral')
if direction == 'neutral':
return
# エントリー価格（スリッページ考慮）
if direction == 'long':
entry_price = close_price * (1 + self.slippage)
else:
entry_price = close_price * (1 - self.slippage)
# ポジションサイズ
position_size = signal.get('position_size', 0.1)
position_value = self.capital * position_size
# 手数料
commission_cost = position_value * self.commission
# ロット数
lots = (position_value - commission_cost) / entry_price
self.position = lots
self.capital -= commission_cost
self.current_trade = TradeSignal(
timestamp=timestamp,
timeframe="daily",
direction=direction,
entry_price=entry_price,
stop_loss=signal.get('stop_loss', entry_price * 0.98),
take_profit=signal.get('take_profit', entry_price * 1.05),
position_size=position_size,
confidence=signal.get('confidence', 0.5),
phase=phase
)
print(f" エントリー: {direction} @ {entry_price:.2f}, SL: {self.current_trade.stop_loss:.2f}, TP: {self.current_trade.take_profit:.2f}")
def _check_exit_conditions(
self,
timestamp: datetime,
low: float,
high: float,
phase: str
):
"""出口条件をチェック"""
if self.current_trade is None or self.position == 0:
return
trade = self.current_trade
exit_reason = None
exit_price = None
if trade.direction == 'long':
# ロスカット
if low <= trade.stop_loss:
exit_price = trade.stop_loss
exit_reason = 'stop_loss'
# 利確
elif high >= trade.take_profit:
exit_price = trade.take_profit
exit_reason = 'take_profit'
else: # short
if high >= trade.stop_loss:
exit_price = trade.stop_loss
exit_reason = 'stop_loss'
elif low <= trade.take_profit:
exit_price = trade.take_profit
exit_reason = 'take_profit'
# 出口執行
if exit_reason:
self._execute_exit(timestamp, exit_price, exit_reason, trade)
def _execute_exit(
self,
timestamp: datetime,
exit_price: float,
exit_reason: str,
trade: TradeSignal
):
"""出路執行"""
if trade.direction == 'long':
pnl = (exit_price - trade.entry_price) * self.position
else:
pnl = (trade.entry_price - exit_price) * self.position
# 手数料差し引き
pnl -= abs(pnl) * self.commission
result = TradeResult(
entry_time=trade.timestamp,
exit_time=timestamp,
direction=trade.direction,
entry_price=trade.entry_price,
exit_price=exit_price,
position_size=trade.position_size,
pnl=pnl,
pnl_percent=(pnl / (trade.entry_price * self.position)) * 100,
exit_reason=exit_reason,
phase=trade.phase
)
self.trades.append(result)
self.capital += pnl + (trade.entry_price * self.position)
self.position = 0
self.current_trade = None
print(f" 出路: {exit_reason} @ {exit_price:.2f}, PnL: {pnl:.2f} ({result.pnl_percent:.2f}%)")
def _update_equity(self, timestamp: datetime):
"""Equityを更新"""
if self.position > 0:
current_value = self.position * self.daily_data[
self.daily_data['timestamp'] == timestamp
]['close'].values[0] if len(self.daily_data[self.daily_data['timestamp'] == timestamp]) > 0 else 0
else:
current_value = self.capital
self.equity_curve.append({
'timestamp': timestamp,
'equity': self.capital + current_value
})
def _generate_summary(self) -> Dict:
"""結果サマリーを生成"""
if not self.trades:
return {"status": "no_trades", "capital": self.capital}
wins = [t for t in self.trades if t.pnl > 0]
losses = [t for t in self.trades if t.pnl <= 0]
total_return = self.capital - self.initial_capital
total_return_pct = (total_return / self.initial_capital) * 100
return {
"initial_capital": self.initial_capital,
"final_capital": self.capital,
"total_return": total_return,
"total_return_percent": total_return_pct,
"total_trades": len(self.trades),
"winning_trades": len(wins),
"losing_trades": len(losses),
"win_rate": len(wins) / len(self.trades) if self.trades else 0,
"avg_win": np.mean([t.pnl for t in wins]) if wins else 0,
"avg_loss": np.mean([t.pnl for t in losses]) if losses else 0,
"profit_factor": abs(sum([t.pnl for t in wins]) / sum([t.pnl for t in losses])) if losses and sum([t.pnl for t in losses]) != 0 else float('inf'),
"max_drawdown": self._calculate_max_drawdown(),
"trades": self.trades,
"equity_curve": self.equity_curve
}
def _calculate_max_drawdown(self) -> float:
"""最大ドローダウンの計算"""
if not self.equity_curve:
return 0.0
equity = [e['equity'] for e in self.equity_curve]
peak =