Labeling tool: the expert labels ranges in plain text, one plot at a time (D-098, point 68)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
maximeandClaude Opus 5.5 committed 2026-10-30 08:59:38 +01:00
1 parent a0467e4c82
commit fcd9191a95
7 files changed
+337 -8

No files matched your search

+4 -2
View File
@@ -55,6 +55,7 @@ python3 vues-deplacements/maquette/explore.py [dossier] # page Explore : View,
python3 detectors/categories.py <dossier> # événements du journal, une ligne chacun python3 detectors/categories.py <dossier> # événements du journal, une ligne chacun
python3 detectors-view/detecteurs.py data/<STATION> [--du D --au F] # page des détecteurs seuls python3 detectors-view/detecteurs.py data/<STATION> [--du D --au F] # page des détecteurs seuls
./detectors-view/status.sh # page Status par son data loader : station, dates, Analyse ./detectors-view/status.sh # page Status par son data loader : station, dates, Analyse
python3 labeling/labeling.py [data/<STATION> --du D --au F] # l'expert étiquette : un plot, une plage, du texte, Add
python3 .claude/skills/events-learner/benchmark.py # détecteurs face à la base d'events python3 .claude/skills/events-learner/benchmark.py # détecteurs face à la base d'events
pdftotext -layout "docs/aimsight/<fichier>.pdf" - # lire un PDF AIMsight pdftotext -layout "docs/aimsight/<fichier>.pdf" - # lire un PDF AIMsight
python3 -m venv .venv && .venv/bin/pip install plotly matplotlib # recréer .venv python3 -m venv .venv && .venv/bin/pip install plotly matplotlib # recréer .venv
@@ -70,13 +71,13 @@ python3 -m venv .venv && .venv/bin/pip install plotly matplotlib # recréer .
### Lire sans saturer le contexte ### Lire sans saturer le contexte
- Fichier long (tailles en lignes ci-dessous) : lire son plan (`grep -n '^#' <fichier>`), puis la seule section utile (Read avec `offset` et `limit`). - Fichier long (tailles en lignes ci-dessous) : lire son plan (`grep -n '^#' <fichier>`), puis la seule section utile (Read avec `offset` et `limit`).
- `docs/decisions.md` (970 l, D-001 à D-097) : index par `grep -n '^## D-' docs/decisions.md`, puis l'entrée citée seulement ; son **Statut** dit si elle est remplacée. - `docs/decisions.md` (980 l, D-001 à D-098) : index par `grep -n '^## D-' docs/decisions.md`, puis l'entrée citée seulement ; son **Statut** dit si elle est remplacée.
- `data/` : explorer par script (`common.stations.load_stations`, outils de `agent-tools/`), jamais en affichant les CSV. - `data/` : explorer par script (`common.stations.load_stations`, outils de `agent-tools/`), jamais en affichant les CSV.
- Ne pas lire : `docs/superpowers/` (historique, sauf le plan vivant et la spec du support), `out/`, `.venv/`, `graphify-out/`. - Ne pas lire : `docs/superpowers/` (historique, sauf le plan vivant et la spec du support), `out/`, `.venv/`, `graphify-out/`.
### Racine ### Racine
- `README.md` : point d'entrée pour un humain. `run.md` (115 l) : les commandes que lance l'utilisateur (pompage, métriques de qualité par `~/optical_emulator`, `/events-learner`, `/review-event`). `push.sh "<message>"` : pull, commit de tout, push. - `README.md` : point d'entrée pour un humain. `run.md` (123 l) : les commandes que lance l'utilisateur (pompage, étiquetage, métriques de qualité par `~/optical_emulator`, `/events-learner`, `/review-event`). `push.sh "<message>"` : pull, commit de tout, push.
### `docs/` ### `docs/`
@@ -100,6 +101,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). - `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/` : 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`. - `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, une barre de temps pour sélectionner une plage, du texte libre sans catégorie ; Add écrit une ligne dans `<STATION>.jsonl`, versionné.
- `events-learner/`, `aiguiser/` : les séances de `/events-learner` et de `/aiguiser`, retiré (D-084, D-097), une par dossier `<séance>_<STATION>/` (`lot-NN/`, `bilan.md`) ; historique, à ne lire que sur demande. - `events-learner/`, `aiguiser/` : les séances de `/events-learner` et de `/aiguiser`, retiré (D-084, D-097), une par dossier `<séance>_<STATION>/` (`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`. - `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`.
- `agent-tools/` : les outils de lecture des agents (D-081) : `donnees.py` (lecture commune, aussi des détecteurs), `inventaire`, `resume`, `plages`, `jours`, `ensemble`, `graphique`, `vignettes`, `gif` ; mode d'emploi : skill `lire-les-donnees` ; optimisés ou complétés par le `tool-builder` de `/events-learner` (D-097). - `agent-tools/` : les outils de lecture des agents (D-081) : `donnees.py` (lecture commune, aussi des détecteurs), `inventaire`, `resume`, `plages`, `jours`, `ensemble`, `graphique`, `vignettes`, `gif` ; mode d'emploi : skill `lire-les-donnees` ; optimisés ou complétés par le `tool-builder` de `/events-learner` (D-097).
+8 -6
View File
@@ -34,13 +34,13 @@ def formulaire(station="", du="", au=""):
<button>Analyse</button></form>""" <button>Analyse</button></form>"""
def accueil(): def accueil(titre="Status", nom="data-loader"):
"""Le formulaire seul, dans out/data-loader.html -> son chemin.""" """Le formulaire seul, dans out/<nom>.html -> son chemin."""
chemin = ROOT / "out" / "data-loader.html" chemin = ROOT / "out" / f"{nom}.html"
chemin.parent.mkdir(exist_ok=True) chemin.parent.mkdir(exist_ok=True)
chemin.write_text(f"""<!doctype html><html lang="en"><head><meta charset="utf-8"><title>Status loader</title> chemin.write_text(f"""<!doctype html><html lang="en"><head><meta charset="utf-8"><title>{titre} loader</title>
<style>body{{font-family:system-ui,sans-serif;margin:16px;background:#fff;color:#1a1a19}}</style></head><body> <style>body{{font-family:system-ui,sans-serif;margin:16px;background:#fff;color:#1a1a19}}</style></head><body>
<h2>Status</h2>{formulaire()}</body></html>""", encoding="utf-8") <h2>{titre}</h2>{formulaire()}</body></html>""", encoding="utf-8")
return chemin return chemin
@@ -50,6 +50,8 @@ def ouvrir(chemin):
class Chargeur(_Pages): class Chargeur(_Pages):
SCRIPT = STATUS # le script que lance « Analyse » ; labeling/labeling.py a le sien
def do_GET(self): def do_GET(self):
url = urlsplit(self.path) url = urlsplit(self.path)
if url.path != "/analyse": if url.path != "/analyse":
@@ -58,7 +60,7 @@ class Chargeur(_Pages):
station = q.get("station") station = q.get("station")
if station not in stations(): # le nom devient un chemin : une station de data/, rien d'autre if station not in stations(): # le nom devient un chemin : une station de data/, rien d'autre
return self.send_error(400, "Unknown station") return self.send_error(400, "Unknown station")
args = [sys.executable, str(STATUS), str(ROOT / "data" / station), "--sans-ouvrir"] args = [sys.executable, str(self.SCRIPT), str(ROOT / "data" / station), "--sans-ouvrir"]
args += [f"--{k}={q[k]}" for k in ("du", "au") if q.get(k)] args += [f"--{k}={q[k]}" for k in ("du", "au") if q.get(k)]
r = subprocess.run(args, capture_output=True, text=True) r = subprocess.run(args, capture_output=True, text=True)
if r.returncode: if r.returncode:
+7
View File
@@ -971,3 +971,10 @@ Règles du journal :
- **Pourquoi** : l'utilisateur, 2026-10-29 : le lecteur de `/aiguiser` extrait des informations sans savoir ce qui est pertinent, et refait le même travail à chaque séance sans être guidé ; celui qui profite des outils, c'est l'analyste, qui apprend par la base d'events. Constat : la vérité de `/aiguiser` comptait tout écart comme un moment, si bien que « mieux » voulait dire « voir plus » (neuf modifications sur neuf gardées en quatre séances ; outils de 419 à 1 423 lignes, skill de 4,8 à 20,9 Ko) ; et l'inventaire cachait des données : six colonnes de qualité d'image remplies sur LENZSPITZE et NADELHORN, 31 métriques système, qu'aucun outil ni aucune doc ne citait. - **Pourquoi** : l'utilisateur, 2026-10-29 : le lecteur de `/aiguiser` extrait des informations sans savoir ce qui est pertinent, et refait le même travail à chaque séance sans être guidé ; celui qui profite des outils, c'est l'analyste, qui apprend par la base d'events. Constat : la vérité de `/aiguiser` comptait tout écart comme un moment, si bien que « mieux » voulait dire « voir plus » (neuf modifications sur neuf gardées en quatre séances ; outils de 419 à 1 423 lignes, skill de 4,8 à 20,9 Ko) ; et l'inventaire cachait des données : six colonnes de qualité d'image remplies sur LENZSPITZE et NADELHORN, 31 métriques système, qu'aucun outil ni aucune doc ne citait.
- **Options écartées** : revoir `/aiguiser` comme `/events-learner` (un `reading-critic`, un `reading-upgrader`, un `reading-control` ; première proposition de Claude) : le lecteur restait sans notion de pertinence ; un `tool-builder` qui retire des outils (l'utilisateur) ; un contrôle du `tool-builder` sur le diff (l'utilisateur ne sait pas encore comment le faire) ; un nouveau script pour l'inventaire des données (`inventaire.py` étendu suffit). - **Options écartées** : revoir `/aiguiser` comme `/events-learner` (un `reading-critic`, un `reading-upgrader`, un `reading-control` ; première proposition de Claude) : le lecteur restait sans notion de pertinence ; un `tool-builder` qui retire des outils (l'utilisateur) ; un contrôle du `tool-builder` sur le diff (l'utilisateur ne sait pas encore comment le faire) ; un nouveau script pour l'inventaire des données (`inventaire.py` étendu suffit).
- **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. - **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.
- **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), 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/<STATION>.jsonl`, une ligne chacune (`debut`, `fin`, `description`), versionné ; zones grisées sur tous les plots, chevauchements admis ; une étiquette se corrige 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.
- **Conséquence** : `score.py` ne lit pas ces étiquettes (pas de catégorie, et un instant sans étiquette n'y veut pas dire « rien vu »). Comment l'analyste s'en sert reste à décider, une fois assez d'étiquettes écrites. Une étiquette n'entre dans `events/` que par `/new-event` ou l'`event-builder`.
@@ -124,6 +124,7 @@ Types : **Comprendre** (lire, expliquer, rien ne change), **Décider** (l'utilis
| 65 | Un saut marqué dès son début | Coder | — | à faire (détail) | | 65 | Un saut marqué dès son début | Coder | — | à faire (détail) |
| 66 | Client et spécialiste : la complexité sur demande | Décider | 58, 62, 64 | idée gardée | | 66 | Client et spécialiste : la complexité sur demande | Décider | 58, 62, 64 | idée gardée |
| 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 | | 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 |
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). 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).
@@ -1553,6 +1554,41 @@ Les cas se croisent : une caméra posée sur un pont a deux ouvrages, celui qui
- [ ] `analyser-lot` : la note parmi ce qu'il lit ; la carte à la demande. - [ ] `analyser-lot` : la note parmi ce qu'il lit ; la carte à la demande.
- [ ] Le test, si l'utilisateur le veut. - [ ] Le test, si l'utilisateur le veut.
### Point 68 : L'expert étiquette lui-même : un outil web
**L'idée** (l'utilisateur, 2026-10-30). Une petite page web pour voir les données et les étiqueter soi-même, en expert du domaine : une base sur laquelle le LLM travaille ensuite ; l'analyste regarde ces étiquettes et prend connaissance des phénomènes, en plus de ce qu'on lui explique (point 67). Complémentaire, pas à la place.
**Avis de Claude (2026-10-30) : oui.**
- La seule vérité du projet est aujourd'hui l'analyste : `score.py` et le benchmark jugent les détecteurs sur ses étiquettes (« l'analyste peut se tromper aussi ») ; le plan dit encore à relire celles de E-001 à E-005 (point 48). Aucune étiquette ne vient de l'expert.
- Une étiquette coûte une ligne, un event un dossier (`/new-event`). Les deux se complètent : une étiquette marquante devient un event, et les cas des points 60, 62 et 64, que Claude devait chercher, l'expert les désigne.
- Ce qui fera sa valeur, c'est le **pourquoi** : une plage et le mot « saut » n'apprennent rien à l'analyste ; « référence cachée, la reprojection décale ces cibles, elle revient et tout se recale » lui apprend à raisonner.
**Précisions de l'utilisateur (2026-10-30), qui remplacent la proposition de Claude sur la page Status.** Les données se consultent déjà sur le monitoring : l'outil ne sert qu'à se repérer dans le temps et à écrire. Une page à part, un plot à la fois ; du langage naturel, **aucune catégorie**, pour ne pas borner (on en déduira après coup) ; un bouton Add qui écrit aussitôt dans le fichier, sans Save ; les zones déjà étiquetées restent visibles et peuvent se superposer ; un dossier à la racine, `labeling/`. Le but est d'avoir les étiquettes : un outil local, fonctionnel et très simple, ni parfait ni déployable.
**Description, à approuver par l'utilisateur.** De haut en bas :
1. Le data loader de la page Status (`chargeur.formulaire`) : station, dates, Analyse.
2. Un menu déroulant, comme le menu Advanced d'Explore (`select_graph` de l'application de référence) : Error value, X, Y, Relative shift H et V, Corrected shift H et V (`corr_x`, `corr_y`), References (reproj. error), Camera movement ; seulement les plots qui ont des données (Quality plus tard : seul NADELHORN a `quality/`, et il faudrait un lecteur de plus). Capteurs en légende comme à la page Status ; la plage de temps est gardée quand on change de plot.
3. Le plot : glisser zoome. Les zones étiquetées y sont grisées, sur tous les plots.
4. Dessous, la barre de temps, mêmes abscisses, qui suit le zoom : glisser y sélectionne une plage (box select horizontal de Plotly ; une figure n'a qu'un mode de glissement, d'où deux figures alignées). Chaque étiquette y est une barre, son texte au survol ; celles qui se chevauchent s'empilent, comme les status.
5. Dessous, la plage sélectionnée en UTC, le champ de texte, le bouton Add.
**Choix de Claude, à corriger au besoin.**
- `labeling/<STATION>.jsonl`, une ligne par étiquette : `{"debut": "2026-10-08T01:00Z", "fin": "2026-10-08T02:45Z", "description": "…"}`, les noms de champs de l'analyste, sans ceux qui bornent. Add écrit une ligne ; un `grep` suffit à chercher ; le diff git se lit. Versionné (`data/` ne l'est pas), hors de `events/` (ses seules portes : `/new-event`, `event-builder`).
- Pas de `capteurs` : le texte les dit.
- Pas de modification ni de suppression dans la page : une ligne à retirer du fichier.
- Un seul fichier de code, `labeling/labeling.py` : la page et son serveur (celui du data loader, plus l'enregistrement) ; de la page Status, seule change la cible du formulaire.
- Rien d'autre sur la page : ni images, ni status des détecteurs, ni température, que le monitoring montre.
**Les limites à garder.**
- Une étiquette de l'expert est ponctuelle : un instant sans étiquette n'y veut pas dire « rien vu », contrairement à l'analyste (point 45). Face aux détecteurs, « trouvées » aurait un sens, « justes » non, tant qu'une plage n'est pas marquée relue en entier ; et `score.py` ne lit pas ces étiquettes, faute de catégorie. L'outil sert à apprendre, pas à calculer un score.
- Si l'analyste lit l'étiquette du lot qu'il analyse, il récite : elle lui apprend sur les autres périodes, et peut le mesurer sur la sienne (le test avant et après du point 67). Proposé, pas imposé.
- Pas d'alourdissement (point 67, ~85 Ko) : l'analyste n'y vient qu'une fois assez d'étiquettes écrites, à la demande, par une recherche. Rien à construire de son côté dans l'essai.
- [x] L'utilisateur approuve la description (2026-10-30).
- [x] L'outil : `labeling/labeling.py` (D-098), essayé le 2026-10-30 sur NIEDERHORN du 2026-09-25 au 2026-10-08 par de vrais gestes dans Chrome : sélection et poignées, Add, chevauchement, zoom suivi par la barre, changement de plot, rechargement ; pages de NORDEND (20 Mo, toute la période), CLARIDEN, LENZSPITZE et NADELHORN générées, NORDEND et LENZSPITZE chargées en moins de 2 s, un changement de plot en moins d'une seconde.
- [ ] L'utilisateur l'essaie et le valide (commité avant l'essai, à sa demande, le 2026-10-30).
- [ ] Quelques cas étiquetés par l'utilisateur ; regarder ensuite ce que l'analyste en tire.
--- ---
## Annexe A — Les rapports des agents du 2026-10-23, résumés ## Annexe A — Les rapports des agents du 2026-10-23, résumés
@@ -1734,3 +1770,6 @@ Une ligne par séance : date, point(s) traités, ce qui a changé, ce qui reste.
- 2026-10-29 : point 56, D-097 : `/aiguiser` retiré ; l'analyste voit ses données (`inventaire.py`), écrit ses scripts, dit ses outils ; le `tool-builder` optimise ou ajoute, sans retrait ni contrôle ; à essayer sur une séance. - 2026-10-29 : point 56, D-097 : `/aiguiser` retiré ; l'analyste voit ses données (`inventaire.py`), écrit ses scripts, dit ses outils ; le `tool-builder` optimise ou ajoute, sans retrait ni contrôle ; à essayer sur une séance.
- 2026-10-29 : point 67 : brouillon de `docs/displacement/domaine/chaine-de-mesure.md`, sources marquées ([U] utilisateur, [A] AIMsight, [D] données, [H] hypothèse de Claude) ; pas encore dans ce que lit l'analyste ; reste la relecture de l'utilisateur. - 2026-10-29 : point 67 : brouillon de `docs/displacement/domaine/chaine-de-mesure.md`, sources marquées ([U] utilisateur, [A] AIMsight, [D] données, [H] hypothèse de Claude) ; pas encore dans ce que lit l'analyste ; reste la relecture de l'utilisateur.
- 2026-10-29 : vocal relu face au plan et à la note : l'état des pipelines ajouté au point 57 ; dans `chaine-de-mesure.md`, le saut qui revient (bénin, la question est sa cause) et l'hésitation de l'utilisateur sur JUNGFRAU (support ou objectif). - 2026-10-29 : vocal relu face au plan et à la note : l'état des pipelines ajouté au point 57 ; dans `chaine-de-mesure.md`, le saut qui revient (bénin, la question est sa cause) et l'hésitation de l'utilisateur sur JUNGFRAU (support ou objectif).
- 2026-10-30 : point 68 ajouté (idée de l'utilisateur : une page web pour étiqueter soi-même, en expert) : avis de Claude, oui ; essai proposé sur la page Status, étiquettes libres dans `etiquettes-expert/`, limites notées ; à valider.
- 2026-10-30 : point 68, précisions de l'utilisateur : une page à part dans `labeling/`, un plot à la fois comme le menu Advanced, une barre de temps alignée pour sélectionner, du texte sans catégorie, Add écrit aussitôt, zones étiquetées visibles ; description à approuver.
- 2026-10-30 : point 68, description approuvée, outil construit et essayé (D-098), commité à la demande de l'utilisateur ; reste son essai.
+270
View File
@@ -0,0 +1,270 @@
"""L'outil d'étiquetage de l'expert (D-098, point 68 du plan du journal du matin) : se repérer dans le temps et écrire ce qu'on
voit, en langage naturel, sans catégorie ; les données se consultent sur le monitoring. En haut, le data loader de la page
Status ; un menu déroulant, un plot à la fois, comme le menu Advanced d'Explore ; dessous, une barre de temps aux mêmes
abscisses, qui suit le zoom : y glisser sélectionne une plage, puis du texte et Add. Add écrit aussitôt une ligne dans
labeling/<STATION>.jsonl : {"debut": "2026-10-08T01:00Z", "fin": "2026-10-08T02:45Z", "description": "…"}, en UTC, les noms
de champs de l'analyste (etiquettes.json). Une étiquette se corrige dans ce fichier, puis recharger la page. Les zones
étiquetées sont grisées sur tous les plots ; sur la barre, une barre chacune, son texte au survol, celles qui se chevauchent
l'une sous l'autre. Son serveur local (http://127.0.0.1:8767, lancé en tâche de fond) sert out/ et data/, plus /analyse
(ce script lancé à chaque fois, comme le data loader) et /labels (lire et ajouter).
Usage : python3 labeling/labeling.py [<dossier de station> [--du AAAA-MM-JJ] [--au AAAA-MM-JJ]]
(sans dossier : le data loader seul ; --au exclu ; sans dates, toute la période du dossier ; page :
out/labeling_<STATION>_<du>_<au>.html, ouverte)
"""
import argparse
import html
import http.server
import json
import os
import sys
from datetime import datetime
from pathlib import Path
from urllib.parse import parse_qs, urlsplit
ICI = Path(__file__).resolve().parent
sys.path[:0] = [str(ICI.parent / "detectors-view"), str(ICI.parent / "detectors-view" / "data-loader")]
import chargeur # noqa: E402 (son formulaire, son serveur ; bascule seule sur .venv si plotly manque)
import detecteurs # noqa: E402 (les couleurs et les références de la page Status)
from detecteurs import ROOT, donnees # noqa: E402
from plotly.offline import get_plotlyjs_version # noqa: E402
PORT = 8767 # ni celui de common.page (8765), ni celui du data loader (8766)
# Le menu Advanced d'Explore (select_graph, Dashboard/layouts/ExploreLayout.py de l'application de référence), dans son ordre
PLOTS = (("error_value", "Error value"), ("x", "X [px]"), ("y", "Y [px]"),
("relative_x", "Relative Horizontal Shift"), ("relative_y", "Relative Vertical Shift"),
("corr_x", "Relative Corrected Horizontal Shift"), ("corr_y", "Relative Corrected Vertical Shift"),
("reproj_err", "References (reproj. error)"))
CAMERA = "Camera movement"
FORMAT = "%Y-%m-%dT%H:%MZ"
# Une figure Plotly n'a qu'un mode de glissement : le plot zoome, la barre, figure à part, sélectionne. Elle reprend à chaque
# changement du plot sa plage et ses marges, la légende pouvant les élargir : c'est ce qui garde les abscisses alignées.
PAGE_JS = """
const GRIS = '#6b6b66', BLEU = '#2a78d6', VOIE = 22; // VOIE : px par rangée d'étiquettes
const fig = document.getElementById('fig'), barre = document.getElementById('barre'), menu = document.getElementById('plot');
const texte = document.getElementById('texte'), add = document.getElementById('add'), plage = document.getElementById('plage');
const AIDE = plage.textContent;
let labels = [], choix = null; // choix : la plage sélectionnée, [debut, fin] au format des étiquettes
const lisible = s => s.slice(0, 16).replace('T', ' ');
const marge = () => ({l: 60, r: 20, t: 10, b: 30});
function zones() {
const z = (a, b, couleur, o) => ({type: 'rect', xref: 'x', yref: 'paper', x0: lisible(a), x1: lisible(b), y0: 0, y1: 1,
fillcolor: couleur, opacity: o, line: {width: 0}, layer: 'below'});
return labels.map(l => z(l.debut, l.fin, GRIS, 0.2)).concat(choix ? [z(choix[0], choix[1], BLEU, 0.25)] : []);
}
function aligne() {
const f = fig._fullLayout;
if (!barre._fullLayout) return; // au chargement, la barre se dessine juste après le plot
return Plotly.relayout(barre, {'xaxis.range': f.xaxis.range.slice(), 'margin.l': f._size.l, 'margin.r': f._size.r});
}
function dessineFig() {
const p = PLOTS[menu.value];
// uirevision : le zoom et les capteurs cachés restent d'un plot à l'autre ; l'ordonnée, propre à chaque plot, se recale
// uid sans espace ni parenthèse : Plotly s'en sert comme d'un sélecteur CSS
return Plotly.react(fig, p.traces.map(t => ({type: 'scatter', mode: 'lines', x: T[t.t], y: t.y, name: t.name, uid: t.name.replace(/\\W/g, '_'),
line: t.line, hovertemplate: `${t.name}: %{y}<extra></extra>`})),
{height: 460, hovermode: 'closest', plot_bgcolor: 'white', margin: marge(), legend: {x: 1.01, y: 1}, uirevision: 1, shapes: zones(),
xaxis: {type: 'date', range: [lisible(A), lisible(B)], gridcolor: '#e6e6e2'},
yaxis: {title: {text: p.titre}, uirevision: p.titre, gridcolor: '#eeeeea', zeroline: false}},
{responsive: true, doubleClick: 'reset'}).then(aligne);
}
function dessineBarre() {
const tries = [...labels].sort((a, b) => a.debut < b.debut ? -1 : 1), voies = [];
const voie = tries.map(l => { // la première rangée libre, sinon une nouvelle, comme les status
const r = voies.findIndex(f => f <= l.debut), i = r < 0 ? voies.length : r;
voies[i] = l.fin;
return i;
});
const n = Math.max(1, voies.length), f = fig._fullLayout;
return Plotly.react(barre, [{type: 'bar', orientation: 'h', y: voie, base: tries.map(l => lisible(l.debut)),
x: tries.map(l => Date.parse(l.fin) - Date.parse(l.debut)), width: 0.85, marker: {color: GRIS}, text: tries.map(l => l.description),
textposition: 'inside', insidetextanchor: 'start', textangle: 0, unselected: {marker: {opacity: 1}}, // sinon une sélection les pâlit
hoverinfo: 'text', hovertext: tries.map(l => `${lisible(l.debut)} → ${lisible(l.fin)} UTC<br>${l.description.replace(/\\n/g, '<br>')}`)}],
{height: 40 + VOIE * n, dragmode: 'select', selectdirection: 'h', hovermode: 'closest', plot_bgcolor: '#f2f2ef', showlegend: false,
margin: {...marge(), l: f._size.l, r: f._size.r}, uniformtext: {minsize: 9, mode: 'hide'},
xaxis: {type: 'date', range: f.xaxis.range.slice(), showgrid: false},
yaxis: {range: [n - 0.5, -0.5], fixedrange: true, showticklabels: false, showgrid: false, zeroline: false},
newselection: {line: {color: BLEU, width: 1}}, activeselection: {fillcolor: BLEU, opacity: 0.25}},
{responsive: true, displayModeBar: false, doubleClick: false});
}
function maj() {
plage.textContent = choix ? `${lisible(choix[0])} → ${lisible(choix[1])} UTC` : AIDE;
add.disabled = !(choix && choix[0] < choix[1] && texte.value.trim());
}
function choisit(c) {
choix = c;
maj();
return Plotly.relayout(fig, {shapes: zones()});
}
menu.onchange = dessineFig;
texte.oninput = maj;
add.onclick = async () => {
add.disabled = true;
const corps = {station: STATION, debut: choix[0], fin: choix[1], description: texte.value.trim()};
const r = await fetch('/labels', {method: 'POST', body: JSON.stringify(corps)}).catch(e => e);
if (!r.ok) { // rien n'est perdu : le texte et la plage restent dans la page
maj();
return alert('Not saved: ' + (r.statusText || r.message));
}
labels.push(await r.json());
texte.value = '';
await dessineBarre();
await Plotly.relayout(barre, {selections: []});
await choisit(null);
};
dessineFig().then(dessineBarre).then(() => {
fig.on('plotly_relayout', aligne);
barre.on('plotly_selected', ev => {
const r = ev && ev.range && ev.range.x;
if (r) choisit(r.map(v => String(v).slice(0, 16).replace(' ', 'T') + 'Z'));
});
barre.on('plotly_deselect', () => choisit(null));
// Lues à chaque chargement, pas écrites dans la page : recharger montre toujours le fichier.
fetch('/labels?station=' + encodeURIComponent(STATION))
.then(r => r.ok ? r.json() : Promise.reject(new Error(r.statusText)))
.then(l => {
labels = l.filter(x => x.debut < B && x.fin > A);
return dessineBarre().then(() => Plotly.relayout(fig, {shapes: zones()}));
})
.catch(e => alert('Labels not read: ' + e.message));
});
"""
def plots(mesures, poses, a, b):
"""-> (T, [plot]) : T, les heures de chaque série, une fois, elles reviennent dans chaque plot (clé : le capteur, "" pour la
caméra) ; plot : titre et traces (name, t : sa clé dans T, y, line), sans les plots ni les capteurs vides."""
heure = lambda t: t.strftime("%Y-%m-%d %H:%M") # noqa: E731 (UTC, sans fuseau : comme l'affiche Plotly)
valeurs = lambda s, c: [None if m[c] is None else round(m[c], 5) for m in s] # noqa: E731
dans = {s: [m for m in mesures[s] if a <= m["t"] < b] for s in sorted(mesures)}
refs = detecteurs.references(mesures, a, b)
out = []
for col, titre in PLOTS:
series = {s: valeurs(ms, col) for s, ms in dans.items()}
traces = [{"name": s + " (ref.)" * (s in refs), "t": s, "y": y,
"line": {"width": 1.2, "color": detecteurs.COULEURS[i % len(detecteurs.COULEURS)], "dash": "dot" if s in refs else "solid"}}
for i, (s, y) in enumerate(series.items()) if any(v is not None for v in y)]
if traces:
out.append({"titre": titre, "traces": traces})
if poses:
out.append({"titre": CAMERA + " (deg)", "traces": [{"name": c, "t": "", "y": valeurs(poses, c), "line": {"width": 1.2, "color": couleur}}
for c, couleur in detecteurs.POSE]})
return {"": [heure(p["t"]) for p in poses], **{s: [heure(m["t"]) for m in ms] for s, ms in dans.items()}}, out
def page(dossier, du=None, au=None):
mesures = donnees.charger(dossier)
if not mesures:
raise SystemExit(f"Aucun export « advanced » dans {dossier}.")
tous = sorted({m["t"] for ms in mesures.values() for m in ms})
a = donnees.instant(du) if du else tous[0]
b = donnees.instant(au) if au else tous[-1] + (tous[-1] - tous[-2])
T, liste = plots(mesures, [p for p in donnees.charger_camera(dossier) if a <= p["t"] < b], a, b)
if not liste:
raise SystemExit(f"Aucune mesure dans {dossier} du {du} au {au}.")
station = os.path.basename(os.path.normpath(dossier))
nom = f"{station}_{donnees.iso(a)[:10]}_{donnees.iso(b)[:10]}"
chemin = ROOT / "out" / f"labeling_{nom}.html"
chemin.parent.mkdir(exist_ok=True)
js = lambda v: json.dumps(v, separators=(",", ":")).replace("</", "<\\/") # noqa: E731
options = "".join(f'<option value="{i}">{html.escape(p["titre"])}</option>' for i, p in enumerate(liste))
chemin.write_text(f"""<!doctype html><html lang="en"><head><meta charset="utf-8"><title>Labeling {html.escape(nom)}</title>
<script src="https://cdn.plot.ly/plotly-{get_plotlyjs_version()}.min.js"></script>
<style>body{{font-family:system-ui,sans-serif;margin:16px;background:#fff;color:#1a1a19}}
textarea{{width:100%;box-sizing:border-box;font:inherit;padding:6px}} select,button{{font:inherit}} #plage{{margin:8px 0}}</style></head><body>
<h2>Labeling, {html.escape(station)}</h2>
{chargeur.formulaire(station, du or "", au or "")}
<label>Plot <select id="plot">{options}</select></label>
<div id="fig"></div>
<div id="barre"></div>
<p id="plage">Drag on the bar above to select a time range.</p>
<textarea id="texte" rows="3" placeholder="What do we see in this range?"></textarea>
<p><button id="add" disabled>Add</button></p>
<script>const T = {js(T)}, PLOTS = {js(liste)}, STATION = {js(station)}, A = {js(donnees.iso(a))}, B = {js(donnees.iso(b))};
{PAGE_JS}</script>
</body></html>""", encoding="utf-8")
return chemin
def fichier(station):
return ICI / f"{station}.jsonl"
def lire(station):
f = fichier(station)
# split et non splitlines : celui-ci couperait aussi sur les séparateurs Unicode que le texte peut contenir
return [json.loads(l) for l in f.read_text(encoding="utf-8").split("\n") if l.strip()] if f.exists() else []
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
raise ValueError("unknown station")
if not description or datetime.strptime(debut, FORMAT) >= datetime.strptime(fin, FORMAT):
raise ValueError("empty text or range")
label = {"debut": debut, "fin": fin, "description": description}
f = fichier(station)
# Une ligne retirée à la main peut laisser le fichier sans fin de ligne : la suivante se collerait à elle.
avant = f.read_bytes() if f.exists() else b""
with open(f, "ab") as sortie:
sortie.write(b"\n" * bool(avant and not avant.endswith(b"\n")) + json.dumps(label, ensure_ascii=False).encode() + b"\n")
return label
class Serveur(chargeur.Chargeur):
SCRIPT = __file__
def repond(self, valeur):
corps = json.dumps(valeur, ensure_ascii=False).encode()
self.send_response(200)
self.send_header("Content-Type", "application/json; charset=utf-8")
self.send_header("Content-Length", str(len(corps)))
self.end_headers()
self.wfile.write(corps)
def do_GET(self):
url = urlsplit(self.path)
if url.path != "/labels":
return super().do_GET()
station = parse_qs(url.query).get("station", [""])[0]
if station not in chargeur.stations():
return self.send_error(400, "Unknown station")
try:
self.repond(lire(station))
except ValueError as e: # une ligne abîmée à la main : le dire, sans toucher au fichier
self.send_error(500, f"labeling/{station}.jsonl unreadable: {e}")
def do_POST(self):
if self.path != "/labels":
return self.send_error(404)
# Ce fichier sera lu par l'analyste : une autre page du navigateur ne doit pas pouvoir y écrire.
if self.headers.get("Origin") not in (None, f"http://127.0.0.1:{PORT}"):
return self.send_error(403)
try:
self.repond(ajouter(json.loads(self.rfile.read(int(self.headers["Content-Length"])))))
except (KeyError, TypeError, AttributeError, ValueError) as e:
self.send_error(400, f"Not a label: {e}")
if __name__ == "__main__":
if sys.argv[1:] == ["serve"]:
http.server.ThreadingHTTPServer(("127.0.0.1", PORT), Serveur).serve_forever()
p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
p.add_argument("dossier", nargs="?", help="sans dossier : le data loader seul")
p.add_argument("--du")
p.add_argument("--au")
p.add_argument("--sans-ouvrir", action="store_true", help="écrit la page sans l'ouvrir")
o = p.parse_args()
chemin = page(o.dossier, o.du, o.au) if o.dossier else chargeur.accueil("Labeling", "labeling-loader")
print(chemin)
if not o.sans_ouvrir:
chargeur.open_served(chemin, PORT, __file__)
+8
View File
@@ -22,6 +22,14 @@ Une plage choisie (historique, jour en échec) :
Détails : `extraction/README.md`. Détails : `extraction/README.md`.
# Étiqueter des données (labeling)
```bash
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/<STATION>.jsonl`. Une étiquette se corrige 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`.
# Compléter les métriques de qualité d'une caméra (optical_emulator) # Compléter les métriques de qualité d'une caméra (optical_emulator)
Les anciennes caméras n'ont pas les six métriques de qualité (`peak`, `flux`, `sharpness`, `fwhm`, `dominance`, `snr`) dans leurs déplacements. `~/optical_emulator` les recalcule à partir des images DIFF, en rejouant sur CPU le calcul du GPU des caméras récentes. Les anciennes caméras n'ont pas les six métriques de qualité (`peak`, `flux`, `sharpness`, `fwhm`, `dominance`, `snr`) dans leurs déplacements. `~/optical_emulator` les recalcule à partir des images DIFF, en rejouant sur CPU le calcul du GPU des caméras récentes.
@@ -135,3 +135,4 @@ Ce qui peut arriver sur le terrain, relié aux catégories du journal, sans le d
- Retour de l'utilisateur (2026-10-29) sur les détecteurs : dire la cause, pas seulement l'événement ; rendre l'analyste plus savant d'abord (trois effets thermiques, températures, métriques de qualité, cause des sauts), les détecteurs ensuite. Points 57 à 66 du plan. - Retour de l'utilisateur (2026-10-29) sur les détecteurs : dire la cause, pas seulement l'événement ; rendre l'analyste plus savant d'abord (trois effets thermiques, températures, métriques de qualité, cause des sauts), les détecteurs ensuite. Points 57 à 66 du plan.
- Idée de l'utilisateur (2026-10-29) : le savoir métier de l'analyste, suffisant sans l'alourdir ? Proposition de Claude au point 67 du plan : une note d'une page sur la chaîne de mesure (où chaque cause entre), la carte lue à la demande. - Idée de l'utilisateur (2026-10-29) : le savoir métier de l'analyste, suffisant sans l'alourdir ? Proposition de Claude au point 67 du plan : une note d'une page sur la chaîne de mesure (où chaque cause entre), la carte lue à la demande.
- Idée de l'utilisateur (2026-10-30) : une page web pour étiqueter soi-même les données, en expert, pour que l'analyste apprenne de ces étiquettes. Précisée par l'utilisateur au point 68 du plan : une page à part, `labeling/`, un plot à la fois, une barre de temps pour sélectionner une plage, du texte libre sans catégorie.