Tương Quan Tín Hiệu: Cần Theo Dõi Bao Nhiêu Cặp Giao Dịch

Bạn khởi động một chiến lược trên 10 cặp crypto: BTC/USDT, ETH/USDT, SOL/USDT, AVAX/USDT và sáu altcoin khác. Logic có vẻ hoàn hảo: nếu chiến lược hoạt động 5% thời gian trên một cặp, thì với 10 cặp, ít nhất một cặp sẽ hoạt động $1 - 0.95^{10} = 40\%$ thời gian. Mức sử dụng tăng gấp bốn lần.

Trên thực tế, mức sử dụng chỉ đạt 15-16%, không phải 40%. Mười cặp của bạn hoạt động như 3 cặp. Vốn nằm chờ, fill_efficiency giảm, và lợi nhuận danh mục thực tế thấp hơn dự kiến ba lần.

Nguyên nhân là tương quan tín hiệu. Và trong thị trường tiền điện tử, mức độ này cực kỳ cao.

Ảo Tưởng Về Đa Dạng Hóa Trong Crypto

Trong tài chính truyền thống, đa dạng hóa có tác dụng vì cổ phiếu Apple và ETF dầu mỏ phản ứng với các yếu tố khác nhau. Trong thị trường tiền điện tử, mọi thứ lại khác.

BTC là yếu tố chi phối. Khi Bitcoin giảm 5%, ETH giảm 6-8%, SOL giảm 8-12%, altcoin giảm 10-20%. Tương quan lợi nhuận hàng ngày trong thị trường crypto liên tục trên 0.6, và trong thời điểm hoảng loạn tiệm cận 1.0.

Nhưng đối với chúng ta — các algo trader — điều quan trọng không phải là tương quan giá, mà là tương quan tín hiệu. Nếu chiến lược dựa trên momentum và BTC kích hoạt tín hiệu vào lệnh, thì xác suất cao là ETH và SOL cũng sẽ kích hoạt tín hiệu tương tự trong cùng phút đó. Tất cả các cặp vào long đồng thời, tất cả thoát đồng thời. Mười vị thế — nhưng thực chất chỉ là một cược.

Tại Sao 10 Cặp ≠ Đa Dạng Hóa Gấp 10 Lần

Phát Biểu Hình Thức

Giả sử một chiến lược trên mỗi trong số $N$ cặp hoạt động $p$ phần thời gian. Nếu các tín hiệu hoàn toàn độc lập, xác suất ít nhất một cặp đang hoạt động:

$P(\geq 1\ \text{active}) = 1 - (1 - p)^N$

Với Chiến lược B ($p = 0.05$, $N = 10$):

$P(\geq 1) = 1 - 0.95^{10} = 1 - 0.5987 \approx 40.1\%$

Nhưng các tín hiệu không độc lập. Các đồng tiền điện tử di chuyển đồng bộ — nghĩa là tín hiệu xuất hiện và tắt theo cụm.

Tương Quan Biến 10 Cặp Thành 3

Trực giác như sau: nếu 10 cặp có tương quan, chúng mang thông tin không phải từ 10 nguồn độc lập mà chỉ khoảng 3-4. Chúng ta hình thức hóa điều này qua effective_N:

$N_{eff} = \frac{N}{C_f}$

trong đó $C_f$ là hệ số tương quan, phản ánh tương quan tín hiệu theo từng cặp trung bình. Khi $C_f = 1$ các cặp hoàn toàn độc lập; khi $C_f = N$ chúng đồng nhất.

Với các cặp crypto, $C_f \approx 3$ là giá trị điển hình. Khi đó:

$N_{eff} = \frac{10}{3} \approx 3.3$

$P(\geq 1) = 1 - 0.95^{3.3} \approx 1 - 0.844 = 15.6\%$

Không phải 40%, mà là 15.6%. Chênh lệch 2.5 lần. Fill efficiency giảm tương ứng, kéo theo lợi nhuận thực tế của toàn bộ danh mục (xem PnL per Active Time).

Tương Quan Trong Thị Trường Crypto

BTC Là Yếu Tố Chi Phối

Thị trường crypto có cấu trúc nhân tố rõ rệt. BTC giải thích 60-80% phương sai lợi nhuận hàng ngày của hầu hết các altcoin. Điều này thể hiện rõ qua PCA (Phân Tích Thành Phần Chính):

import numpy as np
from sklearn.decomposition import PCA

def analyze_crypto_factor_structure(returns_matrix: np.ndarray, pair_names: list) -> dict:
    """
    Phân tích PCA về cấu trúc nhân tố của lợi nhuận crypto.

    Args:
        returns_matrix: ma trận lợi nhuận [n_days x n_pairs]
        pair_names: danh sách tên cặp giao dịch
    """
    pca = PCA()
    pca.fit(returns_matrix)

    explained = pca.explained_variance_ratio_
    cumulative = np.cumsum(explained)

    print("Cấu trúc nhân tố:")
    for i, (var, cum) in enumerate(zip(explained[:5], cumulative[:5])):
        print(f"  PC{i+1}: {var:.1%} phương sai (tích lũy: {cum:.1%})")

    loadings = pca.components_[0]
    print("\nHệ số tải PC1 (nhân tố BTC):")
    for name, load in sorted(zip(pair_names, loadings), key=lambda x: -abs(x[1])):
        print(f"  {name}: {load:.3f}")

    return {
        "explained_variance": explained,
        "n_effective_factors": int(np.searchsorted(cumulative, 0.90)) + 1,
        "pc1_loadings": dict(zip(pair_names, loadings)),
    }

Kết quả điển hình cho danh mục 10 cặp crypto:

Bốn nhân tố giải thích 90% phương sai. Trong 10 cặp, không quá 4 cặp là "độc lập."

Tương Quan Tín Hiệu vs. Tương Quan Giá

Đây là một điểm quan trọng. Tương quan giá và tương quan tín hiệu là hai thứ khác nhau. Giá BTC và ETH tương quan ở mức 0.85, nhưng tín hiệu của một chiến lược cụ thể có thể tương quan ở mức 0.95 hoặc 0.50 — tùy thuộc vào logic vào lệnh.

Ví dụ: chiến lược RSI quá mua/quá bán. RSI trên BTC vượt qua 30 (quá bán) — vào long. ETH ở cùng thời điểm cũng có thể bị quá bán (tương quan tín hiệu ~0.90). Hoặc không, nếu ETH giảm chậm hơn (tương quan tín hiệu ~0.40).

Cách tiếp cận đúng là đo tương quan của tín hiệu cụ thể, không phải chuỗi giá:

import numpy as np
from itertools import combinations

def signal_correlation_matrix(
    signals: dict,  # {pair: np.array of 0/1 per minute}
    method: str = "pearson",
) -> np.ndarray:
    """
    Tính ma trận tương quan tín hiệu (nhị phân: 0 = không có vị thế, 1 = đang có vị thế).

    Args:
        signals: từ điển {pair_name: binary_signal_array}
        method: phương pháp tương quan ("pearson", "jaccard")
    """
    pairs = sorted(signals.keys())
    n = len(pairs)
    corr_matrix = np.ones((n, n))

    for i, j in combinations(range(n), 2):
        s_i = signals[pairs[i]]
        s_j = signals[pairs[j]]

        if method == "pearson":
            corr = np.corrcoef(s_i, s_j)[0, 1]
        elif method == "jaccard":
            intersection = np.sum(s_i & s_j)
            union = np.sum(s_i | s_j)
            corr = intersection / union if union > 0 else 0
        else:
            raise ValueError(f"Phương pháp không xác định: {method}")

        corr_matrix[i, j] = corr
        corr_matrix[j, i] = corr

    return corr_matrix, pairs


def estimate_correlation_factor(corr_matrix: np.ndarray) -> float:
    """
    Ước tính correlation_factor từ ma trận tương quan tín hiệu.

    correlation_factor = 1 + (N-1) * mean_pairwise_correlation

    Khi tương quan = 0 → C_f = 1 (tất cả độc lập).
    Khi tương quan = 1 → C_f = N (tất cả đồng nhất).
    """
    n = corr_matrix.shape[0]
    upper_triangle = corr_matrix[np.triu_indices(n, k=1)]
    mean_corr = np.mean(upper_triangle)

    correlation_factor = 1 + (n - 1) * mean_corr
    return correlation_factor

Tương Quan Theo Thời Gian: Bình Thường vs. Hoảng Loạn

Tương quan không tĩnh. Trong giai đoạn bình thường, BTC và các altcoin có thể phân kỳ — ETH tăng theo tin tức Ethereum, SOL theo tin tức Solana. Trong khủng hoảng, tất cả co lại thành một nhân tố duy nhất: risk-on/risk-off.

def rolling_correlation_factor(
    signals: dict,
    window_days: int = 30,
    step_days: int = 7,
) -> list:
    """
    Correlation_factor cuộn để phát hiện thay đổi chế độ.
    """
    pairs = sorted(signals.keys())
    minutes_per_day = 1440
    window = window_days * minutes_per_day
    step = step_days * minutes_per_day

    total_minutes = len(signals[pairs[0]])
    results = []

    for start in range(0, total_minutes - window, step):
        end = start + window
        window_signals = {p: signals[p][start:end] for p in pairs}

        corr_matrix, _ = signal_correlation_matrix(window_signals)
        cf = estimate_correlation_factor(corr_matrix)

        results.append({
            "start_minute": start,
            "end_minute": end,
            "correlation_factor": cf,
            "effective_n": len(pairs) / cf,
        })

    return results

Bức tranh điển hình cho 10 cặp crypto:

Trong hoảng loạn, 10 cặp co lại còn 1-2 cặp hiệu quả. Chính xác khi đa dạng hóa cần thiết nhất thì nó biến mất. Đây là phiên bản crypto của quy luật kinh điển "tương quan tiến về 1 trong khủng hoảng."

effective_N: Khái Niệm Chủ Chốt

Công Thức và Suy Luận

Ý tưởng về effective_N được mượn từ thống kê, nơi kích thước mẫu hiệu quả tính đến tự tương quan của các quan sát. Với mục đích của chúng ta:

$N_{eff} = \frac{N}{1 + (N - 1) \cdot \bar{\rho}}$

trong đó $\bar{\rho}$ là tương quan tín hiệu theo từng cặp trung bình. Ký hiệu rút gọn:

$N_{eff} = \frac{N}{C_f}, \quad C_f = 1 + (N - 1) \cdot \bar{\rho}$

Tính chất:

• Khi $\bar{\rho} = 0$: $C_f = 1$, $N_{eff} = N$ — độc lập hoàn toàn
• Khi $\bar{\rho} = 1$: $C_f = N$, $N_{eff} = 1$ — tất cả các cặp đồng nhất
• Khi $\bar{\rho} = 0.25$ và $N = 10$: $C_f = 3.25$, $N_{eff} = 3.08$

Cách Ước Tính correlation_factor Từ Dữ Liệu

Trên thực tế, có ba cách tiếp cận:

1. Từ ma trận tương quan tín hiệu (chính xác).

Chạy chiến lược trên tất cả các cặp, thu được tín hiệu nhị phân (0/1 cho mỗi phút), xây dựng ma trận tương quan, tính $C_f$ theo công thức trên.

2. Từ PCA của lợi nhuận giá (xấp xỉ).

Nếu tín hiệu phụ thuộc nhiều vào động lực giá (momentum, mean-reversion), bạn có thể ước tính $N_{eff}$ là số thành phần PCA giải thích 90% phương sai.

3. Từ heuristic theo loại tài sản (thô).

Với danh mục crypto gồm BTC, ETH, SOL, AVAX, MATIC, DOGE, DOT, LINK, UNI, ATOM, ước tính an toàn là $C_f \approx 3$.

Mô Hình Hóa Mức Sử Dụng Slot

Công Thức cho $P(\geq 1\ \text{active})$

Công thức cơ bản tính đến tương quan:

$P(\geq 1\ \text{active}) = 1 - (1 - p)^{N_{eff}}$

Bảng cho các chiến lược và số cặp khác nhau ($C_f = 3$):

Với Chiến lược B có hoạt động 5%, bạn cần 50 cặp chỉ để có ít nhất một vị thế hoạt động một nửa thời gian. Và điều đó chưa tính đến việc 50 cặp crypto có tương quan mạnh hơn so với 10 cặp.

Orchestrator Đa Slot

Một orchestrator thực tế quản lý nhiều slot đồng thời. Nếu bạn có 5 slot và 10 cặp, mức sử dụng được tính khác đi:

$\text{utilization} = \frac{\min(E[\text{active}], \text{max\_slots})}{\text{max\_slots}}$

$E[\text{active}] = N_{eff} \cdot p$

def estimate_fill_efficiency(
    trading_time_pct: float,
    n_pairs: int,
    correlation_factor: float = 3.0,
    max_slots: int = 1,
) -> dict:
    """
    Ước tính phân tích fill efficiency cho orchestrator đa slot.

    Args:
        trading_time_pct: tỷ lệ thời gian hoạt động của một chiến lược trên một cặp
        n_pairs: số cặp giao dịch
        correlation_factor: hệ số tương quan tín hiệu
        max_slots: số lượng vị thế đồng thời tối đa

    Returns:
        dict với các chỉ số mức sử dụng
    """
    effective_n = n_pairs / correlation_factor

    p_at_least_one = 1 - (1 - trading_time_pct) ** effective_n

    expected_active = effective_n * trading_time_pct

    utilization = min(expected_active, max_slots) / max_slots

    fill_efficiency = min(p_at_least_one, utilization)

    return {
        "effective_n": effective_n,
        "p_at_least_one": p_at_least_one,
        "expected_active": expected_active,
        "utilization": utilization,
        "fill_efficiency": fill_efficiency,
    }


configs = [
    ("Strategy B, 10 pairs, 1 slot", 0.05, 10, 3.0, 1),
    ("Strategy B, 10 pairs, 3 slots", 0.05, 10, 3.0, 3),
    ("Strategy B, 30 pairs, 1 slot", 0.05, 30, 3.0, 1),
    ("Strategy A, 10 pairs, 1 slot", 0.15, 10, 3.0, 1),
    ("Strategy C, 10 pairs, 1 slot", 0.45, 10, 3.0, 1),
    ("Strategy C, 10 pairs, 5 slots", 0.45, 10, 3.0, 5),
]

for name, p, n, cf, slots in configs:
    result = estimate_fill_efficiency(p, n, cf, slots)
    print(f"{name}:")
    print(f"  N_eff = {result['effective_n']:.1f}")
    print(f"  P(≥1 active) = {result['p_at_least_one']:.1%}")
    print(f"  E[active] = {result['expected_active']:.2f}")
    print(f"  fill_efficiency = {result['fill_efficiency']:.1%}")
    print()

Kết quả dự kiến:

Strategy B, 10 pairs, 1 slot:
  N_eff = 3.3
  P(≥1 active) = 15.6%
  E[active] = 0.17
  fill_efficiency = 15.6%

Strategy B, 10 pairs, 3 slots:
  N_eff = 3.3
  P(≥1 active) = 15.6%
  E[active] = 0.17
  fill_efficiency = 5.6%

Strategy B, 30 pairs, 1 slot:
  N_eff = 10.0
  P(≥1 active) = 40.1%
  E[active] = 0.50
  fill_efficiency = 40.1%

Strategy A, 10 pairs, 1 slot:
  N_eff = 3.3
  P(≥1 active) = 41.8%
  E[active] = 0.50
  fill_efficiency = 41.8%

Strategy C, 10 pairs, 1 slot:
  N_eff = 3.3
  P(≥1 active) = 89.0%
  E[active] = 1.50
  fill_efficiency = 89.0%

Strategy C, 10 pairs, 5 slots:
  N_eff = 3.3
  P(≥1 active) = 89.0%
  E[active] = 1.50
  fill_efficiency = 30.0%

Lưu ý: Chiến lược B với 3 slot và 10 cặp cho fill_efficiency 5.6%. Ba slot hoàn toàn vô nghĩa khi số cặp hoạt động dự kiến chỉ là 0.17. Slot nên được phân bổ tương xứng với tải dự kiến.

Mô Phỏng Từ Dữ Liệu Thực

Mô hình phân tích chỉ là xấp xỉ. Để ước tính chính xác, bạn cần mô phỏng trên tín hiệu thực:

import numpy as np

def simulate_fill_efficiency(
    all_signals: dict,       # {(strategy, pair): [(entry_min, exit_min), ...]}
    max_slots: int = 10,
    test_period_minutes: int = 750 * 24 * 60,  # 750 ngày
    priority_fn=None,        # hàm ưu tiên để chọn vị thế
) -> dict:
    """
    Mô phỏng tải slot thực của orchestrator.

    Với mỗi phút: đếm có bao nhiêu cặp muốn vào lệnh,
    và có bao nhiêu slot thực sự được chiếm (tính đến giới hạn).

    Args:
        all_signals: tín hiệu theo cặp và chiến lược
        max_slots: số lượng vị thế đồng thời tối đa
        test_period_minutes: độ dài khoảng kiểm tra tính bằng phút
        priority_fn: nếu None — FIFO; ngược lại — hàm xếp hạng
    """
    demand_timeline = np.zeros(test_period_minutes, dtype=np.int32)
    capped_timeline = np.zeros(test_period_minutes, dtype=np.int32)

    for signals in all_signals.values():
        for entry_min, exit_min in signals:
            if entry_min < test_period_minutes:
                end = min(exit_min, test_period_minutes)
                demand_timeline[entry_min:end] += 1

    capped_timeline = np.minimum(demand_timeline, max_slots)

    total_demand = np.sum(demand_timeline)
    total_filled = np.sum(capped_timeline)
    time_with_any_active = np.sum(demand_timeline > 0)

    fill_efficiency = np.mean(capped_timeline) / max_slots
    demand_fill_ratio = total_filled / total_demand if total_demand > 0 else 0
    time_utilization = time_with_any_active / test_period_minutes

    slot_distribution = {}
    for s in range(max_slots + 1):
        slot_distribution[s] = np.mean(capped_timeline == s)

    return {
        "fill_efficiency": fill_efficiency,
        "demand_fill_ratio": demand_fill_ratio,
        "time_utilization": time_utilization,
        "avg_demand": np.mean(demand_timeline),
        "avg_filled": np.mean(capped_timeline),
        "slot_distribution": slot_distribution,
        "overflow_pct": np.mean(demand_timeline > max_slots),
    }

Mô phỏng trên dữ liệu thực thường cho mức sử dụng thậm chí còn thấp hơn ước tính phân tích, vì nó tính đến sự phân cụm tín hiệu theo thời gian: tất cả các cặp vào đồng thời tạo ra overflow, rồi tất cả im lặng tạo ra khoảng trống.

Cần Theo Dõi Bao Nhiêu Cặp? Phân Tích Lợi Nhuận Giảm Dần

Câu hỏi then chốt: ở $N$ nào thì việc thêm một cặp mới không còn tăng đáng kể fill_efficiency?

import numpy as np

def diminishing_returns_analysis(
    trading_time_pct: float,
    correlation_factor: float = 3.0,
    max_pairs: int = 100,
    target_utilization: float = 0.80,
) -> dict:
    """
    Phân tích lợi nhuận giảm dần khi thêm các cặp mới.
    """
    results = []
    target_n = None

    for n in range(1, max_pairs + 1):
        n_eff = n / correlation_factor
        p_active = 1 - (1 - trading_time_pct) ** n_eff
        marginal = 0
        if n > 1:
            prev_eff = (n - 1) / correlation_factor
            prev_p = 1 - (1 - trading_time_pct) ** prev_eff
            marginal = p_active - prev_p

        results.append({
            "n_pairs": n,
            "n_effective": n_eff,
            "p_at_least_one": p_active,
            "marginal_gain": marginal,
        })

        if target_n is None and p_active >= target_utilization:
            target_n = n

    return {
        "results": results,
        "target_n_for_utilization": target_n,
    }


analysis_b = diminishing_returns_analysis(0.05, correlation_factor=3.0, target_utilization=0.80)
print(f"Chiến lược B: cần {analysis_b['target_n_for_utilization']} cặp để đạt 80% P(≥1)")

for r in analysis_b["results"]:
    if r["n_pairs"] in [1, 3, 5, 10, 20, 30, 50, 80]:
        print(f"  N={r['n_pairs']:3d}: N_eff={r['n_effective']:.1f}, "
              f"P(≥1)={r['p_at_least_one']:.1%}, "
              f"marginal={r['marginal_gain']:.2%}")

Kết quả cho Chiến lược B ($p = 0.05$, $C_f = 3$):

Với Chiến lược B, đạt 80% mức sử dụng một slot là không thể ngay cả với 100 cặp (cần ~96 cặp). Đây là giới hạn cơ bản: một chiến lược với thời gian giao dịch 5% không phù hợp để vận hành một slot — nó cần cách tiếp cận danh mục với nhiều chiến lược.

Với Chiến lược A ($p = 0.15$, $C_f = 3$):

Chiến lược A đạt 80% mức sử dụng ở ~30 cặp. Lợi nhuận biên ở cặp thứ 30 chỉ là +1.2%.

Với Chiến lược C ($p = 0.45$, $C_f = 3$):

Chiến lược C với 45% thời gian giao dịch đạt 90% mức sử dụng chỉ với 10 cặp. Thêm nhiều hơn là vô nghĩa.

Suy Giảm Lợi Thế Qua Các Cặp Giao Dịch

Còn một yếu tố khác giới hạn số cặp: suy giảm lợi thế. Một chiến lược được phát triển và tối ưu hóa trên BTC/USDT có thể hoạt động kém hơn trên các altcoin ít thanh khoản hơn.

Nguyên nhân suy giảm:

• Thanh khoản: slippage trên DOGE/USDT cao hơn nhiều lần so với BTC/USDT
• Spread: các cặp ít thanh khoản hơn có spread bid-ask rộng hơn
• Vi cấu trúc: các mẫu sổ lệnh khác nhau giữa các cặp
• Thao túng: altcoin ít thanh khoản dễ bị pump-and-dump

def edge_decay_analysis(
    strategy_results: dict,  # {pair: {"pnl_per_day": float, "n_trades": int}}
    min_trades: int = 30,
) -> list:
    """
    Xếp hạng các cặp theo lợi thế tính đến suy giảm.
    """
    ranked = []
    for pair, metrics in strategy_results.items():
        if metrics["n_trades"] < min_trades:
            continue
        ranked.append({
            "pair": pair,
            "pnl_per_day": metrics["pnl_per_day"],
            "n_trades": metrics["n_trades"],
            "sharpe": metrics.get("sharpe", 0),
        })

    ranked.sort(key=lambda x: x["pnl_per_day"], reverse=True)

    cumulative_pnl = []
    running_sum = 0
    for i, r in enumerate(ranked):
        running_sum += r["pnl_per_day"]
        avg = running_sum / (i + 1)
        cumulative_pnl.append({
            "n_pairs": i + 1,
            "last_added": r["pair"],
            "last_pnl_per_day": r["pnl_per_day"],
            "avg_pnl_per_day": avg,
        })

    return cumulative_pnl

Bức tranh điển hình:

Thêm cặp thứ 10 làm giảm PnL/ngày trung bình của danh mục. Đến cặp thứ 8, lợi thế đã giảm còn một nửa so với cặp tốt nhất. Cần cân bằng giữa fill_efficiency (tăng theo số cặp) và lợi thế trung bình (giảm).

Số Cặp Tối Ưu: Mô Hình Thống Nhất

Chúng ta kết hợp fill_efficiency và suy giảm lợi thế thành một chỉ số duy nhất — PnL danh mục dự kiến mỗi ngày:

$\text{Portfolio PnL/day} = \text{avg\_edge}(N) \times \text{fill\_efficiency}(N) \times 365$

def optimal_pairs_count(
    pair_edges: list,           # PnL/ngày theo thứ tự giảm dần: [0.89, 0.82, 0.71, ...]
    trading_time_pct: float,
    correlation_factor: float = 3.0,
    max_slots: int = 1,
) -> dict:
    """
    Tìm số cặp tối ưu để tối đa hóa PnL danh mục.
    """
    best_n = 0
    best_score = 0
    results = []

    for n in range(1, len(pair_edges) + 1):
        avg_edge = np.mean(pair_edges[:n])

        n_eff = n / correlation_factor
        p_active = 1 - (1 - trading_time_pct) ** n_eff
        expected_active = n_eff * trading_time_pct
        utilization = min(expected_active, max_slots) / max_slots
        fill_eff = min(p_active, utilization)

        portfolio_score = avg_edge * fill_eff * 365

        results.append({
            "n_pairs": n,
            "avg_edge": avg_edge,
            "fill_efficiency": fill_eff,
            "portfolio_annualized": portfolio_score,
        })

        if portfolio_score > best_score:
            best_score = portfolio_score
            best_n = n

    return {
        "optimal_n": best_n,
        "optimal_score": best_score,
        "results": results,
    }


edges = [0.89, 0.82, 0.71, 0.65, 0.55, 0.48, 0.40, 0.31, 0.22, 0.12,
         0.08, 0.05, 0.02, -0.01, -0.05]

opt = optimal_pairs_count(edges, trading_time_pct=0.15, correlation_factor=3.0)
print(f"Số cặp tối ưu: {opt['optimal_n']}")
print(f"Danh mục hàng năm: {opt['optimal_score']:.1f}%")

for r in opt["results"]:
    print(f"  N={r['n_pairs']:2d}: avg_edge={r['avg_edge']:.2f}%, "
          f"fill_eff={r['fill_efficiency']:.1%}, "
          f"portfolio={r['portfolio_annualized']:.1f}%")

Điểm tối ưu thường nằm ở chỗ fill_efficiency biên từ việc thêm một cặp không còn bù đắp cho sự sụt giảm lợi thế trung bình. Với danh mục crypto điển hình:

• Chiến lược B (5% thời gian): tối ưu ở 8-12 cặp
• Chiến lược A (15% thời gian): tối ưu ở 6-10 cặp
• Chiến lược C (45% thời gian): tối ưu ở 4-6 cặp

Một nghịch lý: chiến lược có thời gian giao dịch thấp nhất lại hưởng lợi từ nhiều cặp nhất, nhưng fill_efficiency vẫn thấp. Giải pháp không phải là thêm nhiều cặp, mà là kết hợp với các chiến lược khác (xem Combo Strategies).

Đa Dạng Hóa Xuyên Cặp: Chiến Lược Giảm Tương Quan

Nếu bạn không thể tăng số cặp vô hạn, bạn có thể giảm $C_f$ — tức là tăng sự đa dạng tín hiệu.

Chiến Lược 1: Kết Hợp Token Thanh Khoản Cao và DeFi

BTC, ETH, BNB có tương quan rất mạnh. Nhưng UNI (DEX), AAVE (cho vay), CRV (stablecoin) có thể có động lực riêng. Thêm token DeFi giảm $\bar{\rho}$ trung bình từ 0.35 xuống 0.20-0.25:

$C_f = 1 + 9 \times 0.20 = 2.8 \quad \text{(so với 3.25 khi } \bar{\rho} = 0.25\text{)}$

Chiến Lược 2: Nhiều Chiến Lược Khác Nhau Trên Cùng Cặp

Thay vì 10 cặp với một chiến lược — 5 cặp với hai chiến lược khác nhau. Nếu các chiến lược dựa trên nguyên tắc khác nhau (momentum vs. mean-reversion), tín hiệu của chúng có thể tương quan âm:

• Momentum vào long khi giá tăng
• Mean-reversion vào long khi giá giảm

$\bar{\rho}_{\text{cross-strategy}} < 0 \implies C_f < 1 \implies N_{eff} > N$

Đây là cách duy nhất để đạt $N_{eff} > N$ — sử dụng các chiến lược có tương quan tín hiệu âm.

Chiến Lược 3: Spot vs. Futures

Kinh doanh chênh lệch tỷ lệ funding và giao dịch spot có cấu trúc tương quan khác nhau. Thêm chiến lược kinh doanh chênh lệch vào danh mục giảm đáng kể $C_f$ tổng thể, vì kinh doanh chênh lệch theo định nghĩa khai thác sự phân kỳ, không phải hội tụ.

Khuyến Nghị Thực Tế Theo Loại Chiến Lược

Chiến Lược Tần Suất Cao, Thời Gian Thấp (thời gian giao dịch < 10%)

Đại diện điển hình: Chiến lược B (5% thời gian, 38 giao dịch trong 750 ngày).

• Số cặp: 10-15 (tối ưu cân bằng lợi thế/fill)
• Vấn đề: fill_efficiency thấp ngay cả với 15 cặp (~20-25%)
• Giải pháp: bắt buộc kết hợp với các chiến lược khác trong orchestrator
• $C_f$ cho crypto: 2.5-3.5
• Theo dõi: $C_f$ cuộn để thích nghi số cặp với chế độ thị trường

Chiến Lược Thời Gian Trung Bình (thời gian giao dịch 10-30%)

Đại diện điển hình: Chiến lược A (15% thời gian, 418 giao dịch trong 750 ngày).

• Số cặp: 6-10
• Fill_efficiency ở 10 cặp: ~40%
• Giải pháp: kết hợp 2-3 chiến lược như vậy lấp đầy 80%+ thời gian
• $C_f$ cho crypto: 2.5-3.5
• Tập trung: chọn cặp có lợi thế tối đa, đừng chạy theo số lượng

Chiến Lược Thời Gian Cao (thời gian giao dịch > 30%)

Đại diện điển hình: Chiến lược C (45% thời gian).

• Số cặp: 4-6
• Fill_efficiency ở 6 cặp: ~80%
• Vấn đề: overflow — nhiều cặp hoạt động đồng thời nhưng ít slot hơn
• Giải pháp: tăng max_slots hoặc thêm ưu tiên cặp
• $C_f$ cho crypto: 2.5-4.0 (cao hơn do các vị thế dài chồng chéo trong khủng hoảng)

Bảng Tóm Tắt

Kết Nối Với Các Chỉ Số Khác Trong Chuỗi

Bài viết này là bài thứ mười một trong chuỗi "Backtest Không Ảo Tưởng". Tương quan tín hiệu ảnh hưởng trực tiếp đến các chỉ số từ các bài trước:

• PnL per Active Time: fill_efficiency là hệ số nhân then chốt trong công thức lợi nhuận thực tế. Nếu bạn đánh giá quá cao fill_efficiency khi bỏ qua tương quan, dự báo PnL danh mục của bạn sẽ quá lạc quan.

• Tỷ lệ funding: với tương quan cao, các vị thế mở đồng thời — và chi phí funding tăng tuyến tính theo số slot. Overflow + funding = đốt vốn nhanh.

• Kinh doanh chênh lệch tỷ lệ funding: các chiến lược kinh doanh chênh lệch là chất đa dạng hóa tự nhiên làm giảm $C_f$ của danh mục. Tín hiệu của chúng tương quan yếu với các chiến lược momentum và mean-reversion.

• Combo strategies (bài tiếp theo): cách xây dựng danh mục chiến lược với các $p$ và $C_f$ khác nhau để đạt 90%+ mức sử dụng. Điều phối cascade tính đến tương quan tín hiệu khi phân công ưu tiên.

Kết Luận

Đa dạng hóa trong crypto không phải là về số cặp. 10 cặp có tương quan cho hiệu quả của 3-4 cặp độc lập. Trong hoảng loạn, còn ít hơn.

Bốn điểm rút ra:

1. Tính effective_N, không phải N. Với các cặp crypto $C_f \approx 3$. Mười cặp tương đương ~3.3 cặp hiệu quả. Lập kế hoạch fill_efficiency dựa trên $N_{eff}$, không phải $N$.

2. Đo tương quan tín hiệu, không phải tương quan giá. Tương quan giá là proxy, không phải thay thế. Chạy chiến lược trên tất cả các cặp và tính ma trận tương quan tín hiệu nhị phân.

3. Tính đến suy giảm lợi thế. Nhiều cặp hơn đồng nghĩa với PnL/ngày trung bình thấp hơn. Điểm tối ưu nằm ở chỗ fill_efficiency biên từ cặp mới vẫn còn bù đắp cho sự sụt giảm lợi thế.

4. Giảm $C_f$, đừng tăng $N$. Kết hợp các chiến lược khác nhau trên cùng cặp hiệu quả hơn là một chiến lược trên nhiều cặp hơn. Đa dạng hóa xuyên chiến lược có thể cho $N_{eff} > N$.

Hệ số tương quan là biến ẩn quyết định mức độ thực tế của dự báo mức sử dụng và lợi nhuận. Bỏ qua nó nghĩa là xây dựng danh mục trên ảo tưởng.

Liên Kết Hữu Ích

1. Markowitz, H. — Portfolio Selection (1952)
2. López de Prado — Advances in Financial Machine Learning: Denoising and Detoning
3. Ledoit, O. & Wolf, M. — Honey, I Shrunk the Sample Covariance Matrix (2004)
4. Laloux, L. et al. — Noise Dressing of Financial Correlation Matrices (1999)
5. Cont, R. — Empirical Properties of Asset Returns: Stylized Facts and Statistical Issues
6. Ernest Chan — Algorithmic Trading: Portfolio Construction and Risk Management
7. Rebonato, R. & Jäckel, P. — The Most General Methodology for Creating a Valid Correlation Matrix

Trích Dẫn

@article{soloviov2026signalcorrelation,
  author = {Soloviov, Eugen},
  title = {Signal Correlation: How Many Pairs to Monitor},
  year = {2026},
  url = {https://marketmaker.cc/vi/blog/post/signal-correlation-pairs},
  version = {0.1.0},
  description = {Tại sao 10 cặp crypto không mang lại đa dạng hóa gấp 10 lần, cách tính effective\_N qua correlation\_factor, và bạn thực sự cần theo dõi bao nhiêu cặp để đạt 80-90\% mức sử dụng slot của orchestrator.}
}