Loading video...

Video Failed to Load

Go Home

AI TENNIS ANALYSIS. A FULL COMPUTER VISION SYSTEM. BUILT ON YOLO, PYTORCH, AND KEYPOINT EXTRACTION. Take any tennis match broadcast, any camera angle, any resolution. Feed it into the pipeline. YOLO detects both players and the tennis ball frame by frame. No manual labeling, no pre-annotated dataset. A fine-tuned...

120,219 views • 2 months ago •via X (Twitter)

0 Comments

No comments available

Comments from the original post will appear here

Related Videos

7 repos that mass replace a $50,000/year sports analytics department. all free. all open source. -> replaces Hawkeye-level court analysis YOLO tracks players and ball from any broadcast. ResNet50 extracts court keypoints. homography converts pixels to real meters. speed, position, aggression - all from a TV feed. -> replaces paid sports data subscriptions ($500/mo) every ATP match since 1968. rankings, results, stats. 1.5K stars. the holy grail dataset that every tennis ML project is built on. -> replaces point-level data feeds ($200/mo) point-by-point data for every Grand Slam since 2011. the kind of granularity you need for live Bayesian models. -> replaces shot-by-shot scouting reports 5,000+ matches charted shot by shot. direction, depth, error type. crowdsourced and free. -> replaces pre-match and in-match prediction services ELO + serve/return stats → win probability. updates during the match. exactly what a live Bayesian engine needs. -> replaces ball trajectory prediction tools CV analysis + CatBoost bounce prediction + separate court detector neural net. most advanced open-source tennis CV pipeline. -> replaces traditional bookmaker APIs Polymarket CLOB API. real-time share prices, orderbook depth, bid/ask spreads. no margin, no bookmaker - just the crowd. trade positions mid-match, not just pre-match. total before: $50K/year sports analytics stack total now: $0 like + bookmark you'll need this when you build your first tennis bot

zostaff

35,652 views • 2 months ago

9 repos that mass replace a $150,000/year NBA analytics department. all free. all open source. -> replaces Second Spectrum and SportVU YOLO tracks every player and ball from any broadcast. assigns teams by jersey color. court keypoint detection builds a tactical top-down map. speed, distance, passes - all from a TV feed. no sensors. -> replaces paid NBA prediction services ($100/mo) XGBoost + Neural Net. moneyline and totals. Kelly Criterion sizing. 69% accuracy. pulls odds from FanDuel/DraftKings automatically. the most starred NBA betting repo on GitHub. -> replaces an entire quant sports desk 5-model ensemble: XGBoost + PyTorch MLP + Ridge + Lasso + baseline. Optuna-tuned hyperparameters. SQLite database with box scores, play-by-play, betting lines, injury reports. production-grade. -> replaces manual daily prediction workflows XGBoost/LightGBM with GitHub Actions automation. scrapes new data, retrains models, outputs daily win probabilities. set it and forget it. -> replaces ELO subscription services custom ELO + Ridge + XGBoost + Neural Networks ensemble. full data scraping pipeline. comprehensive visualizations. FiveThirtyEight-style ratings from scratch. -> replaces Four Factors analytics dashboards ELO rating system + Four Factors + PCA dimensionality reduction. detailed comparison of 10+ models. honest 65.3% accuracy - because that's what real NBA prediction looks like. -> replaces computer vision analytics platforms ($500/mo) YOLO player/ball tracking. automatic team assignment. court keypoints. pass and interception detection. speed and distance. full tactical view. modular architecture. -> replaces shot tracking hardware YOLOv8 detects ball and hoop in real-time. linear regression predicts trajectory. registers makes and misses automatically. works on any video feed. -> replaces paid sports data subscriptions ($300/mo) official Python client for NBA. com API. box scores, play-by-play, shot charts, player tracking. 40+ years of data. zero cost. the foundation every NBA ML project is built on. like + bookmark you'll need this when you build your first NBA prediction bot

zostaff

102,508 views • 2 months ago

Perfect 1v1 Drill For Finding Your LOCKDOWN Defenders! Coach LoGalbo takes you through a drill that is perfect for finding your lockdown defenders that you can rely on when the lights turn on. As Nick LoGalbo says, it's a great way to find your "Rambo" which is a defender that you can rely on to defend your opponent’s best ball handler in the full court. And, an added offensive benefit to this drill, is that it allows for offensive players to work on their ball handling in the face of defensive pressure! This 1 on 1 Contain Drill is from Nick LoGalbo's Outer Third Defense (No Middle Defense). That's why the goal of this basketball drill is to force the opponent's primary ball handlers to the outer thirds of the basketball court (and out of the middle!) as soon as they catch the ball. By doing this, it allows the defense to dictate the entry pass to one side of the floor. By keeping the ball on the outer third of the basketball court, you can overload the backside of the defense which helps control the opponents passing lanes, deters easy passes and helps eliminate the dribble drive. You can incorporate this drill every other day in practice to re-emphasize to your defenders the importance of keeping the ball handlers out of the middle of the basketball court. Instructions and Keys to the 1 on 1 Contain Drill: - Give the ball handler a cushion. This makes it easier to contain them in the outer thirds. - Chest and contest a crossover to the middle. You do not turn your body. You must beat the offensive player to the spot and turn them back to the outer thirds. - If you get beat, you sprint ahead of the ball. You do not continue shuffling. - Keep the ball in the outer thirds the entire length of the court. It does not stop after the offensive player gets past half court. - The goal of the drill is to simply keep the ball handler in the outer thirds. - The defense should focus on beating the ball to the spot and chest to contest defense. - As soon as the first group gets to halfcourt, the second group begins. - After a group makes it all the way to the opposite baseline, they switch positions and get in line to repeat the drill going the opposite direction. Coaching Tips - Once a player gets chest to contest, they must spring back to get in front of the ball. Your goal is not to be running side by side. You must get in front of the offensive player. This prevents the offensive player from getting an angle to the basket. - After running through the drill for a specified amount of time, switch directions so the offensive players must focus on using both hands as their primary dribbling hand. - It is important to mix up players rather than like positions always competing against each other, so that players get used to guarding a wide variety of positions. It forces the players to adjust defensively regarding speed and skill. - Another positive of this drill is it gives you the ability to assess who your Rambo is: players who can work the point guard up the floor.

Joe Haefner | Breakthrough Basketball

38,009 views • 1 year ago

Why the character movement in my custom game engine felt janky and how I fixed it. In a game engine, most often, a character moves using the physics engine. Meaning, the player is not just a coordinate in space but a physical body. It has velocity, it handles collisions, and it interacts with the world. Now, as you might know, physics engines need stability. If you run them at variable framerates, things start breaking. Objects phase through walls or fly off into space because the math becomes unpredictable. This is why most game engines lock their physics loop to a 60Hz fixed rate. But here’s the problem: If you have a high-end system, you don't want to limit it at 60 FPS. That's a waste of good hardware. Now, that said, if the GPU is rendering at 144 FPS but the player's position (physics driven) only updates 60 times a second, it creates a micro-stutter that ruins the "smooth" feel of the game. A good way to fix this is to treat the character as two separate things: 1. The Physics Body (Invisible part): This is the "real" character. It lives in the 60Hz physics world, it moves the player and handles collisions. 2. The Visual Model and Camera (Visible part): This is what the player actually sees. It doesn't care about collisions, its only job is to look nice and smooth at whatever framerate the GPU is pushing. Once you have this separation, you can use interpolation to keep them in sync. Every time the physics clock ticks, you save the previous position of the invisible body before moving it to the new one. Between those ticks, calculate how far we are between the last physics update and the next one. By using this to drive the visible parts of the game, the stutters disappear. The physics loop stays fixed behind the scenes, while the visuals slide smoothly between the snapshots. Example: - Right after a tick: blend_weight= 0.0 (The visual model stays at the old physics position). - Halfway to the next: blend_weight= 0.5 (The visual model slides to the middle point). - Just before the next: blend_weight= 0.9 (The visual model is almost at the new physics position). Pro-Tip A critical mistake I made initially, and one many devs make, is parenting the camera and visible parts directly to the player body. If you do this, the camera inherits the discrete 60Hz physics movement by default. In that setup, interpolation won't work because the camera is "stuck" to the physics clock. For this fix to work you must decouple the camera and visuals from the body and move them separately. Player movement processing in Detis Engine: - fixed_process: Physics runs at 60Hz. Handles collisions and raw movement. - process: Variable rate. Mainly used for player input caching in the player case. - late_process: Variable rate. Handles interpolated camera movement after physics and everything else is done being processed. - render. Submits the final interpolated transforms to the GPU. The test environment in the video is running on an old 2070-based laptop. Hopefully the video compression won't introduce any stutter... I’m sharing this in hopes it helps a fellow dev. Cheers.

Ioannis Koukourakis

48,518 views • 6 months ago

Ferris State HC Tony Annese - Mesh (QB/Ball Carrier) & Motion Fundamentals QB Mesh Fundamentals - Regardless of play, the first thing the QB needs to do to make sure he has a good mesh is stab the ball back off his hip towards the ball carrier as far as he can. - His arms should be straightened with his eyes at the HOK. - The ball should move with the back through his track. - If the ball is pulled the decision must be made by the time the ball gets to the QB's front hip. Ball Carrier Mesh Fundamentals - The potential ball carrier is the one that is responsible for his track. He needs to make sure his is at the mesh point that the QB is creating. - He must maintain a pocket that is firm enough to secure the ball but loose enough that the QB can pull the ball if the read is a pull read. - Do not deviate from the track until you fully clear the mesh. - If you do not get the ball then track away from the HOK and make him chase you. Motion Fundamentals - All of our motions start up at FULL SPEED! It is incredibly important to make every motion at full speed so the QB has a consistent timing. - The QB is responsible for sending the motion back on every play except for the triple option. - This allows us to control each motion easier. - Every Jet motion should be timed as if the jet back was getting the ball regardless of play. - The motion back will change his depth based on play. - This allows us to use motion with a multitude of schemes. - The motion stops at different spots on different plays and each perimeter player must understand where he should stop for each play.

James Light

19,145 views • 5 months ago