Trong thị trường crypto perpetual futures, việc tiếp cận dữ liệu lịch sử chất lượng cao là yếu tố quyết định giữa một chiến lược có lãi và một chiến lược thất bại. Bài viết này sẽ hướng dẫn bạn cách kết nối HolySheep AI với Tardis Botany (API cung cấp dữ liệu Coinbase International Perp) để thực hiện nghiên cứu định lượng backtesting funding rate, open interest (OI) và mark price với chi phí tối ưu nhất năm 2026.

Mở đầu: Bối cảnh chi phí AI năm 2026

Trước khi đi vào nội dung kỹ thuật, hãy cùng xem bức tranh tổng quan về chi phí AI API năm 2026 để bạn hiểu vì sao việc chọn đúng nhà cung cấp ảnh hưởng trực tiếp đến ROI của nghiên cứu định lượng:

Model Giá Input ($/MTok) Giá Output ($/MTok) 10M token/tháng ($) Ghi chú
DeepSeek V3.2 $0.42 $0.42 $8.40 Giá rẻ nhất, phù hợp xử lý data
Gemini 2.5 Flash $2.50 $10.00 $25.00 Nhanh, chi phí trung bình
GPT-4.1 $8.00 $32.00 $80.00 Chi phí cao cho nghiên cứu
Claude Sonnet 4.5 $15.00 $75.00 $150.00 Đắt nhất, chất lượng cao nhất

Bảng 1: So sánh chi phí AI API chính — Nguồn: Dữ liệu giá chính thức 2026, đã xác minh.

Với nghiên cứu định lượng đòi hỏi xử lý hàng triệu token dữ liệu lịch sử, việc chọn DeepSeek V3.2 thông qua HolySheep AI giúp bạn tiết kiệm 94.4% chi phí so với dùng Claude Sonnet 4.5 trực tiếp — từ $150 xuống còn $8.40 cho 10 triệu token/tháng. Đây là con số mà bất kỳ nhà nghiên cứu định lượng nào cũng cần tính toán kỹ.

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

✅ Nên sử dụng bài viết này nếu bạn là:

❌ Không cần thiết nếu bạn:

Tổng quan kiến trúc hệ thống

Trước khi viết code, bạn cần hiểu rõ luồng dữ liệu hoàn chỉnh:

┌─────────────────────────────────────────────────────────────────────┐
│  LUỒNG DỮ LIỆU BACKTESTING COINBASE INTERNATIONAL PERP             │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  Tardis Botany API ──→ Python Script ──→ HolySheep AI ──→ Kết quả  │
│  (Dữ liệu thô)      (Xử lý)      (Phân tích NLP)     (Insights)   │
│                                                                     │
│  Chi tiết:                                                          │
│  1. Tardis Botany → Lấy dữ liệu funding_rate, open_interest,      │
│                      mark_price theo timestamp                     │
│  2. Python → Parse, clean, chuyển thành DataFrame                   │
│  3. HolySheep AI → Phân tích pattern, viết chiến lược               │
│  4. Backtest Engine → Mô phỏng P&L, Sharpe Ratio, Max Drawdown    │
│                                                                     │
│  Chi phí ước tính:                                                   │
│  - Tardis: $99-$499/tháng (tùy gói dữ liệu)                       │
│  - HolySheep: $8.40/10M tokens (DeepSeek V3.2)                     │
│  - Tiết kiệm 85%+ so với OpenAI/Anthropic trực tiếp               │
└─────────────────────────────────────────────────────────────────────┘

Cài đặt môi trường và dependencies

Đầu tiên, cài đặt tất cả thư viện cần thiết. Khuyến nghị sử dụng Python 3.10+ và virtual environment để tránh xung đột phiên bản.

# Tạo virtual environment và cài đặt dependencies
python -m venv venv_holy_sheep
source venv_holy_sheep/bin/activate  # Linux/Mac

venv_holy_sheep\Scripts\activate   # Windows


pip install --upgrade pip
pip install requests pandas numpy matplotlib python-dotenv
pip install tardis-client  # SDK chính thức của Tardis
pip install backtesting    # Thư viện backtesting
pip install scipy statsmodels  # Phân tích thống kê


Kiểm tra phiên bản

python --version

Output mong đợi: Python 3.10.x hoặc cao hơn

Tạo file cấu hình môi trường với các biến cần thiết:

# File: config.py
import os
from dotenv import load_dotenv

load_dotenv()


============================================================


CẤU HÌNH API HOLYSHEEP - QUAN TRỌNG: KHÔNG DÙNG DOMAIN KHÁC


============================================================

HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
HOLYSHEEP_API_KEY = os.getenv("HOLYSHEEP_API_KEY")


Tardis Botany API Configuration

TARDIS_API_KEY = os.getenv("TARDIS_API_KEY")
TARDIS_EXCHANGE = "coinbase_international"  # Coinbase International Perp
TARDIS_MARKETS = [
    "BTC-PERP",
    "ETH-PERP",
    "SOL-PERP",
]


Cấu hình backtesting

BACKTEST_START = "2025-01-01"
BACKTEST_END = "2025-12-31"
INITIAL_CAPITAL = 10_000  # USDT
RISK_FREE_RATE = 0.04  # 4% annual

print("✅ Cấu hình loaded thành công")
print(f"   Tardis Exchange: {TARDIS_EXCHANGE}")
print(f"   Markets: {TARDIS_MARKETS}")
print(f"   HolySheep Base URL: {HOLYSHEEP_BASE_URL}")

Kết nối Tardis Botany API lấy dữ liệu lịch sử

Đây là bước cốt lõi — kết nối Tardis Botany để lấy dữ liệu funding rate, open interest và mark price từ Coinbase International Perp. Tardis cung cấp dữ liệu realtime và historical với độ chính xác cao.

# File: tardis_data_fetcher.py
import requests
import pandas as pd
from datetime import datetime, timedelta
import time
import json
from config import TARDIS_API_KEY, TARDIS_EXCHANGE, TARDIS_MARKETS

def fetch_funding_rate_history(
    market: str,
    start_date: str,
    end_date: str
) -> pd.DataFrame:
    """
    Lấy dữ liệu funding rate lịch sử từ Tardis API
    cho Coinbase International Perp.
    
    Args:
        market: Ví dụ 'BTC-PERP'
        start_date: 'YYYY-MM-DD'
        end_date: 'YYYY-MM-DD'
    
    Returns:
        DataFrame với columns: timestamp, funding_rate, market
    """
    
    # Tardis API endpoint cho funding rate
    url = f"https://api.tardis.dev/v1/funding-rates/{TARDIS_EXCHANGE}/{market}"
    
    headers = {
        "Authorization": f"Bearer {TARDIS_API_KEY}",
        "Content-Type": "application/json"
    }
    
    params = {
        "from": start_date,
        "to": end_date,
        "format": "dataframe",  # Trả về DataFrame trực tiếp
        "interval": "1h"  # 1 giờ, có thể chọn 8h (tần suất funding chuẩn)
    }
    
    print(f"📡 Đang fetch dữ liệu {market} từ {start_date} đến {end_date}...")
    
    try:
        response = requests.get(
            url,
            headers=headers,
            params=params,
            timeout=30
        )
        response.raise_for_status()
        
        df = pd.DataFrame(response.json())
        
        # Parse timestamp
        df['timestamp'] = pd.to_datetime(df['timestamp'])
        df['funding_rate'] = df['funding_rate'].astype(float)
        df['market'] = market
        
        print(f"   ✅ Đã lấy {len(df)} records cho {market}")
        return df
        
    except requests.exceptions.HTTPError as e:
        print(f"   ❌ HTTP Error: {e.response.status_code} - {e.response.text}")
        return pd.DataFrame()
    except requests.exceptions.Timeout:
        print(f"   ❌ Timeout khi kết nối Tardis API")
        return pd.DataFrame()
    except Exception as e:
        print(f"   ❌ Lỗi không xác định: {str(e)}")
        return pd.DataFrame()

def fetch_ohlcv_and_oi(market: str, start_date: str, end_date: str) -> pd.DataFrame:
    """
    Lấy dữ liệu OHLCV + Open Interest từ Tardis
    """
    
    url = f"https://api.tardis.dev/v1/derivatives/ohlcv/{TARDIS_EXCHANGE}/{market}"
    
    headers = {
        "Authorization": f"Bearer {TARDIS_API_KEY}",
        "Content-Type": "application/json"
    }
    
    params = {
        "from": start_date,
        "to": end_date,
        "interval": "1h",
        "fields": "timestamp,open,high,low,close,volume,open_interest"
    }
    
    print(f"📡 Fetching OHLCV + OI cho {market}...")
    
    try:
        response = requests.get(url, headers=headers, params=params, timeout=60)
        response.raise_for_status()
        
        df = pd.DataFrame(response.json())
        df['timestamp'] = pd.to_datetime(df['timestamp'])
        
        # Convert sang float
        numeric_cols = ['open', 'high', 'low', 'close', 'volume', 'open_interest']
        for col in numeric_cols:
            df[col] = pd.to_numeric(df[col], errors='coerce')
        
        print(f"   ✅ OHLCV + OI: {len(df)} records")
        return df
        
    except Exception as e:
        print(f"   ❌ Lỗi fetch OHLCV+OI: {str(e)}")
        return pd.DataFrame()

def combine_all_markets(start: str, end: str) -> dict:
    """
    Tổng hợp dữ liệu cho tất cả markets
    """
    all_data = {}
    
    for market in TARDIS_MARKETS:
        print(f"\n{'='*50}")
        print(f"🔄 Xử lý market: {market}")
        print('='*50)
        
        # Lấy funding rate
        funding_df = fetch_funding_rate_history(market, start, end)
        
        # Lấy OHLCV + OI
        ohlcv_df = fetch_ohlcv_and_oi(market, start, end)
        
        # Merge theo timestamp
        if not funding_df.empty and not ohlcv_df.empty:
            merged = pd.merge(
                ohlcv_df,
                funding_df[['timestamp', 'funding_rate']],
                on='timestamp',
                how='left'
            )
            merged['funding_rate'] = merged['funding_rate'].fillna(method='ffill')
            all_data[market] = merged
        else:
            all_data[market] = ohlcv_df if not ohlcv_df.empty else funding_df
        
        # Rate limit: Tardis cho phép ~10 requests/phút trên gói standard
        time.sleep(6)
    
    return all_data

if __name__ == "__main__":
    from config import BACKTEST_START, BACKTEST_END
    
    data = combine_all_markets(BACKTEST_START, BACKTEST_END)
    
    # Lưu cache
    for market, df in data.items():
        df.to_csv(f"data/{market.replace('/', '-')}_raw.csv", index=False)
        print(f"💾 Đã lưu: data/{market.replace('/', '-')}_raw.csv")
    
    print(f"\n✅ Hoàn tất fetch dữ liệu cho {len(data)} markets")

Gọi HolySheep AI phân tích chiến lược funding rate

Sau khi có dữ liệu thô, bước tiếp theo là dùng HolySheep AI (base_url: https://api.holysheep.ai/v1) để phân tích pattern và đề xuất chiến lược. Với giá DeepSeek V3.2 chỉ $0.42/MTok, bạn có thể chạy hàng chục lượt phân tích mà chi phí vẫn rất thấp.

# File: holysheep_strategy_analyzer.py
import requests
import json
import pandas as pd
from datetime import datetime
from config import HOLYSHEEP_BASE_URL, HOLYSHEEP_API_KEY

def analyze_with_holysheep(
    market: str,
    funding_df: pd.DataFrame,
    ohlcv_df: pd.DataFrame,
    prompt_template: str
) -> dict:
    """
    Gọi HolySheep AI (DeepSeek V3.2) để phân tích dữ liệu funding rate
    và đề xuất chiến lược backtesting.
    
    ⚠️ QUAN TRỌNG: base_url PHẢI là https://api.holysheep.ai/v1
    """
    
    # Tóm tắt dữ liệu gửi lên AI (để tiết kiệm token)
    funding_summary = {
        "market": market,
        "record_count": len(funding_df),
        "date_range": f"{funding_df['timestamp'].min()} đến {funding_df['timestamp'].max()}",
        "avg_funding_rate": float(funding_df['funding_rate'].mean()),
        "max_funding_rate": float(funding_df['funding_rate'].max()),
        "min_funding_rate": float(funding_df['funding_rate'].min()),
        "std_funding_rate": float(funding_df['funding_rate'].std()),
    }
    
    # Tính correlation với price
    merged = pd.merge(
        funding_df,
        ohlcv_df[['timestamp', 'close']],
        on='timestamp',
        how='inner'
    )
    
    correlation = float(merged['funding_rate'].corr(merged['close'])) if len(merged) > 10 else 0.0
    
    prompt = f"""
Bạn là chuyên gia Quantitative Research trong thị trường crypto perpetual futures.

Dưới đây là dữ liệu funding rate cho market {market}:

{funding_summary}

Correlation giữa funding rate và close price: {correlation}

Hãy phân tích và trả lời:
1. Pattern funding rate: rate thường tập trung ở mức nào? Có seasonality không?
2. Chiến lược backtesting đề xuất: vào lệnh khi nào, thoát khi nào?
3. Risk management: stop loss, position sizing như thế nào?
4. Các tham số cụ thể (entry threshold, exit threshold, hold period)

Trả lời bằng JSON format với keys: analysis, strategy, parameters, risk_metrics.
"""
    
    # ============================================================
    # GỌI HOLYSHEEP AI - KHÔNG DÙNG api.openai.com HAY api.anthropic.com
    # ============================================================
    url = f"{HOLYSHEEP_BASE_URL}/chat/completions"
    
    headers = {
        "Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "model": "deepseek-v3.2",  # Model rẻ nhất, hiệu quả cho data analysis
        "messages": [
            {
                "role": "system",
                "content": "Bạn là chuyên gia quantitative research cho crypto perpetual futures."
            },
            {
                "role": "user",
                "content": prompt
            }
        ],
        "temperature": 0.3,  # Low temperature cho analysis nhất quán
        "max_tokens": 2000
    }
    
    print(f"🤖 Đang gọi HolySheep AI cho {market}...")
    
    try:
        response = requests.post(
            url,
            headers=headers,
            json=payload,
            timeout=45
        )
        
        elapsed_ms = response.elapsed.total_seconds() * 1000
        
        response.raise_for_status()
        result = response.json()
        
        content = result['choices'][0]['message']['content']
        usage = result.get('usage', {})
        
        print(f"   ✅ Response nhận sau {elapsed_ms:.1f}ms")
        print(f"   📊 Tokens: input={usage.get('prompt_tokens', 'N/A')}, "
              f"output={usage.get('completion_tokens', 'N/A')}")
        
        return {
            "market": market,
            "analysis": content,
            "latency_ms": elapsed_ms,
            "tokens_used": usage.get('total_tokens', 0),
            "cost_usd": usage.get('total_tokens', 0) / 1_000_000 * 0.42  # $0.42/MTok
        }
        
    except requests.exceptions.HTTPError as e:
        print(f"   ❌ HTTP Error {e.response.status_code}: {e.response.text}")
        return {"market": market, "error": str(e)}
    except KeyError as e:
        print(f"   ❌ Response format lỗi: {str(e)}")
        return {"market": market, "error": "Invalid response format"}
    except Exception as e:
        print(f"   ❌ Lỗi: {str(e)}")
        return {"market": market, "error": str(e)}

def batch_analyze_markets(data: dict, markets: list) -> list:
    """
    Chạy phân tích cho nhiều markets, tiết kiệm chi phí với DeepSeek V3.2
    """
    results = []
    total_cost = 0.0
    total_latency = 0.0
    
    for market in markets:
        if market not in data or data[market].empty:
            print(f"⚠️ Không có dữ liệu cho {market}, bỏ qua...")
            continue
        
        df = data[market]
        
        result = analyze_with_holysheep(
            market=market,
            funding_df=df[['timestamp', 'funding_rate']],
            ohlcv_df=df[['timestamp', 'close']],
            prompt_template=""
        )
        
        if 'cost_usd' in result:
            total_cost += result['cost_usd']
            total_latency += result['latency_ms']
        
        results.append(result)
        
        print(f"   💰 Chi phí lũy kế: ${total_cost:.4f}, "
              f"Latency lũy kế: {total_latency:.1f}ms\n")
    
    print(f"\n{'='*60}")
    print(f"📊 TỔNG KẾT CHI PHÍ HOLYSHEEP:")
    print(f"   Markets analyzed: {len(results)}")
    print(f"   Total cost: ${total_cost:.4f}")
    print(f"   Avg latency: {total_latency/len(results):.1f}ms")
    print(f"   So với Claude Sonnet 4.5: Tiết kiệm "
          f"${len(results) * 0.15 - total_cost:.4f}")
    print('='*60)
    
    return results

if __name__ == "__main__":
    import os
    
    # Load dữ liệu đã fetch
    for m in ["BTC-PERP", "ETH-PERP"]:
        market_key = m
        csv_path = f"data/{market_key.replace('/', '-')}_raw.csv"
        
        if os.path.exists(csv_path):
            df = pd.read_csv(csv_path, parse_dates=['timestamp'])
            funding_df = df[['timestamp', 'funding_rate']].dropna()
            ohlcv_df = df[['timestamp', 'close']].dropna()
            
            result = analyze_with_holysheep(market_key, funding_df, ohlcv_df, "")
            
            with open(f"analysis/{market_key.replace('/', '-')}_analysis.txt", "w") as f:
                f.write(result.get('analysis', str(result)))
            print(f"💾 Đã lưu analysis: analysis/{market_key.replace('/', '-')}_analysis.txt")

Backtesting engine với chiến lược Funding Rate Arbitrage

Dựa trên phân tích từ HolySheep AI, phần này triển khai backtesting engine để đánh giá hiệu quả chiến lược funding rate trên dữ liệu lịch sử Coinbase International Perp.

# File: backtesting_engine.py
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from datetime import datetime, timedelta
from typing import Tuple, List
import json

class FundingRateBacktester:
    """
    Backtesting engine cho chiến lược Funding Rate Arbitrage
    trên Coinbase International Perp.
    
    Chiến lược cơ bản:
    - LONG khi funding rate < ngưỡng dưới (bị âm nặng → có thể mean-revert)
    - SHORT khi funding rate > ngưỡng trên (bị dương nhiều → có thể giảm)
    - Đóng lệnh khi funding rate về zero hoặc sau N giờ
    """
    
    def __init__(self, capital: float = 10_000, fee: float = 0.0004):
        self.capital = capital
        self.initial_capital = capital
        self.fee = fee  # Maker fee Coinbase International: ~0.04%
        self.positions = []
        self.trades = []
        self.equity_curve = []
        
    def run_backtest(
        self,
        df: pd.DataFrame,
        entry_threshold: float = -0.001,  # -0.1% → LONG
        exit_threshold: float = 0.0002,    # +0.02% → đóng
        max_hold_hours: int = 8,
        position_pct: float = 0.95  # 95% vốn cho mỗi lệnh
    ) -> dict:
        """
        Chạy backtest với các tham số cho trước
        """
        
        df = df.copy()
        df = df.sort_values('timestamp').reset_index(drop=True)
        
        # Khởi tạo biến theo dõi
        balance = self.initial_capital
        position = None  # None, 'long', hoặc 'short'
        entry_price = 0
        entry_time = None
        entry_funding = 0
        
        equity = [self.initial_capital]
        timestamps = [df['timestamp'].iloc[0]]
        
        for i in range(len(df)):
            row = df.iloc[i]
            current_price = row['close']
            current_funding = row['funding_rate']
            current_time = row['timestamp']
            
            hold_hours = (current_time - entry_time).total_seconds() / 3600 if entry_time else 0
            
            # === LOGIC ĐÓNG LỆNH ===
            if position == 'long':
                should_close = (
                    current_funding >= exit_threshold or
                    hold_hours >= max_hold_hours or
                    i == len(df) - 1
                )
                
                if should_close:
                    pnl = (current_price - entry_price) / entry_price * balance
                    
                    # Trừ phí funding (long phải trả funding khi dương)
                    funding_cost = current_funding * balance * (hold_hours / 8)
                    net_pnl = pnl - funding_cost - (balance * self.fee * 2)
                    
                    balance += net_pnl
                    self.trades.append({
                        'entry_time': entry_time,
                        'exit_time': current_time,
                        'side': 'long',
                        'entry_price': entry_price,
                        'exit_price': current_price,
                        'funding_at_entry': entry_funding,
                        'pnl': net_pnl,
                        'hold_hours': hold_hours
                    })
                    position = None
                    entry_time = None
                    
            elif position == 'short':
                should_close = (
                    current_funding <= -exit_threshold or
                    hold_hours >= max_hold_hours or
                    i == len(df) - 1
                )
                
                if should_close:
                    pnl = (entry_price - current_price) / entry_price * balance
                    
                    # Short nhận funding khi âm
                    funding_revenue = -current_funding * balance * (hold_hours / 8)
                    net_pnl = pnl + funding_revenue - (balance * self.fee * 2)
                    
                    balance += net_pnl
                    self.trades.append({
                        'entry_time': entry_time,
                        'exit_time': current_time,
                        'side': 'short',
                        'entry_price': entry_price,
                        'exit_price': current_price,
                        'funding_at_entry': entry_funding,
                        'pnl': net_pnl,
                        'hold_hours': hold_hours
                    })
                    position = None
                    entry_time = None
            
            # === LOGIC MỞ LỆNH ===
            if position is None:
                if current_funding < entry_threshold:
                    position = 'long'
                    entry_price = current_price
                    entry_time = current_time
                    entry_funding = current_funding
                    
                elif current_funding > -entry_threshold:  # funding dương cao
                    position = 'short'
                    entry_price = current_price
                    entry_time = current_time
                    entry_funding = current_funding
            
            equity.append(balance)
            timestamps.append(current_time)
        
        # Tính metrics
        trades_df = pd.DataFrame(self.trades)
        
        if len(trades_df) == 0:
            return self._empty_results()
        
        total_return = (balance - self.initial_capital) / self.initial_capital
        
        # Annualized return
        days = (df['timestamp'].max() - df['timestamp'].min()).days
        annual_return = total_return * 365 / max(days, 1)
        
        # Sharpe Ratio
        daily_returns = pd.Series(equity).pct_change().dropna()
        sharpe = (daily_returns.mean() / daily_returns.std()) * np.sqrt(365) if daily_returns.std() > 0 else 0
        
        # Max Drawdown
        cumulative = pd.Series(equity)
        running_max = cumulative.expanding().max()
        drawdown = (cumulative - running_max) / running_max
        max_drawdown = drawdown.min()
        
        # Win rate
        winning_trades = (trades_df['pnl'] > 0).sum()
        win_rate = winning_trades / len(trades_df)
        
        avg_win = trades_df[trades_df['pnl'] > 0]['pnl'].mean() if winning_trades > 0 else 0
        avg_loss = trades_df[trades_df['pnl'] < 0]['pnl'].mean() if (len(trades_df) - winning_trades) > 0 else 0
        profit_factor = abs(avg_win / avg_loss) if avg_loss != 0 else float('inf')
        
        results = {
            'total_return': total_return,
            'annual_return': annual_return,
            'final_capital': balance,
            'total_trades': len(trades_df),
            'winning_trades': winning_trades,
            'win_rate': win_rate,
            'sharpe_ratio': sharpe,
            'max_drawdown': max_drawdown,
            'avg_win': avg_win,
            'avg_loss': avg_loss,
            'profit_factor': profit_factor,
            'equity_curve': equity,
            'timestamps': timestamps,
            'trades': trades_df.to_dict('records')
        }
        
        return results
    
    def _empty_results(self) -> dict:
        return {
            'total_return': 0, 'annual_return': 0, 'final_capital': self.capital,
            'total_trades': 0, 'win_rate': 0, 'sharpe_ratio': 0,
            'max_drawdown': 0, 'profit_factor': 0, 'equity_curve': [],
            'trades': []
        }
    
    def plot_results(self, results: dict, market: str):
        """Vẽ biểu đồ equity curve và drawdown"""
        
        fig, axes = plt.subplots(2, 1, figsize=(14, 8))
        
        # Equity curve
        equity = results['equity_curve']
        timestamps = results['timestamps']
        
        axes[0].plot(timestamps, equity, 'b-', linewidth=1.5, label='Equity')
        axes[0].axhline(y=self.initial_capital, color='gray', linestyle='--', alpha=0.7)
        axes[0].set_title(f'{market} - Funding Rate Arbitrage Strategy\n'
                          f'Return: {results["total_return"]*100:.2f}% | '
                          f'Sharpe: {results["sharpe_ratio"]:.2f} | '
                          f'Max DD: {results["max_drawdown"]*100:.2f}%',
                          fontsize=12)
        axes[0].set_ylabel('Capital (USD)')
        axes[0].legend()
        axes[0].grid(True, alpha=0.3)

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