diff --git a/docs/COMEBACKS.md b/docs/COMEBACKS.md new file mode 100644 index 0000000..43e0ec8 --- /dev/null +++ b/docs/COMEBACKS.md @@ -0,0 +1,46 @@ +# Comebacks (τ = 20 total DR plays a week; an add = on, then on again in 2 of the next 3 weeks, after 8 weeks under τ) + +## Adds, archive 2019-24: 745 + +| before the add | adds | share | discography known | release 8w before–1w after | NMF DK 8w before–1w after | release or NMF | +|---|---|---|---|---|---|---| +| active in the last 26 weeks (back after 8-25 weeks off) | 202 | 27% | 92% | 50% | 20% | 53% | +| quiet 26w, former favourite (4+ weeks on DR before) | 108 | 14% | 94% | 59% | 36% | 63% | +| quiet 26w, played before but never on | 335 | 45% | 75% | 49% | 15% | 51% | +| quiet 26w, no older data | 24 | 3% | 96% | 46% | 8% | 46% | +| too little data to tell | 76 | 10% | 83% | 57% | 13% | 59% | + +Examples, former favourites: Søren Huss (2024-04-15), Carpark North (2023-10-30), Maroon 5 (2020-09-14), Michael Bublé (2023-11-27), Nephew (2020-03-30), Calvin Harris (2020-09-07), S.O.A.P. (2023-11-27), KH Marie (2023-05-01), Adele (2020-09-21), Lady Gaga (2021-05-17), Caroline Polachek (2022-12-19), Kellermensch (2022-05-09) + +## Adds, current panel 2025-26: 155 + +| before the add | adds | share | discography known | release 8w before–1w after | NMF DK 8w before–1w after | release or NMF | +|---|---|---|---|---|---|---| +| active in the last 26 weeks (back after 8-25 weeks off) | 28 | 18% | 100% | 50% | 54% | 54% | +| quiet 26w, former favourite (4+ weeks on DR before) | 23 | 15% | 100% | 74% | 61% | 83% | +| quiet 26w, played before but never on | 42 | 27% | 90% | 67% | 48% | 76% | +| quiet 26w, no older data | 5 | 3% | 100% | 60% | 60% | 80% | +| too little data to tell | 57 | 37% | 96% | 60% | 51% | 74% | + +Examples, former favourites: The Strokes (2026-04-06), Agnes (2026-04-27), Astrid Engberg (2026-08-31), Stromae (2026-06-15), Jungle (2026-04-06), Lowly (2026-08-10), Stormzy (2026-04-27), Maximillian (2026-05-25), Phoebe Bridgers (2026-08-17), KOPS (2026-04-13), Peggy Gou (2026-07-13), beabadoobee (2026-05-04) + +## After a release, quiet artists (under τ for 26 weeks): add in the release week or the 4 after + +| period | artist | releases | adds | rate (90% CI) | +|---|---|---|---|---| +| archive 2019-24 | quiet 26w, former favourite (4+ weeks on DR before) | 387 | 30 | 7.8% (5.8–10.3%) | +| archive 2019-24 | quiet 26w, played before but never on | 4815 | 80 | 1.7% (1.4–2.0%) | +| archive 2019-24 | quiet 26w, no older data | 709 | 8 | 1.1% (0.6–2.0%) | +| current panel 2025-26 | quiet 26w, former favourite (4+ weeks on DR before) | 188 | 8 | 4.3% (2.4–7.4%) | +| current panel 2025-26 | quiet 26w, played before but never on | 2689 | 9 | 0.3% (0.2–0.6%) | +| current panel 2025-26 | quiet 26w, no older data | 432 | 2 | 0.5% (0.2–1.4%) | + +Discographies (Deezer) known for 7980 of 20924 artists (7980 of the 8786 in today's pool). + +## Adds with a discography but no release nearby (current panel, 58 cases, first 25 read by hand) + +- **Throwbacks and old songs** (Colby O'Donis, The Calling, Sean Kingston, MAGIC!, Echosmith): back on air with an old hit, no release at all. +- **No usable Deezer data** (Den Danske Strygekvartet, Folkeklubben, Christian Ki, L.I.G.A., Nikolaj Vonsild, Tobias Laust): Danish acts with nothing near the add date. +- **Added before the release** (Stormzy +4 weeks, Mitski +4 weeks, The Calling +7 weeks): radio plays a single before Deezer lists it. A listing of released music can't see this; it needs announced or radio dates. +- **A later track from an album** (Agnes, Iceage, Dave, Rob Thomas): picked up 2–4 months after the release. +- One junk artist ("Ukendt Kunstner"). diff --git a/src/model/long.rs b/src/model/long.rs index 0ee8e54..fd1f8a7 100644 --- a/src/model/long.rs +++ b/src/model/long.rs @@ -337,3 +337,95 @@ pub fn run(db: &Db, p: &Panel, tau: f64, win: usize, stay: usize) -> Result Result { + const Q: usize = 26; // "quiet" = under τ in each of the 26 weeks before + let l = Long::load(db, p)?; + let na = l.artists.len(); + let on = |a: usize, w: usize| l.y(a, w) >= tau; + let same_era = |a: usize, b: usize| (a < l.cur0) == (b < l.cur0); + // Sustained add at week s: on at s, on in 2 of s+1..s+3, under τ the 8 weeks before, all observed. + let is_add = |a: usize, s: usize| -> bool { + s >= OFF && s + 3 < l.w() && same_era(s - OFF, s + 3) && (s - OFF..=s + 3).all(|w| l.obs(a, w)) + && on(a, s) && (s + 1..=s + 3).filter(|&w| on(a, w)).count() >= 2 && (s - OFF..s).all(|w| !on(a, w)) + }; + // What the artist was before week s. + #[derive(Clone, Copy, PartialEq)] + enum Kind { Active, Favourite, Seen, NoOld, Unknown } + let kind = |a: usize, s: usize| -> Kind { + if s < Q { return Kind::Unknown; } + let recent: Vec = (s - Q..s).filter(|&w| l.obs(a, w)).collect(); + if recent.len() < Q * 4 / 5 { return Kind::Unknown; } + if recent.iter().any(|&w| on(a, w)) { return Kind::Active; } + let old: Vec = (0..s - Q).filter(|&w| l.obs(a, w)).collect(); + if old.is_empty() { return Kind::NoOld; } + if old.iter().filter(|&&w| on(a, w)).count() >= 4 { Kind::Favourite } else { Kind::Seen } + }; + let names = ["active in the last 26 weeks (back after 8-25 weeks off)", "quiet 26w, former favourite (4+ weeks on DR before)", + "quiet 26w, played before but never on", "quiet 26w, no older data", "too little data to tell"]; + let idx = |k: Kind| match k { Kind::Active => 0, Kind::Favourite => 1, Kind::Seen => 2, Kind::NoOld => 3, Kind::Unknown => 4 }; + let near = |a: usize, s: usize, before: i64, after: i64| -> (bool, bool) { + let d = l.weeks[s]; + let rel = l.releases[a].as_ref().is_some_and(|r| r.iter().any(|x| *x >= d - Duration::weeks(before) && *x <= d + Duration::days(7 * after + 6))); + let nmf = l.nmf[a].iter().any(|(x, _)| *x >= d - Duration::weeks(before) && *x <= d + Duration::days(7 * after + 6)); + (rel, nmf) + }; + + let mut md = String::new(); + let _ = writeln!(md, "# Comebacks (τ = {tau} total DR plays a week; an add = on, then on again in 2 of the next 3 weeks, after 8 weeks under τ)\n"); + for (label, lo, hi) in [("archive 2019-24", 0, l.cur0), ("current panel 2025-26", l.cur0, l.w())] { + // [kind][era]: adds, discography known, release -8w..+1w, NMF -8w..+1w, either + let mut c = [[0usize; 5]; 5]; + let mut ex: Vec> = vec![Vec::new(); 5]; + for a in 0..na { for s in lo.max(OFF)..hi { if is_add(a, s) { + let k = idx(kind(a, s)); + let (r, n) = near(a, s, 8, 1); + c[k][0] += 1; c[k][1] += l.releases[a].is_some() as usize; c[k][2] += r as usize; c[k][3] += n as usize; c[k][4] += (r || n) as usize; + if ex[k].len() < 12 { ex[k].push(format!("{} ({})", l.artists[a].name, l.weeks[s])); } + } } } + let total: usize = c.iter().map(|r| r[0]).sum(); + let _ = writeln!(md, "## Adds, {label}: {total}\n\n| before the add | adds | share | discography known | release 8w before–1w after | NMF DK 8w before–1w after | release or NMF |\n|---|---|---|---|---|---|---|"); + for k in 0..5 { + let r = c[k]; let pc = |x: usize| if r[0] > 0 { format!("{:.0}%", 100.0 * x as f64 / r[0] as f64) } else { "—".into() }; + let _ = writeln!(md, "| {} | {} | {} | {} | {} | {} | {} |", names[k], r[0], if total > 0 { format!("{:.0}%", 100.0 * r[0] as f64 / total as f64) } else { "—".into() }, pc(r[1]), pc(r[2]), pc(r[3]), pc(r[4])); + } + let _ = writeln!(md, "\nExamples, former favourites: {}\n", ex[1].join(", ")); + } + + // Releases by quiet artists (Deezer, none in the 6 weeks before): add within the release week + 4? + let _ = writeln!(md, "## After a release, quiet artists (under τ for 26 weeks): add in the release week or the 4 after\n"); + let _ = writeln!(md, "| period | artist | releases | adds | rate (90% CI) |\n|---|---|---|---|---|"); + for (label, lo, hi) in [("archive 2019-24", 0, l.cur0), ("current panel 2025-26", l.cur0, l.w())] { + let mut c = [[0usize; 2]; 5]; + for a in 0..na { + let Some(rel) = &l.releases[a] else { continue }; + let mut prev: Option = None; + for d in rel { + let fresh = prev.is_none_or(|p| (*d - p).num_weeks() >= 6); + prev = Some(*d); + if !fresh { continue; } + let Some(s0) = l.weeks.iter().position(|w| *w <= *d && *d < *w + Duration::weeks(1)) else { continue }; + if s0 < lo || s0 + 4 + 3 >= hi || !(s0..=s0 + 7).all(|w| l.obs(a, w)) { continue; } + let k = kind(a, s0); + if k == Kind::Active || k == Kind::Unknown { continue; } + c[idx(k)][0] += 1; + c[idx(k)][1] += (s0..=s0 + 4).any(|s| is_add(a, s)) as usize; + } + } + for k in 1..4 { + let (n, x) = (c[k][0] as f64, c[k][1] as f64); + if n == 0.0 { continue; } + // Wilson 90% interval + let (ph, z) = (x / n, 1.645f64); + let den = 1.0 + z * z / n; + let mid = (ph + z * z / (2.0 * n)) / den; + let half = z * (ph * (1.0 - ph) / n + z * z / (4.0 * n * n)).sqrt() / den; + let _ = writeln!(md, "| {label} | {} | {} | {} | {:.1}% ({:.1}–{:.1}%) |", names[k], n, x, 100.0 * ph, 100.0 * (mid - half).max(0.0), 100.0 * (mid + half)); + } + } + let looked = (0..na).filter(|&a| l.releases[a].is_some()).count(); + let _ = writeln!(md, "\nDiscographies (Deezer) known for {looked} of {na} artists ({} of the {} in today's pool).", (0..p.a()).filter(|&a| l.releases[a].is_some()).count(), p.a()); + Ok(md) +} diff --git a/src/model/mod.rs b/src/model/mod.rs index 8eb27e9..71a8557 100644 --- a/src/model/mod.rs +++ b/src/model/mod.rs @@ -10,6 +10,7 @@ //! airplay model events [--out docs/BACKTEST-EVENTS.md] backtest of the release-event model //! airplay model adds [--h 0,4] [--out docs/BACKTEST-ADDS.md] backtest of the new-add model //! airplay model long [--tau 20] [--w 2] [--stay 3] [--out docs/LONG.md] 2019– any-DR model, all years vs 1 year +//! airplay model comebacks [--tau 20] [--out docs/COMEBACKS.md] //! airplay model rank [--h 4] [--max-h 12] [--top 50] pub mod addcheck; @@ -99,6 +100,12 @@ pub fn run(db: &Db, args: &[String]) -> Result<()> { if let Some(out) = arg(args, "--out") { std::fs::write(out, &md)?; } print!("{md}"); } + Some("comebacks") => { + let tau: f64 = arg(args, "--tau").and_then(|s| s.parse().ok()).unwrap_or(20.0); + let md = long::comebacks(db, &p, tau)?; + if let Some(out) = arg(args, "--out") { std::fs::write(out, &md)?; } + print!("{md}"); + } Some("leakcheck") => { print!("{}", leakcheck::run(&p)?); } Some("addcheck") => { if let Some(r) = arg(args, "--rule") { let _ = adds::ADD_RULE.set(r); }