Sharpen NORDEND lot 01: modification 2
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
1ff6da05bd
commit
09cd4638a5
14 files changed
+183
-22
No files matched your search
@@ -2,7 +2,7 @@
|
||||
|
||||
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] [--capteurs A,B] [--debut ...] [--fin ...] [--sortie DOSSIER]
|
||||
[--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 :
|
||||
@@ -18,6 +18,12 @@ Deux PNG, dont les chemins sont imprimés :
|
||||
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,
|
||||
@@ -61,6 +67,7 @@ def main():
|
||||
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)
|
||||
@@ -182,10 +189,19 @@ def main():
|
||||
print(multiples)
|
||||
|
||||
# 3. résidus : chaque capteur moins son propre niveau
|
||||
for col in residus:
|
||||
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)
|
||||
print(f"\n{col} moins le niveau propre ({'hors ' + o.hors if hors else 'médiane de la fenêtre'}), médiane par pas de "
|
||||
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]
|
||||
@@ -196,11 +212,22 @@ def main():
|
||||
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 m in ms:
|
||||
pas.setdefault(t0 + ((m["t"] - t0) // o.pas) * o.pas, []).append(m[col] - lv[0])
|
||||
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([m["t"] for m in ms], [m[col] - lv[0] for m in ms], "-", lw=0.4, color="0.7")
|
||||
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)
|
||||
@@ -211,12 +238,21 @@ def main():
|
||||
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")
|
||||
fig.suptitle(f"{station} : {col} moins le niveau propre de chaque capteur, médiane par pas de "
|
||||
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}")
|
||||
chemin = base.format(f"residus-{col}" + ("-autres" if autres else ""))
|
||||
fig.savefig(chemin, dpi=100, bbox_inches="tight")
|
||||
plt.close(fig)
|
||||
print(chemin)
|
||||
|
||||
@@ -0,0 +1,94 @@
|
||||
"""Plages datées par capteur et par colonne, au pas natif des mesures, pour l'agent de diagnostic.
|
||||
|
||||
Usage : python3 agents/diagnostic/outils/plages.py data/PS_DES_COUDRES/ [--colonnes error_value,corr_x,corr_y]
|
||||
[--k 5] [--fusion 1h] [--hors T1/T2] [--capteurs A,B] [--debut ...] [--fin ...]
|
||||
|
||||
Pour chaque colonne, chaque capteur est comparé à son propre niveau sur la fenêtre --debut/--fin (médiane des
|
||||
valeurs non vides ; avec --hors T1/T2, celle du reste de la fenêtre, hors du moment lu : utile quand un épisode
|
||||
long fausse la médiane) et à son bruit propre (médiane des écarts entre deux mesures consécutives non vides, hors --hors).
|
||||
1. Un tableau par colonne : niveau, bruit, et le plus grand saut d'une mesure à la suivante (valeur, en bruits,
|
||||
les deux instants).
|
||||
2. Les plages où la colonne s'écarte de son niveau de plus de --k bruits : début et fin (première et dernière
|
||||
mesure hors niveau), nombre de mesures hors niveau, valeur extrême (écart signé au niveau, en unités et en
|
||||
bruits) et son instant. Deux plages séparées de moins de --fusion (défaut 1h) n'en font qu'une ; les mesures
|
||||
rejetées (colonne vide) ne coupent pas une plage. Une plage qui touche le bord de la fenêtre est datée au
|
||||
bord (le niveau est celui de la fenêtre : un palier durable peut faire de l'autre moitié la « plage »).
|
||||
Chaque colonne est lue aux mesures, jamais moyennée par pas. Rend des valeurs, pas de verdict.
|
||||
"""
|
||||
import argparse
|
||||
import statistics
|
||||
import sys
|
||||
|
||||
from donnees import charger, est_reference, filtrer, instant, iso
|
||||
from resume import COLONNES, duree
|
||||
|
||||
|
||||
def main():
|
||||
a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
||||
a.add_argument("dossier")
|
||||
a.add_argument("--colonnes", default="error_value,corr_x,corr_y")
|
||||
a.add_argument("--k", type=float, default=5, help="écart au niveau compté, en bruits propres du capteur")
|
||||
a.add_argument("--fusion", default="1h", type=duree, help="deux plages séparées de moins que cela n'en font qu'une")
|
||||
a.add_argument("--hors", help="T1/T2 : niveau et bruit se calculent hors de ce moment (les plages se cherchent partout)")
|
||||
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)
|
||||
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(",")
|
||||
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, 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.")
|
||||
|
||||
for col in colonnes:
|
||||
print(f"\n== {col} : niveau, bruit, plus grand saut d'une mesure à la suivante ==")
|
||||
print(f"{'capteur':9}{'n':>5}{'niveau':>10}{'bruit':>10}{'saut':>10}{'(bruits)':>9} entre")
|
||||
plages = []
|
||||
for s in noms:
|
||||
ms = [(m["t"], m[col]) for m in series[s] if m[col] is not None]
|
||||
if len(ms) < 2:
|
||||
print(f"{s:9}{len(ms):5} (moins de 2 valeurs)")
|
||||
continue
|
||||
ref = [x for x in ms if not hors or not hors[0] <= x[0] <= hors[1]]
|
||||
if len(ref) < 2:
|
||||
print(f"{s:9}{len(ms):5} (moins de 2 valeurs hors --hors)")
|
||||
continue
|
||||
niv = statistics.median(v for _, v in ref)
|
||||
sauts = [(b[1] - a_[1], a_[0], b[0]) for a_, b in zip(ms, ms[1:])]
|
||||
bruit = statistics.median(abs(b[1] - a_[1]) for a_, b in zip(ref, ref[1:]))
|
||||
d, t1, t2 = max(sauts, key=lambda x: abs(x[0]))
|
||||
bru = f"{d / bruit:9.1f}" if bruit else f"{'-':>9}"
|
||||
print(f"{s:9}{len(ms):5}{niv:10.4g}{bruit:10.3g}{d:+10.4g}{bru} {iso(t1)} et {iso(t2)}")
|
||||
if not bruit:
|
||||
continue
|
||||
groupe = []
|
||||
for t, v in ms + [(None, 0)]:
|
||||
if t is not None and abs(v - niv) > o.k * bruit:
|
||||
if groupe and t - groupe[-1][0] > o.fusion:
|
||||
plages.append((s, groupe, niv, bruit))
|
||||
groupe = []
|
||||
groupe.append((t, v))
|
||||
elif t is None and groupe:
|
||||
plages.append((s, groupe, niv, bruit))
|
||||
print(f"\n{col} : plages à plus de {o.k:g} bruits du niveau{' (niveau hors ' + o.hors + ')' if hors else ''} (fusion {int(o.fusion.total_seconds() // 60)} min)")
|
||||
print(f"{'capteur':9}{'début':<18}{'fin':<18}{'mesures':>8}{'extrême':>10}{'(bruits)':>9} à")
|
||||
for s, g, niv, bruit in plages:
|
||||
t, v = max(g, key=lambda x: abs(x[1] - niv))
|
||||
print(f"{s:9}{iso(g[0][0]):<18}{iso(g[-1][0]):<18}{len(g):8}{v - niv:+10.4g}{(v - niv) / bruit:9.1f} {iso(t)}")
|
||||
if not plages:
|
||||
print("(aucune)")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -2,7 +2,8 @@
|
||||
|
||||
Usage : .venv/bin/python agents/diagnostic/outils/vignettes.py data/PS_DES_COUDRES/
|
||||
--capteurs REF_G,REF_D --heures 2026-10-13T22:00Z,2026-10-14T02:00Z [--rayon 100] [--contraste [MIN,MAX]] [--sortie DOSSIER]
|
||||
Une ligne par capteur, une colonne par heure. Chaque vignette est centrée sur la position brute (x, y) du capteur
|
||||
Une ligne par capteur, une colonne par heure. Quand il n'y a pas d'image à l'heure demandée, la plus proche est
|
||||
prise : l'écart est imprimé et l'heure réelle de l'image est dans le titre de la vignette. Chaque vignette est centrée sur la position brute (x, y) du capteur
|
||||
dans l'export « advanced », lue à la mesure la plus proche de l'image ; les pixels ne sont pas retouchés, l'éclat
|
||||
se compare donc d'une vignette à l'autre. Imprime les positions utilisées, le fond (médiane des pixels de la
|
||||
vignette), le 99e centile et le pic (maximum) du niveau de gris de chaque vignette (0 à 255), puis le chemin du PNG.
|
||||
@@ -49,24 +50,26 @@ def main():
|
||||
absents = [s for s in noms if s not in par]
|
||||
if absents:
|
||||
sys.exit(f"Capteurs inconnus : {', '.join(absents)}. Connus : {', '.join(sorted(par))}.")
|
||||
sans_image = [iso(h) for h in heures if h not in images]
|
||||
if sans_image:
|
||||
connues = sorted(h for h in images if h)
|
||||
sys.exit(f"Pas d'image à {', '.join(sans_image)}. Images : {len(connues)}, "
|
||||
f"de {iso(connues[0])} à {iso(connues[-1])}." if connues else f"Aucune image dans {o.dossier}.")
|
||||
connues = sorted(h for h in images if h)
|
||||
if not connues:
|
||||
sys.exit(f"Aucune image dans {o.dossier}.")
|
||||
proche = {h: min(connues, key=lambda i: abs(i - h)) for h in heures} # image à l'heure demandée, sinon la plus proche
|
||||
for h in heures:
|
||||
if proche[h] != h:
|
||||
print(f"Pas d'image à {iso(h)} : la plus proche est celle de {iso(proche[h])} (écart {abs(proche[h] - h)}).")
|
||||
|
||||
r = o.rayon
|
||||
coupes = {}
|
||||
for j, h in enumerate(heures):
|
||||
img = plt.imread(images[h])
|
||||
img = plt.imread(images[proche[h]])
|
||||
for i, s in enumerate(noms):
|
||||
m = min((m for m in par[s] if m["x"] is not None), key=lambda m: abs(m["t"] - h))
|
||||
m = min((m for m in par[s] if m["x"] is not None), key=lambda m: abs(m["t"] - proche[h]))
|
||||
x, y = round(m["x"]), round(m["y"])
|
||||
c = img[max(y - r, 0):y + r, max(x - r, 0):x + r]
|
||||
gris = c[..., :3].mean(axis=-1) if c.ndim == 3 else c
|
||||
gris = gris * 255 if gris.max() <= 1 and c.dtype.kind == "f" else gris
|
||||
coupes[i, j] = (c, gris)
|
||||
print(f"{s} {iso(h)} : x={m['x']:.1f} y={m['y']:.1f} (mesure de {iso(m['t'])}), {os.path.basename(images[h])}, "
|
||||
print(f"{s} {iso(h)} : x={m['x']:.1f} y={m['y']:.1f} (mesure de {iso(m['t'])}), {os.path.basename(images[proche[h]])}, "
|
||||
f"fond {centile(gris, 50):.0f}, p99 {centile(gris, 99):.0f}, pic {gris.max():.0f}")
|
||||
bornes = {}
|
||||
if o.contraste:
|
||||
@@ -82,7 +85,7 @@ def main():
|
||||
ax.imshow(gris, cmap="gray", interpolation="nearest", **bornes)
|
||||
else:
|
||||
ax.imshow(c, interpolation="nearest")
|
||||
ax.set_title(f"{noms[i]} {heures[j].strftime('%d/%m %H:%MZ')}", fontsize=9)
|
||||
ax.set_title(f"{noms[i]} {proche[heures[j]].strftime('%d/%m %H:%MZ')}" + ("" if proche[heures[j]] == heures[j] else " (demandée " + heures[j].strftime('%H:%MZ') + ")"), fontsize=9)
|
||||
ax.set_xticks([])
|
||||
ax.set_yticks([])
|
||||
station = os.path.basename(os.path.normpath(o.dossier))
|
||||
|
||||
Reference in new issue
Block a user