refactor for readability

README.md

@@ -38,13 +38,22 @@ This inference pipeline is part of a larger AWS-based NFL play analysis system.
    +-------------------------| X3D        |
                              +-----+------+
                                    |
-                                   v
-                             +-----+------+
-                             | Amazon S3: |
-                             | output-    |
-                             | plays      |
                              +-----+------+
-                                   |
+                             |     |      |
+                             v     |      v
+                      +------+--+  |  +---+--------+
+                      | Amazon  |  |  | SageMaker: |
+                      | S3:     |  |  | Whisper    |
+                      | output- |  |  | Audio      |
+                      | plays   |  |  | Transcript |
+                      +---------+  |  +-----+------+
+                                   |        |
+                                   |        v
+                                   |  +-----+------+
+                                   |  | Amazon S3: |
+                                   |  | play-      |
+                                   |  | transcripts|
+                                   |  +------------+
                                    v
                              +-----+------+
                              | DynamoDB:  |
@@ -52,20 +61,59 @@ This inference pipeline is part of a larger AWS-based NFL play analysis system.
                              +------------+
 ```
 
-**This repository specifically implements the X3D classification component** that runs on SageMaker to analyze video clips and determine play scoring characteristics.
+**This repository implements both the X3D video classification and Whisper audio transcription components** that run on SageMaker to analyze video clips for play scoring characteristics and NFL commentary transcription. In the production architecture, Whisper transcription is applied only to identified plays rather than all video segments.
+
+### Local Processing Pipeline
+
+The optimized processing pipeline separates video and audio analysis for maximum efficiency:
+
+```mermaid
+graph TD
+    A[Video Clips] --> B[Phase 1: Video Analysis]
+    B --> C[X3D Classification]
+    B --> D[NFL Play State Analysis]
+    B --> E[Play Boundary Detection]
+    
+    E --> F{Play Detected?}
+    F -->|Yes| G[Phase 2: Audio Analysis<br/>Play Clips Only]
+    F -->|No| H[Skip Audio]
+    
+    G --> I[Whisper Transcription]
+    G --> J[NFL Sports Corrections]
+    
+    C --> K[classification.json]
+    D --> L[play_analysis.json]
+    E --> L
+    I --> M[transcripts.json<br/>Play Audio Only]
+    J --> M
+    H --> N[No Transcript]
+    
+    style B fill:#e1f5fe
+    style G fill:#f3e5f5
+    style F fill:#fff3e0
+    style K fill:#c8e6c9
+    style L fill:#c8e6c9
+    style M fill:#c8e6c9
+```
 
 ## Repository Structure
 
 ```plaintext
-├── data/                   # Put your 2s video clips here (.mov or .mp4)
-├── segments/               # Output directory for ContinuousScreenSplitter.swift
-├── ContinuousScreenSplitter.swift # Swift tool to capture screen and split into 2s segments
-├── inference.py            # Main inference script: loads model and scores one clip
-├── run_all_clips.py        # Wrapper to iterate over all clips and save classification + transcripts
-├── kinetics_classnames.json# Kinetics-400 label map (auto-downloaded on first run)
-├── requirements.txt        # Python dependencies
-├── classification.json     # Output file with video classification results
-└── transcripts.json        # Output file with audio transcription results
+├── config.py               # 🔧 Central configuration and constants
+├── video.py                # 🎬 Video classification and NFL play analysis
+├── audio.py                # 🎙️ Audio transcription with NFL enhancements
+├── inference.py            # 🔄 Backward compatibility interface
+├── run_all_clips.py        # 🚀 Main processing pipeline orchestrator
+├── speed_test.py           # ⚡ Performance benchmarking tools
+├── data/                   # 📼 Put your 2s video clips here (.mov or .mp4)
+├── segments/               # 📁 Output directory for ContinuousScreenSplitter.swift
+├── ContinuousScreenSplitter.swift # 📱 Swift tool to capture screen and split into segments
+├── kinetics_classnames.json# 📋 Kinetics-400 label map (auto-downloaded on first run)
+├── requirements.txt        # 📦 Python dependencies
+├── classification.json     # 📊 Output: video classification results
+├── transcripts.json        # 📝 Output: audio transcription results
+├── play_analysis.json      # 🏈 Output: NFL play analysis and boundaries
+└── ARCHITECTURE.md         # 📖 Detailed architecture documentation
 ```
 
 ## Prerequisites
@@ -135,9 +183,15 @@ python inference.py data/segment_000.mov
 ```
 
 This will:
-- Print the Top-5 predicted Kinetics-400 labels + probabilities for the given clip
-- Generate high-quality audio transcription using Whisper-Medium with NFL sports vocabulary
-- Save results to `classification.json` and `transcripts.json`
+- Run X3D video classification with NFL play state analysis
+- Generate high-quality audio transcription using Whisper-Medium with NFL enhancements
+- Print results to console and save to `classification.json` and `transcripts.json`
+
+**🏗️ Modular Architecture**: The system now uses a clean modular design:
+- `video.py`: Video classification and play analysis
+- `audio.py`: Audio transcription with NFL corrections  
+- `config.py`: Centralized configuration management
+- `inference.py`: Backward compatibility interface
 
 ### 4. Process clips with optimized pipeline
 
@@ -284,10 +338,21 @@ After:  "is the sixth best quarterback in the NFL"
 ### Pipeline Customization
 
 * **Processing phases**: Use `--video-only` for speed-critical applications
-* **Batch sizes**: Modify save frequency in `run_all_clips.py` (currently every 5 video clips, 3 audio clips)
+* **Batch sizes**: Modify `VIDEO_SAVE_INTERVAL` and `AUDIO_SAVE_INTERVAL` in `config.py`
 * **Testing**: Use `--max-clips N` to limit processing for development
 * **File output**: Customize output file names with `--classification-file`, `--transcript-file`, `--play-analysis-file`
 
+### Modular Architecture Benefits
+
+* **🔧 Easy Configuration**: All settings centralized in `config.py`
+* **🎯 Focused Development**: Separate modules for video, audio, and configuration
+* **🧪 Better Testing**: Individual modules can be tested in isolation
+* **⚡ Performance Tuning**: Optimize video and audio processing independently
+* **📈 Scalability**: Add new models or sports without affecting existing code
+* **🔄 Backward Compatibility**: Existing scripts continue to work unchanged
+
+See `ARCHITECTURE.md` for detailed technical documentation.
+
 ## Troubleshooting
 
 ### Video Issues

audio.py

@@ -0,0 +1,462 @@
+"""
+Audio Transcription and NFL Commentary Processing Module.
+
+This module handles:
+1. Whisper-based speech-to-text transcription optimized for NFL broadcasts
+2. NFL-specific vocabulary enhancement and corrections
+3. Audio preprocessing with noise filtering and normalization
+4. Sports-specific text post-processing and standardization
+
+Key Components:
+- AudioTranscriber: Main class for speech recognition
+- NFLTextCorrector: Sports-specific text correction and enhancement
+- AudioPreprocessor: Audio loading and filtering utilities
+"""
+
+import re
+import subprocess
+from typing import Dict, List, Optional, Tuple
+
+import numpy as np
+from transformers import pipeline
+
+from config import (
+    AUDIO_MODEL_NAME, AUDIO_DEVICE, AUDIO_SAMPLE_RATE, AUDIO_MIN_DURATION, 
+    AUDIO_MIN_AMPLITUDE, AUDIO_HIGHPASS_FREQ, AUDIO_LOWPASS_FREQ,
+    WHISPER_GENERATION_PARAMS, NFL_SPORTS_CONTEXT, NFL_TEAMS, NFL_POSITIONS,
+    ENABLE_DEBUG_PRINTS
+)
+
+
+class AudioPreprocessor:
+    """
+    Audio preprocessing utilities for enhanced transcription quality.
+    
+    Handles audio loading, filtering, and normalization to optimize
+    Whisper transcription for NFL broadcast content.
+    """
+    
+    def __init__(self, 
+                 sample_rate: int = AUDIO_SAMPLE_RATE,
+                 highpass_freq: int = AUDIO_HIGHPASS_FREQ,
+                 lowpass_freq: int = AUDIO_LOWPASS_FREQ):
+        """
+        Initialize audio preprocessor.
+        
+        Args:
+            sample_rate: Target sample rate for audio
+            highpass_freq: High-pass filter frequency (removes low rumble)
+            lowpass_freq: Low-pass filter frequency (removes high noise)
+        """
+        self.sample_rate = sample_rate
+        self.highpass_freq = highpass_freq
+        self.lowpass_freq = lowpass_freq
+    
+    def load_audio(self, path: str) -> Tuple[np.ndarray, int]:
+        """
+        Load and preprocess audio from video file using FFmpeg.
+        
+        Applies noise filtering and normalization for optimal transcription.
+        
+        Args:
+            path: Path to video/audio file
+            
+        Returns:
+            Tuple of (audio_array, sample_rate)
+        """
+        # Build FFmpeg command with audio filtering
+        cmd = [
+            "ffmpeg", "-i", path,
+            "-af", f"highpass=f={self.highpass_freq},lowpass=f={self.lowpass_freq},loudnorm",
+            "-f", "s16le",              # 16-bit signed little-endian
+            "-acodec", "pcm_s16le",     # PCM codec
+            "-ac", "1",                 # Mono channel
+            "-ar", str(self.sample_rate), # Sample rate
+            "pipe:1"                    # Output to stdout
+        ]
+        
+        try:
+            # Run FFmpeg and capture audio data
+            process = subprocess.Popen(
+                cmd, 
+                stdout=subprocess.PIPE, 
+                stderr=subprocess.DEVNULL
+            )
+            raw_audio = process.stdout.read()
+            
+            # Convert to numpy array and normalize to [-1, 1]
+            audio = np.frombuffer(raw_audio, np.int16).astype(np.float32) / 32768.0
+            
+            # Apply additional normalization if audio is present
+            if len(audio) > 0:
+                max_amplitude = np.max(np.abs(audio))
+                if max_amplitude > 0:
+                    audio = audio / (max_amplitude + 1e-8)  # Prevent division by zero
+            
+            return audio, self.sample_rate
+            
+        except Exception as e:
+            if ENABLE_DEBUG_PRINTS:
+                print(f"[ERROR] Audio loading failed for {path}: {e}")
+            return np.array([]), self.sample_rate
+    
+    def is_valid_audio(self, audio: np.ndarray) -> bool:
+        """
+        Check if audio meets minimum quality requirements for transcription.
+        
+        Args:
+            audio: Audio array to validate
+            
+        Returns:
+            True if audio is suitable for transcription
+        """
+        if len(audio) == 0:
+            return False
+        
+        # Check minimum duration
+        duration = len(audio) / self.sample_rate
+        if duration < AUDIO_MIN_DURATION:
+            return False
+        
+        # Check minimum amplitude (not too quiet)
+        max_amplitude = np.max(np.abs(audio))
+        if max_amplitude < AUDIO_MIN_AMPLITUDE:
+            return False
+        
+        return True
+
+
+class NFLTextCorrector:
+    """
+    NFL-specific text correction and enhancement system.
+    
+    Applies sports vocabulary corrections, standardizes terminology,
+    and fixes common transcription errors in NFL commentary.
+    """
+    
+    def __init__(self):
+        """Initialize NFL text corrector with sports-specific rules."""
+        self.nfl_teams = NFL_TEAMS
+        self.nfl_positions = NFL_POSITIONS
+        self.sports_context = NFL_SPORTS_CONTEXT
+        
+        # Build correction dictionaries
+        self._build_correction_patterns()
+    
+    def _build_correction_patterns(self) -> None:
+        """Build regex patterns for common NFL terminology corrections."""
+        self.basic_corrections = {
+            # Position corrections
+            r'\bqb\b': "QB",
+            r'\bquarter back\b': "quarterback", 
+            r'\bwide receiver\b': "wide receiver",
+            r'\btight end\b': "tight end",
+            r'\brunning back\b': "running back",
+            r'\bline backer\b': "linebacker",
+            r'\bcorner back\b': "cornerback",
+            
+            # Play corrections
+            r'\btouch down\b': "touchdown",
+            r'\bfield goal\b': "field goal", 
+            r'\bfirst down\b': "first down",
+            r'\bsecond down\b': "second down",
+            r'\bthird down\b': "third down",
+            r'\bfourth down\b': "fourth down",
+            r'\byard line\b': "yard line",
+            r'\bend zone\b': "end zone",
+            r'\bred zone\b': "red zone",
+            r'\btwo minute warning\b': "two minute warning",
+            
+            # Common misheard words
+            r'\bfourty\b': "forty",
+            r'\bfourty yard\b': "forty yard",
+            r'\btwenny\b': "twenty",
+            r'\bthirty yard\b': "thirty yard",
+            
+            # Numbers/downs that are often misheard
+            r'\b1st\b': "first",
+            r'\b2nd\b': "second", 
+            r'\b3rd\b': "third",
+            r'\b4th\b': "fourth",
+            r'\b1st and 10\b': "first and ten",
+            r'\b2nd and long\b': "second and long",
+            r'\b3rd and short\b': "third and short",
+            
+            # Team name corrections (common mishears)
+            r'\bforty niners\b': "49ers",
+            r'\bforty-niners\b': "49ers", 
+            r'\bsan francisco\b': "49ers",
+            r'\bnew england\b': "Patriots",
+            r'\bgreen bay\b': "Packers",
+            r'\bkansas city\b': "Chiefs",
+            r'\bnew york giants\b': "Giants",
+            r'\bnew york jets\b': "Jets",
+            r'\blos angeles rams\b': "Rams",
+            r'\blos angeles chargers\b': "Chargers",
+            
+            # Yard markers and positions
+            r'\b10 yard line\b': "ten yard line",
+            r'\b20 yard line\b': "twenty yard line",
+            r'\b30 yard line\b': "thirty yard line",
+            r'\b40 yard line\b': "forty yard line", 
+            r'\b50 yard line\b': "fifty yard line",
+            r'\bmid field\b': "midfield",
+            r'\bgoal line\b': "goal line",
+            
+            # Penalties and flags
+            r'\bfalse start\b': "false start",
+            r'\boff side\b': "offside",
+            r'\bpass interference\b': "pass interference",
+            r'\broughing the passer\b': "roughing the passer",
+            r'\bdelay of game\b': "delay of game",
+            
+            # Common play calls
+            r'\bplay action\b': "play action",
+            r'\bscreen pass\b': "screen pass",
+            r'\bdraw play\b': "draw play",
+            r'\bboot leg\b': "bootleg",
+            r'\broll out\b': "rollout",
+            r'\bshot gun\b': "shotgun",
+            r'\bno huddle\b': "no huddle"
+        }
+        
+        self.fuzzy_corrections = {
+            # Team names with common misspellings
+            r'\bpatriots?\b': "Patriots",
+            r'\bcowboys?\b': "Cowboys", 
+            r'\bpackers?\b': "Packers",
+            r'\bchief\b': "Chiefs",
+            r'\bchiefs?\b': "Chiefs",
+            r'\beagles?\b': "Eagles",
+            r'\bgiants?\b': "Giants",
+            r'\brams?\b': "Rams",
+            r'\bsaints?\b': "Saints",
+            
+            # Positions with common variations
+            r'\bquarterbacks?\b': "quarterback",
+            r'\brunning backs?\b': "running back",
+            r'\bwide receivers?\b': "wide receiver",
+            r'\btight ends?\b': "tight end",
+            r'\blinebackers?\b': "linebacker",
+            r'\bcornerbacks?\b': "cornerback",
+            r'\bsafety\b': "safety",
+            r'\bsafeties\b': "safety",
+            
+            # Play terms
+            r'\btouchdowns?\b': "touchdown",
+            r'\bfield goals?\b': "field goal",
+            r'\binterceptions?\b': "interception",
+            r'\bfumbles?\b': "fumble",
+            r'\bsacks?\b': "sack",
+            r'\bpunt\b': "punt",
+            r'\bpunts?\b': "punt",
+            
+            # Numbers and yards
+            r'\byards?\b': "yard",
+            r'\byards? line\b': "yard line",
+            r'\byard lines?\b': "yard line"
+        }
+        
+        # Terms that should always be capitalized
+        self.capitalization_terms = [
+            "NFL", "QB", "Patriots", "Cowboys", "Chiefs", "Packers", "49ers", 
+            "Eagles", "Giants", "Rams", "Saints", "Bills", "Ravens", "Steelers"
+        ]
+    
+    def correct_text(self, text: str) -> str:
+        """
+        Apply comprehensive NFL-specific text corrections.
+        
+        Args:
+            text: Raw transcription text
+            
+        Returns:
+            Corrected and standardized text
+        """
+        if not text:
+            return text
+        
+        corrected = text
+        
+        # Apply basic corrections
+        corrected = self._apply_corrections(corrected, self.basic_corrections)
+        
+        # Apply fuzzy corrections
+        corrected = self._apply_corrections(corrected, self.fuzzy_corrections)
+        
+        # Apply capitalization rules
+        corrected = self._apply_capitalization(corrected)
+        
+        return corrected.strip()
+    
+    def _apply_corrections(self, text: str, corrections: Dict[str, str]) -> str:
+        """Apply a set of regex corrections to text."""
+        corrected = text
+        for pattern, replacement in corrections.items():
+            corrected = re.sub(pattern, replacement, corrected, flags=re.IGNORECASE)
+        return corrected
+    
+    def _apply_capitalization(self, text: str) -> str:
+        """Apply proper capitalization for NFL terms."""
+        corrected = text
+        for term in self.capitalization_terms:
+            pattern = r'\b' + re.escape(term.lower()) + r'\b'
+            corrected = re.sub(pattern, term, corrected, flags=re.IGNORECASE)
+        return corrected
+
+
+class AudioTranscriber:
+    """
+    Whisper-based audio transcriber optimized for NFL broadcasts.
+    
+    Combines Whisper speech recognition with NFL-specific enhancements
+    for high-quality sports commentary transcription.
+    """
+    
+    def __init__(self, 
+                 model_name: str = AUDIO_MODEL_NAME,
+                 device: int = AUDIO_DEVICE):
+        """
+        Initialize audio transcriber.
+        
+        Args:
+            model_name: Whisper model name (base, medium, large)
+            device: Device for inference (-1 for CPU, 0+ for GPU)
+        """
+        self.model_name = model_name
+        self.device = device
+        self.preprocessor = AudioPreprocessor()
+        self.corrector = NFLTextCorrector()
+        
+        # Initialize Whisper pipeline
+        self._initialize_pipeline()
+    
+    def _initialize_pipeline(self) -> None:
+        """Initialize the Whisper transcription pipeline."""
+        if ENABLE_DEBUG_PRINTS:
+            print(f"Initializing Whisper pipeline: {self.model_name}")
+        
+        self.pipeline = pipeline(
+            "automatic-speech-recognition",
+            model=self.model_name,
+            device=self.device,
+            generate_kwargs=WHISPER_GENERATION_PARAMS
+        )
+        
+        if ENABLE_DEBUG_PRINTS:
+            print("Whisper pipeline ready")
+    
+    def transcribe_clip(self, video_path: str) -> str:
+        """
+        Transcribe audio from a video clip with NFL-specific enhancements.
+        
+        Args:
+            video_path: Path to video file
+            
+        Returns:
+            Transcribed and corrected text
+        """
+        # Load and preprocess audio
+        audio, sample_rate = self.preprocessor.load_audio(video_path)
+        
+        # Validate audio quality
+        if not self.preprocessor.is_valid_audio(audio):
+            return ""
+        
+        try:
+            # Run Whisper transcription
+            result = self.pipeline(audio, generate_kwargs=WHISPER_GENERATION_PARAMS)
+            text = result.get("text", "").strip()
+            
+            # Clean up common Whisper artifacts
+            text = self._clean_whisper_artifacts(text)
+            
+            # Apply NFL-specific corrections
+            text = self.corrector.correct_text(text)
+            
+            return text
+            
+        except Exception as e:
+            if ENABLE_DEBUG_PRINTS:
+                print(f"[WARN] Transcription failed for {video_path}: {e}")
+            return ""
+    
+    def _clean_whisper_artifacts(self, text: str) -> str:
+        """Remove common Whisper transcription artifacts."""
+        # Remove placeholder text
+        text = text.replace("[BLANK_AUDIO]", "")
+        text = text.replace("♪", "")  # Remove music notes
+        text = text.replace("(music)", "")
+        text = text.replace("[music]", "")
+        
+        # Clean up extra whitespace
+        text = re.sub(r'\s+', ' ', text)
+        
+        return text.strip()
+
+
+# ============================================================================
+# CONVENIENCE FUNCTIONS FOR BACKWARD COMPATIBILITY
+# ============================================================================
+
+# Global instance for backward compatibility
+_audio_transcriber = None
+
+def get_audio_transcriber() -> AudioTranscriber:
+    """Get global audio transcriber instance (lazy initialization)."""
+    global _audio_transcriber
+    if _audio_transcriber is None:
+        _audio_transcriber = AudioTranscriber()
+    return _audio_transcriber
+
+def transcribe_clip(path: str) -> str:
+    """
+    Backward compatibility function for audio transcription.
+    
+    Args:
+        path: Path to video file
+        
+    Returns:
+        Transcribed text
+    """
+    transcriber = get_audio_transcriber()
+    return transcriber.transcribe_clip(path)
+
+def load_audio(path: str, sr: int = AUDIO_SAMPLE_RATE) -> Tuple[np.ndarray, int]:
+    """
+    Backward compatibility function for audio loading.
+    
+    Args:
+        path: Path to audio/video file
+        sr: Sample rate (kept for compatibility)
+        
+    Returns:
+        Tuple of (audio_array, sample_rate)
+    """
+    preprocessor = AudioPreprocessor(sample_rate=sr)
+    return preprocessor.load_audio(path)
+
+def apply_sports_corrections(text: str) -> str:
+    """
+    Backward compatibility function for text corrections.
+    
+    Args:
+        text: Text to correct
+        
+    Returns:
+        Corrected text
+    """
+    corrector = NFLTextCorrector()
+    return corrector.correct_text(text)
+
+def fuzzy_sports_corrections(text: str) -> str:
+    """
+    Backward compatibility function (now handled within NFLTextCorrector).
+    
+    Args:
+        text: Text to correct
+        
+    Returns:
+        Corrected text
+    """
+    return apply_sports_corrections(text)

classification.json

@@ -20,5 +20,1656 @@
       "\"passing American football (in game)\"",
       0.0025873929262161255
     ]
-  ]
+  ],
+  "segment_002.mov": [
+    [
+      "\"mowing lawn\"",
+      0.004539191722869873
+    ],
+    [
+      "\"riding or walking with horse\"",
+      0.002820482011884451
+    ],
+    [
+      "\"driving tractor\"",
+      0.002591945929452777
+    ],
+    [
+      "\"catching or throwing baseball\"",
+      0.002587514230981469
+    ],
+    [
+      "archery",
+      0.0025512496940791607
+    ]
+  ],
+  "segment_003.mov": [
+    [
+      "\"hurling (sport)\"",
+      0.0035289316438138485
+    ],
+    [
+      "headbutting",
+      0.0029045743867754936
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.002668950939550996
+    ],
+    [
+      "\"pumping fist\"",
+      0.0026475831400603056
+    ],
+    [
+      "\"playing cricket\"",
+      0.002635735785588622
+    ]
+  ],
+  "segment_004.mov": [
+    [
+      "applauding",
+      0.00304257869720459
+    ],
+    [
+      "headbutting",
+      0.0029725206550210714
+    ],
+    [
+      "\"pumping fist\"",
+      0.0029444803949445486
+    ],
+    [
+      "\"hurling (sport)\"",
+      0.0027822419069707394
+    ],
+    [
+      "\"shaking hands\"",
+      0.002624393440783024
+    ]
+  ],
+  "segment_005.mov": [
+    [
+      "\"catching or throwing baseball\"",
+      0.003370030550286174
+    ],
+    [
+      "\"pumping fist\"",
+      0.00289507070556283
+    ],
+    [
+      "\"catching or throwing frisbee\"",
+      0.0026615660171955824
+    ],
+    [
+      "\"eating hotdog\"",
+      0.002651733811944723
+    ],
+    [
+      "\"javelin throw\"",
+      0.0026478723157197237
+    ]
+  ],
+  "segment_006.mov": [
+    [
+      "\"riding mountain bike\"",
+      0.0030539515428245068
+    ],
+    [
+      "\"bench pressing\"",
+      0.0030068582855165005
+    ],
+    [
+      "\"changing wheel\"",
+      0.0028557234909385443
+    ],
+    [
+      "\"checking tires\"",
+      0.002828161232173443
+    ],
+    [
+      "\"changing oil\"",
+      0.0025825132615864277
+    ]
+  ],
+  "segment_007.mov": [
+    [
+      "\"changing oil\"",
+      0.003507673041895032
+    ],
+    [
+      "\"pushing wheelchair\"",
+      0.0028540242929011583
+    ],
+    [
+      "motorcycling",
+      0.002735486486926675
+    ],
+    [
+      "\"checking tires\"",
+      0.0026065800338983536
+    ],
+    [
+      "\"changing wheel\"",
+      0.0026001674123108387
+    ]
+  ],
+  "segment_008.mov": [
+    [
+      "motorcycling",
+      0.0034892940893769264
+    ],
+    [
+      "\"riding mountain bike\"",
+      0.0027264610398560762
+    ],
+    [
+      "\"pushing wheelchair\"",
+      0.0026729153469204903
+    ],
+    [
+      "\"changing oil\"",
+      0.002655936172232032
+    ],
+    [
+      "snowmobiling",
+      0.002622972708195448
+    ]
+  ],
+  "segment_009.mov": [
+    [
+      "\"kicking field goal\"",
+      0.0051559642888605595
+    ],
+    [
+      "\"tossing coin\"",
+      0.002858997555449605
+    ],
+    [
+      "\"passing American football (in game)\"",
+      0.002840855158865452
+    ],
+    [
+      "\"high kick\"",
+      0.0024956425186246634
+    ],
+    [
+      "headbutting",
+      0.002494481625035405
+    ]
+  ],
+  "segment_010.mov": [
+    [
+      "\"tossing coin\"",
+      0.003494303673505783
+    ],
+    [
+      "headbutting",
+      0.003139702370390296
+    ],
+    [
+      "\"kicking field goal\"",
+      0.003000226803123951
+    ],
+    [
+      "\"passing American football (in game)\"",
+      0.0028010711539536715
+    ],
+    [
+      "\"pumping fist\"",
+      0.0026133027859032154
+    ]
+  ],
+  "segment_011.mov": [
+    [
+      "headbutting",
+      0.0035944455303251743
+    ],
+    [
+      "\"kicking field goal\"",
+      0.002746515441685915
+    ],
+    [
+      "\"passing American football (in game)\"",
+      0.00274651194922626
+    ],
+    [
+      "cheerleading",
+      0.0027097328566014767
+    ],
+    [
+      "\"playing ice hockey\"",
+      0.002675419207662344
+    ]
+  ],
+  "segment_012.mov": [
+    [
+      "cheerleading",
+      0.0033036908134818077
+    ],
+    [
+      "\"dancing macarena\"",
+      0.0031919179018586874
+    ],
+    [
+      "applauding",
+      0.0027217946480959654
+    ],
+    [
+      "\"hitting baseball\"",
+      0.0026708708610385656
+    ],
+    [
+      "\"garbage collecting\"",
+      0.0026213040109723806
+    ]
+  ],
+  "segment_013.mov": [
+    [
+      "\"pumping fist\"",
+      0.0035472228191792965
+    ],
+    [
+      "\"kicking field goal\"",
+      0.0027715854812413454
+    ],
+    [
+      "\"dunking basketball\"",
+      0.0027416404336690903
+    ],
+    [
+      "applauding",
+      0.002673310926184058
+    ],
+    [
+      "celebrating",
+      0.002629267517477274
+    ]
+  ],
+  "segment_014.mov": [
+    [
+      "headbutting",
+      0.0038350492250174284
+    ],
+    [
+      "bobsledding",
+      0.002937863813713193
+    ],
+    [
+      "\"playing ice hockey\"",
+      0.002785387681797147
+    ],
+    [
+      "\"punching person (boxing)\"",
+      0.002671806840226054
+    ],
+    [
+      "\"changing wheel\"",
+      0.0026315213181078434
+    ]
+  ],
+  "segment_015.mov": [
+    [
+      "\"passing American football (in game)\"",
+      0.00389948021620512
+    ],
+    [
+      "\"side kick\"",
+      0.003301523393020034
+    ],
+    [
+      "\"kicking field goal\"",
+      0.002986735198646784
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.0026217757258564234
+    ],
+    [
+      "\"catching or throwing baseball\"",
+      0.002540471963584423
+    ]
+  ],
+  "segment_016.mov": [
+    [
+      "\"passing American football (in game)\"",
+      0.006536518689244986
+    ],
+    [
+      "\"side kick\"",
+      0.0025378491263836622
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.0025076796300709248
+    ],
+    [
+      "\"kicking field goal\"",
+      0.002507618861272931
+    ],
+    [
+      "\"high kick\"",
+      0.0024923686869442463
+    ]
+  ],
+  "segment_017.mov": [
+    [
+      "\"passing American football (in game)\"",
+      0.004528654273599386
+    ],
+    [
+      "\"kicking field goal\"",
+      0.003415569895878434
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.0026175878010690212
+    ],
+    [
+      "\"side kick\"",
+      0.0025776273105293512
+    ],
+    [
+      "\"high kick\"",
+      0.0025026851799339056
+    ]
+  ],
+  "segment_018.mov": [
+    [
+      "\"passing American football (in game)\"",
+      0.004061450716108084
+    ],
+    [
+      "\"side kick\"",
+      0.0038009993731975555
+    ],
+    [
+      "\"kicking field goal\"",
+      0.002601894084364176
+    ],
+    [
+      "\"high kick\"",
+      0.002582114189863205
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.0025175546761602163
+    ]
+  ],
+  "segment_019.mov": [
+    [
+      "\"passing American football (in game)\"",
+      0.006576324347406626
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.002554940525442362
+    ],
+    [
+      "\"kicking field goal\"",
+      0.0024935186374932528
+    ],
+    [
+      "\"side kick\"",
+      0.0024903316516429186
+    ],
+    [
+      "\"catching or throwing frisbee\"",
+      0.002489960053935647
+    ]
+  ],
+  "segment_020.mov": [
+    [
+      "\"passing American football (in game)\"",
+      0.006745155900716782
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.002495990600436926
+    ],
+    [
+      "\"kicking field goal\"",
+      0.0024898555129766464
+    ],
+    [
+      "headbutting",
+      0.002489602193236351
+    ],
+    [
+      "\"shaking hands\"",
+      0.0024894699454307556
+    ]
+  ],
+  "segment_021.mov": [
+    [
+      "\"passing American football (in game)\"",
+      0.004887602757662535
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.002793429885059595
+    ],
+    [
+      "situp",
+      0.0026539755053818226
+    ],
+    [
+      "\"dribbling basketball\"",
+      0.0026028482243418694
+    ],
+    [
+      "\"throwing ball\"",
+      0.002529650926589966
+    ]
+  ],
+  "segment_022.mov": [
+    [
+      "\"pumping fist\"",
+      0.002948896726593375
+    ],
+    [
+      "\"passing American football (in game)\"",
+      0.0028372337110340595
+    ],
+    [
+      "\"tossing coin\"",
+      0.0027690029237419367
+    ],
+    [
+      "\"shaking hands\"",
+      0.0027542426250874996
+    ],
+    [
+      "headbutting",
+      0.0026179237756878138
+    ]
+  ],
+  "segment_023.mov": [
+    [
+      "\"pumping fist\"",
+      0.003991341684013605
+    ],
+    [
+      "headbutting",
+      0.002623251872137189
+    ],
+    [
+      "motorcycling",
+      0.0025920518673956394
+    ],
+    [
+      "skydiving",
+      0.0025866003707051277
+    ],
+    [
+      "bobsledding",
+      0.0025851819664239883
+    ]
+  ],
+  "segment_024.mov": [
+    [
+      "\"riding a bike\"",
+      0.0037740382831543684
+    ],
+    [
+      "motorcycling",
+      0.002751761581748724
+    ],
+    [
+      "bobsledding",
+      0.0026172574143856764
+    ],
+    [
+      "\"riding unicycle\"",
+      0.0025924895890057087
+    ],
+    [
+      "\"pumping fist\"",
+      0.0025839442387223244
+    ]
+  ],
+  "segment_025.mov": [
+    [
+      "bobsledding",
+      0.004564006347209215
+    ],
+    [
+      "\"shaking hands\"",
+      0.0026650093495845795
+    ],
+    [
+      "motorcycling",
+      0.002605688525363803
+    ],
+    [
+      "\"pumping fist\"",
+      0.0026000377256423235
+    ],
+    [
+      "skydiving",
+      0.0025698416866362095
+    ]
+  ],
+  "segment_026.mov": [
+    [
+      "\"tossing coin\"",
+      0.005768336355686188
+    ],
+    [
+      "squat",
+      0.0025260422844439745
+    ],
+    [
+      "\"side kick\"",
+      0.0025187088176608086
+    ],
+    [
+      "\"shaking hands\"",
+      0.0025166154373437166
+    ],
+    [
+      "\"kicking field goal\"",
+      0.0025109625421464443
+    ]
+  ],
+  "segment_027.mov": [
+    [
+      "\"carrying baby\"",
+      0.0028944576624780893
+    ],
+    [
+      "\"side kick\"",
+      0.002688055858016014
+    ],
+    [
+      "\"salsa dancing\"",
+      0.002644676947966218
+    ],
+    [
+      "\"hula hooping\"",
+      0.0026000014040619135
+    ],
+    [
+      "archery",
+      0.002581424079835415
+    ]
+  ],
+  "segment_028.mov": [
+    [
+      "\"stretching arm\"",
+      0.004183173179626465
+    ],
+    [
+      "archery",
+      0.0028685072902590036
+    ],
+    [
+      "\"carrying baby\"",
+      0.002629334107041359
+    ],
+    [
+      "yoga",
+      0.0025525041855871677
+    ],
+    [
+      "\"stretching leg\"",
+      0.0025523642543703318
+    ]
+  ],
+  "segment_029.mov": [
+    [
+      "\"getting a tattoo\"",
+      0.0036486154422163963
+    ],
+    [
+      "archery",
+      0.0027306571137160063
+    ],
+    [
+      "\"punching person (boxing)\"",
+      0.0027052827645093203
+    ],
+    [
+      "\"punching bag\"",
+      0.002618985017761588
+    ],
+    [
+      "squat",
+      0.0026112094055861235
+    ]
+  ],
+  "segment_030.mov": [
+    [
+      "\"spray painting\"",
+      0.004089465364813805
+    ],
+    [
+      "\"getting a tattoo\"",
+      0.002762633841484785
+    ],
+    [
+      "\"playing paintball\"",
+      0.0027071302756667137
+    ],
+    [
+      "\"changing wheel\"",
+      0.0026773668359965086
+    ],
+    [
+      "bobsledding",
+      0.0025922050699591637
+    ]
+  ],
+  "segment_031.mov": [
+    [
+      "\"mowing lawn\"",
+      0.0034001749008893967
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.003030994674190879
+    ],
+    [
+      "\"catching or throwing baseball\"",
+      0.0028556634206324816
+    ],
+    [
+      "\"pumping fist\"",
+      0.002578843617811799
+    ],
+    [
+      "\"riding or walking with horse\"",
+      0.002575062680989504
+    ]
+  ],
+  "segment_032.mov": [
+    [
+      "\"passing American football (in game)\"",
+      0.003045632503926754
+    ],
+    [
+      "marching",
+      0.0030235128942877054
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.0029362209606915712
+    ],
+    [
+      "\"kicking field goal\"",
+      0.0027396646328270435
+    ],
+    [
+      "\"hurling (sport)\"",
+      0.002676320029422641
+    ]
+  ],
+  "segment_033.mov": [
+    [
+      "\"mowing lawn\"",
+      0.004852019250392914
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.002654429292306304
+    ],
+    [
+      "\"hurling (sport)\"",
+      0.002581879962235689
+    ],
+    [
+      "\"kicking soccer ball\"",
+      0.0025664607528597116
+    ],
+    [
+      "\"juggling soccer ball\"",
+      0.002544356742873788
+    ]
+  ],
+  "segment_034.mov": [
+    [
+      "archery",
+      0.004724352620542049
+    ],
+    [
+      "\"trimming or shaving beard\"",
+      0.0026578360702842474
+    ],
+    [
+      "\"golf driving\"",
+      0.002610759809613228
+    ],
+    [
+      "\"tossing coin\"",
+      0.002541653113439679
+    ],
+    [
+      "\"mowing lawn\"",
+      0.0025332642253488302
+    ]
+  ],
+  "segment_035.mov": [
+    [
+      "\"playing harmonica\"",
+      0.006103646010160446
+    ],
+    [
+      "whistling",
+      0.002615551697090268
+    ],
+    [
+      "smoking",
+      0.0025100400671362877
+    ],
+    [
+      "yawning",
+      0.0025017866864800453
+    ],
+    [
+      "\"playing ukulele\"",
+      0.0025011510588228703
+    ]
+  ],
+  "segment_036.mov": [
+    [
+      "\"passing American football (in game)\"",
+      0.006577454507350922
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.002514705527573824
+    ],
+    [
+      "\"kicking field goal\"",
+      0.0025104687083512545
+    ],
+    [
+      "\"side kick\"",
+      0.0025097192265093327
+    ],
+    [
+      "\"high kick\"",
+      0.002491986844688654
+    ]
+  ],
+  "segment_037.mov": [
+    [
+      "\"passing American football (in game)\"",
+      0.006760087329894304
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.0024913023225963116
+    ],
+    [
+      "\"kicking field goal\"",
+      0.00248970789834857
+    ],
+    [
+      "\"side kick\"",
+      0.002489360049366951
+    ],
+    [
+      "\"high kick\"",
+      0.002489320933818817
+    ]
+  ],
+  "segment_038.mov": [
+    [
+      "\"passing American football (in game)\"",
+      0.0062811062671244144
+    ],
+    [
+      "\"kicking field goal\"",
+      0.0026691341772675514
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.002501868177205324
+    ],
+    [
+      "\"side kick\"",
+      0.0024906292092055082
+    ],
+    [
+      "\"tossing coin\"",
+      0.0024903123266994953
+    ]
+  ],
+  "segment_039.mov": [
+    [
+      "\"passing American football (in game)\"",
+      0.004427704028785229
+    ],
+    [
+      "\"kicking field goal\"",
+      0.00305744051001966
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.0028497367165982723
+    ],
+    [
+      "\"shaking hands\"",
+      0.0025244825519621372
+    ],
+    [
+      "\"tossing coin\"",
+      0.0025086107198148966
+    ]
+  ],
+  "segment_040.mov": [
+    [
+      "\"passing American football (in game)\"",
+      0.00507122790440917
+    ],
+    [
+      "\"tossing coin\"",
+      0.0028494407888501883
+    ],
+    [
+      "\"kicking field goal\"",
+      0.0025832131505012512
+    ],
+    [
+      "\"shaking hands\"",
+      0.0025662044063210487
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.0025347082410007715
+    ]
+  ],
+  "segment_041.mov": [
+    [
+      "\"passing American football (in game)\"",
+      0.002910151146352291
+    ],
+    [
+      "\"tossing coin\"",
+      0.00288573419675231
+    ],
+    [
+      "bobsledding",
+      0.0027363626286387444
+    ],
+    [
+      "\"changing wheel\"",
+      0.0027150516398251057
+    ],
+    [
+      "\"kicking field goal\"",
+      0.0026453319005668163
+    ]
+  ],
+  "segment_042.mov": [
+    [
+      "bobsledding",
+      0.0029746112413704395
+    ],
+    [
+      "marching",
+      0.0026662067975848913
+    ],
+    [
+      "\"riding mountain bike\"",
+      0.0026005373802036047
+    ],
+    [
+      "archery",
+      0.002575363963842392
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.0025738172698765993
+    ]
+  ],
+  "segment_043.mov": [
+    [
+      "bobsledding",
+      0.0032584425061941147
+    ],
+    [
+      "\"changing wheel\"",
+      0.002937484998255968
+    ],
+    [
+      "\"driving car\"",
+      0.0028462321497499943
+    ],
+    [
+      "motorcycling",
+      0.00263536861166358
+    ],
+    [
+      "skateboarding",
+      0.002625212771818042
+    ]
+  ],
+  "segment_044.mov": [
+    [
+      "archery",
+      0.0029061429668217897
+    ],
+    [
+      "bobsledding",
+      0.002719373907893896
+    ],
+    [
+      "\"golf driving\"",
+      0.0027050392236560583
+    ],
+    [
+      "barbequing",
+      0.0025971110444515944
+    ],
+    [
+      "\"golf putting\"",
+      0.0025699003599584103
+    ]
+  ],
+  "segment_045.mov": [
+    [
+      "barbequing",
+      0.003022523829713464
+    ],
+    [
+      "\"changing wheel\"",
+      0.002754890127107501
+    ],
+    [
+      "\"mowing lawn\"",
+      0.0026360696647316217
+    ],
+    [
+      "auctioning",
+      0.0026054272893816233
+    ],
+    [
+      "\"changing oil\"",
+      0.0025794513057917356
+    ]
+  ],
+  "segment_046.mov": [
+    [
+      "\"tossing coin\"",
+      0.003568414831534028
+    ],
+    [
+      "\"side kick\"",
+      0.003212416311725974
+    ],
+    [
+      "\"rock scissors paper\"",
+      0.002615532139316201
+    ],
+    [
+      "\"punching person (boxing)\"",
+      0.0026119472458958626
+    ],
+    [
+      "\"high kick\"",
+      0.002596732461825013
+    ]
+  ],
+  "segment_047.mov": [
+    [
+      "\"passing American football (in game)\"",
+      0.0031079247128218412
+    ],
+    [
+      "\"juggling soccer ball\"",
+      0.0028041608165949583
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.002784370444715023
+    ],
+    [
+      "\"catching or throwing baseball\"",
+      0.0027656129095703363
+    ],
+    [
+      "\"tossing coin\"",
+      0.0027509713545441628
+    ]
+  ],
+  "segment_048.mov": [
+    [
+      "\"tossing coin\"",
+      0.004612566903233528
+    ],
+    [
+      "\"passing American football (in game)\"",
+      0.0030128920916467905
+    ],
+    [
+      "\"side kick\"",
+      0.002602673601359129
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.0025423497427254915
+    ],
+    [
+      "\"rock scissors paper\"",
+      0.0025353787932544947
+    ]
+  ],
+  "segment_049.mov": [
+    [
+      "beatboxing",
+      0.002776292385533452
+    ],
+    [
+      "\"pumping fist\"",
+      0.0027726562693715096
+    ],
+    [
+      "\"shaking hands\"",
+      0.0027530265506356955
+    ],
+    [
+      "\"playing poker\"",
+      0.002649413887411356
+    ],
+    [
+      "\"arm wrestling\"",
+      0.0026053758338093758
+    ]
+  ],
+  "segment_050.mov": [
+    [
+      "crying",
+      0.0032352209091186523
+    ],
+    [
+      "beatboxing",
+      0.002813587663695216
+    ],
+    [
+      "\"fixing hair\"",
+      0.002721605822443962
+    ],
+    [
+      "\"pumping fist\"",
+      0.002583273220807314
+    ],
+    [
+      "\"brushing hair\"",
+      0.0025578502099961042
+    ]
+  ],
+  "segment_051.mov": [
+    [
+      "\"passing American football (in game)\"",
+      0.005108952056616545
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.002873431658372283
+    ],
+    [
+      "\"side kick\"",
+      0.002661630278453231
+    ],
+    [
+      "\"kicking field goal\"",
+      0.0026403891388326883
+    ],
+    [
+      "\"high kick\"",
+      0.0025104281958192587
+    ]
+  ],
+  "segment_052.mov": [
+    [
+      "\"passing American football (in game)\"",
+      0.0058504920452833176
+    ],
+    [
+      "\"kicking field goal\"",
+      0.0027115345001220703
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.0026032112073153257
+    ],
+    [
+      "\"side kick\"",
+      0.0025289678014814854
+    ],
+    [
+      "\"high kick\"",
+      0.002494329586625099
+    ]
+  ],
+  "segment_053.mov": [
+    [
+      "\"passing American football (in game)\"",
+      0.006694582756608725
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.0025113301817327738
+    ],
+    [
+      "\"side kick\"",
+      0.0024927803315222263
+    ],
+    [
+      "\"kicking field goal\"",
+      0.0024906357284635305
+    ],
+    [
+      "\"high kick\"",
+      0.002489699050784111
+    ]
+  ],
+  "segment_054.mov": [
+    [
+      "\"passing American football (in game)\"",
+      0.006701494567096233
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.0025095203891396523
+    ],
+    [
+      "\"kicking field goal\"",
+      0.0024933733511716127
+    ],
+    [
+      "\"side kick\"",
+      0.002489532344043255
+    ],
+    [
+      "headbutting",
+      0.002489422680810094
+    ]
+  ],
+  "segment_055.mov": [
+    [
+      "\"passing American football (in game)\"",
+      0.005614574532955885
+    ],
+    [
+      "\"kicking field goal\"",
+      0.002844724338501692
+    ],
+    [
+      "\"tossing coin\"",
+      0.0025539705529809
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.0025522371288388968
+    ],
+    [
+      "headbutting",
+      0.0024937023408710957
+    ]
+  ],
+  "segment_056.mov": [
+    [
+      "headbutting",
+      0.003259368008002639
+    ],
+    [
+      "\"pumping fist\"",
+      0.0029684980399906635
+    ],
+    [
+      "\"playing ice hockey\"",
+      0.0029396419413387775
+    ],
+    [
+      "\"shaking hands\"",
+      0.002817715285345912
+    ],
+    [
+      "\"passing American football (in game)\"",
+      0.002679395256564021
+    ]
+  ],
+  "segment_057.mov": [
+    [
+      "bobsledding",
+      0.004842189606279135
+    ],
+    [
+      "\"pumping fist\"",
+      0.002615878591313958
+    ],
+    [
+      "\"driving car\"",
+      0.002567970659583807
+    ],
+    [
+      "\"playing poker\"",
+      0.0025621275417506695
+    ],
+    [
+      "\"playing ice hockey\"",
+      0.002544831018894911
+    ]
+  ],
+  "segment_058.mov": [
+    [
+      "motorcycling",
+      0.002834487706422806
+    ],
+    [
+      "\"driving car\"",
+      0.002728639403358102
+    ],
+    [
+      "\"changing wheel\"",
+      0.0027119864244014025
+    ],
+    [
+      "bobsledding",
+      0.002644300926476717
+    ],
+    [
+      "kissing",
+      0.002592987846583128
+    ]
+  ],
+  "segment_059.mov": [
+    [
+      "bobsledding",
+      0.004265598952770233
+    ],
+    [
+      "\"playing ice hockey\"",
+      0.0030175303108990192
+    ],
+    [
+      "\"playing paintball\"",
+      0.002638093428686261
+    ],
+    [
+      "motorcycling",
+      0.0025540166534483433
+    ],
+    [
+      "\"riding mountain bike\"",
+      0.002545550698414445
+    ]
+  ],
+  "segment_060.mov": [
+    [
+      "\"passing American football (in game)\"",
+      0.005962858442217112
+    ],
+    [
+      "\"kicking field goal\"",
+      0.002803174778819084
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.0025008893571794033
+    ],
+    [
+      "\"side kick\"",
+      0.0024952334351837635
+    ],
+    [
+      "headbutting",
+      0.002492264611646533
+    ]
+  ],
+  "segment_061.mov": [
+    [
+      "\"passing American football (in game)\"",
+      0.006750195287168026
+    ],
+    [
+      "\"kicking field goal\"",
+      0.0024920343421399593
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.002491830848157406
+    ],
+    [
+      "\"side kick\"",
+      0.0024899402633309364
+    ],
+    [
+      "\"high kick\"",
+      0.002489452948793769
+    ]
+  ],
+  "segment_062.mov": [
+    [
+      "\"passing American football (in game)\"",
+      0.006219817325472832
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.002605071058496833
+    ],
+    [
+      "headbutting",
+      0.0025401373859494925
+    ],
+    [
+      "\"kicking field goal\"",
+      0.0025001864414662123
+    ],
+    [
+      "\"pumping fist\"",
+      0.002497575245797634
+    ]
+  ],
+  "segment_063.mov": [
+    [
+      "marching",
+      0.003558160038664937
+    ],
+    [
+      "\"passing American football (in game)\"",
+      0.0030603946652263403
+    ],
+    [
+      "\"tango dancing\"",
+      0.00266551086679101
+    ],
+    [
+      "\"side kick\"",
+      0.002660425379872322
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.002627450041472912
+    ]
+  ],
+  "segment_064.mov": [
+    [
+      "\"passing American football (in game)\"",
+      0.00557365408167243
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.0027207054663449526
+    ],
+    [
+      "headbutting",
+      0.0026054433546960354
+    ],
+    [
+      "\"pumping fist\"",
+      0.00251823291182518
+    ],
+    [
+      "\"kicking field goal\"",
+      0.002515583299100399
+    ]
+  ],
+  "segment_065.mov": [
+    [
+      "\"side kick\"",
+      0.005902828648686409
+    ],
+    [
+      "\"high kick\"",
+      0.0025668020825833082
+    ],
+    [
+      "wrestling",
+      0.0025415299460291862
+    ],
+    [
+      "squat",
+      0.0025292884092777967
+    ],
+    [
+      "\"drop kicking\"",
+      0.00251045823097229
+    ]
+  ],
+  "segment_066.mov": [
+    [
+      "bobsledding",
+      0.003806664375588298
+    ],
+    [
+      "\"changing wheel\"",
+      0.0029659303836524487
+    ],
+    [
+      "\"punching bag\"",
+      0.0027637933380901814
+    ],
+    [
+      "headbutting",
+      0.00258650747127831
+    ],
+    [
+      "motorcycling",
+      0.002585215028375387
+    ]
+  ],
+  "segment_067.mov": [
+    [
+      "\"changing wheel\"",
+      0.0038947509601712227
+    ],
+    [
+      "\"pushing car\"",
+      0.002689485903829336
+    ],
+    [
+      "\"driving car\"",
+      0.00266862940043211
+    ],
+    [
+      "\"changing oil\"",
+      0.0026266295462846756
+    ],
+    [
+      "\"arm wrestling\"",
+      0.0025696069933474064
+    ]
+  ],
+  "segment_068.mov": [
+    [
+      "\"passing American football (not in game)\"",
+      0.0030197601299732924
+    ],
+    [
+      "\"passing American football (in game)\"",
+      0.0029855112079530954
+    ],
+    [
+      "\"kicking field goal\"",
+      0.0027115403208881617
+    ],
+    [
+      "\"catching or throwing baseball\"",
+      0.0026096913497895002
+    ],
+    [
+      "\"high kick\"",
+      0.0026070410385727882
+    ]
+  ],
+  "segment_069.mov": [
+    [
+      "\"passing American football (in game)\"",
+      0.005361294839531183
+    ],
+    [
+      "\"kicking field goal\"",
+      0.002796306274831295
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.0027009581681340933
+    ],
+    [
+      "\"side kick\"",
+      0.002553092548623681
+    ],
+    [
+      "\"high kick\"",
+      0.002506962278857827
+    ]
+  ],
+  "segment_070.mov": [
+    [
+      "\"passing American football (in game)\"",
+      0.005472357384860516
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.002799208741635084
+    ],
+    [
+      "\"kicking field goal\"",
+      0.0027042534202337265
+    ],
+    [
+      "\"side kick\"",
+      0.0025148894637823105
+    ],
+    [
+      "\"catching or throwing baseball\"",
+      0.002496932167559862
+    ]
+  ],
+  "segment_071.mov": [
+    [
+      "\"side kick\"",
+      0.003893344197422266
+    ],
+    [
+      "\"passing American football (in game)\"",
+      0.0035547567531466484
+    ],
+    [
+      "\"kicking field goal\"",
+      0.002741483272984624
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.0026810814160853624
+    ],
+    [
+      "\"catching or throwing baseball\"",
+      0.0025338695850223303
+    ]
+  ],
+  "segment_072.mov": [
+    [
+      "\"passing American football (in game)\"",
+      0.005563896149396896
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.0027015593368560076
+    ],
+    [
+      "\"side kick\"",
+      0.002657951321452856
+    ],
+    [
+      "\"kicking field goal\"",
+      0.0026104655116796494
+    ],
+    [
+      "\"catching or throwing baseball\"",
+      0.0024953498505055904
+    ]
+  ],
+  "segment_073.mov": [
+    [
+      "\"passing American football (in game)\"",
+      0.006470989435911179
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.0025515288580209017
+    ],
+    [
+      "\"side kick\"",
+      0.0025365715846419334
+    ],
+    [
+      "\"kicking field goal\"",
+      0.002492384286597371
+    ],
+    [
+      "\"high kick\"",
+      0.002490945626050234
+    ]
+  ],
+  "segment_074.mov": [
+    [
+      "\"passing American football (in game)\"",
+      0.004092047456651926
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.0037548826076090336
+    ],
+    [
+      "\"side kick\"",
+      0.0026034193579107523
+    ],
+    [
+      "\"kicking field goal\"",
+      0.0025540809147059917
+    ],
+    [
+      "\"catching or throwing baseball\"",
+      0.0025116554461419582
+    ]
+  ],
+  "segment_075.mov": [
+    [
+      "\"passing American football (in game)\"",
+      0.006258341949433088
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.002621858147904277
+    ],
+    [
+      "\"kicking field goal\"",
+      0.0025423644110560417
+    ],
+    [
+      "\"catching or throwing baseball\"",
+      0.0024970977101475
+    ],
+    [
+      "\"pumping fist\"",
+      0.0024926913902163506
+    ]
+  ],
+  "segment_076.mov": [
+    [
+      "\"hurling (sport)\"",
+      0.003916610963642597
+    ],
+    [
+      "headbutting",
+      0.0029018200002610683
+    ],
+    [
+      "\"passing American football (in game)\"",
+      0.0027735705953091383
+    ],
+    [
+      "\"passing American football (not in game)\"",
+      0.00273358216509223
+    ],
+    [
+      "\"kicking field goal\"",
+      0.0026465952396392822
+    ]
+  ],
+  "segment_077.mov": []
 }

config.py

@@ -0,0 +1,163 @@
+"""
+Configuration constants and settings for NFL Play Detection System.
+
+This module centralizes all configuration parameters to make the system
+easier to tune and maintain.
+"""
+
+import torch
+
+# ============================================================================
+# MODEL CONFIGURATION
+# ============================================================================
+
+# Video Classification Model
+VIDEO_MODEL_NAME = "x3d_m"  # Options: x3d_xs, x3d_s, x3d_m, x3d_l
+DEVICE = torch.device("cpu")  # Use "cuda" for GPU acceleration if available
+
+# Audio Transcription Model
+AUDIO_MODEL_NAME = "openai/whisper-medium"  # Options: whisper-base, whisper-medium, whisper-large
+AUDIO_DEVICE = -1  # -1 for CPU, 0+ for GPU device index
+
+# ============================================================================
+# VIDEO PROCESSING PARAMETERS
+# ============================================================================
+
+# Video preprocessing settings
+VIDEO_CLIP_DURATION = 2.0  # Duration in seconds for video clips
+VIDEO_NUM_SAMPLES = 16     # Number of frames to sample from clip
+VIDEO_SIZE = 224           # Spatial size for model input (224x224)
+
+# Kinetics-400 label map
+KINETICS_LABELS_URL = "https://dl.fbaipublicfiles.com/pyslowfast/dataset/class_names/kinetics_classnames.json"
+KINETICS_LABELS_PATH = "kinetics_classnames.json"
+
+# Video preprocessing normalization (ImageNet standards)
+VIDEO_MEAN = [0.45, 0.45, 0.45]
+VIDEO_STD = [0.225, 0.225, 0.225]
+
+# ============================================================================
+# PLAY DETECTION PARAMETERS
+# ============================================================================
+
+# Confidence thresholds for play state detection
+PLAY_CONFIDENCE_THRESHOLD = 0.002
+PLAY_BOUNDARY_WINDOW_SIZE = 3
+
+# NFL-specific action classifications for play state detection
+PLAY_START_INDICATORS = [
+    "passing American football (in game)",
+    "kicking field goal", 
+    "side kick",
+    "high kick"
+]
+
+PLAY_ACTION_INDICATORS = [
+    "catching or throwing baseball",  # Often misclassified football throws
+    "catching or throwing softball",
+    "playing cricket",  # Sometimes catches football
+    "throwing ball"
+]
+
+NON_PLAY_INDICATORS = [
+    "applauding",
+    "marching", 
+    "sitting",
+    "standing",
+    "clapping",
+    "cheering"
+]
+
+# ============================================================================
+# AUDIO PROCESSING PARAMETERS
+# ============================================================================
+
+# Audio preprocessing settings
+AUDIO_SAMPLE_RATE = 16000
+AUDIO_MIN_DURATION = 0.5  # Minimum duration in seconds to process
+AUDIO_MIN_AMPLITUDE = 0.01  # Minimum amplitude threshold
+
+# FFmpeg audio filtering parameters
+AUDIO_HIGHPASS_FREQ = 80    # Hz - remove low frequency noise
+AUDIO_LOWPASS_FREQ = 8000   # Hz - remove high frequency noise
+
+# Whisper generation parameters (optimized for speed and NFL content)
+WHISPER_GENERATION_PARAMS = {
+    "language": "en",           # Force English detection
+    "task": "transcribe",       # Don't translate
+    "temperature": 0.0,         # Deterministic output
+    "do_sample": False,         # Greedy decoding (fastest)
+    "num_beams": 1,            # Single beam (fastest)
+    "length_penalty": 0.0,     # No length penalty for speed
+    "early_stopping": True     # Stop as soon as possible
+}
+
+# ============================================================================
+# NFL SPORTS VOCABULARY AND CORRECTIONS
+# ============================================================================
+
+# Comprehensive NFL terminology for transcription enhancement
+NFL_TEAMS = [
+    "Patriots", "Cowboys", "Packers", "49ers", "Chiefs", "Bills", "Ravens", "Steelers",
+    "Eagles", "Giants", "Rams", "Saints", "Buccaneers", "Panthers", "Falcons", "Cardinals",
+    "Seahawks", "Broncos", "Raiders", "Chargers", "Dolphins", "Jets", "Colts", "Titans",
+    "Jaguars", "Texans", "Browns", "Bengals", "Lions", "Vikings", "Bears", "Commanders"
+]
+
+NFL_POSITIONS = [
+    "quarterback", "QB", "running back", "wide receiver", "tight end", "offensive line",
+    "defensive end", "linebacker", "cornerback", "safety", "kicker", "punter",
+    "center", "guard", "tackle", "fullback", "nose tackle", "middle linebacker"
+]
+
+NFL_TERMINOLOGY = [
+    "touchdown", "field goal", "first down", "second down", "third down", "fourth down",
+    "punt", "fumble", "interception", "sack", "blitz", "snap", "hike", "audible",
+    "red zone", "end zone", "yard line", "scrimmage", "pocket", "shotgun formation",
+    "play action", "screen pass", "draw play", "bootleg", "rollout", "scramble",
+    "timeout", "penalty", "flag", "holding", "false start", "offside", "encroachment",
+    "pass interference", "roughing the passer", "illegal formation", "delay of game"
+]
+
+NFL_GAME_SITUATIONS = [
+    "two minute warning", "overtime", "coin toss", "kickoff", "touchback", "fair catch",
+    "onside kick", "safety", "conversion", "extra point", "two point conversion",
+    "challenge", "replay", "incomplete", "completion", "rushing yards", "passing yards"
+]
+
+NFL_COMMENTARY_TERMS = [
+    "yards to go", "first and ten", "goal line", "midfield", "hash marks",
+    "pocket presence", "arm strength", "accuracy", "mobility", "coverage",
+    "rush defense", "pass rush", "secondary", "offensive line", "defensive line"
+]
+
+# Combine all NFL terms for comprehensive vocabulary
+NFL_SPORTS_CONTEXT = NFL_TEAMS + NFL_POSITIONS + NFL_TERMINOLOGY + NFL_GAME_SITUATIONS + NFL_COMMENTARY_TERMS
+
+# ============================================================================
+# FILE PROCESSING PARAMETERS
+# ============================================================================
+
+# Supported video file formats
+SUPPORTED_VIDEO_FORMATS = ["*.mov", "*.mp4"]
+
+# Default output file names
+DEFAULT_CLASSIFICATION_FILE = "classification.json"
+DEFAULT_TRANSCRIPT_FILE = "transcripts.json"
+DEFAULT_PLAY_ANALYSIS_FILE = "play_analysis.json"
+
+# Progress saving intervals
+VIDEO_SAVE_INTERVAL = 5   # Save video results every N clips
+AUDIO_SAVE_INTERVAL = 3   # Save audio results every N clips
+
+# ============================================================================
+# LOGGING AND DEBUG SETTINGS
+# ============================================================================
+
+# Debug output control
+ENABLE_DEBUG_PRINTS = False
+ENABLE_FRAME_SHAPE_DEBUG = False  # Can be expensive for large batches
+
+# Progress reporting
+ENABLE_PROGRESS_BARS = True
+ENABLE_PERFORMANCE_TIMING = True

inference.py

@@ -1,471 +1,96 @@
-import os
-import subprocess
-import numpy as np
-import torch
-import json
-import urllib.request
-from pytorchvideo.data.encoded_video import EncodedVideo
-from transformers import pipeline
+"""
+Legacy Inference Module - Backward Compatibility Interface.
 
-# === Config ===
-model_name = "x3d_m"   # options: x3d_xs, x3d_s, x3d_m, x3d_l
-device = torch.device("cpu")
+This module provides a simplified interface that maintains backward compatibility
+with the original inference.py while leveraging the new modular architecture.
 
-# === Load Model ===
-model = torch.hub.load(
-    "facebookresearch/pytorchvideo",
-    model_name,
-    pretrained=True
-).to(device).eval()
+For new development, use the specific modules directly:
+- video.py: Video classification and play analysis
+- audio.py: Audio transcription and NFL corrections
+- config.py: Configuration and constants
 
-# === Load Kinetics-400 Labels ===
-label_map_path = "kinetics_classnames.json"
-if not os.path.exists(label_map_path):
-    urllib.request.urlretrieve(
-        "https://dl.fbaipublicfiles.com/pyslowfast/dataset/class_names/kinetics_classnames.json",
-        label_map_path
-    )
-with open(label_map_path, "r") as f:
-    raw = json.load(f)
+This module is maintained for:
+1. Backward compatibility with existing scripts
+2. Simple single-clip processing interface
+3. Legacy CLI functionality
+"""
 
-# Determine mapping: list, numeric-keys dict, or inverted dict
-if isinstance(raw, list):
-    kinetics_labels = {i: raw[i] for i in range(len(raw))}
-elif isinstance(raw, dict):
-    # check if keys are numeric strings
-    numeric_keys = True
-    for k in raw.keys():
-        try:
-            int(k)
-        except:
-            numeric_keys = False
-            break
-    if numeric_keys:
-        kinetics_labels = {int(k): v for k, v in raw.items()}
-    else:
-        # assume values are indices
-        kinetics_labels = {}
-        for k, v in raw.items():
-            try:
-                idx = int(v)
-                kinetics_labels[idx] = k
-            except:
-                continue
-else:
-    raise ValueError("Unexpected label map format for kinetics_classnames.json")
+import os
+import sys
+import json
+from typing import List, Tuple
+
+# Import from new modular structure
+from video import predict_clip, analyze_play_state, detect_play_boundaries
+from audio import transcribe_clip, load_audio, apply_sports_corrections, fuzzy_sports_corrections
+
+# Re-export all functions for backward compatibility
+__all__ = [
+    'predict_clip',
+    'analyze_play_state', 
+    'detect_play_boundaries',
+    'transcribe_clip',
+    'load_audio',
+    'apply_sports_corrections',
+    'fuzzy_sports_corrections'
+]
 
-# === Preprocessing ===
-def preprocess(frames, num_samples: int = 16, size: int = 224) -> torch.Tensor:
-    C, T, H, W = frames.shape
-    vid = frames.permute(1, 0, 2, 3).float() / 255.0
-    idxs = torch.linspace(0, T - 1, num_samples).long()
-    clip = vid[idxs]
-    top = max((H - size) // 2, 0)
-    left = max((W - size) // 2, 0)
-    clip = clip[:, :, top:top+size, left:left+size]
-    clip = clip.permute(1, 0, 2, 3).unsqueeze(0)
-    mean = torch.tensor([0.45, 0.45, 0.45], device=device).view(1, 3, 1, 1, 1)
-    std = torch.tensor([0.225, 0.225, 0.225], device=device).view(1, 3, 1, 1, 1)
-    clip = (clip - mean) / std
-    return clip
 
-# === Play State Detection ===
-def analyze_play_state(predictions, confidence_threshold=0.002):
-    """
-    Analyze predictions to determine if this is likely start, middle, or end of play
+def main():
     """
-    if not predictions:
-        return "unknown", 0.0
-    
-    # Football-specific labels that indicate different play states
-    play_start_indicators = [
-        "passing American football (in game)",
-        "kicking field goal", 
-        "side kick",
-        "high kick"
-    ]
-    
-    play_action_indicators = [
-        "catching or throwing baseball",  # Often misclassified football throws
-        "catching or throwing softball",
-        "playing cricket",  # Sometimes catches football
-        "throwing ball"
-    ]
+    CLI interface for single clip processing (backward compatibility).
     
-    non_play_indicators = [
-        "applauding",
-        "marching", 
-        "sitting",
-        "standing",
-        "clapping",
-        "cheering"
-    ]
-    
-    # Calculate weighted scores for each state
-    play_start_score = 0.0
-    play_action_score = 0.0
-    non_play_score = 0.0
-    
-    for label, confidence in predictions:
-        # Remove quotes and normalize
-        clean_label = label.replace('"', '').lower()
-        
-        if any(indicator.lower() in clean_label for indicator in play_start_indicators):
-            play_start_score += confidence * 2.0  # Weight play-specific actions higher
-        elif any(indicator.lower() in clean_label for indicator in play_action_indicators):
-            play_action_score += confidence
-        elif any(indicator.lower() in clean_label for indicator in non_play_indicators):
-            non_play_score += confidence
-    
-    # Determine play state
-    max_score = max(play_start_score, play_action_score, non_play_score)
-    
-    if max_score < confidence_threshold:
-        return "unknown", max_score
-    elif play_start_score == max_score:
-        return "play_active", play_start_score
-    elif play_action_score == max_score:
-        return "play_action", play_action_score  
-    else:
-        return "non_play", non_play_score
-
-# === Enhanced Prediction ===
-def predict_clip(path: str):
-    try:
-        video = EncodedVideo.from_path(path)
-        clip_data = video.get_clip(0, 2.0)
-        frames = clip_data["video"]
-        
-        if frames is None:
-            print(f"[ERROR] Failed to load video frames from {path}")
-            return []
-            
-        # print(f"[DEBUG] Loaded video frames shape: {frames.shape}")  # Disabled for speed
-        inp = preprocess(frames).to(device)
-        with torch.no_grad():
-            logits = model(inp)
-            probs = torch.softmax(logits, dim=1)[0]
-        top5 = torch.topk(probs, k=5)
-        results = []
-        for idx_tensor, score in zip(top5.indices, top5.values):
-            idx = idx_tensor.item()
-            label = kinetics_labels.get(idx, f"Class_{idx}")
-            results.append((label, float(score)))
-        
-        # Add play state analysis
-        play_state, confidence = analyze_play_state(results)
-        print(f"[PLAY STATE] {play_state} (confidence: {confidence:.3f})")
-        
-        return results
-    except Exception as e:
-        print(f"[ERROR] Failed to process {path}: {e}")
-        return []
-
-# === Advanced Play Sequence Detection ===
-def detect_play_boundaries(clip_results, window_size=3):
+    Usage:
+        python inference.py path/to/clip.mov
     """
-    Analyze sequence of clips to detect play start and end boundaries
-    """
-    if len(clip_results) < window_size:
-        return []
-    
-    play_states = []
-    for results in clip_results:
-        state, confidence = analyze_play_state(results)
-        play_states.append((state, confidence))
-    
-    boundaries = []
-    
-    # Look for transitions from non_play -> play_active (START)
-    # and play_active -> non_play (END)
-    for i in range(len(play_states) - 1):
-        current_state, current_conf = play_states[i]
-        next_state, next_conf = play_states[i + 1]
-        
-        if (current_state in ["non_play", "unknown"] and 
-            next_state in ["play_active", "play_action"] and
-            next_conf > 0.002):
-            boundaries.append(("play_start", i + 1, next_conf))
-            
-        if (current_state in ["play_active", "play_action"] and
-            next_state in ["non_play", "unknown"] and
-            current_conf > 0.002):
-            boundaries.append(("play_end", i, current_conf))
-    
-    return boundaries
-
-# === Audio ASR Setup ===
-# Using Whisper Medium for optimal NFL broadcast transcription accuracy
-asr = pipeline(
-    "automatic-speech-recognition",
-    model="openai/whisper-medium",  # Medium model for complex broadcast audio
-    device=-1,
-    # Optimized for English sports content
-    generate_kwargs={
-        "language": "en",  # Force English to avoid multilingual detection
-        "task": "transcribe"  # Don't translate
-    }
-)
-
-# === Sports-Specific Vocabulary ===
-NFL_SPORTS_CONTEXT = [
-    # NFL Teams
-    "Patriots", "Cowboys", "Packers", "49ers", "Chiefs", "Bills", "Ravens", "Steelers",
-    "Eagles", "Giants", "Rams", "Saints", "Buccaneers", "Panthers", "Falcons", "Cardinals",
-    "Seahawks", "Broncos", "Raiders", "Chargers", "Dolphins", "Jets", "Colts", "Titans",
-    "Jaguars", "Texans", "Browns", "Bengals", "Lions", "Vikings", "Bears", "Commanders",
-    
-    # NFL Positions
-    "quarterback", "QB", "running back", "wide receiver", "tight end", "offensive line",
-    "defensive end", "linebacker", "cornerback", "safety", "kicker", "punter",
-    "center", "guard", "tackle", "fullback", "nose tackle", "middle linebacker",
-    
-    # NFL Terminology
-    "touchdown", "field goal", "first down", "second down", "third down", "fourth down",
-    "punt", "fumble", "interception", "sack", "blitz", "snap", "hike", "audible",
-    "red zone", "end zone", "yard line", "scrimmage", "pocket", "shotgun formation",
-    "play action", "screen pass", "draw play", "bootleg", "rollout", "scramble",
-    "timeout", "penalty", "flag", "holding", "false start", "offside", "encroachment",
-    "pass interference", "roughing the passer", "illegal formation", "delay of game",
-    
-    # Game Situations
-    "two minute warning", "overtime", "coin toss", "kickoff", "touchback", "fair catch",
-    "onside kick", "safety", "conversion", "extra point", "two point conversion",
-    "challenge", "replay", "incomplete", "completion", "rushing yards", "passing yards",
-    
-    # Common Commentary
-    "yards to go", "first and ten", "goal line", "midfield", "hash marks",
-    "pocket presence", "arm strength", "accuracy", "mobility", "coverage",
-    "rush defense", "pass rush", "secondary", "offensive line", "defensive line"
-]
-
-NFL_PROMPT = " ".join(NFL_SPORTS_CONTEXT[:20])  # Use first 20 terms as prompt context
-
-# === Audio Loading via FFmpeg ===
-def load_audio(path: str, sr: int = 16000):
-    """Enhanced audio loading with filtering and normalization"""
-    cmd = [
-        "ffmpeg", "-i", path,
-        "-af", "highpass=f=80,lowpass=f=8000,loudnorm",  # Filter noise and normalize
-        "-f", "s16le",
-        "-acodec", "pcm_s16le",
-        "-ac", "1", "-ar", str(sr),
-        "pipe:1"
-    ]
-    proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
-    raw = proc.stdout.read()
-    audio = np.frombuffer(raw, np.int16).astype(np.float32) / 32768.0
-    
-    # Normalize audio levels
-    if len(audio) > 0:
-        audio = audio / (np.max(np.abs(audio)) + 1e-8)
-    
-    return audio, sr
-
-# === Enhanced Transcription with Sports Context ===
-def transcribe_clip(path: str) -> str:
-    audio, sr = load_audio(path, sr=16000)
-    
-    # Skip transcription if audio is too short or quiet
-    if len(audio) < sr * 0.5:  # Less than 0.5 seconds
-        return ""
-    
-    if np.max(np.abs(audio)) < 0.01:  # Very quiet audio
-        return ""
-    
-    try:
-        # Speed-optimized parameters for fast testing
-        result = asr(
-            audio,
-            generate_kwargs={
-                "language": "en",
-                "task": "transcribe",
-                "temperature": 0.0,  # Deterministic output
-                "do_sample": False,  # Greedy decoding (fastest)
-                "num_beams": 1,  # Single beam (fastest)
-                "length_penalty": 0.0,  # No length penalty for speed
-                "early_stopping": True  # Stop as soon as possible
-            }
-        )
-        text = result.get("text", "").strip()
-        
-        # Clean up common Whisper artifacts
-        text = text.replace("[BLANK_AUDIO]", "").strip()
-        text = text.replace("♪", "").strip()  # Remove music notes
-        
-        # Post-process with sports-specific corrections
-        text = apply_sports_corrections(text)
-        
-        return text
-    except Exception as e:
-        print(f"[WARN] Transcription failed: {e}")
-        return ""
-
-def apply_sports_corrections(text: str) -> str:
-    """Apply NFL-specific text corrections and standardization"""
-    import re
+    if len(sys.argv) < 2:
+        print("Usage: python inference.py <path_to_video_clip>")
+        print("Example: python inference.py data/segment_001.mov")
+        sys.exit(1)
+    
+    clip_path = sys.argv[1]
+    
+    if not os.path.exists(clip_path):
+        print(f"Error: File '{clip_path}' not found")
+        sys.exit(1)
+    
+    print(f"Processing: {clip_path}")
+    print("=" * 50)
+    
+    # Video classification
+    print("🎬 Video Classification:")
+    predictions = predict_clip(clip_path)
+    
+    if predictions:
+        print(f"\nTop-5 labels for {clip_path}:")
+        for label, score in predictions:
+            print(f"{label:>30s} : {score:.3f}")
+        
+        # Save classification results
+        clip_name = os.path.basename(clip_path)
+        with open("classification.json", "w") as f:
+            json.dump({clip_name: predictions}, f, indent=2)
+        print(f"\n✓ Classification saved to classification.json")
+    else:
+        print("❌ Video classification failed")
     
-    if not text:
-        return text
+    # Audio transcription
+    print("\n🎙️ Audio Transcription:")
+    transcript = transcribe_clip(clip_path)
     
-    # Common misheard sports terms corrections
-    corrections = {
-        # Position corrections
-        r'\bqb\b': "QB",
-        r'\bquarter back\b': "quarterback", 
-        r'\bwide receiver\b': "wide receiver",
-        r'\btight end\b': "tight end",
-        r'\brunning back\b': "running back",
-        r'\bline backer\b': "linebacker",
-        r'\bcorner back\b': "cornerback",
-        
-        # Play corrections
-        r'\btouch down\b': "touchdown",
-        r'\bfield goal\b': "field goal", 
-        r'\bfirst down\b': "first down",
-        r'\bsecond down\b': "second down",
-        r'\bthird down\b': "third down",
-        r'\bfourth down\b': "fourth down",
-        r'\byard line\b': "yard line",
-        r'\bend zone\b': "end zone",
-        r'\bred zone\b': "red zone",
-        r'\btwo minute warning\b': "two minute warning",
-        
-        # Common misheard words
-        r'\bfourty\b': "forty",
-        r'\bfourty yard\b': "forty yard",
-        r'\btwenny\b': "twenty",
-        r'\bthirty yard\b': "thirty yard",
-        
-        # Numbers/downs that are often misheard
-        r'\b1st\b': "first",
-        r'\b2nd\b': "second", 
-        r'\b3rd\b': "third",
-        r'\b4th\b': "fourth",
-        r'\b1st and 10\b': "first and ten",
-        r'\b2nd and long\b': "second and long",
-        r'\b3rd and short\b': "third and short",
-        
-        # Team name corrections (common mishears)
-        r'\bforty niners\b': "49ers",
-        r'\bforty-niners\b': "49ers", 
-        r'\bsan francisco\b': "49ers",
-        r'\bnew england\b': "Patriots",
-        r'\bgreen bay\b': "Packers",
-        r'\bkansas city\b': "Chiefs",
-        r'\bnew york giants\b': "Giants",
-        r'\bnew york jets\b': "Jets",
-        r'\blos angeles rams\b': "Rams",
-        r'\blos angeles chargers\b': "Chargers",
+    if transcript:
+        print(f"Transcript: {transcript}")
         
-        # Yard markers and positions
-        r'\b10 yard line\b': "ten yard line",
-        r'\b20 yard line\b': "twenty yard line",
-        r'\b30 yard line\b': "thirty yard line",
-        r'\b40 yard line\b': "forty yard line", 
-        r'\b50 yard line\b': "fifty yard line",
-        r'\bmid field\b': "midfield",
-        r'\bgoal line\b': "goal line",
-        
-        # Penalties and flags
-        r'\bfalse start\b': "false start",
-        r'\boff side\b': "offside",
-        r'\bpass interference\b': "pass interference",
-        r'\broughing the passer\b': "roughing the passer",
-        r'\bdelay of game\b': "delay of game",
-        
-        # Common play calls
-        r'\bplay action\b': "play action",
-        r'\bscreen pass\b': "screen pass",
-        r'\bdraw play\b': "draw play",
-        r'\bboot leg\b': "bootleg",
-        r'\broll out\b': "rollout",
-        r'\bshot gun\b': "shotgun",
-        r'\bno huddle\b': "no huddle"
-    }
-    
-    # Apply corrections (case-insensitive)
-    corrected_text = text
-    for pattern, replacement in corrections.items():
-        corrected_text = re.sub(pattern, replacement, corrected_text, flags=re.IGNORECASE)
-    
-    # Capitalize specific terms that should always be capitalized
-    capitalize_terms = ["NFL", "QB", "Patriots", "Cowboys", "Chiefs", "Packers", "49ers", 
-                       "Eagles", "Giants", "Rams", "Saints", "Bills", "Ravens", "Steelers"]
-    for term in capitalize_terms:
-        pattern = r'\b' + re.escape(term.lower()) + r'\b'
-        corrected_text = re.sub(pattern, term, corrected_text, flags=re.IGNORECASE)
-    
-    # Enhanced spell-check for common NFL terms using fuzzy matching
-    corrected_text = fuzzy_sports_corrections(corrected_text)
+        # Save transcript results
+        clip_name = os.path.basename(clip_path)
+        with open("transcripts.json", "w") as f:
+            json.dump({clip_name: transcript}, f, indent=2)
+        print(f"✓ Transcript saved to transcripts.json")
+    else:
+        print("ℹ️ No audio content detected or transcription failed")
     
-    return corrected_text.strip()
+    print("\n🏁 Processing complete!")
 
-def fuzzy_sports_corrections(text: str) -> str:
-    """Apply fuzzy matching for sports terms that might be slightly misheard"""
-    import re
-    
-    # Define common NFL terms and their likely misspellings
-    fuzzy_corrections = {
-        # Team names with common misspellings
-        r'\bpatriots?\b': "Patriots",
-        r'\bcowboys?\b': "Cowboys", 
-        r'\bpackers?\b': "Packers",
-        r'\bchief\b': "Chiefs",
-        r'\bchiefs?\b': "Chiefs",
-        r'\beagles?\b': "Eagles",
-        r'\bgiants?\b': "Giants",
-        r'\brams?\b': "Rams",
-        r'\bsaints?\b': "Saints",
-        
-        # Positions with common variations
-        r'\bquarterbacks?\b': "quarterback",
-        r'\brunning backs?\b': "running back",
-        r'\bwide receivers?\b': "wide receiver",
-        r'\btight ends?\b': "tight end",
-        r'\blinebackers?\b': "linebacker",
-        r'\bcornerbacks?\b': "cornerback",
-        r'\bsafety\b': "safety",
-        r'\bsafeties\b': "safety",
-        
-        # Play terms
-        r'\btouchdowns?\b': "touchdown",
-        r'\bfield goals?\b': "field goal",
-        r'\binterceptions?\b': "interception",
-        r'\bfumbles?\b': "fumble",
-        r'\bsacks?\b': "sack",
-        r'\bpunt\b': "punt",
-        r'\bpunts?\b': "punt",
-        
-        # Numbers and yards
-        r'\byards?\b': "yard",
-        r'\byards? line\b': "yard line",
-        r'\byard lines?\b': "yard line"
-    }
-    
-    corrected = text
-    for pattern, replacement in fuzzy_corrections.items():
-        corrected = re.sub(pattern, replacement, corrected, flags=re.IGNORECASE)
-    
-    return corrected
 
-# === CLI ===
 if __name__ == "__main__":
-    import sys
-    clip_path = sys.argv[1] if len(sys.argv) > 1 else "segments/segment_000.mov"
-
-    # Video classification + classification.json
-    preds = predict_clip(clip_path)
-    with open("classification.json", "w") as f:
-        json.dump({os.path.basename(clip_path): preds}, f, indent=2)
-    print("\nTop-5 labels for", clip_path)
-    for label, score in preds:
-        print(f"{label:>30s} : {score:.3f}")
-
-    # Audio transcription + transcripts.json
-    transcript = transcribe_clip(clip_path)
-    print(f"Transcript for {clip_path}: {transcript}")
-    with open("transcripts.json", "w") as f:
-        json.dump({os.path.basename(clip_path): transcript}, f, indent=2)
-    print("Wrote transcripts.json")
-
+    main()

run_all_clips.py

@@ -1,23 +1,56 @@
 #!/usr/bin/env python3
 """
-Loop over all .mov/.mp4 files in the `data/` directory, call `predict_clip` and `transcribe_clip` 
-from inference.py on each, print the results, and save both classification and transcription 
-results to separate JSON files as they're generated.
+NFL Play Detection Pipeline - Optimized for continuous processing.
+
+This script orchestrates the complete NFL play detection workflow:
+1. Video classification using X3D models (Phase 1)
+2. NFL-specific play state analysis and boundary detection
+3. Audio transcription using Whisper with NFL enhancements (Phase 2)
+
+The pipeline is optimized for continuous processing with separate phases,
+allowing for flexible deployment scenarios (real-time, batch, testing).
 """
+
 import os
 import glob
 import json
 import argparse
 import time
-from inference import predict_clip, transcribe_clip, detect_play_boundaries, analyze_play_state
+from typing import Dict, List, Any, Optional
 
+# Import from new modular structure
+from video import predict_clip, analyze_play_state, detect_play_boundaries
+from audio import transcribe_clip
+from config import (
+    SUPPORTED_VIDEO_FORMATS, DEFAULT_CLASSIFICATION_FILE, DEFAULT_TRANSCRIPT_FILE,
+    DEFAULT_PLAY_ANALYSIS_FILE, VIDEO_SAVE_INTERVAL, AUDIO_SAVE_INTERVAL
+)
 
-def main(input_dir: str = "data", classification_file: str = "classification.json", transcript_file: str = "transcripts.json", play_analysis_file: str = "play_analysis.json", skip_audio: bool = False, max_clips: int = None):
-    # find video files
-    patterns = ["*.mov", "*.mp4"]
+
+def main(input_dir: str = "data", 
+         classification_file: str = DEFAULT_CLASSIFICATION_FILE, 
+         transcript_file: str = DEFAULT_TRANSCRIPT_FILE, 
+         play_analysis_file: str = DEFAULT_PLAY_ANALYSIS_FILE, 
+         skip_audio: bool = False, 
+         max_clips: Optional[int] = None) -> Dict[str, Any]:
+    """
+    Main processing function for NFL play detection pipeline.
+    
+    Args:
+        input_dir: Directory containing video clips
+        classification_file: Output file for video classifications
+        transcript_file: Output file for audio transcriptions
+        play_analysis_file: Output file for play analysis results
+        skip_audio: If True, skip audio transcription (Phase 2)
+        max_clips: Limit processing to first N clips (for testing)
+        
+    Returns:
+        Dictionary with processing statistics and results
+    """
+    # Find video files using supported formats
     clips = []
-    for pat in patterns:
-        clips.extend(glob.glob(os.path.join(input_dir, pat)))
+    for pattern in SUPPORTED_VIDEO_FORMATS:
+        clips.extend(glob.glob(os.path.join(input_dir, pattern)))
     clips = sorted(clips)
     if not clips:
         print(f"No clips found in '{input_dir}'.")
@@ -86,8 +119,8 @@ def main(input_dir: str = "data", classification_file: str = "classification.jso
         else:
             print(f"  [WARN] No classification scores (skipped or error)")
 
-        # Write incremental results after every 5 clips or at the end
-        if i % 5 == 0 or i == len(clips):
+        # Write incremental results after every N clips or at the end
+        if i % VIDEO_SAVE_INTERVAL == 0 or i == len(clips):
             try:
                 with open(classification_file, 'w') as f:
                     json.dump(classification_results, f, indent=2)
@@ -169,8 +202,8 @@ def main(input_dir: str = "data", classification_file: str = "classification.jso
                 print(f"  [ERROR] Failed to transcribe: {e}")
                 transcript_results[clip_name] = ""
 
-            # Write incremental results after every 3 clips or at the end
-            if i % 3 == 0 or i == len(clips):
+            # Write incremental results after every N clips or at the end
+            if i % AUDIO_SAVE_INTERVAL == 0 or i == len(clips):
                 try:
                     with open(transcript_file, 'w') as f:
                         json.dump(transcript_results, f, indent=2)
@@ -213,9 +246,9 @@ if __name__ == "__main__":
     parser.add_argument('--video-only', action='store_true', help='Process only video classification (85%% faster)')
     parser.add_argument('--audio-only', action='store_true', help='Process only audio transcription (requires existing classification.json)')
     parser.add_argument('--max-clips', type=int, help='Limit processing to first N clips (for testing)')
-    parser.add_argument('--classification-file', default='classification.json', help='Video classification output file')
-    parser.add_argument('--transcript-file', default='transcripts.json', help='Audio transcript output file')
-    parser.add_argument('--play-analysis-file', default='play_analysis.json', help='Play analysis output file')
+    parser.add_argument('--classification-file', default=DEFAULT_CLASSIFICATION_FILE, help='Video classification output file')
+    parser.add_argument('--transcript-file', default=DEFAULT_TRANSCRIPT_FILE, help='Audio transcript output file')
+    parser.add_argument('--play-analysis-file', default=DEFAULT_PLAY_ANALYSIS_FILE, help='Play analysis output file')
     
     args = parser.parse_args()
     

transcripts.json

@@ -1,3 +1,79 @@
 {
-  "segment_001.mov": "I can tell you that Lamar Jackson right now is"
+  "segment_001.mov": "I can tell you that Lamar Jackson right now is",
+  "segment_002.mov": "is the sixth best quarterback in the NFL.",
+  "segment_003.mov": "Well and that's just pure",
+  "segment_004.mov": "It's totally based off of passing, right.",
+  "segment_005.mov": "You got to consider what he is.",
+  "segment_006.mov": "two time MVP that uses his",
+  "segment_007.mov": "legs as well as he uses his arm.",
+  "segment_008.mov": "They found a great combination.",
+  "segment_009.mov": "with him Derek Henry but.",
+  "segment_010.mov": "If they're going to stack the box, if the Bengals feel",
+  "segment_011.mov": "I feel like they're going to have to put eight in the box all day.",
+  "segment_012.mov": "to stop this run game. Don't be surprised.",
+  "segment_013.mov": "that Lamar has a big day through the.",
+  "segment_014.mov": "here.",
+  "segment_015.mov": "will be the I for",
+  "segment_016.mov": "Now they switch. That was about six hundred.",
+  "segment_017.mov": "pounds of running",
+  "segment_018.mov": "That very motion is flower",
+  "segment_019.mov": "It goes to flowers.",
+  "segment_020.mov": "brought by likely and a block",
+  "segment_021.mov": "Back by Kohler and out of bounds goes.",
+  "segment_022.mov": "flowers with a jet swing.",
+  "segment_023.mov": "and on the play picks up nine",
+  "segment_024.mov": "9 to the 39.",
+  "segment_025.mov": "on that offensive line.",
+  "segment_026.mov": "Donnie Stanley has been terrific at the left.",
+  "segment_027.mov": "tackle. He's healthy. He really has been.",
+  "segment_028.mov": "There's been some shuffling at the guards as you see that.",
+  "segment_029.mov": "He moved around in the rookie.",
+  "segment_030.mov": "We're on the side. Patrick Ricard.",
+  "segment_031.mov": "He gets overlooked a lot.",
+  "segment_032.mov": "But he does everything for this team.",
+  "segment_033.mov": "He's he's basically like an extra line.",
+  "segment_034.mov": "extra tight end out there leading the",
+  "segment_035.mov": "holes for this run game and a great job.",
+  "segment_036.mov": "with Todd Monkin last week striking a rough",
+  "segment_037.mov": "The defensive coordinator second down one.",
+  "segment_038.mov": "Down with the dives",
+  "segment_039.mov": "Very good.",
+  "segment_040.mov": "And a gain of four is.",
+  "segment_041.mov": "He's out to the 43.",
+  "segment_042.mov": "And a first down.",
+  "segment_043.mov": "Here's a look at Von Bell who makes that stuff.",
+  "segment_044.mov": "and on that defensive line.",
+  "segment_045.mov": "They get back Chris Jenkins",
+  "segment_046.mov": "and Hill. Hendrickson is healthy.",
+  "segment_047.mov": "and covered on the other side.",
+  "segment_048.mov": "The defense has been picked up.",
+  "segment_049.mov": "on some this year but they are getting healthy as you.",
+  "segment_050.mov": "So they get back McKinley Jackson today.",
+  "segment_051.mov": "He'll be right back, Myles Murphy, BJ Hill missed the last.",
+  "segment_052.mov": "couple of games it's important to.",
+  "segment_053.mov": "to have those guys up front. Henry.",
+  "segment_054.mov": "Trying to follow a block.",
+  "segment_055.mov": "Nice tackle made by Hubbard.",
+  "segment_056.mov": "with the forty five and a gain of two.",
+  "segment_057.mov": "It'll be second down and eight.",
+  "segment_058.mov": "Well, it's going to be important all day long.",
+  "segment_059.mov": "strong to tackle low you've got to be able.",
+  "segment_060.mov": "to take the legs out of Derrick",
+  "segment_061.mov": "for Kenry if you go up too high you know.",
+  "segment_062.mov": "that stiff arm and gets in the open field to score.",
+  "segment_063.mov": "speed so excellent job there.",
+  "segment_064.mov": "by Hill and Hubbard to bring him down.",
+  "segment_065.mov": "Thank you.",
+  "segment_066.mov": "Max Hill with the hit. Mike Hilton is out.",
+  "segment_067.mov": "today knee injury didn't practice",
+  "segment_068.mov": "this all week.",
+  "segment_069.mov": "A second year defensive backup",
+  "segment_070.mov": "Michigan taking his place.",
+  "segment_071.mov": "In the first possession of the game",
+  "segment_072.mov": "second down and eight",
+  "segment_073.mov": "That record is on the move.",
+  "segment_074.mov": "Jackson to the air.",
+  "segment_075.mov": "swings it up field",
+  "segment_076.mov": "Miller makes the grab.",
+  "segment_077.mov": ""
 }

video.py

@@ -0,0 +1,398 @@
+"""
+Video Classification and NFL Play Analysis Module.
+
+This module handles:
+1. X3D-based video classification using Kinetics-400 pretrained models
+2. NFL-specific play state analysis (play_active, play_action, non_play)
+3. Play boundary detection across video sequences
+4. Video preprocessing and frame extraction
+
+Key Components:
+- VideoClassifier: Main class for video classification
+- PlayAnalyzer: NFL-specific play state detection
+- BoundaryDetector: Sequence analysis for play start/end detection
+"""
+
+import os
+import json
+import urllib.request
+from typing import List, Tuple, Optional, Dict, Any
+
+import torch
+import numpy as np
+from pytorchvideo.data.encoded_video import EncodedVideo
+
+from config import (
+    VIDEO_MODEL_NAME, DEVICE, VIDEO_CLIP_DURATION, VIDEO_NUM_SAMPLES, VIDEO_SIZE,
+    KINETICS_LABELS_URL, KINETICS_LABELS_PATH, VIDEO_MEAN, VIDEO_STD,
+    PLAY_CONFIDENCE_THRESHOLD, PLAY_BOUNDARY_WINDOW_SIZE,
+    PLAY_START_INDICATORS, PLAY_ACTION_INDICATORS, NON_PLAY_INDICATORS,
+    ENABLE_DEBUG_PRINTS, ENABLE_FRAME_SHAPE_DEBUG
+)
+
+
+class VideoClassifier:
+    """
+    X3D-based video classifier for action recognition.
+    
+    Uses PyTorchVideo's pretrained X3D models trained on Kinetics-400 dataset.
+    Supports multiple model sizes (xs, s, m, l) with different speed/accuracy tradeoffs.
+    """
+    
+    def __init__(self, model_name: str = VIDEO_MODEL_NAME, device: torch.device = DEVICE):
+        """
+        Initialize the video classifier.
+        
+        Args:
+            model_name: X3D model variant (x3d_xs, x3d_s, x3d_m, x3d_l)
+            device: PyTorch device for inference
+        """
+        self.model_name = model_name
+        self.device = device
+        self.model = None
+        self.labels = None
+        
+        # Initialize model and labels
+        self._load_model()
+        self._load_kinetics_labels()
+    
+    def _load_model(self) -> None:
+        """Load and prepare the X3D model for inference."""
+        if ENABLE_DEBUG_PRINTS:
+            print(f"Loading X3D model: {self.model_name}")
+        
+        self.model = torch.hub.load(
+            "facebookresearch/pytorchvideo",
+            self.model_name,
+            pretrained=True
+        ).to(self.device).eval()
+        
+        if ENABLE_DEBUG_PRINTS:
+            print(f"Model loaded successfully on {self.device}")
+    
+    def _load_kinetics_labels(self) -> None:
+        """Download and load Kinetics-400 class labels."""
+        # Download labels if not present
+        if not os.path.exists(KINETICS_LABELS_PATH):
+            if ENABLE_DEBUG_PRINTS:
+                print("Downloading Kinetics-400 labels...")
+            urllib.request.urlretrieve(KINETICS_LABELS_URL, KINETICS_LABELS_PATH)
+        
+        # Load and parse labels
+        with open(KINETICS_LABELS_PATH, "r") as f:
+            raw_labels = json.load(f)
+        
+        # Handle different label formats
+        if isinstance(raw_labels, list):
+            self.labels = {i: raw_labels[i] for i in range(len(raw_labels))}
+        elif isinstance(raw_labels, dict):
+            # Check if keys are numeric strings
+            if all(k.isdigit() for k in raw_labels.keys()):
+                self.labels = {int(k): v for k, v in raw_labels.items()}
+            else:
+                # Assume values are indices, invert the mapping
+                self.labels = {}
+                for k, v in raw_labels.items():
+                    try:
+                        self.labels[int(v)] = k
+                    except (ValueError, TypeError):
+                        continue
+        else:
+            raise ValueError(f"Unexpected label format in {KINETICS_LABELS_PATH}")
+        
+        if ENABLE_DEBUG_PRINTS:
+            print(f"Loaded {len(self.labels)} Kinetics-400 labels")
+    
+    def preprocess_video(self, frames: torch.Tensor, 
+                        num_samples: int = VIDEO_NUM_SAMPLES,
+                        size: int = VIDEO_SIZE) -> torch.Tensor:
+        """
+        Preprocess video frames for X3D model input.
+        
+        Args:
+            frames: Video tensor of shape (C, T, H, W)
+            num_samples: Number of frames to sample
+            size: Spatial size for center crop
+            
+        Returns:
+            Preprocessed tensor ready for model input
+        """
+        C, T, H, W = frames.shape
+        
+        # Convert to float and normalize to [0, 1]
+        video = frames.permute(1, 0, 2, 3).float() / 255.0
+        
+        # Temporal sampling - uniformly sample frames
+        indices = torch.linspace(0, T - 1, num_samples).long()
+        clip = video[indices]
+        
+        # Spatial center crop
+        top = max((H - size) // 2, 0)
+        left = max((W - size) // 2, 0)
+        clip = clip[:, :, top:top+size, left:left+size]
+        
+        # Rearrange dimensions and add batch dimension: (N, C, T, H, W)
+        clip = clip.permute(1, 0, 2, 3).unsqueeze(0)
+        
+        # Apply ImageNet normalization
+        mean = torch.tensor(VIDEO_MEAN, device=self.device).view(1, 3, 1, 1, 1)
+        std = torch.tensor(VIDEO_STD, device=self.device).view(1, 3, 1, 1, 1)
+        clip = (clip - mean) / std
+        
+        return clip
+    
+    def classify_clip(self, video_path: str, top_k: int = 5) -> List[Tuple[str, float]]:
+        """
+        Classify a single video clip and return top-k predictions.
+        
+        Args:
+            video_path: Path to video file
+            top_k: Number of top predictions to return
+            
+        Returns:
+            List of (label, confidence) tuples sorted by confidence
+        """
+        try:
+            # Load video
+            video = EncodedVideo.from_path(video_path)
+            clip_data = video.get_clip(0, VIDEO_CLIP_DURATION)
+            frames = clip_data["video"]
+            
+            if frames is None:
+                if ENABLE_DEBUG_PRINTS:
+                    print(f"[ERROR] Failed to load video frames from {video_path}")
+                return []
+            
+            if ENABLE_FRAME_SHAPE_DEBUG:
+                print(f"[DEBUG] Loaded video frames shape: {frames.shape}")
+            
+            # Preprocess and run inference
+            input_tensor = self.preprocess_video(frames).to(self.device)
+            
+            with torch.no_grad():
+                logits = self.model(input_tensor)
+                probabilities = torch.softmax(logits, dim=1)[0]
+            
+            # Get top-k predictions
+            top_k_probs, top_k_indices = torch.topk(probabilities, k=top_k)
+            
+            results = []
+            for idx_tensor, prob in zip(top_k_indices, top_k_probs):
+                idx = idx_tensor.item()
+                label = self.labels.get(idx, f"Class_{idx}")
+                results.append((label, float(prob)))
+            
+            return results
+            
+        except Exception as e:
+            if ENABLE_DEBUG_PRINTS:
+                print(f"[ERROR] Failed to process {video_path}: {e}")
+            return []
+
+
+class PlayAnalyzer:
+    """
+    NFL-specific play state analyzer.
+    
+    Analyzes video classification results to determine:
+    - play_active: Active football plays (passing, kicking)
+    - play_action: Football-related actions (catching, throwing) 
+    - non_play: Non-game activities (applauding, commentary)
+    - unknown: Low confidence or ambiguous clips
+    """
+    
+    def __init__(self, confidence_threshold: float = PLAY_CONFIDENCE_THRESHOLD):
+        """
+        Initialize play analyzer.
+        
+        Args:
+            confidence_threshold: Minimum confidence for state classification
+        """
+        self.confidence_threshold = confidence_threshold
+        self.play_start_indicators = PLAY_START_INDICATORS
+        self.play_action_indicators = PLAY_ACTION_INDICATORS  
+        self.non_play_indicators = NON_PLAY_INDICATORS
+    
+    def analyze_play_state(self, predictions: List[Tuple[str, float]]) -> Tuple[str, float]:
+        """
+        Analyze video classification predictions to determine play state.
+        
+        Args:
+            predictions: List of (label, confidence) tuples from video classifier
+            
+        Returns:
+            Tuple of (play_state, confidence_score)
+        """
+        if not predictions:
+            return "unknown", 0.0
+        
+        # Calculate weighted scores for each play state
+        play_start_score = 0.0
+        play_action_score = 0.0
+        non_play_score = 0.0
+        
+        for label, confidence in predictions:
+            # Clean label for matching
+            clean_label = label.replace('"', '').lower()
+            
+            # Check against different indicator categories
+            if self._matches_indicators(clean_label, self.play_start_indicators):
+                play_start_score += confidence * 2.0  # Weight play-specific actions higher
+            elif self._matches_indicators(clean_label, self.play_action_indicators):
+                play_action_score += confidence
+            elif self._matches_indicators(clean_label, self.non_play_indicators):
+                non_play_score += confidence
+        
+        # Determine final play state
+        max_score = max(play_start_score, play_action_score, non_play_score)
+        
+        if max_score < self.confidence_threshold:
+            return "unknown", max_score
+        elif play_start_score == max_score:
+            return "play_active", play_start_score
+        elif play_action_score == max_score:
+            return "play_action", play_action_score
+        else:
+            return "non_play", non_play_score
+    
+    def _matches_indicators(self, label: str, indicators: List[str]) -> bool:
+        """Check if label matches any indicator in the list."""
+        return any(indicator.lower() in label for indicator in indicators)
+
+
+class BoundaryDetector:
+    """
+    Play boundary detection for video sequences.
+    
+    Analyzes sequences of play states to detect:
+    - Play start points (non_play -> play_active transitions)
+    - Play end points (play_active -> non_play transitions)
+    """
+    
+    def __init__(self, window_size: int = PLAY_BOUNDARY_WINDOW_SIZE):
+        """
+        Initialize boundary detector.
+        
+        Args:
+            window_size: Window size for sequence analysis
+        """
+        self.window_size = window_size
+        self.play_analyzer = PlayAnalyzer()
+    
+    def detect_boundaries(self, clip_results: List[List[Tuple[str, float]]]) -> List[Tuple[str, int, float]]:
+        """
+        Detect play boundaries across a sequence of video clips.
+        
+        Args:
+            clip_results: List of classification results for each clip
+            
+        Returns:
+            List of (boundary_type, clip_index, confidence) tuples
+        """
+        if len(clip_results) < self.window_size:
+            return []
+        
+        # Analyze play state for each clip
+        play_states = []
+        for results in clip_results:
+            state, confidence = self.play_analyzer.analyze_play_state(results)
+            play_states.append((state, confidence))
+        
+        boundaries = []
+        
+        # Look for state transitions
+        for i in range(len(play_states) - 1):
+            current_state, current_conf = play_states[i]
+            next_state, next_conf = play_states[i + 1]
+            
+            # Detect play start: non_play/unknown -> play_active/play_action
+            if (current_state in ["non_play", "unknown"] and 
+                next_state in ["play_active", "play_action"] and
+                next_conf > self.play_analyzer.confidence_threshold):
+                boundaries.append(("play_start", i + 1, next_conf))
+            
+            # Detect play end: play_active/play_action -> non_play/unknown
+            if (current_state in ["play_active", "play_action"] and
+                next_state in ["non_play", "unknown"] and
+                current_conf > self.play_analyzer.confidence_threshold):
+                boundaries.append(("play_end", i, current_conf))
+        
+        return boundaries
+
+
+# ============================================================================
+# CONVENIENCE FUNCTIONS FOR BACKWARD COMPATIBILITY
+# ============================================================================
+
+# Global instances for backward compatibility
+_video_classifier = None
+_play_analyzer = None
+_boundary_detector = None
+
+def get_video_classifier() -> VideoClassifier:
+    """Get global video classifier instance (lazy initialization)."""
+    global _video_classifier
+    if _video_classifier is None:
+        _video_classifier = VideoClassifier()
+    return _video_classifier
+
+def get_play_analyzer() -> PlayAnalyzer:
+    """Get global play analyzer instance (lazy initialization)."""
+    global _play_analyzer
+    if _play_analyzer is None:
+        _play_analyzer = PlayAnalyzer()
+    return _play_analyzer
+
+def get_boundary_detector() -> BoundaryDetector:
+    """Get global boundary detector instance (lazy initialization)."""
+    global _boundary_detector
+    if _boundary_detector is None:
+        _boundary_detector = BoundaryDetector()
+    return _boundary_detector
+
+def predict_clip(path: str) -> List[Tuple[str, float]]:
+    """
+    Backward compatibility function for video classification.
+    
+    Args:
+        path: Path to video file
+        
+    Returns:
+        List of (label, confidence) tuples
+    """
+    classifier = get_video_classifier()
+    results = classifier.classify_clip(path)
+    
+    # Print play state analysis for compatibility
+    if results:
+        analyzer = get_play_analyzer()
+        play_state, confidence = analyzer.analyze_play_state(results)
+        print(f"[PLAY STATE] {play_state} (confidence: {confidence:.3f})")
+    
+    return results
+
+def analyze_play_state(predictions: List[Tuple[str, float]]) -> Tuple[str, float]:
+    """
+    Backward compatibility function for play state analysis.
+    
+    Args:
+        predictions: Classification results
+        
+    Returns:
+        Tuple of (play_state, confidence)
+    """
+    analyzer = get_play_analyzer()
+    return analyzer.analyze_play_state(predictions)
+
+def detect_play_boundaries(clip_results: List[List[Tuple[str, float]]]) -> List[Tuple[str, int, float]]:
+    """
+    Backward compatibility function for boundary detection.
+    
+    Args:
+        clip_results: List of classification results for each clip
+        
+    Returns:
+        List of boundary detections
+    """
+    detector = get_boundary_detector()
+    return detector.detect_boundaries(clip_results)