Model Copula untuk Pemodelan Risiko Gabungan pada Portofolio Kripto

Korelasi adalah alat pertama yang paling banyak digunakan oleh manajer portofolio dalam menilai diversifikasi. Namun di pasar kripto, korelasi bisa sangat menyesatkan. Dua token mungkin menunjukkan korelasi Pearson sebesar 0,3 saat pasar tenang, lalu melonjak hingga 0,95 saat terjadi crash. Korelasi linear mengasumsikan distribusi eliptikal — asumsi yang runtuh ketika berhadapan dengan ekor tebal dan struktur ketergantungan asimetris yang menjadi ciri khas imbal hasil mata uang kripto.

Model copula memecahkan masalah ini dengan memisahkan perilaku marginal (bagaimana setiap aset berperilaku secara individual) dari struktur ketergantungan (bagaimana aset-aset bergerak bersama). Pemisahan ini, yang berakar pada teorema Sklar, memberi kita kerangka kerja yang fleksibel untuk memodelkan distribusi gabungan penuh imbal hasil portofolio — termasuk di bagian ekor tempat risiko sesungguhnya berada.

Mengapa Korelasi Linear Gagal untuk Kripto

Bayangkan sebuah portofolio yang terdiri dari BTC, ETH, SOL, dan AVAX. Selama keruntuhan Terra/Luna pada Mei 2022, korelasi antara aset-aset ini konvergen mendekati 1,0 — tepat pada saat diversifikasi paling dibutuhkan. Pengoptimal mean-variance yang mengasumsikan korelasi stabil akan sangat meremehkan risiko portofolio.

Masalah utama korelasi Pearson untuk kripto:

1. Distribusi non-eliptikal. Imbal hasil kripto menunjukkan skewness dan kurtosis yang signifikan. Imbal hasil harian BTC secara rutin menunjukkan nilai kurtosis di atas 10 (distribusi normal: 3).
2. Ketergantungan asimetris. Aset-aset cenderung lebih berkorelasi saat terjadi penurunan dibandingkan saat rally. Fenomena "penurunan korelasi" ini terdokumentasi dengan baik di pasar ekuitas dan bahkan lebih menonjol di pasar kripto.
3. Ketergantungan ekor. Probabilitas bahwa dua aset secara bersamaan mengalami kerugian ekstrem tidak tertangkap oleh korelasi linear. Dua aset dapat memiliki korelasi yang identik namun ketergantungan ekor yang sangat berbeda.

Teorema Sklar: Fondasi

Teorema Sklar (1959) menyatakan bahwa setiap distribusi gabungan multivariat $F(x_1, x_2, \ldots, x_d)$ dapat diuraikan menjadi:

$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 distribusi marginal dan $C: [0,1]^d \to [0,1]$ adalah copula — sebuah fungsi yang mengkodekan seluruh struktur ketergantungan antarvariabel.

Sebaliknya, jika marginal bersifat kontinu, copula $C$ bersifat unik.

Dekomposisi ini sangat kuat karena memungkinkan kita untuk:

• Memodelkan distribusi marginal setiap aset secara terpisah (menggunakan GARCH, EVT, atau distribusi apa pun yang sesuai)
• Memodelkan struktur ketergantungan secara independen melalui copula
• Menggabungkan keduanya untuk mendapatkan distribusi gabungan penuh

Densitas distribusi gabungan terfaktorkan 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 densitas copula dan $f_i$ adalah densitas marginal.

Keluarga Copula dan Sifat-sifatnya

Copula Gaussian

Copula Gaussian diparameterisasi 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.

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

Copula Gaussian memiliki ketergantungan ekor nol — ia secara sistematis meremehkan probabilitas kejadian ekstrem gabungan. Hal ini merupakan faktor kunci dalam kesalahan penetapan harga CDO sebelum 2008, dan sama berbahayanya untuk pemodelan risiko kripto.

Copula t Student

Copula t memperkenalkan ketergantungan ekor simetris melalui parameter derajat 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)$

Ketergantungan 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 menghasilkan $\lambda \approx 0,18$ — probabilitas 18% bahwa kedua aset berada pada kuantil terburuk secara bersamaan. Nilai $\nu$ yang lebih rendah (ekor lebih tebal) meningkatkan probabilitas ini. Pasar kripto, dengan imbal hasil berekor tebal, biasanya memerlukan $\nu$ dalam kisaran 3-8.

Copula t merupakan peningkatan signifikan dibandingkan Gaussian, tetapi memberlakukan ketergantungan ekor yang simetris ($\lambda_L = \lambda_U$). Dalam praktiknya, aset kripto sering menunjukkan ketergantungan ekor bawah yang lebih kuat (crash bersama) dibandingkan ketergantungan ekor atas (rally bersama).

Copula Clayton

Copula Clayton menangkap ketergantungan ekor bawah — persis jenis perilaku pengelompokan crash asimetris yang kita lihat di kripto:

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

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

Seiring meningkatnya $\theta$, ketergantungan ekor bawah semakin kuat. Untuk $\theta = 2$, $\lambda_L \approx 0,71$ — probabilitas sangat tinggi untuk kerugian ekstrem gabungan.

Copula Gumbel

Copula Gumbel adalah bayangan cermin — ia menangkap ketergantungan 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$

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

Copula Frank

Copula Frank memiliki ketergantungan ekor nol di kedua ekor ($\lambda_L = \lambda_U = 0$), sehingga cocok untuk memodelkan ketergantungan di bagian tengah distribusi tanpa efek 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 Copula yang Tepat untuk Kripto

Untuk portofolio kripto, bukti empiris menunjukkan:

• Clayton atau Gumbel yang dirotasi (survival Gumbel) untuk ketergantungan ekor bawah — menangkap penularan crash
• Copula t sebagai pilihan serbaguna yang andal ketika ketergantungan ekor simetris dapat diterima
• Copula Joe untuk menangkap ketergantungan ekor atas yang kuat pada fase rally

Penelitian oleh Bruhn dan Jeleskovic (2024) menemukan bahwa model GARCH-copula, khususnya yang menggunakan marginal t Student dengan copula t, secara konsisten mengungguli pendekatan mean-variance dan historical CVaR di berbagai kondisi pasar kripto — penurunan (2022), pemulihan (2023), dan stabilitas (2024).

Kutukan Dimensionalitas: Hadirnya Vine Copula

Copula multivariat standar (Gaussian, copula t) dapat diskalakan ke dimensi tinggi namun memberlakukan asumsi yang membatasi. Copula Archimedean (Clayton, Gumbel, Frank) secara alami bersifat bivariat — memperluas keduanya ke dimensi $d > 2$ mengharuskan semua pasangan berbagi parameter ketergantungan yang sama, yang tidak realistis.

Vine copula memecahkan masalah ini dengan menguraikan copula berdimensi $d$ menjadi serangkaian copula bivariat yang disusun dalam struktur pohon. Setiap pasangan variabel (bersyarat pada yang lain) mendapatkan keluarga copula bivariat dan parameternya sendiri.

Konstruksi Pair-Copula

Untuk densitas berdimensi $d$, faktorisasi vine copula 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 densitas copula bivariat untuk variabel $i$ dan $j$ yang dikondisikan pada himpunan $S$.

Vine copula berdimensi $d$ memerlukan $\binom{d}{2} = d(d-1)/2$ copula bivariat. Untuk portofolio kripto 10 aset, itu berarti 45 pair copula — masing-masing berpotensi berasal dari keluarga yang berbeda.

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

C-vine (Canonical vine): Setiap pohon memiliki satu simpul akar yang terhubung ke semua simpul lainnya. Paling baik ketika satu variabel mendominasi — misalnya, BTC sebagai penggerak pasar.

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 (Drawable vine): Struktur jalur sekuensial. Paling baik ketika variabel memiliki urutan alami (misalnya, berdasarkan kapitalisasi pasar atau sektor).

R-vine (Regular vine): Struktur paling umum — urutan pohon mana pun yang valid. R-vine mencakup baik C-vine maupun D-vine.

Penelitian pada portofolio mata uang kripto menunjukkan bahwa struktur D-vine sering menghasilkan prakiraan VaR yang lebih unggul dibandingkan C-vine dan R-vine untuk aset kripto, meskipun hal ini bergantung pada komposisi portofolio tertentu.

Mengapa Vine Copula Penting untuk Kripto

Portofolio yang terdiri dari 8 aset kripto yang dimodelkan dengan satu copula Clayton memaksa semua 28 pasangan untuk berbagi $\theta$ yang sama. Namun BTC-ETH mungkin memiliki $\theta_{\text{Clayton}} = 3,5$ (ketergantungan crash yang kuat) sementara SOL-AVAX mungkin memiliki $\theta = 1,2$ (sedang). Vine copula memungkinkan setiap pasangan mengekspresikan struktur ketergantungannya sendiri:

• BTC-ETH: copula 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$)

Fleksibilitas ini sangat penting untuk estimasi risiko portofolio yang akurat.

Memodelkan Marginal: GARCH-EVT

Sebelum menyesuaikan copula, kita perlu mentransformasi deret imbal hasil setiap aset menjadi variabel seragam $[0,1]$ (transformasi integral probabilitas). Pipeline standarnya:

1. Sesuaikan model GARCH pada deret imbal hasil setiap aset untuk menangkap volatilitas yang bervariasi terhadap waktu
2. Ekstrak residual yang dinormalisasi $z_t = (r_t - \mu_t) / \sigma_t$
3. Sesuaikan ekor menggunakan Teori Nilai Ekstrem (EVT) — khususnya, Distribusi Pareto Umum (GPD) untuk ekor atas dan bawah di luar ambang batas (biasanya persentil ke-5 dan ke-95)
4. Gunakan CDF empiris untuk bagian tengah distribusi
5. Terapkan transformasi integral probabilitas untuk mendapatkan observasi pseudo-seragam $u_{i,t} = \hat{F}_i(z_{i,t})$

Pendekatan GARCH-EVT ini sering disebut metode "semi-parametrik". Metode ini menangkap dengan tepat:

• Pengelompokan volatilitas (GARCH)
• Ekor tebal (GPD dari EVT)
• Bentuk keseluruhan distribusi (CDF empiris untuk bagian tengah)

Untuk aset kripto, model EGARCH(1,1) atau GJR-GARCH(1,1) dengan inovasi t Student cenderung bekerja dengan baik, karena menangkap respons volatilitas asimetris (berita buruk meningkatkan volatilitas lebih banyak daripada berita baik).

VaR dan CVaR Portofolio dengan Copula

Value-at-Risk (VaR)

VaR portofolio pada tingkat kepercayaan $\alpha$ adalah:

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

di mana $L$ adalah kerugian portofolio. Dengan copula, kita mengestimasi VaR melalui Monte Carlo:

1. Simulasi $N$ sampel dari vine copula yang telah disesuaikan (dalam ruang seragam)
2. Transformasi kembali ke ruang imbal hasil menggunakan invers CDF marginal
3. Hitung imbal hasil portofolio: $r_p = \sum_i w_i \cdot r_i$
4. VaR adalah kuantil $\alpha$ dari distribusi kerugian portofolio yang disimulasikan

Conditional Value-at-Risk (CVaR / Expected Shortfall)

CVaR adalah kerugian yang diharapkan dengan syarat 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 bersifat koheran (memenuhi sub-aditivitas), sehingga lebih unggul dari VaR untuk optimasi portofolio. Estimasi Monte Carlo sangat mudah — rata-rata kerugian yang melebihi VaR.

Mengapa Risiko Berbasis Copula Lebih Baik dari Risiko Berbasis Korelasi

Pertimbangkan dua portofolio dengan korelasi berpasangan yang identik sebesar 0,5:

• Portofolio A: Ketergantungan copula Gaussian (tanpa ketergantungan ekor)
• Portofolio B: Ketergantungan copula Clayton ($\theta = 2$, $\lambda_L = 0,71$)

Pada tingkat kepercayaan 99%, Portofolio B akan memiliki VaR dan CVaR yang secara signifikan lebih tinggi karena copula Clayton secara tepat memodelkan kecenderungan aset untuk crash bersama. Copula Gaussian meremehkan risiko ini dengan mengasumsikan bahwa gerakan bersama yang ekstrem hampir tidak pernah terjadi.

Dalam studi empiris pada portofolio kripto, perbedaan CVaR 99% antara model Gaussian dan vine copula dapat melebihi 30-40%, artinya model berbasis korelasi dapat meremehkan risiko ekor hingga sepertiga atau lebih.

Implementasi: Python dengan pyvinecopulib

Berikut adalah pipeline lengkap untuk menyesuaikan vine copula pada imbal hasil kripto dan mengestimasi VaR/CVaR portofolio.

Langkah 1: Persiapan Data dan Penyesuaian 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 Probabilitas

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: Sesuaikan Vine Copula

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 Ketergantungan 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 portofolio kripto mungkin terlihat seperti ini:

Perhatikan bagaimana setiap pasangan dapat memiliki struktur ketergantungan yang sepenuhnya berbeda. BTC-SOL menunjukkan ketergantungan ekor bawah yang kuat (Clayton) dengan ketergantungan ekor atas nol — keduanya crash bersama tetapi tidak selalu rally bersama. BTC-MATIC tidak menunjukkan ketergantungan ekor sama sekali (Frank), yang menunjukkan adanya manfaat diversifikasi bahkan di kondisi ekstrem.

Backtesting Model VaR Copula

Model VaR hanya berguna jika terkalibrasi dengan baik. Backtest standar menghitung pelanggaran VaR — hari-hari ketika kerugian aktual melebihi VaR yang diprediksi — dan menguji apakah tingkat pelanggaran sesuai dengan tingkat yang diharapkan.

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 seharusnya memiliki tingkat pelanggaran mendekati 1%. Jika tingkatnya jauh lebih tinggi, model meremehkan risiko. Jika jauh lebih rendah, model terlalu konservatif.

Pertimbangan Praktis

Biaya Komputasi

Penyesuaian vine copula adalah $O(d^2 \cdot n)$ per tingkat pohon. Untuk portofolio 10 aset dengan jendela bergulir 500 hari, backtest penuh dengan 50.000 simulasi Monte Carlo per langkah dapat memakan waktu berjam-jam. Strategi untuk mengelola ini:

• Vine terpotong: Atur trunc_lvl=3 atau trunc_lvl=4 — pohon yang lebih tinggi menangkap ketergantungan kondisional yang lebih lemah yang berkontribusi lebih sedikit pada risiko
• Jumlah simulasi yang dikurangi: 10.000-20.000 simulasi sering sudah cukup untuk VaR 99%
• Komputasi paralel: Penyesuaian GARCH untuk setiap aset bersifat independen dan dapat diparalelkan
• Caching model: Sesuaikan ulang copula setiap minggu daripada setiap hari, hanya memperbarui prakiraan GARCH

Kesadaran Rezim

Pasar kripto menunjukkan rezim yang berbeda (bull, bear, sideways, peristiwa volatilitas tinggi). Satu vine copula yang disesuaikan pada seluruh sampel mungkin tidak menangkap ketergantungan yang bergantung pada rezim. Pertimbangkan:

• Jendela bergulir 250-500 hari
• Copula dengan pergantian rezim di mana parameter copula bergantung pada status Markov tersembunyi
• Observasi berbobot eksponensial yang memberikan bobot lebih besar pada data terbaru

Jebakan Umum

1. Melupakan PIT. Memasukkan imbal hasil mentah langsung ke dalam copula alih-alih observasi pseudo-seragam akan menghasilkan hasil yang tidak bermakna. Selalu transformasikan ke margin seragam terlebih dahulu.
2. Overfitting dengan terlalu banyak keluarga. Menyertakan setiap keluarga bivariat yang mungkin dalam set seleksi dapat menyebabkan overfitting, terutama dengan sampel yang pendek. Gunakan BIC untuk pemilihan model dan pertimbangkan pembatasan pada 4-5 keluarga.
3. Mengabaikan ketergantungan serial. Copula memodelkan ketergantungan lintas-seksi pada satu titik waktu. Jika Anda melewatkan langkah GARCH dan memasukkan imbal hasil yang terautokorelasi ke dalam copula, ketergantungan yang diestimasi akan terkontaminasi oleh efek serial.
4. Copula statis di pasar yang dinamis. Copula yang disesuaikan pada data pasar bull 2021 akan dikalibrasi dengan buruk untuk crash 2022. Selalu gunakan jendela bergulir atau yang terus berkembang.

Kesimpulan

Model copula — khususnya vine copula — menyediakan kerangka kerja yang matematis ketat untuk memodelkan risiko gabungan portofolio kripto yang jauh melampaui apa yang dapat ditangkap oleh korelasi linear. Keunggulan utamanya:

• Pemodelan marginal dan ketergantungan yang terpisah melalui teorema Sklar
• Ketergantungan ekor yang fleksibel melalui pemilihan keluarga copula yang tepat (Clayton untuk penularan crash, Gumbel untuk ko-pergerakan rally, copula t untuk ekor simetris)
• Skalabilitas dimensi tinggi melalui dekomposisi vine copula, di mana setiap pasangan aset mendapatkan copula bivariate-nya sendiri
• Estimasi VaR/CVaR yang akurat yang memperhitungkan ketergantungan non-linear dan asimetris — sangat penting untuk manajemen risiko di pasar di mana "semua crash bersama" adalah norma, bukan pengecualian

Pipeline GARCH-EVT-Copula kini menjadi pendekatan standar di dana lindung nilai kuantitatif dan meja risiko yang berfokus pada kripto. Dengan pustaka seperti pyvinecopulib, hambatan implementasi cukup rendah sehingga setiap trader sistematis dapat mengintegrasikan pemodelan risiko berbasis copula ke dalam alur kerja manajemen portofolio mereka.

Kode dalam artikel ini menyediakan titik awal yang berfungsi. Untuk penggunaan produksi, Anda perlu menambahkan validasi silang yang tepat untuk pemilihan orde GARCH, model marginal yang lebih canggih (misalnya, EGARCH dengan efek leverage, atau ukuran volatilitas yang direalisasikan menggunakan data intraday), dan pengujian stres di bawah parameter copula hipotetis yang dikalibrasi pada episode krisis historis.

Referensi

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