LLM Alpha Mining: Cómo extraer señales de trading de las conferencias de resultados y documentos financieros

Hay un chiste en Wall Street: "La información más valiosa de una conferencia de resultados no es lo que dijo el CEO, sino cómo lo dijo." Cuando Tim Cook dice "somos cautelosamente optimistas" en lugar del "estamos muy satisfechos" del año pasado — eso no es un juego lingüístico, es una señal que vale cientos de millones de dólares.

Durante décadas, los fondos cuantitativos han intentado sistematizar la extracción de estas señales. Primero contaron la frecuencia de palabras "positivas" y "negativas" usando diccionarios. Luego desplegaron BERT. Y ahora tenemos GPT-4o, Claude y LLMs de código abierto capaces de analizar las sutilezas del doblehablar corporativo con una precisión que asusta hasta a los propios investigadores.

Vamos a desglosar cómo construir un pipeline completo para extraer señales de trading de las conferencias de resultados — desde obtener la transcripción hasta el backtesting de rendimientos anormales acumulados.

Por qué las conferencias de resultados son una mina de oro para el alfa

Post-Earnings Announcement Drift: la anomalía que no muere

En 1968, Ball y Brown descubrieron algo extraño: después de publicarse los resultados trimestrales, las acciones siguen derivando en la dirección de la "sorpresa" durante otros 60-90 días. Lo llamaron Post-Earnings Announcement Drift (PEAD). Ha pasado más de medio siglo desde entonces, se han escrito cientos de artículos, la anomalía se ha explicado desde una docena de ángulos — y aún funciona.

PEAD es una de las anomalías de mercado más persistentes en la historia de las finanzas. Una estrategia de portafolio de "comprar sorpresa positiva, vender sorpresa negativa" ha entregado históricamente un rendimiento excedente anual del 10-25%. ¿Por qué el mercado no ha arbitrado esto? Varias razones:

• Atención limitada de los inversores — cuando 200 empresas reportan en la misma semana, es físicamente imposible leer todas las transcripciones
• Complejidad cognitiva — una conferencia de resultados dura 45-60 minutos, y la señal clave puede estar enterrada en una sola frase en el minuto 38 de la sesión de preguntas y respuestas
• Ambigüedad del lenguaje — el CFO dice "estamos navegando vientos en contra", y sin contexto no está claro si es una advertencia suave o una cobertura estándar

Aquí es donde entran en escena los LLMs. Por primera vez, tenemos una herramienta que puede procesar 500 transcripciones en una noche mientras capta matices que incluso analistas experimentados pasarían por alto.

PEAD.txt: el texto importa más que los números

Investigadores del Banco de la Reserva Federal de Filadelfia (Meursault, Liang, Routledge, Scanlon) publicaron el artículo PEAD.txt, que revirtió supuestos sobre el valor de la información textual. Construyeron un análogo textual de la sorpresa de resultados estándar — SUE.txt — que no utiliza en absoluto el valor numérico de resultados.

¿El resultado? SUE.txt genera un drift que es el doble de grande que el PEAD clásico. Además: en los últimos años, mientras el PEAD clásico basado en sorpresas numéricas prácticamente ha desaparecido (el mercado aprendió), el drift textual sigue siendo significativo. El mercado aprendió a procesar números rápidamente, pero aún tiene dificultades con la interpretación textual.

Este es el argumento fundamental a favor de un enfoque basado en NLP para las conferencias de resultados.

Del sentimiento a la semántica: evolución de los enfoques

Primera generación: bag-of-words y diccionarios (2000-2015)

Todo comenzó con el diccionario Loughran-McDonald (2011) — una lista de palabras etiquetadas como "positivas", "negativas", "inciertas" y "litigiosas". La idea era elegante en su simplicidad: contar el porcentaje de palabras negativas en una presentación 10-K y operar sobre eso.

¿El problema? La palabra "outstanding" en un contexto financiero más a menudo significa "deuda impagada" que "resultado excelente". La palabra "riesgo" en Risk Management no es una señal negativa — es una descripción de proceso. Los diccionarios de sentimiento NLP estándar tuvieron un desempeño vergonzosamente pobre en textos financieros.

Loughran y McDonald crearon un diccionario especializado, que mejoró la situación, pero el problema fundamental persistió: bag-of-words no entiende el contexto. "No dejamos de cumplir las expectativas" — hay dos palabras "negativas" aquí, pero el significado es positivo.

Segunda generación: FinBERT y transformers (2019-2023)

En 2019, Dogu Araci publicó FinBERT — BERT afinado con textos financieros de Reuters TRC2. Los resultados fueron impresionantes: una mejora de 14 puntos porcentuales en el dataset Financial PhraseBank sobre el estado del arte. FinBERT entendía el contexto: "outstanding" junto a "debt" — negativo, junto a "performance" — positivo.

Pero FinBERT tenía una limitación: una ventana de contexto de 512 tokens. Una conferencia de resultados dura entre 8.000 y 12.000 palabras. Dividir en fragmentos y promediar el sentimiento significa perder la semántica entre párrafos. El CEO podría comenzar con optimismo y luego mencionar de pasada problemas en la cadena de suministro durante las preguntas. FinBERT analiza cada fragmento de forma independiente y pierde ese contraste.

Tercera generación: LLMs con contexto largo (2023-presente)

GPT-4, Claude, Gemini con ventanas de contexto de 128K-1M tokens cambiaron las reglas del juego. Ahora se puede cargar una transcripción completa de una vez y hacer preguntas que requieren entender el documento entero.

El estudio clave — Lopez-Lira & Tang (2023) "Can ChatGPT Forecast Stock Price Movements?" En más de 50.000 titulares, GPT-4 mostró una tasa de acierto de ~90% al predecir la dirección de la reacción inicial del mercado y predijo significativamente el drift posterior, especialmente para empresas de pequeña capitalización y noticias negativas. Los modelos anteriores (GPT-1, GPT-2, BERT) no mostraron esta capacidad — el poder predictivo emerge como una propiedad emergente de los modelos grandes.

BloombergGPT (2023) — un modelo de 50 mil millones de parámetros entrenado con el corpus financiero de Bloomberg — demostró mejoras en NER financiero, clasificación de noticias y análisis de sentimiento. FinGPT — su alternativa de código abierto — alcanza un 89% de precisión en tareas de sentimiento financiero usando un enfoque centrado en datos y RAG.

MarketSenseAI, que utiliza GPT-4 con Chain-of-Thought y aprendizaje en contexto para el análisis del S&P 100, mostró un alfa excedente del 10-30% y rendimientos acumulados de hasta el 72% en 15 meses de pruebas. Sí, estas cifras deben tomarse con cautela (backtest ≠ trading en vivo), pero la tendencia es clara.

Pipeline de datos: dónde obtener los datos

SEC EDGAR: la fuente oficial

Para acciones estadounidenses, la fuente primaria es SEC EDGAR. Las conferencias de resultados no suelen presentarse directamente, pero hay documentos relacionados disponibles:

• Presentaciones 8-K (Item 2.02 — Resultados de Operaciones) — comunicados de prensa con resultados, a menudo incluyendo el exhibit 99 con la transcripción
• 10-Q / 10-K — informes trimestrales y anuales con Management Discussion & Analysis (MD&A) — también una fuente de texto valiosa
• DEF 14A — declaraciones de poder con información sobre la compensación de la dirección

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 y APIs comerciales

Las transcripciones de conferencias de resultados son un producto aparte. Seeking Alpha fue históricamente la principal fuente gratuita, pero ahora restringe el acceso. Opciones comerciales:

• Seeking Alpha Premium API — transcripciones completas con etiquetas de interlocutor
• AlphaVantage Earnings API — nivel gratuito con limitaciones
• Financial Modeling Prep — transcripciones + fundamentales
• Earnings Call Edge / Motley Fool Transcripts — fuentes alternativas

Cripto: llamadas de gobernanza y propuestas de DAO

Aquí es donde se pone interesante. Los principales protocolos DeFi celebran su equivalente a las conferencias de resultados:

• Uniswap — llamadas de gobernanza, llamadas comunitarias, grabaciones en YouTube
• Aave — llamadas comunitarias mensuales + propuestas en el foro de gobernanza
• MakerDAO — llamadas de gobernanza + extensas discusiones en el foro
• Compound — propuestas de gobernanza con discusiones detalladas

Las transcripciones de llamadas cripto suelen estar sin estructurar. La solución — Whisper de OpenAI para transcribir grabaciones de YouTube:

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

El costo de la transcripción vía la API de Whisper: $0,006/min. Una llamada de gobernanza de una hora cuesta ~$0,36. Para una opción autoalojada — Whisper Large-v3 Turbo transcribe un archivo de 60 minutos en ~17 segundos (216x tiempo real) en una GPU moderna.

Estrategias de prompting para LLM: de lo ingenuo a lo listo para producción

Estrategia 1: sentimiento directo (débil)

El enfoque más ingenuo — preguntar directamente al modelo:

"¿Es esta conferencia de resultados positiva o negativa para el precio de la acción?"

¿Funciona esto? Sí, sorprendentemente. Lopez-Lira & Tang demostraron que incluso un prompt tan primitivo produce predicciones estadísticamente significativas. Pero hay problemas:

• Salida binaria — se pierden las gradaciones. "Catástrofe" y "leve decepción" reciben la misma etiqueta
• Sin explicación — no está claro en qué basó el modelo su decisión
• Inestabilidad — una ejecución repetida puede dar una respuesta diferente

Estrategia 2: extracción estructurada con Chain-of-Thought (fuerte)

La idea: en lugar de un único número, extraer un conjunto estructurado de señales, obligando al modelo a explicar cada paso.

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

Observe varios puntos clave:

Esquema Pydantic — OpenAI Structured Outputs garantiza el 100% de cumplimiento del esquema. Se acabó el "sorry, I cannot parse the JSON". Cada campo tiene una descripción que actúa como un mini-prompt para un aspecto específico del análisis.

Chain-of-Thought dentro del esquema — los campos reasoning y key_quote obligan al modelo a "mostrar su trabajo". Esto no solo mejora la calidad (el modelo se ve obligado a encontrar una cita específica antes de emitir un juicio), sino que también crea un rastro de auditoría para los reguladores.

Temperatura 0,1 — no queremos creatividad. Necesitamos reproducibilidad. A temperatura 0, el modelo a veces se "atasca" en patrones; 0,1 es el compromiso óptimo.

Estrategia 3: few-shot con ejemplos históricos

Aún más potente — dar al modelo ejemplos de conferencias de resultados pasadas con reacciones de mercado reales:

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

Los ejemplos few-shot ayudan al modelo a calibrarse: aprende que "cautiously optimistic" en el lenguaje de Wall Street no es positivo — es un negativo suave. Sin ejemplos, el LLM podría interpretar las palabras literalmente.

Cuatro tipos de señales

1. Sorpresa de guidance

La señal más directa. Una empresa proporciona una previsión (guidance) para el próximo trimestre/año, y el mercado reacciona a la desviación respecto al consenso. Un LLM puede extraer el guidance incluso cuando la dirección lo comunica de forma vaga:

• "We expect revenues in the range of..." — guidance directo, fácil de parsear
• "We feel comfortable with current Street estimates" — confirmación implícita del consenso
• "There are puts and takes relative to consensus" — señal de riesgo implícita

Un LLM entiende las tres formulaciones; regex entiende solo la primera.

2. Métricas de confianza: densidad de palabras de cobertura

Esta es mi señal favorita porque es contraintuitiva. La esencia: los directivos son personas con formación jurídica y departamentos legales paranoicos. Cuando las cosas van bien, se permiten ser específicos. Cuando se están gestando problemas — empiezan a cubrirse.

Métricas a seguir:

El último punto es particularmente interesante. El CEO es un narrador — su trabajo es pintar un cuadro bonito. El CFO es quien rinde cuentas ante los auditores. Cuando el CEO dice "transformative growth ahead" y el CFO interviene de inmediato con "while maintaining disciplined cost management" — esta divergencia señala tensiones internas.

3. Inteligencia competitiva

Un LLM puede extraer menciones de competidores de una transcripción, incluso cuando la dirección evita nombrarlos directamente. "The largest player in the market" — eso no es ningún misterio para GPT-4 si conoce la industria.

Señal de trading: si la empresa A menciona al competidor B en un contexto negativo durante su conferencia de resultados ("we're taking share from..."), eso es una señal no solo para A (long) sino también para B (short). Un pairs trade.

4. Señales de rotación directiva

Frases marcadoras de cambios de dirección o giros estratégicos:

• "Exploring strategic alternatives" — probable venta de la empresa
• "Right-sizing our operations" — despidos masivos
• "The board has initiated a comprehensive review" — el CEO se irá pronto
• "We're bringing in fresh perspectives" — el equipo actual ha fracasado

Cada una de estas frases tiene una correlación estadísticamente significativa con la dinámica de precios posterior. Un LLM puede detectarlas con cero falsos positivos — porque entiende el contexto, a diferencia de regex, que podría capturar "strategic alternatives" en una descripción de línea de productos.

Backtesting: metodología de estudio de eventos

Estamos generando señales — genial. Pero ¿funcionan? El método de verificación estándar es un Event Study con el cálculo de rendimientos anormales acumulados (CAR).

Metodología

1. Definir el evento — la fecha de la conferencia de resultados
2. Ventana de estimación — [-250, -30] días de negociación antes del evento para estimar rendimientos "normales"
3. Ventana del evento — [-1, +60] días alrededor del evento
4. Calcular rendimientos normales mediante el modelo de mercado: $R_{it} = \alpha_i + \beta_i R_{mt} + \epsilon_{it}$
5. Rendimiento anormal — la diferencia entre el rendimiento real y el "normal"
6. CAR — suma acumulada de rendimientos anormales durante la ventana del evento

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

Qué esperamos ver

Basándonos en la investigación existente, los CAR realistas para señales de LLM:

El indicador clave es la significancia estadística. Con p < 0,01 y N > 200 eventos, se puede hablar de una señal robusta. Con p > 0,05 — podría ser ruido.

Implementación en producción: de Jupyter a producción

Arquitectura del pipeline en tiempo real

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)│
            └──────────────────────────────┘

Análisis de costos: cuánto cuesta una conferencia de resultados

Desglosemos la economía de procesar una única conferencia de resultados en producción:

Un momento, la estimación era de $30-50 por llamada. ¿De dónde salen esas cifras? Depende del modelo y el enfoque:

• Opción económica (GPT-4o-mini, una sola pasada): $0,50-1,00
• Opción estándar (GPT-4o, extracción estructurada + análisis de fragmentos): $2-5
• Opción premium (GPT-4o, múltiples pasadas, validación cruzada, comparación histórica): $15-30
• Nivel hedge fund (múltiples modelos + revisión humana + streaming en tiempo real): $30-50+

Para un fondo cuantitativo que opera con 500 tickers, el costo de procesar una temporada de resultados (~2.000 llamadas en 6 semanas) es de $4.000-$10.000 con la opción estándar. Dado un alfa promedio por posición del 1-3% — el ROI es astronómico.

Latencia: la carrera por los milisegundos

En el mundo del HFT, la latencia lo es todo. Pero para las estrategias basadas en resultados, la situación es diferente:

1. Una conferencia de resultados dura 45-60 minutos — hay tiempo
2. El PEAD se extiende durante 60 días — no hace falta entrar en el primer segundo
3. La principal dislocación ocurre en los primeros 30 minutos después de que termina la llamada

La estrategia óptima es de dos fases:

• Fase 1 (tiempo real): analizar fragmentos de 5 minutos durante la llamada, formando una señal preliminar
• Fase 2 (post-llamada): análisis completo de toda la transcripción entre 2 y 5 minutos después de que termina

La Fase 1 proporciona una ventaja de 5-10 minutos sobre los participantes del mercado que esperan a que termine la llamada. Para acciones de mediana capitalización, esto es suficiente.

Expansión al mundo cripto: gobernanza DeFi y propuestas de DAO

El mercado cripto es un terreno de pruebas ideal para el LLM alpha mining. He aquí por qué:

1. Menos actores institucionales — lo que significa más ineficiencia para explotar
2. Gobernanza = conferencia de resultados — las decisiones de la DAO afectan directamente a la tokenomics
3. Mercado 24/7 — se puede operar la reacción de inmediato
4. Datos públicos — todas las propuestas y votaciones están on-chain

Tipos de eventos cripto para el análisis

Propuestas de gobernanza (Aave, Compound, Uniswap)

Una propuesta cambia parámetros del protocolo — tasas de interés, factores de colateral, fee switches. Un LLM puede evaluar el impacto económico:

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

Anuncios de actualización de protocolo

Cuando Uniswap anuncia v4 con hooks, o Aave lanza GHO — eso es el equivalente a un lanzamiento de producto en TradFi. Un LLM puede evaluar el impulso narrativo y la relevancia técnica.

Informes de tesorería

Las grandes DAO tienen tesorerías por valor de cientos de millones. Los informes trimestrales de tesorería son un análogo directo de los resultados. Runway, tasa de quema, diversificación — todo susceptible de análisis por LLM.

Particularidades de las señales cripto

A diferencia de TradFi, en cripto:

• Los datos on-chain confirman o contradicen la narrativa — se puede cruzar lo dicho en las llamadas de gobernanza con las métricas reales del protocolo (TVL, volumen, usuarios activos)
• Las wallets ballena como insider trading — los grandes movimientos de wallets tras discusiones de gobernanza a menudo preceden a la votación
• Amplificación del sentimiento a través de CT (Crypto Twitter) — una señal de una llamada de gobernanza puede amplificarse o suprimirse por las narrativas de Twitter

Trampas y limitaciones

Alucinaciones: cuando el modelo inventa números

Un LLM puede "extraer" guidance que no estaba en la transcripción. Esto es especialmente peligroso al analizar la densidad de palabras de cobertura: el modelo puede contar más o menos palabras de las que realmente existen.

Solución: verificación de dos fases. El LLM extrae, el código determinista verifica. Para las palabras de cobertura — conteo con regex en paralelo a la evaluación del LLM. Desviación > 20% — marcar para revisión manual.

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

Limitaciones de la ventana de contexto

Incluso 128K tokens pueden no ser suficientes si se quiere alimentar:

• Transcripción actual (~10K tokens)
• Transcripción anterior para comparación (~10K)
• Previsiones de consenso de analistas (~2K)
• Ejemplos few-shot (~3K)
• Prompt del sistema (~1K)

Total ~26K — entra justo. Pero si se añade una presentación 10-K (~80-120K tokens) para contexto — ya se está al límite. Solución: RAG para recuperar fragmentos relevantes de documentos largos.

Sesgo y errores sistemáticos

Los LLM se entrenan con datos históricos donde ciertas frases se asociaban con ciertos resultados. Pero el mercado se adapta:

• Si todos empiezan a contar palabras de cobertura con GPT-4, los directivos cambiarán su lenguaje
• El modelo puede sobreponderar la importancia de patrones de los datos de entrenamiento (sesgo de supervivencia)
• El lenguaje corporativo evoluciona: "sinergias" en 2010 significaba una cosa, en 2026 — otra

Riesgo de trade masificado

Si 50 fondos cuantitativos usan el mismo GPT-4 para analizar las mismas transcripciones — la señal se degrada. Una analogía: cuando todos empezaron a operar el PEAD sobre sorpresas numéricas, la anomalía se redujo. Lo mismo ocurrirá con las señales textuales, pero con retraso:

1. Ahora (2026) — pocos usan sistemáticamente LLMs para conferencias de resultados. El alfa es significativo
2. En 2-3 años — adopción generalizada, el alfa disminuye
3. En 5 años — las señales básicas de LLM se convierten en commodity, el edge persiste solo en modelos personalizados y datos únicos

Este es el ciclo de vida estándar de una señal de alfa. Disfrútelo mientras dure.

En lugar de una conclusión: un plan de acción

Si quiere empezar a usar LLMs para el análisis de conferencias de resultados, aquí tiene un plan mínimo viable:

1. Empiece con datos gratuitos — SEC EDGAR + EdgarTools para presentaciones 8-K/10-Q
2. Use extracción estructurada — esquemas Pydantic vía OpenAI Structured Outputs
3. Haga backtesting vía event study — CAR sobre datos históricos, mínimo 200 eventos
4. Añada ejemplos few-shot — 5-10 ejemplos etiquetados mejoran radicalmente la calidad
5. Verifique de forma determinista — el LLM extrae, regex verifica, el humano audita
6. Empiece con mediana capitalización — más alfa, menos competencia con grandes fondos
7. Expanda a cripto — llamadas de gobernanza y propuestas de DAO como territorio inexplorado

Recuerde la regla cardinal del análisis cuantitativo: si una señal suena demasiado buena para ser verdad — vuelva a comprobarla. Los LLM crean una ilusión de comprensión, pero detrás de ella hay un emparejamiento estadístico de patrones. Una herramienta poderosa — pero una herramienta, no un oráculo.

Bibliografía

1. Ball, R., Brown, P. (1968). An Empirical Evaluation of Accounting Income Numbers. Journal of Accounting Research, 6(2), 159-178. — Primer descubrimiento del 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. — Artículo canónico sobre el PEAD.

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. — Diccionario de sentimiento financiero.

4. Araci, D. (2019). FinBERT: Financial Sentiment Analysis with Pre-trained Language Models. arXiv:1908.10063. — BERT para NLP financiero, +14pp sobre el SOTA.

5. Wu, S. et al. (2023). BloombergGPT: A Large Language Model for Finance. arXiv:2303.17564. — Modelo de 50B parámetros de Bloomberg.

6. Yang, H. et al. (2023). FinGPT: Open-Source Financial Large Language Models. arXiv:2306.06031. — Alternativa de código abierto a BloombergGPT, 89% de precisión.

7. Lopez-Lira, A., Tang, Y. (2023). Can ChatGPT Forecast Stock Price Movements? Return Predictability and Large Language Models. arXiv:2304.07619. — GPT-4 predice rendimientos con ~90% de tasa de acierto.

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. — El PEAD basado en texto es el doble de grande que el PEAD numérico.

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. — Framework GPT-4 con 10-30% de alfa excedente en el 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. — Generación automática de señales de trading vía LLM.

11. Zhang, X. et al. (2025). Can LLMs Hit Moving Targets? Tracking Evolving Signals in Corporate Disclosures. arXiv:2510.03195. — Detección de "objetivos móviles" en las divulgaciones corporativas.

12. Chen, Z. et al. (2025). Large Language Models in Equity Markets: Applications, Techniques, and Insights. Frontiers in Artificial Intelligence. — Revisión de 84 estudios de LLM en finanzas.

Este artículo tiene carácter educativo y no constituye asesoramiento de inversión. Cualquier estrategia de trading descrita aquí requiere un backtesting exhaustivo y gestión de riesgos antes de su implementación con capital real.