2026-10-25 11:25:12 +01:00
|
|
|
"""Score des détecteurs du journal face aux étiquettes de l'analyste (point 45 du plan du journal du matin, D-062).
|
|
|
|
|
|
|
|
|
|
Une case : une mesure d'un capteur dans un lot. Chaque case reçoit, d'un côté, les catégories des moments de l'analyste
|
|
|
|
|
qui la couvrent (etiquettes.json, D-061), de l'autre, celles des événements des détecteurs (categories.py, le lot classé
|
|
|
|
|
avec ses 3 jours d'historique, comme la commande du lot). Pour chaque catégorie, et pour les deux niveaux de validité
|
|
|
|
|
qui ne sont pas « fiable » :
|
|
|
|
|
trouvées : cases étiquetées que les détecteurs ont aussi signalées (part des étiquetées) ;
|
|
|
|
|
justes : cases signalées que l'analyste a aussi étiquetées (part des signalées).
|
|
|
|
|
Validité d'une case : la pire de ses catégories ; « à ignorer » : les zones grisées du journal (carte des événements,
|
|
|
|
|
section 4) ; « prudence » : visibilité réduite et turbulence ; « fiable » sinon (dilatation, contraction, à vérifier :
|
|
|
|
|
jamais grisées), et sans catégorie. Un trou n'a pas de mesure, donc pas de case ; un moment « aucune » n'est pas compté.
|
|
|
|
|
Le score est un fait, pas un verdict : l'analyste peut se tromper aussi.
|
2026-11-03 15:12:24 +01:00
|
|
|
Avec --du et --au, le score d'une plage (D-112, /detector-learner) : les détecteurs face aux étiquettes de l'étiqueteur
|
2026-11-02 16:25:44 +01:00
|
|
|
(labeling/auto/<STATION>.jsonl) qui touchent le lot, par famille (labeling/familles.md) et par instant, les étiquettes
|
2026-11-03 14:57:52 +01:00
|
|
|
ne disant pas leurs capteurs ; la catégorie d'un événement est sa famille (un détecteur par famille, D-119), sauf un saut
|
|
|
|
|
bref resté seul, qui prend la famille de l'étiquette qui le couvre. Aucune étiquette sur le lot : sortie en erreur.
|
2026-11-03 15:12:24 +01:00
|
|
|
Usage : python3 .claude/skills/detector-learner/score.py <dossier de station> [etiquettes.json ...]
|
2026-10-29 10:26:49 +01:00
|
|
|
(défaut : events-learner/*/lot-*/etiquettes.json de la station)
|
2026-11-03 15:12:24 +01:00
|
|
|
python3 .claude/skills/detector-learner/score.py <dossier de station> --du AAAA-MM-JJ --au AAAA-MM-JJ
|
|
|
|
|
python3 .claude/skills/detector-learner/score.py --test
|
2026-10-25 11:25:12 +01:00
|
|
|
"""
|
|
|
|
|
import glob
|
|
|
|
|
import json
|
|
|
|
|
import os
|
2026-11-03 15:12:24 +01:00
|
|
|
import subprocess
|
2026-10-25 11:25:12 +01:00
|
|
|
import sys
|
|
|
|
|
from datetime import timedelta
|
|
|
|
|
from pathlib import Path
|
|
|
|
|
|
|
|
|
|
RACINE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "..")
|
2026-10-28 17:19:51 +01:00
|
|
|
sys.path.insert(0, os.path.join(RACINE, "detectors"))
|
2026-10-29 09:58:48 +01:00
|
|
|
sys.path.insert(0, os.path.join(RACINE, ".claude", "skills", "analyser-lot"))
|
2026-10-28 16:36:45 +01:00
|
|
|
import categories # noqa: E402 (il met lui-même agent-tools sur le chemin)
|
2026-10-25 11:25:12 +01:00
|
|
|
from donnees import charger, instant, iso # noqa: E402
|
|
|
|
|
from etiquettes import defauts, vocabulaire # noqa: E402
|
|
|
|
|
|
|
|
|
|
HISTORIQUE = timedelta(days=3) # comme la commande du lot (D-056)
|
2026-11-03 09:31:18 +01:00
|
|
|
IGNORER = {"visibilite_nulle", "passage", "cible_masquee", "cible_a_probleme", "saut_bref"} # zones grisées (carte, section 4)
|
2026-10-25 11:25:12 +01:00
|
|
|
# ponytail: la turbulence est toujours « prudence » : l'étiquette ne dit pas si elle est forte (grisée alors dans le
|
|
|
|
|
# journal) ; un champ de force dans les étiquettes si cet écart compte
|
|
|
|
|
PRUDENCE = {"visibilite_reduite", "turbulence"}
|
|
|
|
|
NIVEAUX = ("à ignorer", "prudence")
|
2026-11-03 14:57:52 +01:00
|
|
|
CAUSES_SAUT = {"Obstruction", "Visibility", "Displacement"} # un saut bref : la famille de sa cause (familles.md, frontières)
|
2026-10-25 11:25:12 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
def validite(cats):
|
|
|
|
|
return "à ignorer" if cats & IGNORER else "prudence" if cats & PRUDENCE else None
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def cases(mesures, debut, fin):
|
|
|
|
|
"""Mesures -> [(capteur, instant iso)] du lot, fin exclue."""
|
|
|
|
|
return [(s, t) for s, ms in mesures.items() for m in ms if debut <= (t := iso(m["t"])) < fin]
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def marquer(cs, spans):
|
|
|
|
|
"""Cases, [(début, fin, capteurs, catégorie)] -> {case: {catégories}} ; fin incluse, capteurs vides : tous."""
|
|
|
|
|
out = {c: set() for c in cs}
|
|
|
|
|
for d, f, capteurs, cat in spans:
|
|
|
|
|
for s, t in cs:
|
|
|
|
|
if d <= t <= f and (not capteurs or s in capteurs):
|
|
|
|
|
out[(s, t)].add(cat)
|
|
|
|
|
return out
|
|
|
|
|
|
|
|
|
|
|
2026-10-26 16:48:13 +01:00
|
|
|
def evenements(mesures, debut, fin):
|
|
|
|
|
"""Événements des détecteurs qui touchent le lot, classé avec ses jours d'historique (comme la commande du lot)."""
|
2026-10-25 11:25:12 +01:00
|
|
|
h, b = instant(debut) - HISTORIQUE, instant(fin)
|
|
|
|
|
tranche = {s: k for s, ms in mesures.items() if (k := [m for m in ms if h <= m["t"] < b])}
|
2026-10-26 16:48:13 +01:00
|
|
|
return [v for v in (categories.evenements(tranche) if tranche else []) if v["end"] >= debut]
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def detectes(mesures, debut, fin):
|
|
|
|
|
"""Événements des détecteurs du lot -> spans de marquer."""
|
|
|
|
|
return [(v["start"], v["end"], v["sensors"], v["category"]) for v in evenements(mesures, debut, fin)]
|
2026-10-25 11:25:12 +01:00
|
|
|
|
|
|
|
|
|
2026-11-02 16:25:44 +01:00
|
|
|
def compter(paires):
|
|
|
|
|
"""[(clés étiquetées, clés signalées)], une paire par case -> {clé: [étiquetées, signalées, les deux]}."""
|
2026-10-25 11:25:12 +01:00
|
|
|
n = {}
|
2026-11-02 16:25:44 +01:00
|
|
|
for a, d in paires:
|
2026-10-25 11:25:12 +01:00
|
|
|
for k in a | d:
|
|
|
|
|
x = n.setdefault(k, [0, 0, 0])
|
|
|
|
|
x[0], x[1], x[2] = x[0] + (k in a), x[1] + (k in d), x[2] + (k in a and k in d)
|
|
|
|
|
return n
|
|
|
|
|
|
|
|
|
|
|
2026-11-03 15:12:24 +01:00
|
|
|
def version():
|
|
|
|
|
"""La version des détecteurs : le commit, suivi de « + » si detectors/ a des changements non commités."""
|
|
|
|
|
def git(*a):
|
|
|
|
|
return subprocess.run(["git", "-C", RACINE, *a], capture_output=True, text=True).stdout.strip()
|
|
|
|
|
return git("rev-parse", "--short", "HEAD") + ("+" if git("status", "--porcelain", "--", "detectors") else "")
|
|
|
|
|
|
|
|
|
|
|
2026-11-02 16:25:44 +01:00
|
|
|
def score(etiq, det):
|
|
|
|
|
"""{case: catégories de l'analyste}, {case: catégories des détecteurs} -> {clé: [étiquetées, signalées, les deux]}."""
|
|
|
|
|
return compter([x | {v} if (v := validite(x)) else x for x in (etiq[c], det[c])] for c in etiq)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def familles():
|
2026-11-03 14:57:52 +01:00
|
|
|
"""{catégorie du journal: famille} : chaque famille est sa propre catégorie (D-119), dans l'ordre de categories.py."""
|
|
|
|
|
return {c: c for c in categories.CATEGORIES}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def bref(v):
|
|
|
|
|
"""Un événement qui n'est qu'un saut revenu, resté seul (aucune cause ne l'a absorbé)."""
|
|
|
|
|
return v["category"] == "Displacement" and v["episodes"][0]["label"] == categories.SAUT
|
2026-11-02 16:25:44 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
def etiquettes_auto(station, debut, fin):
|
|
|
|
|
"""labeling/auto/<STATION>.jsonl -> les étiquettes de l'étiqueteur qui touchent [début, fin)."""
|
|
|
|
|
chemin = os.path.join(RACINE, "labeling", "auto", f"{station}.jsonl")
|
|
|
|
|
if not os.path.exists(chemin):
|
|
|
|
|
return []
|
|
|
|
|
with open(chemin, encoding="utf-8") as f:
|
|
|
|
|
return [e for e in map(json.loads, filter(str.strip, f)) if e["debut"] < fin and e["fin"] >= debut]
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def familles_lot(dossier, debut, fin, etiq=None):
|
|
|
|
|
"""Score d'un lot par famille et par instant (D-112) -> ({famille: [étiquetés, signalés, les deux]}, étiquettes).
|
|
|
|
|
Un instant : une heure du lot où un capteur au moins a une mesure ; il reçoit les familles des étiquettes qui le
|
|
|
|
|
couvrent, bornes comprises, et celles des événements des détecteurs. etiq : les étiquettes, sinon labeling/auto/."""
|
|
|
|
|
# ponytail: par instant et non par capteur, les étiquettes ne disent leurs capteurs que dans le texte ; un champ
|
|
|
|
|
# capteurs dans l'étiquette, si cette finesse manque
|
2026-11-03 14:57:52 +01:00
|
|
|
mesures = charger(dossier)
|
2026-11-02 16:25:44 +01:00
|
|
|
if etiq is None:
|
|
|
|
|
etiq = etiquettes_auto(os.path.basename(os.path.normpath(dossier)), debut, fin)
|
|
|
|
|
evts = evenements(mesures, debut, fin)
|
|
|
|
|
paires = []
|
|
|
|
|
for t in sorted({t for _, t in cases(mesures, debut, fin)}):
|
2026-11-03 14:57:52 +01:00
|
|
|
a = {e.get("categorie", "sans famille") for e in etiq if e["debut"] <= t <= e["fin"]} - {"None"}
|
|
|
|
|
d = {"saut_bref" if bref(v) else v["category"] for v in evts if v["start"] <= t <= v["end"]}
|
2026-11-02 16:25:44 +01:00
|
|
|
if "saut_bref" in d:
|
|
|
|
|
d = d - {"saut_bref"} | (a & CAUSES_SAUT or {"saut_bref"})
|
|
|
|
|
paires.append((a, d))
|
|
|
|
|
return compter(paires), etiq
|
|
|
|
|
|
|
|
|
|
|
2026-10-25 11:25:12 +01:00
|
|
|
def pct(a, b):
|
|
|
|
|
return f"{a}/{b} ({round(100 * a / b)} %)" if b else "—"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def afficher(titre, n):
|
|
|
|
|
print(titre)
|
|
|
|
|
print(f" {'':<22}{'trouvées':>20}{'justes':>20}")
|
|
|
|
|
for k in [*NIVEAUX, *sorted(set(n) - set(NIVEAUX))]:
|
|
|
|
|
if k in n:
|
|
|
|
|
lab, sig, both = n[k]
|
|
|
|
|
print(f" {k:<22}{pct(both, lab):>20}{pct(both, sig):>20}")
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def lots(dossier, chemins, explicite):
|
|
|
|
|
station = os.path.basename(os.path.normpath(dossier))
|
|
|
|
|
mesures = charger(dossier)
|
|
|
|
|
vocab = vocabulaire()
|
|
|
|
|
total, vus = {}, 0
|
|
|
|
|
for chemin in chemins:
|
|
|
|
|
nom = os.path.join(*Path(chemin).resolve().parent.parts[-2:])
|
|
|
|
|
with open(chemin, encoding="utf-8") as f:
|
|
|
|
|
lot = json.load(f)
|
|
|
|
|
if lot.get("station") != station:
|
|
|
|
|
if explicite:
|
|
|
|
|
print(f"{nom} : station {lot.get('station')!r}, le dossier est {station!r} : sauté")
|
|
|
|
|
continue
|
|
|
|
|
if fautes := defauts(lot, station, set(mesures), *vocab):
|
|
|
|
|
print(f"{nom} : étiquettes à corriger ({len(fautes)} défauts, etiquettes.py) : sauté")
|
|
|
|
|
continue
|
|
|
|
|
cs = cases(mesures, lot["debut"], lot["fin"])
|
|
|
|
|
if not cs:
|
|
|
|
|
print(f"{nom} : aucune mesure du lot dans {dossier} : sauté")
|
|
|
|
|
continue
|
|
|
|
|
moments = [m for m in lot["moments"] if m["categorie"] != "aucune"]
|
|
|
|
|
etiq = marquer(cs, [(m["debut"], m["fin"], m["capteurs"], m["categorie"]) for m in moments])
|
|
|
|
|
n = score(etiq, marquer(cs, detectes(mesures, lot["debut"], lot["fin"])))
|
|
|
|
|
afficher(f"{nom} : {lot['debut']} → {lot['fin']}, {len(moments)} moments comptés "
|
|
|
|
|
f"({len(lot['moments']) - len(moments)} « aucune »), {len(cs)} cases", n)
|
|
|
|
|
for k, v in n.items():
|
|
|
|
|
total[k] = [a + b for a, b in zip(total.get(k, [0, 0, 0]), v)]
|
|
|
|
|
vus += 1
|
|
|
|
|
if vus > 1:
|
|
|
|
|
afficher(f"Total : {vus} lots", total)
|
|
|
|
|
elif not vus:
|
|
|
|
|
print(f"Aucun lot étiqueté de {station} à compter.")
|
2026-10-26 16:48:13 +01:00
|
|
|
return total # la page de fin de séance (comparaison.py) en fait son tableau
|
2026-10-25 11:25:12 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
def test():
|
|
|
|
|
"""Lot 1 de l'essai de NORDEND (2026-10-05 → 09), les détecteurs tels qu'ils sont : leurs événements pris pour
|
|
|
|
|
étiquettes donnent tout juste ; une catégorie oubliée par l'analyste fait baisser « justes », une étiquette que les
|
|
|
|
|
détecteurs n'ont pas fait baisser « trouvées » ; la pire validité l'emporte."""
|
|
|
|
|
mesures = charger(os.path.join(RACINE, "vues-deplacements", "cas", "2026-10_NORDEND", "NORDEND"))
|
|
|
|
|
debut, fin = "2026-10-05T00:00Z", "2026-10-09T00:00Z"
|
|
|
|
|
cs = cases(mesures, debut, fin)
|
|
|
|
|
spans = detectes(mesures, debut, fin)
|
|
|
|
|
assert cs and spans, "aucune case ou aucun événement sur le lot de l'essai"
|
|
|
|
|
det = marquer(cs, spans)
|
|
|
|
|
assert all(x[0] == x[1] == x[2] for x in score(det, det).values())
|
|
|
|
|
cat = next(s[3] for s in spans if validite({s[3]}))
|
|
|
|
|
oubli = score(marquer(cs, [s for s in spans if s[3] != cat]), det)[cat]
|
|
|
|
|
assert oubli[0] == oubli[2] == 0 < oubli[1], oubli
|
|
|
|
|
ajout = score(marquer(cs, spans + [(debut, fin, [], "derive_lente")]), det)["derive_lente"]
|
|
|
|
|
assert ajout == [len(cs), 0, 0], ajout
|
|
|
|
|
assert validite({"visibilite_reduite", "visibilite_nulle"}) == "à ignorer"
|
|
|
|
|
assert validite({"dilatation_thermique", "a_verifier"}) is None
|
2026-11-02 16:25:44 +01:00
|
|
|
# par famille (D-112) : chaque catégorie du journal a sa famille, sauf saut_bref ; les événements des détecteurs pris
|
|
|
|
|
# pour étiquettes, sauts brefs à part, donnent chaque famille trouvée et juste en entier
|
|
|
|
|
corr = familles()
|
|
|
|
|
assert set(categories.CATEGORIES) - set(corr) == {"saut_bref"}, corr
|
|
|
|
|
etiq = [{"debut": v["start"], "fin": v["end"], "categorie": corr[v["category"]]}
|
|
|
|
|
for v in evenements(mesures, debut, fin) if v["category"] != "saut_bref"]
|
|
|
|
|
n, _ = familles_lot(os.path.join(RACINE, "vues-deplacements", "cas", "2026-10_NORDEND", "NORDEND"), debut, fin, etiq)
|
|
|
|
|
assert n and all(x[0] == x[1] == x[2] for k, x in n.items() if k != "saut_bref"), n
|
2026-10-25 11:25:12 +01:00
|
|
|
print("test : bon")
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if __name__ == "__main__":
|
|
|
|
|
if sys.argv[1:] == ["--test"]:
|
|
|
|
|
test()
|
2026-11-02 16:25:44 +01:00
|
|
|
elif len(sys.argv) == 6 and sys.argv[2::2] == ["--du", "--au"]:
|
|
|
|
|
station, du, au = os.path.basename(os.path.normpath(sys.argv[1])), iso(instant(sys.argv[3])), iso(instant(sys.argv[5]))
|
|
|
|
|
n, etiq = familles_lot(sys.argv[1], du, au)
|
|
|
|
|
if not etiq:
|
|
|
|
|
sys.exit(f"Aucune étiquette de {station} sur {du} → {au} dans labeling/auto/{station}.jsonl : "
|
|
|
|
|
"étiqueter le lot d'abord (@etiqueteur).")
|
|
|
|
|
afficher(f"{station} : {du} → {au}, {len(etiq)} étiquettes de labeling/auto/{station}.jsonl, par famille et par instant", n)
|
2026-10-25 11:25:12 +01:00
|
|
|
elif len(sys.argv) >= 2:
|
|
|
|
|
explicites = sys.argv[2:]
|
2026-10-29 10:26:49 +01:00
|
|
|
tous = sorted(glob.glob(os.path.join(RACINE, "events-learner", "*", "lot-*", "etiquettes.json")))
|
2026-10-25 11:25:12 +01:00
|
|
|
lots(sys.argv[1], explicites or tous, bool(explicites))
|
|
|
|
|
else:
|
|
|
|
|
sys.exit(__doc__)
|