comparaison.py: the end-of-session page of /boucle is now the detecteurs.py page, with the analyst's bars above the detectors'

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
maximeandClaude Opus 5.5 committed 2026-10-27 10:30:18 +01:00
1 parent 5e665e761a
commit eca278279d
4 files changed
+46 -74

No files matched your search

+1 -1
View File
@@ -94,6 +94,6 @@ Si `git status --short docs/ameliorations-processus.md` montre un changement : c
## 7. Réponse finale
`python3 .claude/skills/boucle/comparaison.py <dossier> <séance>` : la page de fin de séance, `out/boucle_<SEANCE>_<STATION>.html`, qui s'ouvre dans le navigateur (D-066). En haut, `corr_x` et `corr_y` de tous les capteurs sur toute la plage de la séance ; dessous, une ligne par catégorie : la lecture de l'analyste (ses étiquettes) au-dessus des événements des détecteurs tels qu'ils sont en fin de séance, et en gris ses moments hors catégorie ; tout en bas, la ligne « Error rate », l'`error_value` moyenne de tous les capteurs à chaque instant (du vert au rouge, avec sa barre de couleur, comme `detecteurs.py`) ; sous la figure, le score de la séance et le benchmark sur la base de cas. Le but, séance après séance : que les deux coïncident. Un échec du script va dans la réponse, sans relance.
`python3 .claude/skills/boucle/comparaison.py <dossier> <séance>` : la page de fin de séance, `out/boucle_<SEANCE>_<STATION>.html`, qui s'ouvre dans le navigateur (D-066). C'est la page de `python3 .claude/skills/boucle/detecteurs.py <dossier> --du <début> --au <fin>` sur la plage de la séance (images de la caméra et timelapse d'un événement au clic, pose de la caméra, `corr_x` et `corr_y` de chaque capteur, ligne « Error rate »), chaque ligne de catégorie dédoublée : la lecture de l'analyste (ses étiquettes) au-dessus des événements des détecteurs tels qu'ils sont en fin de séance, et en gris ses moments hors catégorie ; sous la figure, la liste des événements, le score de la séance et le benchmark sur la base de cas. Le but, séance après séance : que les deux coïncident. Un échec du script va dans la réponse, sans relance.
En 8 lignes au plus : la page, la base de la séance, le chemin du bilan, le benchmark (ligne `total` / `toutes`, `grep -E '^total +toutes'`, début → fin), le nombre de modifications gardées et de cas créés, le nombre d'étiquettes (`<séance>/lot-*/etiquettes.json`, à garder même si l'utilisateur annule des modifications : elles ne dépendent pas des détecteurs), les erreurs, les difficultés relevées et, avec `--ameliorer`, celles corrigées. Tout est sur `master`, rien n'est poussé : l'utilisateur annule ce qu'il ne garde pas par `git revert`.
+21 -63
View File
@@ -1,12 +1,12 @@
"""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. Tout en bas, la ligne « Error rate » : à chaque instant, l'error_value moyenne de tous les capteurs (du vert
au rouge, échelle fixe de 0 à 1, comme detecteurs.py). 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.
La page de detecteurs.py (images de la caméra, timelapse d'un événement au clic, pose de la caméra, corr_x et corr_y de
chaque capteur en couleur, ligne « Error rate »), chaque ligne de catégorie dédoublée : en haut 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 (la plage classée 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é). Sous la figure, la liste des
événements des détecteurs, le score de la séance (score.py sur ses seules étiquettes) et le benchmark. 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)
"""
@@ -29,7 +29,6 @@ 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
# du vert au rouge (demande de l'utilisateur, 2026-10-27) : couleurs d'état de la palette de référence (skill dataviz)
VERT_ROUGE = ["#0ca30c", "#fab219", "#ec835a", "#d03b3b"]
@@ -85,6 +84,9 @@ def tableau(total, ordre, titre="Catégorie"):
def page(dossier, seance):
"""La page de detecteurs.py sur la plage de la séance (images, timelapse, pose de la caméra, capteurs en couleur),
plus les moments de l'analyste, le score de la séance et le benchmark."""
import detecteurs # ici : detecteurs importe ce module
chemins = sorted(glob.glob(os.path.join(seance, "lot-*", "etiquettes.json")))
if not chemins:
sys.exit(f"{seance} : aucun lot-*/etiquettes.json")
@@ -93,70 +95,26 @@ def page(dossier, seance):
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=4, cols=1, shared_xaxes=True, vertical_spacing=0.03,
row_heights=[260, 260, 40 * len(ordre) + 20, 30],
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.add_trace(taux_erreur(mesures, a, b), row=4, col=1)
fig.update_layout(barmode="group", bargap=0.25, bargroupgap=0.1, height=650 + 40 * len(ordre),
margin={"l": 170, "r": 90, "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()}
ordre = [*score.categories.CATEGORIES, HORS]
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>
entete = f"""<h1>Séance {html.escape(nom)}</h1>
<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. Ligne Error rate : error_value moyenne de tous les capteurs à chaque instant.
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).
souvent, ou une nouveauté ; aucun détecteur ne peut le rejoindre. Survol : capteurs, preuve, description ; un clic sur une
barre, de l'analyste ou des détecteurs, joue son timelapse. Le but de la boucle : que les deux barres de chaque ligne coïncident.</p>"""
annexe = f"""<style>td small{{color:#8a8984}} tr.niveau td{{color:#5f5e5a;font-style:italic}}</style>
<h3>Score de la séance</h3>
<p>On compte des mesures : une mesure, c'est un capteur à un instant.
<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 à
@@ -166,11 +124,11 @@ de prudence (visibilité réduite, turbulence).</p>
<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>
<code>python3 .claude/skills/boucle/benchmark.py</code> ; dans le temps : <code>{os.path.relpath(benchmark.HISTORIQUE, ROOT)}</code>
(version {benchmark.version()}).</p>
{tableau(bench, list(bench), "Cas")}
</body></html>""")
return chemin
{tableau(bench, list(bench), "Cas")}"""
return detecteurs.page(dossier, debut, fin, entete=entete, annexe=annexe, analyste=agent,
chemin=os.path.join(ROOT, "out", f"boucle_{nom}.html"))
if __name__ == "__main__":
+23 -9
View File
@@ -94,7 +94,7 @@ document.getElementById('gif-av').onclick = () => { joue(false); image(G.k - 1);
document.getElementById('gif-ap').onclick = () => { joue(false); image(G.k + 1); };
gd.on('plotly_click', ev => {
const p = ev.points[0];
if (p.data.name === 'Détecteurs') return gif(p.customdata);
if (p.customdata) return gif(p.customdata); // la barre d'un événement (détecteurs ou analyste)
const x = ms(String(p.x));
let best = 0;
IM.forEach((m, i) => { if (Math.abs(ms(m.t) - x) < Math.abs(ms(IM[best].t) - x)) best = i; });
@@ -104,8 +104,10 @@ montre(0);
"""
def page(dossier, du=None, au=None, entete="", annexe="", chemin=None):
"""entete, annexe : HTML ajouté avant et après la figure (page de /revue-cas) ; chemin : la page, sinon out/detecteurs_…."""
def page(dossier, du=None, au=None, entete="", annexe="", chemin=None, analyste=()):
"""entete, annexe : HTML ajouté avant et après la figure (page de /revue-cas) ; chemin : la page, sinon out/detecteurs_… ;
analyste : ses moments [(début, fin, catégorie, survol)], en barres au-dessus de celles des détecteurs, chaque ligne de
catégorie dédoublée (page de fin de séance de /boucle, comparaison.py)."""
mesures = score.charger(dossier)
if not mesures:
raise SystemExit(f"Aucun export « advanced » dans {dossier}.")
@@ -120,8 +122,11 @@ def page(dossier, du=None, au=None, entete="", annexe="", chemin=None):
evts = score.evenements(mesures, score.iso(a), score.iso(b))
spans = [(v["start"], v["end"], v["category"],
comparaison.survol(v["label"], v["start"], v["end"], v["sensors"], v["text"])) for v in evts]
presentes = {v["category"] for v in evts}
ordre = [c for c in [*score.categories.CATEGORIES, *sorted(presentes - set(score.categories.CATEGORIES))] if c in presentes]
hors = comparaison.HORS
presentes = {v["category"] for v in evts} | {s[2] for s in analyste}
ordre = [c for c in [*score.categories.CATEGORIES, *sorted(presentes - set(score.categories.CATEGORIES) - {hors}), hors]
if c in presentes]
haut = 40 if analyste else 30 # deux barres par ligne avec l'analyste
station = os.path.basename(os.path.normpath(dossier))
nom = f"{station}_{score.iso(a)[:10]}_{score.iso(b)[:10]}"
chemin = chemin or os.path.join(ROOT, "out", f"detecteurs_{nom}.html")
@@ -131,9 +136,10 @@ def page(dossier, du=None, au=None, entete="", annexe="", chemin=None):
poses = [p for p in donnees.charger_camera(dossier) if a <= p["t"] < b]
c = 1 if poses else 0 # la ligne de la caméra, seulement si le dossier a des poses sur la plage
fig = make_subplots(rows=4 + c, cols=1, shared_xaxes=True, vertical_spacing=0.025,
row_heights=[200] * c + [260, 260, 30 * len(ordre) + 20, 30],
row_heights=[200] * c + [260, 260, haut * len(ordre) + 20, 30],
subplot_titles=(*["Caméra : pan, tilt, rotation (deg)"] * c, "corr_x (px)", "corr_y (px)",
"Événements des détecteurs, par catégorie", ""))
"Classification : analyste (bleu, en haut ; gris : hors catégorie), détecteurs (orange, en bas)"
if analyste else "Événements des détecteurs, par catégorie", ""))
for col, couleur in POSE if poses else ():
fig.add_trace(go.Scatter(x=[p["t"] for p in poses], y=[p[col] for p in poses], name=col, mode="lines",
line={"width": 1.2, "color": couleur}, hovertemplate=f"{col} : %{{y:.4f}}°<extra></extra>"), row=1, col=1)
@@ -150,9 +156,17 @@ def page(dossier, du=None, au=None, entete="", annexe="", chemin=None):
d.customdata = [[v["start"], score.iso(score.instant(v["end"]) + pas), v["label"]] for v in evts] # le clic : son timelapse
if images:
d.hovertext = [h + "<br><i>clic : timelapse des images</i>" for h in d.hovertext]
fig.add_trace(d, row=3 + c, col=1)
fig.add_trace(d, row=3 + c, col=1) # en mode group, le 1er groupe en bas
for nom_a, couleur, rang, sel in (("Analyste", comparaison.AGENT, 2, [s for s in analyste if s[2] != hors]),
(f"Analyste, {hors}", comparaison.GRIS, 3, [s for s in analyste if s[2] == hors])):
if sel:
t = comparaison.barres(nom_a, couleur, sel, pas, rang, "a")
t.customdata = [[s[0], score.iso(score.instant(s[1]) + pas), f"Analyste : {s[2]}"] for s in sel]
if images:
t.hovertext = [h + "<br><i>clic : timelapse des images</i>" for h in t.hovertext]
fig.add_trace(t, row=3 + c, col=1)
fig.add_trace(comparaison.taux_erreur(mesures, a, b), row=4 + c, col=1)
fig.update_layout(bargap=0.3, height=680 + 230 * c + 30 * len(ordre), hovermode="closest",
fig.update_layout(barmode="group", bargap=0.3, bargroupgap=0.1, height=680 + 230 * c + haut * len(ordre), hovermode="closest",
plot_bgcolor="white", margin={"l": 170, "r": 90, "t": 40, "b": 40},
legend={"orientation": "h", "x": 0, "y": 1.02, "yanchor": "bottom", # au-dessus : à droite, la barre de l'Error rate
"title": {"text": "clic : cacher, double clic : seul", "side": "top left"}})
+1 -1
View File
@@ -44,7 +44,7 @@ Dans une session Claude Code neuve, **en mode auto**, à la racine de Support-Ag
- Le modèle et l'effort choisis pour la session valent pour tous ses agents (D-063).
- La séance tourne seule, sans question, à lancer sur `master`, où elle commite directement (D-070), un commit par étape : analyste, upgrader et validateur si l'analyste a des suggestions, builder s'il y a des nouveautés, puis le releveur, qui note les difficultés dans `docs/ameliorations-processus.md` (rien à demander). Avec `--ameliorer`, l'améliorateur corrige ensuite le skill `/boucle` et ses agents d'après ces relevés et marque les entrées **traité** ; ce qui sort de son périmètre (outils de lecture, détecteurs) ou change ce que fait la boucle reste à traiter à la main (D-071). Les fichiers modifiés et non commités restent sans être commités.
- Bilan dans `vues-deplacements/boucle/<séance>_<SERIE>/bilan.md` ; les étiquettes de l'analyste (`lot-*/etiquettes.json`) sont à garder même si on annule une modification. Ensuite : `git revert` des commits de la séance qu'on ne garde pas (la base de la séance est dans le bilan).
- À la fin, la page `out/boucle_<séance>_<SERIE>.html` s'ouvre (D-066) : les courbes de la plage ; dessous, catégorie par catégorie, l'analyste (bleu) face aux détecteurs (orange) ; le score de la séance et le benchmark.
- À la fin, la page `out/boucle_<séance>_<SERIE>.html` s'ouvre (D-066) : la page de `detecteurs.py` (ci-dessous) sur la plage, images et timelapse compris ; dessous les courbes, catégorie par catégorie, l'analyste (bleu) face aux détecteurs (orange) ; le score de la séance et le benchmark.
- Le benchmark (D-069) : les détecteurs face au diagnostic gardé dans chaque cas de la base (`agents/diagnostic/cas/C-*/etiquettes.json`), lancé au début de chaque lot, après chaque modification et en fin de séance ; chaque passage s'ajoute à `vues-deplacements/benchmark/historique.csv`, avec la version des détecteurs.
Refaire la page d'une séance :