Files
Support-Agent/.claude/skills/boucle/comparaison.py
T
maximeandClaude Opus 5.5 d5bae7a696 Add the loop's end-of-session page and a detector benchmark on the case base
- End-of-session page for /boucle: the session's curves, the analyst's
  labels against the detectors' events per category, a plain score table
  and the benchmark (comparaison.py, D-066)
- Detectors moved to vues-deplacements/detectors/ (D-067)
- Detectors must detect everything; what the client sees is a separate
  layer (D-068)
- Benchmark: each case keeps its labels from creation (etiquettes.json),
  benchmark.py scores the detectors on every case, history in
  vues-deplacements/benchmark/historique.csv; run by /boucle at each lot,
  after each change and at the end, read by the upgrader and validator;
  labels for C-001..C-005 from one analyst pass corrected by their files,
  C-006..C-008 from lot 01 (D-069)
- Fixes from the releveur's notes: /boucle arguments and other sessions,
  branch name in the spec, detector name in categories.py output, learned
  case header, anonymiser.py (camera/, no empty CSVs, --etiquettes),
  ensemble.py (clock-aligned steps, title), plages.py (same-sign merge),
  labeling request written into /nouveau-cas
- Also carries the other session's uncommitted D-065 edits in the same
  files; data/, .gitignore, pomper.py and stations.py are left out

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-26 16:48:13 +01:00

159 lines
10 KiB
Python

"""Page de fin de séance de /boucle : la lecture de l'analyste face aux détecteurs, sur toute la plage de la séance.
En haut, corr_x et corr_y de chaque capteur (px) ; dessous, une ligne par catégorie du journal : en haut de la ligne les
moments de l'analyste (etiquettes.json des lots de la séance), en bas les événements des détecteurs tels qu'ils sont
(chaque lot classé avec ses 3 jours d'historique, comme le score). En dernier, en gris, les moments « aucune » de
l'analyste : vus, mais hors des catégories du journal (sans effet sur les courbes le plus souvent, ou une nouveauté). Une barre va de la première mesure à la dernière,
plus un pas. Sous la figure, le score de la séance (score.py sur ses seules étiquettes). Faire coïncider les deux barres
de chaque ligne, séance après séance, c'est le but de la boucle.
Usage : python3 .claude/skills/boucle/comparaison.py <dossier de station> <dossier de séance>
(page : out/boucle_<séance>.html, ouverte dans le navigateur)
"""
import contextlib
import glob
import html
import io
import json
import os
import statistics
import sys
import textwrap
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "..", "src"))
from common.page import AUTOSCALE_Y_JS, ROOT, open_html # noqa: E402 (bascule seule sur .venv si plotly manque)
import plotly.graph_objects as go # noqa: E402
from plotly.subplots import make_subplots # noqa: E402
import score # noqa: E402 (détecteurs, chargement et score ; met detectors/ et les outils sur le chemin)
from donnees import est_reference # noqa: E402
import benchmark # noqa: E402 (les détecteurs face aux cas de la base, D-069)
AGENT, SCRIPTS = "#2a78d6", "#eb6834" # palette catégorielle de référence, slots 1 et 2 (skill dataviz)
CIBLE, REFERENCE = "rgba(110,110,105,0.55)", "rgba(30,30,28,0.8)" # courbes : l'identité au survol, pas à la couleur
HORS, GRIS = "hors catégorie", "#a3a29c" # moments « aucune » de l'analyste : aucun détecteur ne peut les rejoindre
def survol(titre, debut, fin, capteurs, *lignes):
return "<br>".join([f"<b>{titre}</b>", f"{debut} → {fin}", f"capteurs : {', '.join(capteurs) or 'tous'}",
*("<br>".join(textwrap.wrap(x, 90)) for x in lignes if x)])
def barres(nom, couleur, spans, pas, rang, groupe):
"""[(début, fin, catégorie, survol)] -> barres horizontales, de la première mesure à la dernière plus un pas ; même
groupe : même place dans la ligne."""
debuts = [score.instant(s[0]) for s in spans]
return go.Bar(name=nom, orientation="h", y=[s[2] for s in spans], base=debuts, marker_color=couleur, legendrank=rang,
offsetgroup=groupe,
x=[(score.instant(s[1]) + pas - d).total_seconds() * 1000 for s, d in zip(spans, debuts)],
hovertext=[s[3] for s in spans], hoverinfo="text")
NIVEAUX = {"à ignorer": "Toutes les zones à ignorer", "prudence": "Toutes les zones à lire avec prudence"}
def tableau(total, ordre, titre="Catégorie"):
"""{clé: [mesures de l'analyste, des détecteurs, des deux]} (score.lots) -> table HTML : les catégories, puis les
deux niveaux de validité."""
def part(a, b):
return f"{round(100 * a / b)} %<small> ({a} sur {b})</small>" if b else "—"
cles = [*(c for c in ordre if c in total), *sorted(set(total) - set(ordre) - set(NIVEAUX)), *(k for k in NIVEAUX if k in total)]
lignes = "".join(f"<tr{' class=niveau' if k in NIVEAUX else ''}><td>{NIVEAUX.get(k, k)}</td><td>{total[k][0]}</td>"
f"<td>{total[k][1]}</td><td>{part(total[k][2], total[k][0])}</td><td>{part(total[k][2], total[k][1])}</td></tr>"
for k in cles)
return (f"<table><tr><th>{titre}</th><th>Vues par l'analyste</th><th>Signalées par les détecteurs</th>"
"<th>Trouvées</th><th>Confirmées</th></tr>" + lignes + "</table>")
def page(dossier, seance):
chemins = sorted(glob.glob(os.path.join(seance, "lot-*", "etiquettes.json")))
if not chemins:
sys.exit(f"{seance} : aucun lot-*/etiquettes.json")
lots = []
for c in chemins:
with open(c, encoding="utf-8") as f:
lots.append(json.load(f))
debut, fin = min(x["debut"] for x in lots), max(x["fin"] for x in lots)
a, b = score.instant(debut), score.instant(fin)
mesures = score.charger(dossier)
temps = sorted({m["t"] for ms in mesures.values() for m in ms if a <= m["t"] < b})
pas = statistics.median(y - x for x, y in zip(temps, temps[1:]))
agent = [(m["debut"], m["fin"], c := HORS if m["categorie"] == "aucune" else m["categorie"],
survol(f"Analyste : {c}", m["debut"], m["fin"], m["capteurs"],
f"{m['evenement'] or '—'} ({m['preuve']})", m["description"]))
for x in lots for m in x["moments"]]
vus, scripts = set(), []
for x in lots:
for v in score.evenements(mesures, x["debut"], x["fin"]):
if (k := (v["start"], v["end"], v["category"], tuple(v["sensors"]))) not in vus: # lots voisins : une fois
vus.add(k)
scripts.append((v["start"], v["end"], v["category"],
survol(f"Détecteurs : {v['category']}", v["start"], v["end"], v["sensors"], v["text"])))
presentes = {s[2] for s in agent + scripts}
ordre = [c for c in [*score.categories.CATEGORIES, *sorted(presentes - set(score.categories.CATEGORIES) - {HORS}), HORS]
if c in presentes]
fig = make_subplots(rows=3, cols=1, shared_xaxes=True, vertical_spacing=0.04,
row_heights=[260, 260, 40 * len(ordre) + 20],
subplot_titles=("corr_x (px)", "corr_y (px)",
"Classification : analyste (bleu, en haut ; gris : hors catégorie), détecteurs (orange, en bas)"))
for s in sorted(mesures):
ms = [m for m in mesures[s] if a <= m["t"] < b]
for row, col in ((1, "corr_x"), (2, "corr_y")):
fig.add_trace(go.Scatter(x=[m["t"] for m in ms], y=[m[col] for m in ms], name=s, mode="lines",
line={"width": 1, "color": REFERENCE if est_reference(mesures[s]) else CIBLE}, showlegend=False,
hovertemplate=f"{s} : %{{y:.3f}} px<extra></extra>"), row=row, col=1)
fig.add_trace(barres("Détecteurs", SCRIPTS, scripts, pas, 3, "d"), row=3, col=1) # en mode group, le 1er groupe en bas
fig.add_trace(barres("Analyste", AGENT, [s for s in agent if s[2] != HORS], pas, 1, "a"), row=3, col=1)
fig.add_trace(barres(f"Analyste, {HORS}", GRIS, [s for s in agent if s[2] == HORS], pas, 2, "a"), row=3, col=1)
fig.update_layout(barmode="group", bargap=0.25, bargroupgap=0.1, height=620 + 40 * len(ordre),
margin={"l": 170, "r": 20, "t": 40, "b": 40}, hovermode="closest", plot_bgcolor="white",
legend={"orientation": "h", "y": 1.04, "x": 0})
fig.update_xaxes(type="date", range=[a, b], showgrid=True, gridcolor="#e6e6e2")
fig.update_yaxes(showgrid=True, gridcolor="#eeeeea", zeroline=False)
fig.update_yaxes(categoryorder="array", categoryarray=ordre[::-1], row=3, col=1)
with contextlib.redirect_stdout(io.StringIO()): # le détail par lot : lot-NN/score-avant.txt et score-fin.txt
total = score.lots(dossier, chemins, True)
cas, _ = benchmark.mesurer()
bench = {c: n[benchmark.TOUTES] for c, n in cas.items()}
nom = os.path.basename(os.path.normpath(seance))
corps = fig.to_html(include_plotlyjs="cdn", full_html=False, post_script=AUTOSCALE_Y_JS,
config={"scrollZoom": False}) # la molette fait défiler la page (l'utilisateur)
chemin = os.path.join(ROOT, "out", f"boucle_{nom}.html")
os.makedirs(os.path.dirname(chemin), exist_ok=True)
with open(chemin, "w", encoding="utf-8") as f:
f.write(f"""<!doctype html><html lang="fr"><head><meta charset="utf-8"><title>Boucle {html.escape(nom)}</title>
<style>body{{font-family:system-ui,sans-serif;margin:16px;background:#fff;color:#1a1a19}}
p{{color:#5f5e5a;max-width:70em}} table{{border-collapse:collapse;font-size:14px}}
th,td{{padding:4px 14px;border-bottom:1px solid #e6e6e2;text-align:right}} th:first-child,td:first-child{{text-align:left}}
th{{font-weight:600;color:#3d3d3a}} small{{color:#8a8984}} tr.niveau td{{color:#5f5e5a;font-style:italic}}</style></head><body>
<h2>Séance {html.escape(nom)} : {debut} → {fin} (UTC)</h2>
<p>Dessous les courbes, chaque ligne est une catégorie du journal : la barre du haut est la lecture de l'analyste
(étiquettes des {len(lots)} lot(s) de la séance), celle du bas, les événements des détecteurs dans leur état de fin de
séance. En dernier, en gris, ce que l'analyste a vu hors des catégories du journal : sans effet sur les courbes le plus
souvent, ou une nouveauté ; aucun détecteur ne peut le rejoindre. Survol : capteurs, preuve, description. Le but de la boucle : que les deux barres de chaque ligne coïncident.</p>
{corps}<h3>Score de la séance</h3>
<p>On compte des mesures : une mesure, c'est un capteur à un instant (toutes les {round(pas.total_seconds() / 60)} min ici).
<b>Trouvées</b> : de ce que l'analyste range dans la catégorie, la part que les détecteurs signalent aussi ; le reste, ils
l'ont raté. <b>Confirmées</b> : de ce que signalent les détecteurs, la part que l'analyste range aussi dans la catégorie ;
le reste, ce sont des alertes en trop, ou un oubli de l'analyste. Le but : 100 % dans les deux colonnes ; « — » : rien à
compter. Les moments hors catégorie ne comptent pas, ni les trous (pas de mesure). En italique, les catégories regroupées comme sur la page du client : zones grisées, et zones
de prudence (visibilité réduite, turbulence).</p>
{tableau(total, ordre)}
<h3>Benchmark sur la base de cas</h3>
<p>Les mêmes détecteurs, face au diagnostic gardé dans chaque cas de la base à sa création (ses étiquettes), toutes
catégories ensemble. Il garde les détecteurs d'un recul ; il n'est pas un but. Le détail par catégorie :
<code>python3 .claude/skills/boucle/benchmark.py</code> ; dans le temps : <code>{benchmark.os.path.relpath(benchmark.HISTORIQUE, ROOT)}</code>
(version {benchmark.version()}).</p>
{tableau(bench, list(bench), "Cas")}
</body></html>""")
return chemin
if __name__ == "__main__":
if len(sys.argv) != 3:
sys.exit(__doc__)
p = page(sys.argv[1], sys.argv[2])
print(p)
open_html(p)