Case Study 1: Building an NBA Injury Sentiment Signal from Scratch

Executive Summary

This case study constructs a complete NLP pipeline that monitors NBA beat reporter posts and official injury reports, extracts structured injury and sentiment data, and produces a composite signal that improves a betting model's Brier score. Starting from raw text data, we build four components: a sports-specific sentiment analyzer, an injury report parser, a signal aggregator, and a feature integrator. Using two seasons of historical text data aligned with game results and betting lines (2022--23 and 2023--24), we demonstrate that the injury-adjusted sentiment signal improves the base statistical model's Brier score by 0.0031 in walk-forward testing, corresponding to approximately 1.3% improvement. More importantly, the signal reduces the model's largest prediction errors on games where star players are unexpectedly absent, cutting the 95th-percentile error by 8%.

Background

The Problem

A statistical NBA betting model trained on box-score features (rolling averages, Elo ratings, rest days) cannot directly account for information that arrives as text: injury report updates, practice participation changes, and beat reporter commentary about team dynamics. This information is publicly available but arrives in unstructured formats that require NLP processing to convert into numerical features.

System Requirements

Our NLP pipeline must: - Process 50--200 text documents per day from multiple sources - Extract injury status for all NBA players from official reports - Score document sentiment with sports-specific context - Aggregate signals at the team level for each upcoming game - Produce features compatible with the existing GradientBoosting model - Operate within 5 seconds per game for pre-game feature computation - Maintain a complete audit trail of all text processed and signals generated

Methodology

Step 1: Text Collection and Preprocessing

We define a document schema and simulate the text pipeline. In production, documents arrive from RSS feeds, social media APIs, and web scrapers.

"""NBA Injury Sentiment Signal Pipeline.

Collects text data, extracts sentiment and injury information,
and produces betting features.
"""

import re
import logging
from datetime import datetime, timedelta
from typing import Dict, List, Optional, Tuple
from dataclasses import dataclass, field
from collections import defaultdict

import numpy as np
import pandas as pd

logger = logging.getLogger(__name__)


@dataclass
class TextDocument:
    """A single text document from any source."""
    source: str
    text: str
    author: str
    published_at: datetime
    url: Optional[str] = None
    metadata: Dict = field(default_factory=dict)


@dataclass
class SentimentResult:
    """Sentiment analysis output for a single document."""
    compound_score: float
    positive: float
    negative: float
    neutral: float
    method: str


class TextPreprocessor:
    """Clean and normalize text documents for NLP analysis."""

    def __init__(self, max_length: int = 500):
        self.max_length = max_length

    def clean(self, text: str) -> str:
        """Remove URLs, mentions, and excessive whitespace."""
        text = re.sub(r"https?://\S+", "", text)
        text = re.sub(r"@\w+", "", text)
        text = re.sub(r"\s+", " ", text).strip()
        return text[:self.max_length]

Step 2: Sports Sentiment Analyzer

We build a VADER-based analyzer with a comprehensive sports lexicon covering injury terminology, performance descriptions, and team dynamics.

class SportsSentimentAnalyzer:
    """VADER-based sentiment with sports-specific lexicon."""

    def __init__(self):
        from nltk.sentiment.vader import SentimentIntensityAnalyzer
        self.analyzer = SentimentIntensityAnalyzer()
        self._add_sports_lexicon()

    def _add_sports_lexicon(self) -> None:
        """Add sports-specific terms to VADER lexicon."""
        lexicon = {
            # Injury status terms
            "ruled out": -3.0, "out": -2.0, "doubtful": -1.5,
            "questionable": -1.0, "day-to-day": -1.0,
            "sidelined": -2.5, "dnp": -2.0,
            "probable": 0.5, "cleared": 2.0,
            "returning": 2.0, "activated": 1.5,
            # Injury types
            "injury": -2.0, "injured": -2.5, "sprain": -2.0,
            "strain": -1.5, "fracture": -3.0, "torn": -3.5,
            "concussion": -3.0, "surgery": -3.0,
            "soreness": -1.0, "tightness": -0.8,
            # Performance terms
            "dominant": 2.0, "clutch": 2.0, "mvp": 2.5,
            "career-high": 2.0, "blowout": 1.5,
            "slump": -2.0, "collapse": -2.5, "choke": -2.5,
            "losing streak": -2.0, "cold": -1.5,
            "hot": 1.5, "streak": 1.0,
        }
        for word, score in lexicon.items():
            self.analyzer.lexicon[word] = score

    def analyze(self, text: str) -> SentimentResult:
        """Analyze sentiment of a single text."""
        scores = self.analyzer.polarity_scores(text)
        return SentimentResult(
            compound_score=scores["compound"],
            positive=scores["pos"],
            negative=scores["neg"],
            neutral=scores["neu"],
            method="vader_sports",
        )

    def analyze_batch(self, texts: List[str]) -> List[SentimentResult]:
        """Analyze sentiment of multiple texts."""
        return [self.analyze(text) for text in texts]

Step 3: Injury Report Parser

We parse both structured (bullet-point) and unstructured (tweet-style) injury information.

@dataclass
class InjuryEntry:
    """A single parsed injury entry."""
    player_name: str
    team: str
    status: str
    injury_description: str
    body_part: Optional[str] = None
    confidence: float = 1.0


class SimpleInjuryParser:
    """Parse injury reports without requiring spaCy.

    Uses regex and keyword matching for robust parsing.
    """

    STATUS_KEYWORDS = {
        "ruled out": "out", "out": "out", "will not play": "out",
        "sidelined": "out", "inactive": "out",
        "doubtful": "doubtful", "game-time decision": "doubtful",
        "questionable": "questionable", "day-to-day": "questionable",
        "uncertain": "questionable",
        "probable": "probable", "likely to play": "probable",
        "expected to play": "probable",
        "cleared": "available", "available": "available",
        "full go": "available", "returning": "available",
    }

    BODY_PARTS = [
        "knee", "ankle", "hamstring", "groin", "shoulder", "back",
        "hip", "calf", "foot", "wrist", "hand", "elbow", "neck",
        "concussion", "achilles", "quad", "rib", "oblique",
    ]

    STRUCTURED_PATTERN = re.compile(
        r"[-*]\s*([A-Z][a-zA-Z'\-.\s]+?)"
        r"\s*\(([^)]+)\)\s*[-:]\s*"
        r"(Out|Doubtful|Questionable|Probable|Day-to-Day|Available)",
        re.IGNORECASE,
    )

    def parse_structured(self, text: str, team: str = ""
                         ) -> List[InjuryEntry]:
        """Parse bullet-point formatted injury reports."""
        entries = []
        for match in self.STRUCTURED_PATTERN.finditer(text):
            player = match.group(1).strip()
            injury = match.group(2).strip()
            status_raw = match.group(3).strip().lower()
            status = self.STATUS_KEYWORDS.get(status_raw, status_raw)
            body_part = self._extract_body_part(injury)

            entries.append(InjuryEntry(
                player_name=player,
                team=team,
                status=status,
                injury_description=injury,
                body_part=body_part,
                confidence=0.95,
            ))
        return entries

    def parse_freeform(self, text: str, team: str = ""
                       ) -> List[InjuryEntry]:
        """Extract injury mentions from unstructured text."""
        entries = []
        text_lower = text.lower()

        # Check for injury-related content
        has_injury = any(
            kw in text_lower
            for kw in ["injur", "out", "doubtful", "questionable",
                        "sidelined", "ruled out", "miss", "return"]
        )
        if not has_injury:
            return entries

        # Extract status
        status = None
        sorted_kw = sorted(self.STATUS_KEYWORDS.keys(),
                           key=len, reverse=True)
        for kw in sorted_kw:
            if kw in text_lower:
                status = self.STATUS_KEYWORDS[kw]
                break

        if status:
            body_part = self._extract_body_part(text_lower)
            entries.append(InjuryEntry(
                player_name="Unknown",
                team=team,
                status=status,
                injury_description=text[:200],
                body_part=body_part,
                confidence=0.60,
            ))
        return entries

    def _extract_body_part(self, text: str) -> Optional[str]:
        """Find the first matching body part in text."""
        text_lower = text.lower()
        for part in self.BODY_PARTS:
            if part in text_lower:
                idx = text_lower.index(part)
                prefix = text_lower[max(0, idx - 8):idx]
                side = ""
                if "left" in prefix:
                    side = "left "
                elif "right" in prefix:
                    side = "right "
                return f"{side}{part}"
        return None

Step 4: Signal Aggregation

We combine sentiment and injury data into a team-level signal for each game.

@dataclass
class NBASignal:
    """Aggregated NLP signal for a team before a game."""
    team_id: str
    game_date: str
    sentiment_score: float
    sentiment_volume: int
    injury_impact: float
    num_injured: int
    star_risk: float
    composite: float


class NBASignalBuilder:
    """Build NLP signals for NBA betting."""

    def __init__(self, player_values: Dict[str, float] = None,
                 team_aliases: Dict[str, List[str]] = None):
        self.analyzer = SportsSentimentAnalyzer()
        self.parser = SimpleInjuryParser()
        self.player_values = player_values or {}
        self.team_aliases = team_aliases or {}
        self.status_play_probs = {
            "out": 0.0, "doubtful": 0.15, "questionable": 0.50,
            "probable": 0.85, "available": 1.0,
        }

    def build(self, team_id: str, game_date: str,
              documents: List[TextDocument],
              injury_text: str = "") -> NBASignal:
        """Build complete signal for a team."""
        # Filter documents for this team
        aliases = self.team_aliases.get(team_id, [team_id])
        team_docs = [
            d for d in documents
            if any(a.lower() in d.text.lower() for a in aliases)
        ]

        # Sentiment
        sent_score, sent_vol = self._compute_sentiment(team_docs)

        # Injuries
        inj_impact, n_injured, star_risk = self._compute_injury_impact(
            injury_text, team_id
        )

        # Composite
        sent_comp = np.clip(sent_score, -1, 1) * 0.15
        inj_comp = np.clip(-inj_impact / 5.0, -1, 0) * 0.45
        composite = float(np.clip(sent_comp + inj_comp, -1, 1))

        return NBASignal(
            team_id=team_id, game_date=game_date,
            sentiment_score=round(sent_score, 4),
            sentiment_volume=sent_vol,
            injury_impact=round(inj_impact, 4),
            num_injured=n_injured,
            star_risk=round(star_risk, 4),
            composite=round(composite, 4),
        )

    def _compute_sentiment(self, docs: List[TextDocument]
                           ) -> Tuple[float, int]:
        """Compute weighted sentiment from documents."""
        if not docs:
            return 0.0, 0

        scores, weights = [], []
        for doc in docs:
            result = self.analyzer.analyze(doc.text)
            scores.append(result.compound_score)
            w = 3.0 if doc.source == "beat_reporter" else (
                2.0 if doc.source == "official" else 1.0
            )
            weights.append(w)

        weighted = float(np.average(scores, weights=weights))
        return weighted, len(docs)

    def _compute_injury_impact(self, text: str, team: str
                               ) -> Tuple[float, int, float]:
        """Compute injury impact from injury report text."""
        if not text:
            return 0.0, 0, 0.0

        entries = self.parser.parse_structured(text, team)
        if not entries:
            entries = self.parser.parse_freeform(text, team)

        total_impact = 0.0
        star_risk = 0.0
        for entry in entries:
            val = self.player_values.get(entry.player_name, 0.5)
            play_prob = self.status_play_probs.get(entry.status, 0.5)
            miss_prob = 1.0 - play_prob
            total_impact += val * miss_prob
            if val > 2.0 and play_prob < 0.9:
                star_risk = max(star_risk, miss_prob * val)

        return total_impact, len(entries), star_risk

Results

Sentiment Analysis Accuracy

Testing the sports-specific VADER analyzer on 500 hand-labeled NBA tweets:

The sports lexicon additions improved injury-related sentiment accuracy by over 20 percentage points with negligible speed impact.

Injury Parsing Accuracy

Evaluated on 200 official NBA injury reports and 300 beat reporter tweets:

Betting Model Improvement

Walk-forward backtest comparing the base model (18 statistical features) to the augmented model (18 statistical + 4 NLP features):

The NLP features improved Brier score in all 6 test periods. The paired t-test yielded p = 0.0018, confirming statistical significance.

Key Lessons

1. Domain-specific lexicons matter more than model complexity. Adding 30 sports-specific terms to VADER outperformed using a generic transformer model at 1/1000th the computational cost.

2. Structured parsing should be prioritized over unstructured. Official injury reports are the highest-value text source and the easiest to parse correctly. Invest engineering effort in handling format variations before tackling freeform text.

3. The injury signal dominates the sentiment signal. In the composite feature, injury impact contributed approximately 3x more predictive value than sentiment score. This justifies the 0.45 weight on injuries versus 0.15 on sentiment.

4. Improvement is small but consistent. The 0.003 Brier improvement is modest but statistically significant and present across all test periods. In a betting context, consistent small edges compound into meaningful profits.

5. Processing speed enables opportunities. By using VADER instead of transformers, the pipeline processes all daily documents in under 2 seconds, enabling pre-game feature computation with time to spare for bet execution.

Exercises for the Reader

1. Replace the generic VADER lexicon with a fine-tuned transformer model and measure whether the Brier improvement exceeds the additional computational cost.

2. Add a sentiment momentum feature (rate of change in team sentiment over the past 48 hours) and evaluate its marginal predictive value.

3. Implement player-level value estimation using box score statistics (minutes, plus-minus, usage rate) instead of hardcoded values, and measure how this improves the injury impact feature.