Auto labels reviewed per station and cross-reviewed; all labeling knowledge in labeling/ (D-130)

- Every station's auto labels reviewed by an analyst (/review-auto-labels), then a
  cross-review per family across all stations (new skill /cross-review-labels),
  a finishing pass, and descriptions rewritten in words (no numeric values).
- The three never-labeled ranges (WILDSTRUBEL 07/09-01/10, NORDEND 16/08-01/10)
  labeled and reviewed: 991 auto labels on 11 stations, labeling/controle.py at 0 errors.
- Labeling knowledge gathered in labeling/: regles-d-etiquetage.md (new), familles.md
  (settled boundaries), connaissances/ (notes moved from docs/, links updated),
  the label map rebuilt from reviewed labels, events and cases; events tied to their
  stations (PS_DES_COUDRES is JUNGFRAU). The labeler and reviewers read only labeling/.
- labels-map reads auto labels and events; decision D-130; living plan points 73-75.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
maximeandClaude Opus 5.5 committed 2026-11-05 08:21:57 +01:00
1 parent 8e1cfc52c9
commit 35b5ed4d74
298 files changed
+30413 -960

No files matched your search

@@ -0,0 +1,32 @@
"""Le bruit de jour est-il un bruit rapide (turbulence) ou une courbe lente mal compensée ?
Pour chaque cible, les pas d'une mesure à la suivante (Δcorr, mesures acceptées, cadence régulière) ;
corrélation de deux pas qui se suivent : vers -0,5 pour un bruit blanc (le point revient), vers 0 ou plus
pour une dérive ou une vague. Médiane sur les cibles, par tranche d'heures UTC données.
Usage (depuis la racine) : python3 alternance.py STATION DEBUT FIN H1-H2 [H1-H2 ...]
"""
import sys, statistics as st
sys.path.insert(0, "agent-tools")
import donnees as d
nom, t1, t2 = sys.argv[1], d.instant(sys.argv[2]), d.instant(sys.argv[3])
tranches = [tuple(map(int, a.split("-"))) for a in sys.argv[4:]]
dans = lambda h, a, b: a <= h < b if a < b else (h >= a or h < b)
par = d.charger(f"data/{nom}")
cib = {s: [m for m in d.filtrer(ms, t1, t2) if m["corr_x"] is not None] for s, ms in par.items() if not d.est_reference(ms)}
ts = sorted({m["t"] for ms in cib.values() for m in ms})
cad = st.median([(b - a).total_seconds() for a, b in zip(ts, ts[1:])])
for a, b in tranches:
rs, ampl = [], []
for s, ms in cib.items():
for q in ("corr_x", "corr_y"):
p1, p2 = [], []
for m0, m1, m2 in zip(ms, ms[1:], ms[2:]):
if (m2["t"] - m0["t"]).total_seconds() > 2.5 * cad or not dans(m1["t"].hour, a, b):
continue
p1.append(m1[q] - m0[q]); p2.append(m2[q] - m1[q])
if len(p1) > 20 and st.pstdev(p1) > 0 and st.pstdev(p2) > 0:
rs.append(st.correlation(p1, p2)); ampl.append(st.median(abs(x) for x in p1))
print(f"{nom} {a:02d}-{b:02d} UTC : corrélation de deux pas voisins {st.median(rs):+.2f} "
f"(médiane de {len(rs)} séries), pas médian {st.median(ampl):.4f}")
@@ -0,0 +1,63 @@
"""Bords d'étiquettes : les courbes bougent-elles avant le début ou après la fin ?
Pour une étiquette (STATION#ligne) : niveau (médiane) et bruit (MAD) de chaque cible sur [debut-6h, debut-3h] (avant)
et [fin+3h, fin+6h] (après) ; puis, mesure par mesure de debut-3h à debut et de fin à fin+3h,
le nombre de cibles dont corr_x ou corr_y sort de K bruits de ce niveau ('r' ajouté s'il y a des rejets
de plus qu'au niveau). Une suite qui monte vers le début, ou qui ne retombe pas après la fin,
dit une borne posée trop tard ou trop tôt.
Usage (depuis la racine) : python3 bords.py [--k 5] [--h 3] ID [ID ...]
"""
import sys, json, statistics as st
from datetime import timedelta
sys.path.insert(0, "agent-tools")
import donnees as d
args = sys.argv[1:]
K = float(args[args.index("--k") + 1]) if "--k" in args else 5
H = float(args[args.index("--h") + 1]) if "--h" in args else 3
ids = [a for a in args if "#" in a]
cache = {}
for i in ids:
nom, n = i.split("#")
e = json.loads(open(f"labeling/auto/{nom}.jsonl").readlines()[int(n) - 1])
t1, t2 = d.instant(e["debut"]), d.instant(e["fin"])
if nom not in cache:
cache[nom] = d.charger(f"data/{nom}")
par = cache[nom]
cib = {s: ms for s, ms in par.items() if not d.est_reference(ms)}
idx = {s: {m["t"]: m for m in ms} for s, ms in cib.items()}
h = timedelta(hours=H)
def niveau(a, b):
out = {}
for s, ms in cib.items():
w = [m for m in d.filtrer(ms, a, b) if m["corr_x"] is not None]
if len(w) >= 4:
out[s] = {}
for q in ("corr_x", "corr_y"):
med = st.median(m[q] for m in w) # bruit : MAD de la fenêtre (une dérive thermique lente y tient)
out[s][q] = (med, max(st.median(abs(m[q] - med) for m in w), 1e-4))
return out
def suite(a, b, niv):
inst = sorted({m["t"] for ms in cib.values() for m in d.filtrer(ms, a, b)})
txt = []
for t in inst:
n = r = 0
for s, ms in cib.items():
m = idx[s].get(t)
if m is None or s not in niv:
continue
if m["corr_x"] is None:
r += 1
elif any(abs(m[q] - niv[s][q][0]) > K * niv[s][q][1] for q in ("corr_x", "corr_y")):
n += 1
txt.append(f"{min(n, 9)}{'r' if r else ''}")
return " ".join(txt)
av = niveau(t1 - 2 * h, t1 - h)
ap = niveau(t2 + h, t2 + 2 * h)
print(f"{i} {e['debut']} -> {e['fin']} ({len(cib)} cibles, K={K:g})")
print(f" avant ({H:g} h) : {suite(t1 - h, t1, av)} | début")
print(f" après ({H:g} h) : fin | {suite(t2, t2 + h, ap or av)}")
@@ -0,0 +1,67 @@
"""Bruit rapide des courbes corrigées, heure par heure et jour par jour, pour une station.
Bruit d'une cible à une heure : médiane des écarts de chaque mesure acceptée au milieu de ses deux voisines
(trois mesures en moins de 3 cadences ; une dérive lente, thermique, s'y annule),
corr_x et corr_y ensemble ; bruit de la station : médiane sur les cibles. Profil du lot par heure UTC ;
puis, par jour, le bruit des 6 heures les plus bruitées du profil face aux 6 plus calmes (rapport),
et si une étiquette Visibility de labeling/auto/ couvre la moitié des heures bruitées ce jour-là.
Usage (depuis la racine) : python3 bruit.py STATION DEBUT FIN [--propre] [--cibles]
"""
import sys, json, statistics as st
from datetime import timedelta
sys.path.insert(0, "agent-tools")
import donnees as d
st_nom, t1, t2 = sys.argv[1], d.instant(sys.argv[2]), d.instant(sys.argv[3])
PROPRE = "--propre" in sys.argv # retire à chaque instant la part commune à toutes les cibles (médiane signée) :
# reste le bruit propre de chaque cible (turbulence) ; une pose mal compensée, commune, s'en va
par = d.charger(f"data/{st_nom}")
cib = {s: d.filtrer(ms, t1, t2) for s, ms in par.items() if not d.est_reference(ms)}
ts = sorted({m["t"] for ms in cib.values() for m in ms})
cad = st.median([(b - a).total_seconds() for a, b in zip(ts, ts[1:])])
ecarts = {} # (cible, instant) -> (ex, ey) signés
for s, ms in cib.items():
ok = [m for m in ms if m["corr_x"] is not None]
for a, b, c in zip(ok, ok[1:], ok[2:]):
if (c["t"] - a["t"]).total_seconds() > 3 * cad:
continue
ecarts[(s, b["t"])] = tuple(b[q] - (a[q] + c[q]) / 2 for q in ("corr_x", "corr_y")) # une dérive lente s'annule
commun = {}
if PROPRE:
par_t = {}
for (s, t), e in ecarts.items():
par_t.setdefault(t, []).append(e)
commun = {t: (st.median(e[0] for e in l), st.median(e[1] for e in l)) for t, l in par_t.items() if len(l) >= 3}
cell = {} # (jour, heure) -> {cible: [|écart|]}
for (s, t), e in ecarts.items():
c0 = commun.get(t, (0, 0))
cell.setdefault((t.date(), t.hour), {}).setdefault(s, []).extend([abs(e[0] - c0[0]), abs(e[1] - c0[1])])
val = {k: st.median([st.median(v) for v in c.values()]) for k, c in cell.items() if len(c) >= 3}
prof = {h: st.median([v for (j, hh), v in val.items() if hh == h]) for h in range(24)
if any(hh == h for (j, hh) in val)}
print(f"{st_nom} cadence {cad/60:.0f} min, {len(cib)} cibles")
print("profil (heure UTC: bruit médian, unités de corr) :")
print(" " + " ".join(f"{h:02d}:{v:.3f}" for h, v in sorted(prof.items())))
ordre = sorted(prof, key=prof.get)
calme, agite = sorted(ordre[:6]), sorted(ordre[-6:])
print(f"heures calmes {calme}, agitées {agite}, rapport du profil {st.median([prof[h] for h in agite]) / st.median([prof[h] for h in calme]):.2f}")
etq = [json.loads(l) for l in open(f"labeling/auto/{st_nom}.jsonl") if l.strip()]
vis = [(d.instant(e["debut"]), d.instant(e["fin"])) for e in etq if e["categorie"] == "Visibility"]
print("jour agité calme rapport Visibility sur les heures agitées")
for j in sorted({j for j, h in val}):
a = [val[(j, h)] for h in agite if (j, h) in val]
c = [val[(j, h)] for h in calme if (j, h) in val]
if len(a) < 3 or len(c) < 3:
continue
from datetime import datetime, timezone
hs = [datetime(j.year, j.month, j.day, h, 30, tzinfo=timezone.utc) for h in agite]
couv = sum(any(a0 <= x <= b0 for a0, b0 in vis) for x in hs)
print(f"{j} {st.median(a):.3f} {st.median(c):.3f} {st.median(a) / st.median(c):5.2f} {couv}/6")
if "--cibles" in sys.argv: # rapport agité / calme de chaque cible, sur tout le lot : une gêne de la scène les touche toutes
print("cible : bruit des heures agitées / calmes (rapport)")
for s in sorted(cib):
a = [x for (j, h), c in cell.items() if h in agite for x in c.get(s, [])]
c = [x for (j, h), c in cell.items() if h in calme for x in c.get(s, [])]
if len(a) > 20 and len(c) > 20:
print(f" {s:24} {st.median(a):.4f} / {st.median(c):.4f} ({st.median(a) / max(st.median(c), 1e-6):.2f})")
@@ -0,0 +1,71 @@
"""Frontière Visibility / Thermal displacement : sur la plage d'une étiquette (et une marge), mesure par mesure,
ce qui bouge avec les courbes : l'error_value des cibles (toute la scène ?), la température du boîtier,
l'échelle et la rotation de la caméra.
Niveaux : médiane des 24 h qui finissent 2 h avant le début. Colonnes : heure ; n_corr = cibles dont corr_x ou
corr_y sort de 6 MAD de leur niveau ; ev = médiane sur les cibles de error_value moins niveau ; n_ev = cibles dont
l'error_value sort de 6 MAD ; temp = température du boîtier (heure la plus proche) moins niveau ; scale, rot = pose
moins niveau, en MAD de la pose.
Usage (depuis la racine) : python3 frontiere.py ID [--marge 2] [--pas N] (une ligne toutes les N mesures)
"""
import sys, json, statistics as st
from datetime import timedelta
sys.path.insert(0, "agent-tools")
import donnees as d
a = sys.argv[1:]
i = a[0]
marge = timedelta(hours=float(a[a.index("--marge") + 1]) if "--marge" in a else 2)
pas = int(a[a.index("--pas") + 1]) if "--pas" in a else 1
nom, n = i.split("#")
e = json.loads(open(f"labeling/auto/{nom}.jsonl").readlines()[int(n) - 1])
t1, t2 = d.instant(e["debut"]), d.instant(e["fin"])
dos = f"data/{nom}"
par = d.charger(dos)
cib = {s: ms for s, ms in par.items() if not d.est_reference(ms)}
r0, r1 = t1 - marge - timedelta(hours=24), t1 - marge
def niv(vals):
if len(vals) < 4:
return None
m = st.median(vals)
return m, max(st.median(abs(v - m) for v in vals), 1e-6)
nv = {}
for s, ms in cib.items():
w = d.filtrer(ms, r0, r1)
nv[s] = {q: niv([m[q] for m in w if m[q] is not None]) for q in ("corr_x", "corr_y", "error_value")}
cam = d.charger_camera(dos)
ncam = {q: niv([p[q] for p in cam if r0 <= p["t"] <= r1 and p[q] is not None]) for q in ("scale", "rotation")}
pcam = {p["t"].replace(second=0, microsecond=0): p for p in cam}
tmp = d.charger_temperature(dos)
ntmp = niv([v for t, v in tmp if r0 <= t <= r1])
idx = {s: {m["t"]: m for m in ms} for s, ms in cib.items()}
inst = sorted({t for s in idx for t in idx[s] if t1 - marge <= t <= t2 + marge})
print(f"{i} {e['debut']} -> {e['fin']} {e['categorie']}")
print("heure n_corr ev n_ev temp scale rot")
for k, t in enumerate(inst):
if k % pas:
continue
nc = ne = 0
evs = []
for s in idx:
m = idx[s].get(t)
if m is None:
continue
L = nv[s]
if m["error_value"] is not None and L["error_value"]:
evs.append(m["error_value"] - L["error_value"][0])
ne += abs(m["error_value"] - L["error_value"][0]) > 6 * L["error_value"][1]
if m["corr_x"] is not None and L["corr_x"] and L["corr_y"]:
nc += any(abs(m[q] - L[q][0]) > 6 * L[q][1] for q in ("corr_x", "corr_y"))
tt = min(tmp, key=lambda x: abs(x[0] - t)) if tmp else None
dt = f"{tt[1] - ntmp[0]:+5.1f}" if tt and ntmp and abs(tt[0] - t) < timedelta(hours=1) else " . "
p = pcam.get(t.replace(second=0, microsecond=0))
cs = " ".join(f"{(p[q] - ncam[q][0]) / ncam[q][1]:+6.1f}" if p and p[q] is not None and ncam[q] else " ."
for q in ("scale", "rotation"))
mark = "*" if t1 <= t <= t2 else " "
print(f"{t:%d %H:%M}{mark} {nc:3d} {st.median(evs) if evs else float('nan'):+.4f} {ne:3d} {dt} {cs}")
@@ -0,0 +1,40 @@
"""Par heure UTC sur un lot : pas médian de la pose de la caméra d'une mesure à la suivante (pan, tilt, rotation,
scale), écart médian de l'error_value des cibles à leur niveau du lot, et température médiane du boîtier.
Dit si le bruit de jour vient d'une pose agitée (commune) ou des taches elles-mêmes (error_value).
Usage (depuis la racine) : python3 pose_ev.py STATION DEBUT FIN
"""
import sys, statistics as st
sys.path.insert(0, "agent-tools")
import donnees as d
nom, t1, t2 = sys.argv[1], d.instant(sys.argv[2]), d.instant(sys.argv[3])
dos = f"data/{nom}"
cam = [p for p in d.charger_camera(dos) if t1 <= p["t"] <= t2]
par = d.charger(dos)
cib = {s: d.filtrer(ms, t1, t2) for s, ms in par.items() if not d.est_reference(ms)}
tmp = [(t, v) for t, v in d.charger_temperature(dos) if t1 <= t <= t2]
pas = {}
for a, b in zip(cam, cam[1:]):
if (b["t"] - a["t"]).total_seconds() < 7200:
for q in ("pan", "tilt", "rotation", "scale"):
if a[q] is not None and b[q] is not None:
pas.setdefault((b["t"].hour, q), []).append(abs(b[q] - a[q]))
ev = {}
for s, ms in cib.items():
v = [m["error_value"] for m in ms if m["error_value"] is not None]
if not v:
continue
n = st.median(v)
for m in ms:
if m["error_value"] is not None:
ev.setdefault(m["t"].hour, []).append(m["error_value"] - n)
th = {}
for t, v in tmp:
th.setdefault(t.hour, []).append(v)
print(f"{nom} heure pan tilt rotation scale ev-niveau temp")
for h in range(24):
c = [st.median(pas[(h, q)]) if (h, q) in pas else float("nan") for q in ("pan", "tilt", "rotation", "scale")]
e = st.median(ev[h]) if h in ev else float("nan")
tt = st.median(th[h]) if h in th else float("nan")
print(f" {h:02d} {c[0]:.5f} {c[1]:.5f} {c[2]:.5f} {c[3]:.7f} {e:+.4f} {tt:.1f}")
@@ -0,0 +1,51 @@
"""Écrit visibility/modifications.jsonl à partir des étiquettes actuelles de labeling/auto/ (ids de la table du jour).
Usage (depuis la racine) : python3 labeling/auto/revue-croisee/2026-11-04/visibility/outils/proposer.py"""
import json, os
ici = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
def etiq(i):
st, n = i.split("#")
e = json.loads(open(f"labeling/auto/{st}.jsonl").readlines()[int(n) - 1])
return {k: e[k] for k in ("debut", "fin", "categorie", "description")}
mods = []
# 1. SNCF01 : l'agitation de jour est la turbulence (bruit rapide de toutes les cibles le jour, calme la nuit), comme à
# LENZSPITZE et WILDSTRUBEL ; la cause se dit déduite, sans les hypothèses du soleil et des passages.
VIEUX = ("les courbes corrigées de plusieurs cibles s'agitent bien plus que la nuit, surtout",
"Cause non établie : sur les images de jour, soleil et ombres changent sur la scène autour des cibles ; "
"peut-être aussi la turbulence au-dessus des voies, ou des passages qui cachent les cibles basses.")
NEUF = ("les courbes corrigées de toutes les cibles s'agitent bien plus que la nuit, d'une mesure à l'autre, surtout",
"Cause déduite : la turbulence de l'air chauffé au-dessus des voies (un bruit rapide sur toute la scène, "
"le jour seulement), non visible sur les images ; les rejets de CV.2 et CV.4, cibles basses, peuvent "
"venir aussi de passages, non vus.")
for n in (9, 12, 15, 21, 28, 29, 33, 37, 39, 45, 49, 55, 59, 68, 73, 75, 82, 87, 91, 95):
e = etiq(f"SNCF01#{n}")
for a, b in zip(VIEUX, NEUF):
assert a in e["description"], n
e["description"] = e["description"].replace(a, b)
mods.append({"id": f"SNCF01#{n}", "action": "modifier", "etiquette": e})
e = etiq("SNCF01#25")
a = ("Même gêne de jour que les autres jours, cause non établie (soleil et ombres sur la scène autour des cibles, "
"ou turbulence au-dessus des voies).")
assert a in e["description"]
e["description"] = e["description"].replace(a, "Même turbulence de jour que les autres jours, plus faible : cause "
"déduite, l'air chauffé au-dessus des voies, non visible sur les images.")
mods.append({"id": "SNCF01#25", "action": "modifier", "etiquette": e})
# 2. NIEDERHORN#55 : 21:00 -> 04:00 UTC est la soirée et le début de nuit en heure locale (le soleil se lève vers 12:00 UTC),
# pas « la nuit et au matin » ; les cibles rejetées sont lues sur l'inventaire de la plage (le train de 04:00 est l'étiquette 56).
e = etiq("NIEDERHORN#55")
e["description"] = (
"En soirée et en début de nuit (heure locale), quelques heures : l'erreur de reconnaissance de nombreuses cibles monte, "
"plusieurs sont rejetées par moments (surtout PWD_RMP_B12_019_C09, PWD_RMP_B15_018_C09, e06, e09, PWD_RMP_B12_017_C09, "
"PWD_RMP_B12_018_C09 et PWD_IMP_B07_017_C09) et les autres s'agitent ; les références tiennent, plus haut sur la route. "
"Retour avant minuit, heure locale. Cause probable : pluie ou brume (taches plus petites et plus faibles sur les "
"vignettes de 01:00, sans obstacle). L'ouvrage ne bouge pas : ne pas croire les courbes sur la plage.")
mods.append({"id": "NIEDERHORN#55", "action": "modifier", "etiquette": e})
with open(f"{ici}/modifications.jsonl", "w") as f:
f.writelines(json.dumps(m, ensure_ascii=False) + "\n" for m in mods)
print(len(mods), "modifications")
@@ -0,0 +1,18 @@
"""Par jour : part des mesures rejetées de capteurs donnés, sur une tranche d'heures UTC.
Dit si une cible est perdue chaque jour, quel que soit le temps (Target issue), ou certains jours seulement (Visibility).
Usage (depuis la racine) : python3 rejets.py STATION DEBUT FIN H1-H2 CAPTEUR [CAPTEUR ...]
"""
import sys
sys.path.insert(0, "agent-tools")
import donnees as d
nom, t1, t2 = sys.argv[1], d.instant(sys.argv[2]), d.instant(sys.argv[3])
a, b = map(int, sys.argv[4].split("-"))
par = d.charger(f"data/{nom}")
for s in sys.argv[5:]:
jours = {}
for m in d.filtrer(par[s], t1, t2):
if a <= m["t"].hour < b:
jours.setdefault(m["t"].date(), []).append(d.rejetee(m))
print(s, f"{a:02d}-{b:02d} UTC :", " ".join(f"{j.day:02d}.{j.month:02d}:{100 * sum(v) // len(v)}%" for j, v in sorted(jours.items())))