182 lines
12 KiB
Python
182 lines
12 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. 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.
|
|
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
|
|
# 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"]
|
|
|
|
|
|
def taux_erreur(mesures, a, b):
|
|
"""Ligne « Error rate » : à chaque instant de [a, b), l'error_value moyenne de tous les capteurs, du vert au rouge sur
|
|
une échelle fixe de 0 à 1, avec sa barre de couleur. Dans sa propre rangée : une heatmap sur les axes des barres fait
|
|
planter plotly.js 4.1.1."""
|
|
par_t = {}
|
|
for ms in mesures.values():
|
|
for m in ms:
|
|
if a <= m["t"] < b and m["error_value"] is not None:
|
|
par_t.setdefault(m["t"], []).append((m["error_value"], m["error_threshold"]))
|
|
erreurs = sorted(par_t.items())
|
|
return go.Heatmap(
|
|
x=[t for t, _ in erreurs], y=["Error rate"], z=[[statistics.mean(e for e, _ in v) for _, v in erreurs]],
|
|
text=[[f"{len(v)} capteurs, {sum(1 for e, th in v if th is not None and e > th)} rejetés" for _, v in erreurs]],
|
|
zmin=0, zmax=1, colorscale=[[i / (len(VERT_ROUGE) - 1), c] for i, c in enumerate(VERT_ROUGE)],
|
|
colorbar={"title": {"text": "Error rate", "side": "right"}, "thickness": 12, "len": 0.3, "y": 0, "yanchor": "bottom"},
|
|
hovertemplate="%{x|%Y-%m-%d %H:%M} UTC<br>error_value moyenne : %{z:.3f}<br>%{text}<extra></extra>")
|
|
|
|
|
|
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=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()}
|
|
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. 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).
|
|
<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)
|