LLM Alpha Mining: Wie man Trading-Signale aus Earnings Calls und Finanzdokumenten extrahiert

An der Wall Street gibt es einen Witz: "Die wertvollste Information in einem Earnings Call ist nicht, was der CEO gesagt hat, sondern wie er es gesagt hat." Wenn Tim Cook sagt "wir sind vorsichtig optimistisch" statt des letztjährigen "wir sind sehr zufrieden" — das ist kein Sprachspiel, das ist ein Signal im Wert von Hunderten Millionen Dollar.

Seit Jahrzehnten versuchen Quant-Fonds, die Extraktion dieser Signale zu systematisieren. Zuerst zählten sie die Häufigkeit "positiver" und "negativer" Wörter mithilfe von Wörterbüchern. Dann setzten sie BERT ein. Und jetzt haben wir GPT-4o, Claude und Open-Source-LLMs, die die Feinheiten des Corporate-Doublespeak mit einer Genauigkeit analysieren können, die selbst die Forscher selbst erschreckt.

Lassen Sie uns aufschlüsseln, wie man eine vollwertige Pipeline zur Extraktion von Trading-Signalen aus Earnings Calls aufbaut — vom Erhalt des Transkripts bis zum Backtesting kumulativer abnormaler Renditen.

Warum Earnings Calls eine Goldgrube für Alpha sind

Post-Earnings Announcement Drift: Die Anomalie, die nicht sterben will

1968 entdeckten Ball und Brown etwas Merkwürdiges: Nach der Veröffentlichung der Quartalsergebnisse driften Aktien noch weitere 60-90 Tage in Richtung der "Überraschung" weiter. Sie nannten es Post-Earnings Announcement Drift (PEAD). Seitdem ist mehr als ein halbes Jahrhundert vergangen, Hunderte von Papern wurden geschrieben, die Anomalie wurde aus einem Dutzend Blickwinkeln erklärt — und sie funktioniert immer noch.

PEAD ist eine der beständigsten Marktanomalien in der Geschichte der Finanzwelt. Eine Portfolio-Strategie "kaufe positive Überraschung, verkaufe negative Überraschung" hat historisch 10-25% jährliche Überschussrendite erzielt. Warum hat der Markt das nicht wegarbitriert? Mehrere Gründe:

• Begrenzte Investorenaufmerksamkeit — wenn 200 Unternehmen in derselben Woche berichten, ist es physisch unmöglich, alle Transkripte zu lesen
• Kognitive Komplexität — ein Earnings Call dauert 45-60 Minuten, und das Schlüsselsignal kann in einem einzigen Satz in der 38. Minute der Q&A-Sitzung vergraben sein
• Sprachliche Mehrdeutigkeit — der CFO sagt "wir navigieren durch Gegenwind", und ohne Kontext ist unklar, ob das eine sanfte Warnung oder Standard-Absicherung ist

Hier betreten LLMs die Bühne. Zum ersten Mal haben wir ein Werkzeug, das 500 Transkripte an einem Abend verarbeiten kann, während es Nuancen erfasst, die selbst erfahrene Analysten übersehen würden.

PEAD.txt: Text ist wichtiger als Zahlen

Forscher der Federal Reserve Bank of Philadelphia (Meursault, Liang, Routledge, Scanlon) veröffentlichten das PEAD.txt-Paper, das Annahmen über den Wert textueller Informationen umstieß. Sie bauten ein textbasiertes Analogon der Standard-Earnings-Überraschung — SUE.txt — das den numerischen Earnings-Wert überhaupt nicht verwendet.

Das Ergebnis? SUE.txt erzeugt einen Drift, der doppelt so groß ist wie das klassische PEAD. Darüber hinaus: In den letzten Jahren, während das klassische PEAD basierend auf numerischen Überraschungen praktisch verschwunden ist (der Markt hat gelernt), bleibt der textuelle Drift signifikant. Der Markt hat gelernt, Zahlen schnell zu verarbeiten, kämpft aber weiterhin mit der Textinterpretation.

Dies ist das grundlegende Argument für einen NLP-basierten Ansatz bei Earnings Calls.

Von Sentiment zu Semantik: Evolution der Ansätze

Erste Generation: Bag-of-Words und Wörterbücher (2000-2015)

Alles begann mit dem Loughran-McDonald-Wörterbuch (2011) — einer Wortliste, die als "positiv", "negativ", "unsicher" und "streitbefangen" gekennzeichnet ist. Die Idee war elegant in ihrer Einfachheit: Zähle den Prozentsatz negativer Wörter in einer 10-K-Einreichung und handle darauf.

Das Problem? Das Wort "outstanding" bedeutet im finanziellen Kontext häufiger "ausstehende Schuld" als "hervorragendes Ergebnis". Das Wort "Risiko" im Risikomanagement ist kein negatives Signal — es ist eine Prozessbeschreibung. Standard-NLP-Sentiment-Wörterbücher schnitten bei Finanztexten peinlich schlecht ab.

Loughran und McDonald erstellten ein spezialisiertes Wörterbuch, das die Situation verbesserte, aber das grundlegende Problem blieb bestehen: Bag-of-Words versteht keinen Kontext. "Wir haben es nicht versäumt, die Erwartungen zu erfüllen" — hier stehen zwei "negative" Wörter, aber die Bedeutung ist positiv.

Zweite Generation: FinBERT und Transformer (2019-2023)

2019 veröffentlichte Dogu Araci FinBERT — BERT, feinjustiert auf Finanztexten von Reuters TRC2. Die Ergebnisse waren beeindruckend: eine Verbesserung um 14 Prozentpunkte auf dem Financial-PhraseBank-Datensatz gegenüber dem State-of-the-Art. FinBERT verstand Kontext: "outstanding" neben "debt" — negativ, neben "performance" — positiv.

Aber FinBERT hatte eine Einschränkung: ein Kontextfenster von 512 Token. Ein Earnings Call umfasst 8.000-12.000 Wörter. Die Aufteilung in Chunks und die Durchschnittsbildung des Sentiments bedeutet den Verlust der Semantik zwischen Absätzen. Der CEO könnte mit Optimismus beginnen und dann während der Q&A beiläufig Probleme in der Lieferkette erwähnen. FinBERT analysiert jeden Chunk unabhängig und übersieht diesen Kontrast.

Dritte Generation: LLMs mit langem Kontext (2023-heute)

GPT-4, Claude, Gemini mit Kontextfenstern von 128K-1M Token haben die Spielregeln verändert. Jetzt kann man ein komplettes Transkript auf einmal laden und Fragen stellen, die ein Verständnis des gesamten Dokuments erfordern.

Die Schlüsselstudie — Lopez-Lira & Tang (2023) "Can ChatGPT Forecast Stock Price Movements?" Bei über 50.000 Schlagzeilen zeigte GPT-4 eine Trefferquote von ~90% bei der Vorhersage der Richtung der anfänglichen Marktreaktion und sagte signifikant den nachfolgenden Drift voraus, insbesondere bei Small-Cap-Unternehmen und negativen Nachrichten. Frühere Modelle (GPT-1, GPT-2, BERT) zeigten diese Fähigkeit nicht — die prädiktive Kraft entsteht als emergente Eigenschaft großer Modelle.

BloombergGPT (2023) — ein Modell mit 50 Milliarden Parametern, trainiert auf Bloombergs Finanzkorpus — zeigte Verbesserungen bei finanzieller NER, Nachrichtenklassifizierung und Sentiment-Analyse. FinGPT — seine Open-Source-Alternative — erreicht 89% Genauigkeit bei Finanz-Sentiment-Aufgaben mithilfe eines datenzentrierten Ansatzes und RAG.

MarketSenseAI, das GPT-4 mit Chain-of-Thought und In-Context Learning für die S&P-100-Analyse verwendet, zeigte eine Überschussalpha von 10-30% und kumulative Renditen von bis zu 72% über 15 Monate Testzeit. Ja, diese Zahlen sollten mit Vorsicht betrachtet werden (Backtest ≠ Live-Trading), aber der Trend ist klar.

Daten-Pipeline: Woher man die Daten bekommt

SEC EDGAR: Die offizielle Quelle

Für US-Aktien ist die primäre Quelle SEC EDGAR. Earnings Calls werden normalerweise nicht direkt eingereicht, aber verwandte Dokumente sind verfügbar:

• 8-K-Einreichungen (Item 2.02 — Betriebsergebnisse) — Pressemitteilungen mit Ergebnissen, oft einschließlich Exhibit 99 mit dem Transkript
• 10-Q / 10-K — Quartals- und Jahresberichte mit Management Discussion & Analysis (MD&A) — ebenfalls eine wertvolle Textquelle
• DEF 14A — Proxy Statements mit Informationen zur Managementvergütung

from edgar import Company

company = Company("AAPL")
filings = company.get_filings(form="8-K")

for filing in filings.latest(10):
    if "2.02" in str(filing.items):
        doc = filing.document()
        text = doc.text()  # Full text with exhibits
        print(f"{filing.filing_date}: {len(text)} chars")

Seeking Alpha und kommerzielle APIs

Earnings-Call-Transkripte sind ein separates Produkt. Seeking Alpha war historisch die wichtigste kostenlose Quelle, schränkt den Zugang aber inzwischen ein. Kommerzielle Optionen:

• Seeking Alpha Premium API — vollständige Transkripte mit Sprecherkennzeichnung
• AlphaVantage Earnings API — kostenlose Stufe mit Einschränkungen
• Financial Modeling Prep — Transkripte + Fundamentaldaten
• Earnings Call Edge / Motley Fool Transcripts — alternative Quellen

Krypto: Governance Calls und DAO-Proposals

Hier wird es interessant. Große DeFi-Protokolle halten ihr Äquivalent zu Earnings Calls ab:

• Uniswap — Governance Calls, Community Calls, Aufzeichnungen auf YouTube
• Aave — monatliche Community Calls + Governance-Forum-Proposals
• MakerDAO — Governance Calls + umfangreiche Forendiskussionen
• Compound — Governance-Proposals mit detaillierten Diskussionen

Krypto-Call-Transkripte sind normalerweise unstrukturiert. Die Lösung — OpenAIs Whisper zur Transkription von YouTube-Aufzeichnungen:

import openai
from yt_dlp import YoutubeDL

def transcribe_governance_call(youtube_url: str) -> str:
    """Download audio from YouTube and transcribe via Whisper."""
    ydl_opts = {
        'format': 'bestaudio/best',
        'postprocessors': [{
            'key': 'FFmpegExtractAudio',
            'preferredcodec': 'mp3',
            'preferredquality': '64',  # Low bitrate is sufficient for speech
        }],
        'outtmpl': '/tmp/governance_call.%(ext)s',
    }

    with YoutubeDL(ydl_opts) as ydl:
        ydl.download([youtube_url])

    client = openai.OpenAI()

    with open("/tmp/governance_call.mp3", "rb") as audio_file:
        transcript = client.audio.transcriptions.create(
            model="whisper-1",
            file=audio_file,
            response_format="verbose_json",
            timestamp_granularities=["segment"]
        )

    return transcript.text

Die Kosten der Transkription über die Whisper API: $0,006/Min. Ein einstündiger Governance Call kostet ~$0,36. Für eine Self-Hosted-Option — Whisper Large-v3 Turbo transkribiert eine 60-minütige Datei in ~17 Sekunden (216x Echtzeit) auf einer modernen GPU.

LLM-Prompting-Strategien: Von naiv bis produktionsreif

Strategie 1: Direktes Sentiment (schwach)

Der naivste Ansatz — das Modell direkt fragen:

"Ist dieser Earnings Call positiv oder negativ für den Aktienkurs?"

Funktioniert das? Ja, überraschenderweise. Lopez-Lira & Tang zeigten, dass selbst ein solch primitiver Prompt statistisch signifikante Vorhersagen liefert. Aber es gibt Probleme:

• Binäre Ausgabe — man verliert Abstufungen. "Katastrophe" und "milde Enttäuschung" erhalten das gleiche Label
• Keine Erklärung — es ist unklar, worauf das Modell seine Entscheidung stützt
• Instabilität — ein wiederholter Durchlauf kann eine andere Antwort geben

Strategie 2: Strukturierte Extraktion mit Chain-of-Thought (stark)

Die Idee: Anstatt einer einzelnen Zahl wird ein strukturierter Satz von Signalen extrahiert, wobei das Modell gezwungen wird, jeden Schritt zu erklären.

from pydantic import BaseModel, Field
from openai import OpenAI
from enum import Enum
from typing import Optional


class SentimentLevel(str, Enum):
    VERY_BEARISH = "very_bearish"
    BEARISH = "bearish"
    NEUTRAL = "neutral"
    BULLISH = "bullish"
    VERY_BULLISH = "very_bullish"


class GuidanceSurprise(BaseModel):
    """Deviation of forward guidance from consensus expectations."""
    revenue_guidance_vs_consensus: Optional[float] = Field(
        None, description="% deviation of revenue guidance from consensus"
    )
    margin_guidance_direction: Optional[str] = Field(
        None, description="expanding / stable / contracting"
    )
    key_quote: str = Field(
        description="Verbatim quote with guidance"
    )
    reasoning: str = Field(
        description="CoT: why this guidance matters"
    )


class ConfidenceMetrics(BaseModel):
    """Management confidence metrics."""
    hedge_word_count: int = Field(
        description="Number of hedge words: 'approximately', 'potentially', 'subject to'"
    )
    forward_looking_ratio: float = Field(
        description="Ratio of forward-looking statements to total statements"
    )
    q_and_a_evasion_count: int = Field(
        description="Number of questions where CEO/CFO gave an evasive answer"
    )
    ceo_vs_cfo_sentiment_delta: float = Field(
        description="Sentiment difference between CEO and CFO (-1 to 1). Divergence is a red flag"
    )


class CompetitiveIntelligence(BaseModel):
    """Mentions of competitors and market position."""
    competitors_mentioned: list[str] = Field(
        description="List of mentioned competitors"
    )
    market_share_claims: list[str] = Field(
        description="Market share claims"
    )
    new_product_signals: list[str] = Field(
        description="Signals about new products/services"
    )


class ManagementSignals(BaseModel):
    """Management signals."""
    turnover_risk: SentimentLevel = Field(
        description="Risk of key management turnover"
    )
    tone_shift_from_previous: Optional[str] = Field(
        None, description="How tone changed compared to last quarter"
    )
    insider_language_flags: list[str] = Field(
        description="Marker phrases: 'exploring strategic alternatives', 'right-sizing', etc."
    )


class EarningsCallAnalysis(BaseModel):
    """Complete earnings call analysis."""
    ticker: str
    quarter: str
    overall_sentiment: SentimentLevel
    sentiment_score: float = Field(description="from -1.0 to 1.0")
    guidance_surprise: GuidanceSurprise
    confidence_metrics: ConfidenceMetrics
    competitive_intel: CompetitiveIntelligence
    management_signals: ManagementSignals
    key_risks: list[str]
    key_catalysts: list[str]
    one_line_summary: str


def analyze_earnings_call(transcript: str, ticker: str, quarter: str) -> EarningsCallAnalysis:
    """
    Extract structured signals from an earnings call.
    Cost: ~$0.15-0.30 per call (GPT-4o, ~10K tokens input).
    """
    client = OpenAI()

    system_prompt = """You are a senior equity research analyst with 20 years of experience.
Analyze the following earnings call transcript and extract structured trading signals.

IMPORTANT INSTRUCTIONS:
1. Use Chain-of-Thought reasoning for each field — explain WHY before giving the value
2. Focus on DEVIATIONS from expectations, not absolute statements
3. Pay special attention to Q&A section — management is less scripted there
4. Compare management's language to typical corporate hedging baseline
5. Flag any "strategic alternatives", "right-sizing", or other euphemisms
6. Score sentiment relative to market expectations, not in absolute terms

HEDGE WORDS TO COUNT: approximately, potentially, subject to, may, might,
could, uncertain, challenging, headwinds, navigate, prudent, cautious,
evolving, dynamic, unprecedented, transitional"""

    completion = client.beta.chat.completions.parse(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": f"Ticker: {ticker}\nQuarter: {quarter}\n\n{transcript}"}
        ],
        response_format=EarningsCallAnalysis,
        temperature=0.1,  # Low temperature for reproducibility
    )

    return completion.choices[0].message.parsed

Beachten Sie mehrere Schlüsselpunkte:

Pydantic-Schema — OpenAI Structured Outputs garantiert 100% Schema-Konformität. Kein "sorry, I cannot parse the JSON" mehr. Jedes Feld hat eine Beschreibung, die als Mini-Prompt für einen bestimmten Analyseaspekt fungiert.

Chain-of-Thought innerhalb des Schemas — die Felder reasoning und key_quote zwingen das Modell dazu, "seine Arbeit zu zeigen". Dies verbessert nicht nur die Qualität (das Modell ist gezwungen, ein konkretes Zitat zu finden, bevor es ein Urteil fällt), sondern schafft auch einen Audit-Trail für Regulierungsbehörden.

Temperatur 0,1 — wir wollen keine Kreativität. Wir brauchen Reproduzierbarkeit. Bei Temperatur 0 bleibt das Modell manchmal in Mustern "hängen"; 0,1 ist der optimale Kompromiss.

Strategie 3: Few-Shot mit historischen Beispielen

Noch mächtiger — dem Modell Beispiele vergangener Earnings Calls mit tatsächlichen Marktreaktionen geben:

few_shot_examples = """
EXAMPLE 1:
Transcript excerpt: "We are cautiously optimistic about the second half...
While we continue to navigate macro headwinds, our pipeline remains robust."
Actual market reaction: -3.2% (next day)
Analysis: Despite surface-level positivity, "cautiously optimistic" is a
DOWNGRADE from previous quarter's "very confident". Five hedge words in
two sentences. Market read through the hedging.

EXAMPLE 2:
Transcript excerpt: "Frankly, demand has exceeded our ability to supply.
We're expediting CapEx to address this."
Actual market reaction: +7.8% (next day)
Analysis: "Frankly" signals genuine surprise even from management.
Accelerated CapEx on demand = strong confidence. No hedging language.
"""

Few-Shot-Beispiele helfen dem Modell bei der Kalibrierung: Es lernt, dass "cautiously optimistic" in der Wall-Street-Sprache nicht positiv ist — es ist ein sanftes Negativ. Ohne Beispiele könnte das LLM Wörter wörtlich interpretieren.

Vier Arten von Signalen

1. Guidance Surprise

Das direkteste Signal. Ein Unternehmen gibt eine Prognose (Guidance) für das nächste Quartal/Jahr ab, und der Markt reagiert auf die Abweichung vom Konsens. Ein LLM kann Guidance extrahieren, selbst wenn das Management sie vage kommuniziert:

• "We expect revenues in the range of..." — direkte Guidance, leicht zu parsen
• "We feel comfortable with current Street estimates" — implizite Bestätigung des Konsens
• "There are puts and takes relative to consensus" — implizites Risikosignal

Ein LLM versteht alle drei Formulierungen; Regex versteht nur die erste.

2. Confidence Metrics: Hedge-Word-Dichte

Das ist mein Lieblingssignal, weil es kontraintuitiv ist. Der Kern: Manager sind Menschen mit juristischer Ausbildung und paranoiden Rechtsabteilungen. Wenn es gut läuft, erlauben sie sich, konkret zu sein. Wenn Probleme aufziehen — beginnen sie zu hedgen.

Zu verfolgende Metriken:

Der letzte Punkt ist besonders interessant. Der CEO ist ein Geschichtenerzähler — sein Job ist es, ein schönes Bild zu malen. Der CFO ist derjenige, der den Prüfern gegenüber rechenschaftspflichtig ist. Wenn der CEO sagt "transformative growth ahead" und der CFO sofort einwirft "while maintaining disciplined cost management" — signalisiert diese Divergenz interne Spannungen.

3. Competitive Intelligence

Ein LLM kann Konkurrentenerwähnungen aus einem Transkript extrahieren, selbst wenn das Management direkte Namen vermeidet. "The largest player in the market" — das ist für GPT-4 kein Rätsel, wenn es die Branche kennt.

Trading-Signal: Wenn Unternehmen A in seinem Earnings Call Konkurrent B in negativem Kontext erwähnt ("we're taking share from..."), ist das nicht nur ein Signal für A (Long), sondern auch für B (Short). Ein Pairs Trade.

4. Management-Turnover-Signale

Marker-Phrasen für Managementwechsel oder strategische Kurswechsel:

• "Exploring strategic alternatives" — wahrscheinlicher Unternehmensverkauf
• "Right-sizing our operations" — Massenentlassungen
• "The board has initiated a comprehensive review" — der CEO wird bald gehen
• "We're bringing in fresh perspectives" — das aktuelle Team hat versagt

Jede dieser Phrasen hat eine statistisch signifikante Korrelation mit der nachfolgenden Kursdynamik. Ein LLM kann sie mit null falsch-positiven Ergebnissen erkennen — weil es Kontext versteht, im Gegensatz zu Regex, das "strategic alternatives" in einer Produktlinienbeschreibung fälschlich erfassen könnte.

Backtesting: Event-Study-Methodik

Wir generieren Signale — großartig. Aber funktionieren sie? Die Standard-Verifikationsmethode ist eine Event Study mit der Berechnung kumulativer abnormaler Renditen (CAR).

Methodik

1. Das Ereignis definieren — das Datum des Earnings Calls
2. Schätzfenster — [-250, -30] Handelstage vor dem Ereignis, um "normale" Renditen zu schätzen
3. Ereignisfenster — [-1, +60] Tage rund um das Ereignis
4. Normale Renditen berechnen über das Marktmodell: $R_{it} = \alpha_i + \beta_i R_{mt} + \epsilon_{it}$
5. Abnormale Rendite — die Differenz zwischen tatsächlicher und "normaler" Rendite
6. CAR — kumulative Summe der abnormalen Renditen über das Ereignisfenster

import numpy as np
import pandas as pd
from scipy import stats
from dataclasses import dataclass


@dataclass
class EventStudyResult:
    car: np.ndarray          # Cumulative abnormal returns by day
    t_stats: np.ndarray      # t-statistics for each day
    avg_car_3d: float        # CAR[-1, +1]
    avg_car_30d: float       # CAR[-1, +30]
    avg_car_60d: float       # CAR[-1, +60]
    p_value_3d: float
    p_value_30d: float
    n_events: int


def run_event_study(
    returns: pd.DataFrame,       # Daily stock returns (columns = tickers)
    market_returns: pd.Series,   # Daily market index returns
    events: pd.DataFrame,        # DataFrame with columns: [ticker, date, signal_score]
    estimation_window: int = 220,
    gap: int = 30,
    event_window: tuple = (-1, 60),
) -> EventStudyResult:
    """
    Event study to evaluate the predictive power of LLM signals.

    Sort events by signal_score, form long/short portfolios,
    calculate CAR and test statistical significance.
    """
    all_cars = []

    for _, event in events.iterrows():
        ticker = event['ticker']
        event_date = event['date']

        if ticker not in returns.columns:
            continue

        try:
            event_idx = returns.index.get_loc(event_date, method='ffill')
        except KeyError:
            continue

        est_start = event_idx - estimation_window - gap
        est_end = event_idx - gap

        if est_start < 0:
            continue

        y = returns.iloc[est_start:est_end][ticker].values
        x = market_returns.iloc[est_start:est_end].values

        mask = ~(np.isnan(y) | np.isnan(x))
        if mask.sum() < 60:  # Minimum 60 observations
            continue

        y_clean, x_clean = y[mask], x[mask]

        slope, intercept, _, _, _ = stats.linregress(x_clean, y_clean)
        residual_std = np.std(y_clean - (intercept + slope * x_clean))

        ev_start = event_idx + event_window[0]
        ev_end = event_idx + event_window[1] + 1

        if ev_end > len(returns):
            continue

        actual = returns.iloc[ev_start:ev_end][ticker].values
        market = market_returns.iloc[ev_start:ev_end].values

        expected = intercept + slope * market
        ar = actual - expected
        car = np.cumsum(ar)

        all_cars.append(car)

    if not all_cars:
        raise ValueError("No valid events found")

    min_len = min(len(c) for c in all_cars)
    all_cars = np.array([c[:min_len] for c in all_cars])

    mean_car = np.mean(all_cars, axis=0)
    std_car = np.std(all_cars, axis=0) / np.sqrt(len(all_cars))
    t_stats = mean_car / (std_car + 1e-10)

    offset = -event_window[0]  # Shift to event date

    car_3d = mean_car[min(offset + 1, min_len - 1)] if min_len > offset + 1 else mean_car[-1]
    car_30d = mean_car[min(offset + 30, min_len - 1)] if min_len > offset + 30 else mean_car[-1]
    car_60d = mean_car[min(offset + 60, min_len - 1)] if min_len > offset + 60 else mean_car[-1]

    n = len(all_cars)
    p_3d = 2 * (1 - stats.t.cdf(abs(car_3d / (np.std([c[min(offset+1, min_len-1)] for c in all_cars]) / np.sqrt(n) + 1e-10)), df=n-1))
    p_30d = 2 * (1 - stats.t.cdf(abs(car_30d / (np.std([c[min(offset+30, min_len-1)] for c in all_cars]) / np.sqrt(n) + 1e-10)), df=n-1))

    return EventStudyResult(
        car=mean_car,
        t_stats=t_stats,
        avg_car_3d=car_3d,
        avg_car_30d=car_30d,
        avg_car_60d=car_60d,
        p_value_3d=p_3d,
        p_value_30d=p_30d,
        n_events=n,
    )


def backtest_llm_signals(
    llm_signals: pd.DataFrame,  # [ticker, date, sentiment_score]
    returns: pd.DataFrame,
    market_returns: pd.Series,
):
    """Backtest: long top-quintile signals, short bottom-quintile."""

    llm_signals['quintile'] = pd.qcut(
        llm_signals['sentiment_score'], 5, labels=[1, 2, 3, 4, 5]
    )

    long_events = llm_signals[llm_signals['quintile'] == 5].copy()
    short_events = llm_signals[llm_signals['quintile'] == 1].copy()

    long_result = run_event_study(returns, market_returns, long_events)
    short_result = run_event_study(returns, market_returns, short_events)

    print(f"LONG portfolio (top quintile LLM sentiment):")
    print(f"  CAR[0,+3]:  {long_result.avg_car_3d:+.2%} (p={long_result.p_value_3d:.4f})")
    print(f"  CAR[0,+30]: {long_result.avg_car_30d:+.2%} (p={long_result.p_value_30d:.4f})")
    print(f"  N events:   {long_result.n_events}")

    print(f"\nSHORT portfolio (bottom quintile LLM sentiment):")
    print(f"  CAR[0,+3]:  {short_result.avg_car_3d:+.2%} (p={short_result.p_value_3d:.4f})")
    print(f"  CAR[0,+30]: {short_result.avg_car_30d:+.2%} (p={short_result.p_value_30d:.4f})")
    print(f"  N events:   {short_result.n_events}")

    ls_3d = long_result.avg_car_3d - short_result.avg_car_3d
    ls_30d = long_result.avg_car_30d - short_result.avg_car_30d
    print(f"\nLONG-SHORT spread:")
    print(f"  CAR[0,+3]:  {ls_3d:+.2%}")
    print(f"  CAR[0,+30]: {ls_30d:+.2%}")

Was wir zu sehen erwarten

Basierend auf bestehender Forschung, realistische CARs für LLM-Signale:

Der Schlüsselindikator ist statistische Signifikanz. Bei p < 0,01 und N > 200 Ereignissen kann man von einem robusten Signal sprechen. Bei p > 0,05 — könnte es Rauschen sein.

Produktions-Implementierung: Von Jupyter zu Prod

Real-time-Pipeline-Architektur

YouTube/Audio Stream
       │
       ▼
┌─────────────────┐    ┌──────────────────┐
│  Whisper         │───▶│  Transcript       │
│  Transcription   │    │  Buffer           │
│  (streaming)     │    │  (Redis Stream)   │
└─────────────────┘    └──────────────────┘
                              │
                    ┌─────────┴─────────┐
                    ▼                   ▼
            ┌──────────────┐   ┌──────────────┐
            │ Real-time    │   │ Full-call    │
            │ Chunk Anal.  │   │ Analysis     │
            │ (every 5min) │   │ (after call  │
            │              │   │  ends)       │
            └──────────────┘   └──────────────┘
                    │                   │
                    ▼                   ▼
            ┌──────────────────────────────┐
            │     Signal Aggregator        │
            │  (confidence-weighted merge) │
            └──────────────────────────────┘
                         │
                         ▼
            ┌──────────────────────────────┐
            │     Trading Engine           │
            │  (position sizing, risk mgmt)│
            └──────────────────────────────┘

Kostenanalyse: Wie viel kostet ein Earnings Call

Schlüsseln wir die Ökonomie der Verarbeitung eines einzelnen Earnings Calls in Produktion auf:

Moment, die Schätzung lag bei $30-50 pro Call. Woher kommen diese Zahlen? Es hängt vom Modell und Ansatz ab:

• Budget-Option (GPT-4o-mini, ein einzelner Durchlauf): $0,50-1,00
• Standard-Option (GPT-4o, strukturierte Extraktion + Chunk-Analyse): $2-5
• Premium-Option (GPT-4o, mehrere Durchläufe, Cross-Validierung, historischer Vergleich): $15-30
• Hedge-Fund-Klasse (mehrere Modelle + menschliche Überprüfung + Real-time-Streaming): $30-50+

Für einen Quant-Fonds, der 500 Ticker handelt, betragen die Kosten für die Verarbeitung einer Earnings-Saison (~2.000 Calls über 6 Wochen) $4.000-$10.000 bei der Standard-Option. Angesichts eines durchschnittlichen Alpha pro Position von 1-3% — ist der ROI astronomisch.

Latenz: Das Rennen um Millisekunden

In der HFT-Welt ist Latenz alles. Aber bei earnings-basierten Strategien ist die Situation anders:

1. Ein Earnings Call dauert 45-60 Minuten — man hat Zeit
2. PEAD erstreckt sich über 60 Tage — kein Bedarf, in der ersten Sekunde einzusteigen
3. Die Hauptdislokation geschieht in den ersten 30 Minuten nach Ende des Calls

Die optimale Strategie ist zweiphasig:

• Phase 1 (Real-time): Analyse von 5-Minuten-Chunks während des Calls, Bildung eines vorläufigen Signals
• Phase 2 (Post-Call): vollständige Analyse des gesamten Transkripts 2-5 Minuten nach Ende

Phase 1 bietet einen Vorsprung von 5-10 Minuten gegenüber Marktteilnehmern, die auf das Ende des Calls warten. Bei Mid-Cap-Aktien reicht das.

Erweiterung auf Krypto: DeFi Governance und DAO-Proposals

Der Kryptomarkt ist ein idealer Testbereich für LLM Alpha Mining. Hier ist warum:

1. Weniger institutionelle Akteure — bedeutet mehr Ineffizienz zum Ausnutzen
2. Governance = Earnings Call — DAO-Entscheidungen wirken sich direkt auf die Tokenomics aus
3. 24/7-Markt — man kann die Reaktion sofort handeln
4. Öffentliche Daten — alle Proposals und Abstimmungen sind on-chain

Arten von Krypto-Events für die Analyse

Governance Proposals (Aave, Compound, Uniswap)

Ein Proposal ändert Protokollparameter — Zinssätze, Sicherheitsfaktoren, Fee Switches. Ein LLM kann die wirtschaftliche Auswirkung bewerten:

crypto_analysis_prompt = """Analyze this DeFi governance proposal.
Extract:
1. Economic impact on token holders (positive/negative/neutral)
2. TVL impact estimate (increase/decrease/stable + magnitude)
3. Competitive positioning vs other protocols
4. Risk factors introduced by the proposal
5. Historical precedent (similar proposals in other protocols)
6. Likely voting outcome based on forum discussion sentiment

Proposal: {proposal_text}
Forum discussion: {discussion_text}
"""

Protocol-Update-Ankündigungen

Wenn Uniswap v4 mit Hooks ankündigt oder Aave GHO startet — ist das das Äquivalent eines Produktlaunches in TradFi. Ein LLM kann narrative Dynamik und technische Bedeutung bewerten.

Treasury-Reports

Große DAOs haben Treasuries im Wert von Hunderten Millionen. Quartalsweise Treasury-Reports sind ein direktes Analogon zu Earnings. Runway, Burn Rate, Diversifizierung — alles zugänglich für LLM-Analyse.

Besonderheiten von Krypto-Signalen

Im Gegensatz zu TradFi gilt in Krypto:

• On-Chain-Daten bestätigen oder widersprechen der Narrative — man kann das in Governance Calls Gesagte mit tatsächlichen Protokoll-Metriken (TVL, Volumen, aktive Nutzer) kreuzreferenzieren
• Whale-Wallets als Insider Trading — große Wallet-Bewegungen nach Governance-Diskussionen gehen der Abstimmung oft voraus
• Sentiment-Verstärkung durch CT (Crypto Twitter) — ein Signal aus einem Governance Call kann durch Twitter-Narrative verstärkt oder unterdrückt werden

Fallstricke und Einschränkungen

Halluzinationen: Wenn das Modell Zahlen erfindet

Ein LLM kann Guidance "extrahieren", die nicht im Transkript stand. Das ist besonders gefährlich bei der Analyse der Hedge-Word-Dichte: Das Modell kann mehr oder weniger Wörter zählen, als tatsächlich existieren.

Lösung: zweiphasige Verifikation. Das LLM extrahiert, deterministischer Code verifiziert. Für Hedge-Wörter — Regex-Zählung parallel zur LLM-Bewertung. Abweichung > 20% — für manuelle Überprüfung markieren.

import re

HEDGE_WORDS = [
    r'\bapproximately\b', r'\bpotentially\b', r'\bsubject to\b',
    r'\bmay\b', r'\bmight\b', r'\bcould\b', r'\buncertain\b',
    r'\bchallenging\b', r'\bheadwinds\b', r'\bnavigate\b',
    r'\bprudent\b', r'\bcautious\b', r'\bevolving\b',
    r'\bdynamic\b', r'\bunprecedented\b', r'\btransitional\b',
]

def verify_hedge_count(text: str, llm_count: int) -> dict:
    """Deterministic verification of LLM hedge word count."""
    regex_count = sum(
        len(re.findall(pattern, text, re.IGNORECASE))
        for pattern in HEDGE_WORDS
    )

    deviation = abs(llm_count - regex_count) / (regex_count + 1)

    return {
        "llm_count": llm_count,
        "regex_count": regex_count,
        "deviation": deviation,
        "needs_review": deviation > 0.2,
    }

Kontextfenster-Beschränkungen

Selbst 128K Token reichen möglicherweise nicht aus, wenn man Folgendes einspeisen möchte:

• Aktuelles Transkript (~10K Token)
• Vorheriges Transkript zum Vergleich (~10K)
• Analysten-Konsens-Prognosen (~2K)
• Few-Shot-Beispiele (~3K)
• System-Prompt (~1K)

Gesamt ~26K — passt gerade noch. Aber wenn man eine 10-K-Einreichung (~80-120K Token) für Kontext hinzufügt — ist man bereits am Limit. Lösung: RAG zum Abrufen relevanter Chunks aus langen Dokumenten.

Bias und systematische Fehler

LLMs werden auf historischen Daten trainiert, bei denen bestimmte Phrasen mit bestimmten Ergebnissen verknüpft waren. Aber der Markt passt sich an:

• Wenn alle anfangen, Hedge-Wörter mit GPT-4 zu zählen, werden Manager ihre Sprache ändern
• Das Modell kann die Bedeutung von Mustern aus den Trainingsdaten überbewerten (Survivorship Bias)
• Unternehmenssprache entwickelt sich weiter: "Synergien" bedeutete 2010 etwas anderes als 2026

Crowded-Trade-Risiko

Wenn 50 Quant-Fonds dasselbe GPT-4 verwenden, um dieselben Transkripte zu analysieren — degradiert das Signal. Eine Analogie: Als alle anfingen, PEAD auf numerische Überraschungen zu handeln, schrumpfte die Anomalie. Dasselbe wird mit textuellen Signalen passieren, aber mit Verzögerung:

1. Jetzt (2026) — wenige nutzen LLMs systematisch für Earnings Calls. Alpha ist signifikant
2. In 2-3 Jahren — breite Einführung, Alpha sinkt
3. In 5 Jahren — grundlegende LLM-Signale werden zur Commodity, Edge bleibt nur bei Custom-Modellen und einzigartigen Daten bestehen

Das ist der Standard-Lebenszyklus von Alpha-Signalen. Genießen Sie es, solange es dauert.

Statt eines Fazits: Ein Aktionsplan

Wenn Sie beginnen möchten, LLMs für die Earnings-Call-Analyse zu nutzen, hier ein Minimum Viable Plan:

1. Mit kostenlosen Daten beginnen — SEC EDGAR + EdgarTools für 8-K/10-Q-Einreichungen
2. Strukturierte Extraktion verwenden — Pydantic-Schemas über OpenAI Structured Outputs
3. Via Event Study backtesten — CAR auf historischen Daten, mindestens 200 Ereignisse
4. Few-Shot-Beispiele hinzufügen — 5-10 gelabelte Beispiele verbessern die Qualität radikal
5. Deterministisch verifizieren — LLM extrahiert, Regex verifiziert, Mensch prüft
6. Mit Mid-Cap beginnen — mehr Alpha, weniger Konkurrenz mit großen Fonds
7. Auf Krypto erweitern — Governance Calls und DAO-Proposals als unerschlossenes Terrain

Denken Sie an die Kardinalregel der quantitativen Analyse: wenn ein Signal zu gut klingt, um wahr zu sein — noch einmal prüfen. LLMs erzeugen eine Illusion des Verstehens, aber dahinter steckt statistisches Pattern Matching. Ein mächtiges Werkzeug — aber ein Werkzeug, kein Orakel.

Bibliografie

1. Ball, R., Brown, P. (1968). An Empirical Evaluation of Accounting Income Numbers. Journal of Accounting Research, 6(2), 159-178. — Erste Entdeckung von PEAD.

2. Bernard, V.L., Thomas, J.K. (1989). Post-Earnings-Announcement Drift: Delayed Price Response or Risk Premium? Journal of Accounting Research, 27, 1-36. — Kanonisches PEAD-Paper.

3. Loughran, T., McDonald, B. (2011). When Is a Liability Not a Liability? Textual Analysis, Dictionaries, and 10-Ks. Journal of Finance, 66(1), 35-65. — Finanzielles Sentiment-Wörterbuch.

4. Araci, D. (2019). FinBERT: Financial Sentiment Analysis with Pre-trained Language Models. arXiv:1908.10063. — BERT für finanzielles NLP, +14pp gegenüber SOTA.

5. Wu, S. et al. (2023). BloombergGPT: A Large Language Model for Finance. arXiv:2303.17564. — Bloombergs 50B-Parameter-Modell.

6. Yang, H. et al. (2023). FinGPT: Open-Source Financial Large Language Models. arXiv:2306.06031. — Open-Source-Alternative zu BloombergGPT, 89% Genauigkeit.

7. Lopez-Lira, A., Tang, Y. (2023). Can ChatGPT Forecast Stock Price Movements? Return Predictability and Large Language Models. arXiv:2304.07619. — GPT-4 sagt Renditen mit ~90% Trefferquote voraus.

8. Meursault, V., Liang, P.J., Routledge, B., Scanlon, M.M. (2023). PEAD.txt: Post-Earnings-Announcement Drift Using Text. Journal of Financial and Quantitative Analysis. — Textbasiertes PEAD ist doppelt so groß wie numerisches PEAD.

9. Fatouros, G. et al. (2024). Can Large Language Models Beat Wall Street? Evaluating GPT-4's Impact on Financial Decision-Making with MarketSenseAI. Neural Computing and Applications. — GPT-4-Framework mit 10-30% Überschussalpha auf S&P 100.

10. Chen, Y. et al. (2025). GPT-Signal: Generative AI for Semi-automated Feature Engineering in the Alpha Research Process. arXiv:2410.18448. — Automatische Generierung von Trading-Signalen via LLM.

11. Zhang, X. et al. (2025). Can LLMs Hit Moving Targets? Tracking Evolving Signals in Corporate Disclosures. arXiv:2510.03195. — Erkennung von "Moving Targets" in Unternehmenspublikationen.

12. Chen, Z. et al. (2025). Large Language Models in Equity Markets: Applications, Techniques, and Insights. Frontiers in Artificial Intelligence. — Übersicht über 84 LLM-Studien im Finanzwesen.

Dieser Artikel dient Bildungszwecken und stellt keine Anlageberatung dar. Alle hier beschriebenen Trading-Strategien erfordern gründliches Backtesting und Risikomanagement vor dem Einsatz mit echtem Kapital.