Tháng 3/2025, tôi nhận được một cuộc gọi từ một quỹ phòng hộ nhỏ tại TP.HCM. Họ vừa triển khai một mô hình AI trading với độ chính xác backtest lên tới 78% — con số mà bất kỳ data scientist nào cũng mơ ước. Nhưng sau 3 tháng live trading, drawdown lên tới 35%. Đó là khoảnh khắc tôi nhận ra: backtest hoàn hảo là ảo tưởng nguy hiểm nhất trong trading.

Giải pháp nằm ở Walk-forward Analysis (WFA) — phương pháp mà tôi sẽ hướng dẫn bạn toàn bộ trong bài viết này. Với WFA, bạn sẽ mô phỏng trading thực tế bằng cách liên tục retrain và test trên các cửa sổ thời gian liền kề, loại bỏ hoàn toàn hiện tượng look-ahead bias.

Tại Sao Backtest Truyền Thống Thất Bại?

Backtest truyền thống có 3 lỗ hổng chết người:

Trong kinh nghiệm 5 năm xây dựng hệ thống trading tại HolySheep AI, tôi đã chứng kiến hàng chục dự án "thất bại vì overfitting" — và WFA luôn là giải pháp cứu rỗi.

Nguyên Lý Walk-forward Analysis

WFA hoạt động theo cơ chế "cửa sổ trượt":

┌─────────────────────────────────────────────────────────────────┐
│  TRAINING WINDOW          │  TEST WINDOW                       │
│  (In-Sample)              │  (Out-of-Sample)                   │
├───────────────────────────┼─────────────────────────────────────┤
│  T1 ────────────────── T2 │ T2 ─────────────────── T3           │
│         Retrain & Tune    │    Live Simulation                 │
└─────────────────────────────────────────────────────────────────┘

Cửa sổ tiếp theo:
┌─────────────────────────────────────────────────────────────────┐
│  TRAINING WINDOW          │  TEST WINDOW                       │
├───────────────────────────┼─────────────────────────────────────┤
│  T2 ────────────────── T3 │ T3 ─────────────────── T4          │
│         Retrain & Tune    │    Live Simulation                 │
└─────────────────────────────────────────────────────────────────┘

Quy trình cụ thể:

  1. Bước 1: Train mô hình trên cửa sổ [T1, T2]
  2. Bước 2: Test trên cửa sổ [T2, T3] — KHÔNG có thông tin từ T3 trở đi
  3. Bước 3: Dịch chuyển cửa sổ, lặp lại cho đến khi kết thúc dữ liệu
  4. Bước 4: Tổng hợp kết quả từ tất cả các test windows

Cài Đặt Môi Trường và Khởi Tạo

Tôi luôn bắt đầu với việc setup môi trường sạch. Dưới đây là script hoàn chỉnh sử dụng HolySheep AI API để phân tích dữ liệu thị trường:

#!/usr/bin/env python3
"""
Walk-forward Analysis cho AI Trading Models
Author: HolySheep AI Technical Team
"""

import requests
import json
import numpy as np
import pandas as pd
from datetime import datetime, timedelta
from typing import List, Dict, Tuple
import warnings
warnings.filterwarnings('ignore')


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


CẤU HÌNH HOLYSHEEP AI - Thay thế cho OpenAI/Anthropic


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

HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = "YOUR_HOLYSHEEP_API_KEY"  # Lấy từ https://www.holysheep.ai/register

class HolySheepAIClient:
    """Client tối ưu chi phí với độ trễ <50ms"""
    
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = HOLYSHEEP_BASE_URL
        
    def analyze_market_data(self, data: dict, model: str = "deepseek-v3.2") -> dict:
        """
        Sử dụng DeepSeek V3.2 cho phân tích - chỉ $0.42/MTok
        Tiết kiệm 85% so với GPT-4.1 ($8/MTok)
        """
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        payload = {
            "model": model,
            "messages": [
                {
                    "role": "system", 
                    "content": "Bạn là chuyên gia phân tích thị trường tài chính."
                },
                {
                    "role": "user",
                    "content": f"Phân tích dữ liệu thị trường sau:\n{json.dumps(data, indent=2)}"
                }
            ],
            "temperature": 0.3,
            "max_tokens": 500
        }
        
        start_time = datetime.now()
        response = requests.post(
            f"{self.base_url}/chat/completions",
            headers=headers,
            json=payload,
            timeout=30
        )
        latency = (datetime.now() - start_time).total_seconds() * 1000
        
        if response.status_code == 200:
            result = response.json()
            return {
                "analysis": result['choices'][0]['message']['content'],
                "latency_ms": round(latency, 2),
                "model_used": model,
                "cost_estimate": len(json.dumps(payload)) / 1_000_000 * 0.42  # DeepSeek pricing
            }
        else:
            raise Exception(f"HolySheep API Error: {response.status_code} - {response.text}")


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


KHỞI TẠO CLIENT - Đăng ký tại https://www.holysheep.ai/register


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

client = HolySheepAIClient(API_KEY)


Test kết nối

test_result = client.analyze_market_data({"symbol": "BTC/USD", "price": 67500})
print(f"✅ Kết nối thành công!")
print(f"   Model: {test_result['model_used']}")
print(f"   Latency: {test_result['latency_ms']}ms (cam kết <50ms)")
print(f"   Cost estimate: ${test_result['cost_estimate']:.6f}")

Triển Khai Walk-Forward Engine

Đây là phần core của hệ thống — class WalkForwardEngine xử lý toàn bộ quy trình WFA:

class WalkForwardEngine:
    """
    Walk-Forward Analysis Engine
    Mô phỏng trading thực tế với retraining liên tục
    """
    
    def __init__(
        self,
        train_window_days: int = 252,  # 1 năm train
        test_window_days: int = 63,      # 3 tháng test
        step_days: int = 21,             # Bước nhảy 1 tháng
        min_samples: int = 100
    ):
        self.train_window = train_window_days
        self.test_window = test_window_days
        self.step = step_days
        self.min_samples = min_samples
        self.results = []
        
    def create_windows(self, data: pd.DataFrame) -> List[Tuple[pd.DataFrame, pd.DataFrame]]:
        """
        Tạo các cặp train/test windows
        Đảm bảo không có look-ahead bias
        """
        windows = []
        start_idx = 0
        
        while start_idx + self.train_window + self.test_window <= len(data):
            train_end = start_idx + self.train_window
            test_end = train_end + self.test_window
            
            train_data = data.iloc[start_idx:train_end].copy()
            test_data = data.iloc[train_end:test_end].copy()
            
            if len(train_data) >= self.min_samples and len(test_data) >= self.min_samples // 2:
                windows.append((train_data, test_data))
                
            start_idx += self.step
            
        return windows
    
    def calculate_metrics(self, predictions: np.array, actuals: np.array) -> Dict:
        """
        Tính toán metrics đa chiều
        Không chỉ accuracy - cần Sharpe, Max Drawdown, Win Rate
        """
        returns = np.where(predictions == 1, 
                          np.diff(actuals) / actuals[:-1],
                          -np.diff(actuals) / actuals[:-1])
        
        cumulative = np.cumprod(1 + returns)
        max_dd = np.max(np.maximum.accumulate(cumulative) - cumulative)
        
        return {
            "accuracy": np.mean(predictions == actuals[1:]),
            "sharpe_ratio": returns.mean() / returns.std() * np.sqrt(252) if returns.std() > 0 else 0,
            "max_drawdown": max_dd,
            "win_rate": np.mean(returns > 0),
            "total_return": cumulative[-1] - 1 if len(cumulative) > 0 else 0,
            "avg_return_per_trade": np.mean(returns),
            "profit_factor": abs(returns[returns > 0].sum() / returns[returns < 0].sum()) if returns[returns < 0].sum() != 0 else float('inf')
        }
    
    def run_analysis(
        self, 
        data: pd.DataFrame, 
        feature_cols: List[str],
        target_col: str,
        model_fn: callable
    ) -> pd.DataFrame:
        """
        Chạy toàn bộ Walk-Forward Analysis
        Trả về DataFrame với metrics từng window
        """
        windows = self.create_windows(data)
        all_results = []
        
        for i, (train_data, test_data) in enumerate(windows):
            # Train mô hình trên in-sample data
            X_train = train_data[feature_cols]
            y_train = train_data[target_col]
            
            model = model_fn(X_train, y_train)
            
            # Test trên out-of-sample data
            X_test = test_data[feature_cols]
            y_test = test_data[target_col]
            
            predictions = model.predict(X_test)
            metrics = self.calculate_metrics(predictions, y_test.values)
            
            # Lưu kết quả với metadata
            result = {
                "window_id": i,
                "train_period": f"{train_data.index[0]} to {train_data.index[-1]}",
                "test_period": f"{test_data.index[0]} to {test_data.index[-1]}",
                **metrics
            }
            all_results.append(result)
            
            print(f"Window {i}: Acc={metrics['accuracy']:.2%}, "
                  f"Sharpe={metrics['sharpe_ratio']:.2f}, "
                  f"MaxDD={metrics['max_drawdown']:.2%}")
        
        self.results = pd.DataFrame(all_results)
        return self.results
    
    def get_aggregate_metrics(self) -> Dict:
        """
        Tổng hợp metrics từ tất cả windows
        Đánh giá stability của mô hình
        """
        if not self.results:
            return {}
            
        return {
            "mean_accuracy": self.results['accuracy'].mean(),
            "std_accuracy": self.results['accuracy'].std(),
            "mean_sharpe": self.results['sharpe_ratio'].mean(),
            "worst_drawdown": self.results['max_drawdown'].max(),
            "consistency_score": (self.results['sharpe_ratio'] > 1).mean(),
            "degradation_ratio": self.results['accuracy'].iloc[-1] / self.results['accuracy'].iloc[0]
        }


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


VÍ DỤ SỬ DỤNG VỚI HOLYSHEEP AI


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



Tạo data giả lập (thay bằng dữ liệu thật từ broker)

np.random.seed(42)
dates = pd.date_range('2022-01-01', '2025-12-31', freq='D')
n = len(dates)

price_data = pd.DataFrame({
    'date': dates,
    'close': 100 * np.cumprod(1 + np.random.normal(0.0005, 0.02, n)),
    'volume': np.random.randint(1_000_000, 10_000_000, n),
    'volatility': np.random.uniform(0.1, 0.3, n),
    'rsi': np.random.uniform(30, 70, n),
    'ma_20': 0, 'ma_50': 0
})


Tính Moving Averages

price_data['ma_20'] = price_data['close'].rolling(20).mean()
price_data['ma_50'] = price_data['close'].rolling(50).mean()
price_data = price_data.dropna()


Target: 1 nếu giá tăng ngày mai

price_data['target'] = (price_data['close'].shift(-1) > price_data['close']).astype(int)
price_data = price_data.dropna()


Define features

features = ['volatility', 'rsi', 'ma_20', 'ma_50']
target = 'target'


Simple model function (có thể thay bằng XGBoost, LSTM, etc.)

from sklearn.ensemble import RandomForestClassifier
def create_model(X, y):
    return RandomForestClassifier(n_estimators=100, max_depth=5, random_state=42)


Chạy Walk-Forward Analysis

engine = WalkForwardEngine(
    train_window_days=252,
    test_window_days=63,
    step_days=21
)

results_df = engine.run_analysis(
    price_data.set_index('date'),
    features,
    target,
    create_model
)

print("\n" + "="*60)
print("KẾT QUẢ TỔNG HỢP WALK-FORWARD ANALYSIS")
print("="*60)
agg_metrics = engine.get_aggregate_metrics()
for key, value in agg_metrics.items():
    print(f"{key}: {value:.4f}" if isinstance(value, float) else f"{key}: {value}")

So Sánh Chi Phí: HolySheep AI vs OpenAI/Anthropic

Một trong những điểm tôi yêu thích khi làm việc với HolySheep AI là chi phí huấn luyện mô hình AI cực thấp. Với phân tích walk-forward cần hàng trăm lần gọi API để tối ưu hyperparameters, sự chênh lệch chi phí là đáng kể:

ProviderModelGiá/MTok1,000 Windows ($)Độ trễ
HolySheep AIDeepSeek V3.2$0.42$0.42<50ms
OpenAIGPT-4.1$8.00$8.00~200ms
AnthropicClaude Sonnet 4.5$15.00$15.00~300ms
GoogleGemini 2.5 Flash$2.50$2.50~150ms

Với 1,000 windows phân tích WFA mỗi ngày, bạn tiết kiệm được 95%+ chi phí khi dùng DeepSeek V3.2 qua HolySheep AI — chỉ $0.42 thay vì $8.00 với GPT-4.1.

Tích Hợp AI Feature Engineering

Điểm mạnh của HolySheep AI là khả năng feature engineering thông minh. Tôi sử dụng nó để tự động sinh indicators mới:

def generate_ai_features(data: pd.DataFrame, client: HolySheepAIClient) -> pd.DataFrame:
    """
    Sử dụng HolySheep AI để phân tích và đề xuất features
    Chi phí cực thấp: $0.42/MTok
    """
    market_summary = {
        "current_price": data['close'].iloc[-1],
        "price_change_1d": data['close'].pct_change().iloc[-1],
        "price_change_1w": data['close'].pct_change(7).iloc[-1],
        "volume_trend": data['volume'].rolling(20).mean().iloc[-1] / data['volume'].mean(),
        "volatility_current": data['volatility'].iloc[-1],
        "rsi_current": data['rsi'].iloc[-1]
    }
    
    prompt = """
    Phân tích dữ liệu thị trường sau và đề xuất 5 technical indicators 
    mới giúp cải thiện mô hình dự đoán xu hướng giá:
    
    Chỉ trả lời theo format JSON với cấu trúc:
    {
        "indicators": [
            {"name": "tên_indicator", "formula": "công thức", "description": "mô tả"}
        ]
    }
    """
    
    response = client.analyze_market_data({
        "data": market_summary,
        "request": prompt
    }, model="deepseek-v3.2")
    
    print(f"AI Feature Suggestion - Latency: {response['latency_ms']}ms")
    return response['analysis']


Áp dụng AI-suggested features

ai_features = generate_ai_features(price_data, client)
print("AI Features:", ai_features)


Thêm momentum-based features

price_data['momentum_5'] = price_data['close'].pct_change(5)
price_data['momentum_10'] = price_data['close'].pct_change(10)
price_data['momentum_20'] = price_data['close'].pct_change(20)
price_data['volatility_ratio'] = price_data['volatility'] / price_data['volatility'].rolling(20).mean()


Cập nhật features list

enhanced_features = features + ['momentum_5', 'momentum_10', 'momentum_20', 'volatility_ratio']


Chạy lại WFA với features mới

print("\n" + "="*60)
print("WALK-FORWARD VỚI AI-ENHANCED FEATURES")
print("="*60)

engine_enhanced = WalkForwardEngine(
    train_window_days=252,
    test_window_days=63,
    step_days=21
)

results_enhanced = engine_enhanced.run_analysis(
    price_data.set_index('date'),
    enhanced_features,
    target,
    create_model
)

agg_enhanced = engine_enhanced.get_aggregate_metrics()
print(f"\nSo sánh Performance:")
print(f"  Trước - Mean Accuracy: {agg_metrics['mean_accuracy']:.4f}")
print(f"  Sau   - Mean Accuracy: {agg_enhanced['mean_accuracy']:.4f}")
print(f"  Cải thiện: {(agg_enhanced['mean_accuracy'] - agg_metrics['mean_accuracy'])*100:.2f}%")

Đánh Giá Stability Qua Thời Gian

Một trong những metric quan trọng nhất trong WFA là stability score — cho biết mô hình có hoạt động ổn định qua các market regimes khác nhau hay không:

import matplotlib.pyplot as plt

def evaluate_regime_stability(results_df: pd.DataFrame) -> Dict:
    """
    Đánh giá stability của mô hình qua các market conditions
    """
    # Chia thành bullish/bearish/sideways periods
    results_df['regime'] = pd.cut(
        results_df['total_return'],
        bins=[-np.inf, -0.05, 0.05, np.inf],
        labels=['Bearish', 'Sideways', 'Bullish']
    )
    
    regime_analysis = results_df.groupby('regime').agg({
        'accuracy': ['mean', 'std'],
        'sharpe_ratio': ['mean', 'std'],
        'max_drawdown': 'mean'
    }).round(4)
    
    # Tính consistency score - % windows có Sharpe > 1
    consistency = (results_df['sharpe_ratio'] > 1).mean()
    
    # Degradation ratio - so sánh window cuối với window đầu
    degradation = results_df['accuracy'].iloc[-3:].mean() / results_df['accuracy'].iloc[:3].mean()
    
    return {
        "regime_analysis": regime_analysis,
        "consistency_score": consistency,
        "degradation_ratio": degradation,
        "is_stable": consistency > 0.6 and degradation > 0.8
    }


Chạy evaluation

stability_report = evaluate_regime_stability(results_df)

print("="*60)
print("REGIME STABILITY REPORT")
print("="*60)
print("\nPerformance theo Market Regime:")
print(stability_report['regime_analysis'])
print(f"\nConsistency Score: {stability_report['consistency_score']:.2%}")
print(f"Degradation Ratio: {stability_report['degradation_ratio']:.2f}")
print(f"Model Stability: {'✅ STABLE' if stability_report['is_stable'] else '❌ UNSTABLE'}")


Visualization

fig, axes = plt.subplots(2, 2, figsize=(14, 10))


Plot 1: Accuracy over time

axes[0, 0].plot(results_df['window_id'], results_df['accuracy'], 'b-o', linewidth=2)
axes[0, 0].axhline(results_df['accuracy'].mean(), color='r', linestyle='--', label='Mean')
axes[0, 0].fill_between(results_df['window_id'], 
                        results_df['accuracy'].mean() - results_df['accuracy'].std(),
                        results_df['accuracy'].mean() + results_df['accuracy'].std(),
                        alpha=0.3)
axes[0, 0].set_title('Accuracy qua các Windows')
axes[0, 0].set_xlabel('Window ID')
axes[0, 0].set_ylabel('Accuracy')
axes[0, 0].legend()
axes[0, 0].grid(True, alpha=0.3)


Plot 2: Sharpe Ratio over time

axes[0, 1].plot(results_df['window_id'], results_df['sharpe_ratio'], 'g-o', linewidth=2)
axes[0, 1].axhline(1, color='r', linestyle='--', label='Sharpe=1 Threshold')
axes[0, 1].set_title('Sharpe Ratio qua các Windows')
axes[0, 1].set_xlabel('Window ID')
axes[0, 1].set_ylabel('Sharpe Ratio')
axes[0, 1].legend()
axes[0, 1].grid(True, alpha=0.3)


Plot 3: Cumulative Return

axes[1, 0].bar(results_df['window_id'], results_df['total_return'], 
               color=['green' if x > 0 else 'red' for x in results_df['total_return']])
axes[1, 0].set_title('Total Return từng Window')
axes[1, 0].set_xlabel('Window ID')
axes[1, 0].set_ylabel('Return')
axes[1, 0].grid(True, alpha=0.3)


Plot 4: Max Drawdown

axes[1, 1].bar(results_df['window_id'], results_df['max_drawdown'], color='orange')
axes[1, 1].set_title('Maximum Drawdown từng Window')
axes[1, 1].set_xlabel('Window ID')
axes[1, 1].set_ylabel('Max Drawdown')
axes[1, 1].grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('walkforward_analysis.png', dpi=150, bbox_inches='tight')
print("\n✅ Chart đã lưu: walkforward_analysis.png")

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

1. Lỗi "Look-ahead Bias" do Data Leakage

Mô tả: Khi train mô hình, bạn vô tình sử dụng features chứa thông tin từ tương lai (ví dụ: moving average dài hơn window test).

# ❌ SAI - Data leakage
data['ma_100'] = data['close'].rolling(100).mean()

Khi test trên window 3 tháng, MA_100 chứa thông tin từ >1 năm tương lai



✅ ĐÚNG - Chỉ dùng rolling stats trong training window

def create_features(df, lookback_periods):
    """Tạo features chỉ sử dụng dữ liệu trong window hiện tại"""
    features = {}
    for period in lookback_periods:
        features[f'ma_{period}'] = df['close'].rolling(period).mean()
        features[f'volatility_{period}'] = df['close'].rolling(period).std()
    return pd.DataFrame(features)


Luôn đảm bảo rolling window <= train_window // 2

MAX_LOOKBACK = train_window_days // 2
features = create_features(data, [5, 10, 20, MAX_LOOKBACK])

2. Lỗi "Overfitting quá mức" với Hyperparameters

Mô tả: Grid search hyperparameters trên toàn bộ dataset dẫn đến overfitting toàn cục.

# ❌ SAI - Tune trên tất cả data
param_grid = {'max_depth': [3, 5, 7, 10], 'n_estimators': [50, 100, 200]}
grid_search = GridSearchCV(model, param_grid, cv=5)
grid_search.fit(X_all, y_all)  # Data leak!


✅ ĐÚNG - Nested Walk-Forward

class NestedWFA:
    """Inner WFA để tune hyperparameters"""
    
    def __init__(self, train_window, test_window, step):
        self.train = train_window
        self.test = test_window
        self.step = step
        
    def nested_optimize(self, data, param_grid):
        best_params = []
        windows = create_windows(data, self.train, self.test, self.step)
        
        for train, test in windows:
            scores = []
            for params in ParameterGrid(param_grid):
                model = create_model(**params)
                model.fit(train[features], train[target])
                pred = model.predict(test[features])
                score = accuracy_score(test[target], pred)
                scores.append((score, params))
            
            # Chỉ lưu params tốt nhất của window đó
            best_params.append(max(scores, key=lambda x: x[0])[1])
        
        # Return most common params across windows
        return Counter([str(p) for p in best_params]).most_common(1)[0]

3. Lỗi "Window Size không phù hợp"

Mô tả: Train window quá nhỏ → mô hình underfitting; quá lớn → không phản ánh market regime thay đổi.

# ✅ TỰ ĐỘNG CHỌN OPTIMAL WINDOW SIZE
def find_optimal_window_sizes(data, min_window=63, max_window=504, step=21):
    """
    Tìm window size tối ưu dựa trên stability analysis
    """
    results = []
    
    for train_size in range(min_window, max_window + 1, step):
        for test_size in range(min(train_size // 4, 126), min(train_size // 2, 252), step):
            engine = WalkForwardEngine(train_window_days=train_size, 
                                       test_window_days=test_size,
                                       step_days=test_size)
            df = engine.run_analysis(data, features, target, create_model)
            agg = engine.get_aggregate_metrics()
            
            results.append({
                'train_size': train_size,
                'test_size': test_size,
                'mean_accuracy': agg['mean_accuracy'],
                'stability': agg['mean_accuracy'] / max(agg['std_accuracy'], 0.01),
                'consistency': agg['consistency_score']
            })
    
    results_df = pd.DataFrame(results)
    
    # Score = weighted combination
    results_df['score'] = (
        0.4 * results_df['mean_accuracy'] + 
        0.3 * results_df['stability'] + 
        0.3 * results_df['consistency']
    )
    
    optimal = results_df.loc[results_df['score'].idxmax()]
    print(f"Optimal: Train={optimal['train_size']}d, Test={optimal['test_size']}d")
    
    return int(optimal['train_size']), int(optimal['test_size'])

4. Lỗi "API Timeout" khi xử lý batch lớn

Mô tả: Gọi HolySheep AI API quá nhiều requests cùng lúc gây ra timeout.

import time
from concurrent.futures import ThreadPoolExecutor, as_completed
from ratelimit import limits, sleep_and_retry

class BatchAPIClient:
    """Client với rate limiting và retry logic"""
    
    def __init__(self, api_key, max_retries=3, rate_limit=60):
        self.client = HolySheepAIClient(api_key)
        self.max_retries = max_retries
        self.rate_limit = rate_limit
        self.call_count = 0
        
    @sleep_and_retry
    @limits(calls=60, period=60)  # 60 calls per minute
    def call_with_retry(self, data, model="deepseek-v3.2"):
        """Gọi API với retry logic tự động"""
        for attempt in range(self.max_retries):
            try:
                self.call_count += 1
                result = self.client.analyze_market_data(data, model)
                return result
            except requests.exceptions.Timeout:
                if attempt < self.max_retries - 1:
                    wait = 2 ** attempt  # Exponential backoff
                    print(f"Retry {attempt + 1} sau {wait}s...")
                    time.sleep(wait)
                else:
                    raise
                    
    def batch_analyze(self, data_list, max_workers=5):
        """Xử lý batch với concurrency"""
        results = []
        with ThreadPoolExecutor(max_workers=max_workers) as executor:
            futures = {
                executor.submit(self.call_with_retry, data): i 
                for i, data in enumerate(data_list)
            }
            
            for future in as_completed(futures):
                idx = futures[future]
                try:
                    result = future.result()
                    results.append((idx, result))
                except Exception as e:

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