diff --git a/.claude/agents/label-reviewer.md b/.claude/agents/label-reviewer.md new file mode 100644 index 0000000..884716b --- /dev/null +++ b/.claude/agents/label-reviewer.md @@ -0,0 +1,50 @@ +--- +name: label-reviewer +description: Vérificateur des étiquettes de l'expert (labeling/) — confronte chaque étiquette aux données de sa plage, aux autres étiquettes et à la documentation, pointe les incohérences et pose ses questions à l'expert pour confirmer ou corriger ; ne change une étiquette que sur sa parole. Appelé depuis la conversation avec un fichier labeling/.jsonl et la consigne « vérifier », puis « réponses : … » ; la conversation relaie ses questions à l'utilisateur et lui renvoie les réponses. +tools: Read, Bash, Write, Edit +model: inherit +--- + +Tu es le vérificateur des étiquettes. L'expert, c'est l'utilisateur : il écrit à la main (`labeling/labeling.py`) des plages de données, avec ce qu'il y voit, la cause et comment il l'a sue. Ces étiquettes sont la base de connaissance du projet (D-100) : une erreur y entre dans tout ce qui en apprend. Il peut se tromper sans le voir : une borne décalée, un capteur pour un autre, une heure locale prise pour UTC, un fait que les données ne montrent pas, deux étiquettes qui se contredisent, une cause sans dire comment il l'a sue. + +Tu cherches ces erreurs possibles et tu lui poses la question. Tu ne juges pas son diagnostic à sa place : il a vu ce que tu ne vois pas (le site, les images en entier, son expérience). Une incohérence se dit en question, avec le fait mesuré qui la fonde, jamais en correction. Tu ne lui parles pas directement : la conversation lui pose tes questions et te renvoie ses réponses. + +## Ta demande + +Un fichier `labeling/.jsonl` (une ligne par étiquette : `debut`, `fin`, `description`, parfois `source`, `revue`, en UTC), au besoin une étiquette précise (ses bornes), et l'une de ces deux consignes. Les étiquettes à vérifier : celles qui n'ont pas de champ `revue`, sauf demande contraire. Leurs données : `data//` ; pour une station `E-xxx`, `events/E-xxx/` (D-100). Pour les lire : skill `lire-les-donnees` (outils de `agent-tools/`), jamais en affichant les CSV. + +### « vérifier » + +Pour chaque étiquette : + +1. Tire du texte ses affirmations vérifiables : une colonne qui monte ou ne bouge pas, tel capteur caché, la nuit, le jour, les références qui bougent peu, une durée, un ordre. +2. Mesure chacune dans les données de la plage, et un peu avant et après pour voir si les bornes encadrent le phénomène ; regarde les images quand le texte parle de ce qu'on voit (`vignettes.py`, `gif.py`). +3. Contrôle : + - **Forme** : `debut` < `fin`, au format `AAAA-MM-JJTHH:MMZ` ; des mesures dans la plage. + - **Bornes** : le phénomène commence-t-il et finit-il là, ou déborde-t-il nettement ? La plage se sélectionne à la souris : quelques pas d'écart ne valent pas une question. + - **Noms** : chaque capteur cité existe dans les données, et il est une référence ou une cible comme le dit le texte. + - **Heure** : tout est en UTC ; le jour ou la nuit que dit le texte, face aux images (la station peut être n'importe où : juge sur les images, pas sur l'heure). + - **Faits** : chaque affirmation, face à ta mesure. + - **Cause et preuve** : la cause est-elle dite, et comment il l'a sue (quel plot, quelle image) ? Sinon, demande-le (`run.md`, « Étiqueter des données »). + - **Entre étiquettes** : deux étiquettes qui se chevauchent et se contredisent ; le même phénomène décrit autrement ailleurs dans `labeling/*.jsonl`. + - **Face à la documentation** : `events/carte-des-evenements.md` et `docs/displacement/domaine/chaine-de-mesure.md`, la section utile seulement (`grep -n '^#'`). Une étiquette qui contredit le savoir en place est une question : l'un des deux est faux, peut-être la documentation. +4. Écris la revue dans `labeling/revues/.md` (créé au besoin, complété ensuite, le plus récent en bas) : une section par étiquette, titrée par ses bornes, avec son verdict (`cohérente` ou `à confirmer`), les faits mesurés (valeur, commande) et ses questions, numérotées pour toute la revue (Q1, Q2…). + +Une question : courte, à laquelle on répond par oui, non ou quelques mots, avec le fait qui la fonde. Les plus graves d'abord (une cause ou un fait contredit avant une borne) ; trois au plus par étiquette ; aucune pour une étiquette cohérente, et pas de doute inventé pour en avoir une. + +Rends seulement : le chemin de la revue, le nombre d'étiquettes vérifiées et cohérentes, puis les questions numérotées, chacune avec les bornes de son étiquette. + +### « réponses : » + +- Il confirme : ajoute à l'étiquette `"revue": ""`. +- Il corrige : applique exactement ce qu'il dit (bornes, texte) ; un texte, c'est le sien : tu peux proposer une phrase, tu n'écris que celle qu'il a validée ; puis `revue`. +- Il ne sait pas : l'étiquette reste sans `revue`, la revue le note. +- Une réponse qui n'est pas nette : ne devine pas, rends la question. + +Modifie le fichier par script : une ligne JSON par étiquette, les autres lignes telles quelles, les champs dans leur ordre (`revue` en dernier), `ensure_ascii=False` ; vérifie ensuite que chaque ligne se relit par `json.loads`. Complète la revue (la réponse sous chaque question, ce qui a changé). Rends : les étiquettes changées, une ligne chacune, et les questions qui restent. + +## Règles + +- Tu n'écris que dans `labeling/.jsonl` (sur sa parole) et `labeling/revues/.md`. +- Lecture seule sur les données ; aucun identifiant (`SIM_CCID`, `ip`, `ip_*`) dans la revue ; pour une station `E-xxx`, les noms codés de l'event, jamais le registre de `anonymize-event`. +- Vocabulaire : `confirmed` / `strongly supported` / `consistent with` / `possible` / `insufficient evidence` / `not observed` ; pas de pseudo-probabilités. diff --git a/.claude/skills/labels-learner/analyste.md b/.claude/skills/labels-learner/analyste.md index 7490216..facb22e 100644 --- a/.claude/skills/labels-learner/analyste.md +++ b/.claude/skills/labels-learner/analyste.md @@ -4,7 +4,7 @@ L'expert a étiqueté des plages en texte libre : la cause et comment il l'a sue ## Ce que tu reçois -Le phénomène, le fichier des étiquettes (une ligne chacune : `station`, `debut`, `fin`, `description`, en UTC), le dossier de sortie. Les données de chaque étiquette : `data//`. +Le phénomène, le fichier des étiquettes (une ligne chacune : `station`, `debut`, `fin`, `description`, en UTC), le dossier de sortie. Les données de chaque étiquette : `data//` ; pour une station `E-xxx`, les données codées de l'event : `events/E-xxx/` (D-100). ## Ce que tu as le droit de lire, seulement diff --git a/CLAUDE.md b/CLAUDE.md index 7897b9e..cfead16 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -103,7 +103,7 @@ python3 -m venv .venv && .venv/bin/pip install plotly matplotlib # recréer . - `vues-deplacements/` : le chantier des déplacements (D-052), avec sa propre carte, `vues-deplacements/CLAUDE.md` : `maquette/` (page Explore et `spec.md`, D-053 à D-056), `contexte/` (journal du matin, seuils, lissage, `events-learner`, aiguisage, retiré), `cas/` (NORDEND, parcours de l'utilisateur), `benchmark/historique.csv` (D-069). - `detectors/` : les détecteurs du journal (D-067, D-068, D-084), un détecteur élémentaire par fichier, contrat `detect(mesures)`, classés en événements par `categories.py` ; `archive/` : versions écartées. - `detectors-view/` : le développement de la page des détecteurs (D-093), `detecteurs.py` : images, courbes, Status, catégories, Error rate ; `run-detectors.sh` : la page sur chaque station de `data/` ; `status.py` : la page Status, version pseudo finale de la page Explore du site : corr_x, corr_y, mouvement de la caméra, événements des détecteurs en plages colorées et en étiquettes cliquables au-dessus (sélection : ses capteurs, ses détails et son timelapse sous la figure, sans zoom) (D-094), occultés selon `hierarchie-des-status.md` (D-095, regroupement thermique suspendu) ; en haut, le data loader `data-loader/chargeur.py` (station, dates, « Analyse » ; son serveur, port 8766) ; la page des détecteurs est reprise par la page de fin de séance de `/events-learner` (`comparaison.py`) et par `/review-event`. -- `labeling/` : l'outil d'étiquetage de l'expert (D-098), `labeling.py` : un plot à la fois (déplacements, métriques système), une barre de temps pour sélectionner une plage, du texte libre sans catégorie ; Add écrit une ligne dans `.jsonl`, versionné ; un clic sur une étiquette la lit et la modifie ; `lecons/` : les leçons de `/labels-learner` (D-099), une par phénomène. +- `labeling/` : l'outil d'étiquetage de l'expert (D-098), `labeling.py` : un plot à la fois (déplacements, métriques système), une barre de temps pour sélectionner une plage, du texte libre sans catégorie ; Add écrit une ligne dans `.jsonl`, versionné ; un clic sur une étiquette la lit et la modifie ; les events validés y ont leurs étiquettes, `E-xxx.jsonl` (D-100) ; `revues/` : les revues de l'agent `label-reviewer` (D-101) ; `lecons/` : les leçons de `/labels-learner` (D-099), une par phénomène. - `view/` : `view.py`, les images IRON d'une station sous le data loader de la page Status (glisseur, flèches ; molette pour zoomer, glisser pour se déplacer ; case Labels : le nom des cibles et des références). - `events-learner/`, `aiguiser/` : les séances de `/events-learner` et de `/aiguiser`, retiré (D-084, D-097), une par dossier `_/` (`lot-NN/`, `bilan.md`) ; historique, à ne lire que sur demande. - `events/` : **la base d'events, connaissance métier qui grandit** (D-048, D-080) : `INDEX.md` (le registre, seule porte d'entrée ; mode d'emploi : skill `read-event`, D-085), un dossier `E-xxx/` par event (`event.md` lisible d'abord par un humain, figures, données codées, `etiquettes.json`), validé par l'utilisateur ou « (appris) » par `/events-learner` en attendant `/review-event` ; `carte-des-evenements.md` (familles, catégories du journal, faux amis ; elle apprend de chaque event validé, D-087) et `eventualites-et-categories.drawio`. Un event n'y entre que par `/new-event`, lancé par l'utilisateur, ou par l'event-builder de `/events-learner`. @@ -120,7 +120,7 @@ python3 -m venv .venv && .venv/bin/pip install plotly matplotlib # recréer . - Jeux de travail : VERMONT pour Energy (D-009, le plus long historique) ; WEISSHORN pour Storage (D-034) ; WEISSHORN et NORDEND pour Cellular (D-030, D-032) et Temperature (D-040) ; à pomper s'ils manquent. - WEISSHORN et NORDEND contiennent des identifiants (`SIM_CCID`, `ip`, `ip_*`) : ne pas les recopier. - Les données des events restent, codées, dans `events/`. -- `.claude/` : `rules/analyses.md` ; `agents/` : `diagnostic`, ceux de `/events-learner` (`analyste`, `tool-builder`, `detectors-critic`, `detectors-upgrader`, `detectors-control`, `event-builder`), `revue` (`/review-event`), `documentaliste` (`/labels-learner`, D-099), `releveur` et `ameliorateur` (D-060, D-071) ; `skills/` : `support`, `events-learner`, `analyser-lot`, `lire-les-donnees`, `read-event`, `new-event`, `review-event`, `labels-learner` (D-099), `anonymize-event` (D-049, D-050), `nouvelle-analyse`, `nouveau-domaine` ; `settings.json` (lecture de `.env` interdite). +- `.claude/` : `rules/analyses.md` ; `agents/` : `diagnostic`, ceux de `/events-learner` (`analyste`, `tool-builder`, `detectors-critic`, `detectors-upgrader`, `detectors-control`, `event-builder`), `revue` (`/review-event`), `documentaliste` (`/labels-learner`, D-099), `label-reviewer` (D-101), `releveur` et `ameliorateur` (D-060, D-071) ; `skills/` : `support`, `events-learner`, `analyser-lot`, `lire-les-donnees`, `read-event`, `new-event`, `review-event`, `labels-learner` (D-099), `anonymize-event` (D-049, D-050), `nouvelle-analyse`, `nouveau-domaine` ; `settings.json` (lecture de `.env` interdite). - `.devcontainer/` : environnement de dev en conteneur (D-038), réseau de l'hôte pour joindre la caméra. `out/` : pages et JSON générés. - Tout est versionné (D-014), sauf `out/`, `data/`, `.venv/`, `__pycache__/`, `graphify-out/` et `.env`. diff --git a/docs/decisions.md b/docs/decisions.md index e3cd45b..cb106ad 100644 --- a/docs/decisions.md +++ b/docs/decisions.md @@ -973,7 +973,7 @@ Règles du journal : - **Conséquence** : une séance de `/events-learner` appelle six agents ; l'analyste, qui peut écrire des scripts, coûtera sans doute plus. Lire en brut garde une part de ce qu'apportait le correcteur, qui a trouvé la seule erreur de lecture commune (rejets des références, WILDSTRUBEL, 2026-10-27). Un changement de `donnees.py` se voit d'une séance à l'autre dans l'historique du benchmark. Sans retrait ni contrôle, les outils peuvent encore grossir : à observer. ## D-098 — 2026-10-30 — L'expert étiquette lui-même : `labeling/` -- **Statut** : active, à l'essai ; point 68 du plan du journal du matin. +- **Statut** : active, à l'essai ; point 68 du plan du journal du matin ; complétée par D-100 (les events validés y ont leurs étiquettes). - **Décision** : un outil local et très simple, `labeling/labeling.py`, qui ne sert qu'à se repérer dans le temps et à écrire ; les données se consultent sur le monitoring. Le data loader de la page Status, un plot à la fois (menu Advanced d'Explore, plus les métriques système numériques, sans les identifiants), une barre de temps alignée où l'on sélectionne une plage, du texte, et Add écrit aussitôt. Des étiquettes en langage naturel, **sans catégorie**, dans `labeling/.jsonl`, une ligne chacune (`debut`, `fin`, `description`), versionné ; zones grisées sur tous les plots, chevauchements admis ; un clic sur une étiquette permet de lire et de modifier son texte (Save, demande de l'utilisateur, 2026-10-30) ; ses bornes et son retrait se font dans le fichier. - **Pourquoi** : l'utilisateur, 2026-10-30 : que l'analyste prenne connaissance des phénomènes sur des cas étiquetés par l'expert, en plus de ce qu'on lui explique (point 67) ; pas de catégorie pour ne pas borner, on en déduira après coup ; le but est d'avoir les étiquettes, pas une application. Constat de Claude : la seule vérité du projet était l'analyste (`score.py`, benchmark). - **Options écartées** : l'étiquetage dans la page Status, avec les status des détecteurs, `error_value`, une température et une catégorie facultative (première proposition de Claude) : l'outil doit rester simple, le monitoring montre le reste ; le format de `etiquettes.json` : ses champs obligatoires (catégorie, preuve, capteurs) bornent, et un seul objet JSON se réécrit à chaque ajout. @@ -985,3 +985,18 @@ Règles du journal : - **Pourquoi** : l'utilisateur, 2026-10-30 : les étiquettes ne valent que si l'analyste en apprend, et apprendre, ici, c'est documenter ; 2026-11-02, sur ses 13 premières étiquettes : pas de lecture à l'aveugle, il n'en voit pas l'intérêt ; le texte des étiquettes suffit, pas de fiche de station. Le même jour, l'utilisateur : ce que l'analyste apprend doit être documenté ; il peut poser des questions, et quand il a tout compris, il passe ses conclusions à un agent de documentation, nouveau, dont le rôle est de maintenir la documentation du projet. Constat de Claude sur ces étiquettes : elles disent le mécanisme, et la mesure dans les données le précise (deux références acceptées donnent `reproj_err` = 0, une seule le laisse vide, à JUNGFRAU et NORDEND). - **Options écartées** : des propositions présentées une à une à l'utilisateur, appliquées par l'orchestrateur (première version de Claude, le même jour) : les questions à l'expert tiennent lieu de validation, et la documentation a son agent ; la lecture à l'aveugle avant la confrontation (proposition de Claude, pour mesurer l'écart entre l'analyste seul et l'expert) : refusée par l'utilisateur ; une fiche de contexte par station (ouvrage, références) : le texte des étiquettes le dit ; un nouvel agent : l'analyste sait lire les données ; un document de leçons que l'analyste relirait : les acquis vont dans la chaîne de mesure, la carte et `lire-les-donnees` (point 67 : ne pas l'alourdir). - **Conséquence** : le savoir entre par les réponses de l'expert et se relit au diff avant le commit ; une conclusion vue sur une seule station reste `[H]`. Le `documentaliste` est général : d'autres processus pourront lui passer leurs conclusions. La chaîne de mesure n'est pas encore lue par l'analyste de `/events-learner` (point 67) : ce qu'elle apprend ne l'atteint qu'ensuite. Ni détecteurs ni events ici : `/events-learner` et `/new-event`. + +## D-100 — 2026-11-02 — Les étiquettes, base de connaissance ; les events validés y ont les leurs +- **Statut** : active ; complète D-098 et D-099. +- **Décision** : les étiquettes de l'expert (`labeling/`) sont la base de connaissance la plus fondamentale du projet : des plages de données, avec le diagnostic et la classification de l'expert. Le travail de l'analyste est de refaire cette classification sur des plages. Les events (`events/`) sont gardés, et chaque event **validé** a aussi ses étiquettes, dans `labeling/E-xxx.jsonl` : noms codés de l'event, données dans `events/E-xxx/` (l'outil les ouvre : `python3 labeling/labeling.py events/E-xxx/`), tirées de sa fiche (`event.md`), une étiquette par occurrence du phénomène, le texte disant ce qu'on voit, la cause et comment on l'a sue, la classification, la conséquence ; un champ `source` en plus (`events/E-xxx/event.md`). Écrites par un agent, relues par l'utilisateur. +- **Pourquoi** : l'utilisateur, 2026-11-02 : se concentrer d'abord sur les étiquettes faites à la main, sa base de connaissance ; on ne sait pas si les events serviront, mais ils restent utiles ; avec assez d'étiquettes, on pourra penser à des algorithmes d'apprentissage automatique. Un event validé porte son diagnostic : c'est une étiquette de l'expert. +- **Options écartées** : garder events et étiquettes séparés (avis de Claude, le même jour : doublon avec la carte des événements, et une fiche n'est pas écrite par l'expert) ; ranger ces étiquettes sous le vrai nom de la station (le registre de `anonymize-event` ne va jamais à un agent, et les données codées sont dans l'event) ; reprendre les moments d'`etiquettes.json` (l'analyste sur tout le lot, ceux de E-001 à E-005 pas encore relus, point 48) ; les events « (appris) » (E-012 à E-014) avant `/review-event`. +- **Conséquence** : `/labels-learner` les lit comme les autres ; pour une station `E-xxx`, ses données sont dans `events/E-xxx/`. Un event validé plus tard devra recevoir ses étiquettes (à brancher dans `/new-event` et `/review-event`, point 70). + +## D-101 — 2026-11-02 — Un vérificateur des étiquettes : l'agent `label-reviewer` +- **Statut** : active, à l'essai ; complète D-098 et D-100. +- **Décision** : un agent, `label-reviewer` (`.claude/agents/label-reviewer.md`), appelé depuis la conversation sur un fichier `labeling/.jsonl` : pour chaque étiquette sans champ `revue`, il mesure dans les données ce que dit le texte, contrôle la forme, les bornes, les noms des capteurs, l'heure (UTC, jour ou nuit sur les images), la cause et comment elle a été sue, les autres étiquettes et la documentation (carte des événements, chaîne de mesure), puis écrit sa revue dans `labeling/revues/.md` et rend ses questions ; la conversation les pose à l'utilisateur et lui renvoie les réponses. Il ne change une étiquette que sur la parole de l'utilisateur ; une étiquette confirmée ou corrigée reçoit `"revue": ""`, qu'un Save de son texte dans l'outil retire. +- **Pourquoi** : l'utilisateur, 2026-11-02 : un vérificateur qui pointe les incohérences et lui pose des questions pour confirmer ses étiquettes, car il peut simplement faire des erreurs ; les étiquettes sont la base de connaissance (D-100). +- **Options écartées** : un skill orchestrateur (comme `/review-event`) : la conversation suffit à relayer les questions ; un agent qui corrige seul : une incohérence peut venir des données ou de la documentation, l'expert tranche. +- **Conséquence** : une étiquette porte `revue` une fois vérifiée ; `/labels-learner` ne les distingue pas encore. + diff --git a/docs/superpowers/plans/2026-10-23-journal-du-matin.md b/docs/superpowers/plans/2026-10-23-journal-du-matin.md index ef26760..0123d85 100644 --- a/docs/superpowers/plans/2026-10-23-journal-du-matin.md +++ b/docs/superpowers/plans/2026-10-23-journal-du-matin.md @@ -126,6 +126,7 @@ Types : **Comprendre** (lire, expliquer, rien ne change), **Décider** (l'utilis | 67 | Le savoir métier de l'analyste : le mécanisme, sans plus de pages | Décider | 57 | idée du 2026-10-29 ; trois questions | | 68 | L'expert étiquette lui-même : un outil web | Décider, Coder | — | construit le 2026-10-30 (D-098), `labeling/` ; à essayer par l'utilisateur | | 69 | Apprendre des étiquettes de l'expert : `/labels-learner` | Décider, Coder | 67, 68 | `/labels-learner` construit le 2026-11-02 (D-099) ; premier essai, sur la perte de référence, à lancer par l'utilisateur | +| 70 | Des étiquettes proposées par l'analyste, vérifiées par l'expert | Décider, Coder | 48, 68, 69 | 2026-11-02 : les étiquettes d'abord, base de connaissance (D-100) ; étiquettes des events validés en cours | Chemins conseillés : le plus simple et le plus parlant d'abord, **11 (visibilité simple), 38 (ses statuts : bonne, moyenne, nulle) puis 7 (bouton `Images`)**, qui marchent sans le classement ; le cœur du retour, c'est **5 → 6 → 7 → 8 → 9 → 10** ; les points 1 à 4 se lisent avant si l'on veut d'abord tout comprendre ; le point 27 se lance en parallèle (il n'attend rien). @@ -1696,6 +1697,30 @@ Un seul passage de l'analyste par phénomène, au lieu de deux : moins coûteux **Ajout de l'utilisateur (2026-11-02), qui remplace la validation une à une.** Ce que l'analyste apprend doit être documenté. Il pose ses questions à l'expert tant qu'il n'a pas compris (au plus trois tours) ; quand il a tout compris, il passe ses conclusions à un agent nouveau, le `documentaliste` (`.claude/agents/documentaliste.md`), dont le rôle est de maintenir la documentation du projet : il les place (chaîne de mesure, carte, `lire-les-donnees`, `docs/domaine/`), sans doublon, avec leur source. L'utilisateur relit le diff avant le commit. - [ ] Le premier essai, sur 3 à 5 étiquettes réelles ; corriger le skill. +### Point 70 : Des étiquettes proposées par l'analyste, vérifiées par l'expert + +**Idée de l'utilisateur (2026-11-02).** Un analyste écrit des étiquettes, l'utilisateur les vérifie à la main ; crainte : trop d'étiquettes, qui noient l'agent. Précision de l'utilisateur, le même jour : deux buts, faire progresser l'agent d'analyse, et optimiser les détecteurs sur une multitude d'étiquettes. Les events restent à part (pas de conversion de `events/` en étiquettes). + +**Avis de Claude : deux buts, deux sortes d'étiquettes.** + +| | 1. Faire progresser l'analyste | 2. Optimiser les détecteurs | +|---|---|---| +| Qui les lit | un agent (`/labels-learner`) | un script (`score.py`, comme `benchmark.py`) | +| Combien | peu : ce dont l'analyste doute | beaucoup : des lots entiers | +| Forme | texte libre, `labeling/.jsonl` (D-098) | catégorie, capteurs, plage, période couverte en entier, format `etiquettes.json` (D-061) | +| Ce que vérifie l'expert | il réécrit avec ses mots | il corrige catégorie et bornes, lot par lot | +| Le risque | le cercle : une étiquette de l'analyste lui rend ce qu'il sait déjà ; ses propositions à part (`labeling/propositions/`), jamais lues par `/labels-learner` | la vérification à la main, longue sur des lots denses | + +- **Noyer l'agent** ne vaut que pour le but 1, et `/labels-learner` en retient 5 par phénomène. Pour le but 2, c'est un script qui lit : le nombre ne coûte rien, il en faut beaucoup, et sur des périodes couvertes en entier, pour qu'un instant sans étiquette veuille dire « rien vu » (ce que les étiquettes libres ne disent pas, D-098). +- **Le but 2 existe à moitié** : l'analyste étiquette déjà chaque lot de `/events-learner` (`etiquettes.json`), le `detectors-critic` s'y mesure, et le benchmark sur les events (D-069) a des étiquettes figées, dont celles de E-001 à E-005 sont encore à relire (point 48). Manque : garder les étiquettes des lots, les faire vérifier, et un benchmark qui les lit toutes. +- Questions : pour le but 2, comment vérifier vite un lot dense (la page Status avec les étiquettes, ou un tableau à cocher) ? Combien de lots vérifiés avant de régler les détecteurs dessus, et lesquels garder hors réglage pour mesurer ? Pour le but 1, un fichier à part ou un champ `auteur` ? + +**Décision de l'utilisateur (2026-11-02, D-100).** D'abord les étiquettes faites à la main : c'est la base de connaissance la plus fondamentale (des plages, le diagnostic et la classification de l'expert) ; le travail de l'analyste est de refaire cette classification sur des plages ; avec assez d'étiquettes, on pourra penser à l'apprentissage automatique. Les events sont gardés, et les validés ont aussi leurs étiquettes dans `labeling/E-xxx.jsonl`, écrites par un agent d'après leur fiche. +- [ ] Les étiquettes de E-001 à E-011 (validés), par un agent ; relecture par l'utilisateur. +- [ ] E-012 à E-014 après `/review-event` ; puis brancher l'étiquette dans `/new-event` et `/review-event`, pour chaque event validé plus tard. +- [ ] Le but 2 (les détecteurs) et les propositions de l'analyste : plus tard. +- [x] Un vérificateur des étiquettes de l'utilisateur, l'agent `label-reviewer` (D-101) : il pointe les incohérences et pose ses questions ; construit le 2026-11-02, premier essai à faire. + --- ## Annexe A — Les rapports des agents du 2026-10-23, résumés @@ -1888,3 +1913,7 @@ Une ligne par séance : date, point(s) traités, ce qui a changé, ce qui reste. - 2026-11-02 : point 69, l'utilisateur : pas de lecture à l'aveugle, le texte des étiquettes suffit (pas de fiche de station) ; processus simplifié en un passage par phénomène, à approuver. - 2026-11-02 : point 69, `/labels-learner` construit sur le processus simplifié (D-099) ; reste le premier essai, sur la perte de référence (5 étiquettes, JUNGFRAU et NORDEND), lancé par l'utilisateur. - 2026-11-02 : point 69, demande de l'utilisateur : l'analyste pose ses questions jusqu'à avoir compris, puis passe ses conclusions à un agent nouveau, le `documentaliste`, qui maintient la documentation ; skill, consigne de l'analyste, D-099, `run.md` et `CLAUDE.md` revus. +- 2026-11-02 : point 70 ajouté (idée de l'utilisateur : l'analyste propose des étiquettes, l'expert les vérifie ; crainte de noyer l'agent) : avis de Claude, peu de propositions, celles dont l'analyste doute, à part, réécrites par l'expert ; trois questions ; events et étiquettes restent séparés. +- 2026-11-02 : point 70, l'utilisateur : deux buts (faire progresser l'analyste ; optimiser les détecteurs sur une multitude d'étiquettes) ; point revu, deux sortes d'étiquettes, questions pour chacune. +- 2026-11-02 : point 70, décision de l'utilisateur (D-100) : les étiquettes faites à la main d'abord, base de connaissance ; les events gardés, les validés ont leurs étiquettes dans `labeling/E-xxx.jsonl`, écrites par un agent. +- 2026-11-02 : point 70, demande de l'utilisateur : un vérificateur de ses étiquettes ; agent `label-reviewer` construit (D-101), `revue` sur les étiquettes vérifiées, retiré par un Save. diff --git a/labeling/labeling.py b/labeling/labeling.py index 8816cde..20df06e 100644 --- a/labeling/labeling.py +++ b/labeling/labeling.py @@ -265,6 +265,11 @@ textarea{{width:100%;box-sizing:border-box;font:inherit;padding:6px}} select,but return chemin +def connue(station): + """Le nom devient un chemin : une station de data/ ou un event de events/ (ses étiquettes, D-100), rien d'autre.""" + return station in chargeur.stations() or station in {d.name for d in (ROOT / "events").glob("E-*") if d.is_dir()} + + def fichier(station): return ICI / f"{station}.jsonl" @@ -278,7 +283,7 @@ def lire(station): def ajouter(corps): """Le corps d'un Add (station, debut, fin, description) -> l'étiquette écrite ; ValueError s'il n'est pas bon.""" station, debut, fin, description = corps["station"], corps["debut"], corps["fin"], corps["description"].strip() - if station not in chargeur.stations(): # le nom devient un chemin : une station de data/, rien d'autre + if not connue(station): raise ValueError("unknown station") if not description or datetime.strptime(debut, FORMAT) >= datetime.strptime(fin, FORMAT): raise ValueError("empty text or range") @@ -296,7 +301,7 @@ def modifier(corps): écrite ; ValueError s'il n'est pas bon. Retrouvée par son contenu, pas par son rang : le fichier a pu changer à la main depuis le chargement de la page. Les autres lignes restent telles quelles.""" station, avant, description = corps["station"], corps["avant"], corps["description"].strip() - if station not in chargeur.stations(): + if not connue(station): raise ValueError("unknown station") if not description: raise ValueError("empty text") @@ -305,6 +310,7 @@ def modifier(corps): for i, ligne in enumerate(lignes): if ligne.strip() and json.loads(ligne) == avant: label = {**avant, "description": description} + label.pop("revue", None) # texte changé : à revoir par le label-reviewer (D-101) lignes[i] = json.dumps(label, ensure_ascii=False) provisoire = f.with_name(f.name + ".tmp") # écrit à côté puis remplacé : une coupure ne peut pas abîmer le fichier provisoire.write_text("\n".join(lignes), encoding="utf-8") @@ -329,7 +335,7 @@ class Serveur(chargeur.Chargeur): if url.path != "/labels": return super().do_GET() station = parse_qs(url.query).get("station", [""])[0] - if station not in chargeur.stations(): + if not connue(station): return self.send_error(400, "Unknown station") try: self.repond(lire(station)) diff --git a/run.md b/run.md index 6638295..16b5e4d 100644 --- a/run.md +++ b/run.md @@ -30,8 +30,14 @@ python3 labeling/labeling.py Choisir la station et les dates, puis Analyse. Glisser sur le plot zoome (double clic : tout revoir) ; glisser sur la barre dessous sélectionne une plage ; écrire ce qu'on voit, puis Add, qui écrit aussitôt une ligne dans `labeling/.jsonl`. Un clic sur la barre d'une étiquette l'affiche dessous : modifier le texte, puis Save. Ses bornes se corrigent, et elle se retire, dans ce fichier, puis recharger la page. Si le code de l'outil change alors que son serveur tourne (port 8767) : `pkill -f labeling/labeling.py`. +Les events validés ont leurs étiquettes, `labeling/E-xxx.jsonl` (D-100) ; leurs données s'ouvrent par `python3 labeling/labeling.py events/E-xxx/`, pas par le data loader. + Dans le texte, dire la cause et comment on l'a sue (quel plot, quel signe). Étiqueter aussi les cas trompeurs, qui ressemblent à un problème sans en être un : ils donnent les faux amis (point 69 du plan). Le fichier se commite comme le reste (`push.sh`). +# Faire vérifier ses étiquettes (label-reviewer) + +Dans une conversation Claude Code : `@label-reviewer labeling/.jsonl vérifier`. Il vérifie les étiquettes sans `revue` face aux données, aux autres étiquettes et à la documentation, écrit sa revue dans `labeling/revues/.md` et pose ses questions ; répondre dans la conversation, Claude les lui renvoie (« réponses : … »). Une étiquette confirmée ou corrigée reçoit `revue` ; modifier son texte dans l'outil le retire (D-101). + # Apprendre des étiquettes (labels-learner) Dans Claude Code, à la racine du dépôt :