Optimizer : l'optimisation des détecteurs depuis une analyse (skill improve, ex wf-improve, agents du dépôt agents, benchmark detectors/bench) ; le batch et le scanner archivés

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
maximeandClaude Opus 5.5 committed 2026-11-16 10:59:07 +01:00
1 parent 010c297f60
commit 2cb0c88a2b
117 files changed
+132 -38

No files matched your search

+37
View File
@@ -0,0 +1,37 @@
# Agitation d'une station sur un jour (STATION JOUR [HH HH]) : par instant, médiane sur les cibles du |Δcorr| d'un pas (en bruits), de l'error_value face à la nuit, de la sharpness et du flux face à la nuit ; pose de la caméra.
import statistics
import sys
from datetime import datetime, timedelta, timezone
from outils import RACINE, station, bruit
from data import load_camera
nom, jour = sys.argv[1:3]
h0, h1 = (int(x) for x in sys.argv[3:5]) if len(sys.argv) > 4 else (0, 24)
d = datetime.fromisoformat(jour).replace(tzinfo=timezone.utc)
m, refs = station(nom)
nuit = lambda x: d <= x["t"] < d + timedelta(hours=5) # noqa: E731 ponytail: nuit = 00-05 UTC, juste pour une base
cibles = [s for s in m if s not in refs]
base = {}
for s in cibles:
for c in ("error_value", "sharpness", "flux"):
v = [x[c] for x in m[s] if nuit(x) and x[c] is not None]
if v and statistics.median(v):
base[s, c] = statistics.median(v)
bx = {s: bruit(m[s], "corr_x") for s in cibles}
par = {}
for s in cibles:
ms = [x for x in m[s] if d + timedelta(hours=h0) <= x["t"] < d + timedelta(hours=h1)]
for a, b in zip(ms, ms[1:]):
r = par.setdefault(b["t"], {"d": [], "e": [], "sh": [], "fl": []})
if a["corr_x"] is not None and b["corr_x"] is not None and bx[s]:
r["d"].append(abs(b["corr_x"] - a["corr_x"]) / bx[s])
for c, k in (("error_value", "e"), ("sharpness", "sh"), ("flux", "fl")):
if b[c] is not None and (s, c) in base:
r[k].append(b[c] / base[s, c])
pose = {p["t"]: p for p in load_camera(str(RACINE / "data" / nom))}
med = lambda v: f"{statistics.median(v):5.2f}" if v else " - " # noqa: E731
print("t |Δx|/bruit ev/nuit sharp/nuit flux/nuit pan tilt")
for t in sorted(par):
r, p = par[t], pose.get(t, {})
print(t.strftime("%H:%M"), med(r["d"]), med(r["e"]), med(r["sh"]), med(r["fl"]),
f"{p.get('pan') or float('nan'):+.5f} {p.get('tilt') or float('nan'):+.5f}")
+16
View File
@@ -0,0 +1,16 @@
# Séries brutes de quelques capteurs : STATION CAPTEUR[,CAPTEUR…] DE A (AAAA-MM-JJTHH:MM) -> t, corr_x, corr_y, error_value/seuil, rejet ; bruit en tête.
import sys
from datetime import datetime, timezone
from outils import station, bruit, rejected
nom, noms, de, a = sys.argv[1], sys.argv[2].split(","), *sys.argv[3:5]
de, a = (datetime.fromisoformat(x).replace(tzinfo=timezone.utc) for x in (de, a))
m, refs = station(nom)
for s in noms:
ms = m[s]
print(f"== {s} {'(réf)' if s in refs else ''} bruit x={bruit(ms, 'corr_x'):.4g} y={bruit(ms, 'corr_y'):.4g}")
for x in ms:
if de <= x["t"] <= a:
ev = x["error_value"] / x["error_threshold"] if x["error_threshold"] and x["error_value"] is not None else float("nan")
f = lambda v: " None " if v is None else f"{v:+8.3f}" # noqa: E731
print(x["t"].strftime("%m-%d %H:%M"), f(x["corr_x"]), f(x["corr_y"]), f"{ev:.2f}", "REJ" if rejected(x) else "")
+10
View File
@@ -0,0 +1,10 @@
# Les épisodes bruts de visibility.episodes (avant categories.py) d'une station sur le jour, avec 3 jours d'historique : STATION.
import sys
from outils import D, B, H, station, iso
import visibility
m, _ = station(sys.argv[1])
morceau = {s: k for s, ms in m.items() if (k := [x for x in ms if H <= x["t"] < B])}
for e in visibility.episodes(morceau):
if e["end"] >= iso(D):
print(e["start"][11:], e["end"][11:], e["kind"], e["label"], len(e["sensors"]), e.get("level", ""))
+12
View File
@@ -0,0 +1,12 @@
"""Refait l'étape 1 de batch.py (détecteurs, figures, résumé) dans un dossier de travail, sans toucher à batches/ :
.venv/bin/python outils/etape1.py <dossier>/<jour> <jour> [A,B]. Pour vérifier un changement de batch.py ou des détecteurs."""
import sys
from datetime import datetime, timezone
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parents[1])) # batch.py
import batch
dossier, jour = Path(sys.argv[1]), sys.argv[2]
stations = sys.argv[3].split(",") if len(sys.argv) > 3 else sorted(p.name for p in batch.DONNEES.iterdir() if p.is_dir())
dossier.parent.mkdir(parents=True, exist_ok=True)
batch.detecteurs(dossier, datetime.strptime(jour, "%Y-%m-%d").replace(tzinfo=timezone.utc), stations)
+16
View File
@@ -0,0 +1,16 @@
# ev/seuil médian et part rejetée par capteur sur des fenêtres horaires du jour : STATION "HH-HH,HH-HH,..." (JOUR=AAAA-MM-JJ).
import statistics, sys
import os
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) # outils.py, à côté
from outils import D, station, rejected
from datetime import timedelta
nom, fen = sys.argv[1], [tuple(int(h) for h in f.split("-")) for f in sys.argv[2].split(",")]
m, refs = station(nom)
print("capteur".ljust(18), *[f"{a:02d}-{b:02d}h".rjust(12) for a, b in fen])
for s in sorted(m, key=lambda s: (s not in refs, s)):
cells = []
for a, b in fen:
xs = [x for x in m[s] if D + timedelta(hours=a) <= x["t"] < D + timedelta(hours=b)]
ev = [x["error_value"] / x["error_threshold"] for x in xs if x["error_value"] is not None and x["error_threshold"]]
cells.append(f"{statistics.median(ev) if ev else float('nan'):.2f} r{sum(map(rejected, xs))}/{len(xs)}".rjust(12))
print((s + (" (R)" if s in refs else "")).ljust(18), *cells)
+18
View File
@@ -0,0 +1,18 @@
# Médiane horaire d'une colonne pour quelques capteurs, sur plusieurs jours (STATION COL CAPTEUR[,CAPTEUR] J0 J1 [H0 H1]) : le même motif revient-il chaque jour ?
import statistics, sys
from datetime import datetime, timezone
import os
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) # outils.py, à côté
from outils import station
nom, col, caps, j0, j1 = sys.argv[1:6]
h0, h1 = (int(x) for x in sys.argv[6:8]) if len(sys.argv) > 7 else (0, 24)
m, _ = station(nom)
for s in caps.split(","):
par = {}
for x in m[s]:
j = x["t"].strftime("%m-%d")
if j0 <= j <= j1 and h0 <= x["t"].hour < h1 and x[col] is not None:
par.setdefault(j, {}).setdefault(x["t"].hour, []).append(x[col])
print(s, col, "heures", h0, "à", h1 - 1)
for j in sorted(par):
print(" ", j, " ".join(f"{statistics.median(par[j][h]):+.3f}" if h in par[j] else " - " for h in range(h0, h1)))
+38
View File
@@ -0,0 +1,38 @@
# Instant par instant (STATION [HH:MM HH:MM] [--pas MIN]) : capteurs mesurés, rejetés (cibles, références), les cibles les plus écartées en bruits.
import argparse
import statistics
from outils import D, B, station, ecarts, hhmm, rejected
p = argparse.ArgumentParser()
p.add_argument("station")
p.add_argument("de", nargs="?", default="00:00")
p.add_argument("a", nargs="?", default="23:59")
p.add_argument("--pas", type=float, help="bruit sur les paires espacées d'au moins PAS minutes (rafales)")
p.add_argument("--k", type=int, default=4)
p.add_argument("--seuil", type=float, default=5, help="n'afficher que les cibles au-delà (bruits)")
a = p.parse_args()
m, refs = station(a.station)
ex = {s: ecarts(ms, "corr_x", a.pas) for s, ms in m.items() if s not in refs}
ey = {s: ecarts(ms, "corr_y", a.pas) for s, ms in m.items() if s not in refs}
par = {}
for s, ms in m.items():
for x in ms:
if D <= x["t"] < B:
par.setdefault(x["t"], {})[s] = x
for t in sorted(par):
if not (a.de <= hhmm(t) <= a.a):
continue
c = par[t]
rej = sorted(s for s, x in c.items() if rejected(x))
rr = [s for s in rej if s in refs]
rc = [s for s in rej if s not in refs]
ev = [x["error_value"] / x["error_threshold"] for x in c.values() if x["error_value"] is not None and x["error_threshold"]]
top = []
for nom, e in (("x", ex), ("y", ey)):
v = sorted(((abs(e[s][t]), s, e[s][t]) for s in e if e[s].get(t) is not None), reverse=True)
top += [f"{s}:{nom}{z:+.0f}" for _, s, z in v[:a.k] if abs(z) > a.seuil]
n = sum(1 for z, _, _ in v if z > a.seuil)
top.append(f"[{nom}>{a.seuil:g}: {n}/{len(v)}]")
print(f"{hhmm(t)} n={len(c):2d} ev/s={statistics.median(ev) if ev else float('nan'):.2f} "
f"rejC={len(rc)} rejR={rr} | {' '.join(top)}")
+50
View File
@@ -0,0 +1,50 @@
# Les instants anormaux (rejets non habituels, cibles qui sautent face à leur niveau local) qu'aucune étiquette de la vérité ne couvre, toutes stations (JOUR=AAAA-MM-JJ) ; une étiquette ne couvre que ses capteurs (lus dans « Détecteurs : variété, capteurs ») ; « N capteurs », « tous » ou une ligne du scanner couvrent tout ; une référence rejetée couverte couvre les sauts de l'instant. Hors Thermal. STATION... (JOUR=AAAA-MM-JJ).
import json, re, statistics, sys
import os
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) # outils.py, à côté
from outils import D, B, RACINE, station, bruit, hhmm, rejected, iso
BATCH = RACINE / "batches" / iso(D)[:10]
K, N = 10, 3
def capteurs(e):
m = re.match(r"Détecteurs : [^,]+, (.*?)(, grisé)?\. ", e["description"])
if not m or re.fullmatch(r"\d+ capteurs|tous les capteurs", m.group(1)):
return None # tout
return set(m.group(1).split(", "))
for nom in sys.argv[1:]:
labels = [json.loads(l) for l in open(BATCH / "verite" / f"{nom}.jsonl") if l.strip()]
labels = [(e, capteurs(e)) for e in labels if e["categorie"] != "Thermal displacement"]
m, refs = station(nom)
jour = {s: [x for x in ms if D <= x["t"] < B] for s, ms in m.items()}
habituel = {s for s, ms in jour.items() if ms and sum(map(rejected, ms)) > 0.5 * len(ms)}
sauts, rej = {}, {}
for s, ms in jour.items():
for x in ms:
if rejected(x) and s not in habituel:
rej.setdefault(x["t"], set()).add(s)
if s in refs:
continue
for col in ("corr_x", "corr_y"):
b = bruit(m[s], col, 10)
if not b:
continue
for i, x in enumerate(ms):
v = [y[col] for y in ms[max(0, i - 6):i] + ms[i + 1:i + 7] if y[col] is not None]
if x[col] is not None and len(v) >= 4 and abs(x[col] - statistics.median(v)) > K * b:
sauts.setdefault(x["t"], set()).add(s)
print(f"== {nom} (rejet habituel : {sorted(habituel)})")
for t in sorted(set(sauts) | set(rej)):
S, r = set(sauts.get(t, ())), set(rej.get(t, ()))
if len(S) < N and not r:
continue
for e, c in labels:
if e["debut"] <= iso(t) <= e["fin"]:
if c is None:
S, r = set(), set()
break
if c & r & refs:
S = set()
S -= c; r -= c
if len(S) >= N or r:
print(f" {hhmm(t)} sauts={len(S)} rejets={sorted(r)[:5]}")
+52
View File
@@ -0,0 +1,52 @@
# Outils communs de l'audit : charge une station (chargeur des détecteurs), écarts en bruits, événements des détecteurs.
# Le jour : la variable JOUR (AAAA-MM-JJ, UTC), par défaut 2026-11-05 (l'essai d'où viennent ces scripts).
import os
import statistics
import sys
from datetime import datetime, timedelta, timezone
from pathlib import Path
RACINE = Path(__file__).resolve().parents[1] # le dépôt Optimizer : data/, detectors/, batches/
sys.path.insert(0, str(RACINE / "detectors" / "scripts"))
from data import load, load_temperature, is_reference, rejected, iso # noqa: E402,F401
D = datetime.strptime(os.environ.get("JOUR", "2026-11-05"), "%Y-%m-%d").replace(tzinfo=timezone.utc)
B = D + timedelta(days=1)
H = D - timedelta(days=3)
def station(nom):
"""-> (mesures, refs) : {capteur: [mesure]} et l'ensemble des références."""
m = load(str(RACINE / "data" / nom))
return m, {s for s, ms in m.items() if is_reference(ms)}
def bruit(ms, col, pas_min=None):
"""Bruit propre : médiane des écarts entre deux mesures sur l'historique et le jour (comme batch.py) ;
pas_min (minutes) : ne garder que les paires espacées d'au moins pas_min (contre les rafales)."""
h = [(m["t"], m[col]) for m in ms if H <= m["t"] < B and m[col] is not None]
e = [abs(b - a) for (ta, a), (tb, b) in zip(h, h[1:])
if pas_min is None or (tb - ta).total_seconds() >= pas_min * 60]
return statistics.median(e) if len(e) > 1 else 0
def ecarts(ms, col, pas_min=None):
"""{t: écart à la médiane du jour en bruits} pour le jour ; None si rejetée."""
v = [m[col] for m in ms if D <= m["t"] < B and m[col] is not None]
b = bruit(ms, col, pas_min)
if not v or b <= 0:
return {}
med = statistics.median(v)
return {m["t"]: None if m[col] is None else (m[col] - med) / b for m in ms if D <= m["t"] < B}
def hhmm(t):
return t.strftime("%H:%M")
def evenements(nom):
"""Les événements des détecteurs comme batch.py les obtient (3 jours d'historique)."""
import categories
m = load(str(RACINE / "data" / nom))
morceau = {s: k for s, ms in m.items() if (k := [x for x in ms if H <= x["t"] < B])}
return [v for v in categories.events(morceau, B, str(RACINE / "data" / nom)) if v["end"] > iso(D)]
+16
View File
@@ -0,0 +1,16 @@
# Par instant d'une plage (STATION HH:MM HH:MM) : capteurs rejetés (noms abrégés, R = référence) et nombre de capteurs mesurés (JOUR=AAAA-MM-JJ).
import sys
import os
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) # outils.py, à côté
from outils import D, B, station, rejected, hhmm
nom, de, a = sys.argv[1:4]
m, refs = station(nom)
par = {}
for s, ms in m.items():
for x in ms:
if D <= x["t"] < B and de <= hhmm(x["t"]) <= a:
par.setdefault(x["t"], {})[s] = x
court = lambda s: s.replace("28DEF_RERA_CAM01_", "") + ("(R)" if s in refs else "")
for t in sorted(par):
r = sorted(court(s) for s, x in par[t].items() if rejected(x))
print(hhmm(t), f"n={len(par[t])}", f"rej={len(r)}", " ".join(r))
+13
View File
@@ -0,0 +1,13 @@
# Rejets d'un capteur jour par jour sur tout l'historique : STATION CAPTEUR -> jour, mesures, rejetées.
import sys
from collections import Counter
from outils import station, rejected
m, refs = station(sys.argv[1])
n, r = Counter(), Counter()
for x in m[sys.argv[2]]:
d = x["t"].date().isoformat()
n[d] += 1
r[d] += rejected(x)
print(sys.argv[2], "(réf)" if sys.argv[2] in refs else "(cible)")
print(" ".join(f"{d[5:]}:{r[d]}/{n[d]}" for d in sorted(n)))
+45
View File
@@ -0,0 +1,45 @@
"""Suit le flux d'un agent du batch pendant qu'il tourne (batches/<jour>/scan.jsonl ou improve.jsonl, écrit par claude -p) et
imprime ce qui compte : l'ouverture (source d'authentification, modèle, plugins), les sous-agents lancés, les commandes git et
de mesure, les fichiers écrits, les erreurs d'outil, la fin et son coût. python3 outils/suivre.py <flux.jsonl> [--fin]
(--fin : depuis la fin du fichier, pour reprendre une séance déjà commencée)."""
import json, sys, time
chemin = sys.argv[1]
while True:
try:
f = open(chemin, encoding="utf-8"); break
except FileNotFoundError:
time.sleep(1)
if "--fin" in sys.argv:
f.seek(0, 2)
outils = {}
while True:
l = f.readline()
if not l:
time.sleep(1); continue
if not l.startswith("{"):
print("RAW", l[:200], flush=True); continue
d = json.loads(l)
t, sub, par = d.get("type"), d.get("subtype"), d.get("parent_tool_use_id")
qui = "sous-agent" if par else "orchestrateur"
if t == "system" and sub == "init":
print(f"INIT apiKeySource={d.get('apiKeySource')} model={d.get('model')} plugins={[p['name'] for p in d.get('plugins', [])]} agents={[a for a in d.get('agents', []) if ':' in a]}", flush=True)
elif t == "assistant":
for c in d["message"].get("content", []):
if c.get("type") != "tool_use":
continue
i = c["input"]; outils[c["id"]] = (c["name"], i)
if c["name"] in ("Agent", "Task"):
print(f"AGENT {i.get('subagent_type')} lancé : {i.get('description')}", flush=True)
elif c["name"] == "Bash" and any(k in i.get("command", "") for k in ("git -C", "git commit", "regression.py", "score.py", "revert")):
print(f"BASH ({qui}) {i['command'][:220]}", flush=True)
elif c["name"] in ("Write", "Edit") and "/scripts/" in i.get("file_path", "") or c["name"] == "Write" and i.get("file_path", "").endswith(".md"):
print(f"{c['name'].upper()} ({qui}) {i.get('file_path')}", flush=True)
elif t == "user":
for c in d["message"].get("content", []) if isinstance(d["message"].get("content"), list) else []:
if c.get("type") == "tool_result" and c.get("is_error"):
n, i = outils.get(c.get("tool_use_id"), ("?", {}))
print(f"ERREUR ({qui}) {n} {str(i.get('command') or i.get('file_path') or '')[:120]} -> {str(c.get('content'))[:250]}", flush=True)
elif t == "result":
print(f"FIN {sub} tours={d.get('num_turns')} durée={round((d.get('duration_ms') or 0)/1000)}s coût_équiv={d.get('total_cost_usd')} refus={d.get('permission_denials')}", flush=True)
print("RÉPONSE", (d.get("result") or "")[:600].replace("\n", " | "), flush=True)
break