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

Dieser Blog hat bereits gezeigt, dass Krypto einem Ein-Faktor-Markt nahekommt: die Signalkorrelation zwischen Paaren ordnet PC1 (dem BTC-Faktor) 65 % der Varianz zu und zeigt, dass vier Faktoren 90 % erklären. Zehn "diversifizierte" Paare tragen damit die Information von drei oder vier unabhängigen Paaren. Außerdem wurde gezeigt, dass die Abhängigkeitsstruktur nicht einmal konstant ist: DCC-GARCH modelliert die Korrelationsmatrix als Zeitreihe mit eigenen Regimen, und der Abschnitt zu den Einschränkungen sagt den unbequemen Teil offen aus — "Korrelation ist keine Kausalität und keine Richtung".

Diese letzte Klausel ist die Lücke, die dieser Artikel behandelt. DCC sagt dir, wann sich die Abhängigkeit verdichtet. Es kann dir nicht sagen, in welche Richtung sie zeigt. Transfer Entropy kann es: Sie ist ein modellfreies, von Natur aus asymmetrisches Maß dafür, wie viele Bits die Vergangenheit einer Reihe zur Vorhersage der Zukunft einer anderen beiträgt, zusätzlich zu dem, was die eigene Vergangenheit des Ziels bereits erklärt. Wenn ETH AAVE beständig Informationen sendet, bevor AAVE neu bewertet wird, erkennt Transfer Entropy die Asymmetrie, die keine Korrelationsmatrix darstellen kann.

Es folgen das Maß, sein Schätzer und — wichtiger als das Maß selbst — die Nullkalibrierung und Sensitivitätsanalyse, die entscheiden, ob ein gemessenes Informationsflussnetzwerk ein Signal oder bloße Dekoration ist.

Das gemessene Netzwerk

Status: noch nicht ausgeführt. Die nachfolgende Pipeline ist implementiert, wurde für diesen Artikel aber noch nicht mit realen Daten ausgeführt. Bis das geschieht, ist dieser Artikel eine Methodendarstellung und kein Ergebnis. Der eigene Standard des Blogs — siehe das ehrliche negative Ergebnis und deflationierte Sharpe-Ratio und multiples Testen — lautet: Ein nicht kalibriertes Netzwerk ist so lange Rauschen, bis das Gegenteil bewiesen ist.

Hier müssen vier Dinge in dieser Reihenfolge berichtet werden; keines davon darf aus der Literatur behauptet werden:

1. Die effektive TE-Matrix. Universum, Börse, Datumsbereich, Balkengröße, effektive TE in Bits pro geordnetem Paar, p-Wert pro Paar und der gerichtete Graph, der den Signifikanzfilter überlebt. Das ersetzt die übliche vage Behauptung ("BTC ist die dominante Quelle, DeFi-Token sind Senken") durch eine Tabelle mit ausgehender Stärke, eingehender Stärke und Nettofluss.
2. Die Falsch-Positiv-Rate des Signifikanztests, gemessen durch Ausführung der gesamten Pipeline auf gemischten und synthetisch unabhängigen Reihen. Siehe Nullkalibrierung weiter unten.
3. Ein Sensitivitätssweep über die beiden freien Parameter: n_bins in {3, 5}, gekreuzt mit k in {1, 2, 3, 5}. Wenn die Rangfolge von Anführer und Folger nur in einer Zelle dieses Rasters gilt, ist genau das der Befund.
4. Stabilität über die Zeit. Bleibt die gemessene Rangfolge außerhalb der Stichprobe bestehen, oder wird sie in jedem Fenster neu gemischt? Nichts Nachgelagertes ist es wert, geschrieben zu werden, bevor diese Frage beantwortet ist.

Die Mechanik

Drei Bausteine

Die Shannon-Entropie misst die Unsicherheit einer Zufallsvariablen $X$:

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

Ein Münzwurf hat 1 Bit; ein fairer Würfel hat $\log_2 6 \approx 2.58$ Bit; eine deterministische Variable hat 0.

Die bedingte Entropie misst, wie viel Unsicherheit über $Y$ nach Kenntnis von $X$ bestehen bleibt:

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

Sie ist 0, wenn $X$ $Y$ bestimmt, und entspricht $H(Y)$, wenn beide unabhängig sind.

Die gegenseitige Information ist die zwischen ihnen geteilte Information:

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

Sie ist symmetrisch — $I(X;Y) = I(Y;X)$ — und genau diese Symmetrie muss aufgebrochen werden.

Transfer Entropy

Transfer Entropy, von Schreiber (2000) eingeführt, bricht die Symmetrie, indem sie auf die eigene Vergangenheit des Ziels bedingt. Sie misst, wie stark die Vergangenheit der Quelle $X$ die Unsicherheit über die Zukunft des Ziels $Y$ reduziert, über das hinaus, was die Vergangenheit von $Y$ bereits erklärt.

Sei $Y_t^{(k)}$ der Verlauf der Länge $k$, $(Y_{t-1}, \dots, Y_{t-k})$, und $X_t^{(l)}$ der Quellenverlauf der Länge $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)})}$

Äquivalent als Differenz bedingter Entropien:

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

Wenn die Vergangenheit von $X$ nicht über die eigene Vergangenheit von $Y$ hinaus bei der Vorhersage von $Y$ hilft, gilt $T_{X \to Y} = 0$. Wenn sie hilft, ist die Größe die Zahl der Bits an prädiktiver Information, die fließen.

Wichtige Eigenschaften:

• Nichtnegativ: $T_{X \to Y} \geq 0$.
• Asymmetrisch: Im Allgemeinen gilt $T_{X \to Y} \neq T_{Y \to X}$. Genau darum geht es.
• Nichtparametrisch: Keine Modellannahmen — lineare und nichtlineare Abhängigkeiten werden gleichermaßen erfasst.
• Einheiten: Bits mit $\log_2$, Nats mit $\ln$.

Die Netto-Transfer-Entropy gibt die dominante Richtung an:

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

Positiv bedeutet, dass $X$ ein Netto-Sender an $Y$ ist; negativ bedeutet, dass $Y$ führt.

Transfer Entropy vs. Granger-Kausalität

Die Granger-Kausalität (GC) fragt, ob die Vergangenheit von $X$ eine lineare autoregressive Vorhersage von $Y$ verbessert. Das ist nicht der Engle-Granger-Kointegrationstest, der in statistischem Arbitragehandel und Pair-Trading behandelt wird — gleicher Nachname, aber ein unabhängiges Konzept. Engle-Granger fragt, ob eine lineare Kombination zweier nichtstationärer Reihen stationär ist; Granger-Kausalität fragt, ob eine Reihe bei der Prognose einer anderen hilft. Leser dieses Blogs werden die beiden verwechseln, deshalb lohnt sich diese klare Aussage.

Theoretische Äquivalenz für Gauß-Prozesse

Barnett, Barrett und Seth (2009) bewiesen, dass für gemeinsam gaußverteilte Prozesse Granger-Kausalität und Transfer Entropy bis auf eine monotone Transformation äquivalent sind:

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

wobei $F_{X \to Y}$ die Granger-Kausalitätsstatistik (ein Log-Likelihood-Verhältnis) ist. Für lineare Gauß-Daten erhält man mit beiden Methoden exakt dieselbe kausale Struktur. Transfer Entropy ist daher weniger ein Konkurrent der GC als deren nichtparametrische Verallgemeinerung: Sie fällt genau dort auf GC zurück, wo deren Annahmen gelten.

Wo sie auseinanderlaufen

Die Lücke ist bei Krypto prinzipiell relevant: Renditen haben schwere Tails, Volatilität clustert, und Beziehungen hängen vom Regime ab — alles Dinge, die ein lineares VAR glättet. Ob die Lücke groß genug ist, um die gemessene Führungsrangfolge auf realen Daten zu verändern, ist eine empirische Frage, die dieser Artikel beantworten und nicht annehmen muss.

Dimpfl und Peter (2013) berichten, dass Transfer Entropy in Finanzreihen Flüsse erkennt, die die Granger-Kausalität verpasst, insbesondere unter Stress; Keskin und Aste (2020) berichten ein reichhaltigeres Netzwerk aus nichtlinearer TE in Krypto. Beide werden hier als Motivation zitiert, nicht als Beleg für diesen Datensatz.

Effektive Transfer Entropy: die Bias-Korrektur

Hier kann man leicht etwas falsch machen. Rohe TE-Schätzungen sind bei endlichen Stichproben nach oben verzerrt: Setzt man zwei unabhängige Reihen ein, schätzt man trotzdem $T_{X \to Y} > 0$, allein aufgrund des Stichprobenrauschens in der empirischen gemeinsamen Verteilung. Der Bias wächst mit der Zahl gemeinsamer Zustände, die exponentiell in $k + l$ wächst.

Effektive Transfer Entropy zieht diesen Bias ab:

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

wobei das Surrogat die zeitliche Struktur von $X$ zerstört, seine Randverteilung aber bewahrt. Beachte, was dies ist und was es nicht ist: Der Mittelwert der Surrogate ist eine Schätzung des eigenen Schätz-Bias, und wir ziehen ihn ab. Er ist kein Konfidenzintervall, und effektive TE ist nicht "TE mit Fehlerbalken". Dasselbe Surrogat-Ensemble dient zusätzlich als Nullverteilung für einen p-Wert, aber Subtraktion und Test sind getrennte Verwendungen.

Das Surrogat wird per Block-Bootstrap erzeugt, sodass die Autokorrelation von $X$ innerhalb eines Blocks erhalten bleibt — die allgemeine Mechanik und Begründung des Block-Resamplings werden in Monte Carlo und Bootstrap für Backtests behandelt.

Implementierung

Daten: stündliche Log-Renditen für ein festes Universum wichtiger USDT-Perpetuals von einer einzelnen Börse über einen angegebenen zusammenhängenden Datumsbereich. Das standardmäßige Abrufen von OHLCV und die Konstruktion von Log-Renditen sind Boilerplate, die in statistischem Arbitragehandel und Pair-Trading behandelt wird, und werden hier nicht wiederholt.

Diskretisierung — und eine Warnung vor Leakage

Transfer Entropy benötigt diskrete Zustände. Quantil-Binning ist die übliche Wahl, und zugleich die übliche Stelle, an der die Zukunft durchsickert.

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

Die naive Version mit vollständiger Stichprobe ist für eine deskriptive Aussage geeignet — "in diesem Zeitraum floss Information in diese Richtung" — und für jede handelbare Aussage kontaminiert. Diese Unterscheidung ist das gesamte Thema der Taxonomie des Look-ahead-Bias. Wenn du Kanten aus der vollständigen Stichprobe verwendest, sage es und höre vor dem Wort "Signal" auf.

Transfer Entropy von Grund auf

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

Effektive TE mit einem Block-Bootstrap-Nullmodell

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

Die paarweise Matrix

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

Der schnelle Pfad

pyinform kapselt eine optimierte C-Implementierung:

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)

Nullkalibrierung

Dies ist der wertvollste Teil der Analyse und zugleich derjenige, der am häufigsten übersprungen wird. Bevor du irgendeiner Kante im gemessenen Netzwerk vertraust, führe die gesamte Pipeline aus — Diskretisierung, effektive TE, Surrogattest und Signifikanzfilter — auf Daten aus, bei denen die wahre Antwort bekanntermaßen null ist:

1. Gemischte reale Renditen. Zerstöre die Zeitabstimmung zwischen den Reihen, behalte aber die Randverteilung jeder Reihe bei.
2. Synthetisch unabhängige Reihen. Simuliere $M$ unabhängige Prozesse mit schweren Tails und Volatilitätsclustering, die konstruktionsbedingt keine Kreuzabhängigkeit besitzen.

Berichte anschließend über den Anteil der geordneten Paare, die der Test bei $\alpha = 0.05$ markiert. Liegt dieser Anteil nicht nahe bei 0.05, ist der Test fehlkalibriert und jede Kante im realen Netzwerk verdächtig.

Multiples Testen verschärft das Problem. Ein Universum aus 8 Assets ergibt $8 \times 7 = 56$ geordnete paarweise Tests; 20 Assets ergeben 380. Die Korrekturen — Bonferroni, Holm und Benjamini-Yekutieli-FDR — werden vollständig in deflationierter Sharpe-Ratio und multiplem Testen hergeleitet, zusammen mit der Kalibrierungsstudie, in der die FDR des naiven Tests 1.000 gegenüber 0.007 für BHY beträgt.

Bleibe aber nicht bei einem rohen Bonferroni stehen, denn diese 56 Tests sind keine 56 unabhängigen Blicke auf die Daten. Krypto-Assets sind stark miteinander korreliert — dieser Blog hat PC1 mit 65 % der Varianz gemessen —, genau der korrelierte-Raster-Fehlermodus, der in Akt 5 jenes Artikels dokumentiert ist. Dort führt die Behandlung der rohen Zellzahl eines korrelierten Rasters als Zahl der Versuche zu einer Überkorrektur und weist eine echte Kante fälschlich zurück. Das dortige Ergebnis war ein Band effektiver Versuchs-Schätzungen, kein einzelner Punkt: die Einzeiler-Formel auf Basis der Durchschnittskorrelation $N_{\text{eff}} = N/(1 + (N-1)\bar\rho)$ am weichen Ende sowie die Eigenwertschätzer (Partizipationsverhältnis, PCA-95 %, Kaiser) in der vertretbaren Mitte. Berichte das effektive-$N$-Band für das TE-Raster und prüfe, ob die verbleibenden Kanten über das gesamte Band stabil sind.

Sensitivität: die zwei freien Parameter

Beide Parameter werden meist nach einer Faustregel gesetzt und danach nie wieder überprüft. Stattdessen müssen sie gesweept und die Anführer-/Folger-Rangfolge für jede Zelle berichtet werden.

Verlaufslänge $k$

$k$ steuert, wie viel der eigenen Vergangenheit des Ziels berücksichtigt wird. Ist sie zu klein, schreibst du der Quelle die eigene Autokorrelation des Ziels zu; ist sie zu groß, wird die gemeinsame Verteilung zu dünn besetzt, um sie zu schätzen — die Zahl gemeinsamer Zustände ist $|\mathcal{A}|^{k+l+1}$. Bei 3 Bins, $k=2$ und $l=1$ ergeben sich also $3^4 = 81$ Zustände, während $k=5$ zu $3^7 = 2187$ führt, bei nur wenigen tausend Beobachtungen.

Die üblichen Ausgangspunkte sind $k \in \{1, 2\}$ für Stundendaten und $k \in \{1, \dots, 5\}$ für Tagesdaten, optional gegengeprüft mit AIC/BIC auf dem entsprechenden VAR-Lag. Behandle sie als das zu sweepende Raster, nicht als die Antwort.

Diskretisierung

• 3 Bins (abwärts / flach / aufwärts): robust, funktioniert mit begrenzten Daten und erfasst nur die Richtungsstruktur.
• 5 Bins: erfassen die Größenordnung, benötigen aber deutlich mehr Daten.
• Quantilkanten: annähernd gleiche Belegung, keine leeren Bins — siehe jedoch die obige Warnung vor Leakage.
• Ordinale/symbolische Kodierung: im Stil der Permutationsentropie, robust gegenüber monotonen Transformationen.

Kontinuierliche kernelbasierte TE vermeidet den Diskretisierungsverlust vollständig, kostet aber Bandbreitenauswahl und erheblich mehr Rechenzeit.

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

Die Frage lautet nicht "Wie ist die Rangfolge?", sondern "Ist die Rangfolge in jeder Zelle gleich?" Wenn ein Asset nur bei $k=2$, $n_{\text{bins}}=3$ ein Netto-Sender ist, ist diese Instabilität das Ergebnis und sollte als solche berichtet werden.

Confounding: bedingte Transfer Entropy

Wenn sowohl $X$ als auch $Y$ von einem latenten Faktor $Z$ getrieben werden, meldet paarweise TE einen Fluss zwischen ihnen, der vollständig ein Artefakt des gemeinsamen Treibers ist. In einem Ein-Faktor-Markt ist das kein Sonderfall, sondern die Standarderwartung. Bedingte Transfer Entropy konditioniert ihn heraus:

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

Jede Behauptung, dass SOL Informationen an AVAX sendet, sollte unter Konditionierung auf BTC erneut getestet werden. Verschwindet der Fluss, war das paarweise Ergebnis der als Kostüm verkleidete Marktfaktor.

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

Konditionieren ist nicht kostenlos: Jede Konditionierungsvariable multipliziert den gemeinsamen Zustandsraum mit $|\mathcal{A}|^{l}$, daher benötigt bedingte TE bei demselben $k$ erheblich mehr Daten als die paarweise Version.

Stabilität und die Frage, ob sich irgendetwas davon handeln lässt

Informationsfluss ist nicht statisch — und in diesem Markt ist es auch sonst nichts, was die Ausgangsprämisse der Regimeerkennung mit HMMs und der Grund dafür ist, dass jede Schätzung hier über Fenster erfolgen muss, statt einmalig angepasst zu werden. Die Version dieser Analyse mit rollierenden Fenstern übernimmt allerdings ein bekanntes Ergebnis, anstatt eines zu entdecken. Dass sich die Kryptoabhängigkeit in einer Krise verdichtet, ist bereits mit Zahlen veröffentlicht: die Signalkorrelation zwischen Paaren tabelliert eine durchschnittliche Signalkorrelation von 0.15 in Seitwärtsmärkten bis 0.90 in Panik, wobei $N_{\text{eff}}$ von 4.2 auf 1.1 fällt, und DCC-GARCH macht in Anwendung 3 aus der durchschnittlichen paarweisen Korrelation ein Risikoaversion-Regimesignal mit einem rollierenden Quantil-Flag und dem ausdrücklichen Vorbehalt "Dies ist ein Risikosignal, kein Alpha-Signal".

Die Freeman-Zentralisierung der TE-Ausgangsstärke ist ein anderer Skalar auf einer anderen Matrix, aber es ist dieselbe Bewegung: ein $d \times d$ großes Abhängigkeitsobjekt auf eine Zahl zu reduzieren und zu beobachten, wie sie steigt. Der Maßstab lautet daher nicht "Steigt die Zentralisierung vor Drawdowns?", sondern Übertrifft sie die durchschnittliche paarweise Korrelation als Risikoaversion-Signal? — im direkten Vergleich, auf denselben Fenstern und gegenüber denselben Drawdowns gemessen.

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)

Zwei Fragen müssen beantwortet werden, bevor eine nachgelagerte Anwendung das Schreiben wert ist:

1. Bleibt die Anführer-Rangfolge außerhalb der Stichprobe bestehen? Passe das Netzwerk im Fenster $t$ an und prüfe die Rangfolge im Fenster $t+1$. Berichte die Rangkorrelation über die Fenster. Eine Rangfolge, die sich jede Woche neu mischt, beschreibt Rauschen.
2. Fügt der TE-Filter einem Lead-Lag-Trade etwas hinzu? Das richtige Experiment ist ein einziger kontrollierter Vergleich: dieselbe rollierende Z-Score-Einstiegs-/Ausstiegslogik aus statistischem Arbitragehandel und Pair-Trading und dem Distanzansatz, zweimal ausgeführt, wobei das Vorhandensein des TE-Signifikanzfilters der einzige Unterschied ist und Gebühren einbezogen werden.

Für diesen Artikel wurde keines von beiden ausgeführt. Kein Lead-Lag-Backtest, kein Informations-Momentum-Portfolio, kein Vergleich der Regimeerkennung. Die Gewichtskonstruktionsmechanik für ein hypothetisches Informations-Momentum-Segment wird in verglichenen Portfolio-Optimierungsalgorithmen behandelt — aber beachte, dass ein Softmax über die rohe Netto-Stärke in Bits skalenabhängig beliebig ist und vor einer sinnvollen Interpretation ein Normalisierungsargument benötigt. Ungetesteter Strategiekode wird hier nicht ausgeliefert.

Kosten

TE ist $O(N)$ pro Paar, aber die Konstante wird durch die Zahl gemeinsamer Zustände $|\mathcal{A}|^{k+l+1}$ und durch die Zahl der Surrogate bestimmt. Für $M$ Assets und $B$ Bootstrap-Replikate benötigst du $M(M-1)B$ TE-Auswertungen — bei 50 Assets und 200 Surrogaten sind das 490.000. Die Kosten pro Auswertung hängen vollständig von deiner Hardware, der pyinform-Version und $N$ ab; miss sie auf deinem eigenen Rechner, statt einer zitierten Zahl zu vertrauen. Drei Hebel, wenn es zu langsam ist:

• Parallelisieren. Jedes Paar ist unabhängig — joblib oder multiprocessing.
• Vorfiltern. Berechne zuerst die rohe TE; führe Surrogate nur für Paare oberhalb eines Schwellenwerts aus. (Beachte, dass der Signifikanztest dadurch davon abhängig wird, den Vorfilter zu bestehen; das muss berücksichtigt werden.)
• Universum verkleinern. Zuerst clustern, dann TE zwischen den Clusterrepräsentanten berechnen.

Zusammenfassung

Transfer Entropy ist ein begründetes, modellfreies Maß für gerichteten Informationsfluss und füllt eine echte Lücke im Werkzeugkasten dieses Blogs: DCC-GARCH sagt, wann sich die Abhängigkeit verdichtet; TE sagt, in welche Richtung sie zeigt. Für Gauß-Prozesse fällt sie über $T = \tfrac{1}{2}\ln(1 + F)$ exakt auf die Granger-Kausalität zurück, was sie zu einer Verallgemeinerung und nicht zu einer Konkurrenz macht.

Was sie noch nicht ist, ist ein Ergebnis. Die Pipeline ist implementiert und die Fehlermodi sind aufgezählt — Endstichproben-Bias, der durch Surrogate korrigiert wird, Ganzserien-Binning als Look-ahead-Leakage, ein korreliertes Raster aus 56 Tests, das naive Korrekturen für multiples Testen bricht, Confounding durch einen gemeinsamen Treiber in einem Ein-Faktor-Markt sowie freie Parameter, die die Antwort durchaus bestimmen können. Jeder einzelne Punkt ist ein Grund, einem unkalibrierten TE-Netzwerk zu misstrauen. Ein Netzwerk ohne Nullkalibrierung, Sensitivitätssweep und Stabilitätsprüfung außerhalb der Stichprobe zu veröffentlichen, hieße, die Fehlermodi als Befunde auszugeben.

Referenzen

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