I have released v6.1 of the model. Large improvement in accuracy but most specifically in ROI. So let's talk betting strategy. One question I get asked practically every day is, "why do you recommend only the AI picked winners even if they're not +EV?"

The best tech available for predicting UFC are binary classification algorithms. These are algorithms specialized in classifying a fighter as either 1 or 0, win or loss. The confidence score that the algorithm comes up with is not its fundamental strength.

"So why don't you calibrate it?"

Because the calibration tech we have for these algorithms suck. Platt Scaling and Isotonic Regression are the two most potent weapons we have to calibrate these predictions. I have experimented a lot with them. 100% of the time they suck. They lower the accuracy and the ROI. I've experimented with custom calibrations but it's just too inconsistent and I don't see a promising way forward. I would absolutely love to have better calibration, so if you have any ideas please let me know. That being said, the ultimate goal here is risk-adjusted returns. Calibration is a tool to help us get there but it's not necessary to acheiving the goal.

Anyway, who cares about calibration if we're making fat ROI? Take off your sports bettor hat and all the "fundamentals" you know like +EV is all that matters to be successful. Put on your machine learning cap and look at the data. This is the calibration curve:

Note how the model is highly underconfident in its 50-65% confidence score picks and highly overconfident in it's 35-50% confidence scores. The nature of the algorithm is to maximize it's ability to successfully pick the winner and it does this at the expense of accurate calibration. It clusters it's confidence scores in the 50-65% range. AND THAT'S OK!

Here's the model evaluations and vegas evaluations on the last year of unseen fights:

Note the model is more accurate than Vegas, but it's logloss and Brier scores (essentially real world win%) are worse. Again, THIS IS OK. Why? Because look at these profit strategy backtests over the last year of unseen fights:

The fundamental strategy of betting on 100% of the AI picks on the closing odds is 14% profitable (ai_all_picks_closing). The strategy of picking only the +EV fighter based on the AI confidence score whether the AI picked that fighter to win or not is -0.5% unprofitable (any_fighter_positive_ev_closing).

Interpreting The Strategies

None of this is to say that +EV isn't a helpful metric. Look at another fundamental strategy, betting only on +EV AI-picked fighters (ai_picked_positive_ev_closing): +24.2% ROI. 10% higher than just doing down the line bets but it means sometimes there'll be events where you don't get to bet which makes me sad.

So let's put this all together. Why are parlays so good with this machine learning algorithm? It's because the algorithm is so gosh darn good at picking winners. Parlaying the AI picks, whether +EV or not, is a highly profitable strategy. The best strategy is doing 2 to 3 leg parlays on the +EV AI picked fighters. I'll probably move into posting these parlays again in the homepage.

---

EDIT: Shoutout to @Heisenb3rg on X for bringing Sharpe Ratios to my attention! This is a crucial metric from finance that measures risk-adjusted returns. Essentially, it tells us how much return we're getting for the amount of risk (volatility) we're taking on with a particular betting strategy. A higher Sharpe Ratio is better.

Looking at the Sharpe Ratio analysis, we can see how different strategies compare not just on raw ROI, but also on how bumpy the ride is. For v6.1, the 'ai_picked_positive_ev_closing' strategy seems to offer a strong balance, providing good returns without excessive risk compared to some others. However, the 'ai_all_picks_closing' still performs well from a risk-adjusted perspective, offering broader betting opportunities.

So, what's the takeaway? While different model versions might favor underdogs or favorites differently, the data consistently points towards a simple, robust approach. Considering both the ROI and the Sharpe Ratio (risk-adjusted return), the strategy of betting on all AI picks using the odds available 7 days before the event (ai_all_picks_7day) emerges as the winner. It offers the best blend of profitability and lower volatility, making it the simplest and most effective core strategy based on the current analysis.

It's important to remember that model performance, especially regarding favorites versus underdogs, can shift between versions and timelines. Therefore, relying solely on specific odds ranges like underdogs only might be less reliable long-term despite being very profitable over the past year. Instead, I think focusing on fundamental strategies evaluated through metrics like ROI and Sharpe Ratio is key. For the current model, based on the patterns I've seen over the years, I think I'm going to stick with the core strategy ai_all_picks_sevenday which provides the best risk-adjusted performance indicated by the Sharpe Ratio. To get higher returns at higher risk, 2 to 3 leg parlays of your choice are a good option.

Here are the AI predictions for UFC 314.

Check out the latest video analysis and AI predictions for the upcoming UFC matchup between Emmett and Murphy. The AI generated interpretation of my face always cracks me up.

Check out our latest video explaining how MMA-AI makes its predictions and why our model has been consistently outperforming Vegas odds.

After countless requests from the community, I'm finally pulling back the curtain on how our UFC fight prediction algorithm works. This isn't just another black-box system—it's a carefully engineered, multi-level approach to fight analysis that's consistently outperforming Vegas odds.

Why Share Our Secret Sauce?

Many have asked why I'd reveal the inner workings of a profitable system. The truth is simple: I don't believe in keeping this knowledge secret. Much of this algorithm was developed with the assistance of AI tools that generated about 90% of my code. As someone who's been an open source developer for 15 years, I firmly believe that open knowledge sharing accelerates human progress. I don't have a moat to protect—and frankly, the more people who understand these concepts, the faster our collective knowledge will advance. Sports prediction is hard enough that even with this blueprint, you'll still need to invest thousands of hours to truly master it.

The Four Levels of Fight Prediction

Level 1: Foundation Stats + Bayesian Gamma-Poisson Smoothing

We start with raw fight statistics—strikes thrown, takedowns landed, control time, and dozens more. But raw numbers can be misleading, especially for rare events like submissions. This is where Bayesian Gamma-Poisson smoothing comes in.

Imagine a fighter who's attempted only one submission in their career and landed it. Is their submission accuracy really 100%? Probably not. Gamma-Poisson smoothing helps us balance observed data with prior knowledge, preventing outliers from skewing predictions. For high-volume stats like significant strikes, the smoothing effect is minimal. But for rare events like submissions or knockdowns, it provides crucial stability by "pulling" extreme values toward more realistic expectations based on the fighter's division and overall UFC averages.

Level 2: Comparative Analysis

Next, we calculate a fighter's efficiency metrics: accuracy (how often attacks land), defense (how often they avoid opponents' attacks), output per minute, and the ratios between fighters across all statistics. This gives us a clearer picture of how fighters perform relative to each other, beyond just counting actions. A fighter might land fewer strikes overall but have significantly higher accuracy—a crucial distinction our model captures.

Level 3: Time-Weighted Averages + Variability

MMA evolves rapidly, and a fighter today isn't the same as they were three years ago. We calculate both standard and time-decayed averages with a 1.5-year half-life for all statistics. This means a fight from three months ago has far more impact on our predictions than one from three years ago.

Additionally, we measure the variability of these stats using Median Absolute Deviation (MAD) instead of standard deviation. MAD is less affected by extreme outliers, providing a more stable measure of how consistent a fighter's performance has been.

Level 4: Adjusted Performance (AdjPerf)

Our most sophisticated metric answers a critical question: how does a fighter perform against a specific opponent compared to how that opponent's previous adversaries performed? This z-score normalization looks like:

stat_adjperf = (fighter1_stat - fighter2_stat_prev_opp_avg) / fighter2_stat_prev_opp_mad

In plain English: we're measuring how much better or worse a fighter performed against their opponent compared to what we'd expect based on the opponent's history. If a fighter lands more strikes against someone who's historically difficult to hit, that's far more impressive than landing the same number against someone who's easily hit. AdjPerf captures this crucial context.

Building the Prediction Model

With thousands of engineered features from these four levels, we use Autogluon (thanks to Chris from Wolftickets.ai for this recommendation) to train our prediction model. Using presets like "experimental" and time-ordered data splitting (typically 80/20 or 90/10 train/test), we run extensive cross-validation to ensure reliability.

There's no definitive guide to sports prediction—we've conducted thousands of hours of testing to find what consistently beats Vegas odds. Everything from feature selection to hyperparameter tuning requires constant experimentation and refinement. What works for NFL might not work for UFC, and what worked last year might not work next year.

The final model combines about the 30 best of these features, weighted according to their predictive power. The result is a system that consistently identifies value bets where our predicted win probability exceeds what Vegas odds imply.

The Practical Limitations of ML Probabilities

One of the humbling lessons I've learned over the years is about the relationship between machine learning and betting strategy. Despite the sophisticated nature of our model, I've had to accept that ML algorithms have inherent limitations when it comes to probability calibration. While traditional betting approaches rely heavily on expected value (EV) calculations, I've discovered that applying these same principles directly to ML outputs can be problematic. Our tabular ML models excel at binary classification—essentially determining which fighter is more likely to win—but their confidence scores aren't necessarily true probabilities in the statistical sense. Even when optimizing for log loss (which theoretically improves probability calibration), there remain subtle biases and distortions in how these models estimate probabilities. Through trial and error, I've found that treating the model's outputs as relative confidence levels rather than exact win probabilities leads to more consistent results. Instead of rigidly applying EV formulas, we use confidence thresholds as a filtering mechanism to identify promising bets. This pragmatic approach acknowledges the model's strengths in pattern recognition while respecting its limitations in precise probability estimation—a balance that has proven more effective than assuming perfect calibration.

Why Current LLM-Based Fight Predictions Fall Short

I've extensively tested Large Language Models (LLMs) like GPT-4 for fight predictions, and the results have been consistently disappointing. The fundamental limitation is clear: today's LLMs lack the ability to analyze fight footage. They're trained primarily on text data, which means they miss crucial visual information—a fighter's movement patterns, subtle defensive vulnerabilities, changes in stance, or signs of fatigue that only appear on video. Statistical data can tell us a lot, but the visual dimension of fighting contains irreplaceable insights that no spreadsheet can capture. The good news? This limitation is temporary. Within the next 1-2 years, we'll see multimodal AI systems trained on vast libraries of video footage, capable of analyzing thousands of fights frame-by-frame. When that happens, AI fight prediction will undergo a revolutionary leap forward. Until then, the most effective approach remains combining sophisticated statistical modeling with human expertise for context and interpretation.

Conclusion: The Never-Ending Journey

MMA prediction remains as much art as science. While our technical approach provides an edge, the sport constantly evolves, and so must our model. Every event brings new data, every fighter brings new patterns, and our system continually adapts to these changes.

Whether you're a casual fan or a serious bettor, I hope this behind-the-scenes look helps you appreciate the depth of analysis that goes into each prediction you see on MMA-AI.net. And if you're inspired to build your own model? Even better—innovation thrives when knowledge is shared.

Model v6 is available for tonight's event and events going forward. This is intended to be a long-term release.

Changes:

• Unit tests for everything
  • Finally we have unit tests for all calculations so I can sleep at night. At least now if the model fails I know it's not some unknown bug.
• Bayesian Gamma-Poisson
  • We switched out from just doing Bayesian Beta Binomial smoothing in accuracy/def and per_min calculations to a Bayesian Gamma-Poisson for all stats starting at the very beginning. This is a more robust and consistent smoothing factor.
• Swapped stddev for median absolute deviation for the zscore normalization stat adjperf
  • Adjperf layer of feature engineering changed from:
    stat_adjperf = (fighter1_stat - fighter2_stat_prev_opponents_avg) / fighter2_stat_prev_opponents_stddev
    to:
    stat_adjperf = (fighter1_stat - fighter2_stat_prev_opponents_avg) / fighter2_stat_prev_opponents_mad
  • Median absolute deviation (MAD) is a more robust measure of deviation for sports statistics because it's not as vulnerable to outliers.

Future:

Have a few stats I'd still like to engineer especially around the win conditions of submissions vs KO vs decision.

I have also added visualizations to the predictions. Just hover over the fight or click on the fight to see how each fighter compares to each other using a normalized stat difference. Note that these visualizations do not account for how the model is weighing each stats, it's just the normalized difference in the stats between the fighters to give you an idea of where each fighter has an advantage. Larger surface area = better stats but you may notice sometimes the fighter with the larger surface area is not picked, this is due to the fact the stats are not weighed equally by the model and also because the model makes some complex relationships between the stats that won't be reflected by the visualization.

Based on the past 2 months of performance I'm fairly convinced I have some bugs in the nonunit tested code. I've started the unit testing but I'm not done yet so take this event (3-1-2025 UFC Fight Night) with a grain of salt, might be a good one to skip for now, but I should have lots of time after work to finish unit testing next week and I'll post an update about bugs found once I'm done.

After countless hours of trial and error testing this week, we're implementing a few key refinements to the model. Rather than making sweeping changes, we're focusing on targeted improvements that have shown consistent benefits in our testing:

1. Updated Training Data Window

We're moving the cutoff date for training data from 2014 to 2016. While I've been using 2014 as the starting point for the past 4 years, it's time to shift forward to better capture recent trends in the sport. MMA evolves rapidly, and data from 10 years ago may not be as relevant to today's fighting landscape as it once was.

2. New Feature: UFC Age

We've added a simple but effective new stat: UFCAge. This measures the amount of time a fighter has been in the UFC. While straightforward, this metric helps capture valuable information about a fighter's experience at the highest level of competition.

3. Enhanced Feature Layering

Previously, we were using two primary layers of features:

• Decayed adjusted performance (dec_adjperf_dec_avg)
• Opponents' decayed average (opp_dec_avg)

Now we're adding a third layer: the fighter's individual stats (like strikes_landed_ratio_dec_avg). This addition has proven valuable - by combining all three layers of a key base stat (like head_landed_ratio), the algorithm seems better equipped to predict how each fighter will perform relative to the broader UFC population.

Looking Forward

I'm preparing to start producing analysis videos to help explain the model's decision-making process and break down specific fight predictions. The site has been updated with the latest calibration curve, model evaluations, and feature importance rankings to reflect these changes.

As always, these updates are focused on one goal: improving our ability to predict fight outcomes accurately. The changes might seem subtle, but in the world of fight prediction, small edges often make the difference.

Goddamn that took forever. There was a bug in the zscore normalization stat I named _adjperf. If you recall, the calculation for adjperf is:

stat_adjperf = (fighter1_stat - fighter2_prev_fight_stat_opp_avg) / fighter2_prev_fight_stat_opp_sdev

• f2_stat_opp_avg is the historical opponent average against fighter2 pulled from fighter2's previous fight.
• f2_stat_opp_sdev is the historical opponent standard deviation pulled from fighter2's previous fight.

This stat is extremely complicated to implement and was the reason we were predicting so few fights ever since v5 was released with it included. We train with only data known pre-fight so we shift all the data backwards by 1 fight for all fighters. The consequences:

Case #1:

All fights where at least one fighter is debuting are immediately eliminated because their data is 100% null after we shift the data backwards by 1 fight and we can make no comparisons between them and their opponent.

Case #2:

All fights where at least one fighter has only 1 previous fight is useless because one-previous-fight fighter has a 0 in fighter2_prev_fight_stat_opp_sdev for their opponent's adjperf calculation.

Case #3

One fighter has 3 previous fights, the other fighter has 2. Again, adjusted_performance for fighter1 will be 0.

And so on. It means that _adjperf is causing an enormous amount of fights to be dropped.

I've tried to fix this by calculating an initial standard deviation for all first time fighters. I collect all stats of first-time fighters on a per weightclass, per stat basis. So your _adjperf score against first-time fighters is based on how good or bad you did compared to the median first time fighter's stats. This feels fine, because we're dropping all fights where either fighter only has 2 previous fights anyway.

Bug Fixes

So there was a fun little bug affecting ~2% of the training data where fighter2_stat_opp_sdev would end up being 0.00000002 or something so the adjperf score would end up being like 11,839,902 instead of a more normal 1.5 or -1 (i.e., fighter1 scored 1.5 standard deviations above what fighter2 usually allows in that stat from their historical opponents). The reason was because I only use time-decayed averages in the final model to capture recent trends in both fighters and their opponents and the time-decayed standard deviation calculation is a bit complex:

weight = EXP(-λ * ((T - t) / 365.25))

Sooooooometimes, T = 7.777777777 and t = 77.77777778 due to rounding in Postgres double precision. I have fixed this by capping the minimum standard deviation of stats to their 5th percentile. This is to avoid insane standard deviations in tiny edge cases like Khamzat Chimaev's early UFC run where his opponents only scored like 4 strikes against him in 4 fights then he fought Gilbert Burns who hit him 223 times. This meant Burns' _adjperf score was insane because he took Khamzat like 400 standard deviations away from his previous opponent averages.

Last, I had some small bugs affecting the filtering of training data. The order of filtering the data matters a LOT and I was doing some dumb stuff like filtering out Draws and stuff, THEN calculating number of fights for each fighter and filtering on number of fights which is wrong because I already filtered out fights before calculating number of fights for each fighter.

OK! That about wraps up the updates this week. It took a really long time to get through all those bugs so I'm trying to get the updated predictions out before this event, bear with me.

First, we're changing the wording from "AI win%" to "AI confidence". This is to sort out the confusion that many traditional bettors have. This algo is not specialized in finding +EV. It is a binary classification algorithm, meaning it is very good at figuring out who will win, but not the real world win % chance. Predictor.predict(upcoming_fights) returns a binary value of 1 = fighter1 predicted to win, 0 = fighter1 predicted to lose. We can do predictor.predict_proba(upcoming_fights) and get it's best guess at each fighter's implied probability but generally this probability is not well-calibrated because this is specifically a binary classifier.

Second, the reason we're doing parlays is because they're essentially a multiplier of the profit from the single picks. You can risk less units to win more. You don't have to do this, you can just do the straight picks and limit the boom and bust cycle of the parlay strategy, but backtesting is showing the parlay strategy consistently outperforms the straight picks in ROI.

On this note, up until now I've been randomly creating the parlays. I've been trying to figure out how to get rid of that randomization. Sorting the fights by AI confidence or inconfidence ended up performing worse than random picks. So I thought about what does the algorithm crave to become more accurate? Data.

The new parlay strategy is based on backtesting showing more consistent results by sorting the parlays by total combined fights both fighters have had. Islam has had 15 fights in the UFC. Renato Moicano has had 17 fights. That's 32 fights of data that the algorithm has had time to calibrate on. So whatever the algorithm picks on this fight is likely to have the most consistent accuracy. That's why we're seeing islam in 3 parlays this event.

This strategy could use more refinement, and ideally we'd actually just create every possible 3 leg parlay and set that up as the predictions for every event. The only reason I don't do that is because it takes forever to input all those parlays into betmma.tips and the bookie but maybe once I automate the placing of pre-event picks into betmma.tips or something then I'll start doing all parlay combinations possible as the recommended picks.

Alright, so I'm finally ready to talk about my new key feature: Adjusted Performance. This has been one of those "why didn't I think of this sooner" moments, but also "holy crap this is a nightmare to implement." Let me give you a quick taste of what it looks like mathematically:

fighter1_stat_adjperf = (fighter1_stat − fighter2_stat_opp_avg) / fighter2_stat_opp_sdev

We'll call this f1_stat_adjperf for short. The big idea is to measure how much a fighter's performance in any given fight exceeded or fell short of what we'd expect their opponent to allow. If you go in there against some unstoppable jab machine who normally forces everyone to eat 50 jabs per round, but you manage to hold them to only 20, well, that's huge. But if you never do the math to figure out what your opponent's "baseline" is, you'll just record "Fighter1 absorbed 20 jabs" and maybe think it's not that great. Meanwhile, that's incredibly good compared to the 50 jabs everyone else took. Hence, adjusted performance.

Understanding the _opp Suffix

Before going any further, let's talk about the _opp suffix. First, _opp is the post-fight stats your opponent did against you. So if you see something like f2_stat_opp_avg, that means the stat is referencing "what your opponent's opponents did against them." For example:

• f1_stat_opp_avg: The average of your opponents' performances against you in all their fights.
• f2_stat_opp_avg: The average of your opponent's opponents' performances against your opponent in all their previous fights.
• f2_stat_opp_sdev: The standard deviation of your opponent's opponents performance in those same fights, giving us a measure of the volatility or variability in their performance.

So, if your opponent has 40 strikes landed against them then f2_strikes_opp_avg is 40.

This means, to measure your adjusted performance, you compare your post-fight stat in the fight to their pre-fight _opp_avg, and then scale it by pre-fight _opp_sdev. If you get 60 strikes against someone who averages getting hit 30 times, you're 1 standard deviation above average against that person.

Why It's So Valuable

Let's be honest: raw stats can lie, or at least mislead. If a fighter's output is just "I landed 30 strikes," that doesn't tell me how many strikes they should have been able to land. If they were fighting an iron-clad defensive wizard who typically only allows 10 strikes, then landing 30 is insane. On the flip side, if your opponent is basically an open punching bag who gives up 60 strikes on average, then landing 30 is actually pretty weak.

Adjusted performance changes the game: it says, "30 strikes might be good or bad, but let's see how it compares to what your opponent usually allows." Then, for even more nuance, it's scaled by the opponent's historical standard deviation—so you don't artificially inflate your stats just because you faced someone with wide variability on a certain stat.

The Complexity: Where Do You Even Get These Numbers?

The problem with pulling off something like f1_stat_adjperf is that you actually have to calculate your opponent's _opp_avg and _opp_sdev. In other words:

• Grab all your opponent's previous fights.
• For each of those fights, figure out the stats they allowed to their opponents.
• From that, compute the average allowed stats and the standard deviation of those stats.
• Then bring that back into your current fight to see how well or poorly you did.

This is where the data pipeline can get insane, because you might have a fighter who has 15 or 20 fights, each with a different set of opponents. Some of those opponents have 30 fights apiece. Doing this for every fighter means you need to traverse a huge web of fight stats.

If you run a naive approach—like just using Panda's groupby and merges all day—it becomes unbelievably slow at scale. This is why I had to do some major refactoring, rewriting a chunk of my data pipeline to pull from a properly indexed database (Postgres, in my case). Once your data is properly structured, it's much faster to do these calculations in a single pass or via specialized queries, rather than stumbling around in memory merges.

Time-Decayed Averages & Time-Decayed StdDev

But wait—there's more. I decided to do a time-decayed average (and corresponding standard deviation) with a 1.5-year half-life. That means that a fight 3 months ago is given a lot more weight than a fight 5 years ago, which is basically ancient history in fight years.

Now the complexity is multiplied by, like, a factor of 10. Because to get f2_stat_opp_avg, I can't just average everything your opponent has done; I have to:

• Grab each fight's stat.
• Weight it exponentially based on how recently it happened.
• Sum up those weighted stats.
• Divide by the sum of the weights.
• Then do it all over again for the standard deviation.

And let's not forget: we do this for every single fight, across thousands of fights, across hundreds of fighters. That's why I always say data engineering is half the battle.

Why Bother?

So why go through this code-wrangling fiasco when your standard raw stats might be "good enough?" Because fights are context-dependent. If you have a stand-up specialist with insane takedown defense, but no one has tested it in years, your raw stats might not reflect the real picture of how they handle a brand-new style. By blending in adjusted performance stats, you're no longer stuck just describing how many strikes or takedowns a fighter landed; you're describing how well they did compared to what their opponent typically experiences—and you're discounting or boosting older fights according to their recency.

This is how we start to see nuanced differences that no raw stat alone can show. It's the difference between "Fighter A landed 40 strikes" vs. "Fighter A forced a 1.5 standard-deviation drop in Fighter B's typical striking output." That second statement captures so much more power. If you can integrate these insights into your model, you get a far more realistic prediction of how a matchup might turn out.

v5 beta is *might* be done in time for the next event. I'm 100's of hours in. The data processing and model training is basically done, I just need to figure out the final feature set and do some tuning. Then I need to write the future prediction code for creating and cleaning the data of future fights. Finally, we're beating Vegas accuracy/log loss without including the odds or rating/ranking stats like an Elo score. That's not to say I won't include those in the future, but it's a great sign that the fundamentals of the model are improving. I would like to thank my $200/mo ChatGPT o1 Pro subscription for making this possible. That model absolutely rules at complex code, especially statistics and math.

Here's a recent training run to give you an idea of current levels of performance. This isn't the final model performance, it's just from tinkering with the feature set and training parameters:

Model Performance:
Training log loss: -0.611
Validation log loss: -0.575
Test Log loss: -0.612
Training accuracy: 0.671
Validation accuracy: 0.698
```