Le plugin detector-learner : skill, agents, historique, registre des seuils ; les détecteurs lisent leur donnees.py
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
23dd7299ea
commit
9b3ac0ecfe
20 files changed
+2147
-12
No files matched your search
@@ -0,0 +1,142 @@
|
||||
"""Score des détecteurs sur une plage : les détecteurs du journal face aux étiquettes de labeling/auto/<STATION>.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 <dossier de station> --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/<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 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__)
|
||||
Reference in new issue
Block a user