LLM Alpha Mining: Cara Mengekstrak Sinyal Trading dari Earnings Call dan Dokumen Keuangan

Ada lelucon di Wall Street: "Informasi paling berharga dalam sebuah earnings call bukan apa yang dikatakan CEO, melainkan bagaimana dia mengatakannya." Ketika Tim Cook berkata "we are cautiously optimistic" menggantikan ucapan tahun lalu "we are very pleased" — itu bukan permainan linguistik, itu sinyal bernilai ratusan juta dolar.

Selama beberapa dekade, quant fund telah mencoba mensistematisasi ekstraksi sinyal-sinyal ini. Pertama, mereka menghitung frekuensi kata "positif" dan "negatif" menggunakan kamus. Kemudian mereka menggunakan BERT. Dan kini kita punya GPT-4o, Claude, dan LLM open-source yang mampu menguraikan kehalusan bahasa korporat dengan akurasi yang bahkan menakutkan para peneliti sendiri.

Mari kita bahas cara membangun pipeline lengkap untuk mengekstrak sinyal trading dari earnings call — mulai dari mendapatkan transkrip hingga backtesting cumulative abnormal returns.

Mengapa Earnings Call Adalah Tambang Emas untuk Alpha

Post-Earnings Announcement Drift: Anomali yang Tak Pernah Mati

Pada tahun 1968, Ball dan Brown menemukan sesuatu yang aneh: setelah hasil kuartalan dipublikasikan, saham terus bergerak mengikuti arah "kejutan" selama 60-90 hari berikutnya. Mereka menyebutnya Post-Earnings Announcement Drift (PEAD). Lebih dari setengah abad telah berlalu sejak saat itu, ratusan makalah telah ditulis, anomali ini telah dijelaskan dari berbagai sudut — dan masih tetap bekerja.

PEAD adalah salah satu anomali pasar yang paling persisten dalam sejarah keuangan. Strategi portofolio "beli kejutan positif, jual kejutan negatif" secara historis menghasilkan kelebihan imbal hasil tahunan 10-25%. Mengapa pasar tidak mengarbirasei hal ini? Ada beberapa alasan:

• Perhatian investor yang terbatas — ketika 200 perusahaan melapor dalam satu minggu yang sama, secara fisik tidak mungkin untuk membaca semua transkrip
• Kompleksitas kognitif — sebuah earnings call berlangsung 45-60 menit, dan sinyal kuncinya bisa tersembunyi dalam satu kalimat pada menit ke-38 sesi tanya jawab
• Ambiguitas bahasa — CFO berkata "we are navigating headwinds," dan tanpa konteks tidak jelas apakah ini peringatan halus atau lindung nilai standar

Di sinilah LLM memasuki arena. Untuk pertama kalinya, kita memiliki alat yang dapat memproses 500 transkrip dalam satu malam sambil menangkap nuansa yang bahkan analis berpengalaman pun akan terlewatkan.

PEAD.txt: Teks Lebih Penting daripada Angka

Para peneliti dari Federal Reserve Bank of Philadelphia (Meursault, Liang, Routledge, Scanlon) menerbitkan makalah PEAD.txt, yang menggulingkan asumsi tentang nilai informasi tekstual. Mereka membangun analog berbasis teks dari kejutan pendapatan standar — SUE.txt — yang sama sekali tidak menggunakan nilai pendapatan numerik.

Hasilnya? SUE.txt menghasilkan drift yang dua kali lebih besar daripada PEAD klasik. Lebih jauh lagi: dalam beberapa tahun terakhir, sementara PEAD klasik berbasis kejutan numerik hampir menghilang (pasar telah belajar), drift tekstual tetap signifikan. Pasar belajar memproses angka dengan cepat tetapi masih kesulitan dengan interpretasi teks.

Inilah argumen fundamental yang mendukung pendekatan berbasis NLP untuk earnings call.

Dari Sentimen ke Semantik: Evolusi Pendekatan

Generasi Pertama: Bag-of-Words dan Kamus (2000-2015)

Semuanya dimulai dengan kamus Loughran-McDonald (2011) — daftar kata yang dilabeli sebagai "positif," "negatif," "tidak pasti," dan "litigious." Idenya elegan dalam kesederhanaannya: hitung persentase kata negatif dalam pengajuan 10-K dan trading berdasarkan itu.

Masalahnya? Kata "outstanding" dalam konteks keuangan lebih sering berarti "utang yang belum dibayar" daripada "hasil yang luar biasa." Kata "risk" dalam Risk Management bukan sinyal negatif — melainkan deskripsi proses. Kamus sentimen NLP standar berkinerja sangat buruk pada teks keuangan.

Loughran dan McDonald membuat kamus khusus, yang memperbaiki situasi, tetapi masalah mendasar tetap ada: bag-of-words tidak memahami konteks. "We did not fail to meet expectations" — ada dua kata "negatif" di sini, tetapi maknanya positif.

Generasi Kedua: FinBERT dan Transformers (2019-2023)

Pada tahun 2019, Dogu Araci menerbitkan FinBERT — BERT yang di-fine-tune pada teks keuangan dari Reuters TRC2. Hasilnya mengesankan: peningkatan 14 poin persentase pada dataset Financial PhraseBank dibandingkan state-of-the-art. FinBERT memahami konteks: "outstanding" di sebelah "debt" — negatif, di sebelah "performance" — positif.

Namun FinBERT memiliki keterbatasan: jendela konteks 512 token. Sebuah earnings call berjalan 8.000-12.000 kata. Membagi menjadi potongan-potongan dan merata-ratakan sentimen berarti kehilangan semantik antar-paragraf. CEO mungkin memulai dengan optimisme, kemudian secara santai menyebutkan masalah rantai pasokan selama tanya jawab. FinBERT menganalisis setiap potongan secara independen dan melewatkan kontras ini.

Generasi Ketiga: LLM dengan Konteks Panjang (2023-Sekarang)

GPT-4, Claude, Gemini dengan jendela konteks 128K-1M token mengubah aturan permainan. Kini Anda dapat memuat transkrip lengkap sekaligus dan mengajukan pertanyaan yang memerlukan pemahaman keseluruhan dokumen.

Studi kunci — Lopez-Lira & Tang (2023) "Can ChatGPT Forecast Stock Price Movements?" Pada 50.000+ headline, GPT-4 menunjukkan hit rate ~90% dalam memprediksi arah reaksi pasar awal dan secara signifikan memprediksi drift berikutnya, terutama untuk perusahaan small-cap dan berita negatif. Model sebelumnya (GPT-1, GPT-2, BERT) tidak menunjukkan kemampuan ini — kekuatan prediktif muncul sebagai sifat emergent dari model besar.

BloombergGPT (2023) — model 50 miliar parameter yang dilatih pada korpus keuangan Bloomberg — menunjukkan peningkatan dalam NER keuangan, klasifikasi berita, dan analisis sentimen. FinGPT — alternatif open-source-nya — mencapai akurasi 89% pada tugas sentimen keuangan menggunakan pendekatan data-centric dan RAG.

MarketSenseAI, yang menggunakan GPT-4 dengan Chain-of-Thought dan In-Context Learning untuk analisis S&P 100, menunjukkan alpha berlebih 10-30% dan imbal hasil kumulatif hingga 72% selama 15 bulan pengujian. Ya, angka-angka ini harus dipertimbangkan dengan hati-hati (backtest ≠ live trading), tetapi trennya jelas.

Pipeline Data: Dari Mana Mendapatkan Data

SEC EDGAR: Sumber Resmi

Untuk ekuitas AS, sumber utamanya adalah SEC EDGAR. Transkrip earnings call biasanya tidak diajukan secara langsung, tetapi dokumen terkait tersedia:

• Pengajuan 8-K (Item 2.02 — Results of Operations) — siaran pers dengan hasil, sering kali menyertakan exhibit 99 dengan transkrip
• 10-Q / 10-K — laporan kuartalan dan tahunan dengan Management Discussion & Analysis (MD&A) — juga sumber teks yang berharga
• DEF 14A — pernyataan proxy dengan informasi kompensasi manajemen

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()  # Teks lengkap dengan exhibit
        print(f"{filing.filing_date}: {len(text)} chars")

Seeking Alpha dan API Komersial

Transkrip earnings call adalah produk tersendiri. Seeking Alpha secara historis menjadi sumber gratis utama, tetapi kini membatasi akses. Opsi komersial:

• Seeking Alpha Premium API — transkrip lengkap dengan label pembicara
• AlphaVantage Earnings API — tier gratis dengan keterbatasan
• Financial Modeling Prep — transkrip + fundamental
• Earnings Call Edge / Motley Fool Transcripts — sumber alternatif

Crypto: Governance Call dan Proposal DAO

Di sinilah hal-hal menjadi menarik. Protokol DeFi besar mengadakan padanan earnings call mereka:

• Uniswap — governance call, community call, rekaman di YouTube
• Aave — community call bulanan + proposal forum governance
• MakerDAO — governance call + diskusi forum yang ekstensif
• Compound — proposal governance dengan diskusi terperinci

Transkrip panggilan crypto biasanya tidak terstruktur. Solusinya — Whisper dari OpenAI untuk mentranskrip rekaman YouTube:

import openai
from yt_dlp import YoutubeDL

def transcribe_governance_call(youtube_url: str) -> str:
    """Unduh audio dari YouTube dan transkrip melalui Whisper."""
    ydl_opts = {
        'format': 'bestaudio/best',
        'postprocessors': [{
            'key': 'FFmpegExtractAudio',
            'preferredcodec': 'mp3',
            'preferredquality': '64',  # Bitrate rendah sudah cukup untuk suara
        }],
        '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

Biaya transkripsi melalui Whisper API: $0,006/menit. Satu jam governance call biayanya ~$0,36. Untuk opsi self-hosted — Whisper Large-v3 Turbo mentranskrip file 60 menit dalam ~17 detik (216x real-time) pada GPU modern.

Strategi Prompting LLM: Dari Naif hingga Production-Grade

Strategi 1: Sentimen Langsung (Lemah)

Pendekatan paling naif — tanyakan model secara langsung:

"Apakah earnings call ini positif atau negatif untuk harga saham?"

Apakah ini berhasil? Ya, mengejutkan. Lopez-Lira & Tang menunjukkan bahwa bahkan prompt seprimitive ini menghasilkan prediksi yang signifikan secara statistik. Tetapi ada masalahnya:

• Output biner — Anda kehilangan gradasi. "Bencana" dan "kekecewaan ringan" mendapat label yang sama
• Tidak ada penjelasan — tidak jelas apa yang menjadi dasar keputusan model
• Ketidakstabilan — pengulangan bisa menghasilkan jawaban berbeda

Strategi 2: Ekstraksi Terstruktur dengan Chain-of-Thought (Kuat)

Idenya: alih-alih satu angka, ekstrak kumpulan sinyal terstruktur, memaksa model untuk menjelaskan setiap langkah.

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):
    """Deviasi panduan ke depan dari ekspektasi konsensus."""
    revenue_guidance_vs_consensus: Optional[float] = Field(
        None, description="% deviasi panduan pendapatan dari konsensus"
    )
    margin_guidance_direction: Optional[str] = Field(
        None, description="expanding / stable / contracting"
    )
    key_quote: str = Field(
        description="Kutipan verbatim dengan panduan"
    )
    reasoning: str = Field(
        description="CoT: mengapa panduan ini penting"
    )


class ConfidenceMetrics(BaseModel):
    """Metrik kepercayaan diri manajemen."""
    hedge_word_count: int = Field(
        description="Jumlah kata lindung nilai: 'approximately', 'potentially', 'subject to'"
    )
    forward_looking_ratio: float = Field(
        description="Rasio pernyataan berorientasi masa depan terhadap total pernyataan"
    )
    q_and_a_evasion_count: int = Field(
        description="Jumlah pertanyaan di mana CEO/CFO memberikan jawaban yang menghindar"
    )
    ceo_vs_cfo_sentiment_delta: float = Field(
        description="Perbedaan sentimen antara CEO dan CFO (-1 hingga 1). Divergensi adalah tanda bahaya"
    )


class CompetitiveIntelligence(BaseModel):
    """Penyebutan pesaing dan posisi pasar."""
    competitors_mentioned: list[str] = Field(
        description="Daftar pesaing yang disebutkan"
    )
    market_share_claims: list[str] = Field(
        description="Klaim pangsa pasar"
    )
    new_product_signals: list[str] = Field(
        description="Sinyal tentang produk/layanan baru"
    )


class ManagementSignals(BaseModel):
    """Sinyal manajemen."""
    turnover_risk: SentimentLevel = Field(
        description="Risiko pergantian manajemen kunci"
    )
    tone_shift_from_previous: Optional[str] = Field(
        None, description="Bagaimana nada berubah dibandingkan kuartal lalu"
    )
    insider_language_flags: list[str] = Field(
        description="Frasa penanda: 'exploring strategic alternatives', 'right-sizing', dll."
    )


class EarningsCallAnalysis(BaseModel):
    """Analisis earnings call lengkap."""
    ticker: str
    quarter: str
    overall_sentiment: SentimentLevel
    sentiment_score: float = Field(description="dari -1.0 hingga 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:
    """
    Ekstrak sinyal terstruktur dari earnings call.
    Biaya: ~$0.15-0.30 per panggilan (GPT-4o, ~10K token 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,  # Temperatur rendah untuk reprodusibilitas
    )

    return completion.choices[0].message.parsed

Perhatikan beberapa poin kunci:

Skema Pydantic — OpenAI Structured Outputs menjamin kepatuhan skema 100%. Tidak ada lagi "sorry, I cannot parse the JSON." Setiap field memiliki deskripsi yang berfungsi sebagai mini-prompt untuk aspek analisis tertentu.

Chain-of-Thought dalam skema — field reasoning dan key_quote memaksa model untuk "menunjukkan pekerjaannya." Ini tidak hanya meningkatkan kualitas (model dipaksa menemukan kutipan spesifik sebelum membuat penilaian) tetapi juga menciptakan jejak audit untuk regulator.

Temperature 0.1 — kita tidak menginginkan kreativitas. Kita membutuhkan reprodusibilitas. Pada temperature 0, model terkadang "terjebak" dalam pola; 0.1 adalah kompromi optimal.

Strategi 3: Few-Shot dengan Contoh Historis

Bahkan lebih kuat — berikan model contoh earnings call masa lalu dengan reaksi pasar aktual:

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

Contoh few-shot membantu model melakukan kalibrasi: model belajar bahwa "cautiously optimistic" dalam bahasa Wall Street bukan berarti positif — itu adalah sinyal negatif halus. Tanpa contoh, LLM mungkin menginterpretasikan kata-kata secara harfiah.

Empat Jenis Sinyal

1. Guidance Surprise

Sinyal paling langsung. Sebuah perusahaan memberikan perkiraan (guidance) untuk kuartal/tahun berikutnya, dan pasar bereaksi terhadap penyimpangan dari konsensus. LLM dapat mengekstrak guidance bahkan ketika manajemen mengomunikasikannya secara samar:

• "We expect revenues in the range of..." — guidance langsung, mudah diurai
• "We feel comfortable with current Street estimates" — konfirmasi implisit konsensus
• "There are puts and takes relative to consensus" — sinyal risiko implisit

LLM memahami ketiga ungkapan tersebut; regex hanya memahami yang pertama.

2. Metrik Kepercayaan Diri: Kepadatan Kata Lindung Nilai

Ini adalah sinyal favorit saya karena bersifat kontraintuitif. Intinya: manajer adalah manusia dengan pelatihan hukum dan departemen hukum yang paranoid. Ketika semuanya berjalan baik, mereka mengizinkan diri mereka untuk spesifik. Ketika masalah sedang berkembang — mereka mulai melindungi diri.

Metrik yang perlu dilacak:

Poin terakhir sangat menarik. CEO adalah pencerita — tugasnya adalah melukiskan gambaran yang indah. CFO adalah orang yang bertanggung jawab kepada auditor. Ketika CEO berkata "transformative growth ahead" dan CFO segera menyela "while maintaining disciplined cost management" — divergensi ini menandakan ketegangan internal.

3. Intelijen Kompetitif

LLM dapat mengekstrak penyebutan pesaing dari transkrip, bahkan ketika manajemen menghindari nama langsung. "The largest player in the market" — itu bukan misteri bagi GPT-4 jika ia mengetahui industrinya.

Sinyal trading: jika perusahaan A menyebut pesaing B dalam konteks negatif selama earnings call-nya ("we're taking share from..."), itu adalah sinyal tidak hanya untuk A (long) tetapi juga untuk B (short). Sebuah pairs trade.

4. Sinyal Pergantian Manajemen

Frasa penanda untuk perubahan manajemen atau pivoting strategis:

• "Exploring strategic alternatives" — kemungkinan penjualan perusahaan
• "Right-sizing our operations" — PHK massal
• "The board has initiated a comprehensive review" — CEO akan segera pergi
• "We're bringing in fresh perspectives" — tim saat ini telah gagal

Masing-masing frasa ini memiliki korelasi yang signifikan secara statistik dengan dinamika harga berikutnya. LLM dapat mendeteksinya dengan nol false positive — karena memahami konteks, tidak seperti regex yang mungkin menangkap "strategic alternatives" dalam deskripsi lini produk.

Backtesting: Metodologi Event Study

Kita menghasilkan sinyal — bagus. Tapi apakah mereka bekerja? Metode verifikasi standar adalah Event Study dengan perhitungan Cumulative Abnormal Returns (CAR).

Metodologi

1. Tentukan event — tanggal earnings call
2. Jendela estimasi — [-250, -30] hari trading sebelum event untuk memperkirakan imbal hasil "normal"
3. Jendela event — [-1, +60] hari di sekitar event
4. Hitung imbal hasil normal melalui model pasar: $R_{it} = \alpha_i + \beta_i R_{mt} + \epsilon_{it}$
5. Imbal hasil abnormal — perbedaan antara imbal hasil aktual dan "normal"
6. CAR — jumlah kumulatif imbal hasil abnormal selama jendela event

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 per hari
    t_stats: np.ndarray      # t-statistik untuk setiap hari
    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,       # Imbal hasil saham harian (kolom = ticker)
    market_returns: pd.Series,   # Imbal hasil indeks pasar harian
    events: pd.DataFrame,        # DataFrame dengan kolom: [ticker, date, signal_score]
    estimation_window: int = 220,
    gap: int = 30,
    event_window: tuple = (-1, 60),
) -> EventStudyResult:
    """
    Event study untuk mengevaluasi kekuatan prediktif sinyal LLM.

    Urutkan event berdasarkan signal_score, bentuk portofolio long/short,
    hitung CAR dan uji signifikansi statistik.
    """
    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 observasi
            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]  # Geser ke tanggal event

    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 sinyal kuintil teratas, short kuintil terbawah."""

    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"Portofolio LONG (kuintil teratas sentimen LLM):")
    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"\nPortofolio SHORT (kuintil terbawah sentimen LLM):")
    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"\nSpread LONG-SHORT:")
    print(f"  CAR[0,+3]:  {ls_3d:+.2%}")
    print(f"  CAR[0,+30]: {ls_30d:+.2%}")

Apa yang Kita Harapkan untuk Dilihat

Berdasarkan penelitian yang ada, CAR yang realistis untuk sinyal LLM:

Indikator kuncinya adalah signifikansi statistik. Dengan p < 0,01 dan N > 200 event, Anda dapat berbicara tentang sinyal yang robust. Dengan p > 0,05 — itu mungkin noise.

Implementasi Produksi: Dari Jupyter ke Prod

Arsitektur Pipeline Real-time

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

Analisis Biaya: Berapa Biaya Satu Earnings Call

Mari kita uraikan ekonomi pemrosesan satu earnings call dalam produksi:

Tunggu, estimasinya adalah $30-50 per panggilan. Dari mana angka-angka tersebut berasal? Tergantung pada model dan pendekatan:

• Opsi anggaran (GPT-4o-mini, satu kali pass): $0,50-1,00
• Opsi standar (GPT-4o, ekstraksi terstruktur + analisis potongan): $2-5
• Opsi premium (GPT-4o, beberapa pass, cross-validasi, perbandingan historis): $15-30
• Tingkat hedge fund (beberapa model + tinjauan manusia + streaming real-time): $30-50+

Untuk quant fund yang memperdagangkan 500 ticker, biaya pemrosesan musim earnings (~2.000 panggilan selama 6 minggu) adalah $4.000-$10.000 dengan opsi standar. Mengingat rata-rata alpha per posisi sebesar 1-3% — ROI-nya luar biasa.

Latensi: Perlombaan Milidetik

Dalam dunia HFT, latensi adalah segalanya. Tetapi untuk strategi berbasis earnings, situasinya berbeda:

1. Earnings call berlangsung 45-60 menit — Anda punya waktu
2. PEAD membentang selama 60 hari — tidak perlu masuk di detik pertama
3. Dislokasi utama terjadi dalam 30 menit pertama setelah panggilan berakhir

Strategi optimal adalah dua fase:

• Fase 1 (real-time): analisis potongan 5 menit selama panggilan, membentuk sinyal awal
• Fase 2 (pasca-panggilan): analisis penuh seluruh transkrip 2-5 menit setelah berakhir

Fase 1 memberikan keunggulan 5-10 menit atas peserta pasar yang menunggu panggilan selesai. Untuk saham mid-cap, ini sudah cukup.

Perluasan ke Crypto: Governance DeFi dan Proposal DAO

Pasar crypto adalah ladang pengujian ideal untuk LLM alpha mining. Inilah alasannya:

1. Lebih sedikit pemain institusional — berarti lebih banyak inefisiensi untuk dieksploitasi
2. Governance = earnings call — keputusan DAO secara langsung mempengaruhi tokenomics
3. Pasar 24/7 — Anda dapat memperdagangkan reaksinya segera
4. Data publik — semua proposal dan suara ada on-chain

Jenis Event Crypto untuk Analisis

Proposal Governance (Aave, Compound, Uniswap)

Sebuah proposal mengubah parameter protokol — suku bunga, faktor agunan, fee switch. LLM dapat mengevaluasi dampak ekonomi:

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

Pengumuman Pembaruan Protokol

Ketika Uniswap mengumumkan v4 dengan hooks, atau Aave meluncurkan GHO — itu setara dengan peluncuran produk di TradFi. LLM dapat menilai momentum narasi dan signifikansi teknis.

Laporan Treasury

DAO besar memiliki treasury senilai ratusan juta. Laporan treasury kuartalan adalah analog langsung dari earnings. Runway, burn rate, diversifikasi — semua dapat dianalisis dengan LLM.

Spesifik Sinyal Crypto

Tidak seperti TradFi, dalam crypto:

• Data on-chain mengkonfirmasi atau bertentangan dengan narasi — Anda dapat merujuk silang apa yang dikatakan dalam governance call dengan metrik protokol aktual (TVL, volume, pengguna aktif)
• Dompet whale sebagai insider trading — pergerakan dompet besar setelah diskusi governance sering mendahului pemungutan suara
• Amplifikasi sentimen melalui CT (Crypto Twitter) — sinyal dari governance call dapat diperkuat atau ditekan oleh narasi Twitter

Perangkap dan Keterbatasan

Halusinasi: Ketika Model Menciptakan Angka

LLM dapat "mengekstrak" guidance yang tidak ada dalam transkrip. Ini sangat berbahaya ketika menganalisis kepadatan kata lindung nilai: model mungkin menghitung lebih banyak atau lebih sedikit kata daripada yang sebenarnya ada.

Solusi: verifikasi dua fase. LLM mengekstrak, kode deterministik memverifikasi. Untuk kata lindung nilai — penghitungan regex secara paralel dengan penilaian LLM. Penyimpangan > 20% — tandai untuk tinjauan 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:
    """Verifikasi deterministik jumlah kata lindung nilai LLM."""
    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,
    }

Keterbatasan Jendela Konteks

Bahkan 128K token mungkin tidak cukup jika Anda ingin memasukkan:

• Transkrip saat ini (~10K token)
• Transkrip sebelumnya untuk perbandingan (~10K)
• Perkiraan konsensus analis (~2K)
• Contoh few-shot (~3K)
• System prompt (~1K)

Total ~26K — kita muat. Tetapi jika Anda menambahkan pengajuan 10-K (~80-120K token) untuk konteks — Anda sudah di ujung. Solusi: RAG untuk mengambil potongan relevan dari dokumen panjang.

Bias dan Kesalahan Sistematis

LLM dilatih pada data historis di mana frasa tertentu dikaitkan dengan hasil tertentu. Tetapi pasar beradaptasi:

• Jika semua orang mulai menghitung kata lindung nilai dengan GPT-4, manajer akan mengubah bahasa mereka
• Model mungkin memberi bobot berlebihan pada signifikansi pola dari data pelatihan (survivorship bias)
• Bahasa korporat berkembang: "synergies" pada tahun 2010 berarti satu hal, pada tahun 2026 — sesuatu yang lain

Risiko Crowded Trade

Jika 50 quant fund menggunakan GPT-4 yang sama untuk menganalisis transkrip yang sama — sinyal menurun. Sebuah analogi: ketika semua orang mulai memperdagangkan PEAD pada kejutan numerik, anomali menyusut. Hal yang sama akan terjadi pada sinyal tekstual, tetapi dengan penundaan:

1. Sekarang (2026) — sedikit yang secara sistematis menggunakan LLM untuk earnings call. Alpha signifikan
2. Dalam 2-3 tahun — adopsi luas, alpha berkurang
3. Dalam 5 tahun — sinyal LLM dasar menjadi komoditas, keunggulan hanya bertahan pada model kustom dan data unik

Inilah siklus hidup sinyal alpha standar. Nikmati selagi masih ada.

Sebagai Penutup: Rencana Tindakan

Jika Anda ingin mulai menggunakan LLM untuk analisis earnings call, berikut adalah rencana minimum yang layak:

1. Mulai dengan data gratis — SEC EDGAR + EdgarTools untuk pengajuan 8-K/10-Q
2. Gunakan ekstraksi terstruktur — skema Pydantic melalui OpenAI Structured Outputs
3. Backtest melalui event study — CAR pada data historis, minimum 200 event
4. Tambahkan contoh few-shot — 5-10 contoh berlabel secara radikal meningkatkan kualitas
5. Verifikasi secara deterministik — LLM mengekstrak, regex memverifikasi, manusia mengaudit
6. Mulai dengan mid-cap — lebih banyak alpha, lebih sedikit persaingan dengan dana besar
7. Perluas ke crypto — governance call dan proposal DAO sebagai wilayah yang belum dipetakan

Ingat aturan utama analisis kuantitatif: jika sebuah sinyal terdengar terlalu bagus untuk menjadi kenyataan — periksa lagi. LLM menciptakan ilusi pemahaman, tetapi di baliknya ada pencocokan pola statistik. Alat yang kuat — tetapi alat, bukan oracle.

Bibliografi

1. Ball, R., Brown, P. (1968). An Empirical Evaluation of Accounting Income Numbers. Journal of Accounting Research, 6(2), 159-178. — Penemuan pertama 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. — Makalah PEAD kanonik.

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. — Kamus sentimen keuangan.

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

5. Wu, S. et al. (2023). BloombergGPT: A Large Language Model for Finance. arXiv:2303.17564. — Model 50 miliar parameter Bloomberg.

6. Yang, H. et al. (2023). FinGPT: Open-Source Financial Large Language Models. arXiv:2306.06031. — Alternatif open-source dari BloombergGPT, akurasi 89%.

7. Lopez-Lira, A., Tang, Y. (2023). Can ChatGPT Forecast Stock Price Movements? Return Predictability and Large Language Models. arXiv:2304.07619. — GPT-4 memprediksi imbal hasil dengan hit rate ~90%.

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. — PEAD berbasis teks dua kali lebih besar dari PEAD numerik.

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 dengan alpha berlebih 10-30% pada 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. — Pembuatan sinyal trading otomatis melalui LLM.

11. Zhang, X. et al. (2025). Can LLMs Hit Moving Targets? Tracking Evolving Signals in Corporate Disclosures. arXiv:2510.03195. — Deteksi "moving target" dalam pengungkapan perusahaan.

12. Chen, Z. et al. (2025). Large Language Models in Equity Markets: Applications, Techniques, and Insights. Frontiers in Artificial Intelligence. — Survei 84 studi LLM dalam keuangan.

Artikel ini bersifat edukatif dan tidak merupakan saran investasi. Strategi trading apa pun yang dijelaskan di sini memerlukan backtesting menyeluruh dan manajemen risiko sebelum diterapkan dengan modal nyata.