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>
This commit is contained in:
1 parent
6b3d058a67
commit
d5bae7a696
57 files changed
+1727
-157
No files matched your search
@@ -2,7 +2,7 @@
|
||||
name: boucle
|
||||
description: Séance automatique d'amélioration des détecteurs du journal du matin et de la base de cas, lot après lot, sur une station (D-057) — analyste, upgrader, validateur, builder. Lancé par l'utilisateur seulement, avec /boucle.
|
||||
disable-model-invocation: true
|
||||
argument-hint: "<dossier de station> [--du AAAA-MM-JJ] [--au AAAA-MM-JJ] [--lot 4]"
|
||||
argument-hint: "data/<STATION> [--du AAAA-MM-JJ] [--au AAAA-MM-JJ] [--lot 4]"
|
||||
---
|
||||
|
||||
# La boucle automatique
|
||||
@@ -11,17 +11,17 @@ Tu es l'orchestrateur. Tu découpes la plage en lots, tu appelles les quatre age
|
||||
|
||||
## 1. Mise en place
|
||||
|
||||
- Arguments : le dossier de station ; `--du`, `--au` (jours UTC, facultatifs : sans eux, toute la période) ; `--lot` (jours, 4 par défaut). L'utilisateur choisit ses lots : `--du` / `--au` sur la plage d'un lot n'en traite qu'un.
|
||||
- `python3 agents/diagnostic/outils/inventaire.py <dossier>` : sans export « advanced », dis-le et arrête-toi.
|
||||
- Arguments : le dossier de station ; un nom de station seul (« Nordend ») désigne `data/<NOM EN MAJUSCULES>/` (D-065) ; `--du`, `--au` (jours UTC, facultatifs : sans eux, toute la période ; **`--au` est exclu** : la plage s'arrête à `--au` 00:00Z, `--du 2026-09-01 --au 2026-09-05` fait 4 jours) ; `--lot` (jours, 4 par défaut). L'utilisateur choisit ses lots : `--du` / `--au` sur la plage d'un lot n'en traite qu'un. Des dates écrites autrement (« 2026-09.01 », deux dates sans option) se lisent comme `--du` puis `--au` ; écris dans le bilan, sous « Erreurs », comment tu as lu un argument qui n'était pas net.
|
||||
- `python3 agents/diagnostic/outils/inventaire.py <dossier>` : dossier absent ou sans export « advanced », dis-le et arrête-toi.
|
||||
- `STATION` = le nom du dossier de station (`NORDEND`) ; `SEANCE` = `date -u +%Y-%m-%dT%H%MZ`.
|
||||
- `git switch -c boucle/<SEANCE>_<STATION>` ; les fichiers modifiés de l'utilisateur suivent sans être commités : tu commites toujours par chemin.
|
||||
- `git switch -c boucle/<SEANCE>_<STATION>` ; les fichiers modifiés de l'utilisateur suivent sans être commités : tu commites toujours par chemin. Une autre session peut travailler dans le même dépôt pendant la séance (fichiers modifiés, index déjà chargé, même ce skill) : `git commit -- <chemins>` ne prend que tes chemins ; n'indexe rien d'autre, jamais de `git add -A`, `git stash` ni `git checkout` hors de tes chemins ; garde les consignes lues au début et note le changement dans tes difficultés.
|
||||
- Dossier de séance : `vues-deplacements/boucle/<SEANCE>_<STATION>/`, ci-dessous `<séance>`.
|
||||
|
||||
## 2. Les lots
|
||||
|
||||
`python3 vues-deplacements/journal/categories.py <dossier> --tranche <lot> [--du …] [--au …]` : chaque en-tête `== <début> → <fin> : …` est un lot, numéroté `01`, `02`… Dossier du lot : `<séance>/lot-NN/`, ci-dessous `<lot>`.
|
||||
`python3 vues-deplacements/detectors/categories.py <dossier> --tranche <lot> [--du …] [--au …]` : chaque en-tête `== <début> → <fin> : …` est un lot, numéroté `01`, `02`… Dossier du lot : `<séance>/lot-NN/`, ci-dessous `<lot>`.
|
||||
|
||||
**Commande du lot**, donnée telle quelle aux agents : `python3 vues-deplacements/journal/categories.py <dossier> --du <jour du début> --tranche <lot>`, plus `--au <jour de la fin>` si la fin tombe à `00:00Z` ; sinon c'est le dernier lot, sans `--au`. Exemple : lot `2026-10-05T00:00Z → 2026-10-09T00:00Z` : `--du 2026-10-05 --au 2026-10-09 --tranche 4`.
|
||||
**Commande du lot**, donnée telle quelle aux agents : `python3 vues-deplacements/detectors/categories.py <dossier> --du <jour du début> --tranche <lot>`, plus `--au <jour de la fin>` si la fin tombe à `00:00Z` ; sinon c'est le dernier lot, sans `--au`. Exemple : lot `2026-10-05T00:00Z → 2026-10-09T00:00Z` : `--du 2026-10-05 --au 2026-10-09 --tranche 4`.
|
||||
|
||||
## 3. Pour chaque lot, dans l'ordre
|
||||
|
||||
@@ -30,20 +30,22 @@ Chaque agent est appelé par l'outil Agent avec son `subagent_type` et la demand
|
||||
1. **Analyste** (`analyste`) : `Dossier : <dossier>. Lot NN : <début> → <fin> (UTC). Commande du lot : <commande>. Écris <lot>/critique.md.`
|
||||
`python3 .claude/skills/critiquer-lot/etiquettes.py <dossier> <lot>/etiquettes.json` : sa dernière ligne va au bilan (colonne Étiquettes : « n moments », « absentes » ou « n défauts ») ; tu ne corriges rien et ne relances pas l'analyste pour elles (D-061).
|
||||
`python3 .claude/skills/boucle/score.py <dossier> > <lot>/score-avant.txt 2>&1` : le score des détecteurs du début du lot sur toutes les étiquettes de la station, ce lot compris (D-062).
|
||||
Commit `<lot>/`, message `Loop <STATION> lot NN: critique (<verdict>)`.
|
||||
`python3 .claude/skills/boucle/benchmark.py --seance <SEANCE> --etape "lot-NN avant" > <lot>/benchmark-avant.txt 2>&1` : le benchmark, les détecteurs face au diagnostic gardé dans chaque cas de la base, ajouté à l'historique (D-069).
|
||||
Commit `<lot>/ vues-deplacements/benchmark/historique.csv`, message `Loop <STATION> lot NN: critique (<verdict>)`.
|
||||
2. Verdict `d'accord` : va à l'étape 5.
|
||||
3. **Upgrader** (`upgrader`), passage K = 1, 2 ou 3. Avant le passage 1, note la **base du lot** : `git rev-parse HEAD`.
|
||||
`Dossier : <dossier>. Lot NN : <début> → <fin> (UTC). Commande du lot : <commande>. Critique : <lot>/critique.md. Score avant : <lot>/score-avant.txt. [Validation précédente : <lot>/validation-(K-1).md.] Passage K. Écris <lot>/modification-K.md.`
|
||||
Commit `vues-deplacements/journal/ vues-deplacements/contexte/seuils-du-journal.md <lot>/`, message `Loop <STATION> lot NN: modification K`.
|
||||
4. **Validateur** (`validateur`) : `Dossier : <dossier>. Lot NN : <début> → <fin> (UTC). Commande du lot : <commande>. Critique : <lot>/critique.md. Score avant : <lot>/score-avant.txt. Modification : <lot>/modification-K.md. Base : <base du lot>. Passage K sur 3. Écris <lot>/validation-K.md.`
|
||||
Commit `<lot>/`, message `Loop <STATION> lot NN: validation K (<verdict>)`.
|
||||
`Dossier : <dossier>. Lot NN : <début> → <fin> (UTC). Commande du lot : <commande>. Critique : <lot>/critique.md. Score avant : <lot>/score-avant.txt. Benchmark avant : <lot>/benchmark-avant.txt. [Validation précédente : <lot>/validation-(K-1).md.] Passage K. Écris <lot>/modification-K.md.`
|
||||
Commit `vues-deplacements/detectors/ vues-deplacements/contexte/seuils-du-journal.md <lot>/`, message `Loop <STATION> lot NN: modification K`.
|
||||
Puis, les détecteurs commités : `python3 .claude/skills/boucle/benchmark.py --seance <SEANCE> --etape "lot-NN modification K" > <lot>/benchmark-K.txt 2>&1` (commité avec la validation).
|
||||
4. **Validateur** (`validateur`) : `Dossier : <dossier>. Lot NN : <début> → <fin> (UTC). Commande du lot : <commande>. Critique : <lot>/critique.md. Score avant : <lot>/score-avant.txt. Modification : <lot>/modification-K.md. Benchmark : <lot>/benchmark-avant.txt → <lot>/benchmark-K.txt. Base : <base du lot>. Passage K sur 3. Écris <lot>/validation-K.md.`
|
||||
Commit `<lot>/ vues-deplacements/benchmark/historique.csv`, message `Loop <STATION> lot NN: validation K (<verdict>)`.
|
||||
- `accepté` ou `garder` : va à l'étape 5.
|
||||
- `à reprendre` : retour à l'étape 3, passage K + 1.
|
||||
- `annuler` : `git checkout <base du lot> -- vues-deplacements/journal/ vues-deplacements/contexte/seuils-du-journal.md`, commit de ces deux chemins, message `Loop <STATION> lot NN: modification annulée`.
|
||||
- `annuler` : `git checkout <base du lot> -- vues-deplacements/detectors/ vues-deplacements/contexte/seuils-du-journal.md`, commit de ces deux chemins, message `Loop <STATION> lot NN: modification annulée`.
|
||||
5. **Builder** (`builder`), seulement si l'un des rendus du lot a, sous `## Nouveautés`, autre chose que `aucune` : `Dossier : <dossier>. Lot NN : <début> → <fin> (UTC). Dossier du lot : <lot>/. Séance : <séance>/. Écris <lot>/builder.md.`
|
||||
Si sa ligne `**Cas créés** :` n'est pas `aucun` : commit `agents/diagnostic/cas/ .claude/skills/anonymiser-cas/registre.csv <lot>/`, message `Loop <STATION> lot NN: cas C-xxx, …` ; sinon commit `<lot>/`, message `Loop <STATION> lot NN: builder (aucun cas)`.
|
||||
|
||||
Le lot suivant tourne avec les détecteurs tels qu'ils sont devenus. L'analyste ne relit pas les lots déjà vus ; le score les rejoue, sur leurs étiquettes.
|
||||
Le lot suivant tourne avec les détecteurs tels qu'ils sont devenus. L'analyste ne relit pas les lots déjà vus ; le score les rejoue, sur leurs étiquettes, et le benchmark rejoue les cas de la base, les cas créés au lot compris (leur `etiquettes.json`).
|
||||
|
||||
## 4. Imprévus
|
||||
|
||||
@@ -52,6 +54,7 @@ Un rendu absent après son agent, ou sans ligne de verdict lisible : note-le pou
|
||||
## 5. Bilan
|
||||
|
||||
`python3 .claude/skills/boucle/score.py <dossier> > <séance>/score-fin.txt 2>&1` : le score des détecteurs de fin de séance sur toutes les étiquettes de la station.
|
||||
`python3 .claude/skills/boucle/benchmark.py --seance <SEANCE> --etape fin > <séance>/benchmark-fin.txt 2>&1` : le benchmark de fin de séance (D-069).
|
||||
|
||||
`<séance>/bilan.md` :
|
||||
|
||||
@@ -62,6 +65,10 @@ Branche : boucle/<SEANCE>_<STATION>
|
||||
|
||||
Score : au début de chaque lot `lot-NN/score-avant.txt`, en fin de séance `score-fin.txt` (D-062).
|
||||
|
||||
Benchmark sur la base de cas (D-069) : au début de chaque lot `lot-NN/benchmark-avant.txt`, après chaque modification `lot-NN/benchmark-K.txt`, en fin de séance `benchmark-fin.txt` ; historique `vues-deplacements/benchmark/historique.csv`. Total : <ligne `total toutes` du premier benchmark> → <celle de `benchmark-fin.txt`>.
|
||||
|
||||
Page : `out/boucle_<SEANCE>_<STATION>.html`, l'analyste face aux détecteurs sur toute la plage (D-066) ; la refaire : `python3 .claude/skills/boucle/comparaison.py <dossier> <séance>`.
|
||||
|
||||
| Lot | Dates (UTC) | Analyste | Étiquettes | Modification | Cas créés |
|
||||
|---|---|---|---|---|---|
|
||||
| 01 | … → … | d'accord / suggestions (n) | n moments / absentes / n défauts | aucune / gardée (K passages) / annulée / erreur | C-xxx / aucun |
|
||||
@@ -76,7 +83,7 @@ Score : au début de chaque lot `lot-NN/score-avant.txt`, en fin de séance `sco
|
||||
aucune | <lot, agent, ce qui manquait>
|
||||
```
|
||||
|
||||
Commit `<séance>/bilan.md <séance>/score-fin.txt`, message `Loop <STATION>: bilan`.
|
||||
Commit `<séance>/bilan.md <séance>/score-fin.txt <séance>/benchmark-fin.txt vues-deplacements/benchmark/historique.csv`, message `Loop <STATION>: bilan`.
|
||||
|
||||
## 6. Difficultés
|
||||
|
||||
@@ -85,4 +92,6 @@ Si `git status --short docs/ameliorations-processus.md` montre un changement : c
|
||||
|
||||
## 7. Réponse finale
|
||||
|
||||
En 6 lignes au plus : la branche, le chemin du bilan, 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. Reste sur la branche : l'utilisateur la fusionne, en garde une partie ou revient en arrière.
|
||||
`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 ; 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.
|
||||
|
||||
En 8 lignes au plus : la page, la branche, le chemin du bilan, le benchmark (ligne `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. Reste sur la branche : l'utilisateur la fusionne, en garde une partie ou revient en arrière.
|
||||
@@ -0,0 +1,93 @@
|
||||
"""Benchmark des détecteurs sur la base de cas (point 48 du plan du journal du matin, D-069).
|
||||
|
||||
Chaque cas d'agents/diagnostic/cas/ qui a son etiquettes.json (le diagnostic de l'analyste, figé à la création du cas) :
|
||||
les détecteurs tels qu'ils sont, face à ces étiquettes, mesure par mesure et capteur par capteur (score.py, D-062).
|
||||
Un calcul seulement, sans agent. Par cas, puis au total, et par catégorie : « trouvées » (part des mesures étiquetées
|
||||
que les détecteurs signalent) et « justes » (part des mesures signalées que l'analyste a étiquetées) ; « toutes »
|
||||
somme les catégories (pas les deux niveaux de validité, qui les regroupent). Le benchmark garde les détecteurs
|
||||
d'un recul : il n'est pas un but (sur une dizaine de cas, les détecteurs se régleraient sur eux).
|
||||
Avec --etape, chaque ligne entre dans l'historique, vues-deplacements/benchmark/historique.csv, avec la version des
|
||||
détecteurs (le commit, suivi de « + » si vues-deplacements/detectors/ a des changements non commités) : le score
|
||||
dans le temps, version par version.
|
||||
Usage : python3 .claude/skills/boucle/benchmark.py [--seance <séance> --etape <étape>]
|
||||
"""
|
||||
import argparse
|
||||
import contextlib
|
||||
import csv
|
||||
import glob
|
||||
import io
|
||||
import os
|
||||
import subprocess
|
||||
import sys
|
||||
from datetime import datetime, timezone
|
||||
|
||||
ICI = os.path.dirname(os.path.abspath(__file__))
|
||||
sys.path.insert(0, ICI)
|
||||
import score # noqa: E402
|
||||
|
||||
RACINE = os.path.normpath(os.path.join(ICI, "..", "..", ".."))
|
||||
HISTORIQUE = os.path.join(RACINE, "vues-deplacements", "benchmark", "historique.csv")
|
||||
TOUTES = "toutes"
|
||||
|
||||
|
||||
def version():
|
||||
def git(*a):
|
||||
return subprocess.run(["git", "-C", RACINE, *a], capture_output=True, text=True).stdout.strip()
|
||||
return git("rev-parse", "--short", "HEAD") + ("+" if git("status", "--porcelain", "--", "vues-deplacements/detectors") else "")
|
||||
|
||||
|
||||
def mesurer():
|
||||
"""-> ({cas: {clé: [étiquetées, signalées, les deux]}}, [cas sautés et pourquoi]) ; le total sous « total »."""
|
||||
res, sautes = {}, []
|
||||
for chemin in sorted(glob.glob(os.path.join(RACINE, "agents", "diagnostic", "cas", "C-*", "etiquettes.json"))):
|
||||
cas = os.path.dirname(chemin)
|
||||
sortie = io.StringIO()
|
||||
with contextlib.redirect_stdout(sortie):
|
||||
n = score.lots(cas, [chemin], True)
|
||||
if "sauté" in sortie.getvalue():
|
||||
sautes.append(sortie.getvalue().strip())
|
||||
continue
|
||||
n[TOUTES] = [sum(v[i] for k, v in n.items() if k not in score.NIVEAUX) for i in range(3)]
|
||||
res[os.path.basename(cas)] = n
|
||||
total = {}
|
||||
for n in res.values():
|
||||
for k, v in n.items():
|
||||
total[k] = [a + b for a, b in zip(total.get(k, [0, 0, 0]), v)]
|
||||
if res:
|
||||
res["total"] = total
|
||||
return res, sautes
|
||||
|
||||
|
||||
def afficher(res, sautes, ver):
|
||||
print(f"Benchmark des détecteurs (version {ver}) sur {len(res) - 1 if res else 0} cas, mesure par mesure")
|
||||
print(f"{'cas':8}{'catégorie':24}{'trouvées':>20}{'justes':>20}")
|
||||
for cas, n in res.items():
|
||||
for i, k in enumerate([TOUTES, *sorted(k for k in n if k != TOUTES)]):
|
||||
lab, sig, both = n[k]
|
||||
print(f"{cas if i == 0 else '':8}{k:24}{score.pct(both, lab):>20}{score.pct(both, sig):>20}")
|
||||
for s in sautes:
|
||||
print(s)
|
||||
|
||||
|
||||
def historiser(res, ver, seance, etape):
|
||||
os.makedirs(os.path.dirname(HISTORIQUE), exist_ok=True)
|
||||
neuf = not os.path.exists(HISTORIQUE)
|
||||
date = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%MZ")
|
||||
with open(HISTORIQUE, "a", newline="", encoding="utf-8") as f:
|
||||
w = csv.writer(f)
|
||||
if neuf:
|
||||
w.writerow(("date", "seance", "etape", "version", "cas", "categorie", "etiquetees", "signalees", "les_deux"))
|
||||
w.writerows((date, seance, etape, ver, cas, k, *v) for cas, n in res.items() for k, v in sorted(n.items()))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
p = argparse.ArgumentParser(usage=__doc__)
|
||||
p.add_argument("--seance", default="—")
|
||||
p.add_argument("--etape", help="écrit les lignes dans l'historique sous cette étape (« lot-01 avant »…)")
|
||||
a = p.parse_args()
|
||||
res, sautes = mesurer()
|
||||
ver = version()
|
||||
afficher(res, sautes, ver)
|
||||
if a.etape:
|
||||
historiser(res, ver, a.seance, a.etape)
|
||||
print(f"historique : {os.path.relpath(HISTORIQUE, RACINE)}")
|
||||
@@ -0,0 +1,158 @@
|
||||
"""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)
|
||||
@@ -22,7 +22,7 @@ from datetime import timedelta
|
||||
from pathlib import Path
|
||||
|
||||
RACINE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "..")
|
||||
sys.path.insert(0, os.path.join(RACINE, "vues-deplacements", "journal"))
|
||||
sys.path.insert(0, os.path.join(RACINE, "vues-deplacements", "detectors"))
|
||||
sys.path.insert(0, os.path.join(RACINE, ".claude", "skills", "critiquer-lot"))
|
||||
import categories # noqa: E402 (il met lui-même agents/diagnostic/outils sur le chemin)
|
||||
from donnees import charger, instant, iso # noqa: E402
|
||||
@@ -55,12 +55,16 @@ def marquer(cs, spans):
|
||||
return out
|
||||
|
||||
|
||||
def detectes(mesures, debut, fin):
|
||||
"""Événements des détecteurs qui touchent le lot, classé avec ses jours d'historique -> spans de marquer."""
|
||||
def evenements(mesures, debut, fin):
|
||||
"""É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["start"], v["end"], v["sensors"], v["category"])
|
||||
for v in (categories.evenements(tranche) if tranche else []) if v["end"] >= debut]
|
||||
return [v for v in (categories.evenements(tranche) 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 score(etiq, det):
|
||||
@@ -119,6 +123,7 @@ def lots(dossier, chemins, explicite):
|
||||
afficher(f"Total : {vus} lots", total)
|
||||
elif not vus:
|
||||
print(f"Aucun lot étiqueté de {station} à compter.")
|
||||
return total # la page de fin de séance (comparaison.py) en fait son tableau
|
||||
|
||||
|
||||
def test():
|
||||
|
||||
Reference in new issue
Block a user