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
Test accuracy: 0.691

Basically, we're seeing somewhere around 68% to 69% accuracy on last year's fights (Vegas is currently about 67% accurate) that the model has never seen before with excellent log loss. Log loss is the ability of the model to accurately predict the chance a fighter will win. For example, if in its training data it predicts 50 fighters to have a 70% chance to win, and those fighters won 68% of the time, then the log loss is nicely calibrated. This is what allows us to check the EV of AI predictions versus Vegas odds.

Changes:

• Total rewrite
  • Switched from just pandas dataframes (SLOW) to Postgres SQL database (FAST)
  • Greatly improved code readability, design, and efficiency for easier future updates
• Features
  • Total feature overhaul
  • Per minute
    • Uses Bayesian Posterior Mean to smooth the outliers, zeros, and noise reduction
  • Accuracy/defense
    • Uses Bayesian smoothing with a Beta prior to smooth the outliers, zeros, and noise reduction
    • Priors are calculated on a historical pre-fight per-weightclass, per-stat basis
  • Ratio
    • Now does bounded ratio to prevent division by zero and outlier ratios
  • Average
    • Now includes time decayed average rather than recent average

The reason we do all this smoothing is because when a fighter attempts 0 submissions and lands 0 submissions, giving them 0% accuracy is an unrealistic measure of what their submission accuracy would've been had they attempted any submissions. With smoothing it looks more like this:

Subs_land / subs_attempted = accuracy
0 / 0 = 20% acc (similar to historical weightclass average submission accuracy)
0 / 1 = 18% acc
0 / 10 = 2% acc
These are just examples, not the actual numbers but you get the idea. It punishes fighters who never land any attempts but doesn't overpunish them which means future stats that are layered on top will be more realistic to their actual performance based on sparse data.

Second, no more recent averages over an arbitrary number of fights or dates. Time decayed averages are where it's at. Set a half life, like 1 year. Fights within this 1 year account for, let's say, 50% of the time decayed average. Fights the year prior account for 25% of the time decayed average, etc. This gives a much more precise measure of the fighter as he stands today rather than letting how he stood 5 years ago affect his current stats.

All of these changes above were nice and showed a moderate increase in the model's reliability. However, the real coup de grace was a final layer of statistical analysis over the stats that solved the following problem: if you fought nothing but cans 20 fights in a row your stats would make you look better than Jon Jones. But if you fought nothing but top flight competition 20 fights in a row, your stats would look average to below average despite the fact you'd crush the can crusher. The main way people have solved this has been ranking or rating systems like Elo scores. While this is pretty effective it doesn't solve the core problem of the fighter's individual fight stats being a kind of isolated measurement of the fighter that lacks perspective. How do you turn these core, fight by fight stats into an interconnected web where each individual fight's stats can inform and affect the stats of other related fights?

I'll go into detail about the exact math I did to solve that problem along with the mathematical implementation of the Bayesian smoothing on my Patreon for subscribers here soon. See you next event, hopefully!

After watching UFC 309 systematically demolish my model's predictions with the precision of a prime Anderson Silva, I've spent the past week in a caffeine-fueled debugging frenzy. Between muttering obscenities at my terminal and questioning my life choices, I've had some genuine epiphanies about AI development that might save others from my particular flavor of statistical hell.

The Problem with Yes-Man AI

Large Language Models are like that friend who encourages your 3 AM business ideas. "A blockchain-based dating app for cats? Brilliant!" This becomes particularly dangerous when you're knee-deep in feature engineering and looking for validation rather than criticism.

After extensive testing, I've discovered something fascinating about GPT o1's mathematical capabilities. While most LLMs give basic statistical approaches, GPT o1 can dive deep into complex statistical problems. But the real breakthrough came from building an AI feedback loop: get statistical approaches from GPT o1, feed them to Claude for implementation (it writes cleaner code), then feed Claude's code back to GPT o1 for validation.

Even debugging has improved. When Claude's code throws an exception, feeding the error back works once. But for persistent issues, asking Claude "what do you need to debug this error?" is far more effective. It responds with diagnostic code that, once fed with real data, leads to actual fixes rather than band-aids.

This iterative process, combined with extensive prompt engineering and lots of sample data to help GPT o1 truly understand the problem domain, has led to the first major mathematical breakthrough in V5's development: our new Bayesian approach to handling fight statistics.

Bayesian Beta Binomial: The Zero Division Solution

This is only one of many many improvements in V5 but I find it super interesting so I'm writing about it and fuck you if you don't want to hear about it. Let's dive deep into how we handle the dreaded divide-by-zero problem in fight statistics. When calculating success rates (like submission accuracy or strike accuracy), we use Bayesian Beta Binomial analysis to provide meaningful priors that smoothly handle edge cases.

The approach works like this: Instead of naive division that breaks on zeros, we model each ratio as a Beta distribution where:

• α (alpha) represents successful attempts plus prior successes
• β (beta) represents failed attempts plus prior failures
• The posterior mean (α / (α + β)) gives us our smoothed estimate

For example, with submission accuracy:

submission_accuracy = (submissions + α) / (submission_attempts + α + β)

We determine our priors (α, β) through empirical Bayes by analyzing the historical distribution of success rates across all fighters. These priors vary by stat type, reflecting the different base rates we see in MMA:

• Submissions: Lower α and higher β values reflecting their relative rarity
• Strikes: More balanced α and β values reflecting higher occurrence rates
• Takedowns: Intermediate values based on historical success rates

This approach elegantly handles three critical cases:

• Zero attempts: Returns the prior mean (α/(α+β))
• Small sample sizes: Heavily weights the prior
• Large sample sizes: Converges to the empirical rate

To understand why this matters, consider how submission accuracy was traditionally handled: A fighter attempting 10 submissions and landing none would be assigned 0% accuracy. This creates two problems: it skews averages downward, and when comparing fighters (fighter1_sub_acc / fighter2_sub_acc), we risk another divide-by-zero error.

Our Bayesian approach instead provides more nuanced, realistic estimates. For example:

• 10 attempts, 0 successes = 3.5% accuracy
• 9 attempts, 0 successes = 3.8% accuracy
• 8 attempts, 0 successes = 4.1% accuracy

This prevents over-punishing unsuccessful attempts while ensuring we never hit true zero. The accuracy gradually increases as sample size decreases, reflecting our increasing uncertainty with smaller sample sizes.

The V5 Redemption Arc

For V5, we're continuing to embrace AutoML (specifically AutoGluon) to eliminate the uncertainty in model optimization. Through V1-V3, I spent countless hours manually tuning gradient boosted algorithms like XGBoost and CatBoost. While I learned an enormous amount about hyperparameter optimization and various other tuning, I was never entirely confident I was meeting professional machine learning engineering standards.

AutoML removes that uncertainty. It systematically explores model architectures and hyperparameters in ways that would take me months to do manually. I still do significant tuning, but now it's faster and more reliable. No more wondering if I missed some crucial optimization or made rookie mistakes in the model architecture.

What This Means For Users

MMA-AI.net will continue hosting Model V4 predictions while V5 is under development. However, there won't be any improvements to the current model during this transition. If you want to take a step back and not ride with me for a month or two while I finish V5, I completely understand. This isn't about quick fixes - it's about building something that actually works.

The Bottom Line

Sometimes you need to lose six parlays in a row to light a fire under your ass and actually learn some math. But at least we're failing forward, and V5 will be built on more solid foundations.

P.S. To the UFC 309 fighters: those 3 AM tweets weren't personal. It was just the model and the Monster Energy talking.

I'm absolutely furious. UFC 309 just wiped out 6 units with 6 consecutive parlay losses. After four years of development, countless sleepless nights, and what I thought was a breakthrough in betting strategy, reality hit hard.

The Journey to Version 4

The evolution of MMA-AI.net has been a marathon. Version 1 took two years of meticulous development. When ChatGPT emerged, I saw an opportunity to rebuild everything from the ground up. Version 3 emerged after three months of intense work—I'm talking 5 AM bedtimes, night after night.

Then came Version 4, inspired by Chris from wolftickets.ai. His analysis revealed something fascinating: parlays could be more profitable than single picks when accounting for odds. This insight led to another complete overhaul, this time leveraging autoML to eliminate inefficiencies and using ChatGPT for guidance. The results were stunning: 50-60% ROI over six months.

Success Breeds Complacency

Those six months of success? They made me soft. I coasted. My initial $270 investment had grown to $13,000 purely through profit reinvestment—no additional capital needed. The model was working so well that I focused instead on rebuilding this website using Cursor, an AI-powered IDE. Despite knowing nothing about web development, HTML, or CSS, I managed to transform MMA-AI.net from an ad-riddled eyesore into what you see today.

Traffic surged to all-time highs. Everything seemed perfect. Then UFC 309 happened.

The Wake-Up Call

Six parlays. Six losses. 100% drawdown. The rage I'm feeling isn't just about the money—it's about the realization that I've been resting on my laurels. Those six months of coasting caught up with me in the most painful way possible.

This isn't the end of MMA-AI.net. Honestly, it's just what I needed to get my ass in gear and learn some math. I'm already planning the next evolution.

Stay tuned for my next post about where we go from here.

After three years of development, thousands of hours of feature engineering, and endless testing, I finally redid the stupid website. Goodbye ads, hello pretty new design. This platform represents what I believe to be one of the most sophisticated sports prediction models available today.

The past 5 months have been particularly exciting as we've cracked one of the final pieces of the profit-maximization puzzle: the betting strategy. Chris from wolftickets.ai and I knew there had to be a better approach than simply betting straight picks to maximize ROI. Chris was the first to discover it: parlays.

Since both of our models maintain significant accuracy and log loss advantages over Vegas, we can multiply that edge using parlays. Why? Because parlay odds aren't additive—they're multiplicative. Through extensive testing, we've found that 3-leg parlays offer the optimal balance of risk and reward. While 4-leg parlays actually showed higher ROI in testing, their boom-or-bust nature led to more extreme bankroll swings and higher bankruptcy risk. Since implementing the 3-leg strategy five months ago, the model has achieved a 50% ROI.

The Parlay Strategy

Our approach is straightforward: randomly selected AI picks combined into parlays, with no fighter appearing more than twice to prevent single-fighter dependency. The most common question I get is "Why not just parlay the +EV fighters together?" Well, I've tested hundreds of parlay permutations: underdogs only, favorites only, +EV only, 1-5 leg combinations—every variation imaginable—against a year of unseen fight data. Surprisingly, the +EV-only strategies consistently underperformed compared to randomly selected AI pick parlays.

This might seem counterintuitive, but it likely stems from how we're solving a binary classification problem. Our models excel at distinguishing wins (1) from losses (0), but may be less refined at setting precise win probabilities. I train on log loss, not accuracy—log loss being a metric that heavily penalizes confident mistakes while rewarding confident correct predictions. You can see evidence of this in the calibration curve on our About page.

But honestly? I don't care about the "why." Too many people get tunnel vision focusing on EV, which makes sense if you're working without a mathematical model like MMA-AI.net. But when you have a proven model with demonstrable advantages over Vegas odds, the only metric that matters is ROI. And our testing shows that random AI pick parlays consistently deliver the highest returns.

So here's to the new site, the new strategy, and the new model. You can find my predictions posted here on the home page and occasionally on Twitter/X or https://reddit.com/r/mmabetting before each event.