"""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. Avec --du et --au, le score d'une plage (D-112, /detector-learner) : les détecteurs face aux étiquettes de l'étiqueteur (labeling/auto/.jsonl) qui touchent le lot, par famille (labeling/familles.md) et par instant, les étiquettes ne disant pas leurs capteurs ; la catégorie d'un événement est sa famille (un détecteur par famille, D-119), un saut revenu resté seul compris (Displacement, D-120). Aucune étiquette sur le lot : sortie en erreur. Usage : python3 .claude/skills/detector-learner/score.py [etiquettes.json ...] (défaut : events-learner/*/lot-*/etiquettes.json de la station) python3 .claude/skills/detector-learner/score.py --du AAAA-MM-JJ --au AAAA-MM-JJ python3 .claude/skills/detector-learner/score.py --test """ import glob import json import os import subprocess import sys from datetime import timedelta from pathlib import Path RACINE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "..") sys.path.insert(0, os.path.join(RACINE, "detectors")) sys.path.insert(0, os.path.join(RACINE, ".claude", "skills", "analyser-lot")) import categories # noqa: E402 (il met lui-même agent-tools sur le chemin) from donnees import charger, charger_temperature, instant, iso # noqa: E402 from etiquettes import defauts, vocabulaire # noqa: E402 HISTORIQUE = timedelta(days=3) # comme la commande du lot (D-056) IGNORER = {"visibilite_nulle", "passage", "cible_masquee", "cible_a_probleme", "saut_bref"} # zones grisées (carte, section 4) # 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") 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 def evenements(mesures, debut, fin, temperature=None): """Événements des détecteurs qui touchent le lot, classé avec ses jours d'historique (comme la commande du lot).""" 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])} return [v for v in (categories.evenements(tranche, temperature=temperature) 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)] def compter(paires): """[(clés étiquetées, clés signalées)], une paire par case -> {clé: [étiquetées, signalées, les deux]}.""" n = {} for a, d in paires: 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 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 "") 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(): """{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 etiquettes_auto(station, debut, fin): """labeling/auto/.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 exclues (sauf un trou, sans mesure dedans), 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 mesures = charger(dossier) if etiq is None: etiq = etiquettes_auto(os.path.basename(os.path.normpath(dossier)), debut, fin) evts = evenements(mesures, debut, fin, charger_temperature(dossier)) instants = sorted({t for _, t in cases(mesures, debut, fin)}) # bornes exclues : elles sont la mesure saine d'avant et d'après (D-111) ; un trou, sans mesure dedans, les garde vides = {i for i, e in enumerate(etiq) if not any(e["debut"] < t < e["fin"] for t in instants)} paires = [] for t in instants: a = {e.get("categorie", "sans famille") for i, e in enumerate(etiq) if e["debut"] < t < e["fin"] or (i in vides and e["debut"] <= t <= e["fin"])} - {"None"} d = {v["category"] for v in evts if v["start"] <= t <= v["end"]} paires.append((a, d)) return compter(paires), etiq 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.") return total # la page de fin de séance (comparaison.py) en fait son tableau def test(): """Lot 1 de l'essai de NORDEND (2026-10-05 → 09) : une étiquette (D-111) ne compte que les instants entre ses bornes, la mesure saine d'avant et celle d'après ; un trou, sans mesure entre ses bornes, compte ses deux bornes.""" dossier = os.path.join(RACINE, "vues-deplacements", "cas", "2026-10_NORDEND", "NORDEND") debut, fin = "2026-10-05T00:00Z", "2026-10-09T00:00Z" a, b, c = sorted({t for _, t in cases(charger(dossier), debut, fin)})[10:13] n, _ = familles_lot(dossier, debut, fin, [{"debut": a, "fin": c, "categorie": "X"}]) assert n["X"][0] == 1, n n, _ = familles_lot(dossier, debut, fin, [{"debut": a, "fin": b, "categorie": "X"}]) assert n["X"][0] == 2, n print("test : bon") if __name__ == "__main__": if sys.argv[1:] == ["--test"]: test() 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) elif len(sys.argv) >= 2: explicites = sys.argv[2:] tous = sorted(glob.glob(os.path.join(RACINE, "events-learner", "*", "lot-*", "etiquettes.json"))) lots(sys.argv[1], explicites or tous, bool(explicites)) else: sys.exit(__doc__)