Knowable pool (artists enter only from their first release/play/chart/list/NMF), pooled out-of-sample recalibration (Platt vs isotonic; the site uses pooled Platt per channel, isotonic any channel), release-timing baseline, 8-week bootstrap blocks, surge-rule precision/recall vs the lists with a constant grid (docs/ADDCHECK.md); backtests restructured to score all variants with calibration tables

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-16 00:34:30 +00:00
co-authored by Claude Opus 5.5
parent 94abfa0255
commit 37b3029e02
12 changed files with 767 additions and 339 deletions
+79
View File
@@ -0,0 +1,79 @@
//! Recalibration of predicted probabilities, fitted on pooled out-of-sample forecasts:
//! Platt (a logistic map on the logit) or isotonic regression (pool-adjacent-violators, a
//! monotone step function, interpolated linearly between block centres).
use super::glm::{self, Design};
#[derive(Clone, Debug)]
pub enum Calib {
Identity,
Platt(f64, f64),
/// Knots (predicted, observed), increasing in both.
Iso(Vec<(f64, f64)>),
}
fn logit(p: f64) -> f64 { let p = p.clamp(1e-6, 1.0 - 1e-6); (p / (1.0 - p)).ln() }
impl Calib {
pub fn apply(&self, p: f64) -> f64 {
let out = match self {
Calib::Identity => p,
Calib::Platt(a, b) => glm::sigmoid(a + b * logit(p)),
Calib::Iso(k) => {
if k.is_empty() { p }
else if p <= k[0].0 { k[0].1 }
else if p >= k[k.len() - 1].0 { k[k.len() - 1].1 }
else {
let i = k.partition_point(|x| x.0 <= p);
let ((x0, y0), (x1, y1)) = (k[i - 1], k[i]);
if x1 > x0 { y0 + (y1 - y0) * (p - x0) / (x1 - x0) } else { y1 }
}
}
};
out.clamp(1e-5, 1.0 - 1e-5)
}
/// Platt on pooled (prediction, outcome) pairs; identity if there are too few positives.
pub fn platt(pairs: &[(f64, bool)]) -> Calib {
if pairs.iter().filter(|x| x.1).count() < 10 { return Calib::Identity; }
let mut d = Design::new(2);
for (p, y) in pairs { d.push(&[1.0, logit(*p)], *y as i32 as f64, 1.0); }
let b = glm::logit(&d, 0.0);
if b[1] > 0.0 { Calib::Platt(b[0], b[1]) } else { Calib::Identity }
}
/// Isotonic regression (pool-adjacent-violators) on pooled pairs. A small prior (one pseudo
/// observation at the block's mean prediction) keeps thin blocks off 0 and 1.
pub fn isotonic(pairs: &[(f64, bool)]) -> Calib {
if pairs.iter().filter(|x| x.1).count() < 10 { return Calib::Identity; }
let mut v: Vec<(f64, f64)> = pairs.iter().map(|(p, y)| (*p, *y as i32 as f64)).collect();
v.sort_by(|a, b| a.0.total_cmp(&b.0));
// blocks: (sum p, sum y, n)
let mut blocks: Vec<(f64, f64, f64)> = Vec::new();
for (p, y) in v {
blocks.push((p, y, 1.0));
while blocks.len() >= 2 {
let n = blocks.len();
let (a, b) = (blocks[n - 2], blocks[n - 1]);
if a.1 / a.2 >= b.1 / b.2 { blocks.pop(); blocks.pop(); blocks.push((a.0 + b.0, a.1 + b.1, a.2 + b.2)); } else { break; }
}
}
let knots: Vec<(f64, f64)> = blocks.iter().map(|(sp, sy, n)| { let mp = sp / n; (mp, (sy + mp) / (n + 1.0)) }).collect();
Calib::Iso(knots)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn isotonic_is_monotone_and_fixes_overconfidence() {
// predictions twice too high
let pairs: Vec<(f64, bool)> = (0..20000).map(|i| { let p = (i % 100) as f64 / 100.0; (p, ((i * 7919) % 1000) as f64 / 1000.0 < p / 2.0) }).collect();
let c = Calib::isotonic(&pairs);
let (a, b) = (c.apply(0.2), c.apply(0.8));
assert!(a < b && (a - 0.1).abs() < 0.05 && (b - 0.4).abs() < 0.06, "{a} {b}");
let pl = Calib::platt(&pairs);
assert!(pl.apply(0.8) < 0.6);
}
}