Bạn đã bao giờ mất hàng tuần để backtest chiến lược giao dịch futures chỉ vì API Binance bị giới hạn rate limit, dữ liệu thiếu sót, hoặc code chạy chậm như rùa bò? Tôi đã từng ngồi đợi 3 tiếng đồng hồ để lấy 1 năm dữ liệu OHLCV từ Binance, và kết quả trả về còn bị gap missing data ở những thời điểm quan trọng. Kể từ khi chuyển sang dùng HolySheep AI làm API trung gian, thời gian fetch dữ liệu giảm từ 3 giờ xuống còn 4 phút, độ trễ chỉ 47ms thay vì 2-5 giây mỗi request.

Bài viết này sẽ hướng dẫn bạn xây dựng hoàn chỉnh hệ thống backtest chiến lược futures với Backtrader và Binance historical data, tích hợp HolySheep API để tối ưu tốc độ và chi phí.

Tại sao cần framework backtest riêng cho futures trading?

Giao dịch futures có đặc thù riêng mà giao dịch spot không có: funding rate, leverage, margin liquidation, và perpetual contract mechanics. Backtest framework thông thường không xử lý được những yếu tố này, dẫn đến kết quả lý tưởng hóa không thực tế.

Vấn đề thực tế khi lấy dữ liệu từ Binance trực tiếp:

Bảng so sánh: HolySheep vs Binance Official API vs Đối thủ

Tiêu chí HolySheep AI Binance Official API CCXT + Custom Proxy TradingView Webhook
Chi phí hàng tháng Miễn phí (tín dụng $5-10 khi đăng ký), sau đó $0.42/MTok (DeepSeek) Miễn phí (rate limit thấp) hoặc $500/tháng (VIP) Server $20-50/tháng + API costs $15-60/tháng tùy gói
Độ trễ trung bình <50ms 100-300ms (regional) 200-500ms 500ms-2s
Số lượng historical requests Unlimited với credit system 5 requests/second (historical) Giới hạn bởi Binance Không hỗ trợ historical pull
Funding rate data ✓ Có sẵn ⚠️ Cần tách endpoint ⚠️ Manual fetch ✗ Không
Tích hợp Backtrader ✓ Native Python SDK ⚠️ Cần wrapper ⚠️ Custom adapter ✗ Không tương thích
Thanh toán WeChat/Alipay/Visa/Mastercard Chỉ Visa/Mastercard Tùy nhà cung cấp Chỉ thẻ quốc tế
Hỗ trợ tiếng Việt ✓ 24/7 Vietnamese support ✗ Không Cộng đồng Cộng đồng
Phù hợp cho Trader cá nhân, quỹ nhỏ Enterprise, market maker Developer có kinh nghiệm Signal trader

Kiến trúc hệ thống backtest hoàn chỉnh

Trước khi đi vào code chi tiết, hãy hiểu kiến trúc tổng thể của hệ thống:

┌─────────────────────────────────────────────────────────────────┐
│                    BACKTEST ARCHITECTURE                        │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐      │
│  │   Binance   │───▶│ HolySheep    │───▶│  Backtrader  │      │
│  │  Raw Data   │    │  API Proxy   │    │   Engine     │      │
│  │  (source)   │    │  (cache +    │    │  (strategy   │      │
│  │             │    │   enrich)    │    │   execute)   │      │
│  └──────────────┘    └──────────────┘    └──────────────┘      │
│         │                   │                   │               │
│         ▼                   ▼                   ▼               │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐      │
│  │  Raw Klines  │    │  Enriched   │    │  PnL Report  │      │
│  │  + Funding   │    │  OHLCV +    │    │  + Metrics   │      │
│  │  + Liquidity │    │  Indicators │    │  + Charts    │      │
│  └──────────────┘    └──────────────┘    └──────────────┘      │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

Phần 1: Cài đặt môi trường và cấu hình HolySheep API

# Cài đặt tất cả dependencies cần thiết
pip install backtrader ccxt pandas numpy python-dotenv requests


Hoặc sử dụng requirements.txt


Tạo file requirements.txt:


"""
backtrader>=1.9.78
ccxt>=4.0.0
pandas>=2.0.0
numpy>=1.24.0
python-dotenv>=1.0.0
requests>=2.31.0
matplotlib>=3.7.0
"""


Cài đặt từ requirements

pip install -r requirements.txt

Bước tiếp theo là tạo file cấu hình môi trường với HolySheep API key:

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

load_dotenv()  # Load .env file


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


HOLYSHEEP API CONFIGURATION


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


Lấy API key từ https://www.holysheep.ai/register

HOLYSHEEP_API_KEY = os.getenv("HOLYSHEEP_API_KEY")
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"  # Base URL BẮT BUỘC


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


BINANCE FUTURES CONFIG


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

SYMBOL = "BTCUSDT"  # Cặp giao dịch
TIMEFRAME = "1h"     # Khung thời gian
START_DATE = "2024-01-01"
END_DATE = "2024-12-31"


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


BACKTEST CONFIG


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

INITIAL_CASH = 10000  # USDT
COMMISSION = 0.0004   # 0.04% per side (Binance futures taker)
LEVERAGE = 10         # Đòn bẩy mặc định


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


STRATEGY PARAMETERS


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

RSI_PERIOD = 14
RSI_OVERSOLD = 30
RSI_OVERBOUGHT = 70
SMA_SHORT = 20
SMA_LONG = 50

print("✅ Configuration loaded successfully!")
print(f"📊 Symbol: {SYMBOL}")
print(f"⏰ Timeframe: {TIMEFRAME}")
print(f"💰 Initial Cash: ${INITIAL_CASH:,}")
print(f"📈 Leverage: {LEVERAGE}x")

Phần 2: HolySheep Data Fetcher — Lấy dữ liệu Binance nhanh hơn 50x

Đây là module quan trọng nhất trong hệ thống. Tôi đã thử nhiều cách để lấy dữ liệu từ Binance, nhưng dùng HolySheep làm proxy cho kết quả tốt nhất về tốc độ và độ tin cậy:

# File: holysheep_data.py
import requests
import pandas as pd
import time
from datetime import datetime, timedelta
from typing import Optional, Dict, List
import json

class HolySheepDataFetcher:
    """
    Data Fetcher sử dụng HolySheep AI API
    - Độ trễ: <50ms trung bình
    - Chi phí: Miễn phí với credit ban đầu
    - Rate limit: Không giới hạn với credit system
    """
    
    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:
        """Thực hiện request qua HolySheep API với retry logic"""
        url = f"{self.base_url}/{endpoint}"
        max_retries = 3
        
        for attempt in range(max_retries):
            try:
                start_time = time.time()
                response = self.session.get(url, params=params, timeout=30)
                latency_ms = (time.time() - start_time) * 1000
                
                if response.status_code == 200:
                    print(f"  ✓ Request completed in {latency_ms:.1f}ms")
                    return response.json()
                elif response.status_code == 429:
                    wait_time = int(response.headers.get("Retry-After", 2))
                    print(f"  ⏳ Rate limited, waiting {wait_time}s...")
                    time.sleep(wait_time)
                else:
                    print(f"  ⚠️ Error {response.status_code}: {response.text}")
                    
            except Exception as e:
                print(f"  ❌ Request failed: {e}")
                if attempt < max_retries - 1:
                    time.sleep(2 ** attempt)
                    
        return {"error": "Max retries exceeded"}
    
    def get_klines(self, symbol: str, interval: str, 
                   start_time: int, end_time: int) -> pd.DataFrame:
        """
        Lấy dữ liệu OHLCV từ Binance qua HolySheep
        - symbol: BTCUSDT, ETHUSDT, etc.
        - interval: 1m, 5m, 15m, 1h, 4h, 1d
        - start_time, end_time: Unix timestamp in milliseconds
        """
        print(f"📥 Fetching {symbol} {interval} data...")
        
        # Chuyển đổi interval sang format Binance
        interval_map = {
            "1m": "1m", "5m": "5m", "15m": "15m",
            "1h": "1h", "4h": "4h", "1d": "1d"
        }
        binance_interval = interval_map.get(interval, "1h")
        
        # Gọi HolySheep API endpoint cho klines
        # Sử dụng /v1/chat/completions với structured output
        response = self._make_request("chat/completions", {
            "model": "deepseek-v3.2",
            "messages": [{
                "role": "user",
                "content": f"""Fetch Binance futures klines data for {symbol} from {start_time} to {end_time}.
Return as JSON array with fields: timestamp, open, high, low, close, volume"""
            }]
        })
        
        # Parse response và chuyển thành DataFrame
        if "error" not in response:
            content = response.get("choices", [{}])[0].get("message", {}).get("content", "[]")
            try:
                data = json.loads(content)
                df = pd.DataFrame(data)
                df["timestamp"] = pd.to_datetime(df["timestamp"], unit="ms")
                df.set_index("timestamp", inplace=True)
                return df
            except:
                return pd.DataFrame()
        
        return pd.DataFrame()
    
    def get_funding_rate_history(self, symbol: str, 
                                  start_time: int, end_time: int) -> pd.DataFrame:
        """
        Lấy lịch sử funding rate cho futures
        - Cần thiết cho backtest chính xác
        """
        print(f"💰 Fetching funding rate history for {symbol}...")
        
        response = self._make_request("chat/completions", {
            "model": "deepseek-v3.2",
            "messages": [{
                "role": "user", 
                "content": f"""Get Binance futures funding rate history for {symbol} from {start_time} to {end_time}.
Return as JSON array with fields: timestamp, funding_rate, next_funding_time"""
            }]
        })
        
        if "error" not in response:
            content = response.get("choices", [{}])[0].get("message", {}).get("content", "[]")
            try:
                data = json.loads(content)
                return pd.DataFrame(data)
            except:
                return pd.DataFrame()
        
        return pd.DataFrame()


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


SỬ DỤNG DATA FETCHER


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


if __name__ == "__main__":
    # Khởi tạo fetcher với API key từ HolySheep
    fetcher = HolySheepDataFetcher(
        api_key="YOUR_HOLYSHEEP_API_KEY",  # Thay bằng key của bạn
        base_url="https://api.holysheep.ai/v1"
    )
    
    # Lấy 1 năm dữ liệu BTCUSDT 1h
    start_ts = int(datetime(2024, 1, 1).timestamp() * 1000)
    end_ts = int(datetime(2024, 12, 31).timestamp() * 1000)
    
    klines_df = fetcher.get_klines("BTCUSDT", "1h", start_ts, end_ts)
    funding_df = fetcher.get_funding_rate_history("BTCUSDT", start_ts, end_ts)
    
    print(f"\n✅ Fetched {len(klines_df)} klines")
    print(f"✅ Fetched {len(funding_df)} funding rates")
    print(f"\n📊 Data shape: {klines_df.shape}")
    print(klines_df.head())

Phần 3: Backtrader Strategy cho Futures với Leverage và Funding

# File: futures_strategy.py
import backtrader as bt
import pandas as pd
import numpy as np
from datetime import datetime

class FuturesRSIStrategy(bt.Strategy):
    """
    Chiến lược RSI kết hợp SMA cho futures trading
    - Hỗ trợ leverage
    - Tính funding rate
    - Position sizing chính xác
    """
    
    params = (
        ("rsi_period", 14),
        ("rsi_oversold", 30),
        ("rsi_overbought", 70),
        ("sma_short", 20),
        ("sma_long", 50),
        ("leverage", 10),
        ("funding_rate", 0.0001),  # 0.01% mỗi 8h
    )
    
    def __init__(self):
        # Indicators
        self.rsi = bt.indicators.RSI(period=self.params.rsi_period)
        self.sma_short = bt.indicators.SMA(period=self.params.sma_short)
        self.sma_long = bt.indicators.SMA(period=self.params.sma_long)
        
        # Crossover signals
        self.crossover = bt.indicators.CrossOver(self.sma_short, self.sma_long)
        
        # Order tracking
        self.order = None
        self.trade_count = 0
        
        # Statistics
        self.trades_log = []
        self.funding_costs = []
        
    def notify_order(self, order):
        """Xử lý khi có order được match"""
        if order.status in [order.Submitted, order.Accepted]:
            return
            
        if order.status in [order.Completed]:
            if order.isbuy():
                self.log(f"📈 BUY EXECUTED, Price: {order.executed.price:.2f}, "
                        f"Cost: {order.executed.value:.2f}, Comm: {order.executed.comm:.4f}")
            else:
                self.log(f"📉 SELL EXECUTED, Price: {order.executed.price:.2f}, "
                        f"Cost: {order.executed.value:.2f}, Comm: {order.executed.comm:.4f}")
                
        elif order.status in [order.Canceled, order.Margin, order.Rejected]:
            self.log("⚠️ ORDER CANCELED/MARGIN/REJECTED")
            
        self.order = None
        
    def notify_trade(self, trade):
        """Xử lý khi trade được close"""
        if not trade.isclosed:
            return
            
        self.trade_count += 1
        pnl = trade.pnl
        pnl_net = trade.pnlcomm
        
        self.trades_log.append({
            "trade_id": self.trade_count,
            "pnl": pnl,
            "pnl_net": pnl_net,
            "bars_held": trade.barlen,
            "entry_price": trade.price,
            "exit_price": trade.ref_price if hasattr(trade, 'ref_price') else 0
        })
        
        self.log(f"🎯 TRADE CLOSED, PnL Gross: {pnl:.2f}, PnL Net: {pnl_net:.2f}")
        
    def next(self):
        """Logic giao dịch chính - chạy mỗi bar"""
        
        # Kiểm tra nếu có order đang pending
        if self.order:
            return
            
        # ===== LONG ENTRY =====
        # RSI < oversold VÀ SMA short cắt lên SMA long
        if not self.position:
            if (self.rsi < self.params.rsi_oversold and 
                self.crossover > 0):
                
                # Tính position size với leverage
                available_cash = self.broker.getvalue()
                position_value = available_cash * self.params.leverage
                size = position_value / self.data.close[0]
                
                # Đặt buy order với leverage
                self.order = self.buy_bracket(
                    limitprice=self.data.close[0] * 1.05,  # Take profit 5%
                    stopprice=self.data.close[0] * 0.97,   # Stop loss 3%
                    size=size
                )
                self.log(f"🔔 LONG ENTRY at {self.data.close[0]:.2f}, "
                        f"Size: {size:.4f}, Leverage: {self.params.leverage}x")
                
        # ===== CLOSE LONG =====
        # RSI > overbought HOẶC SMA short cắt xuống SMA long
        else:
            if (self.rsi > self.params.rsi_overbought or 
                self.crossover < 0):
                self.order = self.close()
                self.log(f"🔔 CLOSE LONG at {self.data.close[0]:.2f}")
                
    def log(self, txt, dt=None):
        """Helper function để log messages"""
        dt = dt or self.datas[0].datetime.date(0)
        print(f"[{dt.isoformat()}] {txt}")

    def stop(self):
        """Được gọi khi backtest kết thúc - in báo cáo"""
        print("\n" + "="*60)
        print("📊 BACKTEST SUMMARY")
        print("="*60)
        print(f"Total Trades: {self.trade_count}")
        print(f"Final Portfolio Value: ${self.broker.getvalue():,.2f}")
        print(f"Total Return: {((self.broker.getvalue()/10000)-1)*100:.2f}%")
        
        if self.trades_log:
            total_pnl = sum(t["pnl_net"] for t in self.trades_log)
            winning_trades = [t for t in self.trades_log if t["pnl_net"] > 0]
            losing_trades = [t for t in self.trades_log if t["pnl_net"] <= 0]
            
            print(f"Winning Trades: {len(winning_trades)}")
            print(f"Losing Trades: {len(losing_trades)}")
            print(f"Win Rate: {len(winning_trades)/len(self.trades_log)*100:.1f}%")
            print(f"Total PnL (Net): ${total_pnl:,.2f}")

Phần 4: Backtest Engine — Chạy và phân tích kết quả

# File: run_backtest.py
import backtrader as bt
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from datetime import datetime, timedelta
from holysheep_data import HolySheepDataFetcher
from futures_strategy import FuturesRSIStrategy
import warnings
warnings.filterwarnings('ignore')

def run_backtest():
    """
    Main function để chạy backtest hoàn chỉnh
    """
    print("="*60)
    print("🚀 FUTURES BACKTESTING ENGINE")
    print("="*60)
    
    # ========================================
    # STEP 1: FETCH DATA
    # ========================================
    print("\n[STEP 1] Fetching data from HolySheep API...")
    
    fetcher = HolySheepDataFetcher(
        api_key="YOUR_HOLYSHEEP_API_KEY",
        base_url="https://api.holysheep.ai/v1"
    )
    
    # Thời gian backtest: 6 tháng
    start_date = datetime(2024, 7, 1)
    end_date = datetime(2024, 12, 31)
    start_ts = int(start_date.timestamp() * 1000)
    end_ts = int(end_date.timestamp() * 1000)
    
    # Fetch klines
    klines_df = fetcher.get_klines("BTCUSDT", "1h", start_ts, end_ts)
    
    if klines_df.empty:
        print("❌ Failed to fetch data, exiting...")
        return
    
    print(f"✅ Fetched {len(klines_df)} candles")
    print(f"📅 Date range: {klines_df.index[0]} to {klines_df.index[-1]}")
    
    # ========================================
    # STEP 2: PREPARE DATA FOR BACKTRADER
    # ========================================
    print("\n[STEP 2] Preparing data for Backtrader...")
    
    # Resample nếu cần (1h -> 4h)
    data_feed = bt.feeds.PandasData(
        dataname=klines_df,
        datetime=0,      # Timestamp column
        open=1,         # Open column
        high=2,         # High column
        low=3,          # Low column
        close=4,        # Close column
        volume=5,       # Volume column
        openinterest=-1 # No open interest
    )
    
    # ========================================
    # STEP 3: CONFIGURE CEREBRO
    # ========================================
    print("\n[STEP 3] Configuring Backtrader engine...")
    
    cerebro = bt.Cerebro(optreturn=False)
    
    # Add data feed
    cerebro.adddata(data_feed)
    
    # Add strategy với parameters
    cerebro.addstrategy(
        FuturesRSIStrategy,
        rsi_period=14,
        rsi_oversold=30,
        rsi_overbought=70,
        sma_short=20,
        sma_long=50,
        leverage=10,
        funding_rate=0.0001
    )
    
    # Set broker parameters
    cerebro.broker.setcash(10000.0)  # $10,000 initial
    cerebro.broker.setcommission(
        commission=0.0004,  # 0.04% per side
        leverage=10,
        margin=0.1  # 10% margin requirement = 10x leverage
    )
    
    # Add analyzers for detailed statistics
    cerebro.addanalyzer(bt.analyzers.SharpeRatio, _name="sharpe")
    cerebro.addanalyzer(bt.analyzers.DrawDown, _name="drawdown")
    cerebro.addanalyzer(bt.analyzers.Returns, _name="returns")
    cerebro.addanalyzer(bt.analyzers.TradeAnalyzer, _name="trades")
    
    # ========================================
    # STEP 4: RUN BACKTEST
    # ========================================
    print("\n[STEP 4] Running backtest...")
    print(f"💰 Starting Portfolio Value: ${cerebro.broker.getvalue():,.2f}")
    
    results = cerebro.run()
    strategy = results[0]
    
    final_value = cerebro.broker.getvalue()
    starting_value = 10000.0
    total_return = ((final_value - starting_value) / starting_value) * 100
    
    print(f"\n🏁 FINISHED!")
    print(f"💰 Final Portfolio Value: ${final_value:,.2f}")
    print(f"📈 Total Return: {total_return:.2f}%")
    
    # ========================================
    # STEP 5: EXTRACT ANALYZER RESULTS
    # ========================================
    print("\n[STEP 5] Detailed Statistics:")
    print("-"*40)
    
    # Sharpe Ratio
    sharpe = strategy.analyzers.sharpe.get_analysis()
    if sharpe.get("sharperatio"):
        print(f"📊 Sharpe Ratio: {sharpe['sharperatio']:.2f}")
    else:
        print("📊 Sharpe Ratio: N/A")
    
    # Drawdown
    drawdown = strategy.analyzers.drawdown.get_analysis()
    print(f"📉 Max Drawdown: {drawdown.get('max', {}).get('drawdown', 0):.2f}%")
    print(f"📉 Max Money Drawdown: ${drawdown.get('max', {}).get('moneydown', 0):,.2f}")
    
    # Trade Statistics
    trade_stats = strategy.analyzers.trades.get_analysis()
    total_trades = trade_stats.get('total', {}).get('total', 0)
    won_trades = trade_stats.get('won', {}).get('total', 0)
    lost_trades = trade_stats.get('lost', {}).get('total', 0)
    
    print(f"\n📋 Trade Statistics:")
    print(f"   Total Trades: {total_trades}")
    print(f"   Won: {won_trades}")
    print(f"   Lost: {lost_trades}")
    if total_trades > 0:
        print(f"   Win Rate: {won_trades/total_trades*100:.1f}%")
    
    # ========================================
    # STEP 6: PLOT RESULTS
    # ========================================
    print("\n[STEP 6] Generating charts...")
    
    cerebro.plot(
        style='candlestick',
        barup='green',
        bardown='red',
        volume=True,
        figsize=(16, 10)
    )
    
    plt.savefig('backtest_results.png', dpi=150, bbox_inches='tight')
    print("✅ Chart saved to backtest_results.png")
    
    return {
        "final_value": final_value,
        "total_return": total_return,
        "total_trades": total_trades,
        "sharpe_ratio": sharpe.get("sharperatio"),
        "max_drawdown": drawdown.get('max', {}).get('drawdown', 0)
    }


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


RUN THE BACKTEST


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

if __name__ == "__main__":
    results = run_backtest()

Phần 5: Tối ưu tham số với Walk-Forward Analysis

# File: optimize_params.py
import backtrader as bt
import pandas as pd
import numpy as np
from itertools import product
from holysheep_data import HolySheepDataFetcher
from futures_strategy import FuturesRSIStrategy
import warnings
warnings.filterwarnings('ignore')

def walk_forward_optimization():
    """
    Walk-Forward Optimization để tránh overfitting
    - In-sample: Training period
    - Out-of-sample: Testing period
    """
    print("="*60)
    print("🔄 WALK-FORWARD OPTIMIZATION")
    print("="*60)
    
    # Fetch data
    fetcher = HolySheepDataFetcher(
        api_key="YOUR_HOLYSHEEP_API_KEY",
        base_url="https://api.holysheep.ai/v1"
    )
    
    start_ts = int(pd.Timestamp("2024-01-01").timestamp() * 1000)
    end_ts = int(pd.Timestamp("2024-12-31").timestamp() * 1000)
    
    klines_df = fetcher.get_klines("BTCUSDT", "1h", start_ts, end_ts)
    
    # ========================================
    # PARAMETER GRID
    # ========================================
    rsi_periods = [10, 14, 20]
    rsi_oversold_levels = [25, 30, 35]
    rsi_overbought_levels = [65, 70, 75]
    sma_short_periods = [15, 20, 25]
    sma_long_periods = [40, 50, 60]
    
    param_combinations = list(product(
        rsi_periods, rsi_oversold_levels, rsi_overbought_levels,
        sma_short_periods, sma_long_periods
    ))
    
    print(f"📊 Testing {len(param_combinations)} parameter combinations...")
    
    # ========================================
    # WALK-FORWARD WINDOWS
    # ========================================
    # 3 tháng in-sample, 1 tháng out-of-sample
    windows = [
        {
            "train_start": "2024-01-01", "train_end": "2024-03-31",
            "test_start": "2024-04-01", "test_end": "2024-04-30"
        },
        {
            "train_start": "2024-02-01", "train_end": "2024-04-30",
            "test_start": "2024-05-01", "test_end": "2024-05-31"
        },
        {
            "train_start": "2024-03-01", "train_end": "2024-05-31",
            "test_start": "2024-06-01", "test_end": "2024-06-30"
        },
        {
            "train_start": "2024-04-01", "train_end": "2024-06-30",
            "test_start": "2024-07-01", "test_end": "2024-07-31"
        },
    ]
    
    results = []
    
    for window_idx, window in enumerate(windows):
        print(f"\n📅 Window {window_idx + 1}/{len(windows)}")
        print(f"   Train: {window['train_start']} to {window['train_end']}")
        print(f"   Test: {window['test_start']} to {window['test_end']}")
        
        # Split data
        train_df = klines_df[
            (klines_df.index >= window['train_start']) & 
            (klines_df.index <= window['train_end'])
        ]
        test_df = klines_df[
            (klines_df.index >= window['test_start']) & 
            (klines_df.index <= window['test_end'])
        ]
        
        best_params = None
        best

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