File size: 3,318 Bytes
0040de1 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 | """Which lc0 self-play runs to draw from, and in what proportion.
Tiers follow generation quality: the networks producing the games get weaker as
you go down, so the lower tiers contribute noisier, more exploratory positions.
Keeping a minority of them is deliberate — a corpus drawn only from the strongest
run is narrow in exactly the way this corpus is meant not to be.
Availability was surveyed against storage.lczero.org on 2026-08-25 and differs
from the run list usually quoted:
* test70, test77, test76, test50, test20 and test10 are not hosted at all.
* test78 and test90 exist but every tar is a 10 KB placeholder.
* test80's retained window now starts 2024-04-01; earlier tars were pruned.
* test80 stopped producing on 2025-09-24. test91 is the live run.
* test71 is the Chess960 run — measured 30-36% Chess960 against at most 1.2%
elsewhere — so it is excluded rather than tiered. test71_5 measured 0%.
Named substitutes for the missing runs stay in era and strength order:
test79 and test75 stand in for T70/T78 in the mid tier, test71_5 for T50.
"""
from __future__ import annotations
from dataclasses import dataclass, field
@dataclass(frozen=True)
class Run:
name: str
# Restrict to a slice of the run's date-sorted tars, as "late test60" and
# "early test60" belong to different tiers.
first: float = 0.0
last: float = 1.0
weight: float = 1.0
@dataclass(frozen=True)
class Tier:
name: str
share: float
runs: tuple[Run, ...]
note: str = ""
TIERS: tuple[Tier, ...] = (
Tier(
"strong",
0.60,
(Run("test80", weight=2.0), Run("test91", weight=1.0)),
"Mature run1 plus the live run2. Core modern play.",
),
Tier(
"mid",
0.22,
(Run("test79"), Run("test75"), Run("test60", first=0.60)),
"Late-T60 through T79: transitional styles, sound but more varied.",
),
Tier(
"low",
0.13,
(Run("test40"), Run("test60", last=0.35), Run("test71_5", weight=0.5)),
"2019-2020 nets. Messier tactics and unusual structures.",
),
Tier(
"early",
0.05,
(Run("test30"), Run("run3", weight=0.5)),
"2018-2019 semi-initial play. Kept small; maximum noise.",
),
)
EXCLUDED = {
"test71": "Chess960 run; 30-36% of positions are Chess960",
"test78": "all tars are 10 KB placeholders",
"test90": "all tars are 10 KB placeholders",
}
def quotas(total: int) -> dict[str, int]:
"""Positions per tier, with the rounding residue given to the largest."""
assigned = {tier.name: int(total * tier.share) for tier in TIERS}
largest = max(TIERS, key=lambda t: t.share).name
assigned[largest] += total - sum(assigned.values())
return assigned
def run_quotas(tier: Tier, tier_total: int) -> dict[str, int]:
"""Positions per (run, slice) inside one tier, split by run weight."""
total_weight = sum(r.weight for r in tier.runs)
out: dict[str, int] = {}
for run in tier.runs:
key = f"{run.name}:{run.first:.2f}-{run.last:.2f}"
out[key] = int(tier_total * run.weight / total_weight)
residue = tier_total - sum(out.values())
if out:
out[next(iter(out))] += residue
return out
assert abs(sum(t.share for t in TIERS) - 1.0) < 1e-9
|