AI-powered sports statistics: automate analytics from video

How AI helps automate sports statistics?

Manual tagging of sports statistics is a bottleneck for clubs and studios. Each match requires 8–12 hours of video analyst work, and professional system licenses (e.g., Hawk-Eye) cost tens of thousands of dollars. We develop AI systems that, from standard 2–4 camera video, deliver 80–90% accuracy of professional systems at a fraction of the cost — our solutions are multiple times cheaper. Typical manual tagging errors: missed episodes, subjective possession assessment, distance discrepancy up to 15%. AI avoids these issues: it processes every frame, pinpointing coordinates of all players and the ball. Below — technical details: how we compute metrics and build turnkey solutions.

How AI calculates distance and speed?

For distance, speed, and heatmap calculations we use player tracking from YOLOv8 + ByteTrack. The SportsStatisticsEngine class aggregates per-player data in real time.

import numpy as np
from collections import defaultdict
from dataclasses import dataclass, field
from typing import Optional

@dataclass
class PlayerStats:
    player_id: int
    team: str
    distance_m: float = 0.0
    sprint_count: int = 0      # sprints > 25 km/h
    max_speed_kmh: float = 0.0
    touches: int = 0
    shots: int = 0
    passes_attempted: int = 0
    passes_completed: int = 0
    heatmap: np.ndarray = field(default_factory=lambda: np.zeros((68, 105)))

class SportsStatisticsEngine:
    def __init__(self, fps: float, sport: str = 'football'):
        self.fps = fps
        self.sport = sport
        self.player_stats: dict[int, PlayerStats] = {}
        self.possession_log = []  # (frame_idx, team_with_ball)
        self.event_log = []

        # Speed thresholds (m/frame → km/h)
        self.sprint_threshold = 25 / 3.6 / fps  # m/frame
        self.jogging_threshold = 11 / 3.6 / fps

    def update(self, frame_idx: int, tracked_players: list,
                ball_pos: Optional[tuple]):
        for player in tracked_players:
            pid = player['track_id']
            team = player.get('team', 'unknown')
            pos = player.get('field_pos')

            if pid not in self.player_stats:
                self.player_stats[pid] = PlayerStats(
                    player_id=pid, team=team
                )

            stats = self.player_stats[pid]

            # Distance and speed
            if hasattr(stats, '_prev_pos') and stats._prev_pos and pos:
                dist = np.sqrt((pos[0]-stats._prev_pos[0])**2 +
                                (pos[1]-stats._prev_pos[1])**2)
                stats.distance_m += dist

                # Speed in km/h
                speed_ms = dist * fps
                speed_kmh = speed_ms * 3.6

                if speed_kmh > stats.max_speed_kmh:
                    stats.max_speed_kmh = speed_kmh

                if speed_kmh > 25:
                    stats.sprint_count += 1

            stats._prev_pos = pos

            # Heatmap
            if pos:
                hm_x = int(np.clip(pos[0], 0, 104))
                hm_y = int(np.clip(pos[1], 0, 67))
                stats.heatmap[hm_y, hm_x] += 1

        # Ball possession
        if ball_pos:
            possessing_team = self._determine_possession(
                ball_pos, tracked_players
            )
            self.possession_log.append((frame_idx, possessing_team))

    def _determine_possession(self, ball_pos: tuple,
                                players: list) -> Optional[str]:
        """Closest player to ball = in possession"""
        if not players or not ball_pos:
            return None

        min_dist = float('inf')
        possessing_team = None

        for player in players:
            pos = player.get('field_pos')
            if pos is None:
                continue
            dist = np.sqrt((ball_pos[0]-pos[0])**2 + (ball_pos[1]-pos[1])**2)
            if dist < min_dist:
                min_dist = dist
                possessing_team = player.get('team')

        # Player within 2m = in possession
        return possessing_team if min_dist < 2.0 else None

    def compute_possession_stats(self) -> dict:
        total = len(self.possession_log)
        if total == 0:
            return {'team_a': 50.0, 'team_b': 50.0}

        counts = defaultdict(int)
        for _, team in self.possession_log:
            if team:
                counts[team] += 1

        contested = total - sum(counts.values())
        return {
            team: round(count / total * 100, 1)
            for team, count in counts.items()
        }

    def generate_match_report(self) -> dict:
        report = {
            'possession': self.compute_possession_stats(),
            'players': {}
        }

        for pid, stats in self.player_stats.items():
            report['players'][pid] = {
                'team': stats.team,
                'distance_km': round(stats.distance_m / 1000, 2),
                'sprint_count': stats.sprint_count,
                'max_speed_kmh': round(stats.max_speed_kmh, 1),
                'shots': stats.shots,
                'passes_attempted': stats.passes_attempted,
                'pass_accuracy': (stats.passes_completed /
                                   max(stats.passes_attempted, 1) * 100)
            }

        return report

How AI determines ball possession?

The _determine_possession method computes the closest player to the ball on each frame. If the distance is under 2 meters, possession is recorded. This is simpler and faster than geometric methods and yields ±3–5% accuracy relative to Hawk-Eye.

Text reports

After numerical metrics, we generate analytical text via an LLM — e.g., Mistral 7B. The prompt is tuned to sports bulletin format. For implementation we use Hugging Face Transformers.

from transformers import pipeline

class MatchReportGenerator:
    def __init__(self):
        # GPT or local LLM for text report generation
        self.generator = pipeline('text-generation',
                                   model='mistralai/Mistral-7B-Instruct-v0.2',
                                   device=0)

    def generate_narrative(self, stats: dict, match_info: dict) -> str:
        prompt = f"""Generate a brief analytical match report.
        Match: {match_info['team_a']} vs {match_info['team_b']}
        Score: {match_info['score']}
        Possession: {stats['possession']}
        Top runners: {self._top_runners(stats['players'])}
        Shots on goal: {sum(p['shots'] for p in stats['players'].values())}

        Write a professional analytical text of 3-4 sentences."""

        result = self.generator(prompt, max_new_tokens=200,
                                 temperature=0.7, do_sample=True)
        return result[0]['generated_text'].split(prompt)[-1].strip()

Why AI statistics is more cost-effective than traditional solutions?

An AI system requires 5–10 times lower investment than a Hawk-Eye license and processes data faster than a human. We have delivered over 15 projects for football clubs and studios, and we guarantee at least 80% accuracy on key metrics. If results fall below, we retrain the model at no cost. AI statistics accuracy compared to professional systems:

For amateur and semi-professional competitions, this is sufficient. For professional leagues, additional cameras and calibration boost accuracy to acceptable levels.

In one project we deployed a system for a second-tier club: 4 IP cameras 1080p, a server with RTX 4060, training took 2 weeks. After implementation, match analysis time dropped from 10 hours to 30 minutes, and distance accuracy was 87% versus manual tagging. The club saved roughly tens of thousands of dollars per year on video analyst services.

How we guarantee accuracy?

We follow MLOps practices: model versioning via MLflow, A/B testing on real matches, data drift monitoring. Every client receives an accuracy report on their data. Our years of experience and over 15 completed projects let us tackle tasks of any complexity. We guarantee the final accuracy will not fall below the stated level — otherwise we refine the model for free.

Implementation process

1. Analytics — assess filming conditions, camera count, metric requirements.
2. Design — choose architecture (YOLO + ByteTrack + LLM), prepare data.
3. Training and calibration — fine-tune model for the specific stadium, annotate test episodes.
4. Integration — deploy API, dashboard, configure webhooks.
5. Testing — compare with manual tagging, optimize p99 latency.
6. Deployment — install on server or cloud, train operators.

At each stage we use MLOps practices: model versioning via MLflow, A/B testing, data drift monitoring. This allows quick adaptation to changes in filming conditions.

What's included in the project

• Trained detection and tracking model
• REST API for real-time statistics
• Dashboard (metric visualization, heatmaps, reports)
• Integration with existing infrastructure
• Operations and API documentation
• Operator training (2 hours); 3 months technical support

Estimated timelines

Get a consultation for your project — we will assess complexity and accuracy on your data. Order a pilot project and see results in 4 weeks.