Building a Probabilistic Football Prediction ML Engine

But football is not deterministic.

A good prediction system should not simply return one score and pretend that the prediction is certain.

A more realistic system should calculate probabilities.

For example:

Argentina 2-1 Spain: 13%
Argentina 1-1 Spain: 12%
Argentina 1-0 Spain: 10%
Argentina 2-0 Spain: 9%
Argentina 1-2 Spain: 8%

This is the approach I wanted to follow.

Instead of predicting a single result, the model predicts expected goal intensities for both teams.

For example:

Argentina Expected Goals: 1.82
Spain Expected Goals: 1.27

These expected goal rates can then be converted into a full probability distribution.

The model can calculate:

Argentina Win Probability: 49%
Draw Probability: 26%
Spain Win Probability: 25%

This makes the system probabilistic rather than deterministic.

From a machine learning perspective, this is important because football outcomes contain a large amount of uncertainty.

The goal is not to remove uncertainty.

The goal is to quantify it.

---

# Core Machine Learning Architecture

The core ML pipeline is structured like this:

Historical Football Match Data
            |
            v
Data Cleaning and Validation
            |
            v
Chronological Feature Engineering
            |
            v
Leakage-Safe Rolling Statistics
            |
      +-----+------+
      |            |
      v            v
Poisson       XGBoost
Regression    Count Regression
      |            |
      +-----+------+
            |
            v
Expected Goal Ensemble
            |
      +-----+------+
      |            |
      v            v
Home Goal λ    Away Goal λ
      |            |
      +-----+------+
            |
            v
Exact Score Probability Matrix
            |
     +------+------+
     |      |      |
     v      v      v
Home Win   Draw   Away Win
            |
            v
Top Score Probabilities

The model does not depend on a single algorithm.

Instead, I designed an ensemble architecture.

The core prediction engine combines:

• Poisson Regression
• XGBoost with a Poisson count objective
• Probability distribution modeling
• A lightweight Dixon-Coles-style low-score correction

This gives the system both statistical stability and nonlinear machine learning capability.

---

# Why I Used Poisson Regression

Football goals are count data.

A team can score:

0
1
2
3
4

goals.

The number of goals cannot be negative.

This makes count-based probability models a natural starting point.

Poisson Regression is useful because it models non-negative count outcomes.

In the project, the Poisson model estimates an expected goal intensity:

λ = Expected Number of Goals

For example:

Argentina λ = 1.82
Spain λ = 1.27

These values are not final scores.

They represent the expected scoring rate for each team.

Once we have these values, we can calculate the probability of scoring 0, 1, 2, 3, or more goals.

For example:

P(Argentina scores 0)
P(Argentina scores 1)
P(Argentina scores 2)
P(Argentina scores 3)

The Poisson model provides a strong statistical baseline.

This was important to me because I did not want to build a complex machine learning model without having a simpler benchmark.

A good ML engineering workflow should answer:

That is why Poisson Regression plays an important role in the architecture.

---

# Why I Added XGBoost

Football data contains nonlinear relationships.

For example, the effect of team strength may depend on:

* Opponent strength

* Recent attacking performance

* Recent defensive performance

* xG trend

* xGA trend

* Home advantage

* Competition

* Match importance

* Rest days

A linear model may not capture all these interactions effectively.

That is why I added XGBoost.

The XGBoost model uses a count-based objective:

count:poisson

This allows gradient boosting to predict football goal counts while maintaining a count-focused objective.

The XGBoost model can learn nonlinear patterns such as:

High attacking form
+
Weak opponent defense
+
Positive Elo difference
+
Strong recent xG
=
Higher goal expectation

It can also learn more complex relationships that may not be obvious from simple linear coefficients.

---

# Ensemble Modeling

Instead of selecting only the Poisson model or only the XGBoost model, I combine them.

Conceptually:

Final Expected Goals
=
XGBoost Prediction × Weight
+
Poisson Prediction × Weight

For example:

70% XGBoost
30% Poisson Regression

The exact weight is configurable.

The benefit of this architecture is that each model contributes something different.

Poisson Regression provides:

* Statistical interpretability

* Stable count estimates

* A strong baseline

XGBoost provides:

* Nonlinear learning

* Feature interaction modeling

* Greater flexibility

The final prediction blends both approaches.

This is a practical ensemble strategy that can be extended later with:

* Bayesian models

* Neural networks

* LightGBM

* CatBoost

* Dynamic team-strength models

---

# Exact Score Prediction

Once the system predicts the expected goal intensity for both teams, it creates a score probability matrix.

For every possible score:

P(Home Goals = i)
×
P(Away Goals = j)

The model can estimate probabilities for:

0-0
1-0
0-1
1-1
2-0
2-1
1-2
2-2
3-0
3-1

and so on.

Conceptually, the matrix might look like this:

              Spain Goals

               0      1      2      3

Argentina 0   6.1%   7.8%   4.9%   2.1%

Argentina 1   9.4%  12.2%   7.6%   3.3%

Argentina 2   8.7%  11.3%   7.1%   3.0%

Argentina 3   5.2%   6.8%   4.2%   1.8%

From this matrix, the system calculates match outcome probabilities.

For a home win:

Sum all probabilities where:

Home Goals > Away Goals

For a draw:

Home Goals = Away Goals

For an away win:

Away Goals > Home Goals

This gives mathematically consistent outcome probabilities.

The win, draw, and loss probabilities all come from the same score distribution.

---

# Dixon-Coles-Style Low-Score Adjustment

One limitation of a basic independent Poisson model is that it assumes the goal counts of both teams are independent.

In real football matches, low-scoring results can have dependencies that a simple Poisson model does not fully capture.

For example:

0-0
1-0
0-1
1-1

To improve this, I included a lightweight Dixon-Coles-style low-score correction.

The adjustment modifies the probability of specific low-scoring outcomes.

This helps the model better reflect the behavior of real football matches.

The current implementation is intentionally lightweight.

A more advanced production version could estimate the correlation parameter directly from historical data.

---

# Football Data and Feature Engineering

One of the most important parts of this project is not the algorithm.

It is feature engineering.

A prediction model is only as useful as the information it receives.

The system tracks both:

Team being predicted

and:

Opponent

The model uses a wide set of football features.

Core features include:

Team Elo
Opponent Elo
Elo difference

Recent attacking form:

Recent goals scored
Recent xG
Recent shots
Recent shots on target

Recent defensive form:

Recent goals conceded
Recent xGA
Recent clean-sheet rate

Performance features:

Recent win rate
Recent possession

Opponent features:

Opponent recent goals
Opponent recent goals conceded
Opponent recent xG
Opponent recent xGA
Opponent recent win rate

Contextual features:

Home match
Away match
Neutral venue
Competition
Rest days

Categorical features:

Team
Opponent
Competition

The model uses both numeric and categorical features.

Categorical values are encoded through preprocessing pipelines.

Numeric features are cleaned and processed before reaching the models.

---

# Rolling Team Form

Football teams change over time.

A team's performance from three years ago should not be treated the same as its current form.

That is why the feature engineering pipeline calculates rolling statistics.

For example:

Goals scored in the last 5 matches
Goals conceded in the last 5 matches
Average xG in the last 5 matches
Average xGA in the last 5 matches
Average shots in the last 5 matches
Average shots on target
Recent possession
Recent win rate
Recent clean-sheet rate

Conceptually:

Argentina Recent Form

Goals For: 2.1
Goals Against: 0.9
xG: 1.88
xGA: 0.97
Shots: 14.2
Shots on Target: 5.8
Win Rate: 80%

These statistics dynamically change after each match.

This allows the model to react to recent team performance.

---

# Preventing Data Leakage

Data leakage is one of the biggest risks in sports machine learning.

Imagine predicting a match while accidentally using statistics that already contain information from that same match.

For example:

Predict Argentina vs Spain

but the rolling average already includes Argentina's goals from the Argentina vs Spain match.

The model would appear extremely accurate.

But the evaluation would be completely invalid.

To prevent this, I designed the feature builder chronologically.

For each match:

Step 1:
Calculate all features using previous matches only

Step 2:
Generate training rows

Step 3:
Record the current match result

Step 4:
Update team history

Step 5:
Move to the next match

The current match never contributes to its own pre-match features.

This is one of the most important design decisions in the project.

---

# Why Random Train-Test Splitting Is Dangerous

Many standard machine learning examples use:

train_test_split()

with random shuffling.

That approach is often inappropriate for sports prediction.

Imagine the dataset contains matches from:

2018
2019
2020
2021
2022
2023
2024
2025

A random split might create:

Training:
2025 match

Testing:
2021 match

Now the model has indirectly learned from future football information before predicting an older match.

That is unrealistic.

In production, you can never train on the future.

That is why I use chronological splitting.

For example:

Training:
2018 ---------------- 2023

Testing:
2024 ---------------- 2025

This better simulates real-world prediction.

---

# Time-Aware Model Evaluation

The project evaluates models using a time-aware holdout.

The historical data is sorted chronologically.

Earlier matches are used for training.

Later matches are used for testing.

The evaluation process measures multiple types of model performance.

For goal prediction:

Mean Absolute Error
Root Mean Squared Error
Mean Poisson Deviance

For probabilistic prediction:

Exact Score Negative Log Likelihood
Outcome Brier Score

These metrics measure different properties.

---

# Mean Absolute Error

Mean Absolute Error measures the average difference between predicted goals and actual goals.

Example:

Actual Goals: 2
Predicted Expected Goals: 1.7

Absolute Error: 0.3

Lower is better.

---

# Root Mean Squared Error

RMSE gives greater weight to larger errors.

This is useful because predicting:

0 goals

when a team actually scores:

5 goals

should be penalized more heavily than a small error.

---

# Poisson Deviance

Because the target is count data, Poisson Deviance is a useful evaluation metric.

It evaluates how well the predicted count distribution matches the observed goal counts.

This is more appropriate for count prediction than relying only on standard regression metrics.

---

# Brier Score

Football prediction is not just about choosing the correct winner.

Probability quality matters.

Suppose two models predict Argentina to win.

Model A:

Argentina Win: 51%

Model B:

Argentina Win: 99%

If Argentina loses, Model B should receive a larger penalty because it was far more confident.

The Brier Score measures the quality of probabilistic forecasts.

This makes it useful for evaluating:

Win
Draw
Loss

probabilities.

---

# Exact Score Negative Log Likelihood

I also evaluate how much probability the model assigns to the score that actually happened.

For example:

Actual Score:
Argentina 2-1 Spain

If the model assigned:

P(2-1) = 14%

that contributes differently to the metric than:

P(2-1) = 1%

This helps measure the quality of the entire score distribution rather than only the most likely score.

---

# Formation Prediction Model

Goal prediction and formation prediction are separate machine learning problems.

Because of that, I designed a separate multiclass classifier for formation prediction.

Possible formations include:

4-3-3
4-2-3-1
4-4-2
3-5-2
3-4-2-1

The model can generate probability outputs such as:

4-3-3       58%
4-2-3-1     24%
3-5-2        9%
4-4-2        6%
3-4-2-1      3%

Potential features include:

Team
Opponent
Competition
Team strength
Opponent strength
Recent formation patterns
Match importance
Recent performance

The model is designed as a separate classification task because the prediction target is fundamentally different from goal count prediction.

---

# Starting XI Prediction

The project also includes a player starting-lineup prediction model.

The goal is to estimate:

P(Player Starts)

for each player.

Features can include:

Starts in last 5 matches
Minutes in last 5 matches
Fitness
Injury status
Suspension status
Formation fit
Coach preference
Opponent strength
Match importance
Player position
Team
Opponent

For example:

Player A: 96%
Player B: 91%
Player C: 88%
Player D: 73%

However, selecting the 11 highest probabilities is not enough.

A valid football lineup needs positional structure.

---

# ML Prediction Plus Deterministic Constraints

Suppose the model predicts the highest probabilities for:

3 Goalkeepers
5 Attackers
3 Midfielders

That would not be a valid starting XI.

That is why I separate:

Prediction

from:

Constraint enforcement

The machine learning model predicts the probability that each player starts.

Then deterministic football rules build the final lineup.

For a 4-3-3:

1 Goalkeeper
4 Defenders
3 Midfielders
3 Forwards

For a 4-2-3-1:

1 Goalkeeper
4 Defenders
5 Midfield / Attacking Midfield Players
1 Forward

This architecture reflects a common real-world ML engineering pattern.

Machine learning predicts uncertain outcomes.

Business or domain rules enforce valid final outputs.

---

# Argentina-Focused Football Prediction

Although the project can work with multiple teams, I designed the initial inference use case around Argentina.

The model should not be trained only on Argentina matches.

That dataset would be too small.

Instead:

Multiple Teams
Multiple Competitions
Historical Matches
        |
        v
General Football Learning
        |
        v
Argentina-Specific Features
        |
        v
Argentina Match Prediction

This allows the model to learn general patterns across football.

Then the inference system can focus on:

Argentina vs Spain
Argentina vs Brazil
Argentina vs France

or any other opponent.

---

# Opponent Strength Matters

Scoring three goals against a weak defensive team is not equivalent to scoring three goals against an elite defensive team.

That is why the model includes opponent context.

Important features include:

Team Elo
Opponent Elo
Elo difference
Opponent recent goals conceded
Opponent xGA
Opponent clean-sheet rate

Conceptually:

Argentina Attack Strength
        vs
Spain Defensive Strength

and:

Spain Attack Strength
        vs
Argentina Defensive Strength

This is much more meaningful than looking only at Argentina's recent scores.

---

# Elo-Based Team Strength

Elo ratings provide a dynamic way to estimate team strength.

Each team has a rating.

After each match, ratings can change based on:

Expected result
Actual result
Opponent strength

A higher-rated team beating a much weaker team may gain only a small amount.

A weaker team beating a stronger team may gain much more.

The model uses features such as:

team_elo
opponent_elo
elo_difference

This gives the system a high-level measure of relative team quality.

---

# Rest Days

Player fatigue can influence match performance.

That is why the feature builder tracks:

Days since the team's previous match

and:

Opponent days since previous match

For example:

Argentina Rest Days: 4
Spain Rest Days: 7

This feature becomes especially interesting in tournament football where teams may play multiple knockout matches within a short period.

---

# Neutral Venue Modeling

International tournaments are often played at neutral venues.

The model distinguishes between:

Home match
Away match
Neutral venue

This is important because traditional home advantage may not apply in a World Cup final.

---

# Competition Context

Not all football matches have the same intensity.

A friendly match is different from:

World Cup Final
Copa America Final
World Cup Qualifier
European Championship
Knockout Match

The model includes competition as a categorical feature.

Future versions can expand this with:

Tournament stage
Knockout indicator
Final indicator
Semi-final indicator
Match importance score

---

# Data Pipeline

The project follows a structured ML pipeline.

Raw Football Data
        |
        v
Validation
        |
        v
Cleaning
        |
        v
Chronological Sorting
        |
        v
Feature Engineering
        |
        v
Training Dataset
        |
        v
Model Training
        |
        v
Evaluation
        |
        v
Model Artifacts
        |
        v
Inference API

This separation makes the project easier to maintain and extend.

---

# Project Structure

The repository is organized like a production ML project.

football-prediction-ml-engine/
│
├── README.md
├── MODEL_CARD.md
├── requirements.txt
├── pyproject.toml
├── Dockerfile
├── Makefile
│
├── data/
│   ├── raw/
│   ├── processed/
│   └── demo/
│
├── artifacts/
│
├── reports/
│
├── scripts/
│   ├── generate_demo_data.py
│   ├── train_goal_model.py
│   ├── train_formation_model.py
│   ├── train_lineup_model.py
│   ├── train_all.py
│   └── demo_prediction.py
│
├── src/
│   └── argentina_football_ml/
│       ├── features.py
│       ├── evaluation.py
│       ├── schemas.py
│       │
│       ├── models/
│       │   ├── goal_ensemble.py
│       │   ├── score_distribution.py
│       │   ├── formation.py
│       │   └── lineup.py
│       │
│       ├── inference/
│       │   └── predictor.py
│       │
│       ├── api/
│       │   └── main.py
│       │
│       └── data/
│           └── statsbomb_adapter.py
│
└── tests/

This architecture demonstrates separation of responsibilities.

---

# Feature Builder

The feature builder is one of the most important parts of the project.

Its responsibilities include:

Validating match data
Sorting matches chronologically
Maintaining team histories
Calculating rolling statistics
Preventing current-match leakage
Creating team-perspective rows
Exporting current team state
Generating future fixture features

Each match is transformed into two supervised examples.

Example:

Argentina vs Spain

becomes:

Training Row 1

Team: Argentina
Opponent: Spain
Target: Argentina Goals

and:

Training Row 2

Team: Spain
Opponent: Argentina
Target: Spain Goals

This allows the same model to learn goal behavior from both teams.

---

# Data Preprocessing

The model uses different preprocessing pipelines for numeric and categorical features.

Numeric features may include:

Elo
Goals
xG
Shots
Rest days
Possession
Win rate

Categorical features include:

Team
Opponent
Competition

The preprocessing pipeline handles:

Missing numeric values
Missing categorical values
One-hot encoding
Feature scaling where required

The Poisson model uses scaled numerical inputs.

The XGBoost model does not require the same numeric scaling.

This is handled through separate pipelines.

---

# Model Serialization

After training, models are stored using Joblib.

Artifacts include:

goal_ensemble.joblib
formation_model.joblib
lineup_model.joblib
team_state.json
model_metadata.json