"""Score des détecteurs sur une plage : les détecteurs du journal face aux étiquettes de labeling/auto/.jsonl qui touchent la plage, par famille (labeling/familles.md) et par instant. Une case : une mesure d'un capteur ; elle reçoit, d'un côté, les familles des étiquettes qui la couvrent, de l'autre, celles des événements des détecteurs (categories.py, la plage classée avec ses 3 jours d'historique) ; la catégorie d'un événement est sa famille (un détecteur par famille), un saut revenu resté seul compris (Displacement). Pour chaque famille, 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 qu'une étiquette range aussi dans la famille (part des signalées). Un trou n'a pas de mesure, donc pas de case. Le score est un fait, pas un verdict : les étiquettes peuvent se tromper aussi. Aucune étiquette sur la plage : sortie en erreur. Lancé depuis le dépôt de travail, où detectors/ est monté. Usage : python3 detectors/skills/detector-learner/score.py --du AAAA-MM-JJ --au AAAA-MM-JJ """ import json import os import subprocess import sys from datetime import timedelta RACINE = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "..")) sys.path.insert(0, os.path.join(RACINE, "detectors")) import categories # noqa: E402 (il met lui-même donnees.py sur le chemin) from donnees import charger, instant, iso # 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, dossier=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, dossier=dossier) 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 du dépôt detectors, suivi de « + » s'il a des changements non commités.""" def git(*a): return subprocess.run(["git", "-C", os.path.join(RACINE, "detectors"), *a], capture_output=True, text=True).stdout.strip() return git("rev-parse", "--short", "HEAD") + ("+" if git("status", "--porcelain", "--", ".") 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, 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}") if __name__ == "__main__": if 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 : " "analyser la plage d'abord.") afficher(f"{station} : {du} → {au}, {len(etiq)} étiquettes de labeling/auto/{station}.jsonl, par famille et par instant", n) else: sys.exit(__doc__)