Model Kopula untuk Pemodelan Risiko Bersama dalam Portfolio Kripto

Korelasi adalah alat pertama yang sering digunakan oleh pengurus portfolio dalam menilai kepelbagaian. Namun dalam pasaran kripto, korelasi adalah sangat mengelirukan. Dua token mungkin menunjukkan korelasi Pearson sebesar 0.3 semasa pasaran tenang, kemudian melonjak ke 0.95 semasa kejatuhan pasaran. Korelasi linear mengandaikan taburan eliptikal — satu andaian yang runtuh di bawah ekor berat dan struktur kebergantungan asimetri yang wujud secara endemik dalam pulangan mata wang kripto.

Model kopula menyelesaikan masalah ini dengan memisahkan gelagat marginal (bagaimana setiap aset berkelakuan secara individu) daripada struktur kebergantungan (bagaimana aset bergerak bersama-sama). Pemisahan ini, yang berasaskan teorem Sklar, memberikan kita rangka kerja yang fleksibel untuk memodelkan taburan bersama penuh pulangan portfolio — termasuk ekor di mana risiko sebenarnya berada.

Mengapa Korelasi Linear Gagal untuk Kripto

Pertimbangkan portfolio BTC, ETH, SOL, dan AVAX. Semasa kejatuhan Terra/Luna pada Mei 2022, korelasi antara aset-aset ini menghampiri 1.0, tepat pada saat kepelbagaian paling diperlukan. Pengoptimum min-varians yang mengandaikan korelasi stabil akan merendah-anggari risiko portfolio secara dramatik.

Masalah teras korelasi Pearson untuk kripto:

1. Taburan bukan eliptikal. Pulangan kripto mempamerkan kecondongan dan kurtosis yang ketara. Pulangan harian BTC secara konsisten menunjukkan nilai kurtosis melebihi 10 (taburan normal: 3).
2. Kebergantungan asimetri. Aset cenderung lebih berkorelasi semasa penurunan berbanding semasa kenaikan. Fenomena "pecahan korelasi" ini telah didokumentasikan dengan baik dalam pasaran ekuiti dan lebih ketara dalam kripto.
3. Kebergantungan ekor. Kebarangkalian bahawa dua aset secara serentak mengalami kerugian ekstrem tidak ditangkap oleh korelasi linear. Anda boleh mempunyai dua aset dengan korelasi yang sama tetapi kebergantungan ekor yang sangat berbeza.

Teorem Sklar: Asas Teori

Teorem Sklar (1959) menyatakan bahawa mana-mana taburan bersama multivariat $F(x_1, x_2, \ldots, x_d)$ boleh didekomposisikan kepada:

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

di mana $F_i$ adalah fungsi taburan marginal dan $C: [0,1]^d \to [0,1]$ adalah kopula — fungsi yang mengenkod keseluruhan struktur kebergantungan antara pemboleh ubah.

Sebaliknya, jika marginal adalah selanjar, kopula $C$ adalah unik.

Penguraian ini berkuasa kerana ia membolehkan kita:

• Memodelkan taburan marginal setiap aset secara berasingan (menggunakan GARCH, EVT, atau sebarang taburan yang sesuai)
• Memodelkan struktur kebergantungan secara bebas melalui kopula
• Menggabungkannya untuk mendapatkan taburan bersama penuh

Ketumpatan taburan bersama difaktorkan sebagai:

$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)$

di mana $c$ adalah ketumpatan kopula dan $f_i$ adalah ketumpatan marginal.

Keluarga Kopula dan Sifat-Sifatnya

Kopula Gaussian

Kopula Gaussian diparameterkan oleh matriks korelasi $\Sigma$:

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

di mana $\Phi_{\Sigma}$ adalah CDF normal multivariat dan $\Phi^{-1}$ adalah fungsi kuantil normal univariat.

Kebergantungan ekor: $\lambda_L = \lambda_U = 0$ (untuk $\rho < 1$).

Kopula Gaussian mempunyai kebergantungan ekor sifar — ia secara sistematik merendah-anggari kebarangkalian peristiwa ekstrem bersama. Ini merupakan faktor utama dalam salah penetapan harga CDO sebelum 2008, dan ia sama bahayanya untuk pemodelan risiko kripto.

Kopula t-Student

Kopula t memperkenalkan kebergantungan ekor simetri melalui parameter darjah kebebasan $\nu$:

$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)$

Kebergantungan ekor:

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

Untuk $\nu = 4$ dan $\rho = 0.5$, ini memberikan $\lambda \approx 0.18$ — kebarangkalian 18% bahawa kedua-dua aset berada dalam kuantil terburuk mereka secara serentak. $\nu$ yang lebih rendah (ekor lebih berat) meningkatkan kebarangkalian ini. Pasaran kripto, dengan pulangan berekor tebal, biasanya memerlukan $\nu$ dalam julat 3-8.

Kopula t adalah peningkatan ketara berbanding Gaussian, tetapi ia menguatkuasakan kebergantungan ekor simetri ($\lambda_L = \lambda_U$). Dalam praktik, aset kripto sering mempamerkan kebergantungan ekor bawah yang lebih kuat (jatuh bersama) berbanding kebergantungan ekor atas (naik bersama).

Kopula Clayton

Kopula Clayton menangkap kebergantungan ekor bawah — tepat jenis gelagat pengelompokan kejatuhan asimetri yang kita lihat dalam kripto:

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

Kebergantungan ekor: $\lambda_L = 2^{-1/\theta}$, $\lambda_U = 0$.

Apabila $\theta$ meningkat, kebergantungan ekor bawah menguat. Untuk $\theta = 2$, $\lambda_L \approx 0.71$ — kebarangkalian yang sangat tinggi untuk kerugian ekstrem bersama.

Kopula Gumbel

Kopula Gumbel adalah cermin imej — ia menangkap kebergantungan ekor atas:

$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$

Kebergantungan ekor: $\lambda_L = 0$, $\lambda_U = 2 - 2^{1/\theta}$.

Kopula Frank

Kopula Frank mempunyai kebergantungan ekor sifar di kedua-dua ekor ($\lambda_L = \lambda_U = 0$), menjadikannya sesuai untuk memodelkan kebergantungan dalam bahagian tengah taburan tanpa kesan ekor:

$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)$

Memilih Kopula yang Tepat untuk Kripto

Untuk portfolio kripto, bukti empirikal menunjukkan kepada:

• Clayton atau Gumbel diputar (survival Gumbel) untuk kebergantungan ekor bawah — menangkap wabak kejatuhan
• Kopula t sebagai pilihan tujuan umum yang kukuh apabila kebergantungan ekor simetri boleh diterima
• Kopula Joe untuk menangkap kebergantungan ekor atas yang kuat semasa fasa kenaikan

Penyelidikan oleh Bruhn dan Jeleskovic (2024) mendapati bahawa model GARCH-kopula, khususnya yang menggunakan marginal t-Student dengan kopula t, secara konsisten mengatasi pendekatan min-varians dan CVaR sejarah merentas keadaan pasaran penurunan (2022), pemulihan (2023), dan kestabilan (2024) dalam kripto.

Kutukan Dimensionaliti: Vine Kopula

Kopula multivariat standard (Gaussian, kopula t) berskala ke dimensi tinggi tetapi mengenakan andaian yang ketat. Kopula Archimedean (Clayton, Gumbel, Frank) secara semula jadi adalah bivariat — memanjangkannya ke dimensi $d > 2$ memerlukan semua pasangan berkongsi parameter kebergantungan yang sama, yang tidak realistik.

Vine kopula menyelesaikan masalah ini dengan menguraikan kopula $d$-dimensi kepada rangkaian kopula bivariat yang disusun dalam struktur pokok. Setiap pasangan pemboleh ubah (bersyarat pada yang lain) mendapat keluarga kopula bivariat dan parameternya sendiri.

Pembinaan Pasangan-Kopula

Untuk ketumpatan $d$-dimensi, faktorisasi vine kopula adalah:

$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}$

di mana $c_{i,j|S}$ adalah ketumpatan kopula bivariat untuk pemboleh ubah $i$ dan $j$ bersyarat pada set $S$.

Vine kopula $d$-dimensi memerlukan $\binom{d}{2} = d(d-1)/2$ kopula bivariat. Untuk portfolio kripto 10 aset, itu adalah 45 kopula pasangan — masing-masing berpotensi dari keluarga yang berbeza.

Struktur Vine: C-Vine, D-Vine, R-Vine

C-vine (vine kanonik): Setiap pokok mempunyai nod akar tunggal yang disambungkan ke semua nod lain. Terbaik apabila satu pemboleh ubah mendominasi — contohnya, BTC sebagai pemacu pasaran.

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 (vine boleh lukis): Struktur laluan berurutan. Terbaik apabila pemboleh ubah mempunyai susunan semula jadi (contohnya, mengikut permodalan pasaran atau sektor).

R-vine (vine biasa): Struktur paling umum — sebarang urutan pokok yang sah. R-vine merangkumi kedua-dua C-vine dan D-vine.

Penyelidikan mengenai portfolio mata wang kripto mencadangkan bahawa struktur D-vine sering menghasilkan ramalan VaR yang lebih unggul berbanding C-vine dan R-vine untuk aset kripto, walaupun ini bergantung pada komposisi portfolio tertentu.

Mengapa Vine Kopula Penting untuk Kripto

Portfolio 8 aset kripto yang dimodelkan dengan satu kopula Clayton memaksa semua 28 pasangan berkongsi $\theta$ yang sama. Tetapi BTC-ETH mungkin mempunyai $\theta_{\text{Clayton}} = 3.5$ (kebergantungan kejatuhan yang kuat) manakala SOL-AVAX mungkin mempunyai $\theta = 1.2$ (sederhana). Vine kopula membenarkan setiap pasangan mengungkapkan struktur kebergantungan tersendiri:

• BTC-ETH: kopula t ($\nu=4$, $\rho=0.72$)
• BTC-SOL: Clayton ($\theta=2.1$)
• ETH-AVAX: Frank ($\theta=5.3$)
• SOL-DOT | BTC: Gumbel ($\theta=1.8$)

Fleksibiliti ini adalah kritikal untuk anggaran risiko portfolio yang tepat.

Pemodelan Marginal: GARCH-EVT

Sebelum memasang kopula, kita perlu mentransformasikan siri pulangan setiap aset kepada pemboleh ubah seragam $[0,1]$ (transformasi integral kebarangkalian). Saluran paip standard:

1. Pasangkan model GARCH kepada siri pulangan setiap aset untuk menangkap turun naik yang berubah mengikut masa
2. Ekstrak residual terpiawai $z_t = (r_t - \mu_t) / \sigma_t$
3. Pasangkan ekor menggunakan Teori Nilai Ekstrem (EVT) — khususnya, Taburan Pareto Teritlak (GPD) untuk ekor atas dan bawah melampaui ambang (biasanya persentil ke-5 dan ke-95)
4. Gunakan CDF empirikal untuk bahagian tengah taburan
5. Gunakan transformasi integral kebarangkalian untuk mendapatkan pemerhatian pseudo-seragam $u_{i,t} = \hat{F}_i(z_{i,t})$

Pendekatan GARCH-EVT ini sering dipanggil kaedah "separa-parametrik". Ia menangkap dengan betul:

• Pengelompokan turun naik (GARCH)
• Ekor berat (GPD daripada EVT)
• Bentuk keseluruhan taburan (CDF empirikal untuk bahagian tengah)

Untuk aset kripto, model EGARCH(1,1) atau GJR-GARCH(1,1) dengan inovasi t-Student cenderung berfungsi dengan baik, kerana ia menangkap tindak balas turun naik asimetri (berita buruk meningkatkan turun naik lebih daripada berita baik).

VaR dan CVaR Portfolio dengan Kopula

Value-at-Risk (VaR)

VaR portfolio pada aras keyakinan $\alpha$ adalah:

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

di mana $L$ adalah kerugian portfolio. Dengan kopula, kita menganggar VaR melalui Monte Carlo:

1. Simulasikan $N$ sampel daripada vine kopula yang dipasang (dalam ruang seragam)
2. Transformasi balik ke ruang pulangan menggunakan CDF marginal songsang
3. Kira pulangan portfolio: $r_p = \sum_i w_i \cdot r_i$
4. VaR adalah kuantil-$\alpha$ daripada taburan kerugian portfolio yang disimulasikan

Nilai-at-Risiko Bersyarat (CVaR / Kekurangan Jangkaan)

CVaR adalah kerugian jangkaan yang diberikan kerugian melebihi VaR:

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

CVaR adalah koheren (memenuhi sub-kebolehsetambahan), menjadikannya lebih unggul daripada VaR untuk pengoptimuman portfolio. Anggaran Monte Carlo adalah mudah — puratakan kerugian yang melebihi VaR.

Mengapa Risiko Berasaskan Kopula Mengatasi Risiko Berasaskan Korelasi

Pertimbangkan dua portfolio dengan korelasi pasangan yang sama sebesar 0.5:

• Portfolio A: Kebergantungan kopula Gaussian (tiada kebergantungan ekor)
• Portfolio B: Kebergantungan kopula Clayton ($\theta = 2$, $\lambda_L = 0.71$)

Pada aras keyakinan 99%, Portfolio B akan mempunyai VaR dan CVaR yang lebih tinggi secara signifikan kerana kopula Clayton dengan betul memodelkan kecenderungan aset untuk jatuh bersama. Kopula Gaussian merendah-anggari risiko ini dengan mengandaikan bahawa pergerakan bersama yang ekstrem adalah sangat jarang berlaku.

Dalam kajian empirikal mengenai portfolio kripto, perbezaan dalam CVaR 99% antara model Gaussian dan vine kopula boleh melebihi 30-40%, bermakna model berasaskan korelasi mungkin merendah-anggari risiko ekor sebanyak sepertiga atau lebih.

Pelaksanaan: Python dengan pyvinecopulib

Berikut adalah saluran paip lengkap untuk memasang vine kopula kepada pulangan kripto dan menganggar VaR/CVaR portfolio.

Langkah 1: Penyediaan Data dan Pemasangan Marginal

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()

Langkah 2: Transformasi Integral Kebarangkalian

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
])

Langkah 3: Pasangkan Vine Kopula

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

Langkah 4: VaR dan CVaR Monte Carlo

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

Langkah 5: Analisis Kebergantungan Ekor

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))

Output tipikal untuk portfolio kripto mungkin kelihatan seperti:

Perhatikan bagaimana setiap pasangan boleh mempunyai struktur kebergantungan yang sama sekali berbeza. BTC-SOL menunjukkan kebergantungan ekor bawah yang kuat (Clayton) dengan kebergantungan ekor atas sifar — mereka jatuh bersama tetapi tidak semestinya naik bersama. BTC-MATIC tidak menunjukkan sebarang kebergantungan ekor (Frank), mencadangkan beberapa manfaat kepelbagaian walaupun dalam keadaan ekstrem.

Ujian Belakang Model VaR Kopula

Model VaR hanya berguna jika ia terkalibrasi dengan baik. Ujian belakang standard mengira pelanggaran VaR — hari-hari apabila kerugian sebenar melebihi VaR yang diramalkan — dan menguji sama ada kadar pelanggaran sepadan dengan kadar yang dijangkakan.

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

Model VaR 99% yang terkalibrasi dengan baik sepatutnya mempunyai kadar pelanggaran yang hampir 1%. Jika kadarnya jauh lebih tinggi, model merendah-anggari risiko. Jika jauh lebih rendah, ia terlalu konservatif.

Pertimbangan Praktikal

Kos Pengiraan

Pemasangan vine kopula adalah $O(d^2 \cdot n)$ setiap tahap pokok. Untuk portfolio 10 aset dengan tetingkap gelundur 500 hari, ujian belakang penuh dengan 50,000 simulasi Monte Carlo setiap langkah boleh mengambil masa berjam-jam. Strategi untuk mengurus ini:

• Vine terpotong: Tetapkan trunc_lvl=3 atau trunc_lvl=4 — pokok yang lebih tinggi menangkap kebergantungan bersyarat yang lebih lemah yang kurang menyumbang kepada risiko
• Kiraan simulasi yang dikurangkan: 10,000-20,000 simulasi sering mencukupi untuk VaR 99%
• Pengiraan selari: Pemasangan GARCH untuk setiap aset adalah bebas dan boleh diparalelkan
• Caching model: Pasang semula kopula setiap minggu dan bukannya setiap hari, hanya mengemas kini ramalan GARCH

Kesedaran Rejim

Pasaran kripto mempamerkan rejim yang berbeza (naik, turun, mendatar, peristiwa turun naik tinggi). Satu vine kopula yang dipasang ke seluruh sampel mungkin tidak menangkap kebergantungan bergantung rejim. Pertimbangkan:

• Tetingkap gelundur 250-500 hari
• Kopula pensuisan rejim di mana parameter kopula bergantung pada keadaan Markov tersembunyi
• Pemerhatian berwajaran eksponen yang memberikan lebih banyak berat kepada data terbaru

Perangkap Biasa

1. Melupakan PIT. Memasukkan pulangan mentah terus ke dalam kopula dan bukannya pemerhatian pseudo-seragam akan menghasilkan keputusan yang tidak bermakna. Sentiasa transformasikan ke margin seragam terlebih dahulu.
2. Overfitting dengan terlalu banyak keluarga. Memasukkan setiap keluarga bivariat yang mungkin dalam set pemilihan boleh membawa kepada overfitting, terutamanya dengan sampel pendek. Gunakan BIC untuk pemilihan model dan pertimbangkan untuk mengehadkan kepada 4-5 keluarga.
3. Mengabaikan kebergantungan siri. Kopula memodelkan kebergantungan rentas keratan pada satu titik masa. Jika anda melangkau langkah GARCH dan memasukkan pulangan autoberkorelasi ke dalam kopula, kebergantungan yang dianggar akan dicemari oleh kesan siri.
4. Kopula statik dalam pasaran dinamik. Kopula yang dipasang pada data pasaran naik 2021 akan terkalibrasi dengan buruk untuk kejatuhan 2022. Sentiasa gunakan tetingkap gelundur atau mengembang.

Kesimpulan

Model kopula — khususnya vine kopula — menyediakan rangka kerja yang ketat secara matematik untuk memodelkan risiko bersama portfolio kripto yang jauh melampaui apa yang dapat ditangkap oleh korelasi linear. Kelebihan utama:

• Pemodelan marginal dan kebergantungan yang berasingan melalui teorem Sklar
• Kebergantungan ekor yang fleksibel melalui pemilihan keluarga kopula yang sesuai (Clayton untuk wabak kejatuhan, Gumbel untuk pergerakan bersama kenaikan, kopula t untuk ekor simetri)
• Kebolehskalaan dimensi tinggi melalui penguraian vine kopula, di mana setiap pasangan aset mendapat kopula bivariatnya sendiri
• Anggaran VaR/CVaR yang tepat yang mengambil kira kebergantungan bukan linear dan asimetri — kritikal untuk pengurusan risiko dalam pasaran di mana "segala-galanya jatuh bersama" adalah norma, bukan pengecualian

Saluran paip GARCH-EVT-Kopula kini merupakan pendekatan standard di dana lindung nilai kuantitatif dan meja risiko yang berfokus kepada kripto. Dengan perpustakaan seperti pyvinecopulib, halangan pelaksanaan cukup rendah sehingga mana-mana peniaga sistematik boleh mengintegrasikan pemodelan risiko berasaskan kopula ke dalam aliran kerja pengurusan portfolio mereka.

Kod dalam artikel ini menyediakan titik permulaan yang berfungsi. Untuk penggunaan pengeluaran, anda akan menambah pengesahan silang yang betul untuk pemilihan tertib GARCH, model marginal yang lebih canggih (contohnya, EGARCH dengan kesan leveraj, atau ukuran turun naik yang direalisasikan menggunakan data intrahari), dan ujian tekanan di bawah parameter kopula hipotetik yang dikalibrasi kepada episod krisis sejarah.

Rujukan

• 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.