LLM Alpha & Unstructured Financial Data Mining

The Unstructured Data Problem

More Text Than Anyone Can Read

Every U.S.-listed company files a 10-K annually and a 10-Q quarterly, and most large-caps hold a live earnings call the same day or within a day or two of the release. Across the Russell 3000, that's thousands of documents and transcripts landing in overlapping windows every earnings season — each one running from dozens to hundreds of pages. No research desk, however large, reads all of it closely before the market has already reacted to the numbers.

Two Sigma Research and Point72's Cubist Systematic Strategies have both published on how they treat this as a structural inefficiency: the text is public, but the marginal cost of reading it carefully — for every name, every quarter, within minutes of release — is what actually creates the opportunity. An LLM doesn't get tired, doesn't skip the boring paragraph, and scores the fortieth filing of the day exactly as carefully as the first.

What Changed: LLMs vs. Legacy NLP

Bag-of-words and dictionary-based sentiment scoring (Loughran-McDonald word lists, for example) have been used in academic finance since the 2000s, but they're crude — they can't tell "not disappointing" from "disappointing." Transformer-based models fine-tuned on financial text (FinBERT and its successors) understand negation, hedging language, and context in a way word-count methods never could. That's the specific capability upgrade institutional desks are now running at scale.

Prepared Remarks vs. Q&A: Where the Signal Lives

The Scripted Portion Tells You Less Than You Think

The opening "prepared remarks" section of an earnings call is written, reviewed by legal and IR, and rehearsed before the CEO and CFO ever speak. It is optimized to sound confident and on-message regardless of the underlying quarter. Academic research on earnings call linguistics (building on work popularized in accounting and finance literature since the early 2010s) has repeatedly found that the unscripted analyst Q&A session carries substantially more incremental information than the prepared portion — because executives can't fully script answers to questions they don't control.

Reading the Delta, Not Just the Level

The absolute tone score of a single call matters less than the delta versus that same management team's own historical baseline and versus the tone of the prepared remarks on the very same call. A large negative gap between confident prepared remarks and hedge-heavy Q&A answers — sometimes called a "tone divergence" — is a more specific signal than either section read in isolation: it suggests management is comfortable with the scripted narrative but visibly less comfortable defending it under unscripted questioning.

10-Q/10-K Tone Extraction: MD&A and Risk Factors

Where the Signal Concentrates in a Filing

A 10-K or 10-Q is mostly boilerplate — accounting disclosures, standard legal language, item numbering required by SEC rules. The two sections institutional NLP research consistently focuses on are Management's Discussion & Analysis (MD&A), where management explains results in their own words, and the Risk Factors section, where year-over-year additions, removals, and rewordings are tracked as a distinct signal from the sentiment score itself.

Year-over-Year Similarity as a Signal in Its Own Right

Comparing this quarter's MD&A and Risk Factors text against the prior-year filing using a text-similarity metric (cosine similarity on sentence embeddings is the standard retail-accessible approach) surfaces material changes that a sentiment score alone would miss. A filing that is 95%+ textually similar to the prior year, boilerplate included, tells you management didn't feel the need to say anything new — which is itself informative, especially in a quarter where something changed operationally.

Sentiment Decay Curve: The Half-Life Problem

Why "Correct" Sentiment Isn't Enough

A tone signal can be directionally accurate and still be worthless to trade if it's stale by the time you can act on it. Published academic and industry research on earnings-call and filing sentiment has consistently found that the market's price reaction to textual tone is front-loaded — most of the incremental information gets absorbed into price within hours, not days, of release, with a long thin tail of residual drift that fades over the following sessions.

Modeling Decay as an Exponential

The standard way to operationalize a decay curve is to treat the signal's usable weight as an exponential function of elapsed time since release, so a trading system can decide how much conviction to still assign a stale-but-not-dead signal rather than treating it as binary (tradeable / not tradeable):

weight(t) = 2^(-t / half_life)

where:
  t          = hours elapsed since filing/call release
  half_life  = estimated hours for signal to lose half its value
               (illustrative: 3-24 hours depending on name/liquidity)

Satellite & Web-Scrape Confirmation Signals

Text Tone Is Stronger When It Agrees With Physical-World Data

Both Two Sigma Research and Point72/Cubist have discussed using alternative data — satellite imagery, web-scraped pricing and job postings, app usage telemetry — not as standalone signals but as a way to corroborate or contradict what a tone model extracts from text. A confident MD&A section paired with confirming satellite parking-lot traffic or job-posting growth is a stronger combined signal than either alone; a confident MD&A paired with contradicting physical-world data is itself informative — it flags a filing whose tone may not match reality.

Python Implementation: Full NLP Scoring Pipeline

Full implementation: Transcript/filing ingestion, section splitting (prepared remarks vs. Q&A, MD&A vs. Risk Factors), FinBERT sentiment scoring, year-over-year similarity, decay-weighted signal aggregation.

Complete Python Code

"""
LLM Alpha: Unstructured Financial Data Mining Pipeline
Retail-adapted FinBERT tone extraction for filings and earnings calls

Author: Plan My Retire
Date: March 2026
"""

import re
import numpy as np
import pandas as pd
from datetime import datetime
from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch
from sklearn.metrics.pairwise import cosine_similarity
from sentence_transformers import SentenceTransformer


class FinancialTextScorer:
    """
    Scores financial text (transcripts, filings) for sentiment using
    a FinBERT-family model, with section-aware weighting.
    """

    def __init__(self, model_name="ProsusAI/finbert"):
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model = AutoModelForSequenceClassification.from_pretrained(model_name)
        self.model.eval()
        self.embedder = SentenceTransformer("all-MiniLM-L6-v2")
        self.labels = ["positive", "negative", "neutral"]

    def score_passage(self, text, max_length=512):
        """
        Returns a signed sentiment score in [-1, 1] for a text passage.
        Long passages are chunked and score-averaged.
        """
        chunks = self._chunk_text(text, max_length)
        if not chunks:
            return 0.0

        scores = []
        for chunk in chunks:
            inputs = self.tokenizer(chunk, return_tensors="pt", truncation=True,
                                     max_length=max_length)
            with torch.no_grad():
                logits = self.model(**inputs).logits
            probs = torch.softmax(logits, dim=1).numpy()[0]
            # positive - negative, ignoring neutral mass
            signed = probs[self.labels.index("positive")] - probs[self.labels.index("negative")]
            scores.append(signed)

        return float(np.mean(scores))

    def _chunk_text(self, text, max_length):
        words = text.split()
        chunk_size = max_length - 20  # headroom for special tokens
        return [" ".join(words[i:i + chunk_size])
                for i in range(0, len(words), chunk_size)] if words else []

    def embedding_similarity(self, text_a, text_b):
        """Cosine similarity between two passages, for YoY filing comparison."""
        emb = self.embedder.encode([text_a, text_b])
        return float(cosine_similarity([emb[0]], [emb[1]])[0][0])


class EarningsCallSplitter:
    """
    Splits a raw earnings call transcript into prepared remarks
    and analyst Q&A sections using standard transcript markers.
    """

    QA_MARKERS = [
        r"question-and-answer session",
        r"questions? and answers?",
        r"we will now (begin|open) the (question|q&a)",
        r"first question",
    ]

    def split(self, transcript_text):
        lower = transcript_text.lower()
        split_idx = None
        for pattern in self.QA_MARKERS:
            match = re.search(pattern, lower)
            if match:
                split_idx = match.start()
                break

        if split_idx is None:
            # Fallback: assume last third is Q&A if no marker found
            split_idx = int(len(transcript_text) * 0.66)

        return {
            "prepared_remarks": transcript_text[:split_idx],
            "qa_section": transcript_text[split_idx:]
        }


class FilingSectionExtractor:
    """
    Extracts MD&A and Risk Factors sections from 10-K/10-Q text
    using standard SEC item-number headers.
    """

    SECTION_PATTERNS = {
        "risk_factors": r"item\s+1a\.?\s+risk factors(.*?)item\s+1b",
        "mda": r"item\s+7\.?\s+management.s discussion(.*?)item\s+7a",
    }

    def extract(self, filing_text):
        lower = filing_text.lower()
        sections = {}
        for name, pattern in self.SECTION_PATTERNS.items():
            match = re.search(pattern, lower, re.DOTALL)
            sections[name] = filing_text[match.start():match.end()] if match else ""
        return sections


class DecayWeightedSignal:
    """
    Combines a raw tone score with an exponential decay weight
    based on hours elapsed since release, to avoid treating
    stale signals as equally tradeable to fresh ones.
    """

    def __init__(self, half_life_hours=8.0):
        self.half_life = half_life_hours

    def weight(self, hours_elapsed):
        if hours_elapsed < 0:
            return 0.0
        return 2 ** (-hours_elapsed / self.half_life)

    def weighted_score(self, raw_score, release_time, as_of_time=None):
        as_of_time = as_of_time or datetime.now()
        hours_elapsed = (as_of_time - release_time).total_seconds() / 3600
        return raw_score * self.weight(hours_elapsed)


class TonePipeline:
    """
    End-to-end pipeline: raw transcript/filing text in,
    decay-weighted composite tone score out.
    """

    def __init__(self, half_life_hours=8.0):
        self.scorer = FinancialTextScorer()
        self.call_splitter = EarningsCallSplitter()
        self.filing_extractor = FilingSectionExtractor()
        self.decay = DecayWeightedSignal(half_life_hours)

    def score_earnings_call(self, transcript_text, release_time, as_of_time=None):
        sections = self.call_splitter.split(transcript_text)
        prepared_score = self.scorer.score_passage(sections["prepared_remarks"])
        qa_score = self.scorer.score_passage(sections["qa_section"])

        # Q&A weighted more heavily -- higher incremental information content
        composite_raw = 0.35 * prepared_score + 0.65 * qa_score
        divergence = prepared_score - qa_score

        return {
            "prepared_remarks_score": prepared_score,
            "qa_score": qa_score,
            "tone_divergence": divergence,
            "composite_raw": composite_raw,
            "composite_decay_weighted": self.decay.weighted_score(
                composite_raw, release_time, as_of_time
            ),
        }

    def score_filing(self, filing_text, prior_year_filing_text, release_time,
                      as_of_time=None):
        sections = self.filing_extractor.extract(filing_text)
        prior_sections = self.filing_extractor.extract(prior_year_filing_text)

        mda_score = self.scorer.score_passage(sections["mda"])
        risk_similarity = self.scorer.embedding_similarity(
            sections["risk_factors"], prior_sections["risk_factors"]
        )

        return {
            "mda_score": mda_score,
            "risk_factors_yoy_similarity": risk_similarity,
            "risk_factors_changed": risk_similarity < 0.85,  # heuristic threshold
            "composite_decay_weighted": self.decay.weighted_score(
                mda_score, release_time, as_of_time
            ),
        }


# Example usage
if __name__ == "__main__":
    pipeline = TonePipeline(half_life_hours=8.0)

    sample_transcript = """
    Thank you for joining us today. We are pleased to report strong
    results this quarter, with revenue growth accelerating...
    [prepared remarks continue]
    Question-and-Answer Session
    Analyst: Can you walk us through the margin pressure in the segment?
    CFO: Well, I think, um, there are some puts and takes there, and
    we're cautiously monitoring the situation going into next quarter...
    """

    release_time = datetime(2026, 3, 12, 16, 30)  # 4:30 PM call
    as_of = datetime(2026, 3, 12, 20, 0)  # scoring 3.5 hours later

    result = pipeline.score_earnings_call(sample_transcript, release_time, as_of)

    print(f"Prepared remarks score: {result['prepared_remarks_score']:.3f}")
    print(f"Q&A score: {result['qa_score']:.3f}")
    print(f"Tone divergence (prepared - Q&A): {result['tone_divergence']:.3f}")
    print(f"Decay-weighted composite: {result['composite_decay_weighted']:.3f}")

Retail Deployment: Where You Actually Land on the Curve

Stop Competing in the First 3 Hours

Institutional low-latency desks with direct transcript feeds and dedicated inference infrastructure own the first few hours after release — that portion of the decay curve is not a realistic target for a retail pipeline running on delayed data and consumer-grade compute. The retail-viable version of this strategy targets the multi-day residual drift tail, where slower-moving capital is still repositioning and the signal, while smaller, is more accessible on a delay.

Focus on Under-Covered Names

Because the decay half-life stretches longer for names with thin analyst coverage, retail tone-extraction has a structurally better risk/reward on small- and mid-cap names than on the most heavily covered mega-caps, where the first-hour institutional reaction has typically already consumed most of the available price impact before a retail pipeline can act.

Illustrative Performance

The figures below are hypothetical illustrations of the payoff shape of a decay-weighted tone-divergence strategy targeting the 1-3 day residual window — they are not a track record and are not a promise of similar results. They exist to make the risk/reward shape concrete, not to suggest predictability.

Common Mistakes That Erase This Edge

Your Action Plan

Phase 1: Build and Validate the Scoring Pipeline (4-8 Weeks)

Timeline: Before risking any capital, confirm the pipeline produces sensible, stable scores.

1. Install FinBERT (Hugging Face, free) and run it against a set of historical transcripts with known subsequent price reactions
2. Build the prepared-remarks/Q&A splitter and manually spot-check a sample of splits for accuracy
3. Compute and journal a per-name tone baseline across several quarters before treating any single reading as a signal

Phase 2: Small, Decay-Aware Deployment (2-4 Months)

Timeline: Start with the smallest tradeable size, on the 1-3 day window only.

1. Trade only the residual-tail window — skip the same-day reaction entirely; you're not equipped to compete for it
2. Prioritize under-covered small/mid-caps where the decay half-life is longer and retail latency matters less
3. Require tone-divergence and alt-data agreement before sizing a position — never trade text tone alone at full size
4. Log every trade's realized decay behavior to refine your half-life estimates by liquidity bucket

Phase 3: Systematic Scaling (6+ Months)

Timeline: Only after a full earnings cycle (or more) of validated, small-size execution.

1. Automate filing/transcript ingestion against a real-time EDGAR alert feed and a paid transcript provider
2. Diversify across a basket of names rather than concentrating on high-conviction single names
3. Re-validate decay half-life estimates each earnings season — market regime and coverage patterns shift over time

Recommended Reading

• Institutional Research:
  • Two Sigma Research — published commentary on NLP and unstructured data in systematic investing
  • Point72 / Cubist Systematic Strategies — public commentary on machine learning and alternative data pipelines
• Related PMR Articles:
  • Goldman Sachs Alternative Data (companion piece on FinBERT and satellite/social signal ensembles)
  • Point72 Cubist ML Pipeline (companion piece on the broader ML production pipeline this tone signal would feed into)