Trong hành trình 3 năm xây dựng hệ thống giao dịch tự động, đội ngũ của tôi đã trải qua cuộc di cư từ Binance Official API sang các giải pháp relay trung gian, và cuối cùng chọn HolySheep AI làm nền tảng dữ liệu cho backtesting. Bài viết này là playbook chi tiết, giúp bạn hiểu vì sao, làm thế nào để di chuyển, và đo lường ROI thực tế khi xây dựng hệ thống backtest cho BTC-USDT perpetual contract.

Tại sao backtesting với dữ liệu chất lượng cao lại quan trọng

Khi bắt đầu, chúng tôi nghĩ rằng chỉ cần lấy dữ liệu OHLCV miễn phí từ các sàn là đủ. Sai lầm nghiêm trọng. Dữ liệu miễn phí có độ trễ cao, thiếu funding rate, không có orderbook depth, và quan trọng nhất — không phản ánh điều kiện thị trường thực tế khi liquidity thấp. Chiến lược MA Crossover của chúng tôi đạt Sharpe Ratio 2.3 trên dữ liệu miễn phí, nhưng khi chạy với dữ liệu chất lượng cao từ HolySheep AI, Sharpe Ratio thực tế chỉ còn 0.8. Chênh lệch này có thể khiến bạn mất toàn bộ vốn.

Backtrader vs VectorBT: So sánh toàn diện

Tiêu chí Backtrader VectorBT
Ngôn ngữ Python 3.7+ Python 3.9+ (NumPy acceleration)
Tốc độ backtest 1x - 10x (phụ thuộc dữ liệu) 100x - 1000x (vectorization)
Độ phức tạp code Trung bình, có Cerebro engine Thấp, API đơn giản
Hỗ trợ perpetual Cần custom data feed Hỗ trợ tốt hơn
Transaction cost Đầy đủ (commission, slippage) Chi tiết, có spread modeling
Visualization Matplotlib cơ bản Plotly tương tác, mạnh mẽ
Độ trưởng thành 6+ năm, community lớn 3 năm, đang phát triển mạnh
Phù hợp cho Chiến lược phức tạp, nhiều asset Research nhanh, parameter sweep

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

✅ Nên dùng Backtrader khi:

✅ Nên dùng VectorBT khi:

❌ Không nên dùng khi:

Kiến trúc hệ thống đề xuất

Đây là kiến trúc mà đội ngũ tôi đã implement thành công, sử dụng HolySheep AI làm data layer:

┌─────────────────────────────────────────────────────────────────┐
│                    HỆ THỐNG BACKTEST ARCHITECTURE               │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────────┐  │
│  │ HolySheep    │───▶│ Data Layer   │───▶│ Backtest Engine  │  │
│  │ API          │    │ (Cache/Pg)   │    │ (Backtrader/VBT) │  │
│  │ <50ms        │    │              │    │                  │  │
│  └──────────────┘    └──────────────┘    └────────┬─────────┘  │
│                                                    │            │
│  ┌──────────────┐    ┌──────────────┐    ┌────────▼─────────┐  │
│  │ Risk Engine  │◀───│ Metrics      │◀───│ Results         │  │
│  │ (VaR, MM)    │    │ (Sharpe,DD)  │    │ Storage         │  │
│  └──────────────┘    └──────────────┘    └──────────────────┘  │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

Triển khai với HolySheep API: Code mẫu

1. Kết nối HolySheep và lấy dữ liệu BTC-USDT perpetual

#!/usr/bin/env python3
"""
BTC-USDT Perpetual Data Fetcher với HolySheep API
Tiết kiệm 85%+ chi phí so với API chính thức
"""

import requests
import pandas as pd
from datetime import datetime, timedelta
import time

class HolySheepDataFetcher:
    """Data fetcher cho BTC-USDT perpetual với HolySheep API"""
    
    def __init__(self, api_key: str):
        self.base_url = "https://api.holysheep.ai/v1"
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }
        self.session = requests.Session()
        self.session.headers.update(self.headers)
    
    def get_klines(self, symbol: str = "BTCUSDT", 
                   interval: str = "1h",
                   start_time: int = None,
                   end_time: int = None,
                   limit: int = 1000):
        """
        Lấy dữ liệu OHLCV cho perpetual contract
        
        Args:
            symbol: Cặp giao dịch (BTCUSDT, ETHUSDT...)
            interval: Khung thời gian (1m, 5m, 1h, 4h, 1d)
            start_time: Timestamp ms (mặc định: 7 ngày trước)
            end_time: Timestamp ms (mặc định: hiện tại)
            limit: Số lượng candles (max 1000)
        """
        if end_time is None:
            end_time = int(time.time() * 1000)
        if start_time is None:
            start_time = end_time - (7 * 24 * 60 * 60 * 1000)  # 7 ngày
        
        endpoint = f"{self.base_url}/klines"
        params = {
            "symbol": symbol,
            "interval": interval,
            "startTime": start_time,
            "endTime": end_time,
            "limit": limit
        }
        
        response = self.session.get(endpoint, params=params, timeout=10)
        
        if response.status_code == 200:
            data = response.json()
            return self._parse_klines(data)
        else:
            raise Exception(f"API Error: {response.status_code} - {response.text}")
    
    def _parse_klines(self, raw_data):
        """Parse API response thành DataFrame chuẩn"""
        df = pd.DataFrame(raw_data, columns=[
            'open_time', 'open', 'high', 'low', 'close', 'volume',
            'close_time', 'quote_volume', 'trades', 'taker_buy_volume',
            'taker_buy_quote_volume', 'ignore'
        ])
        
        # Convert numeric columns
        numeric_cols = ['open', 'high', 'low', 'close', 'volume', 
                       'quote_volume', 'taker_buy_volume', 'taker_buy_quote_volume']
        for col in numeric_cols:
            df[col] = pd.to_numeric(df[col], errors='coerce')
        
        # Convert timestamps
        df['open_time'] = pd.to_datetime(df['open_time'], unit='ms')
        df['close_time'] = pd.to_datetime(df['close_time'], unit='ms')
        
        return df
    
    def get_funding_rate(self, symbol: str = "BTCUSDT", 
                         days: int = 30):
        """Lấy lịch sử funding rate cho perpetual"""
        end_time = int(time.time() * 1000)
        start_time = end_time - (days * 24 * 60 * 60 * 1000)
        
        endpoint = f"{self.base_url}/funding_rate"
        params = {
            "symbol": symbol,
            "startTime": start_time,
            "endTime": end_time
        }
        
        response = self.session.get(endpoint, params=params, timeout=10)
        
        if response.status_code == 200:
            return response.json()
        else:
            raise Exception(f"Funding rate error: {response.status_code}")
    
    def get_orderbook_snapshot(self, symbol: str = "BTCUSDT", 
                               limit: int = 100):
        """Lấy orderbook snapshot cho slippage calculation"""
        endpoint = f"{self.base_url}/depth"
        params = {"symbol": symbol, "limit": limit}
        
        response = self.session.get(endpoint, params=params, timeout=10)
        
        if response.status_code == 200:
            return response.json()
        else:
            raise Exception(f"Orderbook error: {response.status_code}")


============ SỬ DỤNG ============

if __name__ == "__main__":
    # Khởi tạo với API key từ HolySheep
    API_KEY = "YOUR_HOLYSHEEP_API_KEY"
    fetcher = HolySheepDataFetcher(API_KEY)
    
    # Lấy 1 năm dữ liệu 1h cho BTC-USDT
    print("Đang lấy dữ liệu BTC-USDT perpetual...")
    
    all_klines = []
    end_time = int(time.time() * 1000)
    start_time = end_time - (365 * 24 * 60 * 60 * 1000)  # 1 năm
    
    # Loop để lấy nhiều chunks
    current_start = start_time
    while current_start < end_time:
        chunk = fetcher.get_klines(
            symbol="BTCUSDT",
            interval="1h",
            start_time=current_start,
            end_time=end_time,
            limit=1000
        )
        all_klines.append(chunk)
        
        if len(chunk) < 1000:
            break
        current_start = int(chunk['open_time'].max().timestamp() * 1000) + 1
        print(f"  Đã lấy {len(all_klines) * 1000} candles...")
    
    # Combine tất cả chunks
    df = pd.concat(all_klines, ignore_index=True)
    df = df.drop_duplicates(subset=['open_time']).sort_values('open_time')
    
    print(f"Tổng cộng: {len(df)} candles")
    print(f"Khoảng thời gian: {df['open_time'].min()} - {df['open_time'].max()}")
    print(f"Giá trung bình: ${df['close'].mean():.2f}")
    print(f"Độ biến động (std): ${df['close'].std():.2f}")

2. Backtrader Integration với HolySheep Data

#!/usr/bin/env python3
"""
Backtrader Strategy cho BTC-USDT Perpetual
Sử dụng dữ liệu từ HolySheep API
"""

import backtrader as bt
import pandas as pd
from holytrader_fetcher import HolySheepDataFetcher

class PerpetualData(bt.feeds.PandasData):
    """Custom data feed hỗ trợ perpetual contract fields"""
    lines = ('funding_rate', 'open_interest',)
    params = (
        ('datetime', 'open_time'),
        ('open', 'open'),
        ('high', 'high'),
        ('low', 'low'),
        ('close', 'close'),
        ('volume', 'volume'),
        ('openinterest', -1),  # Không có trong data
    )

class MACrossStrategy(bt.Strategy):
    """
    Chiến lược MA Crossover với money management
    - MA ngắn: 10 periods
    - MA dài: 50 periods
    - Position size dựa trên volatility
    """
    
    params = (
        ('fast_period', 10),
        ('slow_period', 50),
        ('atr_period', 14),
        ('risk_per_trade', 0.02),  # 2% vốn
        ('max_position', 0.3),     # Max 30% portfolio
    )
    
    def __init__(self):
        self.dataclose = self.datas[0].close
        self.dataopen = self.datas[0].open
        
        # Indicators
        self.fast_ma = bt.indicators.SMA(
            self.data.close, period=self.p.fast_period
        )
        self.slow_ma = bt.indicators.SMA(
            self.data.close, period=self.p.slow_period
        )
        self.atr = bt.indicators.ATR(
            self.data, period=self.p.atr_period
        )
        
        # Crossover signal
        self.crossover = bt.indicators.CrossOver(
            self.fast_ma, self.slow_ma
        )
        
        # Order tracking
        self.order = None
        self.trade_count = 0
        
        # Commission scheme cho perpetual
        self.broker.setcommission(
            commission=0.0004,      # 0.04% taker fee
            margin=0.05,            # 5x leverage
            mult=1.0,
            name='PERPETUAL'
        )
    
    def notify_order(self, order):
        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}')
            else:
                self.log(f'SELL EXECUTED, Price: {order.executed.price:.2f}')
        
        elif order.status in [order.Canceled, order.Margin, order.Rejected]:
            self.log('Order Canceled/Margin/Rejected')
        
        self.order = None
    
    def notify_trade(self, trade):
        if trade.isclosed:
            self.trade_count += 1
            self.log(f'TRADE PROFIT, GROSS: {trade.pnl:.2f}, NET: {trade.pnlcomm:.2f}')
    
    def next(self):
        if self.order:
            return
        
        # Position sizing dựa trên ATR
        risk_amount = self.broker.getvalue() * self.p.risk_per_trade
        position_size = risk_amount / self.atr[0]
        position_value = position_size * self.dataclose[0]
        max_value = self.broker.getvalue() * self.p.max_position
        
        if position_value > max_value:
            position_size = max_value / self.dataclose[0]
        
        # Trading logic
        if not self.position:
            if self.crossover > 0:  # Golden cross
                self.log(f'BUY CREATE, {self.dataclose[0]:.2f}')
                self.order = self.buy(size=int(position_size))
        
        else:
            if self.crossover < 0:  # Death cross
                self.log(f'SELL CREATE, {self.dataclose[0]:.2f}')
                self.order = self.close()
    
    def log(self, txt, dt=None):
        dt = dt or self.datas[0].datetime.date(0)
        print(f'{dt.isoformat()} {txt}')

def run_backtest(api_key: str, initial_cash: float = 100000):
    """Run backtest với dữ liệu từ HolySheep"""
    
    # 1. Fetch dữ liệu
    print("Đang lấy dữ liệu từ HolySheep...")
    fetcher = HolySheepDataFetcher(api_key)
    
    df = fetcher.get_klines(
        symbol="BTCUSDT",
        interval="1h",
        limit=1000
    )
    
    # 2. Setup Cerebro
    cerebro = bt.Cerebro(optreturn=False)
    cerebro.broker.setcash(initial_cash)
    cerebro.addstrategy(MACrossStrategy)
    
    # 3. Add analyzers
    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')
    cerebro.addanalyzer(bt.analyzers.TimeReturn, _name='time_return')
    
    # 4. Add data feed
    data = PerpetualData(dataname=df)
    cerebro.adddata(data)
    
    # 5. Run
    print(f'Starting Portfolio Value: ${cerebro.broker.getvalue():.2f}')
    results = cerebro.run()
    strategy = results[0]
    
    # 6. Kết quả
    final_value = cerebro.broker.getvalue()
    print(f'Final Portfolio Value: ${final_value:.2f}')
    print(f'Total Return: {((final_value - initial_cash) / initial_cash) * 100:.2f}%')
    print(f'Number of trades: {strategy.trade_count}')
    
    # Sharpe ratio
    sharpe = strategy.analyzers.sharpe.get_analysis()
    if sharpe.get('sharperatio'):
        print(f'Sharpe Ratio: {sharpe["sharperatio"]:.3f}')
    
    # Drawdown
    dd = strategy.analyzers.drawdown.get_analysis()
    print(f"Max Drawdown: {dd.get('max', {}).get('drawdown', 0):.2f}%")
    
    return {
        'final_value': final_value,
        'return_pct': ((final_value - initial_cash) / initial_cash) * 100,
        'sharpe': sharpe.get('sharperatio'),
        'max_dd': dd.get('max', {}).get('drawdown', 0),
        'num_trades': strategy.trade_count
    }

if __name__ == '__main__':
    API_KEY = "YOUR_HOLYSHEEP_API_KEY"
    results = run_backtest(API_KEY, initial_cash=100000)

3. VectorBT Integration với HolySheep Data

#!/usr/bin/env python3
"""
VectorBT Backtest cho BTC-USDT Perpetual
Tốc độ nhanh gấp 100-1000x so với Backtrader
"""

import vectorbt as vbt
import pandas as pd
import numpy as np
from holytrader_fetcher import HolySheepDataFetcher

def prepare_signals(fast_ma: pd.Series, slow_ma: pd.Series) -> pd.Series:
    """Tạo signals: 1 = Long, -1 = Short, 0 = Flat"""
    entries = fast_ma > slow_ma
    exits = fast_ma < slow_ma
    return entries.astype(int) - exits.astype(int)

def run_vectorbt_backtest(api_key: str, 
                         initial_cash: float = 100000,
                         fast_period: int = 10,
                         slow_period: int = 50):
    """
    VectorBT backtest với MA Crossover
    """
    # 1. Fetch dữ liệu
    print(f"Đang lấy dữ liệu từ HolySheep...")
    fetcher = HolySheepDataFetcher(api_key)
    
    # Lấy dữ liệu 1h cho 1 năm
    end_time = int(pd.Timestamp.now().timestamp() * 1000)
    start_time = end_time - (365 * 24 * 60 * 60 * 1000)
    
    df = fetcher.get_klines(
        symbol="BTCUSDT",
        interval="1h",
        start_time=start_time,
        end_time=end_time,
        limit=1000
    )
    
    # Multi-chunk fetch
    all_data = [df]
    current_time = start_time
    while current_time < end_time:
        try:
            chunk = fetcher.get_klines(
                symbol="BTCUSDT",
                interval="1h",
                start_time=current_time,
                end_time=end_time,
                limit=1000
            )
            if len(chunk) < 1000:
                all_data.append(chunk)
                break
            all_data.append(chunk)
            current_time = int(chunk['open_time'].max().timestamp() * 1000) + 3600000
        except Exception as e:
            print(f"Lỗi fetch: {e}")
            break
    
    df = pd.concat(all_data, ignore_index=True)
    df = df.drop_duplicates(subset=['open_time']).set_index('open_time')
    df = df.sort_index()
    
    print(f"Đã load {len(df)} candles")
    
    # 2. Tính indicators
    close = df['close']
    fast_ma = vbt.MA.run(close, window=fast_period)
    slow_ma = vbt.MA.run(close, window=slow_period)
    atr = vbt.ATR.run(df['high'], df['low'], close, window=14)
    
    # 3. Tạo signals
    entries = fast_ma.ma_cross(slow_ma, direction='above')
    exits = fast_ma.ma_cross(slow_ma, direction='below')
    
    # 4. Portfolio settings
    portfolio = vbt.Portfolio.from_signals(
        close=close,
        entries=entries,
        exits=exits,
        init_cash=initial_cash,
        fees=0.0004,           # 0.04% taker fee
        slippage=0.0005,       # 0.05% slippage
        leverage=1.0,
        leverage_updating_mode='lazy',
        size_type='percent',
        size=0.95,             # 95% vốn per trade
    )
    
    # 5. Metrics
    print("\n" + "="*50)
    print("KẾT QUẢ BACKTEST")
    print("="*50)
    print(f"Total Return: {portfolio.total_return()*100:.2f}%")
    print(f"Sharpe Ratio: {portfolio.sharpe_ratio():.3f}")
    print(f"Sortino Ratio: {portfolio.sortino_ratio():.3f}")
    print(f"Max Drawdown: {portfolio.max_drawdown()*100:.2f}%")
    print(f"Win Rate: {portfolio.win_rate()*100:.2f}%")
    print(f"Total Trades: {portfolio.trades.count()}")
    print(f"Avg Trade Duration: {portfolio.trades.duration().mean()}")
    
    # 6. Trade analysis
    trades_df = portfolio.trades.records_readable
    if len(trades_df) > 0:
        winning_trades = trades_df[trades_df['Return'] > 0]
        losing_trades = trades_df[trades_df['Return'] <= 0]
        
        print(f"\nTrade Statistics:")
        print(f"  Winning trades: {len(winning_trades)} ({len(winning_trades)/len(trades_df)*100:.1f}%)")
        print(f"  Losing trades: {len(losing_trades)} ({len(losing_trades)/len(trades_df)*100:.1f}%)")
        
        if len(winning_trades) > 0:
            print(f"  Avg Win: {winning_trades['Return'].mean()*100:.2f}%")
        if len(losing_trades) > 0:
            print(f"  Avg Loss: {losing_trades['Return'].mean()*100:.2f}%")
        
        # Profit factor
        gross_profit = winning_trades['Return'].sum() if len(winning_trades) > 0 else 0
        gross_loss = abs(losing_trades['Return'].sum()) if len(losing_trades) > 0 else 1
        print(f"  Profit Factor: {gross_profit/gross_loss:.2f}")
    
    return portfolio

def parameter_sweep(api_key: str):
    """
    Parameter sweep để tìm optimal MA periods
    VectorBT cho phép thử hàng ngàn combinations trong vài giây
    """
    print("Running parameter sweep...")
    fetcher = HolySheepDataFetcher(api_key)
    
    # Lấy dữ liệu
    df = fetcher.get_klines(symbol="BTCUSDT", interval="1h", limit=1000)
    close = df.set_index('open_time')['close']
    
    # Define parameter ranges
    fast_range = range(5, 30, 5)   # 5, 10, 15, 20, 25
    slow_range = range(20, 100, 10) # 20, 30, 40, 50, 60, 70, 80, 90
    
    # Run sweep
    pf = vbt.Parameter(
        names=['fast_period', 'slow_period'],
        ranges=[fast_range, slow_range],
        param_product=True
    ).scan(
        vbt.closes,
        fast_mas=lambda close, fast_period: vbt.MA.run(close, fast_period).ma,
        slow_mas=lambda close, slow_period: vbt.MA.run(close, slow_period).ma,
        entries=lambda fast_ma, slow_ma: fast_ma > slow_ma,
        exits=lambda fast_ma, slow_ma: fast_ma < slow_ma,
        close=close,
        init_cash=100000,
        fees=0.0004
    )
    
    # Results
    results = pf.sort_by('sharpe')
    print("\nTop 10 Parameters by Sharpe Ratio:")
    print(results[['fast_period', 'slow_period', 'sharpe', 'total_return', 'max_drawdown']].head(10))
    
    return pf

if __name__ == '__main__':
    API_KEY = "YOUR_HOLYSHEEP_API_KEY"
    
    # Single backtest
    portfolio = run_vectorbt_backtest(API_KEY)
    
    # Parameter sweep (optional, chậm hơn nhưng cho kết quả tốt hơn)
    # pf = parameter_sweep(API_KEY)
    
    # Visualization
    portfolio.plot(show=True).show()
    portfolio.trades.plot(show=True).show()

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

1. Lỗi "API Error 429: Rate Limit Exceeded"

# VẤN ĐỀ: Request quá nhiều trong thời gian ngắn

MÃ LỖI: HTTP 429 Too Many Requests



GIẢI PHÁP: Implement exponential backoff và caching


import time
import requests
from functools import wraps

class RateLimitedFetcher:
    def __init__(self, api_key: str):
        self.base_url = "https://api.holysheep.ai/v1"
        self.headers = {"Authorization": f"Bearer {api_key}"}
        self.cache = {}
        self.cache_ttl = 300  # 5 phút
        self.last_request_time = 0
        self.min_request_interval = 0.1  # 100ms giữa các request
    
    def _wait_for_rate_limit(self):
        """Đợi đủ thời gian giữa các request"""
        elapsed = time.time() - self.last_request_time
        if elapsed < self.min_request_interval:
            time.sleep(self.min_request_interval - elapsed)
        self.last_request_time = time.time()
    
    def _get_cached(self, key: str):
        """Lấy data từ cache nếu còn valid"""
        if key in self.cache:
            data, timestamp = self.cache[key]
            if time.time() - timestamp < self.cache_ttl:
                return data
        return None
    
    def _set_cache(self, key: str, data):
        """Lưu data vào cache"""
        self.cache[key] = (data, time.time())
    
    def get_klines(self, symbol: str, interval: str, limit: int = 1000, max_retries: int = 3):
        """Fetch với retry logic và exponential backoff"""
        
        cache_key = f"{symbol}_{interval}_{limit}"
        cached = self._get_cached(cache_key)
        if cached:
            print("Sử dụng data từ cache...")
            return cached
        
        self._wait_for_rate_limit()
        
        for attempt in range(max_retries):
            try:
                response = requests.get(
                    f"{self.base_url}/klines",
                    headers=self.headers,
                    params={"symbol": symbol, "interval": interval, "limit": limit},
                    timeout=30
                )
                
                if response.status_code == 200:
                    data = response.json()
                    self._set_cache(cache_key, data)
                    return data
                
                elif response.status_code == 429:
                    # Rate limit - exponential backoff
                    wait_time = (2 ** attempt) * 1.0  # 1s, 2s, 4s
                    print(f"Rate limit hit. Đợi {wait_time}s...")
                    time.sleep(wait_time)
                
                elif response.status_code == 500:
                    # Server error - retry
                    wait_time = (2 ** attempt) * 0.5
                    print(f"Server error. Retry sau {wait_time}s...")
                    time.sleep(wait_time)
                
                else:
                    raise Exception(f"API Error: {response.status_code}")
            
            except requests.exceptions.Timeout:
                if attempt == max_retries - 1:
                    raise
                time.sleep(2 ** attempt)
        
        raise Exception("Max retries exceeded")

2. Lỗi "Data inconsistency: Missing candles in time range"

# VẤN ĐỀ: Dữ liệu bị gap (thiếu candles)

NGUYÊN NHÂN: Exchange maintenance, API timeout, hoặc data fetch error



GIẢI PHÁP: Validate và fill gaps


import pandas as pd
import numpy as np
from datetime import timedelta

def validate_and_fill_gaps(df: pd.DataFrame, 
                           interval: str = '1h',
                           max_gap: int = 5) -> pd.DataFrame:
    """
    Validate data và fill gaps với interpolation
    
    Args:
        df: DataFrame với index là datetime
        interval: Khoảng thời gian ('1h', '4h', '1d')
        max_gap: Số candles tối đa có thể fill
    
    Returns:
        DataFrame đã được validate và fill
    """
    # Convert index thành datetime nếu chưa
    if not isinstance(df.index, pd.DatetimeIndex):
        df.index = pd.to_datetime(df.index)
    
    df = df.sort_index()
    
    # Tạo complete time series
    start_time = df.index.min()

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