2026-10-26 16:48:13 +01:00
"""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,
2026-10-27 10:05:04 +01:00
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
2026-10-26 16:48:13 +01:00
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
2026-10-27 10:05:04 +01:00
# 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>" )
2026-10-26 16:48:13 +01:00
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 ]
2026-10-27 10:05:04 +01:00
fig = make_subplots ( rows = 4 , cols = 1 , shared_xaxes = True , vertical_spacing = 0.03 ,
row_heights = [ 260 , 260 , 40 * len ( ordre ) + 20 , 30 ],
2026-10-26 16:48:13 +01:00
subplot_titles = ( "corr_x (px)" , "corr_y (px)" ,
2026-10-27 10:05:04 +01:00
"Classification : analyste (bleu, en haut ; gris : hors catégorie), détecteurs (orange, en bas)" , "" ))
2026-10-26 16:48:13 +01:00
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 )
2026-10-27 10:05:04 +01:00
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" ,
2026-10-26 16:48:13 +01:00
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
2026-10-27 10:05:04 +01:00
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>
2026-10-26 16:48:13 +01:00
{ 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 )