Compare commits

...
5 Commits
Author SHA1 Message Date
maxime 148870f3ff labels 2026-10-30 16:40:33 +01:00
maximeandClaude Opus 5.5 b52f1c0d22 View tool: Labels checkbox, sensor names on the images, targets and references apart
Positions come from a new detecteurs.positions(), taken out of camera().

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-30 14:18:14 +01:00
maximeandClaude Opus 5.5 83f7f7be7f Labeling tool: system metrics in the plot menu, identifiers left out; point 69: how the analyst learns from labels, still open
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-30 11:23:31 +01:00
maximeandClaude Opus 5.5 647f7f7509 View tool: IRON images under the data loader, browse and zoom
The data loader's error message now names the script that failed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-30 10:44:09 +01:00
maximeandClaude Opus 5.5 fcd9191a95 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>
2026-10-30 08:59:38 +01:00
12 changed files with 620 additions and 18 deletions

No files matched your search

+8 -3
View File
@@ -8,7 +8,7 @@ Diagnostic proactif pour **AIMsight**, un système de surveillance optique de d
Cadrage du product owner : sous-projet G, santé des sites et notifications au client (`docs/aimsight/AIMsight_handoff_G_site_health.md`). Sa dernière section liste les écarts de ce dépôt, à arbitrer par l'utilisateur.
## État et prochaine étape (au 2026-10-29)
## État et prochaine étape (au 2026-10-30)
- **Domaines système, livrés en prototype** : Energy (D-020, D-043), Storage (D-034, D-035), Cellular (D-031, D-037), Temperature (D-040) ; chacun avec ses analyses, sa couleur du jour, sa figure du site, son bloc dans la vue client, sa notification support et son guide (D-039, D-041). Seul Energy repose sur des events de l'expert ; les autres ont des seuils provisoires et attendent le spécialiste.
- **Maquettes du site** (D-022, D-039) : client « System Summary », une page par station, un bloc par domaine ; support « Home », une notification par station et par domaine Orange ou Red, liée à la vue client (D-025).
@@ -18,6 +18,7 @@ Cadrage du product owner : sous-projet G, santé des sites et notifications au c
- **En attente** : agents LLM côté serveur (D-027) et enquête par API (D-042), documents seulement ; communication avec la caméra (dev container, D-038), en attente de la doc de l'API REST ; détection des sauts et tendances (D-055, onglet `Displacements`), très expérimentale.
- **Prochaine étape** :
- journal du matin : les points ouverts du plan vivant, sur les consignes de l'utilisateur ; un point validé n'est plus repris ;
- les étiquettes de l'expert : l'utilisateur en réalise quelques-unes (`labeling/`, D-098) ; comment l'analyste en apprend reste à décider (point 69 du plan, `/labels-learner` proposé) ;
- la première séance de `/events-learner` avec les rôles revus, lancée par l'utilisateur (points 52 à 56 du plan) ; le releveur et l'améliorateur, communs aux processus automatiques, dans une autre conversation ;
- les écarts du handoff, dont « consistent with » face aux phrases catégoriques du journal, quand l'utilisateur les arbitre ;
- Cellular, Storage, Temperature : les réponses du spécialiste (`docs/<domaine>/domaine/questions-pour-l-expert.md`, pour Temperature la question 1 de `point-de-depart.md`), puis corrections et guides.
@@ -55,6 +56,8 @@ python3 vues-deplacements/maquette/explore.py [dossier] # page Explore : View,
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
./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 view/view.py [data/<STATION> --du D --au F] # les images IRON : parcourir, zoomer
python3 .claude/skills/events-learner/benchmark.py # détecteurs face à la base d'events
pdftotext -layout "docs/aimsight/<fichier>.pdf" - # lire un PDF AIMsight
python3 -m venv .venv && .venv/bin/pip install plotly matplotlib # recréer .venv
@@ -70,13 +73,13 @@ python3 -m venv .venv && .venv/bin/pip install plotly matplotlib # recréer .
### 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`).
- `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.
- Ne pas lire : `docs/superpowers/` (historique, sauf le plan vivant et la spec du support), `out/`, `.venv/`, `graphify-out/`.
### 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` (125 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/`
@@ -100,6 +103,8 @@ 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 `<STATION>.jsonl`, versionné.
- `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 `<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`.
- `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).
+9 -7
View File
@@ -34,13 +34,13 @@ def formulaire(station="", du="", au=""):
<button>Analyse</button></form>"""
def accueil():
"""Le formulaire seul, dans out/data-loader.html -> son chemin."""
chemin = ROOT / "out" / "data-loader.html"
def accueil(titre="Status", nom="data-loader"):
"""Le formulaire seul, dans out/<nom>.html -> son chemin."""
chemin = ROOT / "out" / f"{nom}.html"
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>
<h2>Status</h2>{formulaire()}</body></html>""", encoding="utf-8")
<h2>{titre}</h2>{formulaire()}</body></html>""", encoding="utf-8")
return chemin
@@ -50,6 +50,8 @@ def ouvrir(chemin):
class Chargeur(_Pages):
SCRIPT = STATUS # le script que lance « Analyse » ; labeling/labeling.py a le sien
def do_GET(self):
url = urlsplit(self.path)
if url.path != "/analyse":
@@ -58,11 +60,11 @@ class Chargeur(_Pages):
station = q.get("station")
if station not in stations(): # le nom devient un chemin : une station de data/, rien d'autre
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)]
r = subprocess.run(args, capture_output=True, text=True)
if r.returncode:
return self.send_error(500, "status.py failed", r.stderr[-3000:])
return self.send_error(500, f"{Path(self.SCRIPT).name} failed", r.stderr[-3000:])
page = Path(r.stdout.strip().splitlines()[-1]).relative_to(ROOT)
self.send_response(303)
self.send_header("Location", "/" + quote(page.as_posix()))
+12 -8
View File
@@ -248,19 +248,23 @@ gd.on('plotly_click', ev => {
"""
def camera(dossier, mesures, a, b, chemin):
"""Les images de la caméra sur [a, b) ({t, src, e}, src relatif à la page chemin, e l'error_value des capteurs) et la
position médiane de chaque capteur dans l'image ({} si x, y n'y sont pas des positions)."""
vues = [(t, im) for im in donnees.trouver(dossier)["images"] if (t := donnees.heure_image(im)) and a <= t < b]
images = [{"t": score.iso(t).replace("T", " ").rstrip("Z"), "src": quote(Path(os.path.relpath(im, os.path.dirname(chemin))).as_posix())}
for t, im in vues]
def positions(mesures, a, b):
"""La position médiane de chaque capteur dans l'image sur [a, b) ({} si x, y n'y sont pas des positions)."""
maisons = {s: (statistics.median(xs), statistics.median(ys)) for s, ms in mesures.items()
if (xs := [m["x"] for m in ms if a <= m["t"] < b and m["x"] is not None])
and (ys := [m["y"] for m in ms if a <= m["t"] < b and m["y"] is not None])}
# x, y ne sont des positions dans l'image que loin du coin : sur LENZSPITZE, des écarts de moins d'un pixel ;
# alors le timelapse montre l'image entière, sans marque (l'utilisateur, 2026-10-27 : des timelapses minuscules)
if not any(abs(x) > MARGE_PX or abs(y) > MARGE_PX for x, y in maisons.values()):
maisons = {}
return maisons if any(abs(x) > MARGE_PX or abs(y) > MARGE_PX for x, y in maisons.values()) else {}
def camera(dossier, mesures, a, b, chemin):
"""Les images de la caméra sur [a, b) ({t, src, e}, src relatif à la page chemin, e l'error_value des capteurs) et la
position médiane de chaque capteur dans l'image (positions())."""
vues = [(t, im) for im in donnees.trouver(dossier)["images"] if (t := donnees.heure_image(im)) and a <= t < b]
images = [{"t": score.iso(t).replace("T", " ").rstrip("Z"), "src": quote(Path(os.path.relpath(im, os.path.dirname(chemin))).as_posix())}
for t, im in vues]
maisons = positions(mesures, a, b)
# e : l'error_value de chaque capteur entouré à l'heure de l'image, celle de la mesure la plus proche à moins d'un
# demi-pas (les mesures ont quelques secondes de retard sur l'heure de l'image) ; la couleur de son cercle
tous = sorted({m["t"] for ms in mesures.values() for m in ms if a <= m["t"] < b})
+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.
- **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.
## 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, 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/<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 (point 69 du plan : `/labels-learner` proposé). Une étiquette n'entre dans `events/` que par `/new-event` ou l'`event-builder`.
@@ -124,6 +124,8 @@ Types : **Comprendre** (lire, expliquer, rien ne change), **Décider** (l'utilis
| 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 |
| 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 | idée du 2026-10-30 ; l'utilisateur étiquette d'abord, articulation ouverte |
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).
@@ -1396,6 +1398,8 @@ Retour de l'utilisateur du 2026-10-29 (vocal), après des exemples des détecteu
5. Les détecteurs : des séances de `/events-learner` sur des lots qui montrent ces causes ; les catégories nouvelles dans `categories.py` et la hiérarchie des status (D-095).
6. Les détails de détection (65) se font quand on veut, sans attendre.
**Les étiquettes de l'expert (2026-10-30).** Elles s'ajoutent à ce déroulé, à ses étapes 1 et 3 : une source de savoir et de cas (points 68 et 69). Leur place exacte reste à décider, après les premières étiquettes.
**L'état des pipelines** (l'utilisateur, 2026-10-29). Certains sont prêts à être lancés : il en a refait quelques-uns, les analystes et les boucles d'apprentissage sont prêts ; il a deux ou trois choses à faire en parallèle, et avance progressivement avec ce plan.
**Question.** Ce déroulé, et par où commencer : les effets thermiques (58, puis 59), recommandé, puisque toutes les stations ont déjà une température ?
@@ -1457,6 +1461,8 @@ Les cas se croisent : une caméra posée sur un pont a deux ouvrages, celui qui
**À revoir (2026-10-29).** `/events-learner` a maintenant un `tool-builder`, et l'analyste écrit ses propres scripts (D-097, autre conversation) : les températures peuvent arriver par là plutôt que par `/aiguiser`.
**Constat (Claude, 2026-10-30).** NADELHORN et LENZSPITZE n'ont aucune valeur de `sensor_*_deg_c` (fichiers vides, 5 et 12 jours) : leur seule température est `temperature_deg_c`. « Toutes les stations » et « la seule commune », ci-dessus, sont à corriger.
### Point 60 : Des cas thermiques construits et validés
**L'idée** (l'utilisateur, 2026-10-29). Construire des cas concrets de chacun des trois effets, dans leurs différentes circonstances (caméra sur un pont, ouvrage seul, les deux), les documenter et qu'il les valide : l'analyste les apprend par la base d'events.
@@ -1553,6 +1559,102 @@ 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.
- [ ] 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, que le monitoring montre.
**Ajout de l'utilisateur (2026-10-30).** Les métriques système au menu, « System: … » : celles qui ont des valeurs numériques sur la plage. Les identifiants (`SIM_CCID`, `ip`, `ip_*`) ne sont pas lus : `SIM_CCID` a souvent l'air d'un nombre, il serait tracé. Les métriques texte (`link`, `mode`, `last_sync`…) n'ont pas de courbe.
**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 (point 69).
### Point 69 : Apprendre des étiquettes de l'expert : `/labels-learner`
**L'idée** (l'utilisateur, 2026-10-30). Les étiquettes ne valent que si elles servent : un processus, sans doute un skill, qui les montre à l'analyste pour qu'il apprenne. On n'est pas en apprentissage automatique : apprendre, ici, c'est de la documentation. Avec les étiquettes et le savoir métier, l'analyste comprend ce que l'expert étiquette, en conclut quelque chose et le documente. Plutôt l'analyste qu'un nouvel agent : c'est lui qui sait lire les données, et les mécanismes lui manquent (point 67). Question ouverte de l'utilisateur : comment tirer le maximum de ces étiquettes.
**Avis de Claude (2026-10-30).**
- L'analyste, oui, pas de nouvel agent. Une limite : il propose, il n'écrit pas dans ses propres documents. « Seul ce que l'expert a validé ou corrigé doit lui apprendre » (point 51) ; « le mécanisme ne change que sur la parole de l'utilisateur » (point 67).
- Pas de document nouveau : la carte pour les signatures et les faux amis (D-087 : une compilation à part est écartée), la chaîne de mesure pour le mécanisme (point 67), `lire-les-donnees` pour la méthode. Les étiquettes restent brutes dans `labeling/` : l'analyste ne les relit pas en séance, il lit ce qu'elles ont apporté (point 67 : ne pas l'alourdir).
- Le texte d'une étiquette n'est que le début. Ce qu'on peut en tirer de plus :
1. **L'écart** : ce que l'analyste aurait dit seul, face à ce que dit l'expert. C'est ce qu'il y a à apprendre.
2. **La signature mesurée** : l'expert dit « référence cachée » ; l'analyste retrouve dans les données quelles colonnes bougent, de combien, dans quel ordre, ce qui rend le savoir utilisable sur une autre station, puis par les détecteurs.
3. **Les questions à l'expert** : ce que l'analyste ne retrouve pas dans les données, ou ce qu'il y voit d'autre, revient à l'expert ; la réponse dit souvent ce que l'étiquette tenait pour acquis.
4. **Les comparaisons** : plusieurs étiquettes d'un même phénomène disent ce qui est général ; deux courbes semblables aux causes différentes donnent un faux ami.
5. **Les hypothèses à trancher** : les [H] de `chaine-de-mesure.md` peuvent devenir [U] ou [D].
**Proposition (Claude), à approuver.** Un skill `/labels-learner <STATION>`, sur les étiquettes que l'utilisateur désigne ; rendus dans `labeling/lecons/<date>_<STATION>/`, versionnés.
1. **Lecture à l'aveugle** : l'analyste lit, par `analyser-lot`, la plage de l'étiquette et sa marge, sans l'étiquette ; des étiquettes voisines, une seule lecture.
2. **Confrontation** : il reçoit l'étiquette et la chaîne de mesure ; pour chacune : déjà vu et bien dit, vu mais autre cause, pas vu, ou introuvable dans les données ; il retourne aux données pour la signature mesurée.
3. **Propositions** : des changements en termes généraux à la carte, à la chaîne de mesure, à `lire-les-donnees`, chacun avec sa source (l'étiquette citée, [U], [D] ou [H]), plus les questions à l'expert. Vu sur un seul cas ou une seule station : reste [H] (« pas de règle spécifique à un site »).
4. **Validation** : l'orchestrateur les présente une à une à l'utilisateur, comme `/review-event` ; rien n'entre dans les documents sans sa parole.
**Pourquoi la lecture à l'aveugle** (proposée, pas imposée). Après avoir lu la réponse, tout paraît évident : l'analyste dirait que la carte suffit, comme pour le brouillard de JUNGFRAU rangé en `cible_masquee` (point 62), et chercherait dans les données ce que dit l'étiquette (le risque nommé par D-088). Sans elle, le processus coûte moins et garde la signature et les questions, mais ne montre plus l'écart. Ce n'est pas une mesure de ses progrès, écartée par l'utilisateur (D-088).
**Limites.**
- Coût : environ 250 000 jetons pour une lecture d'un lot de 4 jours (D-059, chiffre ancien) ; une plage courte devrait coûter moins, à constater au premier essai, sur 3 à 5 étiquettes.
- Aucune étiquette n'existe encore : le skill s'écrit à l'aveugle et se corrigera sur les premières.
- La chaîne de mesure n'est pas encore lue par l'analyste : le point 67 (relecture, et son ajout à ce qu'il lit) doit suivre, sinon ce savoir ne l'atteint pas.
**Pistes à revoir.** Déduire des catégories de toutes les étiquettes (l'utilisateur, point 68) ; une étiquette marquante vers `/new-event` ; les détecteurs, ensuite, par `/events-learner` (l'ordre du point 57).
**Où on en est (l'utilisateur, 2026-10-30).** D'abord quelques étiquettes. La façon d'articuler le tout reste ouverte : `/labels-learner` n'est ni approuvé ni construit, la proposition ci-dessus attend de vraies étiquettes.
**Les pièces à articuler (Claude, 2026-10-30).**
| Pièce | Ce qu'elle apporte | Où | État |
|---|---|---|---|
| Étiquettes de l'expert | des cas bruts, en langage naturel | `labeling/` (point 68) | outil prêt, aucune étiquette |
| Savoirs dits par l'expert | effets thermiques, heat haze, occultation, causes des sauts | points 58, 61, 62, 64 | notés au plan, à valider |
| Chaîne de mesure | le mécanisme, le pourquoi | `docs/displacement/domaine/chaine-de-mesure.md` (point 67) | brouillon à relire, pas lu par l'analyste |
| Carte des événements | les signatures, les catégories, les faux amis | `events/carte-des-evenements.md` (D-087) | lue par l'analyste ; apprend de chaque event validé |
| Base d'events | des cas documentés et validés | `events/` | par `/new-event`, `/review-event`, `event-builder` |
| Analyste | lit tout cela et étiquette les lots | `analyser-lot` | sa lecture est la vérité de `/events-learner` |
| Détecteurs | le calcul, sans LLM | `detectors/`, par `/events-learner` | après l'analyste (point 57) |
**Le chemin envisagé, à confirmer.** Étiquettes → l'analyste les confronte aux données → ses propositions → la validation de l'utilisateur → chaîne de mesure et carte → l'analyste les lit → ses lectures de lots s'améliorent → `/events-learner` → les détecteurs. Dans le déroulé du point 57, les étiquettes entrent aux étapes 1 (le savoir) et 3 (les cas).
**Les questions, après les premières étiquettes.**
1. Par quoi le processus se lance : étiquette par étiquette, par station, ou par phénomène ?
2. La lecture à l'aveugle, ou non ?
3. Les cas des points 60, 62 et 64 : désignés par des étiquettes, puis `/new-event`, à la place de la recherche de périodes par Claude ?
4. La chaîne de mesure (point 67) : la relire avant, ou à la lumière des étiquettes ?
5. Une étiquette peut-elle un jour juger les détecteurs ? Pas aujourd'hui (D-098) : pas de catégorie, et un instant sans étiquette ne veut pas dire « rien vu ».
**À regarder sur ces étiquettes.** Disent-elles la cause, ou ce qu'on voit ? Comment l'expert l'a su ? Quels plots ? Quelles stations ? Ce qui a gêné dans l'outil.
- [ ] L'utilisateur réalise quelques étiquettes (`run.md`, « Étiqueter des données »).
- [ ] Les regarder ensemble ; répondre aux questions ci-dessus, décider le processus.
- [ ] S'il est retenu : le skill, et ce que l'agent `analyste` doit pouvoir faire de plus (la confrontation, hors `analyser-lot`).
- [ ] Le premier essai, sur 3 à 5 étiquettes réelles ; corriger le skill.
---
## Annexe A — Les rapports des agents du 2026-10-23, résumés
@@ -1734,3 +1836,9 @@ 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 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-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.
- 2026-10-30 : point 69 ajouté (idée de l'utilisateur : un processus pour que l'analyste apprenne des étiquettes) : avis de Claude, l'analyste propose, l'utilisateur valide, pas de document nouveau ; `/labels-learner` proposé, à approuver.
- 2026-10-30 : point 69, l'utilisateur : d'abord quelques étiquettes, l'articulation reste ouverte ; les pièces, le chemin envisagé et cinq questions notés ; rien de construit.
- 2026-10-30 : point 68, demande de l'utilisateur : les métriques système au menu de `labeling.py`, sans les identifiants ; essayées sur cinq stations. Point 59 : `sensor_*_deg_c` vides sur NADELHORN et LENZSPITZE.
+8
View File
@@ -0,0 +1,8 @@
{"debut": "2026-10-11T18:05Z", "fin": "2026-10-12T07:33Z", "description": "Les targets sont placées sur un pont et les références pas. On voit clairement que les références bougent assez peu à l'opposé des targets qui bougent beaucoup. Ici il s'agit de la contraction du pont. Comme il s'agit d'un grand ouvrage il prend tu temps à refroidir. Pour des raisons qui lui sont propres, le pont monte en refroidissant. A la nuit tombée, le pont commence à refroidir et donc bouge. A la levée du jour, le phénomène s'inverse. La temporalité du phénomène est longue car le pont est grand, il prend du temps à refroidir. L'erreur reste très stable sur l'ensemble de l'événement, ce qui laisse suggérer que c'est une mauvais compensation de la caméra. Il en va de même pour l'erreur de reprojection, elle augmente un peu mais ce n'est pas significatif. Pour ce qui est des mouvements de la caméra, on voit des comportements similaire avec une temporalité proche de celle du pont. Comme cette dernière est fixée vers le pont il se peut qu'elle bouge avec ce dernier. Il faut cependant garder à l'esprit que la caméra peut bouger par les effets thermiques à un rythme différent du pont et ceci en raison de temps nécessaire pour le refroidissement. Dans ce cas précis, les temporalités sont similaires."}
{"debut": "2026-10-13T07:14Z", "fin": "2026-10-13T18:27Z", "description": "Effet thermique dû au réchauffement du pont la journée. Dès le lever du soleil, dès que la température augmente. Le phénomène n'est pas super clair quand on regarde les métriques de température des composants de la caméra mais il peut que ce soit juste une forte différence de temporalité entre les deux. Que les composants chauffent vite alors que le pont prend beaucoup de temps à chauffer. Quoi qu'il en soit, on voit clairement un mouvement de l'ouvrage mal compensé par la caméra et donc un creu dans corr_y sur toute la plage. Ici c'est du au réchauffement du pont durant la journée. Les références, elles ne sont pas sur le pont et donc ne subissent pas le mouvement. On voit que les références restent très stable en position mais aussi en erreur value. Rien de significatif avec l'erreur de reproj donc on peut en conclure que le pont bouge, et c'est normal pour un ouvrage de ce genre. Finalement, la caméra bouge aussi, mais plus vite que le pont. C'est surement dû au fait que le support de la caméra chauffe plus vite que le pont et donc que le mouvement se fait plus rapidement. Cette différence de temporalité est peut-être la cause de la mauvaise compensation de la caméra."}
{"debut": "2026-10-14T23:02Z", "fin": "2026-10-15T08:18Z", "description": "Ici on voit clairement des sauts dans corr_x et corr_y avec un retour à la normale ensuite. La tendance haussière est due aux effets thermiques sur le pont. Pour comprendre ce qui s'est passé ici il faut regarder les les error value. On voit que les error value des target sont assez élevées mais pas beaucoup plus que la normale donc pas de changement drastique. En passant, une erreur value haute pour une cible n'est pas un problème en soit, ce sont les variations qui peuvent poser problème. Ceci étant dit, on voit par contre clairement que l'erreur value de REF_d et REF_G montent soudainement. Et l'erreur de reprojection confirme notre observation. Etant donné que les positions des targets sont basées sur le réseau de référence, avec un haut error value sur les référence alors les cibles ne sont plus bien ancrées. Et on le voit encore plus fortement sur l'erreur de reprojection. Elle monte soudainement, ce qui veut dire que la caméra a du mal trouver la transformation qui se calibre sur les référence. La base visuelle est donc davantage instable et les données de déplacement de moins en moins fiable. Soudainement, l'erreur de reprojection passe à 0. Ceci est le signe que la caméra n'est plus capable d'appliquer la transformation de calibration sur les référence. La conséquence, sans réseau de référence, toutes les données de déplacement sont invalidées. C'est impossible de mesurer des mouvements. Ce qui est donc intéressant à dire ici est que les sauts observés sont dû à une perte du réseau de référence à cause d'une mauvaise visibilité de 2 référence. Et comme il ne reste plus que une référence valide, la caméra est incapable de prendre des mesures correctes"}
{"debut": "2026-10-06T05:45Z", "fin": "2026-10-06T06:15Z", "description": "Ici on voit clairement un petit jump avec retour à la normal très rapidement. On voit que c'est un jump, cependant il faut comprendre pourquoi il a eu lieu. Le diagnostic est simple : REF_G a un taux d'erreur soudainement très élevé. Sur les images on dirait qu'un camion passe devant, peut-être même qu'il était arrêté devant et a donc caché complètement la cible pendant l'acquisition. Le système perd donc une cible sur 3. Avec deux cibles restantes, la projection calculée a une erreur de 0 car il existe toujours une transformation qui marche sans erreur avec 2 références tout le temps. Cependant cette transformation est bien différente ce celle a 3 référence donc le réseau de base change et la position des cible aussi. Donc le cas est simple : Un jump a lieu car le système perd une référence par obstruction clair sur une référence. Avec seulement 2 références restantes la reporj change et donc un saut des potions se produit. Retour à la normal dès récupération de la référence perdu (juste après le passage du camion)."}
{"debut": "2026-10-07T08:36Z", "fin": "2026-10-08T15:00Z", "description": "Ce cas est assez complexe parce que on ne peut pas identifier directement quel est le problème. On y voit beaucoup de perturbations dans les données de déplacement, comme beaucoup de bruit. Sur les images on ne voit pas grand chose, c'est peut-être beaucoup de vent, c'est difficile à dire. Dans les données, tout semble à peu près normal sauf le error value. On voit clairement que l'erreur globale augmente pour la majorité des cibles. Tout se voit moins bien sur les images et cette perte de visibilité induit des mouvements supposés mais non réels de l'ouvrage. Combiné à cela, des effets thermiques qui font que c'est difficile à analyser. Finalement le diagnostic est plutôt simple ici même si on ne trouve pas de coupable direct. La visibilité est moins bonne sur toute la période."}
{"debut": "2026-10-16T14:18Z", "fin": "2026-10-19T06:18Z", "description": "Le changement de régime ici est intéressant. Précédemment on observe des clairs phases thermiques avec la dilatation et la contraction du pont. Et d'un coup beaucoup moins, ici on a une tendance haussière sur plusieurs jours. Par la suite ça semble se stabiliser donc on peut raisonnablement écarter un mouvement réel de l'ouvrage. Cependant il y a une forte corrélation avec la température. Mi-octobre la température a chuté et on le voit sur les températures des composants de la caméra. Sur la plage on voit même que la température ne fait que baisser, ce qui casse les cycles thermiques. Cependant il y a peut-être quand même du soleil donc des effets thermiques sur le pont tout de même. Dans cette plage nous pouvons observer une multitude de petite chose comme une perte de visibilité vers la fin de la plage. Cependant, le focus est sur cette tendance qui se corrèle avec la température qui baisse. De plus, les différents événements thermiques de la station montrent que l'ouvrage \"monte\" la nuit quand la température baisse. Donc le mouvement de montée prolongé observé ici est plausible et cohérent avec les effets thermiques déjà observés. Il est donc important d'utiliser la température pour comprendre les données."}
{"debut": "2026-10-26T01:56Z", "fin": "2026-10-26T06:35Z", "description": "Un saut dont la cause est la perte de REF_G. On voit sur l'erreur de reprojection qu'elle passe à 0 durant l'événement. Et c'est très mauvais signe. Une erreur de reproj de 0 signifie que le système tourne sur 2 référence seulement alors qu'il faut au moins 3 référence pour faire le travail de calibration (sorte de triangularisation)."}
{"debut": "2026-10-27T00:56Z", "fin": "2026-10-27T07:01Z", "description": "Ce cas là est intéressant. On observe un saut de 1h à 2h, suivi d'un mouvement jusqu'à 7h du matin. On voit très clairement sur l'erreur value que 2 des 3 référence monte soudainement. On a donc 2 références presque invisible. Mais l'erreur de reprojection est encore plus intéressante. Vers 1h du matin, elle chute brutalement à 0, indiquant qu'une référence est perdue (on ne tourne plus que sur 2, d'ou la valeur de 0). Puis à 2h du matin, on semble perdre une référence supplémentaire, donc le calcul de la reprojection ne se fait plus, d'ou le manque de valeurs. Dans cette configuration, la caméra est \"aveugle\" et toute mesure est invalidée. Si le problème persiste il faut contrôler la qualité des prismes de référence."}
+4
View File
@@ -0,0 +1,4 @@
{"debut": "2026-09-03T18:01Z", "fin": "2026-09-04T04:59Z", "description": "Sur les images on peut y voir une toile d'araignée placée devant l'objectif (à courte distance, presque au contact). On pourrait penser qu'il s'agit simplement d'une obstruction comme on en a souvent. Mais il y a une différence majeur et rare. Etant donné la proximité de l'obstacle à l'objectif, ce dernier apparaît blanc (saturation totale) comme les cibles. Par conséquent, il n'y a plus de distinction entre les cibles et la toile d'araignée. Si on regarde la cible CTR04, on voit qu'elle est clairement et totalement cachée mais aucun signal n'est déclenché. Ni error value, ni error reproj ne bouge significativement. L'obstruction passe totalement inaperçue malgré son évidence sur les images. Pour détecter ces situations il faudrait avoir accès aux métriques de qualité. Ce cas peut silencieusement donner de fausses valeurs sans pour autant le détecter par les métriques d'erreur. Comme c'est un système à 3 référence, l'obstruction la fait passer à 2 mais le système croit toujours en avoir 3. Donc la reprojection est plus simple car CTR04 est beaucoup plus large. Il ne m'est pas clair de comment c'est calculé mais ce cas spécifique me semble être une faille du système."}
{"debut": "2026-09-04T10:59Z", "fin": "2026-09-04T11:30Z", "description": "Sur un système à 3 référence comme ici, en perdre une seule invalide toutes les mesures. On voit sur l'erreur de reprojection que la valeur passe à 0, on a perdu CTR04 et le système se calibre sur les 2 restantes créant un gros shift le la base. Conclusion, tout bouge."}
{"debut": "2026-09-04T16:09Z", "fin": "2026-09-04T18:56Z", "description": "Cas simple de perte de visibilité du plusieurs cibles. On voit sur les images que c'est dû à la toile d'araignée qui bouge devant l'objectif. Cette fois-ci le réseau de référence n'est pas trop affecté. Par contre l'erreur de certaines cibles est très réduite, voir inexistante. En se penchant de plus près on y voit aussi une perturbation avec CTR04, d'oû le mouvement de pas mal de cibles. On a donc deux phénomènes combinés : Perte de quelques cibles et affectation du système de référence."}
{"debut": "2026-09-25T16:02Z", "fin": "2026-09-26T08:38Z", "description": "Dans le cas de Nordend on monitor une façade de carrière qui est peu susceptible d'avoir des mouvement thermiques. Contrairement à un pont ou tout autre ouvrage, un pan de montagne aura peu tendance à bouger par contraction et dilatation thermique car très volumineux. On peut donc exclure tout mouvement thermique de la façade. Il reste donc deux événements thermiques : les effets sur l'objectif et ceux sur le support de la caméra. Et quand on regarde les mouvements de la caméra on voit bien qu'elle bouge. A la tombée de la nuit, le pan et le tilt changent. On a donc un mouvement périodique de la caméra calcé sur les cycles jour/nuit. Ce qui est intéressant est qu'on retrouve ces mêmes cycles dans corr_x principalement, ce qui veut dire que la caméra a mal compensé ses propres mouvements. Le diagnostic de ce cas est donc le suivant : La caméra bouge par effet thermique jour/nuit et compense mal ses mouvements sur un ouvrage qui ne bouge pas. On obtient des déformations dans les courbes."}
+1
View File
@@ -0,0 +1 @@
{"debut": "2026-09-27T04:15Z", "fin": "2026-09-27T12:52Z", "description": "Il ne faut pas oublier dans dans ces plages temporelles que les heures sont en UTC et que les systèmes peuvent être aux 4 coins de la planète. En se basant sur les images, la plage sélectionnée ici correspond à une journée (lever/couché du soleil). On voit un effet thermique sur la caméra celle elle bouge. Il peut soit d'agit d'un effet sur son objectif ou sur sa fixation mais le mouvement est clair. Cependant, l'ouvrage monitoré est une route et cette dernière est peu susceptible de bouger par dilatation/contraction thermique. Quoi qu'il en soit, le système parvient à bien compenser ces phénomène. Par contre Wildstrubel souffre d'un autre phénomène thermique que sont les \"turbulences atmosphériques\" dû aux couches d'air de chaleur différentes. C'est un effet atmosphérique que l'on ne peut pas contourner, c'est physiquement impossible. Globalement bien compensé il se manifeste par des perturbations dans les error value la journée."}
+297
View File
@@ -0,0 +1,297 @@
"""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, plus les métriques système numériques de
metrics/ (« System: … », sans les identifiants) ; 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 glob
import html
import http.server
import json
import os
import re
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 common.stations import load_csv, parse_name # noqa: E402
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"
# Pas de copie des identifiants (CLAUDE.md, « data/ ») : ces fichiers ne sont pas lus ; SIM_CCID a souvent l'air d'un nombre.
IDENTIFIANT = re.compile(r"SIM_CCID$|ip(_|$)")
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: t.mode || 'lines', marker: {size: 4}, 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 metriques(dossier, a, b):
"""Les métriques système numériques de metrics/ sur [a, b) -> {nom: {t: valeur ou None}}, sans celles qui n'ont aucune valeur."""
series = {}
for p in sorted(glob.glob(os.path.join(dossier, "metrics", "*.csv"))):
n = parse_name(p)
if n and not IDENTIFIANT.match(n[1]):
try:
series.setdefault(n[1], {}).update(load_csv(p)) # à heure égale, le dernier fichier, comme load_stations
except ValueError: # une métrique texte (link, mode…) : pas de courbe
pass
dans = {m: {t: v if isinstance(v, float) else None for t, v in sorted(s.items()) if a <= t < b} for m, s in series.items()}
return {m: s for m, s in dans.items() if any(v is not None for v in s.values())}
def plots(mesures, poses, systeme, 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, « system: » et son nom pour une métrique) ; plot : titre et traces (name, t : sa clé dans T, y, line ; mode pour
les métriques, horaires : une valeur seule entre deux trous ne se verrait pas sans marqueur), 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]})
T = {"": [heure(p["t"]) for p in poses], **{s: [heure(m["t"]) for m in ms] for s, ms in dans.items()}}
for nom in sorted(systeme, key=str.lower):
s = systeme[nom]
T["system:" + nom] = [heure(t) for t in s]
out.append({"titre": "System: " + nom, "traces": [{"name": nom, "t": "system:" + nom, "mode": "lines+markers",
"y": [None if v is None else round(v, 5) for v in s.values()],
"line": {"width": 1.2, "color": detecteurs.COULEURS[0]}}]})
return T, 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], metriques(dossier, a, 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__)
+10
View File
@@ -22,6 +22,16 @@ Une plage choisie (historique, jour en échec) :
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`.
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`).
# 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.
+154
View File
@@ -0,0 +1,154 @@
"""Les images IRON d'une station (images/ du pompage). En haut, le data loader de la page Status : une autre station, d'autres
dates, et « Analyse » refait la page. Dessous, l'image, à parcourir au glisseur, par ◀ ▶ ou les flèches du clavier, et à zoomer
comme dans la maquette Explore : molette autour du pointeur, glisser pour se déplacer, double clic pour l'image entière ; le
zoom reste d'une image à l'autre. La case Labels écrit le nom de chaque capteur, à sa position médiane sur la plage : en jaune
les cibles, en bleu et cercle pointillé les références (reproj_err rempli, detecteurs.references) ; grisée si x, y ne sont pas
des positions dans l'image (LENZSPITZE, NADELHORN). Son serveur local (http://127.0.0.1:8768, lancé en tâche de fond) sert
out/ et data/, plus /analyse (ce script lancé à chaque fois, comme le data loader).
Usage : python3 view/view.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/view_<STATION>_<première image>_<dernière image>.html, ouverte)
"""
import argparse
import glob
import html
import http.server
import json
import os
import sys
from pathlib import Path
from urllib.parse import quote
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 positions des capteurs et les références de la page Status)
from detecteurs import donnees # noqa: E402
PORT = 8768 # ni celui de common.page (8765), ni celui du data loader (8766), ni celui de labeling (8767)
# Z : le zoom et le décalage, en fraction du cadre, comme la maquette Explore (explore_template.html).
PAGE_JS = """
const cadre = document.getElementById('cadre'), couche = document.getElementById('couche'), img = document.getElementById('img');
const glis = document.getElementById('glis'), heure = document.getElementById('heure');
const marques = document.getElementById('marques'), labels = document.getElementById('labels');
let V = 0, Z = {k: 1, x: 0, y: 0};
function zoom() {
Z.x = Math.min(0, Math.max(1 - Z.k, Z.x)); // l'image couvre toujours le cadre : on ne la perd pas en la glissant
Z.y = Math.min(0, Math.max(1 - Z.k, Z.y));
couche.style.transform = `translate(${Z.x * 100}%, ${Z.y * 100}%) scale(${Z.k})`;
// Les noms restent à 12 px à l'écran : les tailles des marques sont en em, et 1 px du svg vaut 1 px de l'image.
const W = img.naturalWidth, H = img.naturalHeight;
if (W) marques.style.fontSize = `${12 / (Z.k * Math.min(cadre.clientWidth / W, cadre.clientHeight / H))}px`;
}
const affiche = () => marques.style.display = labels.checked && img.naturalWidth ? '' : 'none';
labels.onchange = affiche;
addEventListener('resize', zoom);
function montre(i) {
V = Math.max(0, Math.min(IM.length - 1, i));
glis.value = V;
img.src = IM[V].src;
for (const n of [V - 1, V + 1]) if (IM[n]) new Image().src = IM[n].src; // les voisines, en cache
}
// L'heure change avec l'image, pas avant : l'image d'avant reste affichée tant que la nouvelle se charge.
img.onload = () => {
heure.textContent = `${IM[V].t} UTC (${V + 1}/${IM.length})`;
marques.setAttribute('viewBox', `0 0 ${img.naturalWidth} ${img.naturalHeight}`); // cadré comme l'image, object-fit: contain
zoom();
affiche();
};
img.onerror = () => {
img.removeAttribute('src');
heure.textContent = `${IM[V].t} UTC (${V + 1}/${IM.length}): image not readable`;
affiche();
};
glis.oninput = () => montre(+glis.value);
document.getElementById('prec').onclick = () => montre(V - 1);
document.getElementById('suiv').onclick = () => montre(V + 1);
document.addEventListener('keydown', e => {
if (e.target.closest('form') || !['ArrowLeft', 'ArrowRight'].includes(e.key)) return;
e.preventDefault(); // sinon le glisseur, s'il a le focus, avance une seconde fois
montre(V + (e.key === 'ArrowLeft' ? -1 : 1));
});
cadre.addEventListener('wheel', ev => { // zoom autour du pointeur
ev.preventDefault();
const r = cadre.getBoundingClientRect(), u = (ev.clientX - r.left) / r.width, v = (ev.clientY - r.top) / r.height;
const k = Math.min(40, Math.max(1, Z.k * Math.exp(-ev.deltaY / 500)));
Z = {k, x: u - k * (u - Z.x) / Z.k, y: v - k * (v - Z.y) / Z.k};
zoom();
}, {passive: false});
cadre.addEventListener('pointerdown', ev => { // déplacement à la souris
cadre.setPointerCapture(ev.pointerId);
const r = cadre.getBoundingClientRect(), de = {...Z, cx: ev.clientX, cy: ev.clientY};
cadre.onpointermove = e => { Z.x = de.x + (e.clientX - de.cx) / r.width; Z.y = de.y + (e.clientY - de.cy) / r.height; zoom(); };
cadre.onpointerup = () => cadre.onpointermove = null;
});
cadre.addEventListener('dblclick', () => { Z = {k: 1, x: 0, y: 0}; zoom(); });
montre(0);
"""
def page(dossier, du=None, au=None):
a, b = donnees.instant(du or "0001-01-01"), donnees.instant(au or "9999-01-01")
vues = [(t, im) for im in sorted(glob.glob(os.path.join(dossier, "images", "*")))
if (t := donnees.heure_image(im)) and a <= t < b]
if not vues:
raise SystemExit(f"Aucune image dans {dossier} du {du} au {au}.")
mesures = donnees.charger(dossier)
maisons, refs = detecteurs.positions(mesures, a, b), detecteurs.references(mesures, a, b)
marques = "".join(f"""<g class="{'ref' if s in refs else 'cible'}"><circle cx="{x:.1f}" cy="{y:.1f}" r=".7em"/>"""
f"""<text x="{x:.1f}" y="{y:.1f}" dy="-1em">{html.escape(s)}</text></g>""" for s, (x, y) in sorted(maisons.items()))
station = os.path.basename(os.path.normpath(dossier))
nom = f"{station}_{donnees.iso(vues[0][0])[:10]}_{donnees.iso(vues[-1][0])[:10]}"
chemin = chargeur.ROOT / "out" / f"view_{nom}.html"
chemin.parent.mkdir(exist_ok=True)
images = [{"t": donnees.iso(t).replace("T", " ").rstrip("Z"), "src": quote(Path(os.path.relpath(im, chemin.parent)).as_posix())}
for t, im in vues]
js = json.dumps(images, separators=(",", ":")).replace("</", "<\\/")
chemin.write_text(f"""<!doctype html><html lang="en"><head><meta charset="utf-8"><title>View {html.escape(nom)}</title>
<style>body{{font-family:system-ui,sans-serif;margin:16px;background:#fff;color:#1a1a19}}
#cadre{{position:relative;height:calc(100vh - 190px);min-height:300px;background:#000;overflow:hidden;cursor:grab;touch-action:none}}
#cadre:active{{cursor:grabbing}}
#couche{{position:absolute;inset:0;transform-origin:0 0}} #couche>*{{position:absolute;inset:0;width:100%;height:100%}}
#img{{object-fit:contain;user-select:none}}
#marques{{overflow:visible;pointer-events:none;font-family:sans-serif}}
#marques circle{{fill:none;stroke:currentColor;stroke-width:.12em}} #marques .ref circle{{stroke-dasharray:.3em .2em}}
#marques text{{fill:currentColor;text-anchor:middle;paint-order:stroke;stroke:rgba(0,0,0,.85);stroke-width:.25em;stroke-linejoin:round}}
.cible{{color:#ffd400}} .ref{{color:#3cc8ff}} #legende{{background:#000;padding:2px 8px;border-radius:3px;white-space:nowrap}}
#nav{{display:flex;flex-wrap:wrap;gap:8px;align-items:center;margin-top:8px}} #glis{{flex:1;min-width:200px}}
#heure{{font-variant-numeric:tabular-nums}} #aide{{color:#6b6b66;font-size:13px;margin:4px 0 0}}</style></head><body>
<h2>View, {html.escape(station)}</h2>
{chargeur.formulaire(station, du or "", au or "")}
<div id="cadre"><div id="couche"><img id="img" alt="" draggable="false"><svg id="marques" style="display:none">{marques}</svg></div></div>
<div id="nav"><button id="prec">◀</button><input id="glis" type="range" min="0" max="{len(images) - 1}" value="0"><button id="suiv">▶</button>
<span id="heure"></span><label><input type="checkbox" id="labels"{" disabled" * (not maisons)}> Labels</label>
{'<span id="legende"><span class="cible">○ Target</span> &nbsp;<span class="ref">◌ Reference</span></span>' if maisons else '<span style="color:#6b6b66">x, y are not image positions at this station</span>'}</div>
<p id="aide">← → image · wheel: zoom · drag: pan · double-click: whole image</p>
<script>const IM = {js};
{PAGE_JS}</script>
</body></html>""", encoding="utf-8")
return chemin
class Serveur(chargeur.Chargeur):
SCRIPT = __file__
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("View", "view-loader")
print(chemin)
if not o.sans_ouvrir:
chargeur.open_served(chemin, PORT, __file__)
@@ -135,3 +135,5 @@ 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.
- 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.
- Idée de l'utilisateur (2026-10-30) : un processus pour que l'analyste apprenne de ces étiquettes, apprendre étant ici de la documentation. Proposition de Claude au point 69 du plan : `/labels-learner`, l'analyste propose, l'utilisateur valide.