Events-learner on the labeler's labels: the session reads the lot's labels in labeling/auto/ instead of having the analyst read the lot; the detectors-critic judges the detectors against them, family by family (correspondence of labeling/familles.md); score.py --du --au scores by family and by instant, the session page shows labels and detectors on one row per family; analyst, tool-builder and event-builder leave the session (D-112, point 72)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
maximeandClaude Opus 5.5 committed 2026-11-02 16:25:44 +01:00
1 parent a95d7ca07a
commit bc984a86d3
14 files changed
+227 -151

No files matched your search

+29 -34
View File
@@ -1,65 +1,61 @@
---
name: events-learner
description: Séance automatique d'amélioration des détecteurs du journal du matin et de la base d'events, sur un lot d'une station, la plage choisie par l'utilisateur (D-057) — analyste, tool-builder, detectors-critic, detectors-upgrader, detectors-control, event-builder. Lancé par l'utilisateur seulement, avec /events-learner.
description: Séance automatique d'amélioration des détecteurs du journal du matin, sur un lot d'une station déjà étiqueté par l'etiqueteur (labeling/auto/), la plage choisie par l'utilisateur (D-057, D-112) — detectors-critic, detectors-upgrader, detectors-control. Lancé par l'utilisateur seulement, avec /events-learner.
disable-model-invocation: true
argument-hint: "data/<STATION> [--du AAAA-MM-JJ] [--au AAAA-MM-JJ] [--ameliorer]"
---
# events-learner : la boucle automatique
Tu es l'orchestrateur. Tu appelles les six agents dans l'ordre, tu transmets leurs rendus et tu commites ; en fin de séance, le releveur note leurs difficultés. **Tu ne juges rien toi-même** : tu lis seulement les lignes de verdict. **Tu ne poses aucune question à l'utilisateur** : la séance tourne seule jusqu'au bout. Spec : `vues-deplacements/contexte/events-learner.md`.
Tu es l'orchestrateur. La vérité de la séance, ce sont les étiquettes du lot, écrites en amont par l'`etiqueteur` dans `labeling/auto/<STATION>.jsonl` (D-106, D-112) ; tu appelles les trois agents dans l'ordre, tu transmets leurs rendus et tu commites ; en fin de séance, le releveur note leurs difficultés. **Tu ne juges rien toi-même** : tu lis seulement les lignes de verdict. **Tu ne poses aucune question à l'utilisateur** : la séance tourne seule jusqu'au bout. Spec : `vues-deplacements/contexte/events-learner.md`.
## 1. Mise en place
- 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) ; `--ameliorer` (facultatif : en fin de séance, l'améliorateur corrige le processus d'après les relevés du releveur, §6, D-071). **La plage est le lot** (D-072) : une séance traite un seul lot, de la longueur que l'utilisateur a choisie par `--du` / `--au`, sans découpe ; un `--lot` ou `--tranche` donné quand même est ignoré (note-le sous « Erreurs »). Des dates écrites autrement (« 2026-09.01 », deux dates sans option) se lisent comme `--du` puis `--au` ; une option entre crochets (`[--ameliorer]`, la syntaxe d'usage recopiée) vaut l'option sans crochets ; écris dans le bilan, sous « Erreurs », comment tu as lu un argument qui n'était pas net.
- `python3 agent-tools/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`.
- La séance se commite directement sur `master` (D-070) : `git branch --show-current` doit dire `master`, sinon dis-le et arrête-toi (pas de `git switch` : une autre session peut travailler dans ce dépôt). Note la **base de la séance** : `git rev-parse HEAD`. Les fichiers modifiés de l'utilisateur restent 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. Le commit par chemin ne protège pas un fichier que tu commites toi-même : note donc, au début, les fichiers déjà modifiés sur les chemins que la séance commite ou fait tourner, `git status --porcelain -- detectors/ vues-deplacements/contexte/seuils-du-journal.md agent-diagnostic/ .claude/skills/anonymize-event/registre.csv agent-tools/ .claude/skills/lire-les-donnees/` ; s'il y en a, liste-les au bilan sous « Erreurs » (les mesures tournent sur eux), ne les commite pas et ne les annule pas : aux étapes 2, 4 et 5 (outils, `annuler`), donne tes chemins fichier par fichier, sans eux (`git diff --name-only <base du lot> HEAD -- <chemins>` liste ceux de la séance).
- La séance se commite directement sur `master` (D-070) : `git branch --show-current` doit dire `master`, sinon dis-le et arrête-toi (pas de `git switch` : une autre session peut travailler dans ce dépôt). Note la **base de la séance** : `git rev-parse HEAD`. Les fichiers modifiés de l'utilisateur restent 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. Le commit par chemin ne protège pas un fichier que tu commites toi-même : note donc, au début, les fichiers déjà modifiés sur les chemins que la séance commite ou fait tourner, `git status --porcelain -- detectors/ vues-deplacements/contexte/seuils-du-journal.md agent-tools/ labeling/auto/` ; s'il y en a, liste-les au bilan sous « Erreurs » (les mesures tournent sur eux), ne les commite pas et ne les annule pas : à l'étape 4 (`annuler`) et au §4, donne tes chemins fichier par fichier, sans eux (`git diff --name-only <base du lot> HEAD -- <chemins>` liste ceux de la séance).
- Dossier de séance : `events-learner/<SEANCE>_<STATION>/`, ci-dessous `<séance>`.
## 2. Le lot
## 2. Le lot et ses étiquettes
Un seul lot, numéroté `01` (`NN` ci-dessous) : de `--du` 00:00Z (sinon le premier jour de la « Période des mesures » de l'inventaire, 00:00Z) à `--au` 00:00Z (sinon la fin de cette période). Une date qui déborde cette période y est ramenée (`--du` au premier jour de la période, `--au` au lendemain de son dernier jour), dans les bornes du lot comme dans sa commande, et dite sous « Erreurs » du bilan : hors de la période, il n'y a rien à lire ni à étiqueter. Dossier du lot : `<séance>/lot-01/`, ci-dessous `<lot>`.
Un seul lot, numéroté `01` (`NN` ci-dessous) : de `--du` 00:00Z (sinon le premier jour de la « Période des mesures » de l'inventaire, 00:00Z) à `--au` 00:00Z (sinon la fin de cette période). Une date qui déborde cette période y est ramenée (`--du` au premier jour de la période, `--au` au lendemain de son dernier jour), dans les bornes du lot comme dans sa commande, et dite sous « Erreurs » du bilan : hors de la période, il n'y a rien à lire. Dossier du lot : `<séance>/lot-01/`, ci-dessous `<lot>`.
**Commande du lot**, donnée telle quelle aux agents : `python3 detectors/categories.py <dossier>`, plus `--du` et `--au` s'ils sont donnés. Exemple : `--du 2026-10-05 --au 2026-10-09`.
**Les étiquettes du lot** : les lignes de `labeling/auto/<STATION>.jsonl` qui touchent la plage, écrites avant la séance par l'`etiqueteur` (`@etiqueteur data/<STATION> du <début> au <fin>`, lancé par l'utilisateur) : une étiquette par anomalie vue sur `corr_x` et `corr_y`, sa famille (`labeling/familles.md`) et sa description ; un instant sans étiquette veut dire que les courbes corrigées n'y montrent rien (D-111). Contrôle : `python3 .claude/skills/events-learner/score.py <dossier> --du <début> --au <fin>` (les bornes du lot) ; s'il sort en erreur (« Aucune étiquette »), dis-le et arrête-toi, sans commit : le lot est à étiqueter d'abord. Tu ne modifies jamais ce fichier.
## 3. Le lot, dans l'ordre
Chaque agent est appelé par l'outil Agent avec son `subagent_type` et la demande ci-dessous, rien d'autre. Un verdict se lit par `grep '^\*\*Verdict\*\* :' <rendu>`. Chaque commit se fait par chemin, `git add <chemins> && git commit -m "<message>" -- <chemins>`, après `git branch --show-current` : une autre session peut changer de branche pendant la séance ; si ce n'est plus `master`, ne commite plus rien (pas de `git switch`), passe au bilan, écrit sans commit, et note la branche trouvée sous « Erreurs ». Son message se termine par une ligne vide puis `Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>`.
1. **Analyste** (`analyste`) : `Dossier : <dossier>. Lot NN : <début> → <fin> (UTC). Commande du lot : <commande>. Écris <lot>/analyse.md.`
`python3 .claude/skills/analyser-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).
Commit `<lot>/`, message `Learn <STATION> lot NN: analysis`.
2. **Tool-builder** (`tool-builder`), à chaque lot : il lit la section « Outils » de l'analyse et améliore les outils de lecture, sans en retirer (D-097) : `Dossier : <dossier>. Lot NN : <début> → <fin> (UTC). Analyse : <lot>/analyse.md. Écris <lot>/tool-builder.md.`
Sa ligne `grep '^\*\*Outils modifiés\*\* :' <lot>/tool-builder.md` va au bilan (colonne Outils). Commit de `<lot>/` et des chemins que `git status --porcelain -- agent-tools/ .claude/skills/lire-les-donnees/` montre, sans les fichiers notés au début (§1), message `Learn <STATION> lot NN: tools (<ligne Outils modifiés>)`. Score et benchmark se calculent après lui : les détecteurs lisent par `agent-tools/donnees.py`, et toutes les mesures de la séance portent ainsi sur la même lecture.
`python3 .claude/skills/events-learner/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).
1. **Score et benchmark avant.**
`python3 .claude/skills/events-learner/score.py <dossier> --du <début> --au <fin> > <lot>/score-avant.txt 2>&1` : les détecteurs du début de séance face aux étiquettes du lot, par famille et par instant (D-112).
`python3 .claude/skills/events-learner/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 event de la base, ajouté à l'historique (D-069).
Commit `<lot>/ vues-deplacements/benchmark/historique.csv`, message `Learn <STATION> lot NN: score and benchmark`.
3. **Detectors-critic** (`detectors-critic`), qui juge les détecteurs face à l'analyse, sans regarder les données (D-090) : `Dossier : <dossier>. Lot NN : <début> → <fin> (UTC). Commande du lot : <commande>. Analyse : <lot>/analyse.md. Score avant : <lot>/score-avant.txt. Écris <lot>/critique.md.`
2. **Detectors-critic** (`detectors-critic`), qui juge les détecteurs face aux étiquettes, sans regarder les données (D-090) : `Dossier : <dossier>. Lot NN : <début> → <fin> (UTC). Commande du lot : <commande>. Étiquettes : labeling/auto/<STATION>.jsonl, celles qui touchent le lot. Score avant : <lot>/score-avant.txt. Écris <lot>/critique.md.`
Commit `<lot>/`, message `Learn <STATION> lot NN: critique (<verdict>)`.
Verdict `d'accord` : va à l'étape 6.
4. **Detectors-upgrader** (`detectors-upgrader`), passage K = 1, 2 ou 3. Avant le passage 1, note la **base du lot** : `git rev-parse HEAD`.
Verdict `d'accord` : va au bilan (§5).
3. **Detectors-upgrader** (`detectors-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. Benchmark avant : <lot>/benchmark-avant.txt. [Contrôle précédent : <lot>/validation-(K-1).md.] Passage K. Écris <lot>/modification-K.md.`
Commit `detectors/ vues-deplacements/contexte/seuils-du-journal.md <lot>/`, message `Learn <STATION> lot NN: modification K`.
Puis, les détecteurs commités : `python3 .claude/skills/events-learner/benchmark.py --seance <SEANCE> --etape "lot-NN modification K" > <lot>/benchmark-K.txt 2>&1` (commité avec la validation).
5. **Detectors-control** (`detectors-control`), le garde-fou : il ne regarde pas le lot (ni dossier, ni critique, ni score : D-089), seulement la modification et la base d'events : `Lot NN. 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.`
4. **Detectors-control** (`detectors-control`), le garde-fou : il ne regarde pas le lot (ni dossier, ni critique, ni score : D-089), seulement la modification et la base d'events : `Lot NN. 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 `Learn <STATION> lot NN: control K (<verdict>)`.
- `accepté` ou `garder` : va à l'étape 6.
- `à reprendre` : retour à l'étape 4, passage K + 1.
- `accepté` ou `garder` : va au bilan (§5).
- `à reprendre` : retour à l'étape 3, passage K + 1.
- `annuler` : `git checkout <base du lot> -- detectors/ vues-deplacements/contexte/seuils-du-journal.md`, commit de ces deux chemins, message `Learn <STATION> lot NN: modification annulée`.
6. **Event-builder** (`event-builder`), à chaque lot : il décide seul, face à la base d'events, ce que l'analyse lui apprend de nouveau (D-091) : `Dossier : <dossier>. Lot NN : <début> → <fin> (UTC). Analyse : <lot>/analyse.md. Dossier du lot : <lot>/. Séance : <séance>/. Écris <lot>/builder.md.`
Si sa ligne `**Events créés** :` n'est pas `aucun` : commit `events/ .claude/skills/anonymize-event/registre.csv <lot>/`, message `Learn <STATION> lot NN: events E-xxx, …` ; sinon commit `<lot>/`, message `Learn <STATION> lot NN: event-builder (aucun event)`.
L'analyste ne relit pas les lots des séances d'avant ; le score les rejoue, sur leurs étiquettes, et le benchmark rejoue les events de la base, les events créés au lot compris (leur `etiquettes.json`).
Le score ne compte que ce lot ; le benchmark rejoue les events de la base, les cas de régression.
## 4. Imprévus
Un rendu absent après son agent, ou sans ligne de verdict lisible : note-le pour le bilan ; si les détecteurs ont changé depuis la base du lot, remets-les comme pour `annuler` ; passe au bilan. Seule exception, le tool-builder : sans rendu ou sans ligne « Outils modifiés », remets les outils tels qu'avant lui, fichier par fichier, sans les fichiers notés au début (`git checkout HEAD -- <fichier>` pour ceux que `git diff --name-only HEAD -- agent-tools/ .claude/skills/lire-les-donnees/` liste), commite `<lot>/` et continue au score et au benchmark. Ne relance pas un agent plus d'une fois.
Un rendu absent après son agent, ou sans ligne de verdict lisible : note-le pour le bilan ; si les détecteurs ont changé depuis la base du lot, remets-les comme pour `annuler` ; passe au bilan. Ne relance pas un agent plus d'une fois.
## 5. Bilan
`python3 .claude/skills/events-learner/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.
Pas de benchmark de fin de séance : celui des détecteurs de fin est le dernier du lot, sur les mêmes events que celui du début ; les events créés par l'event-builder se mesurent à la séance suivante (D-092).
`python3 .claude/skills/events-learner/score.py <dossier> --du <début> --au <fin> > <séance>/score-fin.txt 2>&1` : le score des détecteurs de fin de séance sur les mêmes étiquettes.
Pas de benchmark de fin de séance : celui des détecteurs de fin est le dernier du lot, sur les mêmes events que celui du début (D-092).
`<séance>/bilan.md` :
@@ -68,22 +64,21 @@ Pas de benchmark de fin de séance : celui des détecteurs de fin est le dernier
Commits : sur `master`, depuis <base de la séance> (`git log --oneline <base de la séance>..HEAD`)
Score : au début du lot `lot-01/score-avant.txt`, en fin de séance `score-fin.txt` (D-062).
Étiquettes : `labeling/auto/<STATION>.jsonl`, <n> sur le lot (première ligne de `lot-01/score-avant.txt`).
Score, par famille et par instant (D-112) : au début du lot `lot-01/score-avant.txt`, en fin de séance `score-fin.txt`.
Benchmark sur la base d'events (D-069) : au début du lot `lot-01/benchmark-avant.txt`, après chaque modification `lot-01/benchmark-K.txt` ; historique `vues-deplacements/benchmark/historique.csv`. Total, sur les mêmes events : <ligne `total` de la catégorie `toutes` de `benchmark-avant.txt`, colonnes alignées : `grep -E '^total +toutes'`> → <celle du benchmark de la modification gardée (`benchmark-K.txt`), ou « inchangé » si aucune n'est gardée>.
Page : `out/events-learner_<SEANCE>_<STATION>.html`, l'analyste face aux détecteurs sur toute la plage (D-066) ; la refaire : `python3 .claude/skills/events-learner/comparaison.py <dossier> <séance>`.
Page : `out/events-learner_<SEANCE>_<STATION>.html`, les étiquettes face aux détecteurs, famille par famille (D-066) ; la refaire : `python3 .claude/skills/events-learner/comparaison.py <dossier> <séance> --du <début> --au <fin>`.
| Lot | Dates (UTC) | Outils | Critique | Étiquettes | Modification | Events créés |
|---|---|---|---|---|---|---|
| 01 | … → … | aucun / fichiers modifiés (`donnees.py` dit à part) / erreur | d'accord / suggestions (n) | n moments / absentes / n défauts | aucune / gardée (K passages) / annulée / erreur | E-xxx / aucun |
| Lot | Dates (UTC) | Étiquettes | Critique | Modification |
|---|---|---|---|---|
| 01 | … → … | n | d'accord / suggestions (n) | aucune / gardée (K passages) / annulée / erreur |
## Suggestions non traitées
<« Pas corrigé » des modifications ; suggestions d'un lot sans modification gardée>
## Contradictions avec la base
<lignes « contredit » du rendu de l'event-builder>
## Erreurs
aucune | <lot, agent, ce qui manquait>
```
@@ -95,10 +90,10 @@ Commit `<séance>/bilan.md <séance>/score-fin.txt`, message `Learn <STATION>: b
**Releveur** (`releveur`), une fois, même si tout s'est bien passé : `Processus : /events-learner (.claude/skills/events-learner/SKILL.md). Séance : <séance>/ : la section « Difficultés » de chaque rendu des lots, et « Erreurs » du bilan. Difficultés de l'orchestrateur : aucune | <une consigne de ce skill qui t'a fait deviner, une commande qui a échoué…>.` (D-060)
Si `git status --short docs/ameliorations-processus.md` montre un changement : commit de ce chemin, message `Learn <STATION>: process difficulties`.
**Améliorateur** (`ameliorateur`), seulement avec `--ameliorer` et si le releveur a commité : `Processus : /events-learner. Commit du releveur : <commit>.`, le commit pris par `git rev-parse HEAD` juste après celui du releveur (D-071). Puis commit des chemins qu'il a pu toucher, `.claude/skills/events-learner/ .claude/skills/analyser-lot/ .claude/agents/analyste.md .claude/agents/tool-builder.md .claude/agents/detectors-critic.md .claude/agents/detectors-upgrader.md .claude/agents/detectors-control.md .claude/agents/event-builder.md .claude/agents/releveur.md .claude/agents/ameliorateur.md vues-deplacements/contexte/events-learner.md run.md docs/ameliorations-processus.md`, seulement ceux que `git status --short` montre changés, message `Learn <STATION>: process fixes`. Garde la suite de ce skill telle que tu l'as lue au début.
**Améliorateur** (`ameliorateur`), seulement avec `--ameliorer` et si le releveur a commité : `Processus : /events-learner. Commit du releveur : <commit>.`, le commit pris par `git rev-parse HEAD` juste après celui du releveur (D-071). Puis commit des chemins qu'il a pu toucher, `.claude/skills/events-learner/ .claude/agents/detectors-critic.md .claude/agents/detectors-upgrader.md .claude/agents/detectors-control.md .claude/agents/releveur.md .claude/agents/ameliorateur.md vues-deplacements/contexte/events-learner.md run.md docs/ameliorations-processus.md`, seulement ceux que `git status --short` montre changés, message `Learn <STATION>: process fixes`. Garde la suite de ce skill telle que tu l'as lue au début.
## 7. Réponse finale
`python3 .claude/skills/events-learner/comparaison.py <dossier> <séance>` : la page de fin de séance, `out/events-learner_<SEANCE>_<STATION>.html`, qui s'ouvre dans le navigateur (D-066). C'est la page de `python3 detectors-view/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 d'events. 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/events-learner/comparaison.py <dossier> <séance> --du <début> --au <fin>` : la page de fin de séance, `out/events-learner_<SEANCE>_<STATION>.html`, qui s'ouvre dans le navigateur (D-066). C'est la page de `python3 detectors-view/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 »), une ligne par famille des étiquettes, dédoublée : les étiquettes du lot au-dessus des événements des détecteurs tels qu'ils sont en fin de séance, rangés dans la famille de leur catégorie ; sous la figure, la liste des événements, le score de la séance et le benchmark sur la base d'events. 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'`, du début du lot à la modification gardée), le nombre de modifications gardées et d'events 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`.
En 7 lignes au plus : la page, la base de la séance, le chemin du bilan, le nombre d'étiquettes du lot, le benchmark (ligne `total` / `toutes`, `grep -E '^total +toutes'`, du début du lot à la modification gardée), le nombre de modifications gardées, 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`.
+35 -46
View File
@@ -1,20 +1,16 @@
"""Page de fin de séance de /events-learner : la lecture de l'analyste face aux détecteurs, sur toute la plage de la séance.
"""Page de fin de séance de /events-learner : les étiquettes de l'étiqueteur face aux détecteurs, sur la plage de la séance.
La page de detectors-view/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/events-learner/comparaison.py <dossier de station> <dossier de séance>
(page : out/events-learner_<séance>.html, ouverte dans le navigateur)
chaque capteur en couleur, ligne « Error rate »), une ligne par famille des étiquettes (labeling/familles.md), dédoublée :
en haut les étiquettes de labeling/auto/<STATION>.jsonl qui touchent la plage, 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), rangés par la correspondance de familles.md ;
un saut bref, dont la famille est celle de sa cause, garde sa ligne (D-112). Sous la figure, la liste des événements des
détecteurs, le score de la séance (score.py --du --au) 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/events-learner/comparaison.py <dossier de station> <dossier de séance> --du AAAA-MM-JJ --au AAAA-MM-JJ
(--au exclu ; page : out/events-learner_<séance>.html, ouverte dans le navigateur)
"""
import contextlib
import glob
import html
import io
import json
import os
import sys
@@ -35,60 +31,53 @@ def tableau(total, ordre, titre="Catégorie"):
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>"
return (f"<table><tr><th>{titre}</th><th>Étiquetées</th><th>Signalées par les détecteurs</th>"
"<th>Trouvées</th><th>Confirmées</th></tr>" + lignes + "</table>")
def page(dossier, seance):
def page(dossier, seance, du, au):
"""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."""
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)
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"]]
plus les étiquettes de l'étiqueteur, le score de la séance et le benchmark."""
debut, fin = score.iso(score.instant(du)), score.iso(score.instant(au))
total, etiq = score.familles_lot(dossier, debut, fin)
if not etiq:
sys.exit(f"Aucune étiquette de {os.path.basename(os.path.normpath(dossier))} sur {debut} → {fin} dans labeling/auto/.")
agent = [(e["debut"], e["fin"], c := HORS if e.get("categorie") == "aucune" else e.get("categorie", "sans famille"),
survol(f"Étiquette : {c}", e["debut"], e["fin"], ["dans le texte"], e["description"])) for e in etiq]
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)
events, _ = benchmark.mesurer()
bench = {c: n[benchmark.TOUTES] for c, n in events.items()}
ordre = [*score.categories.CATEGORIES, HORS]
lignes = score.familles()
ordre = [*dict.fromkeys(lignes.values()), HORS]
nom = os.path.basename(os.path.normpath(seance))
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. 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>"""
<p>Dessous les courbes, chaque ligne est une famille des étiquettes (<code>labeling/familles.md</code>) : la barre du haut,
les {len(etiq)} étiquettes de l'étiqueteur qui touchent la plage (<code>labeling/auto/</code>), celle du bas, les événements
des détecteurs dans leur état de fin de séance, rangés dans la famille de leur catégorie (survol : la catégorie du
journal). Un saut bref, de la famille de sa cause, garde sa ligne. Survol : bornes, description ; un clic sur une barre, des
étiquettes 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 à
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)}
<p>On compte des instants : une heure de la plage où un capteur au moins a une mesure ; les étiquettes ne disent leurs
capteurs que dans leur texte. <b>Trouvées</b> : des instants qu'une étiquette range dans la famille, la part que les
détecteurs signalent aussi ; le reste, ils l'ont raté. <b>Confirmées</b> : des instants que signalent les détecteurs, la
part qu'une étiquette range aussi dans la famille ; le reste, ce sont des alertes en trop, ou un oubli de l'étiqueteur.
Un saut bref compte dans la famille de l'étiquette qui le couvre. Le but : 100 % dans les deux colonnes ; « — » : rien à
compter. Les trous ne comptent pas (pas de mesure).</p>
{tableau(total, ordre, "Famille")}
<h3>Benchmark sur la base d'events</h3>
<p>Les mêmes détecteurs, face au diagnostic gardé dans chaque event 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/events-learner/benchmark.py</code> ; dans le temps : <code>{os.path.relpath(benchmark.HISTORIQUE, ROOT)}</code>
(version {benchmark.version()}).</p>
{tableau(bench, list(bench), "Event")}"""
return detecteurs.page(dossier, debut, fin, entete=entete, annexe=annexe, analyste=agent,
return detecteurs.page(dossier, debut, fin, entete=entete, annexe=annexe, analyste=agent, lignes=lignes,
chemin=os.path.join(ROOT, "out", f"events-learner_{nom}.html"))
if __name__ == "__main__":
if len(sys.argv) != 3:
if len(sys.argv) != 7 or sys.argv[3::2] != ["--du", "--au"]:
sys.exit(__doc__)
p = page(sys.argv[1], sys.argv[2])
p = page(sys.argv[1], sys.argv[2], sys.argv[4], sys.argv[6])
print(p)
open_served(p)
+70 -4
View File
@@ -10,13 +10,19 @@ Validité d'une case : la pire de ses catégories ; « à ignorer » : les zones
section 4) ; « prudence » : visibilité réduite et turbulence ; « fiable » sinon (dilatation, contraction, à vérifier :
jamais grisées), et sans catégorie. Un trou n'a pas de mesure, donc pas de case ; un moment « aucune » n'est pas compté.
Le score est un fait, pas un verdict : l'analyste peut se tromper aussi.
Avec --du et --au, le score d'un lot de /events-learner (D-112) : les détecteurs face aux étiquettes de l'étiqueteur
(labeling/auto/<STATION>.jsonl) qui touchent le lot, par famille (labeling/familles.md) et par instant, les étiquettes
ne disant pas leurs capteurs ; les détecteurs passent aux familles par la correspondance de familles.md, un saut bref
prend la famille de l'étiquette qui le couvre. Aucune étiquette sur le lot : sortie en erreur.
Usage : python3 .claude/skills/events-learner/score.py <dossier de station> [etiquettes.json ...]
(défaut : events-learner/*/lot-*/etiquettes.json de la station)
python3 .claude/skills/events-learner/score.py <dossier de station> --du AAAA-MM-JJ --au AAAA-MM-JJ
python3 .claude/skills/events-learner/score.py --test
"""
import glob
import json
import os
import re
import sys
from datetime import timedelta
from pathlib import Path
@@ -34,6 +40,8 @@ IGNORER = {"visibilite_nulle", "passage", "cible_masquee", "cible_degradee", "sa
# journal) ; un champ de force dans les étiquettes si cet écart compte
PRUDENCE = {"visibilite_reduite", "turbulence"}
NIVEAUX = ("à ignorer", "prudence")
FAMILLES = os.path.join(RACINE, "labeling", "familles.md")
CAUSES_SAUT = {"obstruction", "visibilite", "deplacement"} # saut_bref : la famille de sa cause (familles.md, frontières)
def validite(cats):
@@ -67,17 +75,60 @@ def detectes(mesures, debut, fin):
return [(v["start"], v["end"], v["sensors"], v["category"]) for v in evenements(mesures, debut, fin)]
def score(etiq, det):
"""{case: catégories de l'analyste}, {case: catégories des détecteurs} -> {clé: [étiquetées, signalées, les deux]}."""
def compter(paires):
"""[(clés étiquetées, clés signalées)], une paire par case -> {clé: [étiquetées, signalées, les deux]}."""
n = {}
for c in etiq:
a, d = [x | {v} if (v := validite(x)) else x for x in (etiq[c], det[c])]
for a, d in paires:
for k in a | d:
x = n.setdefault(k, [0, 0, 0])
x[0], x[1], x[2] = x[0] + (k in a), x[1] + (k in d), x[2] + (k in a and k in d)
return n
def score(etiq, det):
"""{case: catégories de l'analyste}, {case: catégories des détecteurs} -> {clé: [étiquetées, signalées, les deux]}."""
return compter([x | {v} if (v := validite(x)) else x for x in (etiq[c], det[c])] for c in etiq)
def familles():
"""labeling/familles.md -> {catégorie du journal: famille}, sa correspondance ; saut_bref n'y a pas de famille fixe."""
corr = {}
for part in open(FAMILLES, encoding="utf-8").read().split("## Correspondance")[1].split(" ; "):
gauche, _, droite = part.partition("→")
if f := re.findall(r"`(\w+)`", droite):
corr |= dict.fromkeys(re.findall(r"`(\w+)`", gauche), f[0])
return corr
def etiquettes_auto(station, debut, fin):
"""labeling/auto/<STATION>.jsonl -> les étiquettes de l'étiqueteur qui touchent [début, fin)."""
chemin = os.path.join(RACINE, "labeling", "auto", f"{station}.jsonl")
if not os.path.exists(chemin):
return []
with open(chemin, encoding="utf-8") as f:
return [e for e in map(json.loads, filter(str.strip, f)) if e["debut"] < fin and e["fin"] >= debut]
def familles_lot(dossier, debut, fin, etiq=None):
"""Score d'un lot par famille et par instant (D-112) -> ({famille: [étiquetés, signalés, les deux]}, étiquettes).
Un instant : une heure du lot où un capteur au moins a une mesure ; il reçoit les familles des étiquettes qui le
couvrent, bornes comprises, et celles des événements des détecteurs. etiq : les étiquettes, sinon labeling/auto/."""
# ponytail: par instant et non par capteur, les étiquettes ne disent leurs capteurs que dans le texte ; un champ
# capteurs dans l'étiquette, si cette finesse manque
mesures, corr = charger(dossier), familles()
if etiq is None:
etiq = etiquettes_auto(os.path.basename(os.path.normpath(dossier)), debut, fin)
evts = evenements(mesures, debut, fin)
paires = []
for t in sorted({t for _, t in cases(mesures, debut, fin)}):
a = {e.get("categorie", "sans famille") for e in etiq if e["debut"] <= t <= e["fin"]} - {"aucune"}
d = {corr.get(v["category"], v["category"]) for v in evts if v["start"] <= t <= v["end"]}
if "saut_bref" in d:
d = d - {"saut_bref"} | (a & CAUSES_SAUT or {"saut_bref"})
paires.append((a, d))
return compter(paires), etiq
def pct(a, b):
return f"{a}/{b} ({round(100 * a / b)} %)" if b else "—"
@@ -144,12 +195,27 @@ def test():
assert ajout == [len(cs), 0, 0], ajout
assert validite({"visibilite_reduite", "visibilite_nulle"}) == "à ignorer"
assert validite({"dilatation_thermique", "a_verifier"}) is None
# par famille (D-112) : chaque catégorie du journal a sa famille, sauf saut_bref ; les événements des détecteurs pris
# pour étiquettes, sauts brefs à part, donnent chaque famille trouvée et juste en entier
corr = familles()
assert set(categories.CATEGORIES) - set(corr) == {"saut_bref"}, corr
etiq = [{"debut": v["start"], "fin": v["end"], "categorie": corr[v["category"]]}
for v in evenements(mesures, debut, fin) if v["category"] != "saut_bref"]
n, _ = familles_lot(os.path.join(RACINE, "vues-deplacements", "cas", "2026-10_NORDEND", "NORDEND"), debut, fin, etiq)
assert n and all(x[0] == x[1] == x[2] for k, x in n.items() if k != "saut_bref"), n
print("test : bon")
if __name__ == "__main__":
if sys.argv[1:] == ["--test"]:
test()
elif len(sys.argv) == 6 and sys.argv[2::2] == ["--du", "--au"]:
station, du, au = os.path.basename(os.path.normpath(sys.argv[1])), iso(instant(sys.argv[3])), iso(instant(sys.argv[5]))
n, etiq = familles_lot(sys.argv[1], du, au)
if not etiq:
sys.exit(f"Aucune étiquette de {station} sur {du} → {au} dans labeling/auto/{station}.jsonl : "
"étiqueter le lot d'abord (@etiqueteur).")
afficher(f"{station} : {du} → {au}, {len(etiq)} étiquettes de labeling/auto/{station}.jsonl, par famille et par instant", n)
elif len(sys.argv) >= 2:
explicites = sys.argv[2:]
tous = sorted(glob.glob(os.path.join(RACINE, "events-learner", "*", "lot-*", "etiquettes.json")))