Kripto portfellarida birgalikdagi xavfni modellashtirish uchun kopula modellari

Korrelyatsiya — diversifikatsiyani baholashda ko'pchilik portfel menejerlari birinchi murojaat qiladigan vositadir. Ammo kripto bozorlarida korrelyatsiya xavfli tarzda chalg'ituvchi bo'ladi. Ikkita token tinch bozorlarda 0.3 Pirson korrelyatsiyasini ko'rsatishi mumkin, keyin qulash paytida 0.95 gacha sakrab chiqishi mumkin. Chiziqli korrelyatsiya elliptik taqsimotlarni nazarda tutadi — bu taxmin kriptovalyuta daromadlariga xos og'ir dumlar va assimmetrik bog'liqlik strukturalari ostida qulaydi.

Kopula modellari buni marginal xatti-harakatni (har bir aktiv alohida qanday harakat qilishi) bog'liqlik strukturasidan (aktivlar birgalikda qanday harakatlanishi) ajratish orqali hal qiladi. Sklar teoremasiga asoslangan bu ajratish bizga portfel daromadlarining to'liq birgalikdagi taqsimotini — xavf haqiqatan ham yashaydigan dumlarni ham qo'shgan holda — modellashtirish uchun moslashuvchan asos beradi.

Chiziqli korrelyatsiya nima uchun kripto uchun ishlamaydi

BTC, ETH, SOL va AVAX portfelini ko'rib chiqaylik. 2022-yil may oyida Terra/Luna qulashi paytida bu aktivlar o'rtasidagi korrelyatsiyalar 1.0 ga yaqinlashdi, aynan diversifikatsiya eng zarur bo'lgan paytda. Barqaror korrelyatsiyalarni taxmin qilgan o'rtacha-dispersiya optimallashtiruvchisi portfel xavfini keskin pastroq baholagan bo'lar edi.

Kripto uchun Pirson korrelyatsiyasining asosiy muammolari:

1. Elliptik bo'lmagan taqsimotlar. Kripto daromadlari sezilarli assimmetriya va ekssessni namoyish etadi. BTC kunlik daromadlari muntazam ravishda 10 dan yuqori ekssess qiymatlarini ko'rsatadi (normal taqsimot: 3).
2. Assimmetrik bog'liqlik. Aktivlar o'sish davrlariga qaraganda pasayish davrida ko'proq korrelyatsiyalanadi. Bu "korrelyatsiya buzilishi" hodisasi aksiyalar bozorlarida yaxshi hujjatlashtirilgan va kriptoda yanada aniqroq namoyon bo'ladi.
3. Dum bog'liqligi. Ikki aktivning bir vaqtning o'zida ekstremal zarar ko'rish ehtimoli chiziqli korrelyatsiya bilan aniqlanmaydi. Korrelyatsiyasi bir xil, lekin dum bog'liqligi butunlay boshqacha bo'lgan ikkita aktiv bo'lishi mumkin.

Sklar teoremasi: asos

Sklar teoremasi (1959) har qanday ko'p o'zgaruvchili birgalikdagi taqsimot $F(x_1, x_2, \ldots, x_d)$ quyidagicha ajratilishi mumkinligini bildiradi:

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

bu yerda $F_i$ marginal taqsimot funksiyalari, $C: [0,1]^d \to [0,1]$ esa o'zgaruvchilar orasidagi butun bog'liqlik strukturasini kodlaydigan kopula hisoblanadi.

Aksincha, agar marginallar uzluksiz bo'lsa, kopula $C$ noyob bo'ladi.

Bu ajratish kuchli, chunki u bizga imkon beradi:

• Har bir aktivning marginal taqsimotini alohida modellashtirish (GARCH, EVT yoki mos keladigan boshqa taqsimotdan foydalanib)
• Bog'liqlik strukturasini kopula orqali mustaqil ravishda modellashtirish
• To'liq birgalikdagi taqsimotni olish uchun ularni birlashtirish

Birgalikdagi taqsimot zichligi quyidagicha ko'paytiruvchilarga ajraladi:

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

bu yerda $c$ kopula zichligi, $f_i$ esa marginal zichliklardir.

Kopula oilalari va ularning xususiyatlari

Gauss kopulasi

Gauss kopulasi korrelyatsiya matritsasi $\Sigma$ bilan parametrlanadi:

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

bu yerda $\Phi_{\Sigma}$ ko'p o'zgaruvchili normal CDF, $\Phi^{-1}$ esa bir o'zgaruvchili normal kvantil funksiyasidir.

Dum bog'liqligi: $\lambda_L = \lambda_U = 0$ ($\rho < 1$ uchun).

Gauss kopulasi nol dum bog'liqligiga ega — u birgalikdagi ekstremal hodisalar ehtimolini tizimli ravishda pastroq baholaydi. Bu 2008-yilgacha CDO'larni noto'g'ri narxlashning asosiy omili bo'lgan va kripto xavfini modellashtirish uchun ham xuddi shunday xavflidir.

Styudent t-kopulasi

t-kopula erkinlik darajasi parametri $\nu$ orqali simmetrik dum bog'liqligini kiritadi:

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

Dum bog'liqligi:

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

$\nu = 4$ va $\rho = 0.5$ uchun bu $\lambda \approx 0.18$ ni beradi — ikkala aktivning bir vaqtning o'zida eng yomon kvantilida bo'lish ehtimoli 18%. Pastroq $\nu$ (og'irroq dumlar) bu ehtimolni oshiradi. Yog' dumli daromadlarga ega kripto bozorlari odatda 3-8 oralig'idagi $\nu$ ni talab qiladi.

t-kopula Gaussga nisbatan sezilarli yaxshilanish, lekin u simmetrik dum bog'liqligini ($\lambda_L = \lambda_U$) majburiy qiladi. Amalda kripto aktivlar ko'pincha yuqori dum bog'liqligiga (birgalikda ko'tarilish) qaraganda kuchliroq quyi dum bog'liqligini (birgalikda qulash) namoyish etadi.

Klayton kopulasi

Klayton kopulasi quyi dum bog'liqligini aniqlaydi — bu aynan kriptoda ko'radigan assimmetrik qulash-klasterlanish xatti-harakatidir:

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

Dum bog'liqligi: $\lambda_L = 2^{-1/\theta}$, $\lambda_U = 0$.

$\theta$ ortishi bilan quyi dum bog'liqligi kuchayadi. $\theta = 2$ uchun $\lambda_L \approx 0.71$ — birgalikdagi ekstremal zararlarning juda yuqori ehtimoli.

Gumbel kopulasi

Gumbel kopulasi oyna aksi hisoblanadi — u yuqori dum bog'liqligini aniqlaydi:

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

Dum bog'liqligi: $\lambda_L = 0$, $\lambda_U = 2 - 2^{1/\theta}$.

Frank kopulasi

Frank kopulasi ikkala dumda ham nol dum bog'liqligiga ega ($\lambda_L = \lambda_U = 0$), bu uni dum effektlarisiz taqsimotning asosiy qismidagi bog'liqlikni modellashtirish uchun mos qiladi:

$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 uchun to'g'ri kopulani tanlash

Kripto portfellari uchun empirik dalillar quyidagilarni ko'rsatadi:

• Quyi dum bog'liqligi uchun Klayton yoki aylantirilgan Gumbel (survival Gumbel) — qulash yuqumliligini aniqlash
• Simmetrik dum bog'liqligi qabul qilinadigan bo'lganda ishonchli umumiy maqsadli tanlov sifatida t-kopula
• O'sish fazalarida kuchli yuqori dum bog'liqligini aniqlash uchun Djo kopulasi

Bruhn va Jeleskovic (2024) tadqiqoti GARCH-kopula modellari, xususan Styudent t marginallarini t-kopulalar bilan ishlatuvchilar, kriptoda pasayish (2022), tiklanish (2023) va barqarorlik (2024) bozor sharoitlarida o'rtacha-dispersiya va tarixiy CVaR yondashuvlaridan doimiy ravishda ustun ekanligini aniqladi.

O'lchamlilik la'nati: Vine kopulalari kirib keladi

Standart ko'p o'zgaruvchili kopulalar (Gauss, t-kopula) yuqori o'lchamlarga masshtablanadi, lekin cheklovchi taxminlarni majburiy qiladi. Arximed kopulalari (Klayton, Gumbel, Frank) tabiiy ravishda ikki o'zgaruvchili — ularni $d > 2$ o'lchamlarga kengaytirish barcha juftliklar bir xil bog'liqlik parametrini bo'lishishini talab qiladi, bu esa real emas.

Vine kopulalari $d$-o'lchamli kopulani daraxt strukturasida joylashtirilgan ikki o'zgaruvchili kopulalar kaskadiga ajratish orqali buni hal qiladi. O'zgaruvchilarning har bir jufti (boshqalarga shartli) o'zining ikki o'zgaruvchili kopula oilasi va parametrini oladi.

Juft-kopula konstruksiyasi

$d$-o'lchamli zichlik uchun vine kopula faktorizatsiyasi:

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

bu yerda $c_{i,j|S}$ — $S$ to'plamiga shartli $i$ va $j$ o'zgaruvchilari uchun ikki o'zgaruvchili kopula zichligi.

$d$-o'lchamli vine kopulasi $\binom{d}{2} = d(d-1)/2$ ikki o'zgaruvchili kopulani talab qiladi. 10 aktivli kripto portfeli uchun bu — 45 juft kopula, har biri boshqa oiladan bo'lishi mumkin.

Vine strukturalari: C-vine, D-vine, R-vine

C-vine (kanonik vine): Har bir daraxtda barcha boshqa tugunlar bilan bog'langan bitta ildiz tugun bor. Bitta o'zgaruvchi ustunlik qilganda eng yaxshi — masalan, bozor harakatlantiruvchisi sifatida BTC.

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 (chizib bo'ladigan vine): Ketma-ket yo'l strukturasi. O'zgaruvchilarda tabiiy tartib bo'lganda eng yaxshi (masalan, bozor kapitalizatsiyasi yoki sektor bo'yicha).

R-vine (muntazam vine): Eng umumiy struktura — har qanday yaroqli daraxt ketma-ketligi. R-vine'lar ham C-vine, ham D-vine'ni o'z ichiga oladi.

Kriptovalyuta portfellari bo'yicha tadqiqotlar D-vine strukturalari ko'pincha kripto aktivlar uchun C-vine va R-vine'ga qaraganda yaxshiroq VaR bashoratlarini berishini ko'rsatadi, garchi bu aniq portfel tarkibiga bog'liq bo'lsa-da.

Vine kopulalari nima uchun kripto uchun muhim

Bitta Klayton kopulasi bilan modellashtirilgan 8 ta kripto aktividan iborat portfel barcha 28 juftlikni bir xil $\theta$ ni bo'lishishga majbur qiladi. Lekin BTC-ETH $\theta_{\text{Clayton}} = 3.5$ (kuchli qulash bog'liqligi) ga ega bo'lishi mumkin, SOL-AVAX esa $\theta = 1.2$ (o'rtacha) ga ega bo'lishi mumkin. Vine kopulalari har bir juftlikka o'zining bog'liqlik strukturasini ifodalashga imkon beradi:

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

Bu moslashuvchanlik aniq portfel xavfini baholash uchun juda muhim.

Marginallarni modellashtirish: GARCH-EVT

Kopulani moslashtirishdan oldin, biz har bir aktivning daromad seriyasini bir xil $[0,1]$ o'zgaruvchilarga aylantirishimiz kerak ("ehtimollik integral transformatsiyasi"). Standart konveyer:

1. Vaqt bo'yicha o'zgaruvchan volatillikni aniqlash uchun har bir aktivning daromad seriyasiga GARCH modelini moslashtirish
2. Standartlashtirilgan qoldiqlarni ajratib olish $z_t = (r_t - \mu_t) / \sigma_t$
3. Ekstremal Qiymat Nazariyasi (EVT) yordamida dumlarni moslashtirish — aniqrog'i, chegaradan (odatda 5- va 95-protsentillar) tashqari yuqori va quyi dumlar uchun Umumlashtirilgan Pareto Taqsimoti (GPD)
4. Taqsimotning asosiy qismi uchun empirik CDF dan foydalanish
5. Psevdo-bir xil kuzatuvlarni olish uchun ehtimollik integral transformatsiyasini qo'llash $u_{i,t} = \hat{F}_i(z_{i,t})$

Bu GARCH-EVT yondashuvi ko'pincha "yarim-parametrik" usul deb ataladi. U to'g'ri aniqlaydi:

• Volatillik klasterlanishi (GARCH)
• Og'ir dumlar (EVT dan GPD)
• Taqsimotning umumiy shakli (asosiy qism uchun empirik CDF)

Kripto aktivlar uchun Styudent t innovatsiyalari bilan EGARCH(1,1) yoki GJR-GARCH(1,1) modeli yaxshi ishlaydi, chunki u assimmetrik volatillik reaksiyasini aniqlaydi (yomon xabarlar yaxshi xabarlarga qaraganda volatillikni ko'proq oshiradi).

Kopulalar bilan portfel VaR va CVaR

Xavf ostidagi qiymat (VaR)

$\alpha$ ishonch darajasidagi portfel VaR:

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

bu yerda $L$ — portfel zarari. Kopulalar bilan biz VaR ni Monte-Karlo orqali baholaymiz:

1. Moslashtirilgan vine kopulasidan $N$ namunani modellashtirish (bir xil fazoda)
2. Teskari marginal CDF lardan foydalanib daromad fazosiga qayta aylantirish
3. Portfel daromadlarini hisoblash: $r_p = \sum_i w_i \cdot r_i$
4. VaR — modellashtirilgan portfel zarari taqsimotining $\alpha$-kvantili

Shartli xavf ostidagi qiymat (CVaR / Kutilayotgan yetishmovchilik)

CVaR — zarar VaR dan oshib ketishini hisobga olgan holda kutilayotgan zarardir:

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

CVaR kogerent (subadditivlikni qanoatlantiradi), bu uni portfelni optimallashtirish uchun VaR dan ustun qiladi. Monte-Karlo bahosi to'g'ridan-to'g'ri — VaR dan oshadigan zararlarning o'rtachasini olish.

Nima uchun kopulaga asoslangan xavf korrelyatsiyaga asoslangan xavfdan yaxshiroq

Juftlik korrelyatsiyasi bir xil 0.5 bo'lgan ikkita portfelni ko'rib chiqaylik:

• Portfel A: Gauss kopula bog'liqligi (dum bog'liqligi yo'q)
• Portfel B: Klayton kopula bog'liqligi ($\theta = 2$, $\lambda_L = 0.71$)

99% ishonch darajasida Portfel B da VaR va CVaR sezilarli darajada yuqori bo'ladi, chunki Klayton kopulasi aktivlarning birgalikda qulash tendensiyasini to'g'ri modellashtiradi. Gauss kopulasi ekstremal birgalikdagi harakatlar juda kam uchraydi deb taxmin qilib bu xavfni pastroq baholaydi.

Kripto portfellari bo'yicha empirik tadqiqotlarda Gauss va vine kopula modellari o'rtasidagi 99% CVaR farqi 30-40% dan oshishi mumkin, bu esa korrelyatsiyaga asoslangan modellar dum xavfini uchdan bir yoki undan ko'proq pastroq baholashi mumkinligini anglatadi.

Amalga oshirish: pyvinecopulib bilan Python

Bu yerda kripto daromadlariga vine kopulasini moslashtirish va portfel VaR/CVaR ni baholash uchun to'liq konveyer keltirilgan.

1-qadam: Ma'lumotlarni tayyorlash va marginal moslashtirish

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

2-qadam: Ehtimollik integral transformatsiyasi

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

3-qadam: Vine kopulasini moslashtirish

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

4-qadam: Monte-Karlo VaR va 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")

5-qadam: Dum bog'liqligi tahlili

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

Kripto portfeli uchun odatiy natija shunday ko'rinishi mumkin:

Har bir juftlik butunlay boshqacha bog'liqlik strukturasiga ega bo'lishi mumkinligiga e'tibor bering. BTC-SOL nol yuqori dum bog'liqligi bilan kuchli quyi dum bog'liqligini (Klayton) ko'rsatadi — ular birgalikda qulaydi, lekin albatta birgalikda ko'tarilishi shart emas. BTC-MATIC hech qanday dum bog'liqligini ko'rsatmaydi (Frank), bu ekstremal holatlarda ham ma'lum diversifikatsiya foydasini bildiradi.

Kopula VaR modelini orqaga testlash

VaR modeli faqat yaxshi kalibrlangan bo'lsa foydali. Standart orqaga test VaR buzilishlarini hisoblaydi — haqiqiy zarar bashorat qilingan VaR dan oshgan kunlar — va buzilish darajasi kutilayotgan darajaga mos kelishini tekshiradi.

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

Yaxshi kalibrlangan 99% VaR modelining buzilish darajasi 1% ga yaqin bo'lishi kerak. Agar daraja sezilarli darajada yuqori bo'lsa, model xavfni pastroq baholaydi. Agar sezilarli darajada past bo'lsa, u haddan tashqari konservativ.

Amaliy mulohazalar

Hisoblash xarajati

Vine kopulasini moslashtirish daraxt darajasi bo'yicha $O(d^2 \cdot n)$ ni tashkil qiladi. 500 kunlik aylanma oynali 10 aktivli portfel uchun har bir qadamda 50,000 Monte-Karlo modellashtirish bilan to'liq orqaga test soatlab davom etishi mumkin. Buni boshqarish strategiyalari:

• Kesilgan vine'lar: trunc_lvl=3 yoki trunc_lvl=4 o'rnatish — yuqori daraxtlar xavfga kamroq hissa qo'shadigan zaifroq shartli bog'liqliklarni aniqlaydi
• Kamaytirilgan modellashtirish soni: 99% VaR uchun ko'pincha 10,000-20,000 modellashtirish yetarli
• Parallel hisoblash: Har bir aktiv uchun GARCH moslashtirishlari mustaqil va parallellashtirilishi mumkin
• Model keshlash: Kopulani har kuni emas, har hafta qayta moslashtirish, faqat GARCH bashoratlarini yangilash

Rejim xabardorligi

Kripto bozorlari aniq rejimlarni namoyish etadi (bull, bear, yon tomon, yuqori volatillik hodisalari). Butun namunaga moslashtirilgan yagona vine kopulasi rejimga bog'liq bog'liqlikni aniqlay olmasligi mumkin. Quyidagilarni ko'rib chiqing:

• 250-500 kunlik aylanma oynalar
• Kopula parametrlari yashirin Markov holatiga bog'liq bo'lgan rejim almashtiruvchi kopulalar
• So'nggi ma'lumotlarga ko'proq og'irlik beradigan eksponensial vaznlangan kuzatuvlar

Keng tarqalgan xatolar

1. PIT ni unutish. Psevdo-bir xil kuzatuvlar o'rniga xom daromadlarni to'g'ridan-to'g'ri kopulaga berish mazmunsiz natijalarni beradi. Har doim avval bir xil marginallarga aylantiring.
2. Juda ko'p oilalar bilan ortiqcha moslashtirish. Tanlov to'plamiga mumkin bo'lgan har bir ikki o'zgaruvchili oilani qo'shish ortiqcha moslashtirishga olib kelishi mumkin, ayniqsa qisqa namunalarda. Model tanlash uchun BIC dan foydalaning va 4-5 oila bilan cheklashni ko'rib chiqing.
3. Ketma-ket bog'liqlikni e'tiborsiz qoldirish. Kopulalar bitta vaqt nuqtasida ko'ndalang kesim bog'liqligini modellashtiradi. Agar siz GARCH bosqichini o'tkazib yuborsangiz va avtokorrelyatsiyalangan daromadlarni kopulaga bersangiz, baholangan bog'liqlik ketma-ket effektlar bilan ifloslanadi.
4. Dinamik bozorlarda statik kopulalar. 2021-yil bull bozor ma'lumotlariga moslashtirilgan kopula 2022-yil qulashi uchun yomon kalibrlangan bo'ladi. Har doim aylanma yoki kengayuvchi oynalardan foydalaning.

Xulosa

Kopula modellari — xususan vine kopulalari — chiziqli korrelyatsiya aniqlay oladigan narsadan ancha uzoqqa boradigan kripto portfellarining birgalikdagi xavfini modellashtirish uchun matematik jihatdan qat'iy asos beradi. Asosiy afzalliklar:

• Sklar teoremasi orqali marginal va bog'liqlik modellashtirishini ajratish
• Mos kopula oilasini tanlash orqali moslashuvchan dum bog'liqligi (qulash yuqumliligi uchun Klayton, o'sish birgalikdagi harakati uchun Gumbel, simmetrik dumlar uchun t-kopula)
• Vine kopula dekompozitsiyasi orqali yuqori o'lchamli masshtablanuvchanlik, bunda aktivlarning har bir jufti o'zining ikki o'zgaruvchili kopulasini oladi
• Chiziqli bo'lmagan, assimmetrik bog'liqlikni hisobga oladigan aniq VaR/CVaR bahosi — "hammasi birgalikda qulaydi" istisno emas, norma bo'lgan bozorda xavfni boshqarish uchun muhim

GARCH-EVT-Kopula konveyeri hozir miqdoriy xedj fondlari va kriptoga yo'naltirilgan xavf stollarida standart yondashuv hisoblanadi. pyvinecopulib kabi kutubxonalar bilan amalga oshirish to'sig'i shu qadar past-ki, har qanday tizimli treyder kopulaga asoslangan xavfni modellashtirishni o'zining portfelni boshqarish ish jarayoniga integratsiyalashi mumkin.

Ushbu maqoladagi kod ishlaydigan boshlang'ich nuqtani taqdim etadi. Ishlab chiqarishda foydalanish uchun siz GARCH tartibini tanlash uchun tegishli o'zaro tekshiruvni, murakkabroq marginal modellarni (masalan, richag effektlari bilan EGARCH yoki kun ichidagi ma'lumotlardan foydalanadigan amalga oshirilgan volatillik o'lchovlarini) va tarixiy inqiroz epizodlariga kalibrlangan gipotetik kopula parametrlari ostida stress-testlashni qo'shasiz.

Manbalar

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