Sinyal Korelasyonu: Kaç Parite İzlenmeli

10 kripto paritesinde strateji başlatıyorsunuz: BTC/USDT, ETH/USDT, SOL/USDT, AVAX/USDT ve altı alt coin daha. Mantık çelikten görünüyor: strateji tek bir paritede zamanın %5'inde aktifse, 10 paritede en az birinin aktif olma olasılığı $1 - 0.95^{10} = 40\%$ olmalı. Kullanımda dört kat artış.

Pratikte kullanım %40 değil, %15-16 çıkıyor. 10 pariteniz 3 parite gibi davranıyor. Sermaye boşta bekliyor, fill_efficiency düşüyor ve portföyün efektif getirisi projeksiyonun üç katı gerisinde kalıyor.

Bunun nedeni sinyal korelasyonu. Kripto para birimlerinde bu korkunç derecede yüksek.

Kripto'da Çeşitlendirme Yanılsaması

Geleneksel finansta çeşitlendirme işe yarar çünkü Apple hissesi ve bir petrol ETF'si farklı faktörlere tepki verir. Kripto para piyasasında ise durum bambaşkadır.

BTC baskın faktördür. Bitcoin %5 düştüğünde ETH %6-8, SOL %8-12, alt coinler %10-20 düşer. Kripto piyasasında günlük getiri korelasyonları sürekli olarak 0,6'nın üzerindedir ve panik dönemlerinde 1,0'a yaklaşır.

Ancak algo traderlar için önemli olan fiyat korelasyonu değil, sinyal korelasyonudur. Strateji momentum'a dayanıyorsa ve BTC bir giriş sinyali tetikliyorsa, ETH ve SOL'un da aynı dakikada benzer bir sinyal üretme olasılığı yüksektir. Tüm pariteler aynı anda long'a girer, aynı anda çıkar. On pozisyon — ama özünde tek bir bahis.

Neden 10 Parite ≠ 10 Kat Çeşitlendirme

Biçimsel İfade

$N$ paritenin her birinde bir stratejinin zamanın $p$ oranında aktif olduğunu varsayalım. Sinyaller tamamen bağımsız olsaydı, en az bir paritenin aktif olma olasılığı:

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

Strateji B için ($p = 0.05$, $N = 10$):

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

Ancak sinyaller bağımsız değil. Kripto para birimleri senkronize hareket ediyor — yani sinyaller kümeler halinde ortaya çıkıp kayboluyor.

Korelasyon 10 Pariteyi 3'e Dönüştürür

Sezgi şudur: 10 parite birbiriyle korelasyonluysa, bunlar 10 bağımsız kaynaktan değil, diyelim ki 3-4 kaynaktan bilgi taşıyorlar. Bunu effective_N üzerinden formalize ediyoruz:

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

burada $C_f$, ortalama çift yönlü sinyal korelasyonunu yansıtan korelasyon faktörüdür. $C_f = 1$ olduğunda pariteler tamamen bağımsızdır; $C_f = N$ olduğunda özdeştirler.

Kripto pariteleri için tipik $C_f \approx 3$. O halde:

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

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

%40 değil, %15,6. 2,5 kat fark. Fill efficiency buna göre düşüyor ve bununla birlikte portföyün efektif getirisi de (bkz. Aktif Zamana Göre PnL).

Kripto Piyasalarında Korelasyon

Baskın Faktör Olarak BTC

Kripto piyasası belirgin bir faktör yapısına sahiptir. BTC, çoğu alt coin için günlük getiri varyansının %60-80'ini açıklıyor. Bu PCA (Temel Bileşen Analizi) aracılığıyla açıkça görülüyor:

import numpy as np
from sklearn.decomposition import PCA

def analyze_crypto_factor_structure(returns_matrix: np.ndarray, pair_names: list) -> dict:
    """
    Kripto getirilerinin faktör yapısının PCA analizi.

    Args:
        returns_matrix: getiri matrisi [n_günler x n_parite]
        pair_names: parite adlarının listesi
    """
    pca = PCA()
    pca.fit(returns_matrix)

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

    print("Faktör yapısı:")
    for i, (var, cum) in enumerate(zip(explained[:5], cumulative[:5])):
        print(f"  PC{i+1}: {var:.1%} varyans (kümülatif: {cum:.1%})")

    loadings = pca.components_[0]
    print("\nPC1 yüklemeleri (BTC faktörü):")
    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 kripto pariteli portföy için tipik sonuç:

Dört faktör varyansın %90'ını açıklıyor. 10 pariteden en fazla 4'ü "bağımsız."

Sinyal Korelasyonu ve Fiyat Korelasyonu

Önemli bir nüans var. Fiyat korelasyonu ve sinyal korelasyonu farklı şeylerdir. BTC ve ETH fiyatları 0,85 korelasyona sahip olabilir, ancak belirli bir stratejinin sinyalleri giriş mantığına bağlı olarak 0,95 veya 0,50 korelasyona sahip olabilir.

Örnek: RSI aşırı alım/aşırı satım stratejisi. BTC'de RSI 30'u (aşırı satış) geçiyor — long'a gir. ETH de aynı anda aşırı satışta olabilir (sinyal korelasyonu ~0,90). Ya da ETH daha yavaş düşüyorsa olmayabilir (sinyal korelasyonu ~0,40).

Doğru yaklaşım, fiyat serilerinin değil, spesifik sinyallerin korelasyonunu ölçmektir:

import numpy as np
from itertools import combinations

def signal_correlation_matrix(
    signals: dict,  # {parite: dakika başına 0/1'den oluşan np.array}
    method: str = "pearson",
) -> np.ndarray:
    """
    Sinyal korelasyon matrisini hesapla (ikili: 0 = düz, 1 = pozisyonda).

    Args:
        signals: sözlük {parite_adı: ikili_sinyal_dizisi}
        method: korelasyon yöntemi ("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"Bilinmeyen yöntem: {method}")

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

    return corr_matrix, pairs


def estimate_correlation_factor(corr_matrix: np.ndarray) -> float:
    """
    Sinyal korelasyon matrisinden correlation_factor'ü tahmin et.

    correlation_factor = 1 + (N-1) * mean_pairwise_correlation

    Korelasyon 0 olduğunda → C_f = 1 (tümü bağımsız).
    Korelasyon 1 olduğunda → C_f = N (tümü özdeş).
    """
    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

Zamansal Korelasyon: Sakin ve Panik Dönemleri

Korelasyon statik değildir. Sakin dönemlerde BTC ve alt coinler ayrışabilir — ETH Ethereum haberleriyle, SOL Solana haberleriyle yükselir. Kriz döneminde ise her şey tek bir faktöre indirgenir: risk-on/risk-off.

def rolling_correlation_factor(
    signals: dict,
    window_days: int = 30,
    step_days: int = 7,
) -> list:
    """
    Rejim değişikliklerini tespit etmek için kayan 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 kripto parite için tipik tablo:

Panik döneminde 10 parite 1-2 efektif paritye sıkışıyor. Tam da çeşitlendirmeye en çok ihtiyaç duyulan anda kayboluyor. Bu, klasik "krizde korelasyonlar 1'e gider" olgunun kripto analogu.

effective_N: Temel Kavram

Formül ve Türetme

effective_N fikri istatistikten ödünç alınmıştır; gözlemlerin otokorelasyonunu hesaba katan efektif örneklem büyüklüğünden. Bizim amacımız için:

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

burada $\bar{\rho}$ ortalama çift yönlü sinyal korelasyonudur. Basitleştirilmiş gösterim:

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

Özellikler:

• $\bar{\rho} = 0$ olduğunda: $C_f = 1$, $N_{eff} = N$ — tam bağımsızlık
• $\bar{\rho} = 1$ olduğunda: $C_f = N$, $N_{eff} = 1$ — tüm pariteler özdeş
• $\bar{\rho} = 0.25$ ve $N = 10$ olduğunda: $C_f = 3.25$, $N_{eff} = 3.08$

Veriden correlation_factor Nasıl Tahmin Edilir

Pratikte üç yaklaşım var:

1. Sinyal korelasyon matrisinden (kesin).

Stratejiyi tüm paritelerde çalıştırın, ikili sinyaller edinin (her dakika için 0/1), korelasyon matrisini oluşturun, yukarıdaki formülle $C_f$'yi hesaplayın.

2. Fiyat getirilerinin PCA'sından (yaklaşık).

Sinyaller fiyat dinamiklerine güçlü biçimde bağlıysa (momentum, mean-reversion), $N_{eff}$'i varyansın %90'ını açıklayan PCA bileşenlerinin sayısı olarak tahmin edebilirsiniz.

3. Varlık sınıfı sezgisellerinden (kaba).

BTC, ETH, SOL, AVAX, MATIC, DOGE, DOT, LINK, UNI, ATOM'dan oluşan kripto portföyü için güvenli tahmin $C_f \approx 3$.

Slot Kullanımı Modelleme

$P(\geq 1\ \text{aktif})$ Formülü

Korelasyonu hesaba katan temel formül:

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

Farklı stratejiler ve parite sayıları için tablo ($C_f = 3$):

%5 aktiviteye sahip Strateji B için zamanın yarısında en az bir aktif pozisyona sahip olmak amacıyla 50 parite gerekiyor. Üstelik bu, 50 kripto paritenin 10'dan daha güçlü korelasyona sahip olduğunu hesaba katmadan.

Çok Slotlu Orkestratör

Gerçek bir orkestratör aynı anda birden fazla slotu yönetiyor. 5 slotunuz ve 10 pariteniz varsa, kullanım farklı hesaplanır:

$\text{kullanım} = \frac{\min(E[\text{aktif}], \text{max\_slots})}{\text{max\_slots}}$

$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:
    """
    Çok slotlu orkestratör için fill efficiency'nin analitik tahmini.

    Args:
        trading_time_pct: bir strateji için bir paritede aktif zaman oranı
        n_pairs: işlem paritesi sayısı
        correlation_factor: sinyal korelasyon katsayısı
        max_slots: eşzamanlı maksimum pozisyon sayısı

    Returns:
        kullanım metriklerini içeren 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 = [
    ("Strateji B, 10 parite, 1 slot", 0.05, 10, 3.0, 1),
    ("Strateji B, 10 parite, 3 slot", 0.05, 10, 3.0, 3),
    ("Strateji B, 30 parite, 1 slot", 0.05, 30, 3.0, 1),
    ("Strateji A, 10 parite, 1 slot", 0.15, 10, 3.0, 1),
    ("Strateji C, 10 parite, 1 slot", 0.45, 10, 3.0, 1),
    ("Strateji C, 10 parite, 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()

Beklenen çıktı:

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

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

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

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

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

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

Not: 3 slot ve 10 parite ile Strateji B, fill_efficiency olarak %5,6 gösteriyor. Aktif parite beklentisi yalnızca 0,17 iken üç slot anlamsız. Slotlar beklenen yüke orantılı dağıtılmalı.

Gerçek Verilerden Simülasyon

Analitik model bir yaklaşımdır. Doğru tahmin için gerçek sinyaller üzerinde simülasyon gerekir:

import numpy as np

def simulate_fill_efficiency(
    all_signals: dict,       # {(strateji, parite): [(giriş_dakika, çıkış_dakika), ...]}
    max_slots: int = 10,
    test_period_minutes: int = 750 * 24 * 60,  # 750 gün
    priority_fn=None,        # pozisyon seçimi için öncelik fonksiyonu
) -> dict:
    """
    Orkestratörün gerçek slot yükünü simüle et.

    Her dakika için: kaç paritenin pozisyon girmek istediğini
    ve kaç slotun gerçekten dolu olduğunu (limite göre) say.

    Args:
        all_signals: parite ve stratejilere göre sinyaller
        max_slots: eşzamanlı maksimum pozisyon sayısı
        test_period_minutes: test periyodunun dakika cinsinden uzunluğu
        priority_fn: None ise — FIFO; aksi halde — sıralama fonksiyonu
    """
    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),
    }

Gerçek veriler üzerindeki simülasyon genellikle analitik tahminden daha düşük kullanım gösterir; çünkü sinyallerin zamansal kümelenmesini hesaba katar: tüm pariteler bir kümede aynı anda girerek taşmaya, ardından hepsi sessizleşerek bir boşluğa neden olur.

Kaç Parite İzlenmeli? Azalan Getiriler Analizi

Temel soru: hangi $N$ değerinde bir parite daha eklemenin fill_efficiency üzerindeki etkisi fark edilir düzeyde azalır?

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:
    """
    Yeni parite eklemenin azalan getiriler analizi.
    """
    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"Strateji B: %80 P(≥1) için {analysis_b['target_n_for_utilization']} parite gerekli")

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"marjinal={r['marginal_gain']:.2%}")

Strateji B için sonuçlar ($p = 0.05$, $C_f = 3$):

Strateji B için 100 parite ile bile %80 tek slotlu kullanıma ulaşmak mümkün değil (~96 parite gerekiyor). Bu temel bir kısıtlamadır: %5 işlem süresine sahip bir strateji tek slotlu operasyon için uygun değildir — birden fazla stratejiyle portföy yaklaşımı gerektirir.

Strateji A için ($p = 0.15$, $C_f = 3$):

Strateji A, ~30 paritede %80 kullanıma ulaşıyor. 30. paritedeki marjinal kazanım yalnızca +%1,2.

Strateji C için ($p = 0.45$, $C_f = 3$):

%45 işlem süresine sahip Strateji C, yalnızca 10 paritede %90 kullanıma ulaşıyor. Daha fazla eklemenin anlamı yok.

Pariteler Arasında Edge Bozunumu

Parite sayısını sınırlayan başka bir faktör daha var: edge bozunumu. BTC/USDT üzerinde geliştirilen ve optimize edilen bir strateji, daha az likit alt coinlerde daha kötü performans gösterebilir.

Bozunumun nedenleri:

• Likidite: DOGE/USDT'de kayma BTC/USDT'den birkaç kat daha yüksek
• Spreadler: daha az likit pariteler daha geniş bid-ask spreadlerine sahip
• Mikro yapı: emir defteri kalıpları pariteler arasında farklılık gösteriyor
• Manipülasyon: düşük likidite alt coinleri pump-and-dump'a açık

def edge_decay_analysis(
    strategy_results: dict,  # {parite: {"pnl_per_day": float, "n_trades": int}}
    min_trades: int = 30,
) -> list:
    """
    Pariteleri bozunumu hesaba katarak edge'e göre sırala.
    """
    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

Tipik tablo:

10. parite eklenmesi portföyün ortalama PnL/gün değerini düşürüyor. 8. paritede edge zaten en iyinin yarısına inmiş. fill_efficiency (parite sayısıyla büyüyor) ile ortalama edge (düşüyor) arasında bir denge gerekiyor.

Optimal Parite Sayısı: Bütünleşik Model

fill_efficiency ve edge bozunumunu tek bir metrikte birleştiriyoruz — beklenen portföy PnL/gün:

$\text{Portföy PnL/gün} = \text{avg\_edge}(N) \times \text{fill\_efficiency}(N) \times 365$

def optimal_pairs_count(
    pair_edges: list,           # azalan sırayla PnL/gün: [0.89, 0.82, 0.71, ...]
    trading_time_pct: float,
    correlation_factor: float = 3.0,
    max_slots: int = 1,
) -> dict:
    """
    Portföy PnL'ini maksimize eden optimal parite sayısını bul.
    """
    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"Optimal parite sayısı: {opt['optimal_n']}")
print(f"Portföy yıllıklaştırılmış: {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 genellikle bir parite eklemenin marjinal fill_efficiency'sinin ortalama edge düşüşünü artık telafi etmediği noktada bulunur. Tipik bir kripto portföyü için:

• Strateji B (%5 süre): 8-12 paritede optimum
• Strateji A (%15 süre): 6-10 paritede optimum
• Strateji C (%45 süre): 4-6 paritede optimum

Bir paradoks: en düşük işlem süresine sahip strateji en fazla pariteden yararlanıyor, ancak fill_efficiency yine de düşük kalıyor. Çözüm daha fazla parite değil, diğer stratejilerle kombinasyon (bkz. Kombo Stratejiler).

Çapraz Parite Çeşitlendirme: Korelasyonu Azaltma Stratejileri

Parite sayısını sınırsız artıramıyorsanız, $C_f$'yi düşürebilirsiniz — yani sinyal çeşitliliğini artırabilirsiniz.

Strateji 1: Likit ve DeFi Token Karışımı

BTC, ETH, BNB çok güçlü biçimde korelasyonlu. Ancak UNI (DEX), AAVE (borç verme), CRV (stablecoin'ler) kendi sürücülerine sahip olabilir. DeFi token eklemek ortalama $\bar{\rho}$'yu 0,35'ten 0,20-0,25'e düşürür:

$C_f = 1 + 9 \times 0.20 = 2.8 \quad \text{($\bar{\rho} = 0.25$ iken 3.25'e karşı)}$

Strateji 2: Aynı Pariteler Üzerinde Farklı Stratejiler

Tek stratejiyle 10 parite yerine — iki farklı stratejiyle 5 parite. Stratejiler farklı prensiplere dayanıyorsa (momentum vs. mean-reversion), sinyalleri anti-korelasyonlu olabilir:

• Momentum, fiyat yükseldiğinde long girer
• Mean-reversion, fiyat düştüğünde long girer

$\bar{\rho}_{\text{çapraz-strateji}} < 0 \implies C_f < 1 \implies N_{eff} > N$

$N_{eff} > N$ elde etmenin tek yolu budur — negatif sinyal korelasyonuna sahip stratejiler kullanmak.

Strateji 3: Spot ve Vadeli İşlemler

Fonlama oranı arbitrajı ve spot ticaret farklı bir korelasyon yapısına sahip. Portföye arbitraj stratejileri eklemek genel $C_f$'yi önemli ölçüde azaltır; çünkü arbitraj tanım gereği yakınsama değil, uzaklaşmaları sömürür.

Strateji Türüne Göre Pratik Öneriler

Yüksek Frekanslı Düşük Süreli Stratejiler (işlem süresi < %10)

Tipik örnek: Strateji B (%5 süre, 750 günde 38 işlem).

• Parite sayısı: 10-15 (edge/fill dengesi için optimum)
• Sorun: 15 parite ile bile fill_efficiency düşük (~%20-25)
• Çözüm: orkestratörde diğer stratejilerle zorunlu kombinasyon
• Kripto için $C_f$: 2.5-3.5
• İzleme: piyasa rejimine göre parite sayısını adapte etmek için kayan $C_f$

Orta Süreli Stratejiler (işlem süresi %10-30)

Tipik örnek: Strateji A (%15 süre, 750 günde 418 işlem).

• Parite sayısı: 6-10
• 10 paritede Fill_efficiency: ~%40
• Çözüm: 2-3 böyle stratejiyi kombine etmek zamanın %80'inden fazlasını dolduruyor
• Kripto için $C_f$: 2.5-3.5
• Odak: maksimum edge'li pariteleri seç, miktarın peşine düşme

Yüksek Süreli Stratejiler (işlem süresi > %30)

Tipik örnek: Strateji C (%45 süre).

• Parite sayısı: 4-6
• 6 paritede Fill_efficiency: ~%80
• Sorun: taşma — birden fazla parite aynı anda aktif ama daha az slot var
• Çözüm: max_slots artırma veya parite önceliklendirmesi ekleme
• Kripto için $C_f$: 2.5-4.0 (uzun pozisyonların krizlerde örtüşmesi nedeniyle daha yüksek)

Özet Tablo

Serideki Diğer Metriklerle Bağlantı

Bu makale "Yanılsamasız Backtestler" serisinin on birinci yazısı. Sinyal korelasyonu, önceki makalelerdeki metrikleri doğrudan etkiliyor:

• Aktif Zamana Göre PnL: fill_efficiency, efektif getiri formülündeki kilit çarpandır. Korelasyonu görmezden gelerek fill_efficiency'yi aşırı tahmin ederseniz, portföy PnL tahmininiz gereğinden iyimser olacak.

• Fonlama oranları: yüksek korelasyonla pozisyonlar aynı anda açılıyor — ve fonlama maliyetleri slot sayısıyla doğrusal olarak büyüyor. Taşma + fonlama = hızlandırılmış sermaye yanması.

• Fonlama oranı arbitrajı: arbitraj stratejileri, portföyün $C_f$'sini azaltan doğal bir çeşitleyicidir. Sinyalleri momentum ve mean-reversion stratejileriyle zayıf korelasyona sahip.

• Kombo stratejiler (sonraki makale): %90'dan fazla kullanıma ulaşmak için farklı $p$ ve $C_f$ değerlerine sahip stratejilerden nasıl portföy oluşturulur. Kademeli orkestrasyon, öncelikleri atarken sinyal korelasyonunu hesaba katar.

Sonuç

Kripto'da çeşitlendirme, parite sayısıyla ilgili değil. 10 korelasyonlu parite, 3-4 bağımsız paritenin etkisini veriyor. Panik döneminde daha da az.

Dört çıkarım:

1. N değil, effective_N hesaplayın. Kripto pariteleri için $C_f \approx 3$. On parite yaklaşık 3,3 efektif parite. fill_efficiency'yi $N$ değil, $N_{eff}$ temelinde planlayın.

2. Fiyat korelasyonunu değil, sinyal korelasyonunu ölçün. Fiyat korelasyonu bir vekil, ikame değil. Stratejiyi tüm paritelerde çalıştırın ve ikili sinyal korelasyon matrisini hesaplayın.

3. Edge bozunumunu hesaba katın. Daha fazla parite, daha düşük ortalama PnL/gün demek. Optimum, yeni bir paritenin marjinal fill_efficiency'sinin edge düşüşünü hâlâ telafi ettiği noktadır.

4. $N$'yi artırmak yerine $C_f$'yi düşürün. Aynı pariteler üzerinde farklı stratejiler kombine etmek, daha fazla paritede tek strateji kullanmaktan daha etkilidir. Çapraz strateji çeşitlendirmesi $N_{eff} > N$ sağlayabilir.

Korelasyon faktörü, kullanım ve getiri tahminlerinizin ne kadar gerçekçi olduğunu belirleyen gizli değişkendir. Bunu görmezden gelmek, yanılsamalar üzerine portföy inşa etmek demektir.

Faydalı Bağlantılar

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

Alıntı

@article{soloviov2026signalcorrelation,
  author = {Soloviov, Eugen},
  title = {Sinyal Korelasyonu: Kaç Parite İzlenmeli},
  year = {2026},
  url = {https://marketmaker.cc/tr/blog/post/signal-correlation-pairs},
  version = {0.1.0},
  description = {10 kripto paritesi neden 10 kat çeşitlendirme sağlamıyor, correlation_factor üzerinden effective\_N nasıl hesaplanır ve orkestratör slot kullanımının \%80-90'a ulaşması için gerçekte kaç parite izlemeniz gerekiyor.}
}