Kripto Portföylerde Ortak Risk Modellemesi için Copula Modelleri

Korelasyon, çoğu portföy yöneticisinin çeşitlendirmeyi değerlendirirken başvurduğu ilk araçtır. Ancak kripto piyasalarında korelasyon tehlikeli biçimde yanıltıcıdır. İki token, sakin piyasalarda 0,3'lük bir Pearson korelasyonu gösterirken, bir çöküş sırasında bu değer 0,95'e fırlayabilir. Doğrusal korelasyon eliptik dağılımlar varsayar; bu varsayım ise kripto para getirilerinde yaygın olan ağır kuyruklar ve asimetrik bağımlılık yapıları karşısında çöker.

Copula modelleri bu sorunu, marjinal davranışı (her varlığın bireysel olarak nasıl davrandığı) bağımlılık yapısından (varlıkların birlikte nasıl hareket ettiği) ayırarak çözer. Sklar teoremi'ne dayanan bu ayrım, portföy getirilerinin tam ortak dağılımını — riskin gerçekten bulunduğu kuyruklar dahil — modellemek için esnek bir çerçeve sunar.

Doğrusal Korelasyon Kripto için Neden Başarısız Olur?

BTC, ETH, SOL ve AVAX'tan oluşan bir portföyü ele alalım. Mayıs 2022'deki Terra/Luna çöküşü sırasında bu varlıklar arasındaki korelasyonlar tam da çeşitlendirmeye en çok ihtiyaç duyulan anda 1,0'a yakınsadı. Kararlı korelasyonlar varsayan bir ortalama-varyans optimize edicisi, portföy riskini ciddi biçimde hafife almış olurdu.

Kripto için Pearson korelasyonunun temel sorunları:

1. Eliptik olmayan dağılımlar. Kripto getirileri belirgin çarpıklık ve basıklık sergiler. BTC günlük getirileri düzenli olarak 10'un üzerinde basıklık değerleri gösterir (normal dağılım: 3).
2. Asimetrik bağımlılık. Varlıklar, yükseliş dönemlerine kıyasla düşüş dönemlerinde daha yüksek korelasyon eğilimindedir. Bu "korelasyon çöküşü" olgusu hisse senedi piyasalarında iyi belgelenmiş olup kripto'da çok daha belirgindir.
3. Kuyruk bağımlılığı. İki varlığın aynı anda aşırı kayıp yaşama olasılığı doğrusal korelasyon tarafından yakalanmaz. Aynı korelasyona sahip ancak birbirinden çok farklı kuyruk bağımlılığı olan iki varlığınız olabilir.

Sklar Teoremi: Temel

Sklar teoremi (1959), herhangi bir çok değişkenli ortak dağılımın $F(x_1, x_2, \ldots, x_d)$ şu şekilde ayrıştırılabileceğini belirtir:

$F(x_1, x_2, \ldots, x_d) = C\bigl(F_1(x_1), F_2(x_2), \ldots, F_d(x_d)\bigr)$

burada $F_i$ marjinal dağılım fonksiyonları, $C: [0,1]^d \to [0,1]$ ise copula — değişkenler arasındaki bağımlılık yapısının tamamını kodlayan bir işlevdir.

Tersine, marjinaller sürekli ise copula $C$ tekil (unique) dir.

Bu ayrıştırma güçlüdür çünkü bize şunları sağlar:

• Her varlığın marjinal dağılımını ayrı ayrı modellemek (GARCH, EVT veya uygun herhangi bir dağılım kullanarak)
• Bağımlılık yapısını copula aracılığıyla bağımsız olarak modellemek
• Tam ortak dağılımı elde etmek için bunları birleştirmek

Ortak dağılımın yoğunluğu şu şekilde çarpanlarına ayrılır:

$f(x_1, \ldots, x_d) = c\bigl(F_1(x_1), \ldots, F_d(x_d)\bigr) \cdot \prod_{i=1}^{d} f_i(x_i)$

burada $c$ copula yoğunluğu, $f_i$ ise marjinal yoğunluklardır.

Copula Aileleri ve Özellikleri

Gaussian Copula

Gaussian copula, bir korelasyon matrisi $\Sigma$ ile parametrize edilir:

$C_{\Sigma}^{\text{Gauss}}(u_1, \ldots, u_d) = \Phi_{\Sigma}\bigl(\Phi^{-1}(u_1), \ldots, \Phi^{-1}(u_d)\bigr)$

burada $\Phi_{\Sigma}$ çok değişkenli normal CDF ve $\Phi^{-1}$ tek değişkenli normal kantil fonksiyonudur.

Kuyruk bağımlılığı: $\lambda_L = \lambda_U = 0$ ($\rho < 1$ için).

Gaussian copula sıfır kuyruk bağımlılığına sahiptir — ortak aşırı olayların olasılığını sistematik olarak hafife alır. Bu, 2008 öncesinde CDO'ların yanlış fiyatlandırılmasında kilit bir etken oldu ve kripto risk modellemesi için de aynı derecede tehlikelidir.

Student t-Copula

t-copula, serbestlik derecesi parametresi $\nu$ aracılığıyla simetrik kuyruk bağımlılığı ekler:

$C_{\nu, \Sigma}^{t}(u_1, \ldots, u_d) = t_{\nu, \Sigma}\bigl(t_{\nu}^{-1}(u_1), \ldots, t_{\nu}^{-1}(u_d)\bigr)$

Kuyruk bağımlılığı:

$\lambda_L = \lambda_U = 2 \cdot t_{\nu+1}\left(-\sqrt{\frac{(\nu+1)(1-\rho)}{1+\rho}}\right)$

$\nu = 4$ ve $\rho = 0,5$ için bu $\lambda \approx 0,18$ değerini verir — her iki varlığın da en kötü kantillerinde eş zamanlı bulunma olasılığı %18'dir. Daha düşük $\nu$ (daha ağır kuyruklar) bu olasılığı artırır. Kalın kuyruklu getirileriyle kripto piyasaları genellikle 3-8 aralığında $\nu$ değerleri gerektirir.

t-copula, Gaussian'a kıyasla önemli bir iyileştirmedir; ancak simetrik kuyruk bağımlılığını ($\lambda_L = \lambda_U$) zorunlu kılar. Pratikte kripto varlıkları genellikle üst kuyruk bağımlılığından (birlikte yükselme) daha güçlü bir alt kuyruk bağımlılığı (birlikte çöküş) sergiler.

Clayton Copula

Clayton copula, kripto'da gördüğümüz tam olarak asimetrik çöküş kümeleşmesi davranışı olan alt kuyruk bağımlılığını yakalar:

$C_{\theta}^{\text{Clayton}}(u_1, u_2) = \left(u_1^{-\theta} + u_2^{-\theta} - 1\right)^{-1/\theta}, \quad \theta > 0$

Kuyruk bağımlılığı: $\lambda_L = 2^{-1/\theta}$, $\lambda_U = 0$.

$\theta$ arttıkça alt kuyruk bağımlılığı güçlenir. $\theta = 2$ için $\lambda_L \approx 0,71$ — ortak aşırı kayıp olasılığı çok yüksektir.

Gumbel Copula

Gumbel copula, tam tersidir — üst kuyruk bağımlılığını yakalar:

$C_{\theta}^{\text{Gumbel}}(u_1, u_2) = \exp\left(-\left[(-\ln u_1)^{\theta} + (-\ln u_2)^{\theta}\right]^{1/\theta}\right), \quad \theta \geq 1$

Kuyruk bağımlılığı: $\lambda_L = 0$, $\lambda_U = 2 - 2^{1/\theta}$.

Frank Copula

Frank copula, her iki kuyrukta da sıfır kuyruk bağımlılığına sahiptir ($\lambda_L = \lambda_U = 0$); bu nedenle kuyruk etkileri olmaksızın dağılımın gövdesindeki bağımlılığı modellemek için uygundur:

$C_{\theta}^{\text{Frank}}(u_1, u_2) = -\frac{1}{\theta}\ln\left(1 + \frac{(e^{-\theta u_1}-1)(e^{-\theta u_2}-1)}{e^{-\theta}-1}\right)$

Kripto için Doğru Copula'yı Seçmek

Kripto portföyleri için ampirik kanıtlar şunu işaret eder:

• Alt kuyruk bağımlılığı için Clayton veya döndürülmüş Gumbel (survival Gumbel) — çöküş bulaşmasını yakalama
• Simetrik kuyruk bağımlılığının kabul edilebilir olduğu durumlarda genel amaçlı sağlam bir seçim olarak t-copula
• Yükseliş aşamalarındaki güçlü üst kuyruk bağımlılığını yakalamak için Joe copula

Bruhn ve Jeleskovic'in (2024) araştırması, özellikle t-copula ile Student t marjinalleri kullanan GARCH-copula modellerinin, kripto'daki düşüş (2022), toparlanma (2023) ve istikrar (2024) piyasa koşullarında ortalama-varyans ve tarihsel CVaR yaklaşımlarını tutarlı biçimde geride bıraktığını göstermiştir.

Boyutsallığın Laneti: Vine Copula'ların Devreye Girmesi

Standart çok değişkenli copula'lar (Gaussian, t-copula) yüksek boyutlara ölçeklenebilir ancak kısıtlayıcı varsayımlar dayatır. Archimedean copula'lar (Clayton, Gumbel, Frank) doğaları gereği iki değişkenlidir; bunları $d > 2$ boyutlara genişletmek, tüm çiftlerin aynı bağımlılık parametresini paylaşmasını gerektirir ki bu gerçekçi değildir.

Vine copula'lar bunu, $d$ boyutlu bir copula'yı bir ağaç yapısında düzenlenmiş iki değişkenli copula'lardan oluşan bir basamak olarak ayrıştırarak çözer. Her değişken çifti (diğerlerine koşullu olarak) kendi iki değişkenli copula ailesine ve parametresine sahip olur.

Çift-Copula Yapısı

$d$ boyutlu yoğunluk için vine copula çarpanlarına ayrıştırması şöyledir:

$f(x_1, \ldots, x_d) = \prod_{i=1}^{d} f_i(x_i) \cdot \prod_{j=1}^{d-1}\prod_{i=1}^{d-j} c_{i,i+j|i+1,\ldots,i+j-1}$

burada $c_{i,j|S}$, $S$ kümesine koşullu $i$ ve $j$ değişkenleri için iki değişkenli bir copula yoğunluğudur.

$d$ boyutlu bir vine copula, $\binom{d}{2} = d(d-1)/2$ iki değişkenli copula gerektirir. 10 varlıklı bir kripto portföyü için bu 45 çift copula demektir — her biri potansiyel olarak farklı bir aileden.

Vine Yapıları: C-Vine, D-Vine, R-Vine

C-vine (Kanonik vine): Her ağaçta tüm diğer düğümlere bağlı tek bir kök düğüm vardır. BTC'nin piyasa sürücüsü olduğu durumlarda olduğu gibi bir değişken baskın olduğunda en iyisidir.

Tree 1:    BTC --- ETH
           BTC --- SOL
           BTC --- AVAX
           BTC --- DOT

Tree 2:    ETH|BTC --- SOL|BTC
           ETH|BTC --- AVAX|BTC
           ETH|BTC --- DOT|BTC

D-vine (Çizilebilir vine): Sıralı yol yapısı. Değişkenlerin doğal bir sıralaması olduğunda (örn. piyasa değerine veya sektöre göre) en iyisidir.

R-vine (Düzenli vine): En genel yapı — herhangi bir geçerli ağaç dizisi. R-vine'lar hem C-vine hem de D-vine'ları kapsar.

Kripto para portföyleri üzerine yapılan araştırmalar, D-vine yapılarının kripto varlıkları için C-vine ve R-vine'a kıyasla çoğunlukla daha üstün VaR tahminleri ürettiğini göstermektedir; ancak bu, portföyün spesifik bileşimine bağlıdır.

Vine Copula'ların Kripto için Önemi

Tek bir Clayton copula ile modellenen 8 kripto varlıklı bir portföy, 28 çiftin tamamının aynı $\theta$'yı paylaşmasını zorunlu kılar. Ancak BTC-ETH'nin $\theta_{\text{Clayton}} = 3,5$ (güçlü çöküş bağımlılığı) olurken SOL-AVAX'ın $\theta = 1,2$ (orta düzey) olması mümkündür. Vine copula'lar her çiftin kendi bağımlılık yapısını ifade etmesine izin verir:

• BTC-ETH: t-copula ($\nu=4$, $\rho=0,72$)
• BTC-SOL: Clayton ($\theta=2,1$)
• ETH-AVAX: Frank ($\theta=5,3$)
• SOL-DOT | BTC: Gumbel ($\theta=1,8$)

Bu esneklik, doğru portföy riski tahmini için kritik önem taşır.

Marjinalleri Modellemek: GARCH-EVT

Copula'yı uydurmadan önce her varlığın getiri serisini tekdüze $[0,1]$ değişkenlere ("olasılık integral dönüşümü") dönüştürmemiz gerekir. Standart işlem hattı:

1. Zaman içinde değişen oynaklığı yakalamak için her varlığın getiri serisine GARCH modeli uydurma
2. Standartlaştırılmış artıkları çıkarma $z_t = (r_t - \mu_t) / \sigma_t$
3. Bir eşiği (genellikle 5. ve 95. yüzdelikler) aşan üst ve alt kuyruklar için kuyrukları Aşırı Değer Teorisi (EVT) — özellikle Genelleştirilmiş Pareto Dağılımı (GPD) — kullanarak uydurma
4. Dağılımın gövdesi için ampirik CDF kullanma
5. Sözde tekdüze gözlemler $u_{i,t} = \hat{F}_i(z_{i,t})$ elde etmek için olasılık integral dönüşümü uygulama

Bu GARCH-EVT yaklaşımı çoğunlukla "yarı-parametrik" yöntem olarak adlandırılır. Şunları doğru biçimde yakalar:

• Oynaklık kümelenmesi (GARCH)
• Ağır kuyruklar (EVT'den GPD)
• Dağılımın genel şekli (gövde için ampirik CDF)

Kripto varlıkları için Student t yenilikleriyle EGARCH(1,1) veya GJR-GARCH(1,1) modeli iyi çalışır; zira asimetrik oynaklık tepkisini (kötü haberin oynaklığı iyi haberden daha fazla artırması) yakalar.

Copula'larla Portföy VaR ve CVaR

Riske Maruz Değer (VaR)

$\alpha$ güven düzeyinde portföy VaR'ı:

$\text{VaR}_\alpha = \inf\{ l : P(L \leq l) \geq \alpha \}$

burada $L$ portföy kaybıdır. Copula'larla VaR'ı Monte Carlo yöntemiyle tahmin ederiz:

1. Uydurulan vine copula'dan $N$ örneklem simüle etme (tekdüze uzayda)
2. Ters marjinal CDF'ler kullanılarak getiri uzayına geri dönüştürme
3. Portföy getirilerini hesaplama: $r_p = \sum_i w_i \cdot r_i$
4. VaR, simüle edilen portföy kayıp dağılımının $\alpha$-kantilidir

Koşullu Riske Maruz Değer (CVaR / Beklenen Açık)

CVaR, kaybın VaR'ı aştığı durumlarda beklenen kayıptır:

$\text{CVaR}_\alpha = E[L \mid L \geq \text{VaR}_\alpha] = \frac{1}{1-\alpha}\int_{\alpha}^{1}\text{VaR}_u\, du$

CVaR tutarlıdır (alt-eklenebilirliği sağlar), bu da onu portföy optimizasyonu için VaR'dan üstün kılar. Monte Carlo tahmini basittir — VaR'ı aşan kayıpların ortalaması alınır.

Copula Tabanlı Risk Neden Korelasyon Tabanlı Riskten Üstündür?

0,5'lik özdeş ikili korelasyonlara sahip iki portföyü ele alalım:

• Portföy A: Gaussian copula bağımlılığı (kuyruk bağımlılığı yok)
• Portföy B: Clayton copula bağımlılığı ($\theta = 2$, $\lambda_L = 0,71$)

%99 güven düzeyinde Portföy B, önemli ölçüde daha yüksek VaR ve CVaR gösterecektir; çünkü Clayton copula, varlıkların birlikte çökme eğilimini doğru biçimde modeller. Gaussian copula, aşırı birlikte hareketlerin son derece nadir olduğunu varsayarak bu riski hafife alır.

Kripto portföyleri üzerine yapılan ampirik çalışmalarda, Gaussian ve vine copula modelleri arasındaki %99'luk CVaR farkı %30-40'ı aşabilir; bu da korelasyon tabanlı modellerin kuyruk riskini üçte bir veya daha fazla hafife alabileceğini gösterir.

Uygulama: pyvinecopulib ile Python

Aşağıda kripto getirilerine vine copula uydurma ve portföy VaR/CVaR tahmini için eksiksiz bir işlem hattı yer almaktadır.

Adım 1: Veri Hazırlama ve Marjinal Uydurma

import numpy as np
import pandas as pd
from arch import arch_model
from scipy import stats
import pyvinecopulib as pv

def fetch_crypto_returns(symbols, start="2023-01-01", end="2025-12-31"):
    """
    Fetch daily returns for a list of crypto symbols.
    Replace with your data source (ccxt, yfinance, etc.)
    """
    import yfinance as yf
    prices = yf.download(
        [f"{s}-USD" for s in symbols],
        start=start, end=end
    )["Close"]
    prices.columns = symbols
    returns = np.log(prices / prices.shift(1)).dropna()
    return returns

symbols = ["BTC", "ETH", "SOL", "AVAX", "DOT", "LINK", "MATIC", "ATOM"]
returns = fetch_crypto_returns(symbols)

def fit_garch_marginal(series, dist="t"):
    """
    Fit GJR-GARCH(1,1) with Student-t innovations.
    Returns standardized residuals and the fitted model.
    """
    model = arch_model(
        series * 100,  # scale for numerical stability
        vol="GARCH",
        p=1, o=1, q=1,  # GJR-GARCH
        dist=dist,
        mean="AR",
        lags=1
    )
    result = model.fit(disp="off")
    std_resid = result.std_resid.dropna()
    return std_resid, result

residuals = {}
garch_models = {}
for sym in symbols:
    std_resid, model = fit_garch_marginal(returns[sym])
    residuals[sym] = std_resid
    garch_models[sym] = model

residuals_df = pd.DataFrame(residuals).dropna()

Adım 2: Olasılık İntegral Dönüşümü

def semi_parametric_pit(residuals, tail_threshold=0.05):
    """
    Semi-parametric probability integral transform:
    - GPD for tails beyond threshold
    - Empirical CDF for the body
    Returns pseudo-uniform observations in [0, 1].
    """
    n = len(residuals)
    u = np.zeros(n)
    sorted_resid = np.sort(residuals)

    lower_thresh = np.quantile(residuals, tail_threshold)
    upper_thresh = np.quantile(residuals, 1 - tail_threshold)

    for i, x in enumerate(residuals):
        if x <= lower_thresh:
            lower_exceedances = -(residuals[residuals <= lower_thresh] - lower_thresh)
            shape, _, scale = stats.genpareto.fit(lower_exceedances, floc=0)
            u[i] = tail_threshold * (
                1 - stats.genpareto.cdf(-(x - lower_thresh), shape, scale=scale)
            )
        elif x >= upper_thresh:
            upper_exceedances = residuals[residuals >= upper_thresh] - upper_thresh
            shape, _, scale = stats.genpareto.fit(upper_exceedances, floc=0)
            u[i] = 1 - tail_threshold * (
                1 - stats.genpareto.cdf(x - upper_thresh, shape, scale=scale)
            )
        else:
            u[i] = np.mean(residuals <= x)

    u = np.clip(u, 1e-6, 1 - 1e-6)
    return u

U = np.column_stack([
    semi_parametric_pit(residuals_df[sym].values)
    for sym in symbols
])

Adım 3: Vine Copula'yı Uydurma

controls = pv.FitControlsVinecop(
    family_set=[
        pv.BicopFamily.student,
        pv.BicopFamily.clayton,
        pv.BicopFamily.gumbel,
        pv.BicopFamily.frank,
        pv.BicopFamily.joe,
        pv.BicopFamily.bb1,       # Clayton-Gumbel mixture
        pv.BicopFamily.bb7,       # Joe-Clayton mixture
        pv.BicopFamily.gaussian,
    ],
    selection_criterion="bic",    # BIC for model selection
    tree_criterion="tau",          # Kendall's tau for tree structure
    nonparametric_method="constant",
    trunc_lvl=5,                   # Truncate after 5 trees
)

vine = pv.Vinecop(U, controls=controls)

print(f"Log-likelihood: {vine.loglik(U):.2f}")
print(f"AIC: {vine.aic(U):.2f}")
print(f"BIC: {vine.bic(U):.2f}")

for i in range(vine.order.shape[0] - 1):
    pair = vine.get_pair_copula(0, i)
    print(f"Tree 1, Edge {i}: {pair.family} "
          f"(params: {pair.parameters})")

Adım 4: Monte Carlo VaR ve CVaR

def estimate_var_cvar(vine, garch_models, symbols, weights,
                       n_sim=50_000, alpha=0.99, seed=42):
    """
    Estimate portfolio VaR and CVaR using Monte Carlo simulation
    from the fitted vine copula.
    """
    U_sim = vine.simulate(n=n_sim, seeds=[seed])

    returns_sim = np.zeros((n_sim, len(symbols)))
    for j, sym in enumerate(symbols):
        model = garch_models[sym]
        forecasts = model.forecast(horizon=1)
        mu = forecasts.mean.iloc[-1, 0] / 100  # unscale
        sigma = np.sqrt(forecasts.variance.iloc[-1, 0]) / 100

        nu = model.params.get("nu", 5)
        z_sim = stats.t.ppf(U_sim[:, j], df=nu)
        returns_sim[:, j] = mu + sigma * z_sim

    weights = np.array(weights)
    portfolio_returns = returns_sim @ weights

    losses = -portfolio_returns

    var = np.quantile(losses, alpha)

    cvar = np.mean(losses[losses >= var])

    return var, cvar, portfolio_returns

weights = [1.0 / len(symbols)] * len(symbols)

var_99, cvar_99, sim_returns = estimate_var_cvar(
    vine, garch_models, symbols, weights,
    n_sim=100_000, alpha=0.99
)

print(f"1-day 99% VaR:  {var_99*100:.2f}%")
print(f"1-day 99% CVaR: {cvar_99*100:.2f}%")

from scipy.stats import norm
mu_p = sim_returns.mean()
sigma_p = sim_returns.std()
var_gauss = -(mu_p + sigma_p * norm.ppf(0.01))
print(f"\nGaussian VaR:   {var_gauss*100:.2f}%")
print(f"Copula/Gaussian ratio: {var_99/var_gauss:.2f}x")

Adım 5: Kuyruk Bağımlılığı Analizi

def compute_tail_dependence(vine, symbols):
    """
    Extract lower and upper tail dependence coefficients
    from the first tree of the vine copula.
    """
    results = []
    order = vine.order
    n_edges = order.shape[0] - 1

    for i in range(n_edges):
        pair = vine.get_pair_copula(0, i)
        u_pair = pair.simulate(n=100_000, seeds=[42])
        q = 0.01  # 1st percentile

        mask_lower = (u_pair[:, 0] <= q)
        lambda_L = np.mean(u_pair[mask_lower, 1] <= q) if mask_lower.sum() > 0 else 0

        mask_upper = (u_pair[:, 0] >= 1 - q)
        lambda_U = np.mean(u_pair[mask_upper, 1] >= 1 - q) if mask_upper.sum() > 0 else 0

        i_idx = order[0]
        j_idx = order[i + 1]
        results.append({
            "pair": f"{symbols[i_idx]}-{symbols[j_idx]}",
            "family": str(pair.family),
            "lambda_L": round(lambda_L, 4),
            "lambda_U": round(lambda_U, 4),
        })

    return pd.DataFrame(results)

tail_dep = compute_tail_dependence(vine, symbols)
print(tail_dep.to_string(index=False))

Bir kripto portföyü için tipik çıktı şöyle görünebilir:

Her çiftin tamamen farklı bir bağımlılık yapısına sahip olabileceğine dikkat edin. BTC-SOL, güçlü bir alt kuyruk bağımlılığı (Clayton) ve sıfır üst kuyruk bağımlılığı gösterir — birlikte çökerler ancak birlikte yükselmeleri zorunlu değildir. BTC-MATIC hiç kuyruk bağımlılığı göstermez (Frank); bu, aşırı durumlarda bile bir miktar çeşitlendirme faydası olduğuna işaret eder.

Copula VaR Modelini Geriye Doğru Test Etme

Bir VaR modeli ancak iyi kalibre edilmişse işe yarar. Standart geriye doğru test, VaR ihlallerini — gerçek kaybın tahmin edilen VaR'ı aştığı günleri — hesaplar ve ihlal oranının beklenen oranla eşleşip eşleşmediğini test eder.

def backtest_var(returns, symbols, weights, window=500,
                 alpha=0.99, n_sim=20_000):
    """
    Rolling-window VaR backtest using vine copula.
    """
    violations = []
    var_series = []
    T = len(returns)

    for t in range(window, T):
        window_returns = returns.iloc[t-window:t]

        U_window = np.zeros((window, len(symbols)))
        models_t = {}
        for j, sym in enumerate(symbols):
            std_resid, model = fit_garch_marginal(window_returns[sym])
            models_t[sym] = model
            u = pv.to_pseudo_obs(std_resid.values.reshape(-1, 1))
            U_window[:len(u), j] = u.ravel()

        U_clean = U_window[~np.any(U_window == 0, axis=1)]
        vine_t = pv.Vinecop(U_clean, controls=controls)

        var_t, _, _ = estimate_var_cvar(
            vine_t, models_t, symbols, weights,
            n_sim=n_sim, alpha=alpha
        )
        var_series.append(var_t)

        actual_return = (returns.iloc[t][symbols].values
                         * np.array(weights)).sum()
        violations.append(-actual_return > var_t)

    violation_rate = np.mean(violations)
    expected_rate = 1 - alpha
    print(f"Expected violation rate: {expected_rate:.4f}")
    print(f"Actual violation rate:   {violation_rate:.4f}")
    print(f"Number of violations:    {sum(violations)} / {len(violations)}")

    return violations, var_series

İyi kalibre edilmiş bir %99'luk VaR modelinde ihlal oranının %1'e yakın olması gerekir. Oran önemli ölçüde yüksekse model riski hafife alıyor demektir. Önemli ölçüde düşükse model aşırı muhafazakardır.

Pratik Değerlendirmeler

Hesaplama Maliyeti

Vine copula uydurma her ağaç düzeyi için $O(d^2 \cdot n)$ karmaşıklığındadır. Adım başına 50.000 Monte Carlo simülasyonuyla 500 günlük kayan pencereler kullanan 10 varlıklı bir portföy için tam geriye doğru test saatler sürebilir. Bunu yönetmek için stratejiler:

• Kesik vine'lar: trunc_lvl=3 veya trunc_lvl=4 ayarlayın — daha yüksek ağaçlar riske daha az katkıda bulunan daha zayıf koşullu bağımlılıkları yakalar
• Azaltılmış simülasyon sayısı: %99'luk VaR için çoğunlukla 10.000-20.000 simülasyon yeterlidir
• Paralel hesaplama: Her varlık için GARCH uydurmalar bağımsızdır ve paralel hale getirilebilir
• Model önbellekleme: Copula'yı günlük yerine haftalık olarak yeniden uydurma ve yalnızca GARCH tahminlerini güncelleme

Rejim Farkındalığı

Kripto piyasaları belirgin rejimler sergiler (boğa, ayı, yatay, yüksek oynaklık olayları). Tüm örnek üzerinde uydurulmuş tek bir vine copula, rejime bağlı bağımlılığı yakalayamayabilir. Şunları düşünün:

• 250-500 günlük kayan pencereler
• Copula parametrelerinin gizli bir Markov durumuna bağlı olduğu rejim değiştiren copula'lar
• Son verilere daha fazla ağırlık veren üstel olarak ağırlıklandırılmış gözlemler

Yaygın Tuzaklar

1. PIT'i unutmak. Ham getirileri sözde tekdüze gözlemler yerine doğrudan copula'ya beslemek anlamsız sonuçlar verir. Her zaman önce tekdüze marjinallere dönüştürün.
2. Çok fazla aileyle aşırı uydurma. Seçim kümesine mümkün olan her iki değişkenli aileyi dahil etmek, özellikle kısa örneklerle aşırı uydurmaya yol açabilir. Model seçimi için BIC kullanın ve 4-5 aileyle sınırlamayı düşünün.
3. Seri bağımlılığı görmezden gelmek. Copula'lar tek bir zaman noktasında kesitsel bağımlılığı modeller. GARCH adımını atlayıp otokorrele getirileri copula'ya beslerseniz, tahmin edilen bağımlılık seri etkilerle kirlenecektir.
4. Dinamik piyasalarda statik copula'lar. 2021 boğa piyasası verilerine uydurulan bir copula, 2022 çöküşü için zayıf kalibre edilmiş olacaktır. Her zaman kayan veya genişleyen pencereler kullanın.

Sonuç

Copula modelleri — özellikle vine copula'lar — kripto portföylerinin ortak riskini modellemek için matematiksel açıdan sağlam bir çerçeve sunar ve doğrusal korelasyonun yakalayabileceklerinin çok ötesine geçer. Temel avantajlar:

• Sklar teoremi aracılığıyla ayrı marjinal ve bağımlılık modellemesi
• Uygun copula ailesi seçimi yoluyla esnek kuyruk bağımlılığı (çöküş bulaşması için Clayton, yükseliş birlikte hareketi için Gumbel, simetrik kuyruklar için t-copula)
• Her varlık çiftinin kendi iki değişkenli copula'sını aldığı vine copula ayrıştırması yoluyla yüksek boyutlu ölçeklenebilirlik
• Doğrusal olmayan, asimetrik bağımlılığı hesaba katan doğru VaR/CVaR tahmini — "her şey birlikte çöker" normun istisna değil kural olduğu bir piyasada risk yönetimi için kritik önem taşır

GARCH-EVT-Copula işlem hattı artık nicel hedge fonları ve kripto odaklı risk masalarında standart yaklaşım haline gelmiştir. pyvinecopulib gibi kütüphanelerle uygulama engeli, herhangi bir sistematik yatırımcının copula tabanlı risk modellemesini portföy yönetimi iş akışına entegre edebileceği kadar düşüktür.

Bu makaledeki kod, çalışan bir başlangıç noktası sunar. Üretim kullanımı için GARCH düzeni seçimine yönelik uygun çapraz doğrulama, daha sofistike marjinal modeller (örn. kaldıraç etkileriyle EGARCH veya gün içi verileri kullanan gerçekleşmiş oynaklık ölçütleri) ve tarihsel kriz dönemlerine kalibre edilmiş varsayımsal copula parametreleri altında stres testi eklemek gerekmektedir.

Kaynaklar

• Sklar, A. (1959). Fonctions de repartition a n dimensions et leurs marges. Publications de l'Institut de Statistique de l'Universite de Paris, 8, 229-231.
• Joe, H. (2014). Dependence Modeling with Copulas. Chapman and Hall/CRC.
• Aas, K., Czado, C., Frigessi, A., & Bakken, H. (2009). Pair-copula constructions of multiple dependence. Insurance: Mathematics and Economics, 44(2), 182-198.
• Jeleskovic, V. & Bruhn, L. (2024). Cryptocurrency portfolio optimization: Utilizing a GARCH-Copula model within the Markowitz framework. Journal of Corporate Accounting & Finance.
• Nagler, T. & Vatter, T. (2023). pyvinecopulib: A Python library for vine copula models. GitHub.
• Tiwari, A. K., et al. (2020). Modeling risk dependence and portfolio VaR forecast through vine copula for cryptocurrencies. PLOS ONE, 15(1), e0242102.