Korelasi Isyarat: Berapa Banyak Pasangan Yang Perlu Dipantau

Anda melancarkan strategi pada 10 pasangan kripto: BTC/USDT, ETH/USDT, SOL/USDT, AVAX/USDT, dan enam alt lagi. Logiknya kelihatan kukuh: jika strategi aktif 5% daripada masa pada satu pasangan, maka merentas 10 pasangan sekurang-kurangnya satu sepatutnya aktif $1 - 0.95^{10} = 40\%$ daripada masa. Peningkatan penggunaan empat kali ganda.

Dalam amalan, penggunaan ternyata 15-16%, bukan 40%. 10 pasangan anda berkelakuan seperti 3. Modal duduk melahu, fill_efficiency jatuh, dan pulangan portfolio efektif akhirnya tiga kali lebih rendah daripada yang diunjurkan.

Sebabnya adalah korelasi isyarat. Dan dalam mata wang kripto, ia sangat tinggi secara kritikal.

Ilusi Kepelbagaian dalam Kripto

Dalam kewangan tradisional, kepelbagaian berfungsi kerana saham Apple dan ETF minyak bertindak balas kepada faktor yang berbeza. Dalam pasaran mata wang kripto, semuanya berbeza.

BTC adalah faktor dominan. Apabila Bitcoin jatuh 5%, ETH jatuh 6-8%, SOL jatuh 8-12%, altcoin jatuh 10-20%. Korelasi pulangan harian dalam pasaran kripto secara konsisten melebihi 0.6, dan semasa panik ia menghampiri 1.0.

Tetapi bagi kita — peniaga algo — yang penting bukan korelasi harga, tetapi korelasi isyarat. Jika strategi berasaskan momentum dan BTC mencetuskan isyarat masuk, terdapat kebarangkalian tinggi bahawa ETH dan SOL akan mencetuskan isyarat analogus dalam minit yang sama. Semua pasangan masuk long serentak, semua keluar serentak. Sepuluh kedudukan — tetapi pada dasarnya satu pertaruhan.

Mengapa 10 Pasangan ≠ Kepelbagaian 10x

Pernyataan Formal

Andaikan strategi pada setiap $N$ pasangan aktif $p$ pecahan daripada masa. Jika isyarat adalah bebas sepenuhnya, kebarangkalian bahawa sekurang-kurangnya satu pasangan aktif:

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

Untuk Strategi B ($p = 0.05$, $N = 10$):

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

Tetapi isyarat tidak bebas. Mata wang kripto bergerak serentak — bermakna isyarat muncul dan padam dalam kelompok.

Korelasi Mengubah 10 Pasangan Menjadi 3

Intuisinya adalah: jika 10 pasangan berkorelasi, mereka membawa maklumat bukan daripada 10 sumber bebas tetapi, katakan, 3-4. Kita memformalisasikan ini melalui effective_N:

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

di mana $C_f$ adalah faktor korelasi, mencerminkan korelasi isyarat pasangan purata. Apabila $C_f = 1$ pasangan adalah bebas sepenuhnya; apabila $C_f = N$ mereka adalah identik.

Untuk pasangan kripto, $C_f \approx 3$ yang tipikal. Maka:

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

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

Bukan 40%, tetapi 15.6%. Perbezaan 2.5x. Kecekapan pengisian jatuh dengan sewajarnya, dan bersamanya pulangan efektif seluruh portfolio (lihat PnL setiap Masa Aktif).

Korelasi dalam Pasaran Kripto

BTC sebagai Faktor Dominan

Pasaran kripto mempunyai struktur faktor yang jelas. BTC menerangkan 60-80% varians pulangan harian untuk kebanyakan altcoin. Ini jelas kelihatan melalui PCA (Analisis Komponen Utama):

import numpy as np
from sklearn.decomposition import PCA

def analyze_crypto_factor_structure(returns_matrix: np.ndarray, pair_names: list) -> dict:
    """
    Analisis PCA struktur faktor pulangan kripto.

    Args:
        returns_matrix: matriks pulangan [n_hari x n_pasangan]
        pair_names: senarai nama pasangan
    """
    pca = PCA()
    pca.fit(returns_matrix)

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

    print("Struktur faktor:")
    for i, (var, cum) in enumerate(zip(explained[:5], cumulative[:5])):
        print(f"  PC{i+1}: {var:.1%} varians (kumulatif: {cum:.1%})")

    loadings = pca.components_[0]
    print("\nBeban PC1 (faktor 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)),
    }

Keputusan tipikal untuk portfolio 10 pasangan kripto:

Empat faktor menerangkan 90% varians. Daripada 10 pasangan, tidak lebih daripada 4 adalah "bebas."

Korelasi Isyarat vs. Korelasi Harga

Berikut adalah nuansa penting. Korelasi harga dan korelasi isyarat adalah perkara yang berbeza. Harga BTC dan ETH berkorelasi pada 0.85, tetapi isyarat strategi tertentu mungkin berkorelasi pada 0.95 atau pada 0.50 — bergantung pada logik masuk.

Contoh: strategi RSI overbought/oversold. RSI pada BTC melepasi 30 (oversold) — masuk long. ETH pada masa yang sama mungkin juga oversold (korelasi isyarat ~0.90). Atau mungkin tidak, jika ETH jatuh lebih perlahan (korelasi isyarat ~0.40).

Pendekatan yang betul adalah mengukur korelasi isyarat khusus, bukan siri harga:

import numpy as np
from itertools import combinations

def signal_correlation_matrix(
    signals: dict,  # {pasangan: np.array 0/1 setiap minit}
    method: str = "pearson",
) -> np.ndarray:
    """
    Kira matriks korelasi isyarat (binari: 0 = flat, 1 = dalam kedudukan).

    Args:
        signals: kamus {nama_pasangan: tatasusunan_isyarat_binari}
        method: kaedah korelasi ("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"Kaedah tidak diketahui: {method}")

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

    return corr_matrix, pairs


def estimate_correlation_factor(corr_matrix: np.ndarray) -> float:
    """
    Anggaran correlation_factor daripada matriks korelasi isyarat.

    correlation_factor = 1 + (N-1) * purata_korelasi_pasangan

    Apabila korelasi 0 → C_f = 1 (semua bebas).
    Apabila korelasi 1 → C_f = N (semua identik).
    """
    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

Korelasi Temporal: Tenang vs. Panik

Korelasi tidak statik. Semasa tempoh tenang, BTC dan alt boleh bercerai — ETH naik atas berita Ethereum, SOL atas berita Solana. Dalam krisis, semuanya runtuh kepada faktor tunggal: risk-on/risk-off.

def rolling_correlation_factor(
    signals: dict,
    window_days: int = 30,
    step_days: int = 7,
) -> list:
    """
    Correlation_factor bergulir untuk mengesan perubahan rejim.
    """
    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

Gambaran tipikal untuk 10 pasangan kripto:

Semasa panik, 10 pasangan termampat kepada 1-2 yang efektif. Tepat ketika kepelbagaian paling diperlukan, ia lenyap. Ini adalah analogi kripto bagi klasik "korelasi menuju 1 dalam krisis."

effective_N: Konsep Utama

Formula dan Terbitan

Idea effective_N dipinjam daripada statistik, di mana saiz sampel efektif mengambil kira autokorelasi pemerhatian. Untuk tujuan kita:

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

di mana $\bar{\rho}$ adalah purata korelasi isyarat pasangan. Notasi ringkas:

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

Sifat-sifat:

• Apabila $\bar{\rho} = 0$: $C_f = 1$, $N_{eff} = N$ — kebebasan penuh
• Apabila $\bar{\rho} = 1$: $C_f = N$, $N_{eff} = 1$ — semua pasangan adalah identik
• Apabila $\bar{\rho} = 0.25$ dan $N = 10$: $C_f = 3.25$, $N_{eff} = 3.08$

Cara Menganggar correlation_factor daripada Data

Dalam amalan, terdapat tiga pendekatan:

1. Daripada matriks korelasi isyarat (tepat).

Jalankan strategi pada semua pasangan, dapatkan isyarat binari (0/1 untuk setiap minit), bina matriks korelasi, kira $C_f$ menggunakan formula di atas.

2. Daripada PCA pulangan harga (anggaran).

Jika isyarat sangat bergantung pada dinamik harga (momentum, mean-reversion), anda boleh menganggar $N_{eff}$ sebagai bilangan komponen PCA yang menerangkan 90% varians.

3. Daripada heuristik kelas aset (kasar).

Untuk portfolio kripto BTC, ETH, SOL, AVAX, MATIC, DOGE, DOT, LINK, UNI, ATOM, anggaran selamat adalah $C_f \approx 3$.

Pemodelan Penggunaan Slot

Formula untuk $P(\geq 1\ \text{aktif})$

Formula asas yang mengambil kira korelasi:

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

Jadual untuk strategi dan bilangan pasangan yang berbeza ($C_f = 3$):

Untuk Strategi B dengan aktiviti 5%, anda memerlukan 50 pasangan hanya untuk mempunyai sekurang-kurangnya satu kedudukan aktif separuh masa. Dan itu pun tidak mengambil kira hakikat bahawa 50 pasangan kripto lebih kuat berkorelasi berbanding 10.

Orkestrator Berbilang Slot

Orkestrator sebenar menguruskan berbilang slot serentak. Jika anda mempunyai 5 slot dan 10 pasangan, penggunaan dikira secara berbeza:

$\text{penggunaan} = \frac{\min(E[\text{aktif}], \text{slot\_maks})}{\text{slot\_maks}}$

$E[\text{aktif}] = 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:
    """
    Anggaran analitik kecekapan pengisian untuk orkestrator berbilang slot.

    Args:
        trading_time_pct: pecahan masa aktif untuk satu strategi pada satu pasangan
        n_pairs: bilangan pasangan dagangan
        correlation_factor: pekali korelasi isyarat
        max_slots: bilangan maksimum kedudukan serentak

    Returns:
        dict dengan metrik penggunaan
    """
    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 = [
    ("Strategi B, 10 pasangan, 1 slot", 0.05, 10, 3.0, 1),
    ("Strategi B, 10 pasangan, 3 slot", 0.05, 10, 3.0, 3),
    ("Strategi B, 30 pasangan, 1 slot", 0.05, 30, 3.0, 1),
    ("Strategi A, 10 pasangan, 1 slot", 0.15, 10, 3.0, 1),
    ("Strategi C, 10 pasangan, 1 slot", 0.45, 10, 3.0, 1),
    ("Strategi C, 10 pasangan, 5 slot", 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 aktif) = {result['p_at_least_one']:.1%}")
    print(f"  E[aktif] = {result['expected_active']:.2f}")
    print(f"  fill_efficiency = {result['fill_efficiency']:.1%}")
    print()

Output yang dijangkakan:

Strategi B, 10 pasangan, 1 slot:
  N_eff = 3.3
  P(≥1 aktif) = 15.6%
  E[aktif] = 0.17
  fill_efficiency = 15.6%

Strategi B, 10 pasangan, 3 slot:
  N_eff = 3.3
  P(≥1 aktif) = 15.6%
  E[aktif] = 0.17
  fill_efficiency = 5.6%

Strategi B, 30 pasangan, 1 slot:
  N_eff = 10.0
  P(≥1 aktif) = 40.1%
  E[aktif] = 0.50
  fill_efficiency = 40.1%

Strategi A, 10 pasangan, 1 slot:
  N_eff = 3.3
  P(≥1 aktif) = 41.8%
  E[aktif] = 0.50
  fill_efficiency = 41.8%

Strategi C, 10 pasangan, 1 slot:
  N_eff = 3.3
  P(≥1 aktif) = 89.0%
  E[aktif] = 1.50
  fill_efficiency = 89.0%

Strategi C, 10 pasangan, 5 slot:
  N_eff = 3.3
  P(≥1 aktif) = 89.0%
  E[aktif] = 1.50
  fill_efficiency = 30.0%

Nota: Strategi B dengan 3 slot dan 10 pasangan menunjukkan fill_efficiency sebesar 5.6%. Tiga slot tidak berguna apabila bilangan pasangan aktif yang dijangkakan hanya 0.17. Slot perlu diperuntukkan secara berkadar dengan beban yang dijangkakan.

Simulasi daripada Data Sebenar

Model analitik adalah anggaran. Untuk anggaran yang tepat, anda memerlukan simulasi pada isyarat sebenar:

import numpy as np

def simulate_fill_efficiency(
    all_signals: dict,       # {(strategi, pasangan): [(minit_masuk, minit_keluar), ...]}
    max_slots: int = 10,
    test_period_minutes: int = 750 * 24 * 60,  # 750 hari
    priority_fn=None,        # fungsi keutamaan untuk pemilihan kedudukan
) -> dict:
    """
    Simulasi beban slot sebenar orkestrator.

    Untuk setiap minit: kira berapa banyak pasangan ingin memasuki kedudukan,
    dan berapa banyak slot sebenarnya diduduki (mengambil kira had).

    Args:
        all_signals: isyarat mengikut pasangan dan strategi
        max_slots: bilangan maksimum kedudukan serentak
        test_period_minutes: tempoh ujian dalam minit
        priority_fn: jika None — FIFO; sebaliknya — fungsi penarafan
    """
    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),
    }

Simulasi pada data sebenar sering menunjukkan penggunaan yang lebih rendah berbanding anggaran analitik, kerana ia mengambil kira pengelompokan temporal isyarat: semua pasangan masuk serentak dalam kelompok, mewujudkan limpahan, dan kemudian semuanya senyap, mewujudkan kekosongan.

Berapa Banyak Pasangan yang Perlu Dipantau? Analisis Pulangan Berkurangan

Soalan utama: pada $N$ berapa penambahan satu lagi pasangan berhenti meningkatkan fill_efficiency secara ketara?

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:
    """
    Analisis pulangan berkurangan daripada penambahan pasangan baru.
    """
    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"Strategi B: perlu {analysis_b['target_n_for_utilization']} pasangan untuk 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%}")

Keputusan untuk Strategi B ($p = 0.05$, $C_f = 3$):

Untuk Strategi B, mencapai penggunaan slot tunggal 80% adalah mustahil walaupun dengan 100 pasangan (anda memerlukan ~96 pasangan). Ini adalah had asas: strategi dengan masa dagangan 5% tidak sesuai untuk operasi slot tunggal — ia memerlukan pendekatan portfolio dengan berbilang strategi.

Untuk Strategi A ($p = 0.15$, $C_f = 3$):

Strategi A mencapai penggunaan 80% pada ~30 pasangan. Keuntungan marginal pada pasangan ke-30 hanya +1.2%.

Untuk Strategi C ($p = 0.45$, $C_f = 3$):

Strategi C dengan masa dagangan 45% mencapai penggunaan 90% hanya dengan 10 pasangan. Menambah lebih banyak adalah sia-sia.

Kemerosotan Kelebihan Merentas Pasangan

Terdapat faktor lain yang mengehadkan bilangan pasangan: kemerosotan kelebihan. Strategi yang dibangunkan dan dioptimumkan pada BTC/USDT mungkin berprestasi lebih buruk pada alt yang kurang cair.

Punca kemerosotan:

• Kecairan: slippage pada DOGE/USDT beberapa kali lebih tinggi berbanding BTC/USDT
• Spread: pasangan yang kurang cair mempunyai spread bid-ask yang lebih lebar
• Mikrostruktur: corak buku pesanan berbeza antara pasangan
• Manipulasi: alt berkecairan rendah terdedah kepada pump-and-dump

def edge_decay_analysis(
    strategy_results: dict,  # {pasangan: {"pnl_per_day": float, "n_trades": int}}
    min_trades: int = 30,
) -> list:
    """
    Susun pasangan mengikut kelebihan dengan mengambil kira kemerosotan.
    """
    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

Gambaran tipikal:

Menambah pasangan ke-10 menurunkan purata PnL/hari portfolio. Pada pasangan ke-8, kelebihan sudah separuh daripada yang terbaik. Keseimbangan diperlukan antara fill_efficiency (berkembang dengan bilangan pasangan) dan purata kelebihan (jatuh).

Bilangan Pasangan Optimum: Model Bersepadu

Kita menggabungkan fill_efficiency dan kemerosotan kelebihan ke dalam satu metrik — PnL portfolio yang dijangkakan setiap hari:

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

def optimal_pairs_count(
    pair_edges: list,           # PnL/hari dalam tertib menurun: [0.89, 0.82, 0.71, ...]
    trading_time_pct: float,
    correlation_factor: float = 3.0,
    max_slots: int = 1,
) -> dict:
    """
    Cari bilangan pasangan optimum yang memaksimumkan PnL portfolio.
    """
    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"Bilangan pasangan optimum: {opt['optimal_n']}")
print(f"Portfolio tahunan: {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}%")

Optimum biasanya ditemui pada titik di mana keuntungan fill_efficiency marginal daripada penambahan pasangan tidak lagi mengimbangi penurunan purata kelebihan. Untuk portfolio kripto yang tipikal:

• Strategi B (5% masa): optimum pada 8-12 pasangan
• Strategi A (15% masa): optimum pada 6-10 pasangan
• Strategi C (45% masa): optimum pada 4-6 pasangan

Paradoks: strategi dengan masa dagangan terendah mendapat manfaat daripada pasangan terbanyak, namun fill_efficiency tetap rendah. Penyelesaiannya bukan lebih banyak pasangan, tetapi menggabungkan dengan strategi lain (lihat Strategi Kombo).

Kepelbagaian Merentas Pasangan: Strategi untuk Mengurangkan Korelasi

Jika anda tidak dapat menambah bilangan pasangan tanpa had, anda boleh mengurangkan $C_f$ — iaitu, meningkatkan kepelbagaian isyarat.

Strategi 1: Gabungan Token Cair dan DeFi

BTC, ETH, BNB sangat kuat berkorelasi. Tetapi UNI (DEX), AAVE (pinjaman), CRV (stablecoin) mungkin mempunyai pemacu mereka sendiri. Menambah token DeFi mengurangkan purata $\bar{\rho}$ daripada 0.35 kepada 0.20-0.25:

$C_f = 1 + 9 \times 0.20 = 2.8 \quad \text{(berbanding 3.25 pada } \bar{\rho} = 0.25\text{)}$

Strategi 2: Strategi Berbeza pada Pasangan yang Sama

Daripada 10 pasangan dengan satu strategi — 5 pasangan dengan dua strategi berbeza. Jika strategi berasaskan prinsip berbeza (momentum vs. mean-reversion), isyarat mereka boleh anti-berkorelasi:

• Momentum masuk long apabila harga naik
• Mean-reversion masuk long apabila harga jatuh

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

Ini adalah satu-satunya cara untuk mendapatkan $N_{eff} > N$ — gunakan strategi dengan korelasi isyarat negatif.

Strategi 3: Spot vs. Niaga Hadapan

Arbitraj kadar pembiayaan dan dagangan spot mempunyai struktur korelasi yang berbeza. Menambah strategi arbitraj ke dalam portfolio mengurangkan $C_f$ keseluruhan dengan ketara, kerana arbitraj secara definisi mengeksploitasi perbezaan, bukan penumpuan.

Cadangan Praktikal mengikut Jenis Strategi

Strategi Masa-Rendah Frekuensi Tinggi (masa dagangan < 10%)

Wakil tipikal: Strategi B (5% masa, 38 dagangan merentas 750 hari).

• Bilangan pasangan: 10-15 (optimum untuk keseimbangan kelebihan/pengisian)
• Masalah: fill_efficiency rendah walaupun dengan 15 pasangan (~20-25%)
• Penyelesaian: penggabungan wajib dengan strategi lain dalam orkestrator
• $C_f$ untuk kripto: 2.5-3.5
• Pemantauan: $C_f$ bergulir untuk menyesuaikan kiraan pasangan dengan rejim pasaran

Strategi Masa-Sederhana (masa dagangan 10-30%)

Wakil tipikal: Strategi A (15% masa, 418 dagangan merentas 750 hari).

• Bilangan pasangan: 6-10
• Fill_efficiency pada 10 pasangan: ~40%
• Penyelesaian: menggabungkan 2-3 strategi sedemikian mengisi 80%+ masa
• $C_f$ untuk kripto: 2.5-3.5
• Fokus: pilih pasangan dengan kelebihan maksimum, jangan kejar kuantiti

Strategi Masa-Tinggi (masa dagangan > 30%)

Wakil tipikal: Strategi C (45% masa).

• Bilangan pasangan: 4-6
• Fill_efficiency pada 6 pasangan: ~80%
• Masalah: limpahan — berbilang pasangan aktif serentak, tetapi lebih sedikit slot
• Penyelesaian: tingkatkan max_slots atau tambah keutamaan pasangan
• $C_f$ untuk kripto: 2.5-4.0 (lebih tinggi kerana kedudukan panjang bertindih semasa krisis)

Jadual Ringkasan

Kaitan dengan Metrik Lain dalam Siri

Artikel ini adalah yang kesebelas dalam siri "Ujian Balik Tanpa Ilusi". Korelasi isyarat secara langsung mempengaruhi metrik daripada artikel-artikel sebelumnya:

• PnL setiap Masa Aktif: fill_efficiency adalah pendarab utama dalam formula pulangan efektif. Jika anda menilai terlalu tinggi fill_efficiency dengan mengabaikan korelasi, ramalan PnL portfolio anda akan terlalu optimistik.

• Kadar pembiayaan: dengan korelasi tinggi, kedudukan dibuka serentak — dan kos pembiayaan berkembang secara linear dengan bilangan slot. Limpahan + pembiayaan = pembakaran modal yang dipercepatkan.

• Arbitraj kadar pembiayaan: strategi arbitraj adalah penganeka semula jadi yang mengurangkan $C_f$ portfolio. Isyarat mereka berkorelasi lemah dengan strategi momentum dan mean-reversion.

• Strategi kombo (artikel seterusnya): cara menyusun portfolio strategi dengan $p$ dan $C_f$ yang berbeza untuk mencapai penggunaan 90%+. Orkestrasi berantai mengambil kira korelasi isyarat ketika memberikan keutamaan.

Kesimpulan

Kepelbagaian dalam kripto bukan tentang bilangan pasangan. 10 pasangan berkorelasi menghasilkan kesan 3-4 yang bebas. Semasa panik, lebih sedikit lagi.

Empat pengajaran:

1. Kira effective_N, bukan N. Untuk pasangan kripto $C_f \approx 3$. Sepuluh pasangan adalah ~3.3 yang efektif. Rancang fill_efficiency berdasarkan $N_{eff}$, bukan $N$.

2. Ukur korelasi isyarat, bukan korelasi harga. Korelasi harga adalah proksi, bukan pengganti. Jalankan strategi pada semua pasangan dan kira matriks korelasi isyarat binari.

3. Ambil kira kemerosotan kelebihan. Lebih banyak pasangan bermakna purata PnL/hari yang lebih rendah. Optimum berada pada titik di mana fill_efficiency marginal daripada pasangan baru masih mengimbangi penurunan kelebihan.

4. Kurangkan $C_f$, jangan tingkatkan $N$. Menggabungkan strategi berbeza pada pasangan yang sama adalah lebih berkesan berbanding satu strategi pada lebih banyak pasangan. Kepelbagaian merentas strategi boleh menghasilkan $N_{eff} > N$.

Faktor korelasi adalah pemboleh ubah tersembunyi yang menentukan betapa realistiknya ramalan penggunaan dan pulangan anda. Mengabaikannya bermakna membina portfolio atas ilusi.

Pautan Berguna

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

Petikan

@article{soloviov2026signalcorrelation,
  author = {Soloviov, Eugen},
  title = {Signal Correlation: How Many Pairs to Monitor},
  year = {2026},
  url = {https://marketmaker.cc/ms/blog/post/signal-correlation-pairs},
  version = {0.1.0},
  description = {Mengapa 10 pasangan kripto tidak memberikan kepelbagaian 10x, cara mengira effective\_N melalui correlation\_factor, dan berapa banyak pasangan yang sebenarnya perlu dipantau untuk penggunaan slot orkestrator 80-90\%.}
}