訊號相關性：需要監控多少個交易對

你在10個加密貨幣交易對上啟動策略：BTC/USDT、ETH/USDT、SOL/USDT、AVAX/USDT，再加上另外六個山寨幣。邏輯看似無懈可擊：如果策略在單個交易對上5%的時間處於活躍狀態，那麼在10個交易對上，至少有一個應該在 $1 - 0.95^{10} = 40\%$ 的時間內處於活躍狀態。利用率提高四倍。

實際上，利用率僅為15-16%，而非40%。你的10個交易對錶現得如同3個。資金閒置，fill_efficiency下降，投資組合的有效收益率比預期低三倍。

原因在於訊號相關性。而在加密貨幣中，它高得驚人。

加密貨幣中分散化的幻覺

在傳統金融中，分散化之所以有效，是因為蘋果股票和石油ETF對不同因素做出反應。在加密貨幣市場中，一切都不同。

BTC是主導因素。當比特幣下跌5%時，ETH下跌6-8%，SOL下跌8-12%，山寨幣下跌10-20%。加密貨幣市場的日收益率相關性持續高於0.6，在恐慌時期接近1.0。

但對於我們——演算法交易者——來說，重要的不是價格相關性，而是訊號相關性。如果策略基於動量，並且BTC觸發了入場訊號，ETH和SOL很可能在同一分鐘內觸發類似訊號。所有交易對同時做多，同時退出。十個倉位——但本質上只是一次押注。

為什麼10個交易對 ≠ 10倍分散化

形式化描述

假設策略在 $N$ 個交易對中的每一個上，有 $p$ 比例的時間處於活躍狀態。如果訊號完全獨立，至少有一個交易對活躍的機率為：

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

對於策略B（$p = 0.05$，$N = 10$）：

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

但訊號並非獨立的。加密貨幣同步運動——這意味著訊號以叢集的形式出現和消失。

相關性將10個交易對變為3個

直覺是這樣的：如果10個交易對是相關的，它們攜帶的資訊不是來自10個獨立來源，而是大約3-4個。我們通過effective_N來形式化：

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

其中 $C_f$ 是相關因子，反映了訊號的平均成對相關性。當 $C_f = 1$ 時，交易對完全獨立；當 $C_f = N$ 時，它們完全相同。

對於加密貨幣交易對，典型的 $C_f \approx 3$。則：

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

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

不是40%，而是15.6%。相差2.5倍。Fill efficiency相應下降，整個投資組合的有效收益率也隨之下降（參見按活躍時間計算的PnL）。

加密貨幣市場中的相關性

BTC作為主導因素

加密貨幣市場具有明顯的因子結構。BTC解釋了大多數山寨幣日收益率60-80%的方差。這通過PCA（主成分分析）可以清楚地看到：

import numpy as np
from sklearn.decomposition import PCA

def analyze_crypto_factor_structure(returns_matrix: np.ndarray, pair_names: list) -> dict:
    """
    加密货币收益率因子结构的PCA分析。

    Args:
        returns_matrix: 收益率矩阵 [n_days x n_pairs]
        pair_names: 交易对名称列表
    """
    pca = PCA()
    pca.fit(returns_matrix)

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

    print("Factor structure:")
    for i, (var, cum) in enumerate(zip(explained[:5], cumulative[:5])):
        print(f"  PC{i+1}: {var:.1%} variance (cumulative: {cum:.1%})")

    loadings = pca.components_[0]
    print("\nPC1 loadings (BTC factor):")
    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)),
    }

10個加密貨幣交易對投資組合的典型結果：

四個因子解釋了90%的方差。10個交易對中，"獨立"的不超過4個。

訊號相關性 vs. 價格相關性

這裡有一個重要的細微差別。價格相關性和訊號相關性是不同的概念。BTC和ETH的價格相關性為0.85，但特定策略的訊號相關性可能是0.95或0.50——取決於入場邏輯。

示例：基於RSI超買/超賣的策略。BTC上的RSI穿過30（超賣）——做多入場。同一時刻ETH也可能處於超賣狀態（訊號相關性0.90）。也可能不是，如果ETH下跌更慢（訊號相關性0.40）。

正確的方法是測量訊號本身的相關性，而不是價格序列：

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:
    """
    计算信号相关矩阵（二值：0 = 无仓位，1 = 有仓位）。

    Args:
        signals: 字典 {pair_name: binary_signal_array}
        method: 相关性方法 ("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"Unknown method: {method}")

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

    return corr_matrix, pairs


def estimate_correlation_factor(corr_matrix: np.ndarray) -> float:
    """
    从信号相关矩阵估算correlation_factor。

    correlation_factor = 1 + (N-1) * mean_pairwise_correlation

    当相关性为0 → C_f = 1（全部独立）。
    当相关性为1 → C_f = N（全部相同）。
    """
    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

時間相關性：平靜期 vs. 恐慌期

相關性不是靜態的。在平靜時期，BTC和山寨幣可能會分化——ETH因以太坊新聞上漲，SOL因Solana新聞上漲。在危機中，一切坍縮為一個因子：風險偏好/風險規避。

def rolling_correlation_factor(
    signals: dict,
    window_days: int = 30,
    step_days: int = 7,
) -> list:
    """
    滚动correlation_factor，用于检测市场状态变化。
    """
    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

10個加密貨幣交易對的典型情況：

恐慌期間，10個交易對壓縮至1-2個有效交易對。恰恰在最需要分散化的時候，它消失了。這是經典"危機中相關性趨向1"的加密貨幣版本。

effective_N：核心概念

公式與推導

effective_N的概念借鑑自統計學中的有效樣本量，後者考慮了觀測值的自相關性。對於我們的目的：

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

其中 $\bar{\rho}$ 是訊號的平均成對相關性。簡化表示：

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

性質：

• 當 $\bar{\rho} = 0$ 時：$C_f = 1$，$N_{eff} = N$ — 完全獨立
• 當 $\bar{\rho} = 1$ 時：$C_f = N$，$N_{eff} = 1$ — 所有交易對相同
• 當 $\bar{\rho} = 0.25$ 且 $N = 10$ 時：$C_f = 3.25$，$N_{eff} = 3.08$

如何從資料中估算correlation_factor

實際中有三種方法：

1. 從訊號相關矩陣（精確）。

在所有交易對上執行策略，獲得二值訊號（每分鐘0/1），構建相關矩陣，使用上述公式計算 $C_f$。

2. 從價格收益率的PCA（近似）。

如果訊號強烈依賴於價格動態（動量、均值迴歸），可以將 $N_{eff}$ 估算為解釋90%方差的PCA成分數量。

3. 從資產類別啟發式（粗略）。

對於包含BTC、ETH、SOL、AVAX、MATIC、DOGE、DOT、LINK、UNI、ATOM的加密貨幣投資組合，安全估計為 $C_f \approx 3$。

插槽利用率建模

$P(\geq 1\ \text{active})$ 公式

考慮相關性的基礎公式：

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

不同策略和交易對數量的對照表（$C_f = 3$）：

對於活躍度為5%的策略B，需要50個交易對才能在至少一半的時間內擁有至少一個活躍倉位。而且這還沒有考慮到50個加密貨幣交易對的相關性比10個更強。

多插槽編排器

真正的編排器同時管理多個插槽。如果你有5個插槽和10個交易對，利用率的計算方式不同：

$\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:
    """
    多插槽编排器fill efficiency的解析估算。

    Args:
        trading_time_pct: 单个策略在单个交易对上的活跃时间比例
        n_pairs: 交易对数量
        correlation_factor: 信号相关系数
        max_slots: 最大同时仓位数

    Returns:
        包含利用率指标的dict
    """
    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 = [
    ("策略B，10对，1插槽", 0.05, 10, 3.0, 1),
    ("策略B，10对，3插槽", 0.05, 10, 3.0, 3),
    ("策略B，30对，1插槽", 0.05, 30, 3.0, 1),
    ("策略A，10对，1插槽", 0.15, 10, 3.0, 1),
    ("策略C，10对，1插槽", 0.45, 10, 3.0, 1),
    ("策略C，10对，5插槽", 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()

預期輸出：

策略B，10对，1插槽:
  N_eff = 3.3
  P(≥1 active) = 15.6%
  E[active] = 0.17
  fill_efficiency = 15.6%

策略B，10对，3插槽:
  N_eff = 3.3
  P(≥1 active) = 15.6%
  E[active] = 0.17
  fill_efficiency = 5.6%

策略B，30对，1插槽:
  N_eff = 10.0
  P(≥1 active) = 40.1%
  E[active] = 0.50
  fill_efficiency = 40.1%

策略A，10对，1插槽:
  N_eff = 3.3
  P(≥1 active) = 41.8%
  E[active] = 0.50
  fill_efficiency = 41.8%

策略C，10对，1插槽:
  N_eff = 3.3
  P(≥1 active) = 89.0%
  E[active] = 1.50
  fill_efficiency = 89.0%

策略C，10对，5插槽:
  N_eff = 3.3
  P(≥1 active) = 89.0%
  E[active] = 1.50
  fill_efficiency = 30.0%

請注意：策略B在3個插槽和10個交易對下，fill_efficiency僅為5.6%。當預期活躍交易對數量僅為0.17時，三個插槽毫無意義。插槽應按預期負載成比例分配。

基於真實資料的模擬

解析模型是近似值。要獲得精確估算，需要在真實訊號上進行模擬：

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天
    priority_fn=None,        # 仓位选择的优先级函数
) -> dict:
    """
    模拟编排器的实际插槽负载。

    对于每一分钟：计算有多少交易对想要建仓，
    以及实际占用了多少插槽（考虑限制）。

    Args:
        all_signals: 按交易对和策略分类的信号
        max_slots: 最大同时仓位数
        test_period_minutes: 测试期长度（分钟）
        priority_fn: 如果为None — FIFO；否则 — 排名函数
    """
    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),
    }

在真實資料上的模擬通常顯示的利用率甚至低於解析估算，因為它考慮了訊號的時間聚集性：所有交易對在一個叢集中同時入場，造成溢位，然後全部沉默，造成空白。

需要監控多少交易對？邊際遞減分析

核心問題：在什麼 $N$ 值時，增加一個交易對不再明顯提高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:
    """
    增加新交易对的边际递减分析。
    """
    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"策略B：达到80% P(≥1)需要{analysis_b['target_n_for_utilization']}个交易对")

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%}")

策略B的結果（$p = 0.05$，$C_f = 3$）：

對於策略B，即使有100個交易對也無法達到80%的單插槽利用率（需要約96個交易對）。這是一個根本性限制：交易時間為5%的策略不適合單插槽執行——它需要多策略的投資組合方法。

對於策略A（$p = 0.15$，$C_f = 3$）：

策略A在約30個交易對時達到80%利用率。第30個交易對的邊際增益僅為+1.2%。

對於策略C（$p = 0.45$，$C_f = 3$）：

交易時間為45%的策略C在僅10個交易對時就達到了90%利用率。增加更多沒有意義。

不同交易對的Edge衰減

還有另一個限制交易對數量的因素：edge衰減。在BTC/USDT上開發和最佳化的策略，在流動性較低的山寨幣上可能表現更差。

衰減原因：

• 流動性：DOGE/USDT的滑點比BTC/USDT高數倍
• 價差：流動性較低的交易對有更寬的買賣價差
• 微觀結構：不同交易對的訂單簿模式不同
• 操縱：低流動性山寨幣容易受到拉高出貨的影響

def edge_decay_analysis(
    strategy_results: dict,  # {pair: {"pnl_per_day": float, "n_trades": int}}
    min_trades: int = 30,
) -> list:
    """
    按edge排名交易对，考虑衰减。
    """
    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

典型情況：

新增第10個交易對降低了投資組合的平均PnL/天。到第8個交易對時，edge已經是最好的一半。需要在fill_efficiency（隨交易對數量增長）和平均edge（下降）之間取得平衡。

最優交易對數量：統一模型

我們將fill_efficiency和edge衰減合併為一個指標——預期投資組合每日PnL：

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

def optimal_pairs_count(
    pair_edges: list,           # PnL/天按降序排列：[0.89, 0.82, 0.71, ...]
    trading_time_pct: float,
    correlation_factor: float = 3.0,
    max_slots: int = 1,
) -> dict:
    """
    寻找最大化投资组合PnL的最优交易对数量。
    """
    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"最优交易对数量：{opt['optimal_n']}")
print(f"年化投资组合收益：{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}%")

最優值通常位於新增新交易對的邊際fill_efficiency不再能補償平均edge下降的點。對於典型的加密貨幣投資組合：

• 策略B（5%時間）：最優為8-12個交易對
• 策略A（15%時間）：最優為6-10個交易對
• 策略C（45%時間）：最優為4-6個交易對

一個悖論：交易時間最少的策略從最多的交易對中獲益，但fill_efficiency仍然很低。解決方案不是更多交易對，而是與其他策略組合（參見組合策略）。

跨交易對分散化：降低相關性的策略

如果無法無限增加交易對數量，可以降低 $C_f$ ——即增加訊號多樣性。

策略1：混合流動性代幣和DeFi代幣

BTC、ETH、BNB高度相關。但UNI（DEX）、AAVE（借貸）、CRV（穩定幣）可能有自己的驅動因素。新增DeFi代幣可將平均 $\bar{\rho}$ 從0.35降至0.20-0.25：

$C_f = 1 + 9 \times 0.20 = 2.8 \quad \text{（vs. } \bar{\rho} = 0.25 \text{ 时的 3.25）}$

策略2：在相同交易對上使用不同策略

不是10個交易對配一個策略——而是5個交易對配兩個不同策略。如果策略基於不同原理（動量 vs. 均值迴歸），它們的訊號可能負相關：

• 動量在價格上漲時做多
• 均值迴歸在價格下跌時做多

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

這是獲得 $N_{eff} > N$ 的唯一方法——使用訊號負相關的策略。

策略3：現貨 vs. 期貨

資金費率套利和現貨交易具有不同的相關結構。將套利策略新增到投資組合中可顯著降低整體 $C_f$，因為套利從本質上利用的是差異而非一致性。

按策略型別的實用建議

高頻低時間策略（交易時間 < 10%）

典型代表：策略B（5%時間，750天38筆交易）。

• 交易對數量：10-15（edge/fill平衡的最優值）
• 問題：即使15個交易對，fill_efficiency也很低（約20-25%）
• 解決方案：必須在編排器中與其他策略組合
• 加密貨幣的 $C_f$：2.5-3.5
• 監控：滾動 $C_f$ 以適應市場狀態調整交易對數量

中等時間策略（交易時間 10-30%）

典型代表：策略A（15%時間，750天418筆交易）。

• 交易對數量：6-10
• 10個交易對的Fill_efficiency：約40%
• 解決方案：組合2-3個此類策略可填充80%以上的時間
• 加密貨幣的 $C_f$：2.5-3.5
• 重點：選擇edge最高的交易對，不要追求數量

高時間策略（交易時間 > 30%）

典型代表：策略C（45%時間）。

• 交易對數量：4-6
• 6個交易對的Fill_efficiency：約80%
• 問題：溢位——多個交易對同時活躍，但插槽較少
• 解決方案：增加max_slots或新增交易對優先順序
• 加密貨幣的 $C_f$：2.5-4.0（由於長倉位跨越危機，數值更高）

彙總表

與系列中其他指標的關聯

本文是"沒有幻覺的回測"系列的第十一篇。訊號相關性直接影響前幾篇文章中的指標：

• 按活躍時間計算的PnL： fill_efficiency是有效收益率公式中的關鍵乘數。如果你忽略相關性而高估了fill_efficiency，你的投資組合PnL預測將過於樂觀。

• 資金費率： 高相關性下，倉位同時開啟——資金成本隨插槽數量線性增長。溢位 + 資金費率 = 加速消耗資本。

• 資金費率套利： 套利策略是天然的分散化工具，可降低投資組合的 $C_f$。其訊號與動量和均值迴歸策略弱相關。

• 組合策略（下一篇文章）：如何構建具有不同 $p$ 和 $C_f$ 的策略投資組合，以實現90%以上的利用率。級聯編排在分配優先順序時考慮訊號相關性。

結論

加密貨幣中的分散化不在於交易對的數量。10個相關交易對產生的效果相當於3-4個獨立交易對。恐慌期間更少。

四個要點：

1. 計算effective_N，而不是N。 對於加密貨幣交易對 $C_f \approx 3$。十個交易對約為3.3個有效交易對。根據 $N_{eff}$ 而非 $N$ 來規劃fill_efficiency。

2. 測量訊號相關性，而非價格相關性。 價格相關性是代理指標，不是替代品。在所有交易對上執行策略，計算二值訊號的相關矩陣。

3. 考慮edge衰減。 更多交易對意味著更低的平均PnL/天。最優點在於新交易對的邊際fill_efficiency仍能補償edge下降的位置。

4. 降低 $C_f$，而不是增加 $N$。 在相同交易對上組合不同策略比在更多交易對上使用單一策略更有效。跨策略分散化可以實現 $N_{eff} > N$。

相關因子是決定你的利用率和收益率預測是否現實的隱藏變數。忽略它意味著在幻覺之上構建投資組合。

實用連結

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

引用

@article{soloviov2026signalcorrelation,
  author = {Soloviov, Eugen},
  title = {信号相关性：需要监控多少个交易对},
  year = {2026},
  url = {https://marketmaker.cc/ru/blog/post/signal-correlation-pairs},
  version = {0.1.0},
  description = {为什么10个加密货币交易对无法提供10倍分散化，如何通过correlation\_factor计算effective\_N，以及实际需要监控多少个交易对才能达到80-90\%的编排器插槽利用率。}
}