Loop renamed events-learner; end benchmark on the same events; spec reduced to the why (D-092)

- /boucle becomes /events-learner: skill and scripts in
  .claude/skills/events-learner/, sessions in events-learner/, spec
  vues-deplacements/contexte/events-learner.md, end page
  out/events-learner_<session>.html, commits "Learn <STATION> ...";
  history keeps /boucle, the review page reads both.
- No benchmark-fin.txt: the end benchmark is the last kept
  modification's, on the same events as the start.
- The spec keeps only the why; the how lives in the skill and agents.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
maximeandClaude Opus 5.5 committed 2026-10-29 10:27:05 +01:00
1 parent 79d83be3ff
commit 3b732adc52
169 files changed
+231 -288

No files matched your search

+101
View File
@@ -0,0 +1,101 @@
---
name: events-learner
description: Séance automatique d'amélioration des détecteurs du journal du matin et de la base d'events, sur un lot d'une station, la plage choisie par l'utilisateur (D-057) — analyste, detectors-critic, detectors-upgrader, detectors-control, event-builder. Lancé par l'utilisateur seulement, avec /events-learner.
disable-model-invocation: true
argument-hint: "data/<STATION> [--du AAAA-MM-JJ] [--au AAAA-MM-JJ] [--ameliorer]"
---
# events-learner : la boucle automatique
Tu es l'orchestrateur. Tu appelles les cinq agents dans l'ordre, tu transmets leurs rendus et tu commites ; en fin de séance, le releveur note leurs difficultés. **Tu ne juges rien toi-même** : tu lis seulement les lignes de verdict. **Tu ne poses aucune question à l'utilisateur** : la séance tourne seule jusqu'au bout. Spec : `vues-deplacements/contexte/events-learner.md`.
## 1. Mise en place
- Arguments : le dossier de station ; un nom de station seul (« Nordend ») désigne `data/<NOM EN MAJUSCULES>/` (D-065) ; `--du`, `--au` (jours UTC, facultatifs : sans eux, toute la période ; **`--au` est exclu** : la plage s'arrête à `--au` 00:00Z, `--du 2026-09-01 --au 2026-09-05` fait 4 jours) ; `--ameliorer` (facultatif : en fin de séance, l'améliorateur corrige le processus d'après les relevés du releveur, §6, D-071). **La plage est le lot** (D-072) : une séance traite un seul lot, de la longueur que l'utilisateur a choisie par `--du` / `--au`, sans découpe ; un `--lot` ou `--tranche` donné quand même est ignoré (note-le sous « Erreurs »). Des dates écrites autrement (« 2026-09.01 », deux dates sans option) se lisent comme `--du` puis `--au` ; une option entre crochets (`[--ameliorer]`, la syntaxe d'usage recopiée) vaut l'option sans crochets ; écris dans le bilan, sous « Erreurs », comment tu as lu un argument qui n'était pas net.
- `python3 agent-tools/inventaire.py <dossier>` : dossier absent ou sans export « advanced », dis-le et arrête-toi.
- `STATION` = le nom du dossier de station (`NORDEND`) ; `SEANCE` = `date -u +%Y-%m-%dT%H%MZ`.
- La séance se commite directement sur `master` (D-070) : `git branch --show-current` doit dire `master`, sinon dis-le et arrête-toi (pas de `git switch` : une autre session peut travailler dans ce dépôt). Note la **base de la séance** : `git rev-parse HEAD`. Les fichiers modifiés de l'utilisateur restent sans être commités : tu commites toujours par chemin. Une autre session peut travailler dans le même dépôt pendant la séance (fichiers modifiés, index déjà chargé, même ce skill) : `git commit -- <chemins>` ne prend que tes chemins ; n'indexe rien d'autre, jamais de `git add -A`, `git stash` ni `git checkout` hors de tes chemins ; garde les consignes lues au début et note le changement dans tes difficultés. Le commit par chemin ne protège pas un fichier que tu commites toi-même : note donc, au début, les fichiers déjà modifiés sur les chemins que la séance commite ou fait tourner, `git status --porcelain -- detectors/ vues-deplacements/contexte/seuils-du-journal.md agent-diagnostic/ .claude/skills/anonymize-event/registre.csv` ; s'il y en a, liste-les au bilan sous « Erreurs » (les mesures tournent sur eux), ne les commite pas et ne les annule pas : aux étapes 3 et 4 (`annuler`), donne tes chemins fichier par fichier, sans eux (`git diff --name-only <base du lot> HEAD -- <chemins>` liste ceux de la séance).
- Dossier de séance : `events-learner/<SEANCE>_<STATION>/`, ci-dessous `<séance>`.
## 2. Le lot
Un seul lot, numéroté `01` (`NN` ci-dessous) : de `--du` 00:00Z (sinon le premier jour de la « Période des mesures » de l'inventaire, 00:00Z) à `--au` 00:00Z (sinon la fin de cette période). Une date qui déborde cette période y est ramenée (`--du` au premier jour de la période, `--au` au lendemain de son dernier jour), dans les bornes du lot comme dans sa commande, et dite sous « Erreurs » du bilan : hors de la période, il n'y a rien à lire ni à étiqueter. Dossier du lot : `<séance>/lot-01/`, ci-dessous `<lot>`.
**Commande du lot**, donnée telle quelle aux agents : `python3 detectors/categories.py <dossier>`, plus `--du` et `--au` s'ils sont donnés. Exemple : `--du 2026-10-05 --au 2026-10-09`.
## 3. Le lot, dans l'ordre
Chaque agent est appelé par l'outil Agent avec son `subagent_type` et la demande ci-dessous, rien d'autre. Un verdict se lit par `grep '^\*\*Verdict\*\* :' <rendu>`. Chaque commit se fait par chemin, `git add <chemins> && git commit -m "<message>" -- <chemins>`, après `git branch --show-current` : une autre session peut changer de branche pendant la séance ; si ce n'est plus `master`, ne commite plus rien (pas de `git switch`), passe au bilan, écrit sans commit, et note la branche trouvée sous « Erreurs ». Son message se termine par une ligne vide puis `Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>`.
1. **Analyste** (`analyste`) : `Dossier : <dossier>. Lot NN : <début> → <fin> (UTC). Commande du lot : <commande>. Écris <lot>/analyse.md.`
`python3 .claude/skills/analyser-lot/etiquettes.py <dossier> <lot>/etiquettes.json` : sa dernière ligne va au bilan (colonne Étiquettes : « n moments », « absentes » ou « n défauts ») ; tu ne corriges rien et ne relances pas l'analyste pour elles (D-061).
`python3 .claude/skills/events-learner/score.py <dossier> > <lot>/score-avant.txt 2>&1` : le score des détecteurs du début du lot sur toutes les étiquettes de la station, ce lot compris (D-062).
`python3 .claude/skills/events-learner/benchmark.py --seance <SEANCE> --etape "lot-NN avant" > <lot>/benchmark-avant.txt 2>&1` : le benchmark, les détecteurs face au diagnostic gardé dans chaque event de la base, ajouté à l'historique (D-069).
Commit `<lot>/ vues-deplacements/benchmark/historique.csv`, message `Learn <STATION> lot NN: analysis`.
2. **Detectors-critic** (`detectors-critic`), qui juge les détecteurs face à l'analyse, sans regarder les données (D-090) : `Dossier : <dossier>. Lot NN : <début> → <fin> (UTC). Commande du lot : <commande>. Analyse : <lot>/analyse.md. Score avant : <lot>/score-avant.txt. Écris <lot>/critique.md.`
Commit `<lot>/`, message `Learn <STATION> lot NN: critique (<verdict>)`.
Verdict `d'accord` : va à l'étape 5.
3. **Detectors-upgrader** (`detectors-upgrader`), passage K = 1, 2 ou 3. Avant le passage 1, note la **base du lot** : `git rev-parse HEAD`.
`Dossier : <dossier>. Lot NN : <début> → <fin> (UTC). Commande du lot : <commande>. Critique : <lot>/critique.md. Score avant : <lot>/score-avant.txt. Benchmark avant : <lot>/benchmark-avant.txt. [Contrôle précédent : <lot>/validation-(K-1).md.] Passage K. Écris <lot>/modification-K.md.`
Commit `detectors/ vues-deplacements/contexte/seuils-du-journal.md <lot>/`, message `Learn <STATION> lot NN: modification K`.
Puis, les détecteurs commités : `python3 .claude/skills/events-learner/benchmark.py --seance <SEANCE> --etape "lot-NN modification K" > <lot>/benchmark-K.txt 2>&1` (commité avec la validation).
4. **Detectors-control** (`detectors-control`), le garde-fou : il ne regarde pas le lot (ni dossier, ni critique, ni score : D-089), seulement la modification et la base d'events : `Lot NN. Modification : <lot>/modification-K.md. Benchmark : <lot>/benchmark-avant.txt → <lot>/benchmark-K.txt. Base : <base du lot>. Passage K sur 3. Écris <lot>/validation-K.md.`
Commit `<lot>/ vues-deplacements/benchmark/historique.csv`, message `Learn <STATION> lot NN: control K (<verdict>)`.
- `accepté` ou `garder` : va à l'étape 5.
- `à reprendre` : retour à l'étape 3, passage K + 1.
- `annuler` : `git checkout <base du lot> -- detectors/ vues-deplacements/contexte/seuils-du-journal.md`, commit de ces deux chemins, message `Learn <STATION> lot NN: modification annulée`.
5. **Event-builder** (`event-builder`), à chaque lot : il décide seul, face à la base d'events, ce que l'analyse lui apprend de nouveau (D-091) : `Dossier : <dossier>. Lot NN : <début> → <fin> (UTC). Analyse : <lot>/analyse.md. Dossier du lot : <lot>/. Séance : <séance>/. Écris <lot>/builder.md.`
Si sa ligne `**Events créés** :` n'est pas `aucun` : commit `events/ .claude/skills/anonymize-event/registre.csv <lot>/`, message `Learn <STATION> lot NN: events E-xxx, …` ; sinon commit `<lot>/`, message `Learn <STATION> lot NN: event-builder (aucun event)`.
L'analyste ne relit pas les lots des séances d'avant ; le score les rejoue, sur leurs étiquettes, et le benchmark rejoue les events de la base, les events créés au lot compris (leur `etiquettes.json`).
## 4. Imprévus
Un rendu absent après son agent, ou sans ligne de verdict lisible : note-le pour le bilan ; si les détecteurs ont changé depuis la base du lot, remets-les comme pour `annuler` ; passe au bilan. Ne relance pas un agent plus d'une fois.
## 5. Bilan
`python3 .claude/skills/events-learner/score.py <dossier> > <séance>/score-fin.txt 2>&1` : le score des détecteurs de fin de séance sur toutes les étiquettes de la station.
Pas de benchmark de fin de séance : celui des détecteurs de fin est le dernier du lot, sur les mêmes events que celui du début ; les events créés par l'event-builder se mesurent à la séance suivante (D-092).
`<séance>/bilan.md` :
```markdown
# Séance <SEANCE> : <STATION>, <début> → <fin> (UTC)
Commits : sur `master`, depuis <base de la séance> (`git log --oneline <base de la séance>..HEAD`)
Score : au début du lot `lot-01/score-avant.txt`, en fin de séance `score-fin.txt` (D-062).
Benchmark sur la base d'events (D-069) : au début du lot `lot-01/benchmark-avant.txt`, après chaque modification `lot-01/benchmark-K.txt` ; historique `vues-deplacements/benchmark/historique.csv`. Total, sur les mêmes events : <ligne `total` de la catégorie `toutes` de `benchmark-avant.txt`, colonnes alignées : `grep -E '^total +toutes'`> → <celle du benchmark de la modification gardée (`benchmark-K.txt`), ou « inchangé » si aucune n'est gardée>.
Page : `out/events-learner_<SEANCE>_<STATION>.html`, l'analyste face aux détecteurs sur toute la plage (D-066) ; la refaire : `python3 .claude/skills/events-learner/comparaison.py <dossier> <séance>`.
| Lot | Dates (UTC) | Critique | Étiquettes | Modification | Events créés |
|---|---|---|---|---|---|
| 01 | … → … | d'accord / suggestions (n) | n moments / absentes / n défauts | aucune / gardée (K passages) / annulée / erreur | E-xxx / aucun |
## Suggestions non traitées
<« Pas corrigé » des modifications ; suggestions d'un lot sans modification gardée>
## Contradictions avec la base
<lignes « contredit » du rendu de l'event-builder>
## Erreurs
aucune | <lot, agent, ce qui manquait>
```
Commit `<séance>/bilan.md <séance>/score-fin.txt`, message `Learn <STATION>: bilan`.
## 6. Difficultés
**Releveur** (`releveur`), une fois, même si tout s'est bien passé : `Processus : /events-learner (.claude/skills/events-learner/SKILL.md). Séance : <séance>/ : la section « Difficultés » de chaque rendu des lots, et « Erreurs » du bilan. Difficultés de l'orchestrateur : aucune | <une consigne de ce skill qui t'a fait deviner, une commande qui a échoué…>.` (D-060)
Si `git status --short docs/ameliorations-processus.md` montre un changement : commit de ce chemin, message `Learn <STATION>: process difficulties`.
**Améliorateur** (`ameliorateur`), seulement avec `--ameliorer` et si le releveur a commité : `Processus : /events-learner. Commit du releveur : <commit>.`, le commit pris par `git rev-parse HEAD` juste après celui du releveur (D-071). Puis commit des chemins qu'il a pu toucher, `.claude/skills/events-learner/ .claude/skills/analyser-lot/ .claude/agents/analyste.md .claude/agents/detectors-critic.md .claude/agents/detectors-upgrader.md .claude/agents/detectors-control.md .claude/agents/event-builder.md .claude/agents/releveur.md .claude/agents/ameliorateur.md vues-deplacements/contexte/events-learner.md run.md docs/ameliorations-processus.md`, seulement ceux que `git status --short` montre changés, message `Learn <STATION>: process fixes`. Garde la suite de ce skill telle que tu l'as lue au début.
## 7. Réponse finale
`python3 .claude/skills/events-learner/comparaison.py <dossier> <séance>` : la page de fin de séance, `out/events-learner_<SEANCE>_<STATION>.html`, qui s'ouvre dans le navigateur (D-066). C'est la page de `python3 .claude/skills/events-learner/detecteurs.py <dossier> --du <début> --au <fin>` sur la plage de la séance (images de la caméra et timelapse d'un événement au clic, pose de la caméra, `corr_x` et `corr_y` de chaque capteur, ligne « Error rate »), chaque ligne de catégorie dédoublée : la lecture de l'analyste (ses étiquettes) au-dessus des événements des détecteurs tels qu'ils sont en fin de séance, et en gris ses moments hors catégorie ; sous la figure, la liste des événements, le score de la séance et le benchmark sur la base d'events. Le but, séance après séance : que les deux coïncident. Un échec du script va dans la réponse, sans relance.
En 8 lignes au plus : la page, la base de la séance, le chemin du bilan, le benchmark (ligne `total` / `toutes`, `grep -E '^total +toutes'`, du début du lot à la modification gardée), le nombre de modifications gardées et d'events créés, le nombre d'étiquettes (`<séance>/lot-*/etiquettes.json`, à garder même si l'utilisateur annule des modifications : elles ne dépendent pas des détecteurs), les erreurs, les difficultés relevées et, avec `--ameliorer`, celles corrigées. Tout est sur `master`, rien n'est poussé : l'utilisateur annule ce qu'il ne garde pas par `git revert`.
@@ -0,0 +1,93 @@
"""Benchmark des détecteurs sur la base d'events (point 48 du plan du journal du matin, D-069).
Chaque event d'events/ qui a son etiquettes.json (le diagnostic de l'analyste, figé à la création de l'event) :
les détecteurs tels qu'ils sont, face à ces étiquettes, mesure par mesure et capteur par capteur (score.py, D-062).
Un calcul seulement, sans agent. Par event, puis au total, et par catégorie : « trouvées » (part des mesures étiquetées
que les détecteurs signalent) et « justes » (part des mesures signalées que l'analyste a étiquetées) ; « toutes »
somme les catégories (pas les deux niveaux de validité, qui les regroupent). Le benchmark garde les détecteurs
d'un recul : il n'est pas un but (sur une dizaine d'events, les détecteurs se régleraient sur eux).
Avec --etape, chaque ligne entre dans l'historique, vues-deplacements/benchmark/historique.csv, avec la version des
détecteurs (le commit, suivi de « + » si detectors/ a des changements non commités) : le score
dans le temps, version par version.
Usage : python3 .claude/skills/events-learner/benchmark.py [--seance <séance> --etape <étape>]
"""
import argparse
import contextlib
import csv
import glob
import io
import os
import subprocess
import sys
from datetime import datetime, timezone
ICI = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, ICI)
import score # noqa: E402
RACINE = os.path.normpath(os.path.join(ICI, "..", "..", ".."))
HISTORIQUE = os.path.join(RACINE, "vues-deplacements", "benchmark", "historique.csv")
TOUTES = "toutes"
def version():
def git(*a):
return subprocess.run(["git", "-C", RACINE, *a], capture_output=True, text=True).stdout.strip()
return git("rev-parse", "--short", "HEAD") + ("+" if git("status", "--porcelain", "--", "detectors") else "")
def mesurer():
"""-> ({event: {clé: [étiquetées, signalées, les deux]}}, [events sautés et pourquoi]) ; le total sous « total »."""
res, sautes = {}, []
for chemin in sorted(glob.glob(os.path.join(RACINE, "events", "E-*", "etiquettes.json"))):
event = os.path.dirname(chemin)
sortie = io.StringIO()
with contextlib.redirect_stdout(sortie):
n = score.lots(event, [chemin], True)
if "sauté" in sortie.getvalue():
sautes.append(sortie.getvalue().strip())
continue
n[TOUTES] = [sum(v[i] for k, v in n.items() if k not in score.NIVEAUX) for i in range(3)]
res[os.path.basename(event)] = n
total = {}
for n in res.values():
for k, v in n.items():
total[k] = [a + b for a, b in zip(total.get(k, [0, 0, 0]), v)]
if res:
res["total"] = total
return res, sautes
def afficher(res, sautes, ver):
print(f"Benchmark des détecteurs (version {ver}) sur {len(res) - 1 if res else 0} events, mesure par mesure")
print(f"{'event':8}{'catégorie':24}{'trouvées':>20}{'justes':>20}")
for event, n in res.items():
for i, k in enumerate([TOUTES, *sorted(k for k in n if k != TOUTES)]):
lab, sig, both = n[k]
print(f"{event if i == 0 else '':8}{k:24}{score.pct(both, lab):>20}{score.pct(both, sig):>20}")
for s in sautes:
print(s)
def historiser(res, ver, seance, etape):
os.makedirs(os.path.dirname(HISTORIQUE), exist_ok=True)
neuf = not os.path.exists(HISTORIQUE)
date = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%MZ")
with open(HISTORIQUE, "a", newline="", encoding="utf-8") as f:
w = csv.writer(f)
if neuf:
w.writerow(("date", "seance", "etape", "version", "event", "categorie", "etiquetees", "signalees", "les_deux"))
w.writerows((date, seance, etape, ver, event, k, *v) for event, n in res.items() for k, v in sorted(n.items()))
if __name__ == "__main__":
p = argparse.ArgumentParser(usage=__doc__)
p.add_argument("--seance", default="—")
p.add_argument("--etape", help="écrit les lignes dans l'historique sous cette étape (« lot-01 avant »…)")
a = p.parse_args()
res, sautes = mesurer()
ver = version()
afficher(res, sautes, ver)
if a.etape:
historiser(res, ver, a.seance, a.etape)
print(f"historique : {os.path.relpath(HISTORIQUE, RACINE)}")
@@ -0,0 +1,138 @@
"""Page de fin de séance de /events-learner : la lecture de l'analyste face aux détecteurs, sur toute la plage de la séance.
La page de detecteurs.py (images de la caméra, timelapse d'un événement au clic, pose de la caméra, corr_x et corr_y de
chaque capteur en couleur, ligne « Error rate »), chaque ligne de catégorie dédoublée : en haut les moments de l'analyste
(etiquettes.json des lots de la séance), en bas les événements des détecteurs tels qu'ils sont (la plage classée avec ses
3 jours d'historique, comme le score). En dernier, en gris, les moments « aucune » de l'analyste : vus, mais hors des
catégories du journal (sans effet sur les courbes le plus souvent, ou une nouveauté). Sous la figure, la liste des
événements des détecteurs, le score de la séance (score.py sur ses seules étiquettes) et le benchmark. Faire coïncider
les deux barres de chaque ligne, séance après séance, c'est le but de la boucle.
Usage : python3 .claude/skills/events-learner/comparaison.py <dossier de station> <dossier de séance>
(page : out/events-learner_<séance>.html, ouverte dans le navigateur)
"""
import contextlib
import glob
import html
import io
import json
import os
import statistics
import sys
import textwrap
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "..", "src"))
from common.page import ROOT, open_served # noqa: E402 (bascule seule sur .venv si plotly manque)
import plotly.graph_objects as go # noqa: E402
from plotly.subplots import make_subplots # noqa: E402
import score # noqa: E402 (détecteurs, chargement et score ; met detectors/ et les outils sur le chemin)
import benchmark # noqa: E402 (les détecteurs face aux events de la base, D-069)
AGENT, SCRIPTS = "#2a78d6", "#eb6834" # palette catégorielle de référence, slots 1 et 2 (skill dataviz)
HORS, GRIS = "hors catégorie", "#a3a29c" # moments « aucune » de l'analyste : aucun détecteur ne peut les rejoindre
# du vert au rouge (demande de l'utilisateur, 2026-10-27) : couleurs d'état de la palette de référence (skill dataviz)
VERT_ROUGE = ["#0ca30c", "#fab219", "#ec835a", "#d03b3b"]
def taux_erreur(mesures, a, b):
"""Ligne « Error rate » : à chaque instant de [a, b), l'error_value moyenne de tous les capteurs, du vert au rouge sur
une échelle fixe de 0 à 1, avec sa barre de couleur. Dans sa propre rangée : une heatmap sur les axes des barres fait
planter plotly.js 4.1.1."""
par_t = {}
for ms in mesures.values():
for m in ms:
if a <= m["t"] < b and m["error_value"] is not None:
par_t.setdefault(m["t"], []).append((m["error_value"], m["error_threshold"]))
erreurs = sorted(par_t.items())
return go.Heatmap(
x=[t for t, _ in erreurs], y=["Error rate"], z=[[statistics.mean(e for e, _ in v) for _, v in erreurs]],
text=[[f"{len(v)} capteurs, {sum(1 for e, th in v if th is not None and e > th)} rejetés" for _, v in erreurs]],
zmin=0, zmax=1, colorscale=[[i / (len(VERT_ROUGE) - 1), c] for i, c in enumerate(VERT_ROUGE)],
colorbar={"title": {"text": "Error rate", "side": "right"}, "thickness": 12, "len": 0.3, "y": 0, "yanchor": "bottom"},
hovertemplate="%{x|%Y-%m-%d %H:%M} UTC<br>error_value moyenne : %{z:.3f}<br>%{text}<extra></extra>")
def survol(titre, debut, fin, capteurs, *lignes):
return "<br>".join([f"<b>{titre}</b>", f"{debut} → {fin}", f"capteurs : {', '.join(capteurs) or 'tous'}",
*("<br>".join(textwrap.wrap(x, 90)) for x in lignes if x)])
def barres(nom, couleur, spans, pas, rang, groupe):
"""[(début, fin, catégorie, survol)] -> barres horizontales, de la première mesure à la dernière plus un pas ; même
groupe : même place dans la ligne."""
debuts = [score.instant(s[0]) for s in spans]
return go.Bar(name=nom, orientation="h", y=[s[2] for s in spans], base=debuts, marker_color=couleur, legendrank=rang,
offsetgroup=groupe,
x=[(score.instant(s[1]) + pas - d).total_seconds() * 1000 for s, d in zip(spans, debuts)],
hovertext=[s[3] for s in spans], hoverinfo="text")
NIVEAUX = {"à ignorer": "Toutes les zones à ignorer", "prudence": "Toutes les zones à lire avec prudence"}
def tableau(total, ordre, titre="Catégorie"):
"""{clé: [mesures de l'analyste, des détecteurs, des deux]} (score.lots) -> table HTML : les catégories, puis les
deux niveaux de validité."""
def part(a, b):
return f"{round(100 * a / b)} %<small> ({a} sur {b})</small>" if b else "—"
cles = [*(c for c in ordre if c in total), *sorted(set(total) - set(ordre) - set(NIVEAUX)), *(k for k in NIVEAUX if k in total)]
lignes = "".join(f"<tr{' class=niveau' if k in NIVEAUX else ''}><td>{NIVEAUX.get(k, k)}</td><td>{total[k][0]}</td>"
f"<td>{total[k][1]}</td><td>{part(total[k][2], total[k][0])}</td><td>{part(total[k][2], total[k][1])}</td></tr>"
for k in cles)
return (f"<table><tr><th>{titre}</th><th>Vues par l'analyste</th><th>Signalées par les détecteurs</th>"
"<th>Trouvées</th><th>Confirmées</th></tr>" + lignes + "</table>")
def page(dossier, seance):
"""La page de detecteurs.py sur la plage de la séance (images, timelapse, pose de la caméra, capteurs en couleur),
plus les moments de l'analyste, le score de la séance et le benchmark."""
import detecteurs # ici : detecteurs importe ce module
chemins = sorted(glob.glob(os.path.join(seance, "lot-*", "etiquettes.json")))
if not chemins:
sys.exit(f"{seance} : aucun lot-*/etiquettes.json")
lots = []
for c in chemins:
with open(c, encoding="utf-8") as f:
lots.append(json.load(f))
debut, fin = min(x["debut"] for x in lots), max(x["fin"] for x in lots)
agent = [(m["debut"], m["fin"], c := HORS if m["categorie"] == "aucune" else m["categorie"],
survol(f"Analyste : {c}", m["debut"], m["fin"], m["capteurs"],
f"{m['evenement'] or '—'} ({m['preuve']})", m["description"]))
for x in lots for m in x["moments"]]
with contextlib.redirect_stdout(io.StringIO()): # le détail par lot : lot-NN/score-avant.txt et score-fin.txt
total = score.lots(dossier, chemins, True)
events, _ = benchmark.mesurer()
bench = {c: n[benchmark.TOUTES] for c, n in events.items()}
ordre = [*score.categories.CATEGORIES, HORS]
nom = os.path.basename(os.path.normpath(seance))
entete = f"""<h1>Séance {html.escape(nom)}</h1>
<p>Dessous les courbes, chaque ligne est une catégorie du journal : la barre du haut est la lecture de l'analyste
(étiquettes des {len(lots)} lot(s) de la séance), celle du bas, les événements des détecteurs dans leur état de fin de
séance. En dernier, en gris, ce que l'analyste a vu hors des catégories du journal : sans effet sur les courbes le plus
souvent, ou une nouveauté ; aucun détecteur ne peut le rejoindre. Survol : capteurs, preuve, description ; un clic sur une
barre, de l'analyste ou des détecteurs, joue son timelapse. Le but de la boucle : que les deux barres de chaque ligne coïncident.</p>"""
annexe = f"""<style>td small{{color:#8a8984}} tr.niveau td{{color:#5f5e5a;font-style:italic}}</style>
<h3>Score de la séance</h3>
<p>On compte des mesures : une mesure, c'est un capteur à un instant.
<b>Trouvées</b> : de ce que l'analyste range dans la catégorie, la part que les détecteurs signalent aussi ; le reste, ils
l'ont raté. <b>Confirmées</b> : de ce que signalent les détecteurs, la part que l'analyste range aussi dans la catégorie ;
le reste, ce sont des alertes en trop, ou un oubli de l'analyste. Le but : 100 % dans les deux colonnes ; « — » : rien à
compter. Les moments hors catégorie ne comptent pas, ni les trous (pas de mesure). En italique, les catégories regroupées comme sur la page du client : zones grisées, et zones
de prudence (visibilité réduite, turbulence).</p>
{tableau(total, ordre)}
<h3>Benchmark sur la base d'events</h3>
<p>Les mêmes détecteurs, face au diagnostic gardé dans chaque event de la base à sa création (ses étiquettes), toutes
catégories ensemble. Il garde les détecteurs d'un recul ; il n'est pas un but. Le détail par catégorie :
<code>python3 .claude/skills/events-learner/benchmark.py</code> ; dans le temps : <code>{os.path.relpath(benchmark.HISTORIQUE, ROOT)}</code>
(version {benchmark.version()}).</p>
{tableau(bench, list(bench), "Event")}"""
return detecteurs.page(dossier, debut, fin, entete=entete, annexe=annexe, analyste=agent,
chemin=os.path.join(ROOT, "out", f"events-learner_{nom}.html"))
if __name__ == "__main__":
if len(sys.argv) != 3:
sys.exit(__doc__)
p = page(sys.argv[1], sys.argv[2])
print(p)
open_served(p)
+481
View File
@@ -0,0 +1,481 @@
"""Les détecteurs du journal seuls, sur une plage d'un dossier de station : la page de comparaison.py sans l'analyste.
En tête, les images de la caméra sur la plage (glisseur, flèches du clavier ; un clic sur la figure va à l'image la plus
proche, une ligne verticale la marque sur la figure). Un clic sur la barre d'un événement des détecteurs, comme sur un bloc
du Status, zoome la plage sur lui, ne garde que ses capteurs sur les courbes (la légende rend les autres) et montre sous la
figure ses détails et le timelapse des images de l'événement, recadré sur ses capteurs (Focused image) ou entier (Global image), avec une marge avant et après (comme ▶ Images de la
maquette Explore). ⤓ GIF le télécharge tel qu'il est montré (la page est servie par
http://127.0.0.1 : en file://, le navigateur ne lit pas les pixels des images). En haut de la figure, la pose de la caméra (pan, tilt, rotation [deg],
camera/ du pompage, si le dossier en a), puis corr_x et corr_y de chaque capteur (px, une couleur par capteur, les références
en pointillé ; la légende cache un capteur dans les deux) ; dessous, la ligne « Status » (ce qui se passe : bleu clair, rien ;
bleu foncé, un bloc d'événements nommé par celui qui l'englobe, sans À vérifier ni Dérive lente), puis, dépliée au départ
(un clic sur « ▾ Status » la replie ; un clic sur un bloc zoome la plage sur lui et montre ses détails sous la figure,
le timelapse de ses images à droite, ses capteurs entourés), une ligne par catégorie (toutes, même sans événement), les événements des détecteurs dans
leur état actuel (la plage classée avec ses 3 jours d'historique, comme un lot de /events-learner), et la ligne « Error rate » :
à chaque instant, l'error_value moyenne de tous les capteurs (du vert au rouge, échelle fixe de 0 à 1) ; en bas, la liste des
événements et leur phrase. Ne modifie rien et n'écrit dans aucun historique.
Usage : python3 .claude/skills/events-learner/detecteurs.py <dossier de station> [--du AAAA-MM-JJ] [--au AAAA-MM-JJ]
(--au exclu ; sans dates, toute la période du dossier ; page : out/detecteurs_<STATION>_<du>_<au>.html, ouverte)
"""
import argparse
import html
import itertools
import json
import os
import statistics
from collections import Counter
from pathlib import Path
from urllib.parse import quote
import comparaison # noqa: E402 (met src/, detectors/ et les outils sur le chemin ; barres, survol, couleurs)
from comparaison import ROOT, go, make_subplots, score
from common.page import open_served
import donnees # noqa: E402
MARGE_PX = 150 # marge autour des capteurs, recadrage du timelapse (comme MARGIN_PX de la maquette Explore)
COULEURS = ["#2a78d6", "#eb6834", "#1baf7a", "#8a5cd6", "#d6a12a", "#d63b8a", "#3bb3d6", "#6b6b66"] # un capteur chacun
POSE = (("pan", "#1a1a19"), ("tilt", "#8a8a85"), ("rotation", "#b5651d")) # sombres : à part des couleurs des capteurs
# Ligne Status (point 50 du plan) : ce qui se passe, en un mot (l'utilisateur, 2026-10-27) : bleu clair, aucun événement ;
# bleu foncé, un bloc d'événements qui se touchent, nommé par la catégorie qui l'englobe. « À vérifier » et « Dérive lente »
# n'y entrent pas : un mouvement possible a ses lignes.
STATUT_HORS = {"a_verifier", "derive_lente"}
CALME, EVENEMENT = "#d3e4f5", "#1f4e8c"
ESPACE = 30 # px entre deux lignes de la figure : le titre de la suivante y tient
HEURES = 30 # px de plus sous une courbe : ses heures (l'utilisateur, 2026-10-27 : l'heure sous chaque courbe, pas seulement en bas)
# Le glisseur des images et la ligne verticale de la figure (shapes[0]) ; un clic sur la figure va à l'image la plus proche.
IMAGES_JS = """
const IM = __IMAGES__, ms = s => Date.parse(s.replace(' ', 'T') + (/[Z+]/.test(s.slice(10)) ? '' : 'Z'));
const glis = document.getElementById('glis'), img = document.getElementById('img'), heure = document.getElementById('heure');
const montre = i => {
i = Math.max(0, Math.min(IM.length - 1, i)); glis.value = i;
img.src = IM[i].src; heure.textContent = IM[i].t + ' UTC (' + (i + 1) + '/' + IM.length + ')';
Plotly.relayout(gd, {'shapes[0].x0': IM[i].t, 'shapes[0].x1': IM[i].t});
};
glis.oninput = () => montre(+glis.value);
document.getElementById('prec').onclick = () => montre(+glis.value - 1);
document.getElementById('suiv').onclick = () => montre(+glis.value + 1);
document.addEventListener('keydown', e => {
if (!gv.hidden) { // le timelapse ouvert : ses touches
if (e.key === 'Escape') ferme(); else if (e.key === ' ') { e.preventDefault(); joue(!G.joue); }
else if (e.key === 'ArrowLeft' || e.key === 'ArrowRight') { joue(false); image(G.k + (e.key === 'ArrowLeft' ? -1 : 1)); }
return;
}
if (e.key === 'ArrowLeft') montre(+glis.value - 1); if (e.key === 'ArrowRight') montre(+glis.value + 1);
});
// Timelapse d'un événement (clic sur sa barre) : les images de son début moins une marge à sa fin plus la marge (la moitié de la
// durée, de 1 h à 6 h), une sur n au-delà de G_MAX, G_FPS par seconde, en boucle ; bord rouge pendant l'événement.
const G_MARGE = [3600e3, 6 * 3600e3], G_FPS = 4, G_MAX = 150, MARGE = __MARGE__; // à régler à l'œil (comme la maquette Explore)
// Les capteurs de l'événement entourés sur les images, à leur position médiane sur la plage : cibles en jaune, références
// en bleu (l'utilisateur, 2026-10-27) ; aucune marque si x, y ne sont pas des positions dans l'image (POS vide).
const POS = __POS__, REFS = __REFS__;
const gv = document.getElementById('gif'), gc = gv.querySelector('canvas'), gi = document.getElementById('gif-info');
const ROLE = {avant: 'avant', pendant: 'PENDANT', apres: 'après'};
let G = {f: [], imgs: [], k: 0, run: 0, joue: false, titre: '', capteurs: []};
// Focused image : recadrée sur les capteurs de l'événement (tous, s'il n'en nomme aucun), MARGE autour ; Global image :
// l'image entière (l'utilisateur, 2026-10-27). Sans position des capteurs, l'image entière seule.
const zoom = document.getElementById('gif-z');
zoom.hidden = !Object.keys(POS).length;
zoom.onchange = () => { zoom.blur(); image(G.k); };
function cadre(im) {
const s = G.capteurs.length ? G.capteurs : Object.keys(POS);
if (zoom.value === 'global' || !s.length) return {x: [0, im.naturalWidth], y: [0, im.naturalHeight]};
const b = i => [Math.min(...s.map(c => POS[c][i])) - MARGE, Math.max(...s.map(c => POS[c][i])) + MARGE];
return {x: b(0), y: b(1)};
}
function image(k) {
G.k = (k + G.f.length) % G.f.length;
const f = G.f[G.k], im = G.imgs[G.k];
return im.decode().catch(() => {}).then(() => {
if (!im.naturalWidth) return;
const v = cadre(im);
const x0 = Math.max(0, v.x[0]), y0 = Math.max(0, v.y[0]);
const w = Math.min(im.naturalWidth, v.x[1]) - x0, h = Math.min(im.naturalHeight, v.y[1]) - y0;
gc.width = w; gc.height = h; // le recadrage agrandi à la fenêtre (un zoom), l'image entière à sa taille au plus
gc.style.width = zoom.value === 'global' ? '' : Math.min(innerWidth * 0.85, innerHeight * 0.75 * w / h) + 'px';
const ctx = gc.getContext('2d'), r = Math.max(10, w / 90);
ctx.drawImage(im, x0, y0, w, h, 0, 0, w, h);
ctx.lineWidth = Math.max(2, w / 500); ctx.font = `${Math.round(r * 1.3)}px sans-serif`;
for (const s of G.capteurs) {
ctx.strokeStyle = ctx.fillStyle = REFS.includes(s) ? '#3bb3d6' : '#ffc000';
ctx.beginPath(); ctx.arc(POS[s][0] - x0, POS[s][1] - y0, r, 0, 2 * Math.PI); ctx.stroke();
ctx.fillText(s, POS[s][0] - x0 + r * 1.2, POS[s][1] - y0 - r * 0.6);
}
gc.style.outlineColor = f.role === 'pendant' ? '#d03b3b' : 'transparent';
gi.textContent = `${G.titre} · ${f.t} UTC · ${ROLE[f.role]} · ${G.k + 1} / ${G.f.length}`;
});
}
function joue(on) {
G.joue = on;
const moi = ++G.run;
document.getElementById('gif-p').textContent = on ? '❚❚' : '▶';
const pas = () => { if (moi === G.run) image(G.k + 1).then(() => setTimeout(pas, 1000 / G_FPS)); };
if (on) setTimeout(pas, 1000 / G_FPS);
}
// ici : où jouer le timelapse (les images de Details) ; sans lui, par-dessus la page. Le lecteur (canvas, boutons,
// légende) passe de l'un à l'autre ; ✕ le range dans la fenêtre fermée.
const lecteur = gv.firstElementChild;
function gif([debut, fin, titre, capteurs], ici) {
const a = ms(debut), b = ms(fin), m = Math.min(G_MARGE[1], Math.max(G_MARGE[0], (b - a) / 2));
const ims = IM.filter(im => ms(im.t) >= a - m && ms(im.t) <= b + m), n = Math.ceil(ims.length / G_MAX);
G.f = ims.filter((_, k) => k % n === 0).map(im => ({...im, role: ms(im.t) < a ? 'avant' : ms(im.t) > b ? 'apres' : 'pendant'}));
G.titre = titre;
G.capteurs = (capteurs || []).filter(s => s in POS);
if (!G.f.length) return ici ? ici.replaceChildren('Pas d’image de la caméra pour ce bloc.') : alert('Pas d’image de la caméra pour cet événement.');
G.imgs = G.f.map(f => Object.assign(new Image(), {src: f.src})); // chargées d'avance
if (ici) ici.replaceChildren(lecteur); else { gv.append(lecteur); gv.hidden = false; }
image(0).then(() => joue(true));
}
function ferme() { joue(false); gv.hidden = true; gv.append(lecteur); }
gv.onclick = e => { if (e.target === gv) ferme(); };
document.getElementById('gif-x').onclick = ferme;
document.getElementById('gif-p').onclick = () => joue(!G.joue);
document.getElementById('gif-av').onclick = () => { joue(false); image(G.k - 1); };
document.getElementById('gif-ap').onclick = () => { joue(false); image(G.k + 1); };
// ⤓ GIF : le timelapse tel qu'il est montré (Focused ou Global), réduit à GIF_PX de large, sans bord rouge, date et heure
// en bas à droite (l'utilisateur, 2026-10-28), dans les téléchargements du navigateur (l'utilisateur, 2026-10-27). En file://, le navigateur interdit de lire
// les pixels des images : la page est servie par http://127.0.0.1 (open_served).
const GIF_PX = 1000, exp = document.getElementById('gif-e');
exp.onclick = exporte;
async function exporte() {
joue(false); exp.disabled = true;
const k0 = G.k;
try {
const {GIFEncoder, quantize, applyPalette} = await import('https://cdn.jsdelivr.net/npm/gifenc@1.0.3/dist/gifenc.esm.js');
const enc = GIFEncoder(), ex = document.createElement('canvas');
for (let k = 0; k < G.f.length; k++) {
exp.textContent = `⤓ ${k + 1}/${G.f.length}`;
await image(k);
const s = Math.min(1, GIF_PX / gc.width), w = ex.width = Math.round(gc.width * s), h = ex.height = Math.round(gc.height * s);
const c = ex.getContext('2d', {willReadFrequently: true}), t = Math.max(14, Math.round(w / 40));
c.drawImage(gc, 0, 0, w, h);
c.font = `${t}px sans-serif`;
const l = c.measureText(G.f[k].t + ' UTC').width + t;
c.fillStyle = 'rgba(0,0,0,.6)'; c.fillRect(w - l, h - t * 1.5, l, t * 1.5);
c.fillStyle = '#fff'; c.fillText(G.f[k].t + ' UTC', w - l + t / 2, h - t * 0.45);
const px = c.getImageData(0, 0, w, h).data, pal = quantize(px, 256);
enc.writeFrame(applyPalette(px, pal), w, h, {palette: pal, delay: 1000 / G_FPS});
}
enc.finish();
const nom = `${document.title.replace('Détecteurs ', '')}_${G.titre}_${G.f[0].t}`.replace(/[^A-Za-z0-9_.-]+/g, '_') + '.gif';
Object.assign(document.createElement('a'), {href: URL.createObjectURL(new Blob([enc.bytes()], {type: 'image/gif'})), download: nom}).click();
} catch (e) {
alert('Export GIF impossible : ' + (e.name === 'SecurityError' ? 'en file://, le navigateur ne lit pas les images ; ouvrir la page par son script (http://127.0.0.1).' : e.message));
} finally {
exp.disabled = false; exp.textContent = '⤓ GIF'; image(k0);
}
}
gd.on('plotly_click', ev => {
const p = ev.points[0];
if (p.customdata) return; // un bloc du Status ou une barre : zoom et détails (DEROULEUR_JS)
const x = ms(String(p.x));
let best = 0;
IM.forEach((m, i) => { if (Math.abs(ms(m.t) - x) < Math.abs(ms(IM[best].t) - x)) best = i; });
montre(best);
});
montre(0);
"""
# Le clic sur la barre d'un événement des détecteurs garde ses seuls capteurs sur les courbes (aucun capteur : tous),
# les autres cachés dans la légende, qui les rend.
CAPTEURS_JS = """
function capteurs(s) {
const k = gd.data.flatMap((t, i) => t.legendgroup ? [i] : []);
Plotly.restyle(gd, {visible: k.map(i => !s.length || s.includes(gd.data[i].legendgroup) ? true : 'legendonly')}, k);
}
"""
# Le dérouleur (l'utilisateur, 2026-10-27) : un clic sur « ▾ Status » replie ou déplie la ligne des catégories, dépliée au départ.
DEROULEUR_JS = """
const DISPO = __DISPO__, CACHEES = __CACHEES__; // [repliée, dépliée] ; les traces de la ligne des catégories
let deplie = true;
gd.on('plotly_clickannotation', ev => {
if (ev.index !== __INDEX__) return;
deplie = !deplie;
Plotly.update(gd, {visible: deplie}, DISPO[+deplie], CACHEES);
});
// Un clic sur un bloc du Status (l'utilisateur, 2026-10-27), ou sur une barre d'événement (2026-10-28), zoome la plage sur
// lui et montre ses détails sous la figure, à gauche, et le timelapse de ses images, marge avant et après comprise, à
// droite ; la barre d'un événement des détecteurs ne garde aussi que ses capteurs sur les courbes.
// customdata : [début, fin, nom, détails HTML, capteurs (null : barre de l'analyste)].
gd.on('plotly_click', ev => {
const p = ev.points[0];
if (!p.customdata) return;
const [debut, fin, nom, corps, cs] = p.customdata;
if (p.data.name !== 'Status' && cs) capteurs(cs);
Plotly.relayout(gd, {'xaxis.range': [debut, fin]});
document.getElementById('details').innerHTML = `<p><b>${nom}</b> : ${debut} → ${fin} UTC</p>` + corps;
if (typeof gif === 'function') gif([debut, fin, nom, cs], document.getElementById('det-images'));
});
"""
def disposition(hauteurs, cachee, ouvert, heures=()):
"""Hauteurs des lignes de la figure en px, de haut en bas ; cachee : l'index de la ligne qui se replie ; heures : les
lignes qui ont leurs heures dessous (HEURES de plus) -> relayout Plotly : hauteur de la figure et domaine de chaque
ordonnée (repliée : ordonnée cachée, sur un domaine minuscule, Plotly refusant un domaine nul)."""
vues = [i for i in range(len(hauteurs)) if ouvert or i != cachee]
ecart = {i: ESPACE + HEURES * (i in heures) for i in vues}
p = sum(hauteurs[i] for i in vues) + sum(ecart[i] for i in vues[:-1])
d = {"height": p + 80, f"yaxis{cachee + 1}.domain": [0, 0.001], f"yaxis{cachee + 1}.visible": ouvert} # 80 : marges t et b
haut = p
for i in vues:
d[f"yaxis{i + 1 if i else ''}.domain"] = [max(0.0, (haut - hauteurs[i]) / p), haut / p]
haut -= hauteurs[i] + ecart[i]
return d
def plotly_t(iso):
"""« 2026-09-25T12:00Z » -> « 2026-09-25 12:00 » : Plotly ne lit pas le Z (le zoom du clic sur une barre)."""
return iso.replace("T", " ").rstrip("Z")
def tableau(evts):
"""Événements -> table HTML : début, fin, catégorie, capteurs, phrase."""
return ("<table><tr><th>Début</th><th>Fin</th><th>Catégorie</th><th>Capteurs</th><th>Phrase</th></tr>"
+ "".join(f"<tr><td>{v['start']}</td><td>{v['end']}</td><td>{html.escape(v['label'])}</td>"
f"<td>{html.escape(', '.join(v['sensors']) or 'tous')}</td><td>{html.escape(v['text'])}</td></tr>"
for v in evts) + "</table>")
def references(mesures, a, b):
"""Capteurs de la compensation sur la plage : ceux qui ont un reproj_err (docs/domaine/colonnes-des-deplacements.md :
références seulement), quel que soit pattern_type, vide sur LENZSPITZE et « target » sur des capteurs de CLARIDEN
qui compensent pourtant (l'utilisateur, 2026-10-28 : retrouver les groupes par les données)."""
return {s for s, ms in mesures.items() if any(m["reproj_err"] is not None for m in ms if a <= m["t"] < b)}
def groupes(mesures, refs, debut, fin, capteurs):
"""Détail d'un événement ou d'un bloc (debut, fin inclus ; capteurs vides : tous) : References puis Targets, chacun avec
ses capteurs de l'événement, puis les autres repliés ; par capteur, sur l'événement : mesures rejetées, error_value
maximale face au seuil, amplitude de corr_x et corr_y, et pour une référence reproj_err médian et part des inlier."""
dans = set(capteurs) or set(mesures)
f = lambda v, n=2: "–" if v is None else f"{v:.{n}f}"
def ligne(s):
ms = donnees.filtrer(mesures[s], debut, fin) # fin à la minute près, comme les événements la donnent
val = lambda c: [m[c] for m in ms if m[c] is not None]
amp = lambda c: max(val(c)) - min(val(c)) if val(c) else None
ev, seuil, rp, inl = val("error_value"), val("error_threshold"), val("reproj_err"), val("inlier")
rej = sum(donnees.rejetee(m) for m in ms)
return (f"<tr><td>{html.escape(s)}</td><td>{rej} / {len(ms)}</td><td>{f(max(ev) if ev else None)} / {f(statistics.median(seuil) if seuil else None, 1)}</td>"
f"<td>{f(amp('corr_x'))}</td><td>{f(amp('corr_y'))}</td>"
+ (f"<td>{f(statistics.median(rp) if rp else None, 3)}</td><td>{f(statistics.mean(x == 1 for x in inl) * 100 if inl else None, 0)} %</td>"
if s in refs else "") + "</tr>"), rej, len(ms)
def table(lignes, ref):
return ("<table><tr><th>Capteur</th><th>Rejetées</th><th>error_value max / seuil</th><th>Ampl. corr_x (px)</th>"
"<th>Ampl. corr_y (px)</th>" + "<th>reproj_err méd.</th><th>Inlier</th>" * ref + "</tr>"
+ "".join(l[0] for l in lignes) + "</table>")
out = ""
for nom, ref, role in (("References", True, "Elles compensent le mouvement de la caméra (reproj_err rempli)"),
("Targets", False, "Elles mesurent l'ouvrage")):
tous = sorted(s for s in mesures if (s in refs) == ref)
touches = [ligne(s) for s in tous if s in dans]
autres = [ligne(s) for s in tous if s not in dans]
rej, n = sum(l[1] for l in touches), sum(l[2] for l in touches)
out += (f"<h4>{nom} : {len(touches)} / {len(tous)} dans l'événement</h4><p>{role}."
+ (f" Mesures rejetées des capteurs de l'événement : {rej} / {n}." if touches else "") + "</p>"
+ (table(touches, ref) if touches else "")
+ (f"<details><summary>Les {len(autres)} autres, hors de l'événement</summary>{table(autres, ref)}</details>" if autres else ""))
return out
def statut(evts, temps, pas, mesures, refs):
"""Ligne Status : la plage en blocs (les trous de toutes les cibles comblés au pas comptent comme « No data »). Un bloc
d'événements porte le nom de la catégorie qui en couvre le plus d'instants, celle qui englobe les autres (à égalité, la
première de CATEGORIES) ; le survol dit tous ses événements et leurs capteurs, ses détails (customdata) leur table."""
cats = [c for c in score.categories.CATEGORIES if c not in STATUT_HORS]
grille = [(temps[0], True)]
for t0, t1 in zip(temps, temps[1:]):
grille += [(t0 + k * pas, False) for k in range(1, round((t1 - t0) / pas))] + [(t1, True)]
instants = [(t, [v for v in evts if v["category"] in cats and v["start"] <= score.iso(t) <= v["end"]], not mesure)
for t, mesure in grille]
blocs = [] # (début, fin, nom, couleur, survol, détails, capteurs)
for evenement, bloc in itertools.groupby(instants, key=lambda i: bool(i[1] or i[2])):
bloc = list(bloc)
debut, fin = bloc[0][0], bloc[-1][0] + pas
heures = f"{debut:%Y-%m-%d %H:%M} → {fin:%Y-%m-%d %H:%M} UTC"
if not evenement:
blocs.append((debut, fin, "", CALME, f"{heures}<br>aucun événement", "<p>Aucun événement.</p>", []))
continue
compte = Counter(c for _, actifs, trou in bloc for c in {v["category"] for v in actifs} | ({"trou"} if trou else set()))
nom = score.categories.CATEGORIES[max((c for c in cats if compte[c]), key=compte.__getitem__)]["label"]
vus = list({id(v): v for _, actifs, _ in bloc for v in actifs}.values())
sans_mesure = any(i[2] for i in bloc) and all(v["category"] != "trou" for v in vus)
cs = [] if any(not v["sensors"] for v in vus) else list(dict.fromkeys(c for v in vus for c in v["sensors"]))
lignes = [f"{v['label']} : {', '.join(v['sensors']) if 0 < len(v['sensors']) <= 4 else f'{len(v['sensors'])} capteurs' if v['sensors'] else 'tous'}"
for v in vus] + ["No data : aucune mesure"] * sans_mesure
blocs.append((debut, fin, nom, EVENEMENT, f"{heures}<br><b>{nom}</b><br>" + "<br>".join(lignes),
tableau(vus) + "<p>No data : aucune mesure sur une partie du bloc.</p>" * sans_mesure
+ groupes(mesures, refs, debut, fin - pas, cs), cs)) # ses capteurs (« tous » : aucun)
return go.Bar(name="Status", orientation="h", y=["Status"] * len(blocs), base=[b[0] for b in blocs],
x=[(b[1] - b[0]).total_seconds() * 1000 for b in blocs], marker_color=[b[3] for b in blocs],
text=[b[2] for b in blocs], textposition="inside", insidetextanchor="middle", textangle=0,
textfont={"color": "white"}, hovertext=[b[4] + "<br><i>clic : zoom sur le bloc, ses détails sous la figure</i>" for b in blocs],
hoverinfo="text", showlegend=False,
customdata=[[f"{b[0]:%Y-%m-%d %H:%M:%S}", f"{b[1]:%Y-%m-%d %H:%M:%S}", b[2] or "Aucun événement", b[5], b[6]] for b in blocs])
def page(dossier, du=None, au=None, entete="", annexe="", chemin=None, analyste=()):
"""entete, annexe : HTML ajouté avant et après la figure (page de /review-event) ; chemin : la page, sinon out/detecteurs_… ;
analyste : ses moments [(début, fin, catégorie, survol)], en barres au-dessus de celles des détecteurs, chaque ligne de
catégorie dédoublée (page de fin de séance de /events-learner, comparaison.py)."""
mesures = score.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 = score.instant(du) if du else tous[0]
b = score.instant(au) if au else tous[-1] + (tous[-1] - tous[-2])
temps = [t for t in tous if a <= t < b]
if len(temps) < 2:
raise SystemExit(f"Pas de mesures dans {dossier} entre {score.iso(a)} et {score.iso(b)}.")
pas = statistics.median(y - x for x, y in zip(temps, temps[1:]))
refs = references(mesures, a, b)
evts = score.evenements(mesures, score.iso(a), score.iso(b))
spans = [(v["start"], v["end"], v["category"],
comparaison.survol(v["label"], v["start"], v["end"], v["sensors"], v["text"])) for v in evts]
hors = comparaison.HORS
presentes = {v["category"] for v in evts} | {s[2] for s in analyste}
ordre = [*score.categories.CATEGORIES, *sorted(presentes - set(score.categories.CATEGORIES) - {hors}), *[hors] * (hors in presentes)]
haut = 40 if analyste else 30 # deux barres par ligne avec l'analyste
station = os.path.basename(os.path.normpath(dossier))
nom = f"{station}_{score.iso(a)[:10]}_{score.iso(b)[:10]}"
chemin = chemin or os.path.join(ROOT, "out", f"detecteurs_{nom}.html")
images = [{"t": score.iso(t).replace("T", " ").rstrip("Z"), "src": quote(Path(os.path.relpath(im, os.path.dirname(chemin))).as_posix())}
for im in donnees.trouver(dossier)["images"] if (t := donnees.heure_image(im)) and a <= t < b]
poses = [p for p in donnees.charger_camera(dossier) if a <= p["t"] < b]
c = 1 if poses else 0 # la ligne de la caméra, seulement si le dossier a des poses sur la plage
s_, k_ = 3 + c, 4 + c # les lignes du Status et des catégories, sous les courbes
hauteurs = [200] * c + [260, 260, 44, haut * len(ordre) + 20, 30]
titres = [*["Caméra : pan, tilt, rotation (deg)"] * c, "corr_x (px)", "corr_y (px)", "",
"Classification : analyste (bleu, en haut ; gris : hors catégorie), détecteurs (orange, en bas)"
if analyste else "", ""] # sans l'analyste, pas de titre aux catégories (l'utilisateur, 2026-10-27)
fig = make_subplots(rows=5 + c, cols=1, shared_xaxes=True)
for col, couleur in POSE if poses else ():
fig.add_trace(go.Scatter(x=[p["t"] for p in poses], y=[p[col] for p in poses], name=col, mode="lines",
line={"width": 1.2, "color": couleur}, hovertemplate=f"{col} : %{{y:.4f}}°<extra></extra>"), row=1, col=1)
for i, s in enumerate(sorted(mesures)): # une couleur par capteur ; la légende cache le capteur dans corr_x et corr_y à la fois
ms = [m for m in mesures[s] if a <= m["t"] < b]
ref = s in refs
for row, col in ((1 + c, "corr_x"), (2 + c, "corr_y")):
fig.add_trace(go.Scatter(x=[m["t"] for m in ms], y=[m[col] for m in ms], name=s + " (réf.)" * ref, mode="lines",
legendgroup=s, showlegend=col == "corr_x",
line={"width": 1.2, "color": COULEURS[i % len(COULEURS)], "dash": "dot" if ref else "solid"},
hovertemplate=f"{s} : %{{y:.3f}} px<extra></extra>"), row=row, col=1)
if spans:
d = comparaison.barres("Détecteurs", comparaison.SCRIPTS, spans, pas, 1, "d")
d.customdata = [[plotly_t(v["start"]), plotly_t(score.iso(score.instant(v["end"]) + pas)), v["label"],
tableau([v]) + groupes(mesures, refs, score.instant(v["start"]), score.instant(v["end"]), v["sensors"]),
v["sensors"]] for v in evts]
d.hovertext = [h + "<br><i>clic : zoom, ses capteurs seuls, ses détails" + " et son timelapse" * bool(images)
+ " sous la figure</i>" for h in d.hovertext]
fig.add_trace(d, row=k_, col=1) # en mode group, le 1er groupe en bas
for nom_a, couleur, rang, sel in (("Analyste", comparaison.AGENT, 2, [s for s in analyste if s[2] != hors]),
(f"Analyste, {hors}", comparaison.GRIS, 3, [s for s in analyste if s[2] == hors])):
if sel:
t = comparaison.barres(nom_a, couleur, sel, pas, rang, "a")
t.customdata = [[plotly_t(s[0]), plotly_t(score.iso(score.instant(s[1]) + pas)), f"Analyste : {s[2]}", f"<p>{s[3]}</p>", None]
for s in sel]
t.hovertext = [h + "<br><i>clic : zoom, ses détails" + " et son timelapse" * bool(images) + " sous la figure</i>"
for h in t.hovertext]
fig.add_trace(t, row=k_, col=1)
fig.add_trace(go.Scatter(x=[a] * len(ordre), y=ordre, mode="markers", marker={"opacity": 0}, hoverinfo="skip",
showlegend=False), row=k_, col=1) # invisible : toutes les catégories ont leur ligne, même vides
fig.add_trace(statut(evts, temps, pas, mesures, refs), row=s_, col=1)
fig.add_trace(comparaison.taux_erreur(mesures, a, b), row=5 + c, col=1)
fig.update_layout(barmode="group", bargap=0.3, bargroupgap=0.1, hovermode="closest",
uniformtext={"minsize": 9, "mode": "hide"}, # le nom d'un bloc trop court pour lui : au survol seul
plot_bgcolor="white", margin={"l": 170, "r": 90, "t": 40, "b": 40},
legend={"orientation": "h", "x": 0, "y": 1.02, "yanchor": "bottom", # au-dessus : à droite, la barre de l'Error rate
"title": {"text": "clic : cacher, double clic : seul", "side": "top left"}})
for t in fig.data: # légende : la pose de la caméra et les capteurs seuls
if t.showlegend is None:
t.showlegend = t.name in dict(POSE)
fig.update_xaxes(type="date", range=[a, b], showgrid=True, gridcolor="#e6e6e2")
fig.update_yaxes(showgrid=True, gridcolor="#eeeeea", zeroline=False)
fig.update_yaxes(categoryorder="array", categoryarray=ordre[::-1], row=k_, col=1)
fig.update_yaxes(showticklabels=False, row=s_, col=1) # le dérouleur tient lieu d'étiquette
for r in range(1, 3 + c): # l'heure sous chaque courbe (pose, corr_x, corr_y), pas seulement sous la dernière ligne
fig.update_xaxes(showticklabels=True, row=r, col=1)
for r, titre in enumerate(titres, 1): # chaque titre sur le domaine de sa ligne : il la suit quand le dérouleur bouge
if titre:
fig.add_annotation(text=titre, x=0.5, y=1, xref="x domain", yref="y domain", yanchor="bottom", showarrow=False,
font={"size": 16}, row=r, col=1)
if r == k_: # le titre des catégories se replie avec elles
titre_k = f"annotations[{len(fig.layout.annotations) - 1}].visible"
fig.add_annotation(text="▾ Status", x=0, y=0.5, xref="x domain", yref="y domain", xanchor="right", xshift=-8,
showarrow=False, captureevents=True, font={"size": 13}, row=s_, col=1)
i_der = len(fig.layout.annotations) - 1
dispo = [{**disposition(hauteurs, k_ - 1, o, range(2 + c)), **({titre_k: o} if analyste else {}),
f"annotations[{i_der}].text": "▾ Status" if o else "▸ Status"} for o in (False, True)]
fig.plotly_relayout(dispo[1])
script = ("const gd = document.getElementById('{plot_id}');" + CAPTEURS_JS # ordonnée sans recalage au zoom (2026-10-27)
+ DEROULEUR_JS.replace("__DISPO__", json.dumps(dispo)).replace("__INDEX__", str(i_der))
.replace("__CACHEES__", json.dumps([i for i, t in enumerate(fig.data) if t.yaxis == f"y{k_}"])))
vue = ""
if images:
fig.add_shape(type="line", xref="x", yref="paper", x0=images[0]["t"], x1=images[0]["t"], y0=0, y1=1,
line={"color": "#d03b3b", "width": 1.5})
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 = {}
script += (IMAGES_JS.replace("__IMAGES__", json.dumps(images)).replace("__MARGE__", str(MARGE_PX))
.replace("__POS__", json.dumps(maisons)).replace("__REFS__", json.dumps(sorted(refs))))
vue = f"""<img id="img" alt="image de la caméra" style="max-width:100%;max-height:60vh;margin:8px auto;display:block">
<div style="text-align:center"><button id="prec">◀</button> <input id="glis" type="range" min="0" max="{len(images) - 1}" value="0"
style="width:min(60em,70vw);vertical-align:middle"> <button id="suiv">▶</button> <span id="heure" style="font-variant-numeric:tabular-nums"></span></div>
<div id="gif" hidden><div class="lecteur"><canvas></canvas><div><button id="gif-av">◀</button> <button id="gif-p">❚❚</button>
<button id="gif-ap">▶</button> <button id="gif-x">✕</button> <button id="gif-e" title="télécharger le timelapse en GIF">⤓ GIF</button> <select id="gif-z"><option value="focused">Focused image</option>
<option value="global">Global image</option></select> <span id="gif-info"></span></div></div></div>"""
corps = fig.to_html(include_plotlyjs="cdn", full_html=False, div_id="fig", post_script=script, config={"scrollZoom": False})
os.makedirs(os.path.dirname(chemin), exist_ok=True)
with open(chemin, "w", encoding="utf-8") as f:
f.write(f"""<!doctype html><html lang="fr"><head><meta charset="utf-8"><title>Détecteurs {html.escape(nom)}</title>
<style>body{{font-family:system-ui,sans-serif;margin:16px;background:#fff;color:#1a1a19}} p{{color:#5f5e5a;max-width:70em}}
table{{border-collapse:collapse;font-size:14px}} th,td{{padding:4px 10px;border-bottom:1px solid #e6e6e2;text-align:left;vertical-align:top}}
th{{font-weight:600;color:#3d3d3a}}
#gif{{position:fixed;inset:0;background:rgba(0,0,0,.6);display:flex;align-items:center;justify-content:center;z-index:10}} #gif[hidden]{{display:none}}
#gif>div{{background:#fff;padding:12px;border-radius:6px;max-width:94vw}} .lecteur canvas{{max-width:100%;max-height:78vh;display:block;outline:4px solid transparent;outline-offset:-4px;margin-bottom:8px}}
#gif-info{{font-variant-numeric:tabular-nums;color:#3d3d3a}}
.details{{display:grid;grid-template-columns:minmax(0,1fr) minmax(0,1fr);gap:24px;align-items:start}}</style></head><body>
{entete}
<h2>Détecteurs, {html.escape(station)} : {score.iso(a)} → {score.iso(b)} (UTC)</h2>
<p>Les détecteurs du journal tels qu'ils sont (version {comparaison.benchmark.version()}), la plage classée avec ses 3 jours d'historique.
Survol d'une barre : capteurs et phrase ;
ligne Status, sous les courbes : ce qui se passe (bleu clair : aucun événement ; bleu foncé : un bloc d'événements qui se touchent, nommé par la catégorie
qui en couvre le plus, celle qui englobe les autres ; le survol dit tous ses événements ; sans À vérifier ni Dérive lente) ; un clic sur « ▾ Status » replie ou déplie les catégories, un clic sur un bloc zoome la plage sur lui et montre ses détails sous la figure (Details : ses événements à gauche, le timelapse de ses images à droite, ses capteurs entourés, jaune les cibles, bleu les références, si x et y sont des positions dans l'image) ; ligne Error rate : error_value moyenne de tous les capteurs à chaque instant. Zoom par sélection ; la liste complète est sous la figure.
Images : glisseur ou flèches ← → ; un clic sur une courbe va à l'image la plus proche, marquée par la ligne rouge ;
un clic sur la barre d'un événement fait comme un clic sur un bloc du Status (zoom, ses détails et son timelapse sous la figure)
et, pour un événement des détecteurs, ne garde que ses capteurs sur les courbes (la légende rend les autres) ; le timelapse : marge avant et après, bord rouge pendant ; Focused image : recadré sur ses capteurs, Global image : l'image entière ; espace : pause, ← → : image par image, Échap : fermer ; ⤓ GIF : le télécharger.</p>
{vue}{corps}<h3>Details</h3>
<div class="details"><div id="details"><p>Un clic sur un bloc du Status : ses événements ici, le timelapse de ses images à droite.</p></div>
<div id="det-images"></div></div>
<h3>{len(evts)} événement(s)</h3>
{tableau(evts)}
{annexe}
</body></html>""")
return chemin
if __name__ == "__main__":
p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
p.add_argument("dossier")
p.add_argument("--du")
p.add_argument("--au")
p.add_argument("--sans-ouvrir", action="store_true", help="écrit la page sans l'ouvrir (revue de cas)")
o = p.parse_args()
chemin = page(o.dossier, o.du, o.au)
print(chemin)
if not o.sans_ouvrir:
open_served(chemin)
+158
View File
@@ -0,0 +1,158 @@
"""Score des détecteurs du journal face aux étiquettes de l'analyste (point 45 du plan du journal du matin, D-062).
Une case : une mesure d'un capteur dans un lot. Chaque case reçoit, d'un côté, les catégories des moments de l'analyste
qui la couvrent (etiquettes.json, D-061), de l'autre, celles des événements des détecteurs (categories.py, le lot classé
avec ses 3 jours d'historique, comme la commande du lot). Pour chaque catégorie, et pour les deux niveaux de validité
qui ne sont pas « fiable » :
trouvées : cases étiquetées que les détecteurs ont aussi signalées (part des étiquetées) ;
justes : cases signalées que l'analyste a aussi étiquetées (part des signalées).
Validité d'une case : la pire de ses catégories ; « à ignorer » : les zones grisées du journal (carte des événements,
section 4) ; « prudence » : visibilité réduite et turbulence ; « fiable » sinon (dilatation, contraction, à vérifier :
jamais grisées), et sans catégorie. Un trou n'a pas de mesure, donc pas de case ; un moment « aucune » n'est pas compté.
Le score est un fait, pas un verdict : l'analyste peut se tromper aussi.
Usage : python3 .claude/skills/events-learner/score.py <dossier de station> [etiquettes.json ...]
(défaut : events-learner/*/lot-*/etiquettes.json de la station)
python3 .claude/skills/events-learner/score.py --test
"""
import glob
import json
import os
import sys
from datetime import timedelta
from pathlib import Path
RACINE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "..")
sys.path.insert(0, os.path.join(RACINE, "detectors"))
sys.path.insert(0, os.path.join(RACINE, ".claude", "skills", "analyser-lot"))
import categories # noqa: E402 (il met lui-même agent-tools sur le chemin)
from donnees import charger, instant, iso # noqa: E402
from etiquettes import defauts, vocabulaire # noqa: E402
HISTORIQUE = timedelta(days=3) # comme la commande du lot (D-056)
IGNORER = {"visibilite_nulle", "passage", "cible_masquee", "cible_degradee", "saut_bref"} # zones grisées (carte, section 4)
# ponytail: la turbulence est toujours « prudence » : l'étiquette ne dit pas si elle est forte (grisée alors dans le
# journal) ; un champ de force dans les étiquettes si cet écart compte
PRUDENCE = {"visibilite_reduite", "turbulence"}
NIVEAUX = ("à ignorer", "prudence")
def validite(cats):
return "à ignorer" if cats & IGNORER else "prudence" if cats & PRUDENCE else None
def cases(mesures, debut, fin):
"""Mesures -> [(capteur, instant iso)] du lot, fin exclue."""
return [(s, t) for s, ms in mesures.items() for m in ms if debut <= (t := iso(m["t"])) < fin]
def marquer(cs, spans):
"""Cases, [(début, fin, capteurs, catégorie)] -> {case: {catégories}} ; fin incluse, capteurs vides : tous."""
out = {c: set() for c in cs}
for d, f, capteurs, cat in spans:
for s, t in cs:
if d <= t <= f and (not capteurs or s in capteurs):
out[(s, t)].add(cat)
return out
def evenements(mesures, debut, fin):
"""Événements des détecteurs qui touchent le lot, classé avec ses jours d'historique (comme la commande du lot)."""
h, b = instant(debut) - HISTORIQUE, instant(fin)
tranche = {s: k for s, ms in mesures.items() if (k := [m for m in ms if h <= m["t"] < b])}
return [v for v in (categories.evenements(tranche) if tranche else []) if v["end"] >= debut]
def detectes(mesures, debut, fin):
"""Événements des détecteurs du lot -> spans de marquer."""
return [(v["start"], v["end"], v["sensors"], v["category"]) for v in evenements(mesures, debut, fin)]
def score(etiq, det):
"""{case: catégories de l'analyste}, {case: catégories des détecteurs} -> {clé: [étiquetées, signalées, les deux]}."""
n = {}
for c in etiq:
a, d = [x | {v} if (v := validite(x)) else x for x in (etiq[c], det[c])]
for k in a | d:
x = n.setdefault(k, [0, 0, 0])
x[0], x[1], x[2] = x[0] + (k in a), x[1] + (k in d), x[2] + (k in a and k in d)
return n
def pct(a, b):
return f"{a}/{b} ({round(100 * a / b)} %)" if b else "—"
def afficher(titre, n):
print(titre)
print(f" {'':<22}{'trouvées':>20}{'justes':>20}")
for k in [*NIVEAUX, *sorted(set(n) - set(NIVEAUX))]:
if k in n:
lab, sig, both = n[k]
print(f" {k:<22}{pct(both, lab):>20}{pct(both, sig):>20}")
def lots(dossier, chemins, explicite):
station = os.path.basename(os.path.normpath(dossier))
mesures = charger(dossier)
vocab = vocabulaire()
total, vus = {}, 0
for chemin in chemins:
nom = os.path.join(*Path(chemin).resolve().parent.parts[-2:])
with open(chemin, encoding="utf-8") as f:
lot = json.load(f)
if lot.get("station") != station:
if explicite:
print(f"{nom} : station {lot.get('station')!r}, le dossier est {station!r} : sauté")
continue
if fautes := defauts(lot, station, set(mesures), *vocab):
print(f"{nom} : étiquettes à corriger ({len(fautes)} défauts, etiquettes.py) : sauté")
continue
cs = cases(mesures, lot["debut"], lot["fin"])
if not cs:
print(f"{nom} : aucune mesure du lot dans {dossier} : sauté")
continue
moments = [m for m in lot["moments"] if m["categorie"] != "aucune"]
etiq = marquer(cs, [(m["debut"], m["fin"], m["capteurs"], m["categorie"]) for m in moments])
n = score(etiq, marquer(cs, detectes(mesures, lot["debut"], lot["fin"])))
afficher(f"{nom} : {lot['debut']} → {lot['fin']}, {len(moments)} moments comptés "
f"({len(lot['moments']) - len(moments)} « aucune »), {len(cs)} cases", n)
for k, v in n.items():
total[k] = [a + b for a, b in zip(total.get(k, [0, 0, 0]), v)]
vus += 1
if vus > 1:
afficher(f"Total : {vus} lots", total)
elif not vus:
print(f"Aucun lot étiqueté de {station} à compter.")
return total # la page de fin de séance (comparaison.py) en fait son tableau
def test():
"""Lot 1 de l'essai de NORDEND (2026-10-05 → 09), les détecteurs tels qu'ils sont : leurs événements pris pour
étiquettes donnent tout juste ; une catégorie oubliée par l'analyste fait baisser « justes », une étiquette que les
détecteurs n'ont pas fait baisser « trouvées » ; la pire validité l'emporte."""
mesures = charger(os.path.join(RACINE, "vues-deplacements", "cas", "2026-10_NORDEND", "NORDEND"))
debut, fin = "2026-10-05T00:00Z", "2026-10-09T00:00Z"
cs = cases(mesures, debut, fin)
spans = detectes(mesures, debut, fin)
assert cs and spans, "aucune case ou aucun événement sur le lot de l'essai"
det = marquer(cs, spans)
assert all(x[0] == x[1] == x[2] for x in score(det, det).values())
cat = next(s[3] for s in spans if validite({s[3]}))
oubli = score(marquer(cs, [s for s in spans if s[3] != cat]), det)[cat]
assert oubli[0] == oubli[2] == 0 < oubli[1], oubli
ajout = score(marquer(cs, spans + [(debut, fin, [], "derive_lente")]), det)["derive_lente"]
assert ajout == [len(cs), 0, 0], ajout
assert validite({"visibilite_reduite", "visibilite_nulle"}) == "à ignorer"
assert validite({"dilatation_thermique", "a_verifier"}) is None
print("test : bon")
if __name__ == "__main__":
if sys.argv[1:] == ["--test"]:
test()
elif len(sys.argv) >= 2:
explicites = sys.argv[2:]
tous = sorted(glob.glob(os.path.join(RACINE, "events-learner", "*", "lot-*", "etiquettes.json")))
lots(sys.argv[1], explicites or tous, bool(explicites))
else:
sys.exit(__doc__)