GitHub - tomdoyo/open-command: Open-source command reports!

Let's Measure Command

OpenCommand measures command using the pitch location's distance from target.

This repo contains 2024/2025/2026 computer vision object detections and the full inference pipeline for producing target estimates and resulting command scores.

_{Tyler Rogers dots a backdoor sinker (TB @ TOR, 2026/05/13). Yellow box: broadcast strikezone detection. Thin white circle: catcher glove detection. Thick white circle: glove detection projected onto strikezone plane.}

Updates

2026-08-27: Version 1.2.0

• Inferred targets are now a 2 level hierarchical model fit by empirical Bayes: glove dependence (how much the target moves per inch of glove movement, 4 slopes xx, xz, zx, zz) plus an offset, both shrunk pitcher → league and pitch type → pitch type × handedness. The fixed pitcher × pitch type × season offset retires.
• Glove detections re-exported under one calibration pooled across the three seasons.

2026-08-21: Added 2024 season

2026-08-21: Version 1.1.0

• Targets are now chosen at the highest glove position in the pre-pitch window¹, discounted by how early it is**.

_{¹ Median of ±0.05s around this used to be targets}

How it Works

Summary

• See here for visuals!
• Estimate camera position with broadcast strikezone & ball detection
• Estimate camera zoom/pan/tilt with broadcast strikezone & camera position
• Estimate glove location with camera position/zoom/pan/tilt/roll & glove detection
• Estimate target with glove location
• Estimate command with target & actual location

Install

pip install -r requirements.txt          

Pipeline

Every script in src/ takes upstream CSVs and writes one output.
And they're standalone: python src/<script>.py [year=2026] ...
(This means you can work on a single stage by regenerating just that stage's file!)

raw/gloveball_tracks  raw/strikezone_tracking
     │       │              │
     │       └──────┬───────┘
     │              ▼                            
     │  1. solve_camera_pose.py ──► camera_poses.csv.gz
     │              │                            
     └──────┬───────┘                            
            ▼                                    
  2. solve_glove_locations.py ──► glove_locations/ 
            │                                    
            ▼                                    
  3. target_inference.py ──► targets.csv.gz
            │                                    
            ▼                                   
  4. opencommand.py  ──► command_scores.csv
                        (+ artifacts/validations_<year>.txt)

Step 1 is particularly heavy (hours); other steps take minutes.

In detail

See here for visuals!

1. Solving camera pose (every pitch)

• The CF camera is a fixed mount per game that pans/tilts/zooms per pitch.
• Estimate where the camera is:
  • Statcast's 9-parameter equation (xyz_0, xyz_velo, xyz_acc) gives us ball position in time (through pitch trajectory).
  • Broadcasts draw strikezone as (17in width, sz_top/sz_bot) at the front of the plate (middle for 2026).
  • These give us 12+ datapoints per pitch (8+ ball pixels, 4 box corners) to fit¹ 7 parameters: (Cx, Cy=400², Cz, pan, tilt, roll, f, t0).
  • Just keep the game median Cx/Cz³.
• Fit (pan, tilt, roll, f) separately with fixed (Cx, Cy, Cz).
  • Use the drawn strikezone at a snapshot pre-pitch⁴.
  • Don't use ball positions because camera often moves mid-ball flight.

_{¹ Levenberg-Marquardt on the pixel reprojection error, with a soft_l1 loss.
² Camera depth (Cy) is degenerate against focal length (f): moving camera back and zooming in produce nearly the same pixels. Not a big deal down the line so Cy is fixed at 400.
³ Others are nuisance parameters.
⁴ Snapshot is taken when glove is at the highest point in the [release-2.0s, release-0.3s] window.}

2. Solving glove location (every frame)

• glove_px/pz is a 2D projection of glove onto the camera.
• Use camera pose (Cx, Cy, Cz, pan, tilt, roll, f) to unproject detected glove_px/pz into global glove_xyz¹.

_{¹ Like Cy, glove depth (glove_y) is really hard to estimate. So we assume glove_y to be -1.75ft (median catch depth).}

3. Inferring target with glove locations

• Take the highest glove_xz in the [release-2.0s, release-0.3s] window, discounted by how early it is¹. This is the naive target.
• Some pitchers don't look at the glove, some adjust more than an inch per inch of glove movement. Fit 4 slopes (xx, xz, zx, zz) for how much the target moves per inch the glove moves. This is glove dependence.
• Many pitchers like to "start the pitch from the glove and let the ball break away from it". To account for this, add an offset.
• Both are a 2 level hierarchical model fit by empirical Bayes: each pitcher shrinks to the league, each pitch type shrinks to its pitch type × handedness distribution (a changeup lands about 4 inches below the pitcher's average, a four-seam 4 above), so a pitch type with 10 pitches gets a sane value instead of a 0 inch miss. Glove dependence + offset is the inferred target.
  • This assumes every pitcher is perfectly calibrated on a pitch type level.
• Use plausibility filter² to filter out extreme targets.

_{¹ This is mainly to avoid decoy targets, usually when the runner is on second base.
² (|x| over 20in, z outside the pitch-type floor/cap)}

4. Scoring command

• miss = distance from the actual location to target.
• For leaderboards, median miss is used, after plausible target filter.

Data

Download

The data lives on Hugging Face.

pip install huggingface_hub
hf download tomdoyo/open-command --repo-type dataset --local-dir data

To take one file instead of all of them:

hf download tomdoyo/open-command 2026/command_scores.csv --repo-type dataset --local-dir data

Layout

Each season lives under data/<year>/.

Keys: (game_pk, play_id) identify a pitch.

Raw detections (in data/<year>/raw/) are produced using YOLO11 glove/ball/strikezone detector models, with postprocessing based on detection confidence.

Coverage

OpenCommand tracks nearly all the pitches that it can, with most clips lost being due to no strikezone detected¹ and late center field camera cut².

For 2025: 90.00 / 93.17% possible

_{¹ Sometimes broadcasts don't draw a strikezone box on the screen
² Sometimes camera cuts to CF-cam (i.e. pitcher-batter view) too late}

Topics

Target maps

A nice feature of this is that you can tell where the pitcher was trying to throw, which is really hard just looking at the final location.

Command distribution

2025, naive median miss — min. 50 pitches

2025, inferred median miss — glove dependence + offset

Some correlations

2025 — 478 pitchers, min. 500 pitches

In particular, we can see a strong correlation between command and walk rates.

Why (mean) median miss?

• Median is more robust to extreme values (e.g. due to bad inferred targets/glove detections/etc.)
• Median (50th percentile) better answers "what's pitcher x's typical miss?". A pitcher can't miss by less than 0 in, but can spike one and get a 100 inch miss, which takes 100 pitches with 1 inch above mean miss to make up for it. So coloquially, median makes more sense as an "average".

How accurate is OpenCommand at measuring command?

• This is really hard to tell because there's no ground truth (unless we ask "hey where did you aim?" every pitch).
• True median miss for fastballs is probably 7 to 10 inches.
• Glove detections get post-hoc adjustments based on detection accuracies. This adjustment makes miss distances unbiased, but doesn't remove the pitch-level variance.
• Inferred miss assumes every pitcher perfectly calibrates his pitches, but most pitchers are probably an inch or two off. At the same time, most pitchers fine tune their targets (beyond the catcher's glove) every pitch, depending on the situation. Perhaps these two cancel off on a season-level.
• So, on a season-level, OpenCommand has a good chance of being accurate within <1 inch. On a pitch-level, certainly not.

License & citation

Everything in this repository, data and code, is released under CC BY-NC-SA 4.0: use it, build on it, publish with it, with attribution (cite OpenCommand; see CITATION.cff) and not commercially.

Data derived from MLB broadcast video and Statcast public feeds. MLB and Statcast are trademarks of MLB Advanced Media, L.P.; this project is not affiliated with MLB.