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>
This commit is contained in:
1 parent
6b3d058a67
commit
d5bae7a696
57 files changed
+1727
-157
No files matched your search
@@ -0,0 +1,92 @@
|
||||
"""Essai archivé le 2026-10-24 : version simple de la visibilité (point 11 du plan), moins bonne que la v0 restée en service
|
||||
(detectors/visibilite.py) ; comparaison sur les six jeux : point 11 du plan.
|
||||
|
||||
Journal du matin : visibilité, version simple.
|
||||
|
||||
Une cible est rejetée quand son error_value dépasse son error_threshold. Seules comptent les cibles habituellement vues
|
||||
(sous leur seuil au moins la moitié du temps sur l'export) : une cible que la caméra ne voit presque jamais ne dit rien
|
||||
de la visibilité du moment (PS des Coudres : PM_G ; NIEDERHORN : sept références « e »).
|
||||
1. Poor visibility : au moins NIVEAU des cibles rejetées, sur deux mesures d'affilée ou plus (une mesure plus basse entre
|
||||
deux hautes compte haute : la part rejetée oscille autour du niveau, C-002).
|
||||
2. Brief obstruction : la même chose sur une seule mesure (un passage).
|
||||
3. Target obscured : une cible rejetée la plupart du temps (au moins la moitié de ses mesures), au moins CIBLE_MIN fois à
|
||||
moins de CIBLE_ECART d'écart, quand la station, elle, voit clair.
|
||||
Tous les épisodes sont grisés (ignore = True) ; les labels sont ceux que lit categories.py.
|
||||
Usage : python3 vues-deplacements/detectors/visibilite.py <dossier de station> (affiche les épisodes)
|
||||
"""
|
||||
import os
|
||||
import statistics
|
||||
import sys
|
||||
from datetime import timedelta
|
||||
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "..", "agents", "diagnostic", "outils"))
|
||||
from donnees import charger, iso # noqa: E402
|
||||
|
||||
NIVEAU = 0.2 # provisoire, réglé sur NORDEND d'octobre (buée du 08/10 : 10 à 20 % rejetées), C-002 (toile : 30 à 40 %)
|
||||
# et C-005 (pluie : 30 à 60 %) ; balayé de 0,15 à 0,3 le 2026-10-24
|
||||
CIBLE_MIN = 3 # provisoire : rejets répétés d'une cible (v0)
|
||||
CIBLE_ECART = timedelta(hours=6) # provisoire, réglé sur C-005 (feuilles : 7 rejets en 12 h, jusqu'à 5 h d'écart ; v0)
|
||||
|
||||
|
||||
def _episode(debut, fin, label, capteurs):
|
||||
return {"start": iso(debut), "end": iso(fin), "kind": "visibilite", "label": label, "text": "",
|
||||
"ignore": True, "sensors": sorted(capteurs)}
|
||||
|
||||
|
||||
def detect(mesures):
|
||||
ratios = {} # capteur -> {t: error_value / error_threshold}
|
||||
for s, v in mesures.items():
|
||||
r = {m["t"].replace(second=0, microsecond=0): m["error_value"] / m["error_threshold"]
|
||||
for m in v if m["error_value"] is not None and m["error_threshold"]}
|
||||
if r and statistics.median(r.values()) < 1: # habituellement vue
|
||||
ratios[s] = r
|
||||
instants = sorted({t for r in ratios.values() for t in r})
|
||||
rejetes = {t: {s for s, r in ratios.items() if r.get(t, 0) > 1} for t in instants}
|
||||
vus = {t: sum(t in r for r in ratios.values()) for t in instants}
|
||||
haut = [len(rejetes[t]) >= NIVEAU * vus[t] > 0 for t in instants]
|
||||
for k in range(1, len(instants) - 1): # une mesure basse entre deux hautes
|
||||
haut[k] = haut[k] or (haut[k - 1] and haut[k + 1])
|
||||
out = []
|
||||
|
||||
# 1 et 2 : suites de mesures où la station voit mal ; une seule mesure, c'est un passage.
|
||||
k = 0
|
||||
while k < len(instants):
|
||||
if not haut[k]:
|
||||
k += 1
|
||||
continue
|
||||
j = k
|
||||
while j + 1 < len(instants) and haut[j + 1]:
|
||||
j += 1
|
||||
cs = set().union(*(rejetes[instants[i]] for i in range(k, j + 1)))
|
||||
out.append(_episode(instants[k], instants[j], "Poor visibility" if j > k else "Brief obstruction", cs))
|
||||
k = j + 1
|
||||
|
||||
# 3 : une cible rejetée la plupart du temps pendant que la station voit clair.
|
||||
clair = {t for t, h in zip(instants, haut) if not h}
|
||||
refs = {s for s, v in mesures.items() if v[0]["pattern_type"] == "global_ref"}
|
||||
cibles = []
|
||||
for s, r in ratios.items():
|
||||
if s in refs:
|
||||
continue
|
||||
ts = [t for t in sorted(r) if t in clair and r[t] > 1]
|
||||
groupe = ts[:1]
|
||||
for t in ts[1:] + [None]:
|
||||
if t is not None and t - groupe[-1] <= CIBLE_ECART:
|
||||
groupe.append(t)
|
||||
continue
|
||||
mesurees = [u for u in r if groupe and groupe[0] <= u <= groupe[-1]]
|
||||
if len(groupe) >= CIBLE_MIN and 2 * len(groupe) >= len(mesurees):
|
||||
cibles.append((groupe[0], groupe[-1], s))
|
||||
groupe = [t]
|
||||
for a, b, s in sorted(cibles): # les cibles masquées en même temps forment un seul épisode
|
||||
if out and out[-1]["label"] == "Target obscured" and iso(a) <= out[-1]["end"]:
|
||||
out[-1]["end"] = max(out[-1]["end"], iso(b))
|
||||
out[-1]["sensors"] = sorted(set(out[-1]["sensors"]) | {s})
|
||||
else:
|
||||
out.append(_episode(a, b, "Target obscured", {s}))
|
||||
return sorted(out, key=lambda e: e["start"])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
for e in detect(charger(sys.argv[1])):
|
||||
print(e["start"], "→", e["end"], e["label"], f"| {len(e['sensors'])} :", ",".join(e["sensors"][:8]))
|
||||
@@ -0,0 +1,191 @@
|
||||
"""Journal du matin : des épisodes des détecteurs aux événements catégorisés (point 6 du plan ; catégories validées le
|
||||
2026-10-24 : docs/displacement/domaine/carte-des-evenements.md, section 4).
|
||||
|
||||
Chaque épisode reçoit sa catégorie d'après son détecteur et son label. Un saut revenu à la normale qui chevauche une
|
||||
perte de visibilité, un passage ou une turbulence y est absorbé ; un saut qui dure ou trop récent pour savoir ne l'est
|
||||
jamais ; une turbulence qui chevauche un saut à vérifier n'est pas gardée (un vrai mouvement agite aussi les courbes :
|
||||
le matin du mouvement de CLARIDEN, point 14 du plan). Deux événements de même catégorie à moins d'une heure n'en font
|
||||
qu'un. Chaque événement reçoit sa phrase
|
||||
(point 9, validées le 2026-10-24) : ce qui s'est passé et quoi en faire, sans conditionnel ; la cause n'est dite que si la
|
||||
catégorie l'établit, sinon les images la montrent. Pas de fonction detect : le chargeur ne prend pas ce fichier pour un
|
||||
détecteur.
|
||||
Usage : python3 vues-deplacements/detectors/categories.py <dossier de station> (une ligne par événement)
|
||||
... <dossier> [--du AAAA-MM-JJ] [--au AAAA-MM-JJ] [--tranche 3] [--historique N] (tri en lot, point 30 :
|
||||
chaque tranche de 3 jours classée seule, avec les jours d'historique d'avant s'ils existent ; seuls les événements
|
||||
qui touchent la tranche sont montrés ; « rien » pour une tranche calme)
|
||||
"""
|
||||
import importlib.util
|
||||
import os
|
||||
import sys
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from pathlib import Path
|
||||
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "agents", "diagnostic", "outils"))
|
||||
from donnees import charger, iso # noqa: E402
|
||||
|
||||
# ignore : zone grisée (None : comme le dit le détecteur, la turbulence n'est grisée que forte) ; process : bouton
|
||||
# Images, rien, ou Images et lien vers Diagnosis. L'ordre est celui des lignes de la frise.
|
||||
CATEGORIES = {
|
||||
"visibilite_reduite": {"label": "Reduced visibility", "ignore": False, "process": "images"}, # en retrait (point 38)
|
||||
"visibilite_nulle": {"label": "No visibility", "ignore": True, "process": "images"},
|
||||
"passage": {"label": "Passing obstacle", "ignore": True, "process": "images"},
|
||||
"cible_masquee": {"label": "Target hidden", "ignore": True, "process": "images"},
|
||||
"turbulence": {"label": "Heat haze", "ignore": None, "process": "aucun"},
|
||||
"dilatation_thermique": {"label": "Thermal expansion", "ignore": False, "process": "aucun"}, # effet périodique
|
||||
"contraction_thermique": {"label": "Thermal contraction", "ignore": False, "process": "aucun"}, # (point 41)
|
||||
"trou": {"label": "No data", "ignore": False, "process": "aucun"},
|
||||
"saut_bref": {"label": "Brief jump", "ignore": True, "process": "images"},
|
||||
"a_verifier": {"label": "Shift to check", "ignore": False, "process": "verifier"},
|
||||
}
|
||||
# (détecteur, label, niveau de l'épisode) -> catégorie ; puis détecteur seul ; un détecteur inconnu garde son nom
|
||||
LABELS = {("visibilite", "Poor visibility", "reduced"): "visibilite_reduite",
|
||||
("visibilite", "Poor visibility", "none"): "visibilite_nulle",
|
||||
("visibilite", "Brief obstruction", None): "passage", ("visibilite", "Target obscured", None): "cible_masquee",
|
||||
("sauts", "Sudden jump, back to normal", None): "saut_bref", ("sauts", "Lasting shift", None): "a_verifier",
|
||||
("sauts", "Jump, not back yet", None): "a_verifier",
|
||||
("thermique", "Thermal expansion", None): "dilatation_thermique",
|
||||
("thermique", "Thermal contraction", None): "contraction_thermique"}
|
||||
KINDS = {"turbulence": "turbulence", "trous": "trou"}
|
||||
HOSTS = {"visibilite_reduite", "visibilite_nulle", "passage", "turbulence"} # absorbent un saut revenu (point 5)
|
||||
MERGE = timedelta(hours=1) # même catégorie à moins d'une heure : un seul événement (point 5, 2026-10-24)
|
||||
|
||||
|
||||
def detecteurs():
|
||||
"""Modules de vues-deplacements/detectors/*.py qui ont detect ; un fichier qui ne se charge pas est sauté avec un
|
||||
message."""
|
||||
mods = []
|
||||
for path in sorted(Path(__file__).resolve().parent.glob("*.py")):
|
||||
if path == Path(__file__).resolve():
|
||||
continue
|
||||
try:
|
||||
spec = importlib.util.spec_from_file_location(f"journal_{path.stem}", path)
|
||||
mod = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(mod)
|
||||
except Exception as e: # noqa: BLE001 (prototype : un détecteur cassé ne bloque pas la page)
|
||||
print(f"Journal : {path.name} sauté ({type(e).__name__}: {e})", file=sys.stderr)
|
||||
continue
|
||||
if hasattr(mod, "detect"):
|
||||
mods.append(mod)
|
||||
return mods
|
||||
|
||||
|
||||
def categorie(ep):
|
||||
return LABELS.get((ep["kind"], ep["label"], ep.get("level"))) or KINDS.get(ep["kind"]) or ep["kind"]
|
||||
|
||||
|
||||
def overlap(a, b):
|
||||
return a["start"] <= b["end"] and a["end"] >= b["start"] # heures donnees.iso : l'ordre du texte est celui du temps
|
||||
|
||||
|
||||
def targets(n):
|
||||
return "one target" if n == 1 else f"{n} targets"
|
||||
|
||||
|
||||
def phrase(cat, groupe, sensors, references):
|
||||
"""Phrase du journal d'un événement (validées par l'utilisateur le 2026-10-24) ; un saut absorbé ajoute qu'il n'est
|
||||
pas un mouvement."""
|
||||
n, one = len(sensors), len(sensors) == 1
|
||||
sauts = [e for e in groupe[1:] if categorie(e) == "saut_bref"]
|
||||
jumped = len({s for e in sauts for s in e["sensors"]})
|
||||
lasting = len({s for e in groupe if categorie(e) == "a_verifier" for s in e.get("lasting", [])})
|
||||
refs = ", including the reference targets" if references & set(sensors) else ""
|
||||
text = {
|
||||
"visibilite_nulle": f"The camera could not see {targets(n)} clearly{refs}. "
|
||||
"The curves in this period are not reliable: ignore them.",
|
||||
"visibilite_reduite": f"The camera saw {targets(n)} less clearly than usual{refs}. "
|
||||
"The data in this period are less precise: use them with care.",
|
||||
"passage": f"Something passed in front of {targets(n)} for a single measurement. Ignore this point on the curves.",
|
||||
"cible_masquee": f"{', '.join(sensors)} {'was' if one else 'were'} hidden several times while the targets around "
|
||||
f"{'it' if one else 'them'} stayed clear. Ignore {'its curve' if one else 'their curves'} in this period.",
|
||||
"turbulence": "Warm air made the readings shake. The small fast wiggles are not movement.",
|
||||
"dilatation_thermique": "The structure expands in the day heat. This daily wave is normal: nothing to do.",
|
||||
"contraction_thermique": "The structure contracts as it cools down. This daily wave is normal: nothing to do.",
|
||||
"saut_bref": f"{targets(n).capitalize()} jumped and came back. This is not a movement: ignore it.",
|
||||
"a_verifier": (f"{targets(n).capitalize()} shifted and {'has' if one else 'have'} not come back yet." if not lasting
|
||||
else f"{targets(n).capitalize()} shifted and stayed shifted." if lasting == n
|
||||
else f"{targets(n).capitalize()} shifted; {lasting} of them stayed shifted.")
|
||||
+ " Check whether the structure moved: look at the images.",
|
||||
}.get(cat, groupe[0]["text"]) # trou, et un détecteur inconnu : le texte du détecteur
|
||||
if not jumped:
|
||||
return text
|
||||
return text + (f" The jump of {targets(jumped)} in this period is not a movement." if len(sauts) == 1
|
||||
else f" The jumps of {targets(jumped)} in this period are not movements.")
|
||||
|
||||
|
||||
def evenement(groupe, references):
|
||||
"""Épisodes d'un même événement, le principal en tête -> événement."""
|
||||
cat = categorie(groupe[0])
|
||||
c = CATEGORIES.get(cat, {"label": groupe[0]["label"], "ignore": None, "process": "aucun"})
|
||||
sensors = [] if any(not e["sensors"] for e in groupe) else list(dict.fromkeys(s for e in groupe for s in e["sensors"]))
|
||||
main = [e for e in groupe if categorie(e) == cat] # la durée est celle des épisodes principaux, pas des sauts absorbés
|
||||
return {"start": min(e["start"] for e in main), "end": max(e["end"] for e in main), "category": cat,
|
||||
"label": c["label"], "text": phrase(cat, groupe, sensors, references),
|
||||
"ignore": c["ignore"] if c["ignore"] is not None else any(e["ignore"] for e in groupe if categorie(e) == cat),
|
||||
"sensors": sensors, "process": c["process"], "episodes": groupe}
|
||||
|
||||
|
||||
def classer(episodes, references=frozenset()):
|
||||
"""Épisodes de tous les détecteurs -> événements triés par début (règles : docstring du module) ; references : les
|
||||
capteurs global_ref, pour la phrase."""
|
||||
eps = sorted(episodes, key=lambda e: e["start"])
|
||||
checks = [e for e in eps if categorie(e) == "a_verifier"] # un vrai mouvement n'est jamais pris pour de la turbulence
|
||||
eps = [e for e in eps if categorie(e) != "turbulence" or not any(overlap(e, c) for c in checks)]
|
||||
hosts = [e for e in eps if categorie(e) in HOSTS]
|
||||
host = {id(e): next((h for h in hosts if overlap(e, h)), None) for e in eps if categorie(e) == "saut_bref"}
|
||||
groupes = {id(e): [e] for e in eps if not host.get(id(e))}
|
||||
for e in eps:
|
||||
if host.get(id(e)):
|
||||
groupes[id(host[id(e)])].append(e)
|
||||
merged = []
|
||||
for g in groupes.values():
|
||||
prev = next((m for m in reversed(merged) if categorie(m[0]) == categorie(g[0])), None)
|
||||
end = max((e["end"] for e in prev if categorie(e) == categorie(g[0])), default=None) if prev else None
|
||||
if end and datetime.fromisoformat(g[0]["start"]) - datetime.fromisoformat(end) < MERGE:
|
||||
prev += g
|
||||
else:
|
||||
merged.append(g)
|
||||
return sorted((evenement(g, references) for g in merged), key=lambda v: v["start"])
|
||||
|
||||
|
||||
def evenements(mesures):
|
||||
"""Mesures (donnees.charger) -> événements de tous les détecteurs : ce que la page reçoit dans D.journal."""
|
||||
episodes = []
|
||||
for mod in detecteurs():
|
||||
try:
|
||||
episodes += mod.detect(mesures)
|
||||
except Exception as e: # noqa: BLE001
|
||||
print(f"Journal : {mod.__name__} sauté ({type(e).__name__}: {e})", file=sys.stderr)
|
||||
return classer(episodes, {s for s, ms in mesures.items() if ms[0]["pattern_type"] == "global_ref"})
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
import argparse
|
||||
p = argparse.ArgumentParser(description="Une ligne par événement ; --tranche : chaque tranche classée seule.")
|
||||
p.add_argument("dossier")
|
||||
p.add_argument("--du", help="premier jour UTC, AAAA-MM-JJ (défaut : début des données)")
|
||||
p.add_argument("--au", help="dernier jour UTC exclu, AAAA-MM-JJ (défaut : fin des données)")
|
||||
p.add_argument("--tranche", type=int, default=0, help="jours par tranche (défaut : un seul passage)")
|
||||
# sans historique, une tranche qui commence juste avant un vrai saut le prend pour un saut revenu (PR17 à NORDEND,
|
||||
# le 08/10 à 02:30 : absorbé dans la buée) ; 3 jours le rendent ; règle de l'utilisateur (2026-10-24) : 3 jours
|
||||
# d'historique par défaut, dans la boucle comme dans la vraie application
|
||||
p.add_argument("--historique", type=int, default=3, help="jours de mesures d'avant donnés aux détecteurs (défaut 3)")
|
||||
a = p.parse_args()
|
||||
mesures = charger(a.dossier)
|
||||
ts = [m["t"] for ms in mesures.values() for m in ms]
|
||||
jour = lambda d: datetime.strptime(d, "%Y-%m-%d").replace(tzinfo=timezone.utc) # noqa: E731
|
||||
debut = jour(a.du) if a.du else min(ts).replace(hour=0, minute=0, second=0, microsecond=0)
|
||||
fin = jour(a.au) if a.au else max(ts) + timedelta(seconds=1)
|
||||
t = debut
|
||||
while t < fin:
|
||||
b = min(t + timedelta(days=a.tranche), fin) if a.tranche else fin
|
||||
h = t - timedelta(days=a.historique)
|
||||
tranche = {s: k for s, ms in mesures.items() if (k := [m for m in ms if h <= m["t"] < b])}
|
||||
evs = [v for v in evenements(tranche) if v["end"] >= iso(t)] if tranche else []
|
||||
if a.tranche:
|
||||
print(f"== {iso(t)} → {iso(b)} : {len(evs) or 'rien'}")
|
||||
for v in evs:
|
||||
print(v["start"], "→", v["end"], f"{v['category']:<17}", "grisé" if v["ignore"] else "gardé",
|
||||
f"| {v['episodes'][0]['kind']}", # le détecteur, pour que l'analyste le nomme (boucle, 2026-10-26)
|
||||
f"| {len(v['sensors']) or 'tous les'} capteurs", "| absorbés :", ", ".join(
|
||||
f"{e['kind']} {e['start'][5:16]}" for e in v["episodes"][1:]) or "—")
|
||||
t = b
|
||||
@@ -0,0 +1,146 @@
|
||||
"""Sauts brutaux du journal du matin : corr_x / corr_y (px) de chaque cible, cadence native de l'export « advanced ».
|
||||
|
||||
1. Bruit de la série = médiane des écarts d'une mesure à la suivante ; saut = mesure à K bruits ou plus du niveau
|
||||
d'avant (médiane des BASE mesures précédentes) ; les BASE premières mesures, faute de niveau d'avant, face au niveau
|
||||
d'après (médiane des BASE suivantes), un écart y est un saut revenu aussitôt (point 12 du plan, 2026-10-24).
|
||||
2. Revenu (BASE mesures de suite à moins de la moitié du saut) en moins d'un jour, ou un jour après de retour à sa place
|
||||
habituelle (premier jour de l'export) ou du jour d'avant : « Sudden jump, back to normal », grisé (artefact).
|
||||
3. Sinon « Lasting shift », jamais grisé (peut-être un vrai mouvement) ; moins d'un jour de recul :
|
||||
« Jump, not back yet », pas grisé non plus.
|
||||
4. Les sauts qui se suivent à moins d'une heure, toutes cibles confondues, font un seul épisode (mode commun) ;
|
||||
une seule cible durable (ou trop récente) suffit à ne pas griser l'épisode.
|
||||
5. Références globales exclues ; mesures rejetées (corr vides) sautées.
|
||||
6. Pic commun (lot 01 de la boucle NORDEND, 2026-10-26) : au même instant, au moins PIC_MIN cibles s'écartent d'au moins
|
||||
K_PIC bruits de leurs deux mesures voisines, du même côté (toute l'image secouée un pas) : un saut revenu pour chacune,
|
||||
même sous K. Il entre dans les épisodes du point 4 (près d'un saut durable, il ne grise rien).
|
||||
|
||||
Résultats (2026-10-23, K = 20) :
|
||||
- C-001 PS des Coudres : rien (vérité : rien côté sauts).
|
||||
- C-002 NORDEND juillet : grisés 28/07 21:00 → 29/07 10:45 (18 cibles) et 30/07 13:30 → 31/07 01:15 (18) ; toile revenue
|
||||
31/07 20:30 : « not back yet » (13 cibles, 1 h avant la fin des données).
|
||||
- C-003 WILDSTRUBEL : un saut d'un pas grisé, 04/09 06:45 (le C2 de la fiche) ; les autres sont sur des références
|
||||
ou rejetés.
|
||||
- C-004 CLARIDEN : « Lasting shift » 19/09 06:10, 18 cibles, non grisé ; faux positif probable : une cible agitée seule,
|
||||
18/09 15:40, non grisé ; la dérive de nuit de corr_x (lente) n'est pas un saut.
|
||||
- C-005 NIEDERHORN : train du 01/10 12:00 grisé (1 cible sur 3 : les deux autres à 17 et 19 bruits) ; train du
|
||||
30/09 22:00 vu depuis le 2026-10-24 (2 cibles, première mesure de l'export) ; feuilles, pluie : rien (error_value, pas
|
||||
des sauts). Les trains sont de toute façon attrapés par visibilite (« Passing obstacle ») et le classement y absorbe
|
||||
leurs sauts : ne pas baisser K pour eux (point 12 du plan).
|
||||
- NORDEND octobre : PR17 seule en « Lasting shift » le 08/10 02:30 ; cinq épisodes communs grisés (07/10 19:45,
|
||||
08/10 07:15, 09/10 08:45 et 21:15, 14/10 05:15 : 4 à 15 cibles, aller-retour en moins de 5 h) ; PR15 08/10 04:45,
|
||||
un instant grisé.
|
||||
Pic commun (K_PIC = 6, PIC_MIN = 3, 2026-10-26) : NORDEND, lot du 01 au 04/09 : secousses du 03/09 13:30 (3 cibles) et
|
||||
16:45 (4) grisées, aussi 01/09 15:45 → 16:00 et 02/09 09:45, mêmes secousses d'un pas pendant la bascule de la caméra ;
|
||||
NORDEND octobre : un pic de 3 cibles le 13/10 12:30, et PR17 (08/10 02:30) groupé avec le pic de 02:15, « 3 targets,
|
||||
1 stayed shifted », toujours non grisé ; C-002, C-005 : pics absorbés par la toile et les trains ; C-004 : les pics du
|
||||
mouvement (19/09 06:30, 06:50) restent dans le « Lasting shift » ; C-001, C-003 : rien.
|
||||
"""
|
||||
import statistics
|
||||
import sys
|
||||
from datetime import timedelta
|
||||
from pathlib import Path
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "agents" / "diagnostic" / "outils"))
|
||||
import donnees # noqa: E402
|
||||
|
||||
K = 20 # provisoire, réglé sur C-001 : à 15, deux cibles saines y sont grisées (17 et 18 bruits) ; les trains de
|
||||
# C-005 (17 et 19 bruits) sont attrapés par visibilite : ne pas baisser K
|
||||
K_PIC = 6 # provisoire : pic d'un pas commun à plusieurs cibles (secousses de NORDEND, 6 à 11 bruits, lot 01 de la boucle)
|
||||
PIC_MIN = 3 # provisoire : cibles qui piquent au même pas pour un pic commun (une ou deux : bruit ordinaire)
|
||||
BASE = 4 # mesures qui font le niveau d'avant (1 h à 15 min)
|
||||
GAP = timedelta(hours=1) # deux sauts à moins d'une heure, toutes cibles confondues : un seul épisode
|
||||
BACK_H = 24 # provisoire : retour en moins d'un jour = artefact (C-002 : paliers jusqu'à 11 h 30)
|
||||
|
||||
|
||||
def _sauts(t, v):
|
||||
"""Une série (instants, valeurs) -> [(i début, i fin, état)], état 'back', 'lasting' ou 'recent'."""
|
||||
day = timedelta(hours=BACK_H)
|
||||
noise = statistics.median(abs(y - x) for x, y in zip(v, v[1:]))
|
||||
# ponytail: place habituelle = premier jour de l'export, faux s'il commence dans un artefact
|
||||
ref = statistics.median(x for x, u in zip(v, t) if u < t[0] + day)
|
||||
# les BASE premières mesures, faute de niveau d'avant, face au niveau d'après : un écart y est revenu aussitôt
|
||||
out = [(k, k, "back") for k in range(min(BASE, len(v) - BASE))
|
||||
if noise and abs(v[k] - statistics.median(v[k + 1:k + 1 + BASE])) >= K * noise]
|
||||
i = BASE
|
||||
while noise and i < len(v):
|
||||
base = statistics.median(v[i - BASE:i])
|
||||
if abs(v[i] - base) < K * noise:
|
||||
i += 1
|
||||
continue
|
||||
tol = abs(v[i] - base) / 2 # revenu : BASE mesures de suite à moins de la moitié du saut du niveau d'avant
|
||||
j = next((k for k in range(i + 1, len(v)) if all(abs(x - base) < tol for x in v[k:k + BASE])), len(v))
|
||||
before = statistics.median([x for x, u in zip(v, t) if t[i] - day <= u < t[i]] or [base])
|
||||
after = statistics.median(x for x, u in zip(v, t) if t[i] <= u < t[i] + day)
|
||||
if j < len(v) and t[j] - t[i] <= day:
|
||||
state = "back"
|
||||
elif abs(after - ref) < tol or abs(after - before) < tol: # le jour d'après, la cible est à sa place
|
||||
state, j = "back", i + 1 # habituelle, ou là où elle était le jour d'avant : le saut finissait un creux
|
||||
else:
|
||||
state = "lasting" if t[-1] - t[i] >= day else "recent" # moins d'un jour de recul : on ne sait pas encore
|
||||
out.append((i, j - 1, state))
|
||||
i = j + BASE # niveau d'avant refait après le retour
|
||||
return out
|
||||
|
||||
|
||||
def _pics(t, v):
|
||||
"""Instants où la mesure s'écarte d'au moins K_PIC bruits de ses deux voisines, du même côté (pic d'un pas)."""
|
||||
noise = statistics.median(abs(y - x) for x, y in zip(v, v[1:]))
|
||||
return [t[i] for i in range(1, len(v) - 1) if noise and (v[i] - v[i - 1]) * (v[i] - v[i + 1]) > 0
|
||||
and min(abs(v[i] - v[i - 1]), abs(v[i] - v[i + 1])) >= K_PIC * noise]
|
||||
|
||||
|
||||
def detect(mesures):
|
||||
"""{capteur: [mesure]} (donnees.charger) -> épisodes du journal, triés par début."""
|
||||
found = [] # (début, fin, état, capteur)
|
||||
pics = {} # instant -> cibles qui y font un pic d'un pas
|
||||
for name, ms in mesures.items():
|
||||
if donnees.est_reference(ms):
|
||||
continue
|
||||
for axe in ("corr_x", "corr_y"):
|
||||
kept = [m for m in ms if m[axe] is not None]
|
||||
if len(kept) <= BASE:
|
||||
continue
|
||||
t, v = [m["t"] for m in kept], [m[axe] for m in kept]
|
||||
# un saut qui n'est pas revenu finit avec lui-même, pas avec les données (sa barre cachait les autres)
|
||||
found += [(t[a], t[b] if state == "back" else t[a], state, name) for a, b, state in _sauts(t, v)]
|
||||
for u in _pics(t, v):
|
||||
pics.setdefault(u, set()).add(name)
|
||||
found += [(u, u, "back", s) for u, cs in pics.items() if len(cs) >= PIC_MIN for s in cs] # pic commun : revenu
|
||||
groups = [] # un saut qui n'est pas revenu ne compte que par son instant : sa fin est souvent celle des données
|
||||
for s, e, state, name in sorted(found):
|
||||
if groups and s <= groups[-1]["until"] + GAP:
|
||||
g = groups[-1]
|
||||
else:
|
||||
g = {"start": s, "end": e, "until": s, "sensors": {}}
|
||||
groups.append(g)
|
||||
g["end"], g["until"] = max(g["end"], e), max(g["until"], e if state == "back" else s)
|
||||
g["sensors"].setdefault(name, set()).add(state)
|
||||
return [_episode(g) for g in groups]
|
||||
|
||||
|
||||
def _episode(g):
|
||||
"""Un groupe -> épisode du journal ; un seul saut durable (ou trop récent) suffit à ne pas griser."""
|
||||
n = len(g["sensors"])
|
||||
lasting = sum("lasting" in st for st in g["sensors"].values())
|
||||
recent = any("recent" in st for st in g["sensors"].values())
|
||||
who = "One target" if n == 1 else f"{n} targets together (a single event)"
|
||||
if lasting:
|
||||
label = "Lasting shift"
|
||||
some = "" if lasting == n else f", {lasting} of them stayed shifted for more than a day"
|
||||
text = (f"{who} jumped{some}" if some else f"{who} jumped and stayed shifted for more than a day") + \
|
||||
": this may be a real movement, please check it."
|
||||
elif recent:
|
||||
label = "Jump, not back yet"
|
||||
text = f"{who} jumped less than a day before the last measurement and has not come back yet: check again later."
|
||||
else:
|
||||
label = "Sudden jump, back to normal"
|
||||
text = f"{who} jumped and came back within a day: most likely a measurement artefact, not a movement."
|
||||
return {"start": donnees.iso(g["start"]), "end": donnees.iso(g["end"]), "kind": "sauts", "label": label,
|
||||
"text": text, "ignore": not lasting and not recent, "sensors": sorted(g["sensors"]),
|
||||
"lasting": sorted(s for s, st in g["sensors"].items() if "lasting" in st)} # restées décalées (phrase du journal)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
for ep in detect(donnees.charger(sys.argv[1])):
|
||||
print(ep["start"], ep["end"], "ignore" if ep["ignore"] else "KEEP ", ep["label"], "|", len(ep["sensors"]),
|
||||
",".join(ep["sensors"][:6]), "|", ep["text"])
|
||||
@@ -0,0 +1,185 @@
|
||||
"""Journal du matin : effet périodique, la vague quotidienne des déplacements corrigés (dilatation le jour, contraction
|
||||
le soir : l'utilisateur, 2026-10-24 ; point 41 du plan).
|
||||
|
||||
Méthode, par cible (hors références globales) et par axe (corr_x, corr_y) :
|
||||
1. Chaque jour UTC d'au moins 20 h : moyenne de chaque heure moins la médiane du jour (enlève sauts et dérive).
|
||||
2. Profil = médiane, heure par heure, sur les jours ; « répétabilité » = médiane, sur les jours, de la corrélation
|
||||
entre le jour et le profil des autres jours. Axe concerné si répétabilité ≥ 0,6.
|
||||
3. Cycle de la station si au moins la moitié des cibles ont un axe concerné, **et** (seconde méthode, demandée par
|
||||
l'utilisateur) si une sinusoïde de 24 h, a + b·sin(2πt/24 h) + c·cos(2πt/24 h) par moindres carrés, explique au
|
||||
moins R2_MIN de la courbe d'un axe pour au moins la moitié des cibles.
|
||||
4. Heures chaudes : niveau de nuit = médiane des 8 heures consécutives les plus plates du profil ; une heure est
|
||||
chaude si, en médiane sur les axes concernés, le profil s'en écarte d'au moins 0,3 fois son amplitude.
|
||||
5. Deux épisodes par jour complet qui ressemble aux autres (corrélation médiane ≥ 0,5 sur les axes concernés) :
|
||||
« Thermal expansion » de la première heure chaude à l'heure du plus grand écart au niveau de nuit, puis « Thermal
|
||||
contraction » jusqu'à la fin de la dernière heure chaude. Le sens (une courbe qui monte ou qui descend) dépend de la
|
||||
direction de la cible : on ne le regarde pas, seulement l'écart au niveau de nuit.
|
||||
Sinusoïde (2026-10-24), axes des courbes corrigées où elle explique ≥ 30 % : PS des Coudres 14/22, NORDEND d'octobre
|
||||
0/38, juillet 1/38, WILDSTRUBEL 1/14, CLARIDEN 0/48, NIEDERHORN 14/40 (3 jours, deux nuits de pluie aux mêmes heures,
|
||||
écarté par la première méthode) ; PS des Coudres seule a son effet périodique, 5 jours, dilatation puis contraction.
|
||||
|
||||
Résultats (2026-10-23 ; « cibles » = part des cibles concernées, amplitude = médiane max − min du profil, en px) :
|
||||
| Jeu | corr (ce que voit le client) | x, y bruts |
|
||||
|---|---|---|
|
||||
| PS_DES_COUDRES | 11/11 cibles, 0,17 px, 08-17 h, 5 épisodes | 12/12, 0,55 px, 08-16 h |
|
||||
| NORDEND (juillet, C-002) | 2/18, rien | 18/19, 1,8 px, 06-18 h |
|
||||
| WILDSTRUBEL (C-003) | 3/7, rien | 6/7, 3,2 px, 04-08 h |
|
||||
| CLARIDEN (C-004) | 1/24, rien | 1/24, aucun cycle |
|
||||
| NIEDERHORN (C-005, horaire) | 3/11, rien | 19/30, 4,6 px, ~12 h |
|
||||
| cas 2026-10_NORDEND (11 j) | 9/19, 0,02 px, 08-17 h, sous le seuil (PART = 0,4 : 8 épisodes, sans 08 ni 09/10) | 17/19, 0,78 px, 09-17 h |
|
||||
Lecture : le cycle est presque partout dans les positions brutes (mode commun) et la compensation l'enlève,
|
||||
sauf à PS des Coudres où il reste dans corr, de même forme que dans les positions brutes.
|
||||
"""
|
||||
import math
|
||||
import os
|
||||
import statistics
|
||||
import sys
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "agents", "diagnostic", "outils"))
|
||||
from donnees import charger, iso # noqa: E402
|
||||
|
||||
HEURES_MIN = 20 # provisoire : un jour UTC compte s'il a au moins 20 heures mesurées
|
||||
REPRO = 0.6 # provisoire : un axe a un cycle si chaque jour ressemble aux autres (bruit pur ≈ 0)
|
||||
PART = 0.5 # provisoire : part des cibles concernées ; 2026-10_NORDEND est juste dessous (9/19)
|
||||
CHAUD = 0.3 # provisoire : écart au niveau de nuit, en part de l'amplitude du profil
|
||||
JOUR = 0.5 # provisoire : ressemblance d'un jour aux autres pour lui donner son épisode
|
||||
NUIT = 8 # heures consécutives du profil les plus plates = niveau de nuit
|
||||
R2_MIN = 0.3 # provisoire, ébauche du 2026-10-24 : PS des Coudres 14 axes sur 22 au-dessus, CLARIDEN 0 sur 48
|
||||
W = 2 * math.pi / 86400 # pulsation d'un cycle de 24 h, en rad/s
|
||||
|
||||
|
||||
def _corr(a, b):
|
||||
ma, mb = statistics.mean(a), statistics.mean(b)
|
||||
num = sum((x - ma) * (y - mb) for x, y in zip(a, b))
|
||||
den = (sum((x - ma) ** 2 for x in a) * sum((y - mb) ** 2 for y in b)) ** 0.5
|
||||
return num / den if den else 0.0
|
||||
|
||||
|
||||
def _axe(ms, col):
|
||||
"""-> (profil sur 24 h, {jour: corrélation au profil des autres jours}) ou None."""
|
||||
jours = {}
|
||||
for m in ms:
|
||||
if m[col] is not None:
|
||||
jours.setdefault(m["t"].date(), {}).setdefault(m["t"].hour, []).append(m[col])
|
||||
J = {}
|
||||
for d, hs in jours.items():
|
||||
if len(hs) >= HEURES_MIN:
|
||||
med = statistics.median(v for l in hs.values() for v in l)
|
||||
J[d] = {h: statistics.mean(l) - med for h, l in hs.items()}
|
||||
if len(J) < 2:
|
||||
return None
|
||||
profil = [statistics.median(q[h] for q in J.values() if h in q) for h in range(24) if any(h in q for q in J.values())]
|
||||
if len(profil) < 24:
|
||||
return None
|
||||
ressemblance = {}
|
||||
for d, p in J.items():
|
||||
autres = [q for e, q in J.items() if e != d]
|
||||
hs = [h for h in p if all(h in q for q in autres)]
|
||||
ressemblance[d] = _corr([p[h] for h in hs], [statistics.median(q[h] for q in autres) for h in hs])
|
||||
return profil, ressemblance
|
||||
|
||||
|
||||
def sinus_r2(ms, col):
|
||||
"""Part de la courbe expliquée par une sinusoïde de 24 h (moindres carrés, 3 inconnues), ou None si trop court."""
|
||||
pts = [(m["t"].timestamp(), m[col]) for m in ms if m[col] is not None]
|
||||
if len(pts) <= 48:
|
||||
return None
|
||||
rows = [(1.0, math.sin(W * t), math.cos(W * t)) for t, _ in pts]
|
||||
A = [[sum(r[i] * r[j] for r in rows) for j in range(3)] for i in range(3)]
|
||||
B = [sum(r[i] * y for r, (_, y) in zip(rows, pts)) for i in range(3)]
|
||||
for i in range(3): # élimination de Gauss
|
||||
for k in range(i + 1, 3):
|
||||
f = A[k][i] / A[i][i]
|
||||
A[k] = [x - f * y for x, y in zip(A[k], A[i])]
|
||||
B[k] -= f * B[i]
|
||||
x = [0.0] * 3
|
||||
for i in (2, 1, 0):
|
||||
x[i] = (B[i] - sum(A[i][j] * x[j] for j in range(i + 1, 3))) / A[i][i]
|
||||
m = statistics.mean(y for _, y in pts)
|
||||
sst = sum((y - m) ** 2 for _, y in pts)
|
||||
sse = sum((y - sum(c * v for c, v in zip(x, r))) ** 2 for r, (_, y) in zip(rows, pts))
|
||||
return 1 - sse / sst if sst else None
|
||||
|
||||
|
||||
def sinus(mesures, cols=("corr_x", "corr_y")):
|
||||
"""-> (cibles dont un axe suit une sinusoïde de 24 h, cibles évaluées)."""
|
||||
oui, evaluees = set(), set()
|
||||
for s, ms in mesures.items():
|
||||
if ms[0]["pattern_type"] == "global_ref":
|
||||
continue
|
||||
for col in cols:
|
||||
r2 = sinus_r2(ms, col)
|
||||
if r2 is not None:
|
||||
evaluees.add(s)
|
||||
if r2 >= R2_MIN:
|
||||
oui.add(s)
|
||||
return oui, evaluees
|
||||
|
||||
|
||||
def cycle(mesures, cols=("corr_x", "corr_y")):
|
||||
"""-> (axes concernés [(capteur, col, profil, ressemblance)], nombre de cibles évaluées)."""
|
||||
concernes, cibles = [], set()
|
||||
for s, ms in mesures.items():
|
||||
if ms[0]["pattern_type"] == "global_ref":
|
||||
continue
|
||||
for col in cols:
|
||||
r = _axe(ms, col)
|
||||
if r is None:
|
||||
continue
|
||||
cibles.add(s)
|
||||
if statistics.median(r[1].values()) >= REPRO:
|
||||
concernes.append((s, col) + r)
|
||||
return concernes, len(cibles)
|
||||
|
||||
|
||||
def ecarts(concernes):
|
||||
"""Écart médian (sur les axes concernés) au niveau de nuit, heure par heure, en part de l'amplitude du profil."""
|
||||
def score(p, h):
|
||||
debut = min(range(24), key=lambda i: max(p[(i + k) % 24] for k in range(NUIT)) - min(p[(i + k) % 24] for k in range(NUIT)))
|
||||
nuit = statistics.median(p[(debut + k) % 24] for k in range(NUIT))
|
||||
return abs(p[h] - nuit) / (max(p) - min(p))
|
||||
return [statistics.median(score(c[2], h) for c in concernes) for h in range(24)]
|
||||
|
||||
|
||||
def heures_chaudes(concernes):
|
||||
return [h for h, e in enumerate(ecarts(concernes)) if e >= CHAUD]
|
||||
|
||||
|
||||
def detect(mesures):
|
||||
concernes, n = cycle(mesures)
|
||||
capteurs = sorted({c[0] for c in concernes})
|
||||
if not n or len(capteurs) < PART * n:
|
||||
return []
|
||||
oui, evaluees = sinus(mesures)
|
||||
if not evaluees or len(oui) < PART * len(evaluees): # seconde méthode : la sinusoïde doit le voir aussi
|
||||
return []
|
||||
chaudes = heures_chaudes(concernes)
|
||||
if not chaudes:
|
||||
return []
|
||||
e = ecarts(concernes)
|
||||
pic = max(chaudes, key=lambda h: e[h]) # le plus grand écart au niveau de nuit : fin de la dilatation
|
||||
jours = sorted({d for c in concernes for d in c[3]})
|
||||
episodes = []
|
||||
for d in jours: # ponytail: jours complets seulement, les bouts d'export (22:00 → minuit) n'ont pas d'épisode
|
||||
if statistics.median(c[3][d] for c in concernes if d in c[3]) < JOUR:
|
||||
continue
|
||||
minuit = datetime(d.year, d.month, d.day, tzinfo=timezone.utc)
|
||||
for label, a, b in (("Thermal expansion", chaudes[0], pic), ("Thermal contraction", pic, chaudes[-1] + 1)):
|
||||
if b > a:
|
||||
episodes.append({"start": iso(minuit + timedelta(hours=a)), "end": iso(minuit + timedelta(hours=b)),
|
||||
"kind": "thermique", "label": label, "text": "", "ignore": False, "sensors": capteurs})
|
||||
return episodes
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
mesures = charger(sys.argv[1])
|
||||
for e in detect(mesures):
|
||||
print(e["start"], "→", e["end"], e["label"], len(e["sensors"]), "cibles")
|
||||
for cols in (("corr_x", "corr_y"), ("x", "y")):
|
||||
concernes, n = cycle(mesures, cols)
|
||||
k = len({c[0] for c in concernes})
|
||||
amp = statistics.median(max(c[2]) - min(c[2]) for c in concernes) if concernes else 0
|
||||
oui, evaluees = sinus(mesures, cols)
|
||||
print(f"{cols[0][:-2] or 'brut'} : cibles {k}/{n}, amplitude médiane {amp:.3f} px, heures chaudes (UTC) "
|
||||
f"{heures_chaudes(concernes) if concernes else '-'} ; sinusoïde : cibles {len(oui)}/{len(evaluees)}")
|
||||
@@ -0,0 +1,37 @@
|
||||
"""Journal du matin : moments sans mesure (cadence de l'export « advanced » rompue).
|
||||
|
||||
Cadence : écart médian entre deux instants de mesure, tous capteurs confondus. Un trou : plus de 2 pas manquants entre
|
||||
deux mesures (écart > 3 cadences) ; l'épisode va de la dernière mesure à la suivante. Pas de mesure dans l'export ne
|
||||
veut pas dire station arrêtée (CLAUDE.md) : le texte dit seulement que l'export n'a rien.
|
||||
Usage : python3 vues-deplacements/detectors/trous.py <dossier de station> (affiche les épisodes)
|
||||
"""
|
||||
import os
|
||||
import statistics
|
||||
import sys
|
||||
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "agents", "diagnostic", "outils"))
|
||||
from donnees import charger, iso # noqa: E402
|
||||
|
||||
MISSING = 2 # au-delà de 2 pas manquants, c'est un trou (consigne de l'utilisateur, 2026-10-23)
|
||||
|
||||
|
||||
def duration(s):
|
||||
h, m = divmod(round(s / 60), 60)
|
||||
return f"{h} h {m:02d} min" if h else f"{m} min"
|
||||
|
||||
|
||||
def detect(mesures):
|
||||
ts = sorted({m["t"].replace(second=0, microsecond=0) for ms in mesures.values() for m in ms})
|
||||
if len(ts) < 3:
|
||||
return []
|
||||
gaps = [(b - a).total_seconds() for a, b in zip(ts, ts[1:])]
|
||||
step = statistics.median(gaps)
|
||||
return [{"start": iso(a), "end": iso(b), "kind": "trous", "label": "No data",
|
||||
"text": f"No measurement in the export for {duration(g)} (usually one every {duration(step)}).",
|
||||
"ignore": False, "sensors": []}
|
||||
for a, b, g in zip(ts, ts[1:], gaps) if g > (MISSING + 1) * step]
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
for e in detect(charger(sys.argv[1])):
|
||||
print(e)
|
||||
@@ -0,0 +1,107 @@
|
||||
"""Journal du matin : turbulence atmosphérique (bruit rapide sur les déplacements corrigés).
|
||||
|
||||
Méthode :
|
||||
1. Par capteur et par heure H, sur les mesures de [H − 1 h, H + 2 h) : agitation = médiane de |Δcorr_x| + |Δcorr_y|
|
||||
entre mesures successives (robuste aux sauts d'un seul pas), et médiane de l'error_value.
|
||||
2. Chacune est rapportée au calme du capteur : le quartile bas de ses valeurs horaires sur l'export (souvent la nuit).
|
||||
3. Heure turbulente : au moins la moitié des capteurs à ≥ 1,5 fois leur agitation calme, et error_value médiane
|
||||
des capteurs à ≥ 1,5 fois la calme (l'air chaud brouille les taches : C-003, critère 1).
|
||||
4. Heures voisines fusionnées (trou d'une heure toléré), épisode d'au moins 3 h, écarté si plus de 15 % des mesures
|
||||
sont rejetées (c'est alors de la mauvaise visibilité, autre détecteur). Grisé si l'agitation médiane ≥ 2×.
|
||||
|
||||
Résultats (2026-10-23, seuils ci-dessous) :
|
||||
- WILDSTRUBEL (C-003, vérité : chaque jour ~03:30 → 16:00) : 3 épisodes, 02.09 04:00-15:00, 03.09 05:00-15:00,
|
||||
04.09 04:00-15:00, les 13 capteurs, ×2,3 à ×2,6, tous grisés.
|
||||
- PS_DES_COUDRES (sain, buée une nuit), NORDEND juillet (toile d'araignée), CLARIDEN (mouvement réel),
|
||||
NIEDERHORN (trains, pluie), NORDEND octobre (11 jours) : aucun épisode. Écartés en route : midis agités sans
|
||||
error_value en hausse (PS des Coudres, NORDEND octobre), toile et pluie par les rejets (18 à 43 %), le matin du
|
||||
mouvement de CLARIDEN (06:00-08:00) par la durée.
|
||||
"""
|
||||
import os
|
||||
import statistics
|
||||
import sys
|
||||
from datetime import timedelta
|
||||
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "agents", "diagnostic", "outils"))
|
||||
from donnees import charger, iso # noqa: E402
|
||||
|
||||
RATIO = 1.5 # provisoire, réglé sur C-003 (WILDSTRUBEL : de jour, corr ×1,7 à ×3 la nuit)
|
||||
PART = 0.5 # provisoire : part des capteurs agités en même temps
|
||||
RATIO_ERR = 1.5 # provisoire, réglé sur C-003 (error_value ×1,7 à ×3,2 la nuit ; ≈ ×1 à midi ailleurs)
|
||||
REJET_MAX = 0.15 # provisoire : C-003 ≤ 7 % ; toile d'araignée (C-002) et pluie (C-005) ≥ 18 %
|
||||
FORT = 2.0 # provisoire : C-003 (×2,3 à ×2,6) est fort ; un épisode entre ×1,5 et ×2 reste visible
|
||||
DUREE_MIN = timedelta(hours=3) # provisoire : C-003 dure 10-11 h ; écarte le matin du mouvement réel de C-004 (2 h),
|
||||
# que le classement écarte aussi, quelle que soit la durée (point 14 du plan)
|
||||
HEURE = timedelta(hours=1)
|
||||
|
||||
|
||||
def _heure(t):
|
||||
return t.replace(minute=0, second=0, microsecond=0)
|
||||
|
||||
|
||||
def _rapports(points):
|
||||
"""[(t, valeur)] -> {heure H: médiane sur [H − 1 h, H + 2 h) / quartile bas de ces médianes}."""
|
||||
par = {}
|
||||
for t, v in points:
|
||||
for k in (-1, 0, 1):
|
||||
par.setdefault(_heure(t) + k * HEURE, []).append(v)
|
||||
med = {h: statistics.median(v) for h, v in par.items() if len(v) >= 3}
|
||||
if len(med) < 8:
|
||||
return {}
|
||||
calme = statistics.quantiles(med.values(), n=4)[0]
|
||||
return {h: v / calme for h, v in med.items()} if calme > 0 else {}
|
||||
|
||||
|
||||
def heures(mesures):
|
||||
"""-> {heure: {capteur: (agitation / calme, error_value / calme)}}."""
|
||||
out = {}
|
||||
for s, ms in mesures.items():
|
||||
ag = _rapports([(b["t"], abs(b["corr_x"] - a["corr_x"]) + abs(b["corr_y"] - a["corr_y"]))
|
||||
for a, b in zip(ms, ms[1:]) if a["corr_x"] is not None and b["corr_x"] is not None])
|
||||
er = _rapports([(m["t"], m["error_value"]) for m in ms if m["error_value"] is not None])
|
||||
for h, r in ag.items():
|
||||
if h in er:
|
||||
out.setdefault(h, {})[s] = (r, er[h])
|
||||
return out
|
||||
|
||||
|
||||
def _turbulente(r):
|
||||
return (sum(a >= RATIO for a, _ in r.values()) >= PART * len(r)
|
||||
and statistics.median(e for _, e in r.values()) >= RATIO_ERR)
|
||||
|
||||
|
||||
def detect(mesures):
|
||||
H = heures(mesures)
|
||||
blocs = []
|
||||
for h in sorted(h for h, r in H.items() if _turbulente(r)):
|
||||
if blocs and h - blocs[-1][-1] <= 2 * HEURE:
|
||||
blocs[-1].append(h)
|
||||
else:
|
||||
blocs.append([h])
|
||||
episodes = []
|
||||
for b in blocs:
|
||||
debut, fin = b[0], b[-1] + HEURE
|
||||
dedans = [m for ms in mesures.values() for m in ms if debut <= m["t"] < fin]
|
||||
if fin - debut < DUREE_MIN or sum(m["corr_x"] is None for m in dedans) > REJET_MAX * len(dedans):
|
||||
continue
|
||||
par_capteur = {}
|
||||
for h in b:
|
||||
for s, (a, _) in H[h].items():
|
||||
par_capteur.setdefault(s, []).append(a)
|
||||
agit = {s: statistics.median(v) for s, v in par_capteur.items()}
|
||||
fort = statistics.median(agit.values())
|
||||
episodes.append({
|
||||
"start": iso(debut), "end": iso(fin), "kind": "turbulence",
|
||||
"label": "Heat shimmer",
|
||||
"text": f"Readings were about {fort:.1f}× noisier than in calm hours because of heat shimmer "
|
||||
"(warm air trembling in the line of sight); the small fast wiggles are not movement.",
|
||||
"ignore": fort >= FORT,
|
||||
"sensors": sorted(s for s, v in agit.items() if v >= RATIO),
|
||||
})
|
||||
return episodes
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
for e in detect(charger(sys.argv[1])):
|
||||
print(e["start"], "→", e["end"], e["label"], "(grisé)" if e["ignore"] else "",
|
||||
f"{len(e['sensors'])} capteurs |", e["text"])
|
||||
@@ -0,0 +1,188 @@
|
||||
"""Journal du matin : visibilité / taux d'erreur de reconnaissance (error_value), un épisode grisé par moment douteux.
|
||||
|
||||
Méthode (seuils provisoires ci-dessous) :
|
||||
1. Mesure « haute » : error_value > médiane + 10 MAD et > 2 × médiane du capteur sur l'export (relatif au capteur, pas au seuil).
|
||||
2. Brief obstruction : un instant où au moins 3 capteurs sont hauts, 3 fois plus qu'aux instants voisins (train, véhicule),
|
||||
sans référence (global_ref) parmi eux : un pic d'un pas qui touche les références n'est pas un obstacle devant des
|
||||
cibles (pic de toute l'image, NORDEND le 01.09 11:15, lot 01 de la boucle) ; il n'est pas montré.
|
||||
3. Poor visibility : suites d'au moins 3 mesures hautes par capteur, réunies entre capteurs (au moins 2), réduites aux instants
|
||||
où au moins 15 % du pic de l'épisode est haut ; le texte dit si des références (global_ref) sont touchées.
|
||||
4. Target obscured : une cible (pas une global_ref) rejetée (> error_threshold) et à plus de 5 MAD, au moins 3 fois à moins de 6 h
|
||||
d'écart, la plupart hors des épisodes 2 et 3 (feuilles, neige, reflet sur une cible). Tous les épisodes : ignore = True.
|
||||
5. Niveau d'une Poor visibility (point 38 du plan, validé le 2026-10-24), mesure par mesure : « none » (on ne voit rien) quand
|
||||
au moins MOITIE des cibles habituellement vues (sous leur seuil la moitié du temps au moins) sont rejetées, « reduced »
|
||||
(données moyennes) sinon ; un épisode par période de même niveau, avec le champ level. Sur les cas : NORDEND le 09.10
|
||||
08:45 → 10:30 et 21:30 → 23:15, le 14.10 05:15 → 06:00 en none ; buées de NORDEND et de C-001, toile de C-002, pluie
|
||||
de C-005 en reduced.
|
||||
|
||||
Résultats (2026-10-23 ; vérité : agents/diagnostic/cas/INDEX.md) :
|
||||
- PS_DES_COUDRES (C-001, buée 13.10 23:45 → 14.10 05:15, 2 références sur 3) : Poor visibility 13.10 23:45 → 14.10 04:45, REF_G et
|
||||
REF_D ; aussi la nuit d'avant, 13.10 01:15 → 03:30, mêmes références (hors vérité, pas d'image : sans doute la même buée).
|
||||
- NORDEND juillet (C-002, toile 28.07 20:45 → 31.07 03:00, reprise 31.07 20:30) : Poor visibility 28.07 20:45 → 31.07 02:45 (20 capteurs)
|
||||
et 31.07 20:30 → fin (18), références comprises.
|
||||
- WILDSTRUBEL (C-003, turbulence de jour) : pas de Poor visibility (error_value ×1,5 à ×3 seulement : laissé au détecteur turbulence) ;
|
||||
3 Brief obstruction de jour (02.09 12:00, 03.09 08:15, 04.09 14:00 : un véhicule sur la route à 14:00, image ; les deux
|
||||
premières touchent des références et ne sont plus montrées depuis le lot 01 de la boucle NORDEND) ; PA_9 en
|
||||
Target obscured chaque matin dès 04:30, jusqu'à 06:45, 08:15 ou 12:00 (soleil sur la cible, probable).
|
||||
- CLARIDEN (C-004, mouvement réel) : rien sur le groupe à error_value durablement haute (bon) ; Brief obstruction 18.09 13:40
|
||||
et 20.09 06:20 (tunnel : taches assombries, non établi ; références touchées, plus montrées depuis le lot 01) ;
|
||||
Target obscured PR-284 19.09 18:30 → 18:50.
|
||||
- NIEDERHORN (C-005) : trains 30.09 22:00, 01.10 12:00 et 21:00, 02.10 21:00 (celui du 03.10 10:00, 2 cibles, manqué) ;
|
||||
pluie 01.10 06:00 → 11:00 et 02.10 03:00 → 11:00 (vérité 05:00 et 03:00 → 11:00), références intactes ; feuilles 02.10 10:00 → 22:00.
|
||||
- NORDEND octobre (cas/2026-10_NORDEND) : Poor visibility 07.10 17:15 → 08.10 12:15 (buée du 08.10 02:30), 09.10 07:45 → 14:00
|
||||
(parois ruisselantes), 09.10 20:45 → 23:45 (17 rejets à 23:00, retour à 00:00), 13.10 09:45 → 10:30, 14.10 05:15 → 06:30
|
||||
(taches pâles à l'aube) ; Brief obstruction 12.10 14:15 (09.10 18:45 touche CTR04 : plus montrée depuis le lot 01) ;
|
||||
Target obscured surtout CTR01, PR04, PR09 (souvent rejetées) : à vérifier.
|
||||
|
||||
Version simple essayée le 2026-10-24 (point 11 du plan), à la demande de l'utilisateur : part des cibles rejetées au-dessus
|
||||
de leur seuil, sans comparer chaque capteur à son propre niveau. Moins bonne sur cinq jeux sur six (buée de C-001 manquée,
|
||||
toile de C-002 morcelée, turbulence de C-003 prise pour une perte de visibilité) et grisait le vrai mouvement de C-004 :
|
||||
l'utilisateur a remis cette version en service ; la simple est gardée dans archive/visibilite_simple.py.
|
||||
"""
|
||||
import os
|
||||
import statistics
|
||||
import sys
|
||||
from datetime import timedelta
|
||||
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "agents", "diagnostic", "outils"))
|
||||
from donnees import charger, iso # noqa: E402
|
||||
|
||||
K_MAD = 10 # provisoire, réglé sur C-001 (buée : 11 à 57 MAD) et C-005 (pluie, trains : 10 à 70 MAD)
|
||||
FACTEUR = 2 # provisoire : écarte les capteurs à MAD quasi nulle (C-004 : PWD_REF10 ×1,6 à 14 MAD, C-005)
|
||||
SUITE_MIN = 3 # provisoire : mesures hautes d'affilée pour une mauvaise visibilité (C-001, C-005 pluie)
|
||||
BREF_MIN = 3 # provisoire, réglé sur C-005 (trains : 5 à 17 capteurs ; celui de 2 cibles est manqué)
|
||||
K_CIBLE = 5 # provisoire, réglé sur C-005 (feuilles : 6 à 25 MAD, rejetées)
|
||||
CIBLE_MIN = 3 # provisoire : rejets répétés d'une cible
|
||||
FRAC = 0.15 # provisoire : coupe les queues de PR09 + CTR01 (NORDEND octobre) sans couper la toile (C-002)
|
||||
ECART = 2.5 # provisoire : pas tolérés entre deux mesures hautes d'une même suite (un pas manquant, horloge à la seconde près)
|
||||
COUPURE = timedelta(hours=2) # provisoire : accalmie qui sépare deux épisodes (NORDEND octobre, nuit du 13 au 14.10)
|
||||
SAILLIE = 3 # provisoire : un train ressort d'au moins 3 fois les instants voisins (C-005 : 5 à 17 contre 0 à 2 ;
|
||||
# la toile de C-002 varie de 2 à 9 d'un pas à l'autre)
|
||||
CIBLE_ECART = timedelta(hours=6) # provisoire, réglé sur C-005 (feuilles : 7 rejets en 12 h, jusqu'à 5 h d'écart)
|
||||
MOITIE = 0.5 # provisoire : « on ne voit rien » ; réglé sur NORDEND (09.10 23:00 : 68 % rejetées) et C-005 (pluie : 24 à 33 %)
|
||||
|
||||
|
||||
def _pas(mesures):
|
||||
ts = sorted({m["t"] for v in mesures.values() for m in v})
|
||||
return statistics.median(b - a for a, b in zip(ts, ts[1:]))
|
||||
|
||||
|
||||
def _grouper(points, ecart):
|
||||
"""[(t, capteur)] triés par t -> groupes [(début, fin, {capteurs}, [t])] dont les points sont à ≤ ecart les uns des autres."""
|
||||
groupes = []
|
||||
for t, s in points:
|
||||
if groupes and t - groupes[-1][1] <= ecart:
|
||||
g = groupes[-1]
|
||||
groupes[-1] = (g[0], t, g[2] | {s}, g[3] + [t])
|
||||
else:
|
||||
groupes.append((t, t, {s}, [t]))
|
||||
return groupes
|
||||
|
||||
|
||||
def _episode(debut, fin, label, text, capteurs, level=None):
|
||||
e = {"start": iso(debut), "end": iso(fin), "kind": "visibilite", "label": label, "text": text,
|
||||
"ignore": True, "sensors": sorted(capteurs)}
|
||||
return {**e, "level": level} if level else e
|
||||
|
||||
|
||||
def _niveaux(mesures, instants):
|
||||
"""t -> "none" si au moins MOITIE des cibles habituellement vues sont rejetées à t, "reduced" sinon."""
|
||||
ratios = []
|
||||
for v in mesures.values():
|
||||
r = {m["t"]: m["error_value"] / m["error_threshold"] for m in v if m["error_value"] is not None and m["error_threshold"]}
|
||||
if r and statistics.median(r.values()) < 1:
|
||||
ratios.append(r)
|
||||
return {t: "none" if sum(r.get(t, 0) > 1 for r in ratios) >= MOITIE * max(1, sum(t in r for r in ratios)) else "reduced"
|
||||
for t in instants}
|
||||
|
||||
|
||||
def detect(mesures):
|
||||
ecart = ECART * _pas(mesures)
|
||||
refs = {s for s, v in mesures.items() if v[0]["pattern_type"] == "global_ref"}
|
||||
instants = sorted({m["t"] for v in mesures.values() for m in v})
|
||||
hautes, rejets = {}, {} # capteur -> [t]
|
||||
for s, v in mesures.items():
|
||||
e = [m["error_value"] for m in v if m["error_value"] is not None]
|
||||
if len(e) < 10:
|
||||
continue
|
||||
med = statistics.median(e)
|
||||
mad = statistics.median(abs(x - med) for x in e) or 1e-9
|
||||
for m in v:
|
||||
x = m["error_value"]
|
||||
if x is None:
|
||||
continue
|
||||
if x > med + K_MAD * mad and x > FACTEUR * med:
|
||||
hautes.setdefault(s, []).append(m["t"])
|
||||
if s not in refs and m["error_threshold"] and x > m["error_threshold"] and x > med + K_CIBLE * mad:
|
||||
rejets.setdefault(s, []).append(m["t"])
|
||||
par_t = {} # t -> {capteurs hauts}
|
||||
for s, ts in hautes.items():
|
||||
for t in ts:
|
||||
par_t.setdefault(t, set()).add(s)
|
||||
n = lambda t: len(par_t.get(t, ())) # noqa: E731
|
||||
out = []
|
||||
|
||||
# 2. Brief obstruction : un instant où beaucoup de capteurs sont hauts, au moins SAILLIE fois plus qu'aux instants voisins.
|
||||
brefs = set()
|
||||
for i, t in enumerate(instants):
|
||||
voisins = [n(instants[j]) for j in (i - 1, i + 1) if 0 <= j < len(instants)]
|
||||
if n(t) >= BREF_MIN and n(t) >= SAILLIE * max(voisins):
|
||||
brefs.add(t)
|
||||
if par_t[t] & refs: # références touchées : pas un obstacle devant des cibles (carte : références intactes)
|
||||
continue
|
||||
out.append(_episode(t, t, "Brief obstruction", f"{n(t)} points were poorly seen for a single measurement, then came "
|
||||
"back: probably a train, a vehicle or an animal passing; ignore this point on the curves.", par_t[t]))
|
||||
|
||||
# 3. Poor visibility : suites longues par capteur (sans les instants brefs), réunies entre capteurs,
|
||||
# puis réduites aux instants où au moins FRAC du pic de l'épisode est haut (coupe les queues d'un ou deux capteurs
|
||||
# et les longues accalmies, plus de COUPURE).
|
||||
suites = []
|
||||
for s, ts in hautes.items():
|
||||
pts = [(t, s) for t in ts if t not in brefs]
|
||||
suites += [(a, b, s) for a, b, _, l in _grouper(pts, ecart) if len(l) >= SUITE_MIN]
|
||||
zones = [z for z in _grouper_intervalles(sorted(suites), ecart) if len(z[2]) >= 2]
|
||||
gardees = []
|
||||
for a, b, _ in zones:
|
||||
dans = [t for t in instants if a <= t <= b and t not in brefs]
|
||||
pic = max(n(t) for t in dans)
|
||||
pts = [(t, s) for t in dans if n(t) >= max(1, FRAC * pic) for s in par_t[t]]
|
||||
gardees += [(d, f, cs) for d, f, cs, l in _grouper(pts, max(ecart, COUPURE)) if len(cs) >= 2 and len(set(l)) >= SUITE_MIN]
|
||||
niveau = _niveaux(mesures, instants)
|
||||
for a, b, cs in gardees: # un épisode par période de même niveau (5) ; le texte vient de categories.py
|
||||
seg = []
|
||||
for t in [t for t in instants if a <= t <= b] + [None]:
|
||||
if seg and (t is None or niveau[t] != niveau[seg[0]]):
|
||||
qui = cs & set().union(*(par_t.get(u, set()) for u in seg)) or cs
|
||||
out.append(_episode(seg[0], seg[-1], "Poor visibility", "", qui, niveau[seg[0]]))
|
||||
seg = []
|
||||
if t is not None:
|
||||
seg.append(t)
|
||||
dedans = lambda t: t in brefs or any(a <= t <= b for a, b, _ in gardees) # noqa: E731
|
||||
|
||||
# 4. Target obscured : une cible rejetée à répétition, surtout hors des épisodes ci-dessus.
|
||||
cibles = []
|
||||
for s, ts in rejets.items():
|
||||
for a, b, _, l in _grouper([(t, s) for t in ts], CIBLE_ECART):
|
||||
if len(l) >= CIBLE_MIN and sum(map(dedans, l)) * 2 < len(l):
|
||||
cibles.append((a, b, s))
|
||||
for a, b, cs in _grouper_intervalles(sorted(cibles), timedelta(0)):
|
||||
qui, it, its = ("One target was", "it", "its") if len(cs) == 1 else (f"{len(cs)} targets were", "them", "their")
|
||||
out.append(_episode(a, b, "Target obscured", f"{qui} repeatedly lost while the targets around stayed clear: probably "
|
||||
f"something in front of {it} (leaves, snow) or glare; {its} displacements in this period are unreliable.", cs))
|
||||
return sorted(out, key=lambda e: e["start"])
|
||||
|
||||
|
||||
def _grouper_intervalles(intervalles, ecart):
|
||||
"""[(début, fin, capteur)] triés -> [(début, fin, {capteurs})] des intervalles qui se chevauchent (à ecart près)."""
|
||||
out = []
|
||||
for a, b, s in intervalles:
|
||||
if out and a - out[-1][1] <= ecart:
|
||||
out[-1] = (out[-1][0], max(out[-1][1], b), out[-1][2] | {s})
|
||||
else:
|
||||
out.append((a, b, {s}))
|
||||
return out
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
for e in detect(charger(sys.argv[1])):
|
||||
print(e["start"], "→", e["end"], e["label"], f"| {len(e['sensors'])} :", ",".join(e["sensors"][:8]), "|", e["text"])
|
||||
Reference in new issue
Block a user