🇨🇦 Canadian Grand Prix

How these predictions are made

The number in each cell is the fraction of 10,000 simulated races where that driver hit that result. The simulator draws from three Bayesian models fit on every clean-air race lap from 2018 to today.

The rest of this page is a long, technical explanation of the model. If you just want to read the table and move on, you can stop here.

What each column means

Three models, five markets — why the count differs

The three models capture three independent statistical objects you can fit from F1 data: race-stint pace, single-lap pace, and finish/DNF. Of the five markets, Pole comes from the qualifying model alone, Finish from the reliability model alone, and Win / Podium / Points are not separate predictions — they're the same race-outcome distribution counted at finish-position thresholds of 1, 3, and 10. Counting from a single simulation guarantees P(win) ≤ P(podium) ≤ P(points) automatically.

The pace model — full specification

Fits clean-air race lap times. ~135,000 rows, one per (session, driver, lap) for every clean lap 2018–2026. A clean lap is IsAccurate + green track + not pit-in/out + not stint-warmup + not stint-final.

log(lap_time_s)  =  β_team_year[s, t]
                  +  γ_circuit[s, r]
                  +  δ_compound[c]
                  +  φ_fuel  · fuel_lap_norm
                  +  ψ_tyre  · tyre_age
                  +  ε
        ε  ~  Normal(0, σ)

Non-centred reparameterisation

Hierarchical Bayesian models fit better when you decouple the scale parameter from the unit-effects. Internally the model stores z_team_year ~ Normal(0, 1) and constructs β_team_year = σ_team_year × z_team_year. NUTS samples through this much more cleanly than the centred form, which is why every coefficient in the model has the same trick.

The qualifying model

Fits a single observation per (session, driver) — the fastest single lap that driver set across Q1/Q2/Q3.

log(best_lap_s)  =  β_team_year[s, t]
                  +  γ_circuit[s, r]
                  +  δ_segment[Q1 / Q2 / Q3]
                  +  ε
        ε  ~  Normal(0, σ)

Same priors as the pace model for β_team_year, γ_circuit, and σ. No fuel or tyre slope — quali is single-lap, low-fuel, fresh tyres. δ_segment captures track evolution: the same driver's identical effort in Q1 vs Q3 logs different times because the track rubbers in. Without this, drivers who only progressed to Q1 would look slower than they are.

The reliability model

Bernoulli on whether each (driver, race) ended in DNF. One row per driver per race; ~500 rows per season × 8 seasons.

logit(P_DNF)  =  μ_dnf
              +  β_team_year[s, t]
              +  γ_circuit[circuit_id]
is_dnf  ~  Bernoulli(sigmoid(logit_P_DNF))

Different from pace/quali in three ways:

• Likelihood family. Bernoulli with a logit link, not Gaussian on log-time. Same hierarchical-Normal priors on the coefficients, applied through the logit transform.
• Circuit identifier. Uses the canonical Ergast circuit_id pooled across years, not (season, round). Monaco is persistently accident-prone in 2018 and 2024 alike — pooling concentrates that signal. With ~22 races/season × 20 drivers = 440 rows/season per circuit, splitting by (season, round) would dilute it.
• Population baseline. μ_dnf ~ Normal(-2, 1) centres the prior on a ~12% DNF rate (sigmoid of -2), close to the long-run F1 average. Per-team and per-circuit effects shift this up or down on the logit scale.

How we fit the posteriors

Both NUTS (No-U-Turn Sampler, gradient-based MCMC) and SVI (Stochastic Variational Inference, fast approximation) are supported. NUTS is the default for production runs — slower but exact, sampling roughly 500 warmup + 500 posterior draws per model. SVI uses an AutoNormal guide and is used during development for fit-window experimentation. Both produce the same shape of output: a sample-by-coefficient array that the simulator draws from.

Posteriors are content-addressed by their inputs hash (since, until, method, n_rows, n_drivers, n_teams, num_samples) and cached on disk, so refitting on the same data is a no-op. That's how the per-session workflow stays cheap: the heavy NUTS fit runs weekly, intra-weekend session updates reuse the cached posterior.

Leak-free temporal cutoff

Every fit uses an as_of timestamp that defaults to one second before the target race's qualifying session. Training data filters to laps and results that finished before that timestamp. This is what makes backtesting honest: the 2024 Imola prediction sees only the data the model would have had at the moment of qualifying, not the race outcome it's trying to predict.

The simulator — step by step

1. Draw one joint sample from the three posteriors (one realisation of all coefficients).
2. For each driver, compute predicted log-lap-time as β_team_year[2026, their team] + γ_circuit[2026 R5]. (When the target race's circuit cell isn't in the encoder — typical for upcoming rounds — fall back to μ_circuit.)
3. For each of the 60-ish laps, draw a multiplicative noise term (1 + σ × Normal(0, 1)) and apply it to the driver's lap time.
4. Sum the laps → race time.
5. Roll a DNF outcome from Bernoulli(sigmoid(μ_dnf + β_rel + γ_rel)).
6. Compute quali time the same way as race lap time but using the quali model's posteriors → quali rank.
7. Sort drivers by race time. DNFs go to position 0 (sentinel).
8. Record finish position, quali rank, race time, DNF flag for each driver.
9. Repeat 10,000 times. Aggregate fractions per market.

Identifiability and design choices

A few non-obvious model decisions, and why:

• No driver effect (α_driver). Driver and team are colinear in F1 data — drivers move teams rarely, so a per-driver / per-team coefficient pair fits non-uniquely. With weak priors the fit collapses on whichever side gets first dibs and rankings come out garbled. With tight priors it doesn't recover. The fix is a separate residual model fit on within-team-year teammate gaps, where the colinearity disappears (you're comparing two drivers in the same car). That's planned for v2.
• Per-(season, round) circuit cells, not per-circuit. The same physical track is a different race in different years (regulations change, tarmac is resurfaced, weather differs). Pooling across years would smear those changes. The reliability model is the exception — DNF rates are dominated by track geometry, which is stable.
• AR(1) cross-year structure for β_team_year (added 2026-05-08). Each team's per-year effect is now a Gaussian random walk across seasons: β[s, t] = β[s-1, t] + ε with ε ~ Normal(0, σ_year_step). Last season is the prior mean for this season, so strong recent form gets absorbed without having to overcome an at-zero prior. Sum-to-zero per year removes the identifiability ambiguity with μ_circuit.
• Pace model has no α_driver, but lap noise σ absorbs driver-skill variance. This means the lap noise is wider than it should be, which is part of why team gaps had to fight uphill against the data.

What's NOT in the model

• No driver effect. Drivers in the same (season, team) predict identically. Verstappen and his teammate get the same race-pace forecast. The gap you sometimes see between teammates in this table is pure Monte Carlo noise.
• No track-position effect. The race simulator does not use grid position to determine race outcome. A car predicted to be slowest in qualifying but fastest in race trim would still "win" the simulation. Monaco predictions in particular will look wrong because real Monaco is ~80% determined by qualifying.
• Year-to-year drift prior is a single parameter. σ_year_step is shared across all teams. In reality some teams' form is stable (McLaren 2024-2026), others volatile (Williams across regulation changes). Per-team year-step variance is a v3 enhancement.
• No tyre-strategy model. Pit-stop timing, undercut/overcut effects, 1-stop vs 2-stop choices are not modelled. The pace model captures average stint pace; the strategic decisions made on top of that aren't.
• No weather conditions. Wet vs dry races have completely different pace orderings, and the model treats them identically.
• No live form features — practice times, sprint results, mid-session tyre data, free-practice fuel-corrected pace. These exist in the data but don't feed the model.

The page reflects engine output verbatim. Every number above came out of the simulator, not editorial judgement. If a column looks wrong, the fix lives in the model, not in the display.