Transfer Entropy: Which Way Does Information Flow Between Crypto Assets?

Blog ini telah menetapkan bahawa kripto hampir merupakan pasaran satu faktor: korelasi isyarat antara pasangan meletakkan PC1 (faktor BTC) pada 65% varians dan menunjukkan bahawa empat faktor menjelaskan 90%, jadi sepuluh pasangan "terpelbagai" membawa maklumat tiga atau empat pasangan bebas. Ia juga telah menetapkan bahawa struktur kebergantungan tidak malar: DCC-GARCH memodelkan matriks korelasi sebagai siri masa dengan rejimnya sendiri, dan bahagian Limitations menyatakan dengan jelas — "korelasi bukan kausaliti dan bukan arah."

Klausa terakhir itulah jurang yang ditangani artikel ini. DCC memberitahu bila kebergantungan menjadi lebih ketat. Ia tidak boleh memberitahu ke arah mana ia menunjuk. Transfer entropy boleh: ia ialah ukuran tanpa model dan sememangnya tidak simetri tentang berapa banyak bit daripada masa lalu satu siri menyumbang kepada ramalan masa depan siri lain, melebihi perkara yang telah dijelaskan oleh masa lalu sasaran itu sendiri. Jika ETH secara konsisten menghantar maklumat kepada AAVE sebelum AAVE menetapkan semula harga, transfer entropy melihat ketaksimetrian yang tidak boleh diwakili oleh mana-mana matriks korelasi.

Yang berikut ialah ukuran itu, penganggarannya dan — bahagian yang lebih penting daripada ukuran — penentukuran null serta analisis sensitiviti yang menentukan sama ada rangkaian aliran maklumat yang diukur ialah isyarat atau hiasan.

Rangkaian yang Diukur

Status: belum dijalankan. Pipeline di bawah telah diimplementasikan tetapi belum dijalankan pada data nyata untuk artikel ini. Sehingga ia dijalankan, artikel ini ialah penulisan kaedah, bukan hasil. Piawaian blog sendiri — lihat hasil negatif yang jujur dan deflated Sharpe serta multiple testing — ialah rangkaian yang tidak ditentukur dianggap noise sehingga dibuktikan sebaliknya.

Empat perkara perlu dilaporkan di sini mengikut susunan ini, dan tiada satu pun boleh didakwa berdasarkan literatur:

1. Matriks effective-TE. Universe, exchange, julat tarikh, saiz bar, effective TE dalam bit bagi setiap pasangan bertertib, p-value bagi setiap pasangan dan graf berarah yang melepasi penapis keertian. Ini menggantikan hand-waving biasa ("BTC ialah sumber dominan, token DeFi ialah sink") dengan jadual out-strength / in-strength / net-flow.
2. Kadar false-positive ujian keertian, diukur dengan menjalankan seluruh pipeline pada siri yang di-shuffle dan siri bebas sintetik. Lihat Null Calibration di bawah.
3. Sweep sensitiviti atas dua knob bebas: n_bins dalam {3, 5} disilangkan dengan k dalam {1, 2, 3, 5}. Jika ranking leader/follower hanya bertahan pada satu sel grid itu, itulah penemuannya.
4. Kestabilan mengikut masa. Adakah ranking yang diukur kekal out-of-sample, atau berubah semula pada setiap window? Tiada perkara hiliran berbaloi ditulis sehingga soalan ini dijawab.

Machinery

Tiga blok binaan

Entropi Shannon mengukur ketidakpastian pemboleh ubah rawak $X$:

$H(X) = -\sum_{i=1}^{n} p(x_i) \log_2 p(x_i)$

Lambungan syiling ialah 1 bit; dadu adil ialah $\log_2 6 \approx 2.58$ bit; pemboleh ubah deterministik ialah 0.

Entropi bersyarat mengukur berapa banyak ketidakpastian tentang $Y$ yang kekal selepas mengetahui $X$:

$H(Y|X) = -\sum_{x,y} p(x,y) \log_2 \frac{p(x,y)}{p(x)}$

Ia ialah 0 apabila $X$ menentukan $Y$, dan sama dengan $H(Y)$ apabila kedua-duanya bebas.

Maklumat bersama ialah maklumat yang dikongsi antara kedua-duanya:

$I(X;Y) = H(Y) - H(Y|X) = H(X) - H(X|Y)$

Ia simetri — $I(X;Y) = I(Y;X)$ — dan simetri itulah yang perlu dipecahkan.

Transfer entropy

Transfer entropy, yang diperkenalkan oleh Schreiber (2000), memecahkan simetri dengan mengkondisikan pada masa lalu sasaran sendiri. Ia mengukur sejauh mana masa lalu sumber $X$ mengurangkan ketidakpastian tentang masa depan sasaran $Y$, melebihi perkara yang telah dijelaskan oleh masa lalu $Y$.

Biarkan $Y_t^{(k)}$ menandakan sejarah sepanjang $k$ $(Y_{t-1}, \dots, Y_{t-k})$ dan $X_t^{(l)}$ sejarah sumber sepanjang $l$:

$T_{X \to Y} = \sum p(Y_{t+1}, Y_t^{(k)}, X_t^{(l)}) \log_2 \frac{p(Y_{t+1} \mid Y_t^{(k)}, X_t^{(l)})}{p(Y_{t+1} \mid Y_t^{(k)})}$

Secara setara, sebagai perbezaan entropi bersyarat:

$T_{X \to Y} = H(Y_{t+1} \mid Y_t^{(k)}) - H(Y_{t+1} \mid Y_t^{(k)}, X_t^{(l)})$

Jika masa lalu $X$ tidak membantu meramalkan $Y$ melebihi masa lalu $Y$ sendiri, $T_{X \to Y} = 0$. Jika ia membantu, magnitudnya ialah bilangan bit maklumat ramalan yang mengalir.

Sifat utama:

• Tidak negatif: $T_{X \to Y} \geq 0$.
• Tidak simetri: secara umum $T_{X \to Y} \neq T_{Y \to X}$. Inilah keseluruhan tujuannya.
• Bukan parametrik: tiada andaian model — kebergantungan linear dan nonlinear.
• Unit: bit dengan $\log_2$, nat dengan $\ln$.

Net transfer entropy memberikan arah dominan:

$T_{X \to Y}^{\text{net}} = T_{X \to Y} - T_{Y \to X}$

Nilai positif bermaksud $X$ ialah penghantar bersih kepada $Y$; nilai negatif bermaksud $Y$ mendahului.

Transfer Entropy berbanding Granger Causality

Granger causality (GC) bertanya sama ada masa lalu $X$ memperbaiki ramalan autoregresif linear bagi $Y$. Ini bukan ujian cointegration Engle-Granger yang dibincangkan dalam arbitraj statistik dan pairs trading — nama keluarga sama, konsep tidak berkaitan. Engle-Granger bertanya sama ada gabungan linear dua siri tidak pegun adalah pegun; Granger causality bertanya sama ada satu siri membantu meramalkan siri lain. Pembaca blog ini mungkin mencampurkannya, jadi perkara ini perlu dinyatakan dengan jelas.

Kesetaraan teori untuk proses Gaussian

Barnett, Barrett dan Seth (2009) membuktikan bahawa bagi proses Gaussian bersama, Granger causality dan transfer entropy adalah setara sehingga transformasi monoton:

$T_{X \to Y} = \frac{1}{2} \ln\left(1 + F_{X \to Y}\right)$

di mana $F_{X \to Y}$ ialah statistik Granger causality (nisbah log-likelihood). Bagi data Gaussian linear, kedua-dua kaedah memulihkan struktur kausal yang sama tepat. Oleh itu transfer entropy bukan pesaing GC, sebaliknya generalisasi bukan parametriknya: ia menjadi GC tepat di tempat andaian GC terpakai.

Di mana kedua-duanya berbeza

Jurang ini penting dalam kripto secara prinsip: pulangan mempunyai ekor berat, volatiliti berkelompok dan hubungan bergantung pada rejim, yang semuanya diratakan oleh VAR linear. Sama ada jurang itu cukup besar untuk mengubah ranking peneraju yang diukur pada data nyata ialah soalan empirikal yang mesti dijawab artikel ini, bukan diandaikan.

Dimpfl dan Peter (2013) melaporkan bahawa transfer entropy mengesan aliran yang terlepas oleh Granger causality dalam siri kewangan, khususnya ketika tekanan; Keskin dan Aste (2020) melaporkan rangkaian lebih kaya daripada TE nonlinear dalam kripto. Kedua-duanya dipetik di sini sebagai motivasi, bukan bukti untuk dataset ini.

Effective Transfer Entropy: Pembetulan Bias

Inilah bahagian yang mudah tersilap. Anggaran TE mentah adalah bias ke atas dalam sampel terhingga: masukkan dua siri bebas dan anda masih akan menganggar $T_{X \to Y} > 0$, semata-mata daripada noise pensampelan dalam taburan bersama empirikal. Bias meningkat mengikut bilangan state bersama, yang meningkat secara eksponen dalam $k + l$.

Effective transfer entropy menolak bias tersebut:

$T_{X \to Y}^{\text{eff}} = T_{X \to Y} - \mathbb{E}\!\left[T_{X_{\text{surrogate}} \to Y}\right]$

di mana surrogate memusnahkan struktur temporal $X$ sambil mengekalkan taburan marginalnya. Perhatikan maksudnya: min surrogate ialah anggaran bias penganggar itu sendiri, dan kami menolaknya. Ia bukan selang keyakinan, dan effective TE bukan "TE dengan error bars." Ensemble surrogate yang sama turut menjadi taburan null untuk p-value, tetapi penolakan dan ujian ialah penggunaan yang berasingan.

Surrogate dijana melalui block bootstrap supaya autokorelasi $X$ dalam blok kekal — mekanik umum dan rasional pensampelan semula blok dibincangkan dalam Monte Carlo dan bootstrap untuk backtest.

Pelaksanaan

Data: pulangan log setiap jam bagi universe tetap perpetual USDT utama daripada satu exchange, sepanjang julat tarikh berterusan yang dinyatakan. Pengambilan OHLCV standard dan pembinaan pulangan log ialah boilerplate yang dibincangkan dalam arbitraj statistik dan pairs trading dan tidak diulang.

Diskretisasi — dan amaran leakage

Transfer entropy memerlukan state diskret. Binning kuantil ialah pilihan biasa, dan ia juga tempat biasa kebocoran masa depan berlaku.

import numpy as np
import pandas as pd

def discretize_trailing(series, n_bins=3, warmup=500):
    """Discretize using bin edges estimated on a TRAILING window only.

    Computing quantile edges over the full sample is whole-series
    normalization leakage: every bar's label depends on the entire
    future distribution. See the look-ahead bias taxonomy.
    """
    x = np.asarray(series, dtype=float)
    out = np.full(len(x), -1, dtype=int)
    qs = np.linspace(0, 1, n_bins + 1)[1:-1]
    for t in range(warmup, len(x)):
        edges = np.quantile(x[:t], qs)      # strictly past data
        out[t] = np.digitize(x[t], edges)
    return out

Versi full-sample naif sesuai untuk dakwaan deskriptif — "sepanjang tempoh ini, maklumat mengalir begini" — tetapi tercemar untuk sebarang dakwaan boleh didagangkan. Perbezaan ini ialah keseluruhan subjek taksonomi bias look-ahead. Jika anda menggunakan edges full-sample, nyatakan demikian dan berhenti sebelum perkataan "signal."

Transfer entropy dari awal

from collections import Counter

def transfer_entropy(source, target, k=1, l=1):
    """Transfer entropy T_{source -> target} in bits.

    source, target : 1-D integer arrays of discrete states
    k : history length for the target
    l : history length for the source
    """
    source = np.asarray(source)
    target = np.asarray(target)
    n = len(target)
    max_lag = max(k, l)

    y_future = target[max_lag:]
    y_past = np.column_stack([target[max_lag - i - 1:n - i - 1] for i in range(k)])
    x_past = np.column_stack([source[max_lag - i - 1:n - i - 1] for i in range(l)])
    N = len(y_future)

    yf = y_future.tolist()
    yp = [tuple(row) for row in y_past]
    xp = [tuple(row) for row in x_past]

    c_yf_yp_xp = Counter(zip(yf, yp, xp))
    c_yp_xp = Counter(zip(yp, xp))
    c_yf_yp = Counter(zip(yf, yp))
    c_yp = Counter(yp)

    te = 0.0
    for (yf_val, yp_val, xp_val), count in c_yf_yp_xp.items():
        p_joint = count / N
        p_yf_given_yp_xp = count / c_yp_xp[(yp_val, xp_val)]
        p_yf_given_yp = c_yf_yp[(yf_val, yp_val)] / c_yp[yp_val]
        if p_yf_given_yp > 0 and p_yf_given_yp_xp > 0:
            te += p_joint * np.log2(p_yf_given_yp_xp / p_yf_given_yp)

    return te

Effective TE dengan null block-bootstrap

def effective_transfer_entropy(source, target, k=1, l=1,
                               n_shuffles=200, block_size=5, rng=None):
    """Effective TE plus a surrogate p-value.

    Returns dict: te, ete, p_value, null_mean, null_std
    """
    rng = rng or np.random.default_rng(0)
    te_observed = transfer_entropy(source, target, k, l)

    n = len(source)
    n_blocks = int(np.ceil(n / block_size))
    null_tes = np.empty(n_shuffles)

    for b in range(n_shuffles):
        starts = rng.integers(0, n, size=n_blocks)
        shuffled = np.concatenate(
            [np.take(source, range(s, s + block_size), mode='wrap')
             for s in starts]
        )[:n]
        null_tes[b] = transfer_entropy(shuffled, target, k, l)

    null_mean = null_tes.mean()
    return {
        'te': te_observed,
        'ete': max(te_observed - null_mean, 0.0),
        'p_value': (np.sum(null_tes >= te_observed) + 1) / (n_shuffles + 1),
        'null_mean': null_mean,
        'null_std': null_tes.std(),
    }

Matriks berpasangan

def compute_te_matrix(disc_returns, k=1, n_shuffles=200):
    cols = list(disc_returns.columns)
    m = len(cols)
    te_matrix = np.zeros((m, m))
    pval_matrix = np.ones((m, m))

    for i in range(m):
        for j in range(m):
            if i == j:
                continue
            r = effective_transfer_entropy(
                disc_returns[cols[i]].values,
                disc_returns[cols[j]].values,
                k=k, n_shuffles=n_shuffles,
            )
            te_matrix[i, j] = r['ete']
            pval_matrix[i, j] = r['p_value']

    return (pd.DataFrame(te_matrix, index=cols, columns=cols),
            pd.DataFrame(pval_matrix, index=cols, columns=cols))

Laluan pantas

pyinform membungkus implementasi C yang dioptimumkan:

from pyinform.transferentropy import transfer_entropy as te_pyinform

te_btc_to_eth = te_pyinform(btc_disc, eth_disc, k=2)
te_eth_to_btc = te_pyinform(eth_disc, btc_disc, k=2)

Penentukuran Null

Inilah bahagian analisis yang paling bernilai dan paling kerap dilangkau. Sebelum mempercayai mana-mana edge dalam rangkaian yang diukur, jalankan seluruh pipeline — diskretisasi, effective TE, ujian surrogate, penapis keertian — pada data yang jawapan sebenarnya diketahui sifar:

1. Pulangan nyata yang di-shuffle. Musnahkan pemasaan merentas siri sambil mengekalkan taburan marginal setiap siri.
2. Siri bebas sintetik. Simulasikan $M$ proses bebas berekor berat dan berkelompok volatiliti yang sememangnya tiada kebergantungan silang.

Kemudian laporkan pecahan pasangan bertertib yang ditandai oleh ujian pada $\alpha = 0.05$. Jika pecahan itu tidak hampir 0.05, ujian tersalah ditentukur dan setiap edge dalam rangkaian nyata mencurigakan.

Multiple testing memburukkan keadaan ini. Universe 8 aset menghasilkan $8 \times 7 = 56$ ujian berpasangan bertertib; 20 aset menghasilkan 380. Pembetulan — Bonferroni, Holm, Benjamini-Yekutieli FDR — diterbitkan sepenuhnya dalam deflated Sharpe dan multiple testing, bersama kajian penentukuran yang menunjukkan FDR ujian naif 1.000 berbanding BHY 0.007.

Namun jangan berhenti pada Bonferroni mentah kerana 56 ujian ini bukan 56 pemerhatian bebas. Aset kripto sangat berkorelasi — blog ini mengukur PC1 pada 65% varians — tepatnya mod kegagalan grid berkorelasi yang didokumenkan dalam Act 5 artikel itu. Menganggap bilangan sel mentah grid berkorelasi sebagai bilangan percubaan menyebabkan over-deflation dan penolakan palsu terhadap edge sebenar. Deliverable di sana ialah band anggaran percubaan berkesan, bukan satu titik: one-liner korelasi purata $N_{\text{eff}} = N/(1 + (N-1)\bar\rho)$ pada hujung lembut, dan penganggar eigenvalue (participation ratio, PCA-95%, Kaiser) di bahagian tengah yang defensible. Laporkan band effective-$N$ untuk grid TE dan semak sama ada edge yang kekal stabil merentas band itu.

Sensitiviti: Dua Knob Bebas

Kedua-dua knob di bawah biasanya ditetapkan berdasarkan rule of thumb dan tidak disemak semula. Sebaliknya, lakukan sweep dan laporkan ranking leader/follower pada setiap sel.

Panjang sejarah $k$

$k$ mengawal berapa banyak masa lalu sasaran sendiri yang dikondisikan. Terlalu kecil menyebabkan autokorelasi sasaran sendiri dikaitkan kepada sumber; terlalu besar menjadikan taburan bersama terlalu jarang untuk dianggar — bilangan state bersama ialah $|\mathcal{A}|^{k+l+1}$, jadi dengan 3 bin, $k=2$, $l=1$ terdapat $3^4 = 81$ state, manakala $k=5$ menghasilkan $3^7 = 2187$ berbanding beberapa ribu pemerhatian.

Titik mula konvensional ialah $k \in \{1, 2\}$ untuk data setiap jam dan $k \in \{1, \dots, 5\}$ untuk data harian, dengan pilihan semakan silang AIC/BIC pada lag VAR yang setara. Anggap ini sebagai grid untuk di-sweep, bukan jawapannya.

Diskretisasi

• 3 bin (down / flat / up): teguh, berfungsi dengan data terhad, hanya menangkap struktur arah.
• 5 bin: menangkap magnitud, memerlukan lebih banyak data dengan ketara.
• Quantile edges: penghunian hampir sama dan tiada bin kosong — tetapi lihat amaran leakage di atas.
• Pengekodan ordinal/simbolik: gaya permutation entropy, teguh terhadap transformasi monoton.

TE berasaskan kernel berterusan mengelakkan kehilangan diskretisasi sepenuhnya, dengan kos pemilihan bandwidth dan pengiraan yang jauh lebih berat.

Sweep

for n_bins in (3, 5):
    for k in (1, 2, 3, 5):
        disc = discretize_all(returns, n_bins=n_bins)
        te_df, p_df = compute_te_matrix(disc, k=k)
        rank = net_flow_ranking(te_df, p_df)
        report(n_bins, k, rank)

Soalannya bukan "apakah rankingnya" tetapi "adakah ranking sama pada setiap sel". Jika aset hanya menjadi penghantar bersih pada $k=2$, $n_{\text{bins}}=3$, ketidakstabilan itu ialah hasilnya dan perlu dilaporkan demikian.

Confounding: Transfer Entropy Bersyarat

Jika $X$ dan $Y$ kedua-duanya dipacu oleh faktor laten $Z$, TE berpasangan akan melaporkan aliran antara kedua-duanya yang sepenuhnya merupakan artifak pemacu bersama. Dalam pasaran satu faktor, ini bukan kes pinggir; ia ialah jangkaan lalai. Conditional transfer entropy menghapuskan kesan itu melalui conditioning:

$T_{X \to Y | Z} = H(Y_{t+1} \mid Y_t^{(k)}, Z_t^{(l)}) - H(Y_{t+1} \mid Y_t^{(k)}, X_t^{(l)}, Z_t^{(l)})$

Sebarang dakwaan bahawa SOL menghantar maklumat kepada AVAX perlu diuji semula dengan conditioning pada BTC. Jika aliran hilang, hasil berpasangan itu sebenarnya faktor pasaran yang menyamar.

te_sol_avax_given_btc = te_pyinform(sol_disc, avax_disc, k=2,
                                    condition=btc_disc)

Conditioning bukan percuma: setiap pemboleh ubah conditioning mendarab state space bersama dengan $|\mathcal{A}|^{l}$, jadi conditional TE memerlukan lebih banyak data berbanding versi berpasangan pada $k$ yang sama.

Kestabilan dan Sama Ada Semua Ini Boleh Didagangkan

Aliran maklumat tidak statik — begitu juga perkara lain dalam pasaran ini, yang menjadi premis pembukaan pengesanan rejim dengan HMM dan sebab setiap anggaran di sini perlu menggunakan window, bukan dipadankan sekali. Namun versi rolling-window analisis ini mewarisi hasil yang diketahui, bukan menemui hasil baharu. Kebergantungan kripto mengetat ketika krisis telah diterbitkan dengan nombor: korelasi isyarat antara pasangan menjadualkan korelasi isyarat purata daripada 0.15 dalam pasaran mendatar kepada 0.90 ketika panik, dengan $N_{\text{eff}}$ runtuh daripada 4.2 kepada 1.1; dan Application 3 DCC-GARCH menukar korelasi berpasangan purata kepada isyarat rejim risk-off dengan flag kuantil bergulir serta caveat jelas "ini isyarat risiko, bukan isyarat alpha."

Freeman centralization bagi out-strength TE ialah skalar berbeza pada matriks berbeza, tetapi gerakannya sama: runtuhkan objek kebergantungan $d \times d$ menjadi satu nombor dan lihat ia meningkat. Jadi penandanya bukan "adakah centralization meningkat sebelum drawdown" — tetapi adakah ia mengatasi korelasi berpasangan purata sebagai isyarat risk-off, diukur secara head-to-head pada window dan drawdown yang sama.

def network_centralization(G):
    """Freeman centralization of out-strength. High = one dominant source."""
    if G.number_of_nodes() < 2:
        return 0.0
    s = [sum(d['weight'] for _, _, d in G.out_edges(v, data=True)) for v in G.nodes()]
    total = sum(s)
    if total == 0:
        return 0.0
    n = len(s)
    return sum(max(s) - x for x in s) / ((n - 1) * total)

Dua soalan mesti dijawab sebelum sebarang aplikasi hiliran berbaloi ditulis:

1. Adakah ranking peneraju kekal out-of-sample? Padankan rangkaian pada window $t$, semak ranking pada window $t+1$. Laporkan korelasi ranking merentas window. Ranking yang berubah setiap minggu menggambarkan noise.
2. Adakah penapis TE menambah apa-apa kepada dagangan lead-lag? Eksperimen yang betul ialah perbandingan terkawal tunggal: machinery rolling z-score entry/exit yang sama dalam arbitraj statistik dan pairs trading serta pendekatan jarak, dijalankan dua kali, dengan kewujudan penapis keertian TE sebagai satu-satunya perbezaan, termasuk yuran.

Kedua-duanya belum dijalankan untuk artikel ini. Tiada backtest lead-lag, portfolio information-momentum atau perbandingan pengesanan rejim. Machinery pembinaan berat untuk sleeve information-momentum hipotesis dibincangkan dalam algoritma pengoptimuman portfolio dibandingkan — tetapi perhatikan bahawa softmax atas net-strength mentah dalam bit adalah sewenang-wenangnya dari segi skala dan memerlukan hujah normalisasi sebelum bermakna. Kod strategi yang belum diuji tidak dihantar di sini.

Kos

TE ialah $O(N)$ bagi setiap pasangan, tetapi pemalar didorong oleh bilangan state bersama $|\mathcal{A}|^{k+l+1}$ dan bilangan surrogate. Untuk $M$ aset dan $B$ replikasi bootstrap, anda memerlukan $M(M-1)B$ penilaian TE — dengan 50 aset dan 200 surrogate jumlahnya 490,000. Kos setiap penilaian bergantung sepenuhnya pada hardware, versi pyinform dan $N$; ukur pada mesin sendiri dan bukannya mempercayai angka yang dipetik. Tiga tuas jika terlalu perlahan:

• Parallelize. Setiap pasangan bebas — joblib atau multiprocessing.
• Pre-screen. Kira TE mentah dahulu; jalankan surrogate hanya pada pasangan melebihi ambang. (Perhatikan bahawa ini menjadikan ujian keertian bersyarat pada lulus saringan dan perlu diambil kira.)
• Kecilkan universe. Lakukan clustering dahulu, kemudian kira TE antara wakil cluster.

Ringkasan

Transfer entropy ialah ukuran aliran maklumat berarah yang berprinsip dan tanpa model, serta mengisi jurang sebenar dalam toolkit blog ini: DCC-GARCH memberitahu bila kebergantungan mengetat, TE memberitahu arahnya. Untuk proses Gaussian, ia runtuh tepat kepada Granger causality melalui $T = \tfrac{1}{2}\ln(1 + F)$, menjadikannya generalisasi dan bukannya pesaing.

Namun ia masih bukan hasil. Pipeline di sini telah diimplementasikan dan mod kegagalan disenaraikan — bias sampel terhingga yang dibetulkan oleh surrogate, binning seluruh siri sebagai kebocoran look-ahead, grid berkorelasi 56 ujian yang memecahkan pembetulan multiple-testing naif, confounding pemacu bersama dalam pasaran satu faktor dan parameter bebas yang mungkin menentukan jawapan. Setiap satunya ialah sebab untuk tidak mempercayai rangkaian TE yang tidak ditentukur. Menerbitkan rangkaian tanpa penentukuran null, sweep sensitiviti dan semakan kestabilan out-of-sample bermaksud menerbitkan mod kegagalan seolah-olah ia penemuan.

Rujukan

• Schreiber, T. (2000). "Measuring Information Transfer." Physical Review Letters, 85(2), 461-464.
• Barnett, L., Barrett, A.B., Seth, A.K. (2009). "Granger Causality and Transfer Entropy Are Equivalent for Gaussian Variables." Physical Review Letters, 103(23), 238701.
• Marschinski, R., Kantz, H. (2002). "Analysing the information flow between financial time series." European Physical Journal B, 30(2), 275-281.
• Dimpfl, T., Peter, F.J. (2013). "Using Transfer Entropy to Measure Information Flows Between Financial Markets." Studies in Nonlinear Dynamics & Econometrics, 17(1), 85-102.
• Keskin, Z., Aste, T. (2020). "Information-theoretic measures for nonlinear causality detection: application to social media sentiment and cryptocurrency prices." Royal Society Open Science, 7(9), 200863.
• Jang, S.M. et al. (2022). "Using transfer entropy to measure information flows between cryptocurrencies." Physica A, 586, 126476.
• Nicola, G. et al. (2020). "Network Analysis of Multivariate Transfer Entropy of Cryptocurrencies in Times of Turbulence." Entropy, 22(7), 760.