Files
Support-Agent/agents/diagnostic/outils/ensemble.py
T
maximeandClaude Opus 5.5 d5bae7a696 Add the loop's end-of-session page and a detector benchmark on the case base
- End-of-session page for /boucle: the session's curves, the analyst's
  labels against the detectors' events per category, a plain score table
  and the benchmark (comparaison.py, D-066)
- Detectors moved to vues-deplacements/detectors/ (D-067)
- Detectors must detect everything; what the client sees is a separate
  layer (D-068)
- Benchmark: each case keeps its labels from creation (etiquettes.json),
  benchmark.py scores the detectors on every case, history in
  vues-deplacements/benchmark/historique.csv; run by /boucle at each lot,
  after each change and at the end, read by the upgrader and validator;
  labels for C-001..C-005 from one analyst pass corrected by their files,
  C-006..C-008 from lot 01 (D-069)
- Fixes from the releveur's notes: /boucle arguments and other sessions,
  branch name in the spec, detector name in categories.py output, learned
  case header, anonymiser.py (camera/, no empty CSVs, --etiquettes),
  ensemble.py (clock-aligned steps, title), plages.py (same-sign merge),
  labeling request written into /nouveau-cas
- Also carries the other session's uncommitted D-065 edits in the same
  files; data/, .gitignore, pomper.py and stations.py are left out

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-26 16:48:13 +01:00

270 lines
15 KiB
Python

"""Vue d'ensemble de tous les capteurs d'un export « advanced » : ce que font les capteurs ensemble.
Usage : .venv/bin/python agents/diagnostic/outils/ensemble.py data/PS_DES_COUDRES/
[--colonnes x,y,sigma0] [--colonne error_value] [--pas 15min] [--k 5] [--min 5]
[--residus corr_x,corr_y,error_value] [--hors T1/T2] [--autres] [--capteurs A,B] [--debut ...] [--fin ...] [--sortie DOSSIER]
Chaque capteur est comparé à son propre niveau sur la fenêtre --debut/--fin (médiane et MAD de la fenêtre).
Deux PNG, dont les chemins sont imprimés :
1. « commun » : un panneau par colonne de --colonnes (défaut x,y,sigma0 : position brute et sigma0 de la
caméra) : médiane, sur les capteurs, de l'écart de chaque capteur à sa médiane ; bande grise = 10e à 90e
centile entre capteurs (la dispersion) ; dernier panneau : nombre de capteurs dont --colonne
(défaut error_value) dépasse sa médiane de plus de --k MAD à chaque pas.
2. « multiples » : un petit graphique par capteur (références d'abord) de --colonne, médiane par pas de --pas,
trait pointillé = médiane de la fenêtre ; chaque graphique a son échelle, un palier se voit.
3. « residus-<colonne> » (un PNG par colonne de --residus, défaut corr_x,corr_y,error_value) : un petit graphique par
capteur de la colonne moins le niveau propre du capteur (sa médiane sur la fenêtre, ou hors de --hors T1/T2 si
donné : le niveau est alors celui du reste de la fenêtre, pas celui du moment lu), une échelle par capteur, zéro en
pointillé ; un écart de quelques centièmes sur une colonne `corr` que les bandes parallèles de `graphique.py` cachent
s'y voit. Imprime, par capteur, le niveau, le bruit propre (médiane des écarts entre deux mesures consécutives) et
l'écart minimum et maximum de la médiane par pas de --pas, avec leur instant, en unités de la colonne et en bruits.
Avec --autres, chaque capteur est de plus ramené à l'écart à la médiane des AUTRES capteurs au même instant (on
retranche, à chaque mesure, la médiane des autres capteurs de la même colonne moins leur niveau propre) : ce qui est
partagé par tous (le reste de la compensation d'un mouvement commun) s'annule, ce qui est propre au capteur reste.
PNG « residus-<colonne>-autres » ; la table imprime en plus, par capteur, la pente de ce résidu sur chaque
colonne de --colonnes (médiane commune, ex. y) et la corrélation r : un résidu proportionnel au mouvement commun
(même s'il n'est pas partagé par tous) a une pente non nulle et un r élevé.
Imprime aussi la table de la médiane commune (une ligne par pas de --pas : heure, écart à la médiane de la fenêtre
pour chaque colonne de --colonnes) puis le minimum et le maximum de chaque colonne avec leur instant ; pour dater
un début ou une fin, la table est au pas de --pas (défaut 15min, la cadence des mesures ; un pas plus large,
1h par ex., aplatit un pic d'un à quatre pas et date à l'heure).
Imprime aussi, pour chaque instant où au moins --min capteurs dépassent leur médiane de plus de --k MAD,
le nombre et les capteurs (--min 1 : aussi les instants où un seul capteur sort de son niveau). Rend des valeurs, pas de verdict.
"""
import argparse
import math
import os
import statistics
import sys
import matplotlib
matplotlib.use("Agg")
import matplotlib.dates as mdates # noqa: E402
import matplotlib.pyplot as plt # noqa: E402
from donnees import charger, est_reference, filtrer, instant, iso # noqa: E402
from graphique import COLONNES, RACINE, borne # noqa: E402
from resume import duree # noqa: E402
def niveau(ms, col):
"""(médiane, MAD) des valeurs non vides ; None si aucune."""
v = [m[col] for m in ms if m[col] is not None]
if not v:
return None
med = statistics.median(v)
return med, statistics.median(abs(x - med) for x in v)
def main():
a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
a.add_argument("dossier")
a.add_argument("--colonnes", default="x,y,sigma0")
a.add_argument("--colonne", default="error_value", choices=COLONNES)
a.add_argument("--pas", default="15min", type=duree, help="pas des tables et des courbes en bleu (défaut 15min, la cadence des mesures : un pas plus large aplatit et décale les événements courts)")
a.add_argument("--k", type=float, default=5, help="écart compté, en MAD de la fenêtre")
a.add_argument("--min", type=int, default=5, help="nombre de capteurs à partir duquel un instant est imprimé")
a.add_argument("--residus", default="corr_x,corr_y,error_value", help="colonnes tracées moins le niveau propre de chaque capteur ('' : aucune)")
a.add_argument("--hors", help="T1/T2 : le niveau propre des résidus se calcule hors de ce moment")
a.add_argument("--autres", action="store_true", help="résidus de plus ramenés à la médiane des autres capteurs au même instant, avec pente et corrélation sur le mouvement commun")
a.add_argument("--capteurs", help="liste séparée par des virgules (défaut : tous)")
a.add_argument("--debut", type=instant)
a.add_argument("--fin", type=instant)
a.add_argument("--sortie", default=os.path.join(RACINE, "out", "diagnostic"), help="dossier des PNG")
o = a.parse_args()
par = charger(o.dossier)
if not par:
sys.exit(f"Aucun export « advanced » dans {o.dossier} (voir inventaire.py).")
noms = o.capteurs.split(",") if o.capteurs else sorted(par, key=lambda s: (not est_reference(par[s]), s))
colonnes = o.colonnes.split(",")
residus = [c for c in o.residus.split(",") if c]
hors = tuple(instant(x) for x in o.hors.split("/")) if o.hors else None
if hors and len(hors) != 2:
sys.exit("--hors attend T1/T2.")
for demandes, connus, quoi in ((noms, par, "Capteurs"), (colonnes + residus + [o.colonne], COLONNES, "Colonnes")):
absents = [x for x in demandes if x not in connus]
if absents:
sys.exit(f"{quoi} inconnus : {', '.join(absents)}. Connus : {', '.join(sorted(connus))}.")
series = {s: filtrer(par[s], o.debut, o.fin) for s in noms}
if not any(series.values()):
sys.exit("Aucune mesure dans la fenêtre demandée.")
temps = sorted({m["t"] for s in noms for m in series[s]})
station = os.path.basename(os.path.normpath(o.dossier))
os.makedirs(o.sortie, exist_ok=True)
base = os.path.join(o.sortie, f"{station}_{{}}_{borne(o.debut, 'debut')}_{borne(o.fin, 'fin')}.png")
def ecarts(col):
"""{capteur: {t: valeur - médiane de la fenêtre}}, et les MAD."""
e, mad = {}, {}
for s in noms:
n = niveau(series[s], col)
if n:
e[s] = {m["t"]: m[col] - n[0] for m in series[s] if m[col] is not None}
mad[s] = n[1]
return e, mad
# 1. commun
fig, axes = plt.subplots(len(colonnes) + 1, 1, sharex=True, figsize=(14, 3 * (len(colonnes) + 1)), squeeze=False)
communes = {}
for ax, col in zip(axes[:, 0], colonnes):
e, _ = ecarts(col)
med, bas, haut, tt = [], [], [], []
for t in temps:
v = sorted(e[s][t] for s in e if t in e[s])
if len(v) >= 2:
q = statistics.quantiles(v, n=10, method="inclusive")
tt.append(t), med.append(statistics.median(v)), bas.append(q[0]), haut.append(q[-1])
communes[col] = dict(zip(tt, med))
ax.fill_between(tt, bas, haut, color="0.85", label="10e-90e centile entre capteurs")
ax.plot(tt, med, ".-", ms=2, lw=0.8, label="médiane des capteurs")
ax.set_ylabel(f"{col}\nécart à sa médiane")
ax.grid(alpha=0.3)
ax.legend(loc="upper left", fontsize=8)
e, mad = ecarts(o.colonne)
compte, qui = [], {}
for t in temps:
hauts = [s for s in e if t in e[s] and mad[s] > 0 and e[s][t] > o.k * mad[s]]
compte.append(len(hauts))
if len(hauts) >= o.min:
qui[t] = hauts
axes[-1, 0].step(temps, compte, where="mid", lw=0.8)
axes[-1, 0].set_ylabel(f"capteurs au-dessus\nde médiane + {o.k:g} MAD\n({o.colonne})")
axes[-1, 0].grid(alpha=0.3)
h = next((h for h in (1, 2, 3, 6, 12) if (temps[-1] - temps[0]).total_seconds() / 3600 / h <= 20), 24)
axes[-1, 0].xaxis.set_major_locator(mdates.HourLocator(byhour=range(0, 24, h)))
axes[-1, 0].set_xlim(temps[0], temps[-1])
axes[-1, 0].xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%H:%MZ"))
for ax in axes[:, 0]:
ax.grid(alpha=0.5, which="major")
fig.suptitle(f"{station} : {len(e)} capteurs ensemble, chacun face à son niveau sur la fenêtre (heures UTC)")
commun = base.format("commun")
fig.savefig(commun, dpi=100, bbox_inches="tight")
plt.close(fig)
print(commun)
# table de la médiane commune, par pas
minuit = temps[0].replace(hour=0, minute=0, second=0, microsecond=0)
t0 = minuit + ((temps[0] - minuit) // o.pas) * o.pas # pas calés sur l'horloge (hh:00, hh:15…), pas sur la 1re mesure
lignes_t = {}
for col in colonnes:
for t, v in communes[col].items():
lignes_t.setdefault(t0 + ((t - t0) // o.pas) * o.pas, {}).setdefault(col, []).append(v)
print(f"\nMédiane commune (écart à la médiane de la fenêtre), médiane par pas de {int(o.pas.total_seconds() // 60)} min :")
print(f"{'instant':17}" + "".join(f"{c:>12}" for c in colonnes))
for t in sorted(lignes_t):
print(f"{iso(t):17}" + "".join(f"{statistics.median(lignes_t[t][c]):12.4g}" if c in lignes_t[t] else " " * 12 for c in colonnes))
for col in colonnes:
if communes[col]:
lo, hi = min(communes[col].items(), key=lambda x: x[1]), max(communes[col].items(), key=lambda x: x[1])
print(f"{col} (mesures) : min {lo[1]:.4g} à {iso(lo[0])}, max {hi[1]:.4g} à {iso(hi[0])}")
# 2. petits multiples
col = o.colonne
n = len(noms)
lignes = math.ceil(n / 5)
fig, axes = plt.subplots(lignes, 5, sharex=True, figsize=(18, 2.5 * lignes), squeeze=False)
for ax, s in zip(axes.flat, noms):
ms = [m for m in series[s] if m[col] is not None]
ax.plot([m["t"] for m in ms], [m[col] for m in ms], "-", lw=0.4, color="0.7")
pas = {}
for m in ms:
pas.setdefault(t0 + ((m["t"] - t0) // o.pas) * o.pas, []).append(m[col])
ax.plot(list(pas), [statistics.median(v) for v in pas.values()], "-", lw=1.1, color="C0")
lv = niveau(series[s], col)
if lv:
ax.axhline(lv[0], color="C3", ls=":", lw=0.8)
ax.set_title(s + (" (réf.)" if series[s] and est_reference(series[s]) else ""), fontsize=9)
ax.grid(alpha=0.3)
ax.tick_params(labelsize=7)
ax.xaxis.set_major_locator(mdates.AutoDateLocator(minticks=2, maxticks=5))
ax.xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%Hh"))
for ax in list(axes.flat)[n:]:
ax.axis("off")
fig.suptitle(f"{station} : {col}, médiane par pas de {int(o.pas.total_seconds() // 60)} min (bleu), mesures (gris), "
f"médiane de la fenêtre (pointillé) ; une échelle par capteur (heures UTC)")
fig.tight_layout()
multiples = base.format(f"multiples-{col}")
fig.savefig(multiples, dpi=100, bbox_inches="tight")
print(multiples)
# 3. résidus : chaque capteur moins son propre niveau
for col, autres in [(c, False) for c in residus] + [(c, True) for c in residus if o.autres]:
fig, axes = plt.subplots(lignes, 5, sharex=True, figsize=(18, 2.5 * lignes), squeeze=False)
dev = {}
if autres: # {capteur: {t: valeur - niveau propre}} pour la médiane des autres
for q in noms:
mq = [m for m in series[q] if m[col] is not None]
rq = [m for m in mq if not hors or not hors[0] <= m["t"] <= hors[1]] or mq
nq = niveau(rq, col)
if nq:
dev[q] = {m["t"]: m[col] - nq[0] for m in mq}
print(f"\n{col} moins le niveau propre{' et moins la médiane des autres capteurs au même instant' if autres else ''} ({'hors ' + o.hors if hors else 'médiane de la fenêtre'}), médiane par pas de "
f"{int(o.pas.total_seconds() // 60)} min :")
pentes = []
print(f"{'capteur':9}{'niveau':>10}{'bruit':>10}{'écart min':>11} {'à':<17}{'(bruits)':>9}{'écart max':>11} {'à':<17}{'(bruits)':>9}")
for ax, s in zip(axes.flat, noms):
ms = [m for m in series[s] if m[col] is not None]
ref = [m for m in ms if not hors or not hors[0] <= m["t"] <= hors[1]] or ms
lv = niveau(ref, col)
if not lv:
ax.axis("off")
continue
d = [abs(b[col] - a_[col]) for a_, b in zip(ms, ms[1:])]
bruit = statistics.median(d) if d else 0
if autres:
res = {}
for m in ms:
v = [dev[q][m["t"]] for q in dev if q != s and m["t"] in dev[q]]
if len(v) >= 2:
res[m["t"]] = m[col] - lv[0] - statistics.median(v)
if len(res) < 2:
ax.axis("off")
continue
else:
res = {m["t"]: m[col] - lv[0] for m in ms}
pas = {}
for t, v in res.items():
pas.setdefault(t0 + ((t - t0) // o.pas) * o.pas, []).append(v)
pm = {t: statistics.median(v) for t, v in pas.items()}
ax.plot(list(res), list(res.values()), "-", lw=0.4, color="0.7")
ax.plot(list(pm), list(pm.values()), "-", lw=1.1, color="C0")
ax.axhline(0, color="C3", ls=":", lw=0.8)
ax.set_title(s + (" (réf.)" if est_reference(ms) else "") + f" bruit {bruit:.2g}", fontsize=9)
ax.grid(alpha=0.3)
ax.tick_params(labelsize=7)
ax.xaxis.set_major_locator(mdates.AutoDateLocator(minticks=2, maxticks=5))
ax.xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%Hh"))
lo, hi = min(pm.items(), key=lambda x: x[1]), max(pm.items(), key=lambda x: x[1])
f = lambda v: f"{v / bruit:9.1f}" if bruit else f"{'-':>9}"
print(f"{s:9}{lv[0]:10.4g}{bruit:10.3g}{lo[1]:11.3g} {iso(lo[0]):<17}{f(lo[1])}{hi[1]:11.3g} {iso(hi[0]):<17}{f(hi[1])}")
if autres:
for c in colonnes:
tt = [t for t in res if t in communes[c]]
if len(tt) > 2 and len({communes[c][t] for t in tt}) > 1:
xs, ys = [communes[c][t] for t in tt], [res[t] for t in tt]
pente = statistics.linear_regression(xs, ys).slope
pentes.append(f"{s:9}pente sur {c} commun {pente:+.4g} par unité, r = {statistics.correlation(xs, ys):+.2f}")
for ax in list(axes.flat)[n:]:
ax.axis("off")
if pentes:
print("\n".join(pentes))
fig.suptitle(f"{station} : {col} moins le niveau propre{' et la médiane des autres' if autres else ''} de chaque capteur, médiane par pas de "
f"{int(o.pas.total_seconds() // 60)} min (bleu), mesures (gris) ; une échelle par capteur (heures UTC)")
fig.tight_layout()
chemin = base.format(f"residus-{col}" + ("-autres" if autres else ""))
fig.savefig(chemin, dpi=100, bbox_inches="tight")
plt.close(fig)
print(chemin)
print(f"\nInstants où au moins {o.min} capteurs ont {o.colonne} > médiane de la fenêtre + {o.k:g} MAD :")
for t, hauts in qui.items():
print(f"{iso(t)} {len(hauts):3} {','.join(hauts)}")
if not qui:
print("(aucun)")
if __name__ == "__main__":
main()