Detectors in English, under scripts/; learner tools under scripts/learner/

- data.py (was donnees.py): unused filtrer, heure_image and image sorting removed
- score.py: dead functions (validite, marquer, detectes, score, familles) and the
  validity levels removed; --from/--to
- regression.py: history.csv and --seance/--etape removed
- categories.py: --from/--to/--chunk/--history; process values images/none/check
- benchmark on all stations unchanged (same 132 figures)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
maximeandClaude Opus 5.5 committed 2026-11-13 12:19:52 +01:00
1 parent 9b3ac0ecfe
commit 969637499f
23 files changed
+1877 -1971

No files matched your search

-29
View File
@@ -1,29 +0,0 @@
"""Pour le critique de /detector-learner : la cadence des mesures du lot, puis chaque événement de la commande du lot avec
ses capteurs (categories.py n'en donne que le nombre) ; avant, le nombre de cibles et de références de la station. Même calcul que categories.py sans --tranche (3 jours d'historique).
Usage : python3 detectors/skills/detector-learner/capteurs.py <dossier> --du AAAA-MM-JJ --au AAAA-MM-JJ
"""
import argparse
import os
import statistics
import sys
from datetime import datetime, timedelta, timezone
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "..", "detectors"))
import categories # noqa: E402
p = argparse.ArgumentParser(usage=__doc__)
p.add_argument("dossier")
p.add_argument("--du", required=True)
p.add_argument("--au", required=True)
a = p.parse_args()
jour = lambda d: datetime.strptime(d[:10], "%Y-%m-%d").replace(tzinfo=timezone.utc) # noqa: E731
debut, fin = jour(a.du), jour(a.au)
mesures = categories.charger(a.dossier)
lot = {s: k for s, ms in mesures.items() if (k := [m for m in ms if debut - timedelta(days=3) <= m["t"] < fin])}
ts = sorted({m["t"] for ms in lot.values() for m in ms if m["t"] >= debut})
pas = [(b - a).total_seconds() / 60 for a, b in zip(ts, ts[1:])]
print(f"cadence : {statistics.median(pas):.0f} min (médiane des pas entre mesures)" if pas else "cadence : pas de mesure")
refs = sum(ms[0]["pattern_type"] == "global_ref" for ms in lot.values())
print(f"capteurs : {len(lot) - refs} cibles, {refs} références")
for v in (v for v in categories.evenements(lot, fin, a.dossier) if v["end"] >= categories.iso(debut)) if lot else []:
print(v["start"], "→", v["end"], f"{v['category']:<20}", "|", v["episodes"][0]["label"], "|", ", ".join(sorted(v["sensors"])) or "tous les capteurs")
-69
View File
@@ -1,69 +0,0 @@
"""Benchmark de /detector-learner (D-116) : les détecteurs face à toutes les étiquettes de l'étiqueteur (labeling/auto/).
Pour chaque station de labeling/auto/ qui a son dossier dans data/, le score par famille et par instant de score.py
(D-112), sur la plage de ses étiquettes : du jour de la première à minuit après la dernière. Puis le total, famille par
famille, qui dit si les détecteurs font globalement mieux d'une séance à l'autre. Le bloc de la station de la séance est
son score ; les autres blocs, la non-régression : une famille qui recule sur une station est un recul, même si le total
monte. Avec --etape, chaque ligne (stations et Total) entre dans l'historique, detectors/detector-learner/historique.csv, avec la
version des détecteurs (score.version()).
Usage : python3 detectors/skills/detector-learner/regression.py [--seance <séance> --etape <étape>] [--stations A,B]
"""
import argparse
import csv
import glob
import json
import os
import sys
from datetime import datetime, timezone
RACINE = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", ".."))
import score # noqa: E402 (à côté)
HISTORIQUE = os.path.join(RACINE, "detectors", "detector-learner", "historique.csv")
def plage(chemin):
"""labeling/auto/<STATION>.jsonl -> (début, fin) iso, en jours entiers UTC, fin exclue."""
with open(chemin, encoding="utf-8") as f:
etiq = [json.loads(l) for l in f if l.strip()]
du = min(e["debut"] for e in etiq)[:10]
# ponytail: la fin du lot n'est pas écrite ; minuit le plus proche de la dernière borne (une borne d'étiquette déborde
# d'une mesure après minuit) ; la fin réelle du lot dans labeling/auto/ si l'écart compte
au = score.iso(score.instant(max(e["fin"] for e in etiq)) + score.timedelta(hours=12))[:10]
return score.iso(score.instant(du)), score.iso(score.instant(au))
if __name__ == "__main__":
p = argparse.ArgumentParser(usage=__doc__)
p.add_argument("--seance", default="")
p.add_argument("--etape")
p.add_argument("--stations", help="A,B : ces stations seules, sans historique (un essai plus court)")
a = p.parse_args()
total, res = {}, {}
for chemin in sorted(glob.glob(os.path.join(RACINE, "labeling", "auto", "*.jsonl"))):
station = os.path.basename(chemin)[:-len(".jsonl")]
if a.stations and station not in a.stations.split(","):
continue
dossier = os.path.join(RACINE, "data", station)
if not os.path.isdir(dossier):
print(f"{station} : pas de data/{station}/, sautée\n")
continue
du, au = plage(chemin)
n, etiq = score.familles_lot(dossier, du, au)
score.afficher(f"{station} : {du} → {au}, {len(etiq)} étiquettes", n)
print()
res[station] = n
for k, v in n.items():
total[k] = [a + b for a, b in zip(total.get(k, [0, 0, 0]), v)]
score.afficher("Total", total)
if a.etape and not a.stations:
res["Total"] = total
os.makedirs(os.path.dirname(HISTORIQUE), exist_ok=True)
neuf = not os.path.exists(HISTORIQUE)
date, ver = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%MZ"), score.version()
with open(HISTORIQUE, "a", newline="", encoding="utf-8") as f:
w = csv.writer(f)
if neuf:
w.writerow(("date", "seance", "etape", "version", "station", "famille", "etiquetees", "signalees", "les_deux"))
w.writerows((date, a.seance, a.etape, ver, st, k, *v) for st, n in res.items() for k, v in sorted(n.items()))
print(f"\nhistorique : {os.path.relpath(HISTORIQUE, RACINE)} (version {ver})")
-142
View File
@@ -1,142 +0,0 @@
"""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__)