Detector-learner: one benchmark, scripts moved, critic with realistic suggestions (D-120)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
98be20a2bc
commit
98c3308ca7
14 files changed
+291
-284
No files matched your search
@@ -1,40 +1,40 @@
|
||||
---
|
||||
name: detector-learner
|
||||
description: Séance automatique d'amélioration des détecteurs du journal du matin sur les étiquettes de l'etiqueteur déjà produites (labeling/auto/), la seule vérité (D-116, D-118) — detectors-critic, detectors-upgrader, detectors-control ; le but, des détecteurs alignés sur toutes les étiquettes de labeling/auto/ ; le garde-fou, le score sur les autres stations étiquetées. Lancé par l'utilisateur seulement, avec /detector-learner.
|
||||
description: Séance automatique d'amélioration des détecteurs du journal du matin sur les étiquettes de l'etiqueteur déjà produites (labeling/auto/), la seule vérité (D-116, D-118) — detectors-critic, detectors-upgrader, detectors-control ; le but, des détecteurs alignés sur toutes les étiquettes de labeling/auto/ ; le garde-fou, le benchmark sur les autres stations étiquetées. Lancé par l'utilisateur seulement, avec /detector-learner.
|
||||
disable-model-invocation: true
|
||||
argument-hint: "data/<STATION> [--du AAAA-MM-JJ] [--au AAAA-MM-JJ] [--ameliorer]"
|
||||
argument-hint: "data/<STATION> [--ameliorer]"
|
||||
---
|
||||
|
||||
# detector-learner : les détecteurs face aux étiquettes
|
||||
|
||||
Tu es l'orchestrateur. La vérité de la séance, ce sont les étiquettes de `labeling/auto/<STATION>.jsonl`, écrites en amont par l'`etiqueteur` (D-106) : le diagnostic est déjà fait, il n'y a ni analyste ni autre vérité ici (D-116, D-118). Le but est d'aligner les détecteurs le mieux possible sur l'ensemble des étiquettes de `labeling/auto/` ; le lot de la station montre où regarder. Tu appelles les trois agents des détecteurs 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.
|
||||
Tu es l'orchestrateur. La vérité de la séance, ce sont les étiquettes de `labeling/auto/`, écrites en amont par l'`etiqueteur` (D-106) : le diagnostic est déjà fait, il n'y a ni analyste ni autre vérité ici (D-116, D-118). Le but est d'aligner les détecteurs le mieux possible sur l'ensemble des étiquettes de `labeling/auto/` ; la station de la séance montre où regarder. Tu appelles les trois agents des détecteurs 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.
|
||||
|
||||
## 1. Mise en place
|
||||
|
||||
- Arguments : le dossier de station ; un nom seul (« Nordend ») désigne `data/<NOM EN MAJUSCULES>/`. `--du`, `--au` : jours UTC, `--au` exclu. Sans eux, la plage des étiquettes de la station : du jour de la première à minuit après la dernière (`plage()` de `regression.py` : `python3 -c "import sys; sys.path.insert(0, '.claude/skills/detector-learner'); import regression; print(regression.plage('labeling/auto/<STATION>.jsonl'))"`). `--ameliorer` (facultatif) : en fin de séance, l'améliorateur corrige le processus d'après les relevés du releveur (§4, D-071). Un argument pas net (`[--ameliorer]` entre crochets vaut l'option) : lis-le au mieux et note sous « Erreurs » du bilan comment.
|
||||
- `STATION` = le nom du dossier ; `SEANCE` = `date -u +%Y-%m-%dT%H%MZ` ; dossier de séance `detector-learner/<SEANCE>_<STATION>/`, ci-dessous `<séance>`.
|
||||
- Arguments : le dossier de station ; un nom seul (« Nordend ») désigne `data/<NOM EN MAJUSCULES>/`. `--ameliorer` (facultatif) : en fin de séance, l'améliorateur corrige le processus d'après les relevés du releveur (§4, D-071). Un argument pas net (`[--ameliorer]` entre crochets vaut l'option) : lis-le au mieux et note sous « Erreurs » du bilan comment.
|
||||
- `STATION` = le nom du dossier ; `labeling/auto/<STATION>.jsonl` sans étiquette, ou absent : dis-le et arrête-toi, sans commit. La **plage** de la séance : toutes les étiquettes de la station, du jour de la première à minuit après la dernière (`python3 -c "import sys; sys.path.insert(0, '.claude/skills/detector-learner'); import regression; print(regression.plage('labeling/auto/<STATION>.jsonl'))"`), ci-dessous `<début>` et `<fin>`, celle du bloc de la station dans le benchmark.
|
||||
- `SEANCE` = `date -u +%Y-%m-%dT%H%MZ` ; dossier de séance `detector-learner/<SEANCE>_<STATION>/`, ci-dessous `<séance>`.
|
||||
- Commits directement sur `master` (D-070) : `git branch --show-current` doit dire `master`, sinon dis-le et arrête-toi. Note la **base de la séance** : `git rev-parse HEAD`. Tu commites toujours par chemin (`git add <chemins> && git commit -m "<message>" -- <chemins>`), jamais `git add -A`, `git stash` ni `git checkout` hors de tes chemins : une autre session peut travailler dans ce dépôt. Avant chaque commit, `git branch --show-current` ; si ce n'est plus `master`, ne commite plus rien et passe au bilan. Chaque message finit par une ligne vide puis `Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>`.
|
||||
- `git status --porcelain -- detectors/ vues-deplacements/contexte/seuils-du-journal.md labeling/auto/ labeling/familles.md` (`familles.md` : les familles, une par détecteur, que comptent `score.py` et `regression.py`) : les fichiers déjà modifiés y restent tels quels, ni commités ni annulés ; liste-les sous « Erreurs » du bilan (les mesures tournent sur eux).
|
||||
- `git status --porcelain -- detectors/ vues-deplacements/contexte/seuils-du-journal.md labeling/auto/ labeling/familles.md` (`familles.md` : les familles, une par détecteur, que compte le benchmark) : les fichiers déjà modifiés y restent tels quels, ni commités ni annulés ; liste-les sous « Erreurs » du bilan (les mesures tournent sur eux).
|
||||
|
||||
**Commande du lot**, donnée telle quelle aux agents : `python3 detectors/categories.py <dossier> --du <début> --au <fin>`. **Commande des capteurs**, pour le critique : `python3 .claude/skills/detector-learner/capteurs.py <dossier> --du <début> --au <fin>` (la cadence des mesures, puis les capteurs de chaque événement, dont la commande du lot ne donne que le nombre).
|
||||
**Commande du journal**, donnée telle quelle aux agents : `python3 detectors/categories.py <dossier> --du <début> --au <fin>`. **Commande des capteurs**, pour le critique : `python3 .claude/skills/detector-learner/capteurs.py <dossier> --du <début> --au <fin>` (la cadence des mesures, puis les capteurs de chaque événement, dont la commande du journal ne donne que le nombre).
|
||||
|
||||
**Le benchmark**, la seule mesure de la séance : `python3 .claude/skills/detector-learner/regression.py --seance <SEANCE>_<STATION> --etape <étape> > <séance>/benchmark-<étape>.txt 2>&1`. Le score par famille et par instant sur chaque station de `labeling/auto/`, puis leur `Total`, versé dans `detector-learner/historique.csv`, qui dit si les détecteurs font mieux d'une séance à l'autre. Le bloc `<STATION>` est le score de la séance ; les autres blocs, la non-régression.
|
||||
|
||||
## 2. Dans l'ordre
|
||||
|
||||
Chaque agent est appelé par l'outil Agent avec son `subagent_type` et la demande ci-dessous, rien d'autre, sauf une consigne de l'utilisateur arrivée en cours de séance : ajoute-la telle quelle à la demande des agents suivants (`Consigne de l'utilisateur : …`) et note-la au bilan ; elle passe avant leurs consignes (nombre de suggestions, catégories), pas avant leur périmètre de fichiers, et ce qu'ils ne peuvent pas en faire va dans leur « Pas corrigé ». Un verdict se lit par `grep '^\*\*Verdict\*\* :' <rendu>`.
|
||||
Chaque agent est appelé par l'outil Agent avec son `subagent_type` et la demande ci-dessous, rien d'autre, sauf une consigne de l'utilisateur arrivée en cours de séance : ajoute-la telle quelle à la demande des agents suivants (`Consigne de l'utilisateur : …`) et note-la au bilan ; elle passe avant leurs consignes, pas avant leur périmètre de fichiers, et ce qu'ils ne peuvent pas en faire va dans leur « Pas corrigé ». Un verdict se lit par `grep '^\*\*Verdict\*\* :' <rendu>`.
|
||||
|
||||
1. **Score et non-régression avant.**
|
||||
`python3 .claude/skills/events-learner/score.py <dossier> --du <début> --au <fin> > <séance>/score-avant.txt 2>&1` ; s'il sort en erreur (« Aucune étiquette »), dis-le et arrête-toi, sans commit.
|
||||
`python3 .claude/skills/detector-learner/regression.py --sauf <STATION> > <séance>/regression-avant.txt 2>&1` : les mêmes détecteurs face aux étiquettes des autres stations, le garde-fou.
|
||||
`python3 .claude/skills/detector-learner/regression.py --seance <SEANCE>_<STATION> --etape avant > <séance>/regression-avant-global.txt 2>&1` : le **benchmark**, sur toutes les étiquettes de `labeling/auto/`, la station du lot comprise ; ses lignes entrent dans `detector-learner/historique.csv`, qui dit si les détecteurs font globalement mieux d'une séance à l'autre.
|
||||
Commit `<séance>/ detector-learner/historique.csv`, message `Detector-learner <STATION>: score`.
|
||||
2. **Detectors-critic** (`detectors-critic`) : `Dossier : <dossier>. Lot 01 : <début> → <fin> (UTC). Commande du lot : <commande>. Commande des capteurs : <commande des capteurs>. Étiquettes : labeling/auto/<STATION>.jsonl, celles qui touchent le lot. Score avant : <séance>/score-avant.txt. Écris <séance>/critique.md.`
|
||||
1. **Benchmark avant** : étape `avant`, donc `<séance>/benchmark-avant.txt`.
|
||||
Commit `<séance>/ detector-learner/historique.csv`, message `Detector-learner <STATION>: benchmark`.
|
||||
2. **Detectors-critic** (`detectors-critic`) : `Dossier : <dossier>. Station : <STATION>, plage <début> → <fin> (UTC). Commande du journal : <commande>. Commande des capteurs : <commande des capteurs>. Étiquettes : labeling/auto/<STATION>.jsonl. Score : le bloc <STATION> de <séance>/benchmark-avant.txt. Écris <séance>/critique.md.`
|
||||
Commit `<séance>/`, message `Detector-learner <STATION>: critique (<verdict>)`. Verdict `d'accord` : va au bilan.
|
||||
3. **Detectors-upgrader** (`detectors-upgrader`), passage K = 1, 2 ou 3 :
|
||||
`Dossier : <dossier>. Lot 01 : <début> → <fin> (UTC). Commande du lot : <commande>. Critique : <séance>/critique.md. Score avant : <séance>/score-avant.txt. Benchmark avant (toutes les étiquettes de labeling/auto/) : <séance>/regression-avant-global.txt, à relancer par python3 .claude/skills/detector-learner/regression.py (sans --sauf ni --etape) ; ses blocs des autres stations sont la non-régression. [Contrôle précédent : <séance>/validation-(K-1).md.] Passage K. Écris <séance>/modification-K.md.`
|
||||
Puis `python3 .claude/skills/detector-learner/regression.py --sauf <STATION> > <séance>/regression-K.txt 2>&1` et `python3 .claude/skills/detector-learner/regression.py --seance <SEANCE>_<STATION> --etape "modification K" > <séance>/regression-K-global.txt 2>&1`.
|
||||
`Dossier : <dossier>. Station : <STATION>, plage <début> → <fin> (UTC). Commande du journal : <commande>. Critique : <séance>/critique.md. Benchmark avant : <séance>/benchmark-avant.txt, à relancer par python3 .claude/skills/detector-learner/regression.py (sans --etape). [Contrôle précédent : <séance>/validation-(K-1).md.] Passage K. Écris <séance>/modification-K.md.`
|
||||
Puis le benchmark, étape `modification K`, dans `<séance>/benchmark-K.txt`.
|
||||
Commit `detectors/ vues-deplacements/contexte/seuils-du-journal.md <séance>/ detector-learner/historique.csv`, message `Detector-learner <STATION>: modification K`.
|
||||
4. **Detectors-control** (`detectors-control`), qui ne regarde pas le lot :
|
||||
`Lot 01. Modification : <séance>/modification-K.md. Benchmark (toutes les étiquettes de labeling/auto/) : <séance>/regression-avant-global.txt → <séance>/regression-K-global.txt, à relancer par python3 .claude/skills/detector-learner/regression.py (sans --sauf ni --etape). Non-régression, les autres stations seules : <séance>/regression-avant.txt → <séance>/regression-K.txt. Base : <base de la séance>. Passage K sur 3. Écris <séance>/validation-K.md.`
|
||||
4. **Detectors-control** (`detectors-control`), qui ne regarde pas la station de la séance :
|
||||
`Station de la séance : <STATION>. Modification : <séance>/modification-K.md. Benchmark : <séance>/benchmark-avant.txt → <séance>/benchmark-K.txt, à relancer par python3 .claude/skills/detector-learner/regression.py (sans --etape). Base : <base de la séance>. Passage K sur 3. Écris <séance>/validation-K.md.`
|
||||
Commit `<séance>/`, message `Detector-learner <STATION>: control K (<verdict>)`.
|
||||
- `accepté` ou `garder` : va au bilan.
|
||||
- `à reprendre` : retour à l'étape 3, passage K + 1.
|
||||
@@ -44,9 +44,9 @@ Un rendu absent ou sans verdict lisible : note-le, remets les détecteurs comme
|
||||
|
||||
## 3. Bilan
|
||||
|
||||
`python3 .claude/skills/events-learner/score.py <dossier> --du <début> --au <fin> > <séance>/score-fin.txt 2>&1`. Si la modification est annulée, `python3 .claude/skills/detector-learner/regression.py --seance <SEANCE>_<STATION> --etape fin > <séance>/regression-fin-global.txt 2>&1`, pour que l'historique finisse sur les détecteurs gardés.
|
||||
Le benchmark, étape `fin`, dans `<séance>/benchmark-fin.txt` : les détecteurs gardés.
|
||||
|
||||
`<séance>/bilan.md` : la plage, la base de la séance (`git log --oneline <base>..HEAD`), le nombre d'étiquettes ; le score avant → fin, famille par famille ; la ligne `Total` de la non-régression avant → celle de la modification gardée, et celle du benchmark (`-global`) ; critique (`d'accord` / suggestions n), modification (aucune / gardée en K passages / annulée / erreur) ; `## Suggestions non traitées` (« Pas corrigé » des modifications) ; `## Erreurs` (aucune, ou ce qui manquait).
|
||||
`<séance>/bilan.md` : la plage, la base de la séance (`git log --oneline <base>..HEAD`), le nombre d'étiquettes ; avant → fin, famille par famille, le bloc `<STATION>`, puis les lignes changées des autres stations, puis le `Total` ; critique (`d'accord` / suggestions n), modification (aucune / gardée en K passages / annulée / erreur) ; `## Suggestions non traitées` (« Pas corrigé » des modifications) ; `## Erreurs` (aucune, ou ce qui manquait).
|
||||
|
||||
Commit `<séance>/ detector-learner/historique.csv`, message `Detector-learner <STATION>: bilan`.
|
||||
|
||||
@@ -59,6 +59,6 @@ Si `git status --short docs/ameliorations-processus.md` montre un changement : c
|
||||
|
||||
## 5. Réponse finale
|
||||
|
||||
`python3 .claude/skills/events-learner/comparaison.py <dossier> <séance> --du <début> --au <fin>` : la page de fin de séance, les étiquettes face aux détecteurs famille par famille (son annexe, un reste de /events-learner, ne compte pas). Un échec du script va dans la réponse, sans relance.
|
||||
`python3 .claude/skills/detector-learner/comparaison.py <dossier> <séance> --du <début> --au <fin>` : la page de fin de séance, `out/detector-learner_<SEANCE>_<STATION>.html`, les étiquettes face aux détecteurs famille par famille. Un échec du script va dans la réponse, sans relance.
|
||||
|
||||
En 6 lignes au plus : la page, la base de la séance, le bilan, le score avant → fin, la non-régression et le benchmark (`Total`), la modification gardée ou non, les erreurs et difficultés relevées et, avec `--ameliorer`, celles corrigées. Tout est sur `master`, rien n'est poussé : l'utilisateur annule ce qu'il ne garde pas par `git revert`.
|
||||
En 6 lignes au plus : la page, la base de la séance, le bilan, la station avant → fin et le `Total`, la modification gardée ou non, les erreurs et 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,75 @@
|
||||
"""Page de fin de séance de /detector-learner : les étiquettes de l'étiqueteur face aux détecteurs, sur la plage de la séance.
|
||||
|
||||
La page de detectors-view/detecteurs.py (images de la caméra, timelapse d'un événement au clic, pose de la caméra, corr_x et corr_y de
|
||||
chaque capteur en couleur, ligne « Error rate »), une ligne par famille des étiquettes (labeling/familles.md), dédoublée :
|
||||
en haut les étiquettes de labeling/auto/<STATION>.jsonl qui touchent la plage, en bas les événements des détecteurs tels
|
||||
qu'ils sont (la plage classée avec ses 3 jours d'historique, comme le score), rangés par la correspondance de familles.md ;
|
||||
un saut bref, dont la famille est celle de sa cause, garde sa ligne (D-112). Sous la figure, la liste des événements des
|
||||
détecteurs et le score de la séance (score.py --du --au). 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/detector-learner/comparaison.py <dossier de station> <dossier de séance> --du AAAA-MM-JJ --au AAAA-MM-JJ
|
||||
(--au exclu ; page : out/detector-learner_<séance>.html, ouverte dans le navigateur)
|
||||
"""
|
||||
import html
|
||||
import os
|
||||
import sys
|
||||
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "..", "detectors-view"))
|
||||
import detecteurs # noqa: E402 (la page des détecteurs ; met src/, detectors/ et les outils sur le chemin)
|
||||
from detecteurs import HORS, ROOT, open_served, score, survol # noqa: E402
|
||||
|
||||
|
||||
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>Étiquetées</th><th>Signalées par les détecteurs</th>"
|
||||
"<th>Trouvées</th><th>Confirmées</th></tr>" + lignes + "</table>")
|
||||
|
||||
|
||||
def page(dossier, seance, du, au):
|
||||
"""La page de detecteurs.py sur la plage de la séance (images, timelapse, pose de la caméra, capteurs en couleur),
|
||||
plus les étiquettes de l'étiqueteur et le score de la séance."""
|
||||
debut, fin = score.iso(score.instant(du)), score.iso(score.instant(au))
|
||||
total, etiq = score.familles_lot(dossier, debut, fin)
|
||||
if not etiq:
|
||||
sys.exit(f"Aucune étiquette de {os.path.basename(os.path.normpath(dossier))} sur {debut} → {fin} dans labeling/auto/.")
|
||||
agent = [(e["debut"], e["fin"], c := HORS if e.get("categorie") == "None" else e.get("categorie", "sans famille"),
|
||||
survol(f"Étiquette : {c}", e["debut"], e["fin"], ["dans le texte"], e["description"])) for e in etiq]
|
||||
|
||||
lignes = score.familles()
|
||||
ordre = [*dict.fromkeys(lignes.values()), HORS]
|
||||
nom = os.path.basename(os.path.normpath(seance))
|
||||
entete = f"""<h1>Séance {html.escape(nom)}</h1>
|
||||
<p>Dessous les courbes, chaque ligne est une famille des étiquettes (<code>labeling/familles.md</code>) : la barre du haut,
|
||||
les {len(etiq)} étiquettes de l'étiqueteur qui touchent la plage (<code>labeling/auto/</code>), celle du bas, les événements
|
||||
des détecteurs dans leur état de fin de séance, rangés dans la famille de leur catégorie (survol : la catégorie du
|
||||
journal). Un saut bref, de la famille de sa cause, garde sa ligne. Survol : bornes, description ; un clic sur une barre, des
|
||||
étiquettes ou des détecteurs, joue son timelapse. Le but de la boucle : que les deux barres de chaque ligne coïncident.</p>"""
|
||||
annexe = f"""<style>td small{{color:#8a8984}} tr.niveau td{{color:#5f5e5a;font-style:italic}}</style>
|
||||
<h3>Score de la séance</h3>
|
||||
<p>On compte des instants : une heure de la plage où un capteur au moins a une mesure ; les étiquettes ne disent leurs
|
||||
capteurs que dans leur texte. <b>Trouvées</b> : des instants qu'une étiquette range dans la famille, la part que les
|
||||
détecteurs signalent aussi ; le reste, ils l'ont raté. <b>Confirmées</b> : des instants que signalent les détecteurs, la
|
||||
part qu'une étiquette range aussi dans la famille ; le reste, ce sont des alertes en trop, ou un oubli de l'étiqueteur.
|
||||
Un saut bref compte dans la famille de l'étiquette qui le couvre. Le but : 100 % dans les deux colonnes ; « — » : rien à
|
||||
compter. Les trous ne comptent pas (pas de mesure).</p>
|
||||
{tableau(total, ordre, "Famille")}"""
|
||||
return detecteurs.page(dossier, debut, fin, entete=entete, annexe=annexe, analyste=agent, lignes=lignes,
|
||||
chemin=os.path.join(ROOT, "out", f"detector-learner_{nom}.html"))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
if len(sys.argv) != 7 or sys.argv[3::2] != ["--du", "--au"]:
|
||||
sys.exit(__doc__)
|
||||
p = page(sys.argv[1], sys.argv[2], sys.argv[4], sys.argv[6])
|
||||
print(p)
|
||||
open_served(p)
|
||||
@@ -1,12 +1,12 @@
|
||||
"""Non-régression de /detector-learner (D-116) : les détecteurs face aux étiquettes de l'étiqueteur des autres stations.
|
||||
"""Benchmark de /detector-learner (D-116) : les détecteurs face à toutes les étiquettes de l'étiqueteur (labeling/auto/).
|
||||
|
||||
Pour chaque station de labeling/auto/ (sauf --sauf) qui a son dossier dans data/, le score par famille et par instant
|
||||
de score.py (D-112), sur la plage de ses étiquettes : du jour de la première à minuit après la dernière. Puis le total,
|
||||
famille par famille : le benchmark de /detector-learner, sur toutes les étiquettes de l'étiqueteur, qui dit si les
|
||||
détecteurs font globalement mieux d'une séance à l'autre. Une famille qui recule sur une station est un recul, même si
|
||||
le total monte. Avec --etape, chaque ligne (stations et Total) entre dans l'historique, detector-learner/historique.csv,
|
||||
avec la version des détecteurs (benchmark.version()).
|
||||
Usage : python3 .claude/skills/detector-learner/regression.py [--sauf STATION] [--seance <séance> --etape <étape>]
|
||||
Pour chaque station de labeling/auto/ qui a son dossier dans data/, le score par famille et par instant de score.py
|
||||
(D-112), sur la plage de ses étiquettes : du jour de la première à minuit après la dernière. Puis le total, famille par
|
||||
famille, qui dit si les détecteurs font globalement mieux d'une séance à l'autre. Le bloc de la station de la séance est
|
||||
son score ; les autres blocs, la non-régression : une famille qui recule sur une station est un recul, même si le total
|
||||
monte. Avec --etape, chaque ligne (stations et Total) entre dans l'historique, detector-learner/historique.csv, avec la
|
||||
version des détecteurs (score.version()).
|
||||
Usage : python3 .claude/skills/detector-learner/regression.py [--seance <séance> --etape <étape>]
|
||||
"""
|
||||
import argparse
|
||||
import csv
|
||||
@@ -14,11 +14,10 @@ import glob
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
from datetime import datetime, timezone
|
||||
|
||||
RACINE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "..")
|
||||
sys.path.insert(0, os.path.join(RACINE, ".claude", "skills", "events-learner"))
|
||||
import benchmark # noqa: E402
|
||||
import score # noqa: E402
|
||||
import score # noqa: E402 (à côté)
|
||||
|
||||
HISTORIQUE = os.path.join(RACINE, "detector-learner", "historique.csv")
|
||||
|
||||
@@ -35,17 +34,13 @@ def plage(chemin):
|
||||
|
||||
if __name__ == "__main__":
|
||||
p = argparse.ArgumentParser(usage=__doc__)
|
||||
p.add_argument("--sauf")
|
||||
p.add_argument("--seance", default="")
|
||||
p.add_argument("--etape")
|
||||
a = p.parse_args()
|
||||
sauf = a.sauf.upper() if a.sauf else None
|
||||
total, res = {}, {}
|
||||
for chemin in sorted(glob.glob(os.path.join(RACINE, "labeling", "auto", "*.jsonl"))):
|
||||
station = os.path.basename(chemin)[:-len(".jsonl")]
|
||||
dossier = os.path.join(RACINE, "data", station)
|
||||
if station == sauf:
|
||||
continue
|
||||
if not os.path.isdir(dossier):
|
||||
print(f"{station} : pas de data/{station}/, sautée\n")
|
||||
continue
|
||||
@@ -61,7 +56,7 @@ if __name__ == "__main__":
|
||||
res["Total"] = total
|
||||
os.makedirs(os.path.dirname(HISTORIQUE), exist_ok=True)
|
||||
neuf = not os.path.exists(HISTORIQUE)
|
||||
date, ver = benchmark.datetime.now(benchmark.timezone.utc).strftime("%Y-%m-%dT%H:%MZ"), benchmark.version()
|
||||
date, ver = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%MZ"), score.version()
|
||||
with open(HISTORIQUE, "a", newline="", encoding="utf-8") as f:
|
||||
w = csv.writer(f)
|
||||
if neuf:
|
||||
|
||||
@@ -0,0 +1,230 @@
|
||||
"""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.
|
||||
Avec --du et --au, le score d'une plage (D-112, /detector-learner) : les détecteurs face aux étiquettes de l'étiqueteur
|
||||
(labeling/auto/<STATION>.jsonl) qui touchent le lot, par famille (labeling/familles.md) et par instant, les étiquettes
|
||||
ne disant pas leurs capteurs ; la catégorie d'un événement est sa famille (un détecteur par famille, D-119), sauf un saut
|
||||
bref resté seul, qui prend la famille de l'étiquette qui le couvre. Aucune étiquette sur le lot : sortie en erreur.
|
||||
Usage : python3 .claude/skills/detector-learner/score.py <dossier de station> [etiquettes.json ...]
|
||||
(défaut : events-learner/*/lot-*/etiquettes.json de la station)
|
||||
python3 .claude/skills/detector-learner/score.py <dossier de station> --du AAAA-MM-JJ --au AAAA-MM-JJ
|
||||
python3 .claude/skills/detector-learner/score.py --test
|
||||
"""
|
||||
import glob
|
||||
import json
|
||||
import os
|
||||
import subprocess
|
||||
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_a_probleme", "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")
|
||||
CAUSES_SAUT = {"Obstruction", "Visibility", "Displacement"} # un saut bref : la famille de sa cause (familles.md, frontières)
|
||||
|
||||
|
||||
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 compter(paires):
|
||||
"""[(clés étiquetées, clés signalées)], une paire par case -> {clé: [étiquetées, signalées, les deux]}."""
|
||||
n = {}
|
||||
for a, d in paires:
|
||||
for k in a | d:
|
||||
x = n.setdefault(k, [0, 0, 0])
|
||||
x[0], x[1], x[2] = x[0] + (k in a), x[1] + (k in d), x[2] + (k in a and k in d)
|
||||
return n
|
||||
|
||||
|
||||
def version():
|
||||
"""La version des détecteurs : le commit, suivi de « + » si detectors/ a des changements non commités."""
|
||||
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 score(etiq, det):
|
||||
"""{case: catégories de l'analyste}, {case: catégories des détecteurs} -> {clé: [étiquetées, signalées, les deux]}."""
|
||||
return compter([x | {v} if (v := validite(x)) else x for x in (etiq[c], det[c])] for c in etiq)
|
||||
|
||||
|
||||
def familles():
|
||||
"""{catégorie du journal: famille} : chaque famille est sa propre catégorie (D-119), dans l'ordre de categories.py."""
|
||||
return {c: c for c in categories.CATEGORIES}
|
||||
|
||||
|
||||
def bref(v):
|
||||
"""Un événement qui n'est qu'un saut revenu, resté seul (aucune cause ne l'a absorbé)."""
|
||||
return v["category"] == "Displacement" and v["episodes"][0]["label"] == categories.SAUT
|
||||
|
||||
|
||||
def etiquettes_auto(station, debut, fin):
|
||||
"""labeling/auto/<STATION>.jsonl -> les étiquettes de l'étiqueteur qui touchent [début, fin)."""
|
||||
chemin = os.path.join(RACINE, "labeling", "auto", f"{station}.jsonl")
|
||||
if not os.path.exists(chemin):
|
||||
return []
|
||||
with open(chemin, encoding="utf-8") as f:
|
||||
return [e for e in map(json.loads, filter(str.strip, f)) if e["debut"] < fin and e["fin"] >= debut]
|
||||
|
||||
|
||||
def familles_lot(dossier, debut, fin, etiq=None):
|
||||
"""Score d'un lot par famille et par instant (D-112) -> ({famille: [étiquetés, signalés, les deux]}, étiquettes).
|
||||
Un instant : une heure du lot où un capteur au moins a une mesure ; il reçoit les familles des étiquettes qui le
|
||||
couvrent, bornes comprises, et celles des événements des détecteurs. etiq : les étiquettes, sinon labeling/auto/."""
|
||||
# ponytail: par instant et non par capteur, les étiquettes ne disent leurs capteurs que dans le texte ; un champ
|
||||
# capteurs dans l'étiquette, si cette finesse manque
|
||||
mesures = charger(dossier)
|
||||
if etiq is None:
|
||||
etiq = etiquettes_auto(os.path.basename(os.path.normpath(dossier)), debut, fin)
|
||||
evts = evenements(mesures, debut, fin)
|
||||
paires = []
|
||||
for t in sorted({t for _, t in cases(mesures, debut, fin)}):
|
||||
a = {e.get("categorie", "sans famille") for e in etiq if e["debut"] <= t <= e["fin"]} - {"None"}
|
||||
d = {"saut_bref" if bref(v) else v["category"] for v in evts if v["start"] <= t <= v["end"]}
|
||||
if "saut_bref" in d:
|
||||
d = d - {"saut_bref"} | (a & CAUSES_SAUT or {"saut_bref"})
|
||||
paires.append((a, d))
|
||||
return compter(paires), etiq
|
||||
|
||||
|
||||
def pct(a, b):
|
||||
return f"{a}/{b} ({round(100 * a / b)} %)" if b else "—"
|
||||
|
||||
|
||||
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
|
||||
# par famille (D-112) : chaque catégorie du journal a sa famille, sauf saut_bref ; les événements des détecteurs pris
|
||||
# pour étiquettes, sauts brefs à part, donnent chaque famille trouvée et juste en entier
|
||||
corr = familles()
|
||||
assert set(categories.CATEGORIES) - set(corr) == {"saut_bref"}, corr
|
||||
etiq = [{"debut": v["start"], "fin": v["end"], "categorie": corr[v["category"]]}
|
||||
for v in evenements(mesures, debut, fin) if v["category"] != "saut_bref"]
|
||||
n, _ = familles_lot(os.path.join(RACINE, "vues-deplacements", "cas", "2026-10_NORDEND", "NORDEND"), debut, fin, etiq)
|
||||
assert n and all(x[0] == x[1] == x[2] for k, x in n.items() if k != "saut_bref"), n
|
||||
print("test : bon")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
if sys.argv[1:] == ["--test"]:
|
||||
test()
|
||||
elif len(sys.argv) == 6 and sys.argv[2::2] == ["--du", "--au"]:
|
||||
station, du, au = os.path.basename(os.path.normpath(sys.argv[1])), iso(instant(sys.argv[3])), iso(instant(sys.argv[5]))
|
||||
n, etiq = familles_lot(sys.argv[1], du, au)
|
||||
if not etiq:
|
||||
sys.exit(f"Aucune étiquette de {station} sur {du} → {au} dans labeling/auto/{station}.jsonl : "
|
||||
"étiqueter le lot d'abord (@etiqueteur).")
|
||||
afficher(f"{station} : {du} → {au}, {len(etiq)} étiquettes de labeling/auto/{station}.jsonl, par famille et par instant", n)
|
||||
elif len(sys.argv) >= 2:
|
||||
explicites = sys.argv[2:]
|
||||
tous = sorted(glob.glob(os.path.join(RACINE, "events-learner", "*", "lot-*", "etiquettes.json")))
|
||||
lots(sys.argv[1], explicites or tous, bool(explicites))
|
||||
else:
|
||||
sys.exit(__doc__)
|
||||
Reference in new issue
Block a user