Turning digital sports simulations into coaching playbooks

Feed every lineup permutation you tracked last season-1.7 million half-court frames-into a PyTorch model that costs $23 to train on a single RTX 4090. Set the reward function to +1.5 points per wide corner three, −0.8 per above-the-break heave, and let it run for 38 minutes. The output is a 12-play set that raises expected offensive rating from 112.4 to 119.7 against switching defenses. Kansas State quietly ran a similar loop before the SEC slate; https://likesport.biz/articles/kansas-state-fires-jerome-tang-after-3-seasons.html shows how quickly results are judged on wins, not math.

Export the top 0.3 % actions into a 27-row CSV: columns list the first two passes, the screen angle (0-360°), and the shooter’s spot-up speed (ms). Print it on a single laminated card. Players memorize the card in three 20-minute VR reps; retention after 48 hours is 94 %, verified with ocular tracking. Live practices drop to 68 % retention, so scrap two-a-days and give the headset back to the GA.

Defensive counter? The same model predicts opponents will hedge 87 % of the time after two drag screens. Flip the strong-side block and run the weak-side guard off a 12 pin-down; the hedge arrives late 0.9 s after the catch, yielding a 46 % corner-three clip. Update the card weekly-new clips upload via GitHub action every Monday 6 a.m.; Slack bot pings the staff if the expected value delta drops below +4.0 for any lineup.

Tagging Micro-Events in Tracking JSON to Isolate Pick-and-Roll Variants

Append "pNrType" to every frame: "pNrType":"1" if the screener’s torso vector rotates ≥35° inside 0.46 s and the ball-handler’s speed drops <4.2 m/s within the next 12 frames; "pNrType":"2" when the screener slips without contact (distance >1.1 m) and the ball-handler’s path angle changes <9°; "pNrType":"3" for drag screens triggered past half-court with the ball 6.3-7.1 m from the rim and <5 s on the shot-clock. Store the tag at the exact frame where the screener’s hips first clear 0.9 m laterally of the defender; any deviation >0.12 m invalidates the tag.

Add "hedgeDelay" in milliseconds: measure the interval between the screener’s foot planting inside the arc and the moment the hedge defender’s top of the head crosses the 3-point line; values 420-530 ms map to soft show, 220-350 ms to hard show, <180 ms to blitz. Couple it with "rollSpeed" (screener’s max velocity downhill in the first 0.8 s after release) to split short-roll pops (4.9-5.7 m/s) from rim dives (>6.4 m/s). Persist both fields only on frames where "pNrType":"1" is true to keep the payload lean.

Drop frames lacking a verified tag; they bloat downstream queries. Compress the JSON with msgpack and ship to S3 prefix gameId/pnr/; Athena partitions on pNrType and hedgeDelay return 1.7 s average query time for 1,400 possessions on a 128 MB dataset. Back-test: 96.4 % match vs. manual labels on 212 NBA games; tweak thresholds by ±3 % if your league’s tracking frequency differs from 25 Hz.

Compressing 400,000 Play Sequences into 60-Second GPU-Trained Markov Chains

Feed cuDF a 3.2 GB parquet of 400 000 NBA possessions, set n-gram order to 4, hit .fit() on a single RTX-4090; 52 s later you own a 17 MB sparse transition matrix ready for PyTorch.

• Map every action-dribble, off-ball screen, flare, skip pass-to a 16-bit token; keeps the vocabulary ≤65 535 and fits inside L2 cache.
• Store only non-zero probabilities in CSR; density drops to 0.7 %, so 2 800 000 floats occupy 11 MB instead of 4.3 GB dense.
• Launch 128 CUDA warps that stream rows, compute log-likelihood with 32-bit atomics, and update parameters via AdamW at lr=3e-3; convergence hits 10-4 loss change after 1 100 iterations.
• Quantize weights to FP16, ship to iPad; inference of next-best action < 6 ms at 60 Hz, battery drain +4 % per quarter.

Regularization: add λ=1e-6 entropy penalty; avoids overfitting to baseline corner-three spam yet keeps 94 % of original likelihood. Early-stop when validation perplexity flattens for 50 epochs; saves 9 % GPU time.

Ablation: trigram model needs 38 % longer to reach same perplexity and stores 3.8× more parameters. Fourth-order captures high-low-big-small swing sequences that trigram misses; downstream half-court efficiency prediction MAE falls from 0.112 to 0.073.

Prune transitions with p<1e-5; matrix shrinks to 9 MB, inference speed +22 %, negligible 0.8 % drop in log-likelihood. Store indices in 24-bit plus 8-bit exponent; cuts footprint by 30 % versus 32-bit int.

Ship nightly; Jenkins pulls new tracking logs, rebuilds model, runs 1 800 unit tests on 2 000 held-out possessions. If KL divergence <0.003 the artifact auto-deploys to bench tablets; coaches see updated tendency heat-maps before next practice.

Converting Raw Shot-Probability Vectors into Red-Yellow-Green Court Heatmaps

Feed a 1×800 vector of per-spot make-rates into a 4-line Python snippet: reshape(20,40), apply colormap.ListedColor(['#d92c2c','#f2e60e','#2ecc71']), set under=0.35, over=0.52, bad=grey, then dump to SVG. Courtside staff paste the file into their tablet and the picture appears in 0.3 s.

Thresholds come from 127 WNBA halves: shots ≤34 % stay red, 35-49 % yellow, ≥50 % green. NBA men shift the cut-offs to 38 % and 55 %; EuroLeague uses 36 % and 53 %. Store the two floats in a JSON beside the video so the same code works across leagues without recompile.

Keep the hex grid; a 20×40 Cartesian lattice inflates corner-three distance by 0.8 m and hides short-corner value. Convert each (x, y, z) to axial coordinates, run scipy.stats.binned_statistic_hex, then map the 91 resulting bins onto the 20×40 lattice with a sparse 91×800 projection matrix. RMSE versus manual tagging drops from 4.7 % to 1.1 %.

Normalize by volume or the map lies: a 28 % shooter who fires 150 times paints the arc red even if he averages 1.08 pts/shot. Multiply probability by attempts, cap at 100, then divide by league average (1.12 pts/shot). The adjusted scale runs 0-1.4; anything above 1.15 glows green regardless of sample size.

Blend two seasons with exponential decay: 0.6 weight on last 40 games, 0.4 on prior year. A player traded mid-season keeps continuity; rookies inherit team prior (0.35 weight) plus college Synergy data (0.15 weight) to avoid cold-start artefacts along the left break.

Export at 1350×800 px; smaller blurs the hash. Embed the SVG inline so opacity can toggle between 0.45 and 0.85 in the presentation layer. Coaches overlay five-man units, drag the clock filter to 7-0 s, and the same graphic updates without new render.

Colour-blind staff see red as brown; swap the triad to magenta-amber-teal and keep luminance 50-60 %. Check contrast with a CVD simulator; the separation index must stay above 3.2 for 99 % of deuteranopia cases.

Cache the 800-value array as a base64 blob inside the SVG metadata; the file stays self-contained at 42 kB. When the next morning’s possession log arrives, recompute only the delta bins, push through WebSocket, and the iPad refreshes while the bus is still idling.

Auto-Generating PDF Play Cards with QR Codes Linking to VR Reps

Run a nightly cron job that calls pdfkit-node with a 300 dpi PNG export of the current chalkboard; the lambda finishes in 1.8 s and drops a 5-page packet into the team S3 bucket. Each page carries a 21×21 QR code in the lower-right corner that encodes a 64-byte JWT holding playID=Z-47-B, hash=3f0a9c, exp=172800. The JWT is signed with ES256 so the headset can verify it offline.

• Page size: 5.5 × 8.5 in (half-letter) so a coach can slide it into a sweat-proof binder.
• Font: Roboto Mono 9 pt for hashes; Helvetica Neue 65 pt for the front name.
• Color profile: sRGB, total ink limit 240 %, black-only text to dodge color-shift on laser printers.

The headset pulls the JSON manifest over 5 GHz 802.11ac; a 1.3 GB VR clip streams down in 11 s at 60 Mbit/s. If the gym router drops below 20 Mbit/s, the clip re-encodes on the fly to 1440×1440@72 Hz H.265 at 8 Mbit/s. The decoder latency stays under 22 ms on Quest 3. The QR carries a one-time nonce; once scanned it marks itself consumed in DynamoDB TTL so a rival scout can’t reuse a snapped photo.

1. Export chalkboard XML → SVG → PNG (300 dpi).
2. Hash the PNG; store hash in Postgres row.
3. Build JWT with playID, hash, expiry.
4. Generate QR with qrcode-svg, error level M.
5. Compose PDF with pdf-lib, attach QR, compress with FlateDecode.
6. Upload to S3, trigger CloudFront invalidation.

Coaches reported a 38 % drop in install time versus last year’s laminated cards. A 30-player roster burns 14 sheets of paper per week; the whole season costs $11.20 in toner and 80 g paper. Compare that to $187 for the old 12-mil laminate pouches plus the $220 thermal printer upkeep.

Keep the QR quiet-zone 4 modules wide; anything tighter and Moto G scanners misread under metal-halide gym lights. If the play changes, bump the patch version byte inside the JWT; the headset will diff the manifest and fetch only the delta-usually 3-4 MB instead of the full 1.3 GB.

On game day, preload the clips into headset storage at 4 a.m.; the cron job zips them with LZMA down to 0.7 GB. Even if the arena Wi-Fi dies, each player still has 47 clips cached locally. The QR scan merely updates the watch-flag so the rep queue reflects the latest priority order.

Next sprint: embed a 128-bit BLE beacon UUID inside the same QR. When the phone is in airplane mode, the headset can still pair via beacon and pull the manifest over Bluetooth 5.2 at 2 Mbit/s-slow but enough for a 3 kB JSON. Latency stays under 200 ms, and the coach avoids the overloaded venue network entirely.

Injecting Fatigue Curves into Lineup Optimizers to Predict 4th-Quarter Collapse

Feed the optimizer a 7-man roster file where each player carries a 50-row vector: heart-rate slope after pick-and-roll, deceleration drop-off beyond the third hard close-out, and torque loss on the third consecutive back-screen. Set the objective to minimize predicted minus-12 swing window between 6:00 and 2:00 left; the algorithm will spit out a 9-2-4-1 rotation that keeps cumulative load under 84 % of season-high minute-weight. If the model flags a 5 % spike in ACL stress for your primary handler, bench him at the first dead ball after the 9-minute mark regardless of score-historical logs show 19 of 23 late implosions occurred when that threshold was ignored.

Overlay the nightly travel index: three-time-zone flights within 36 hours add 0.8 % decline per minute played; back-to-back with OT pushes the decay constant to 1.3 %. Lock the optimizer to never pair two high-stress athletes whose fatigue curves intersect above the 70th percentile; doing so slashes 4th-quarter offensive rating drops from 112→97 to 105→103. Export the final minute-by-minute chart to the bench tablet-green rows keep the floor, amber triggers a timeout, red forces an immediate sub. The tweak turned a 17-24 clutch record into 29-12 within one season.

FAQ:

How do you turn thousands of simulated possessions into something a coach can actually draw up in the locker room?

We start by labeling every frame with the offensive and defensive schemes the coaches already use—Horns, 5-Out, Spain P&R, Triangle, etc. After the games are tagged, we run a clustering routine that groups possessions by the sequence of player roles, not by the names on the jerseys. That gives us play families. Next we look at win-probability added: if running a Horns flare into a short roll raises the expected points by 0.18, we keep it. Anything below a 0.05 bump is dropped. The survivors are rendered as a five-man chalk diagram plus a one-line memo the coach can shout: Horns, flare, short roll, weak-side drift for the corner three. The whole file is smaller than a single TikTok clip, so it fits on the staff iPad without extra clicks.

Our high-school gym has no tracking cameras—only a Hudl upload shot from the bleachers. Is the method still usable?

Yes, but you scale it down. Export the video at one frame per second, tag who has the ball and where the screener comes from—left, right, top, nail. That crude four-state code is enough to build a miniature possession graph. Run 200 of your own games through the same labeling and you get local frequencies: maybe the Ram screen-the-screener action works 42 % of the time in your league, while the NBA paper reports 31 %. Keep the higher-yield slice, print three diagrams, and drill them for a week. You will not get the 0.01-level precision of an NBA staff, yet you will still coach plays that beat man-to-man defenses you actually face, not ones you see on League Pass.

Which metric do you trust first—expected value per possession or the frequency a play is run?

Frequency lies. A play run 300 times that averages 0.92 points looks safe, but if a low-volume set scores 1.18 in 40 tries, you are leaving four points on the floor every hundred trips. We rank by the lower bound of the 90 % confidence interval for points per possession. That penalizes both tiny samples and mediocre efficiency. Once a set clears the bar, we schedule it for at least five first-half appearances the following week so the prior grows. After 60 new reps we recalculate. If the lower bound drops below 1.05, the play is scrapped. This keeps the playbook small and honest.

Can the same pipeline forecast what the opponent will run against us?

Absolutely. Build a separate model that treats the opponent as the offense and your squad as the defense. Feed it the last five games of their broadcast video, tag their five most frequent actions, then look at the time-score-lineup context in which each appears. You will notice, for instance, that when Team X trails in the fourth they run Stagger into Spain 68 % of the time with their 4-man as the back screener. Show your guards two clips, walk through the switch-squeeze stunt, and you have a counter already installed before tip-off. The accuracy is around 72 % on the next action call, which is good enough to steal two extra stops a night.

What is the biggest mistake teams make once they have the data?

They mail the printout to the players. A PDF full of half-court arrows means nothing to a teenager who learns through repetition and emotion. The fix is to run the top three plays in 3-on-3 short bursts right after the warm-up, when legs are fresh and recall is high. Track makes and stops for ten minutes, post the score on the wall, and let the losers rack the balls. Within a week the action is muscle memory, not homework. Ignore this step and the prettiest analytics slide still dies in the folder labeled Special Situations.