Detectors in English, under scripts/; learner tools under scripts/learner/

- data.py (was donnees.py): unused filtrer, heure_image and image sorting removed
- score.py: dead functions (validite, marquer, detectes, score, familles) and the
  validity levels removed; --from/--to
- regression.py: history.csv and --seance/--etape removed
- categories.py: --from/--to/--chunk/--history; process values images/none/check
- benchmark on all stations unchanged (same 132 figures)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
maximeandClaude Opus 5.5 committed 2026-11-13 12:19:52 +01:00
1 parent 9b3ac0ecfe
commit 969637499f
23 files changed
+1877 -1971

No files matched your search

-246
View File
@@ -1,246 +0,0 @@
"""Journal du matin : des épisodes des détecteurs aux événements, un par famille.
Un détecteur par famille des étiquettes (labeling/familles.md) : visibility.py, obstruction.py, target_issue.py,
thermal_displacement.py, no_data.py, displacement.py. La catégorie d'un événement est sa famille, le champ kind de ses
épisodes ; leur label en dit la sorte (Poor visibility, Heat shimmer, Brief obstruction, Slow drift…). Règles :
- un saut revenu à la normale (SAUT) qui chevauche un épisode de HOTES (perte de visibilité, passage, turbulence, et en
dernier l'effet thermique, s'il touche plusieurs cibles) y est absorbé : il en prend la cause et la famille ; sinon il
reste Displacement, sans cause établie, à vérifier sur les images (familles.md, « Un saut puis le retour ») ; un passage
(Brief obstruction, un seul instant) n'absorbe que les sauts qui commencent à son instant, pas ceux de plusieurs jours
qu'il croise (/detector-learner Displacement, modification 1, S5) ;
- une dérive lente ou un saut revenu dont toutes les cibles sont dans un épisode Target issue qui le chevauche y est absorbé
(la courbe d'une cible à problème est à ignorer, familles.md) ;
- un décalage qui dure, ou trop récent pour savoir (DECALAGES), n'est jamais absorbé ;
- une turbulence qui chevauche un décalage de plusieurs cibles n'est pas gardée : un vrai mouvement agite aussi les courbes ;
le décalage d'une seule cible ne retire pas la turbulence de toute la scène, et une turbulence n'absorbe que les sauts
revenus qui commencent pendant elle, pas celui de la veille qui revient dans sa journée (/detector-learner Visibility,
modification 1, S1 : WILDSTRUBEL) ;
- deux événements de même sorte à moins de MERGE n'en font qu'un ; deux Obstruction (Target obscured, Brief
obstruction), seulement s'ils partagent un capteur (/detector-learner Obstruction, modification 1 : S1, des cibles
différentes enchaînées en un événement de plusieurs jours ; S3, des passages de quelques minutes en une heure entière) ;
deux Target issue aussi : chaque cible à problème garde ses bornes (/detector-learner Target issue, modification 1, S3) ;
un passage n'absorbe que les sauts revenus dans MERGE après son instant (S3 : pas le saut de 30 h d'une autre cible).
Chaque événement reçoit sa phrase, en anglais (le site) : ce qui s'est passé et quoi en faire, comme le dit la colonne
« Pour le client » de familles.md ; la cause n'est dite que si la sorte l'établit, sinon les images la montrent.
Pas de fonction detect : le chargeur ne prend pas ce fichier pour un détecteur.
Usage : python3 detectors/categories.py <dossier de station> (une ligne par événement : famille, sorte, capteurs)
... <dossier> [--du AAAA-MM-JJ] [--au AAAA-MM-JJ] [--tranche 3] [--historique N] (tri en lot : chaque tranche
de N 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 functools
import importlib.util
import inspect
import os
import sys
from datetime import datetime, timedelta, timezone
from pathlib import Path
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) # donnees.py, à côté
from donnees import charger, charger_camera, charger_metriques, charger_temperature, iso # noqa: E402
# Ce qu'un détecteur peut lire de la station en plus des mesures, s'il le déclare dans detect (D-124, D-134) :
# temperature [(t, °C)], médiane horaire des composants ; camera [pose] (pan, tilt, rotation, scale, sigma0) ;
# metriques {nom: [(t, valeur)]}, toutes les métriques numériques (sensor_CPU_deg_c, sensor_GPU_deg_c, BusVoltage…).
CONTEXTE = {"temperature": charger_temperature, "camera": charger_camera, "metriques": charger_metriques}
@functools.lru_cache(maxsize=None)
def _contexte(dossier, cle):
return CONTEXTE[cle](dossier)
# Les familles de labeling/familles.md, dans l'ordre des lignes de la frise ; ignore : zone grisée (None : comme le
# disent ses épisodes : une perte de visibilité totale, une turbulence forte) ; process : bouton Images, rien, ou Images
# et lien vers Diagnosis.
CATEGORIES = {
"Visibility": {"ignore": None, "process": "images"},
"Obstruction": {"ignore": True, "process": "images"},
"Target issue": {"ignore": True, "process": "images"},
"Thermal displacement": {"ignore": False, "process": "aucun"},
"No data": {"ignore": False, "process": "aucun"},
"Displacement": {"ignore": False, "process": "verifier"},
}
SAUT = "Sudden jump, back to normal" # un saut revenu : sa cause, s'il chevauche un hôte ; sinon Displacement
DECALAGES = {"Lasting shift", "Jump, not back yet", "Large shift"} # à vérifier : jamais absorbés
HOTES = {"Poor visibility", "Brief obstruction", "Heat shimmer", "Thermal expansion", "Thermal contraction",
"Camera thermal expansion", "Camera thermal contraction", "Camera thermal movement"} # disent la cause d'un saut revenu qui les chevauche
MERGE = timedelta(hours=1) # même sorte à moins d'une heure : un seul événement (règle validée, 2026-10-24)
def detecteurs():
"""Modules de 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 ep["kind"]
def sorte(ep):
"""La sorte d'un épisode dans sa famille : les décalages ensemble, l'effet thermique sans « Camera », la perte de
visibilité par niveau."""
label = "shift" if ep["label"] in DECALAGES else ep["label"].removeprefix("Camera ").capitalize()
return ep["kind"], label, ep.get("level")
def thermique(ep):
return ep["kind"] == "Thermal displacement"
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(groupe, sensors, references):
"""Phrase du journal d'un événement (validées par l'utilisateur le 2026-10-24), d'après la sorte de son épisode
principal ; un saut absorbé ajoute qu'il a la même cause."""
n, one, ep = len(sensors), len(sensors) == 1, groupe[0]
sauts = [e for e in groupe[1:] if e["label"] == SAUT]
jumped = len({s for e in sauts for s in e["sensors"]})
lasting = len({s for e in groupe if e["label"] in DECALAGES for s in e.get("lasting", [])})
refs = ", including the reference targets" if references & set(sensors) else ""
camera = ep["label"].startswith("Camera")
large = any(e["label"] == "Large shift" for e in groupe)
sort = "shift" if ep["label"] in DECALAGES else f"{ep['label']} {ep['level']}" if ep.get("level") else ep["label"]
text = {
"Poor visibility none": f"The camera could not see {targets(n)} clearly{refs}. "
"The curves in this period are not reliable: ignore them.",
"Poor visibility reduced": f"The camera saw {targets(n)} less clearly than usual{refs}. "
"The data in this period are less precise: use them with care.",
"Brief obstruction": f"Something passed in front of {targets(n)} for a single measurement. Ignore this point on the curves.",
"Target obscured": 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.",
"Heat shimmer": "Warm air made the readings shake. The small fast wiggles are not movement.",
"expansion": ("The camera support expands in the day heat; the curves are corrected for it."
if camera else "The structure expands in the day heat.") + " This daily wave is normal: nothing to do.",
"contraction": ("The camera support contracts as it cools down; the curves are corrected for it."
if camera else "The structure contracts as it cools down.") + " This daily wave is normal: nothing to do.",
SAUT: f"{targets(n).capitalize()} jumped and came back. The cause is not established: look at the images.",
"shift": (f"{targets(n).capitalize()}, most of the targets, shifted together: everything moved." if large
else 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(sort.split()[-1] if thermique(ep) else sort, ep["text"]) # No data, Target issue, Slow drift : le texte du détecteur
if ep["kind"] == "Target issue":
text += f" Ignore {'its curve' if one else 'their curves'} in this period and look at the images of the target."
if not jumped:
return text
return text + (f" The jump of {targets(jumped)} in this period has the same cause." if len(sauts) == 1
else f" The jumps of {targets(jumped)} in this period have the same cause.")
def evenement(groupe, references):
"""Épisodes d'un même événement, le principal en tête -> événement."""
cat, so = categorie(groupe[0]), sorte(groupe[0])
c = CATEGORIES.get(cat, {"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 sorte(e) == so] # 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": cat, "text": phrase(groupe, sensors, references),
"ignore": c["ignore"] if c["ignore"] is not None else any(e["ignore"] for e in main),
"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"])
# un vrai mouvement n'est jamais pris pour de la turbulence ; le décalage d'une seule cible n'est pas un mouvement de la scène
checks = [e for e in eps if e["label"] in DECALAGES and len(e["sensors"]) > 1]
eps = [e for e in eps if e["label"] != "Heat shimmer" or not any(overlap(e, c) for c in checks)]
# la vague thermique n'absorbe qu'en dernier (un saut d'un passage ou d'une pluie va à eux), et que les sauts de
# plusieurs cibles : la vague les fait bouger ensemble, une cible seule qui saute n'est pas la vague (C2 de E-003)
hosts = sorted((e for e in eps if e["label"] in HOTES), key=thermique)
host = {id(e): next((h for h in hosts if overlap(e, h) and (len(e["sensors"]) > 1 or not thermique(h))
and (h["label"] != "Heat shimmer" or h["start"] <= e["start"])
and (h["label"] != "Brief obstruction" or e["start"] == h["start"]
and datetime.fromisoformat(e["end"]) - datetime.fromisoformat(h["start"]) <= MERGE)), None)
for e in eps if e["label"] == SAUT}
# une dérive ou un saut revenu dont toutes les cibles sont dans un épisode Target issue qui le chevauche : sa courbe
# est à ignorer, il en prend la famille (/detector-learner Displacement, modification 1, S6)
host.update({id(e): h for e in eps if e["label"] in (SAUT, "Slow drift") and not host.get(id(e))
and (h := next((h for h in eps if h["kind"] == "Target issue" and overlap(e, h)
and set(e["sensors"]) <= set(h["sensors"])), None))})
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 sorte(m[0]) == sorte(g[0]) and (g[0]["kind"] not in ("Obstruction", "Target issue")
or set(g[0]["sensors"]) & {s for e in m for s in e["sensors"]})), None)
end = max((e["end"] for e in prev if sorte(e) == sorte(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, fin=None, dossier=None):
"""Mesures (donnees.charger) -> événements de tous les détecteurs : ce que la page reçoit dans D.journal. Un détecteur
reçoit en plus ce que sa fonction detect déclare : fin, la fin de la fenêtre lue (tri en lot), pour un trou qui la
touche ; une clé de CONTEXTE, lue dans le dossier de la station (une fois par dossier), vide sans dossier."""
episodes = []
for mod in detecteurs():
try:
params = inspect.signature(mod.detect).parameters
kw = {k: _contexte(dossier, k) if dossier else {} if k == "metriques" else [] for k in CONTEXTE if k in params}
if "fin" in params:
kw["fin"] = fin
episodes += mod.detect(mesures, **kw)
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[:10], "%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, b, a.dossier) 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']:<20}", "grisé" if v["ignore"] else "gardé",
f"| {v['episodes'][0]['label']}", # la sorte : la règle du détecteur de la famille
f"| {len(v['sensors']) or 'tous les'} capteurs", "| absorbés :", ", ".join(
f"{e['label']} {e['start'][5:16]}" for e in v["episodes"][1:]) or "—")
t = b
-359
View File
@@ -1,359 +0,0 @@
"""Journal du matin : le détecteur de la famille Displacement (labeling/familles.md) : les sauts brutaux de corr_x /
corr_y (px) de chaque cible, à la cadence native de l'export « advanced », et la dérive lente (en fin de fichier). Une
cible qui bascule (« Target flipping ») est de la famille Target issue : episodes() la rend, detect() la laisse à
target_issue.py.
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 (une heure de mesures de suite à moins de la moitié du saut : BASE à 15 min, une seule à 4 h, boucle
/detector-learner MICHIGAN, modification 1) 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é ; sa cause n'est pas
établie ici (categories.py lui donne celle de la catégorie qui le chevauche, sinon : à vérifier sur les images).
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).
7. Boucle CLARIDEN, lot 01 (2026-10-26) : un saut jamais revenu ne clôt plus la lecture de la série, son nouveau niveau
devient le niveau d'avant ; un épisode qui n'est pas grisé finit à son dernier saut, pas aux retours (ils ne sont
plus à griser) ; une cible qui bascule (REPET sauts revenus ou plus, chacun à moins d'un jour du précédent) fait un
épisode « back to normal » à elle seule, de la première à la dernière bascule, hors des épisodes communs.
Résultats (2026-10-23, K = 20) :
- E-001 PS des Coudres : rien (vérité : rien côté sauts).
- E-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).
- E-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.
- E-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.
- E-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é ; E-002, E-005 : pics absorbés par la toile et les trains ; E-004 : les pics du
mouvement (19/09 06:30, 06:50) restent dans le « Lasting shift » ; E-001, E-003 : rien.
Point 7 (REPET = 5, 2026-10-26) : CLARIDEN, lot du 18 au 22/09 : PR_BG grisé 19/09 06:40 → 21/09 23:20 (28 bascules de
12 px ; les autres cibles en font 3 au plus) ; le saut seul de D-303-A le 18/09 15:40 vu ; le « Lasting shift » du
matin garde 05:40 → 10:30 ; E-001 à E-003, E-005 à E-008 : inchangés.
Catégories du terrain (D-074, 2026-10-27) : la cible qui bascule pendant BASCULE au moins, avec SEULES cibles au plus en même temps, devient « Target flipping » (Target issue, plus un
saut bref) ; un saut durable d'au moins GROS des cibles, « Large shift » (gros saut : tout a bougé), toujours à vérifier.
/detector-learner Target issue, modification 1, S2 : BASCULE de 6 h à 36 h ; une cible qui bascule un jour, pendant une
gêne de toute la scène (pluie, brouillard, nuit de mauvaise visibilité), n'est pas une cible à problème (familles.md : des
rejets propres presque chaque jour) ; ses sauts revenus vont à la gêne qui les chevauche, sinon restent Displacement.
8. Saut sous K qui reste (boucle NIEDERHORN, lot 01, 2026-10-27 ; K_DURABLE = 7, PALIER = 8) : un saut d'au moins
K_DURABLE bruits compte s'il est durable au point 3 et que la médiane du jour d'après s'écarte de celle du jour d'avant,
du côté du saut, d'au moins PALIER fois la variation ordinaire du niveau d'un jour UTC au suivant (médiane des écarts
entre niveaux journaliers) ; sinon il est ignoré (ni revenu ni trop récent : seuls les sauts de K bruits ou plus le
sont). NIEDERHORN : e09, corr_y −0,19 px le 02/10 20:00 (8 bruits, 13 variations ordinaires), « Lasting shift », avec
e10 au même instant (corr_x +0,22 px, resté) ; E-001 : rien (cibles saines à 6 variations ordinaires au plus) ;
E-004 : le mouvement du 19/09 couvre deux fois plus de mesures à vérifier ; les autres events inchangés.
"""
import statistics
import sys
from datetime import timedelta
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parent)) # donnees.py, à côté
import donnees # noqa: E402
K = 20 # provisoire, réglé sur E-001 : à 15, deux cibles saines y sont grisées (17 et 18 bruits) ; les trains de
# E-005 (17 et 19 bruits) sont attrapés par visibilite : ne pas baisser K
K_DURABLE = 7 # provisoire : sous K, un saut qui reste compte dès K_DURABLE bruits (boucle NIEDERHORN, lot 01 : e09,
# corr_y −0,18 px d'un coup, 8 bruits, resté 5 jours)
PALIER = 8 # provisoire : ... s'il reste : médiane du jour d'après, du côté du saut, à PALIER fois la variation
# ordinaire du niveau d'un jour au suivant de celle du jour d'avant (e09 : 13 ; E-001, cibles saines : 6 au plus)
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 (E-002 : paliers jusqu'à 11 h 30)
BASCULE = timedelta(hours=36) # provisoire : une cible à problème bascule plusieurs jours (PR_BG : 2,5 jours) ; en moins,
# c'est un matin agité (E-009 : C8 et C13, 5 bascules en 1 h 20 pendant le mouvement) ou une nuit de gêne
# (NORDEND, JUNGFRAU : 12 à 28 h dans une perte de visibilité), un saut revenu, absorbé par son hôte
SEULES = 2 # provisoire : cibles qui basculent en même temps, au plus (FLORIDA : les deux collées ; E-002, toile sur les
# références : 15 à la fois)
GROS = 0.5 # provisoire : part des cibles d'un saut durable pour un gros saut (E-004 : presque toutes)
REPET = 5 # provisoire : sauts revenus d'une même cible, à moins d'un jour l'un de l'autre, qui en font une cible qui
# bascule (PR_BG de CLARIDEN, boucle lot 01 : une trentaine en 2,5 jours)
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:]))
pas = statistics.median(b - a for a, b in zip(t, t[1:])) # cadence de la série
retour = max(1, min(BASE, round(timedelta(hours=1) / pas))) # mesures d'une heure (BASE à 15 min, une à 4 h)
# 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)
lv = {} # niveau de chaque jour UTC ; sa variation ordinaire d'un jour au suivant juge un saut sous K
for x, u in zip(v, t):
lv.setdefault(u.date(), []).append(x)
lv = [statistics.median(x) for _, x in sorted(lv.items())]
ordinaire = statistics.median(abs(b - a) for a, b in zip(lv, lv[1:])) if len(lv) > 2 else 0
# 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_DURABLE * noise:
i += 1
continue
tol = abs(v[i] - base) / 2 # revenu : une heure de 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 + retour])), 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
if abs(v[i] - base) < K * noise and (state != "lasting" or (after - before) * (v[i] - base) < 0
or not ordinaire or abs(after - before) < PALIER * ordinaire):
i += 1 # sous K, seul compte un saut qui reste : le jour d'après loin du jour d'avant, de son côté
continue
out.append((i, j - 1, state))
# niveau d'avant refait après le retour ; jamais revenu : le nouveau niveau devient celui d'avant, la suite
# reste lue (PR_BG de CLARIDEN, lot 01 : ses bascules après le saut de 10:30 étaient invisibles)
i = (j if j < len(v) else i) + BASE
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 episodes(mesures):
"""{capteur: [mesure]} (donnees.charger) -> épisodes des sauts, triés par début : Displacement, et Target issue pour
une cible qui bascule."""
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
seuls = _bascules(found) # une cible qui saute et revient sans cesse : un épisode à elle seule, hors des communs
found = [f for f in found if f[2] != "back" or not any(f[3] in g["sensors"] and g["start"] <= f[0] <= g["end"]
for g in seuls)]
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, "last": s, "sensors": {}}
groups.append(g)
g["end"], g["until"], g["last"] = max(g["end"], e), max(g["until"], e if state == "back" else s), s
g["sensors"].setdefault(name, set()).add(state)
longues = [g for g in seuls if g["flip"]] # bascules de nombreuses cibles en même temps : la compensation, pas une
for g in longues: # cible à problème
if sum(h["start"] <= g["end"] and h["end"] >= g["start"] for h in longues) > SEULES:
g["flip"] = 0
total = sum(not donnees.est_reference(ms) for ms in mesures.values())
return sorted((_episode(g, total) for g in groups + seuls), key=lambda ep: ep["start"])
def _bascules(found):
"""Sauts revenus d'une même cible, chacun à moins de BACK_H du précédent : REPET ou plus -> un groupe, de la
première à la dernière bascule."""
day, seuls = timedelta(hours=BACK_H), []
for name in {f[3] for f in found}:
chain = [] # (début, fin) ; corr_x et corr_y en double : comptés par instant
for s, e in sorted({(s, e) for s, e, state, n in found if n == name and state == "back"}) + [(None, None)]:
if chain and s is not None and s <= max(c[1] for c in chain) + day:
chain.append((s, e))
continue
if len({c[0] for c in chain}) >= REPET:
seuls.append({"start": chain[0][0], "end": max(c[1] for c in chain), "sensors": {name: {"back"}},
"flip": len({c[0] for c in chain}) if max(c[1] for c in chain) - chain[0][0] >= BASCULE else 0})
chain = [(s, e)]
return seuls
def _episode(g, total):
"""Un groupe -> épisode du journal ; un seul saut durable (ou trop récent) suffit à ne pas griser ; une cible qui
bascule : « Target flipping » (Target issue, D-074) ; un saut durable de GROS cibles ou plus : « Large shift »
(le gros saut, sous-groupe de « À vérifier »)."""
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 g.get("flip"):
name = next(iter(g["sensors"]))
return {"start": donnees.iso(g["start"]), "end": donnees.iso(g["end"]), "kind": "Target issue", "label": "Target flipping",
"text": f"{name} jumped and came back {g['flip']} times: its tracking is not reliable, look at the images "
"of the target.", "ignore": True, "sensors": [name], "lasting": []}
if lasting and n >= GROS * total:
label = "Large shift"
text = f"{n} targets jumped together and {lasting} of them stayed shifted: everything moved, please check it."
elif 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: the cause is not established, look at the images."
end = g["last"] if lasting or recent else g["end"] # pas grisé : le dernier saut, pas les retours
return {"start": donnees.iso(g["start"]), "end": donnees.iso(end), "kind": "Displacement", "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)
def detect(mesures):
return sorted([e for e in episodes(mesures) if e["kind"] == "Displacement"] + derive(mesures), key=lambda ep: ep["start"])
# --- Dérive lente ---------------------------------------------------------------------------------------------------
# Dérive lente : une cible qui bouge peu à peu, jour après jour.
#
# Reprend la tendance de l'onglet Displacements (D-055, explore.find_trend) sur l'export « advanced » (corr_x, corr_y, px),
# pour que la boucle puisse l'entraîner comme les autres détecteurs. Méthode, par cible (hors références globales) et par
# axe (seuils provisoires, ceux de D-055) :
# 1. Niveau du jour : médiane des mesures de chaque jour UTC d'au moins HEURES heures mesurées sur 24, en part des heures
# que la station mesure (boucle /detector-learner MICHIGAN, modification 1 : à une mesure toutes les 4 h, 5 des 6
# heures ; avant, aucun jour ne comptait) ; au moins JOURS jours.
# 2. Pente de Theil-Sen et tau de Kendall des niveaux journaliers ; amplitude du jour : écart entre ses déciles 9 et 1.
# 3. Dérive : |pente| × durée ≥ TAILLE fois l'amplitude médiane du jour, |tau| ≥ REGULIER, et aucun pas d'un jour au
# suivant de plus de la moitié de la dérive (un saut qui dure n'est pas une dérive : le détecteur sauts le prend).
# 4. Un épisode par cible (un axe suffit), de la première mesure du premier jour à la dernière du dernier ; pas grisé.
# 4 bis. Par morceaux (/detector-learner Displacement, modification 1, S1) : une cible sans dérive sur toute la fenêtre
# peut dériver quelques jours, puis se poser ou repartir en arrière. Sur chaque suite d'au moins JOURS jours retenus,
# dérive = niveau du dernier jour moins celui du premier, au moins MORCEAU amplitudes du jour (médiane de la série),
# |tau| ≥ REGULIER du même signe, aucun pas d'un jour retenu au suivant de plus de la moitié de la dérive ; les
# morceaux pris de la plus grande dérive à la plus petite, sans se chevaucher (ils peuvent partager le jour où le
# niveau tourne) : chacun va d'un extrême du niveau à l'autre, un épisode par morceau et par axe. À MORCEAU = 1, les
# cycles thermiques de quelques jours et le bruit des niveaux passent (JUNGFRAU, NORDEND) : 3,5 garde les rangées de
# CLARIDEN (3,8 à 8,3 amplitudes), écarte JUNGFRAU (3,1 au plus). Les morceaux ne remplacent pas l'étape 3 : à leur
# place, la fin des dérives de MICHIGAN et ce que couvraient les tendances de WILDSTRUBEL étaient perdus.
# Un morceau ne franchit pas un trou : deux jours retenus qui se suivent sont à TROU jours au plus l'un de l'autre
# (modification 2, remarque 1 du contrôle : l'écart d'un niveau à travers trois jours sans mesure est un pas, pas une
# pente ; il faisait des morceaux de toute la fenêtre, CLARIDEN 09-28 → 11-01). Un jour manquant ne coupe pas.
# 5. Dérive de la caméra (même modification) : au moins GROS des cibles dérivent du même côté sur corr_x ou corr_y, et au
# moins GROS des capteurs, références comprises, sur leurs positions brutes x ou y : seuls les morceaux du point 4 bis
# sont signalés, pas la tendance de toute la fenêtre (/detector-learner Displacement, modification 1, S2 : la caméra
# mal compensée qui dérive, NEBRASKA, est un Displacement pour les étiquettes ; avant, rien n'était signalé). Les
# cibles d'un pont qui suivent la saison (JUNGFRAU, étiquetées Thermal displacement jour après jour) passent l'étape 3
# mais pas MORCEAU ; NEBRASKA les deux. BREITHORN (5 capteurs sur 16 en x comme en y) et MICHIGAN ne sont pas
# concernées.
HEURES = 20 # un jour compte s'il a au moins 20 heures mesurées sur 24 (comme D-055), en part des heures mesurées
JOURS = 5 # jours au minimum pour une tendance (TREND_DAYS de D-055)
TAILLE = 1.0 # dérive ≥ TAILLE amplitudes journalières (TREND_SIZE de D-055)
REGULIER = 0.6 # |tau de Kendall| des niveaux journaliers (TREND_STEADY de D-055)
MORCEAU = 3.5 # dérive par morceaux ≥ MORCEAU amplitudes journalières (point 4 bis)
TROU = 2 # un morceau ne passe pas d'un jour retenu au suivant à plus de TROU jours (point 4 bis)
def _decile(vs, q):
vs = sorted(vs)
return vs[min(len(vs) - 1, int(q * len(vs)))]
def _jours(ms, col):
"""-> {jour UTC: ses mesures}, les jours retenus (point 1)."""
jours = {}
for m in ms:
if m[col] is not None:
jours.setdefault(m["t"].date(), []).append(m)
creneaux = len({m["t"].hour for js in jours.values() for m in js}) # heures que la station mesure (6 à 4 h de pas)
return {d: js for d, js in jours.items() if len({m["t"].hour for m in js}) >= HEURES / 24 * creneaux}
def _derive(ms, col):
"""-> (dérive en px, jours, premier instant, dernier) ou None."""
jours = _jours(ms, col)
if len(jours) < JOURS:
return None
niv = sorted((d.toordinal(), statistics.median(m[col] for m in js)) for d, js in jours.items())
paires = [(a, b) for k, a in enumerate(niv) for b in niv[k + 1:]]
pente = statistics.median((b[1] - a[1]) / (b[0] - a[0]) for a, b in paires)
tau = sum((b[1] > a[1]) - (b[1] < a[1]) for a, b in paires) / len(paires)
derive = pente * (niv[-1][0] - niv[0][0])
ampl = statistics.median(_decile([m[col] for m in js], 0.9) - _decile([m[col] for m in js], 0.1) for js in jours.values())
pas = max(abs(b[1] - a[1]) for a, b in zip(niv, niv[1:]))
if abs(derive) < TAILLE * ampl or abs(tau) < REGULIER or pas > abs(derive) / 2:
return None
d0, d1 = min(jours), max(jours)
return derive, len(jours), min(m["t"] for m in jours[d0]), max(m["t"] for m in jours[d1])
def _morceaux(ms, col):
"""-> [(dérive en px, jours, premier instant, dernier)] : les morceaux de dérive (point 4 bis)."""
jours = _jours(ms, col)
if len(jours) < JOURS:
return []
ds = sorted(jours)
niv = [statistics.median(m[col] for m in jours[d]) for d in ds]
ampl = statistics.median(_decile([m[col] for m in js], 0.9) - _decile([m[col] for m in js], 0.1) for js in jours.values())
morceaux = [] # (dérive, i, j)
for i in range(len(ds)):
signes = pas = 0
for j in range(i + 1, len(ds)):
if (ds[j] - ds[j - 1]).days > TROU:
break # un écart à travers un trou est un pas (le détecteur des sauts le prend), pas une pente
signes += sum((niv[j] > niv[k]) - (niv[j] < niv[k]) for k in range(i, j)) # tau de Kendall, pas à pas
pas = max(pas, abs(niv[j] - niv[j - 1]))
n, d = j - i + 1, niv[j] - niv[i]
if n >= JOURS and d and abs(d) >= MORCEAU * ampl and pas <= abs(d) / 2 \
and signes * (1 if d > 0 else -1) >= REGULIER * n * (n - 1) / 2:
morceaux.append((d, i, j))
pris = []
for d, i, j in sorted(morceaux, key=lambda x: (-abs(x[0]), x[2] - x[1])):
if all(j <= a or i >= b for _, a, b in pris):
pris.append((d, i, j))
return [(d, j - i + 1, min(m["t"] for m in jours[ds[i]]), max(m["t"] for m in jours[ds[j]])) for d, i, j in pris]
def _commune(mesures, cols):
"""Au moins GROS des capteurs dérivent du même côté sur un même axe de cols."""
for col in cols:
signes = [x[0] > 0 for ms in mesures.values() if (x := _derive(ms, col))]
if max(signes.count(True), signes.count(False)) >= GROS * len(mesures):
return True
return False
def derive(mesures):
cibles = {s: ms for s, ms in mesures.items() if not donnees.est_reference(ms)}
camera = _commune(cibles, ("corr_x", "corr_y")) and _commune(mesures, ("x", "y")) # point 5 : morceaux seuls
out = []
for s, ms in sorted(mesures.items()):
if donnees.est_reference(ms):
continue
r = [] if camera else [x for col in ("corr_x", "corr_y") if (x := _derive(ms, col))]
r = [max(r, key=lambda x: abs(x[0]))] if r else [x for col in ("corr_x", "corr_y") for x in _morceaux(ms, col)]
out += [{"start": donnees.iso(a), "end": donnees.iso(b), "kind": "Displacement", "label": "Slow drift",
"text": f"{s} drifts slowly and steadily: {derive:+.2f} px in {n} days. Keep watching it.",
"ignore": False, "sensors": [s]} for derive, n, a, b in r]
return out
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"])
-162
View File
@@ -1,162 +0,0 @@
"""Lecture des données d'une station pour l'agent de diagnostic (bibliothèque standard).
Formats : labeling/connaissances/colonnes-des-deplacements.md. Toute heure est en UTC.
"""
import csv
import glob
import os
import re
import statistics
from datetime import datetime, timezone
# Colonnes numériques de l'export « advanced » ; une case vide devient None.
NUM = ("x", "y", "error_value", "error_threshold", "relative_x", "relative_y",
"corr_x", "corr_y", "reproj_err", "inlier", "sigma0",
"peak", "flux", "sharpness", "fwhm", "dominance", "snr") # qualité de l'image : caméras récentes seulement (LENZSPITZE)
# Pose de la caméra (camera/, pompage) : pan, tilt, rotation [deg], scale, sigma0 (résidu du recalage).
POSE = ("pan", "tilt", "rotation", "scale", "sigma0")
IMAGE_RE = re.compile(r"^(\d{8}T\d{4})Z_")
def _entete(chemin):
with open(chemin, newline="") as f:
return next(csv.reader(f), [])
def trouver(dossier):
"""Dossier de station -> {'advanced', 'horaire', 'camera', 'images', 'autres'} : chemins triés, sous-dossiers compris."""
out = {"advanced": [], "horaire": [], "camera": [], "images": [], "autres": []}
for p in sorted(glob.glob(os.path.join(dossier, "**", "*"), recursive=True)):
if os.path.isdir(p) or "images_diff" in p.split(os.sep): # images différentielles du pompage (--diff) : pas des vues de la caméra
continue
entete = _entete(p) if p.endswith(".csv") else []
if p.lower().endswith((".jpg", ".jpeg", ".png")):
out["images"].append(p)
elif "sensor_name" in entete and "corr_x" in entete: # quality/ (optical_emulator) a sensor_name, pas corr_x
out["advanced"].append(p)
elif "timestamp" in entete:
out["horaire"].append(p)
elif "median_pan" in entete:
out["camera"].append(p)
else:
out["autres"].append(p)
return out
def _nombre(v):
v = v.strip()
return float(v) if v else None
def charger(dossier):
"""Exports « advanced » du dossier -> {capteur: [mesure]}, triées par t, un seul relevé par instant.
Mesure : dict avec t (datetime UTC), pattern_type, et les colonnes de NUM (float ou None).
Une mesure rejetée (voir rejetee) a corr_x, corr_y vides, comme le dit la doc des colonnes : la station
les vide pour une cible, mais en laisse de remplis (souvent absurdes) pour une référence ; on les vide ici.
"""
par = {}
for chemin in trouver(dossier)["advanced"]:
with open(chemin, newline="") as f:
for r in csv.DictReader(f):
m = {c: _nombre(r.get(c) or "") for c in NUM} # inlier manque dans les exports anciens
m["t"] = instant(r["time_utc"])
m["pattern_type"] = r["pattern_type"]
if rejetee(m):
m["corr_x"] = m["corr_y"] = None
par.setdefault(r["sensor_name"].strip(), {})[m["t"]] = m # certains exports finissent le nom par un saut de ligne
return {s: [d[t] for t in sorted(d)] for s, d in par.items()}
def charger_temperature(dossier):
"""Températures de la carte de la station (metrics/, sensor_*_deg_c) -> [(t, °C)] triées : la médiane des composants à
chaque heure ; [] sans ces métriques. Les composants montent et descendent ensemble (l'étiqueteur lit « les
températures de tous les composants ») ; la médiane écarte la pointe d'un seul, le GPU qui calcule (D-124)."""
par = {}
for chemin in glob.glob(os.path.join(dossier, "metrics", "*_deg_c_*.csv")):
with open(chemin, newline="") as f:
for r in csv.DictReader(f):
if (v := _nombre(r.get("metric") or "")) is not None:
par.setdefault(instant(r["time_utc"]), []).append(v)
return [(t, statistics.median(v)) for t, v in sorted(par.items())]
def charger_camera(dossier):
"""Mouvements de la caméra du dossier -> [pose] triées par t ; pose : t et les colonnes de POSE (float ou None).
Une ligne par recalage de la caméra ; on lit les médianes (min = max dans les fichiers reçus : une mesure par minute).
Un instant de mesure sans pose : la caméra n'a pas été recalée.
"""
par = {}
for chemin in trouver(dossier)["camera"]:
with open(chemin, newline="") as f:
for r in csv.DictReader(f):
p = {c: _nombre(r.get("median_" + c, "")) for c in POSE}
p["t"] = instant(r["time_utc"])
par[p["t"]] = p
return [par[t] for t in sorted(par)]
IDENTIFIANTS = re.compile(r"^(SIM_CCID|ip(_.*)?)$") # identifiants de la station : jamais lus
METRIQUE_RE = re.compile(r"^(.+?)_\d{4}_\d{2}_\d{2}_")
def charger_metriques(dossier):
"""Métriques de la station (metrics/, un CSV par métrique et par jour) -> {nom: [(t, valeur)]} triées : les
valeurs numériques seulement (BusVoltage, sensor_CPU_deg_c, rsrp_dBm…) ; les métriques texte (link, mode…) et les
identifiants (SIM_CCID, ip*) ne sont pas lus. Nom : celui du fichier, sans la station ni la date."""
# ponytail: les métriques texte sont sautées ; les lire (link up/down) quand un détecteur en a besoin
station, par = os.path.basename(os.path.normpath(dossier)) + "_", {}
for chemin in glob.glob(os.path.join(dossier, "metrics", "*.csv")):
if not (m := METRIQUE_RE.match(os.path.basename(chemin))):
continue
nom = m.group(1).removeprefix(station)
if IDENTIFIANTS.match(nom):
continue
with open(chemin, newline="") as f:
for r in csv.DictReader(f):
try:
v = float((r.get("metric") or "").strip("[]'\" ")) # certaines métriques arrivent en liste : ['-95']
except ValueError:
continue
par.setdefault(nom, {})[instant(r["time_utc"])] = v
return {n: sorted(d.items()) for n, d in sorted(par.items())}
def est_reference(mesures):
"""Référence du réseau de compensation (pattern_type global_ref), sinon cible. Certains exports ont pattern_type vide,
sur toute la période ou au début : on lit alors le premier pattern_type rempli et, s'il n'y en a aucun, reproj_err
ou inlier remplis (références seulement : labeling/connaissances/colonnes-des-deplacements.md)."""
t = next((m["pattern_type"] for m in mesures if m["pattern_type"]), None)
if t is not None:
return t == "global_ref"
return any(m["reproj_err"] is not None or m["inlier"] is not None for m in mesures)
def rejetee(m):
"""Mesure rejetée par la station : error_value au-dessus du seuil du capteur (error_threshold) ; sans ces deux valeurs, corr_x vide."""
if m["error_value"] is not None and m["error_threshold"] is not None:
return m["error_value"] > m["error_threshold"]
return m["corr_x"] is None
def filtrer(mesures, debut, fin):
"""Mesures entre debut et fin inclus, à la minute près (comme iso() les affiche) ; None = pas de borne."""
return [m for m in mesures if (debut is None or m["t"] >= debut)
and (fin is None or m["t"].replace(second=0, microsecond=0) <= fin)]
def heure_image(chemin):
"""'20261013T1200Z_10167931.jpg' -> datetime UTC ; None si le nom ne suit pas ce format (D-045)."""
m = IMAGE_RE.match(os.path.basename(chemin))
return datetime.strptime(m.group(1), "%Y%m%dT%H%M").replace(tzinfo=timezone.utc) if m else None
def instant(texte):
"""'2026-01-01T00:00Z' ou '2026-01-01 00:00' -> datetime UTC ; une heure sans fuseau est lue en UTC."""
t = datetime.fromisoformat(texte)
return t.astimezone(timezone.utc) if t.tzinfo else t.replace(tzinfo=timezone.utc)
def iso(t):
return t.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%MZ")
-43
View File
@@ -1,43 +0,0 @@
"""Journal du matin : le détecteur de la famille No data (labeling/familles.md) : 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. Fin de la fenêtre lue (fin, si
l'appelant la donne : le tri en lot de categories.py) : la même règle entre la dernière mesure et fin, l'épisode allant
jusqu'à fin (boucle CLARIDEN, lot 01 : 44 h sans mesure jusqu'à la fin du lot, non signalées). 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 detectors/no_data.py <dossier de station> (affiche les épisodes)
"""
import os
import statistics
import sys
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) # donnees.py, à côté
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, fin=None):
"""fin : fin de la fenêtre lue (datetime, exclue), facultative ; sans elle, un trou final n'est pas vu."""
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)
out = [(a, b, g, "") for a, b, g in zip(ts, ts[1:], gaps)]
if fin: # fin exclue : la dernière mesure attendue est à fin − 1 pas, l'écart se compte comme entre deux mesures
out.append((ts[-1], fin, (fin - ts[-1]).total_seconds(), ", up to the end of the period"))
return [{"start": iso(a), "end": iso(b), "kind": "No data", "label": "No data",
"text": f"No measurement in the export for {duration(g)}{fin_txt} (usually one every {duration(step)}).",
"ignore": False, "sensors": []}
for a, b, g, fin_txt in out if g > (MISSING + 1) * step]
if __name__ == "__main__":
for e in detect(charger(sys.argv[1])):
print(e)
-38
View File
@@ -1,38 +0,0 @@
"""Journal du matin : le détecteur de la famille Obstruction (labeling/familles.md) : un objet cache une ou quelques
cibles, un instant ou longtemps. Il reprend deux calculs partagés avec d'autres familles :
- l'error_value de visibility.py : Brief obstruction (un passage, un instant) et Target obscured (une cible rejetée à
répétition quand les autres restent vues, ou une gêne qui ne touche que quelques cibles, sans référence) ;
- les rejets jour après jour de target_issue.py : une cible rejetée moins d'une semaine, Target obscured.
Un capteur déjà dans un épisode Target issue (Degraded target, Target stuck) qui le chevauche n'est pas rendu en
Obstruction : sa courbe est déjà à ignorer, la famille est Target issue (frontière « Target issue ou épisode d'une autre
famille » de labeling/familles.md ; /detector-learner Obstruction, modification 1 : S1, cibles à problème de FLORIDA,
NORDEND, SNCF01, NIEDERHORN, JUNGFRAU, CLARIDEN découpées en Target obscured ; S3, leurs rejets isolés en Brief obstruction).
Usage : python3 detectors/obstruction.py <dossier de station> (affiche les épisodes)
"""
import os
import sys
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) # donnees.py, à côté
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import target_issue # noqa: E402
import visibility # noqa: E402
from donnees import charger # noqa: E402
def detect(mesures):
ti = target_issue.episodes(mesures)
issues = [e for e in ti if e["kind"] == "Target issue"]
out = []
for e in visibility.episodes(mesures) + ti:
if e["kind"] != "Obstruction":
continue
pris = {s for h in issues if h["start"] <= e["end"] and h["end"] >= e["start"] for s in h["sensors"]}
if not (e := {**e, "sensors": [s for s in e["sensors"] if s not in pris]})["sensors"]: # sans les capteurs déjà
continue # en Target issue
out.append(e)
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]), "|", e["text"])
+243
View File
@@ -0,0 +1,243 @@
"""From the detectors' episodes to events, one per family.
One detector per label family (labeling/familles.md): visibility.py, obstruction.py, target_issue.py,
thermal_displacement.py, no_data.py, displacement.py. The category of an event is its family, the kind field of its
episodes; their label gives the variety (Poor visibility, Heat shimmer, Brief obstruction, Slow drift…). Rules:
- a jump back to normal (JUMP_BACK) that overlaps an episode of HOSTS (loss of visibility, something passing, heat
shimmer, and last the thermal effect, if it touches several targets) is absorbed into it: it takes its cause and
family; otherwise it stays Displacement, cause not established, to be checked on the images (familles.md, "A jump then
the return"); a Brief obstruction (one instant) only absorbs the jumps starting at its instant, not those of several
days it crosses (learner session Displacement, mod. 1, S5);
- a slow drift or a jump back whose targets are all in an overlapping Target issue episode is absorbed into it (the
curve of a problem target is to be ignored, familles.md);
- a shift that lasts, or too recent to know (SHIFTS), is never absorbed;
- heat shimmer overlapping a shift of several targets is not kept: a real movement also shakes the curves; the shift of
a single target does not remove the heat shimmer of the whole scene, and heat shimmer only absorbs the jumps back
starting during it, not the one of the day before coming back within its day (learner session Visibility, mod. 1,
S1: WILDSTRUBEL);
- two events of the same variety less than MERGE apart make one; two Obstruction (Target obscured, Brief obstruction)
only if they share a sensor (learner session Obstruction, mod. 1: S1, different targets chained into an event of
several days; S3, passings of a few minutes into a whole hour); two Target issue too: each problem target keeps its
bounds (learner session Target issue, mod. 1, S3); a Brief obstruction only absorbs the jumps back within MERGE after
its instant (S3: not the 30 h jump of another target).
Each event gets its sentence, in English (the site): what happened and what to do about it, as the "For the client"
column of familles.md says; the cause is only given if the variety establishes it, otherwise the images show it.
No detect function: the loader does not take this file for a detector.
Usage: python3 detectors/scripts/categories.py <station folder> (one line per event: family, variety, sensors)
... <folder> [--from YYYY-MM-DD] [--to YYYY-MM-DD] [--chunk 3] [--history N] (batch run: each chunk of N days
classified alone, with the days of history before it if they exist; only the events touching the chunk are
shown; "nothing" for a quiet chunk)
"""
import functools
import importlib.util
import inspect
import os
import sys
from datetime import datetime, timedelta, timezone
from pathlib import Path
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) # data.py, next to it
from data import iso, load, load_camera, load_metrics, load_temperature # noqa: E402
# What a detector can read from the station besides the measurements, if it declares it in detect (D-124, D-134):
# temperature [(t, °C)], hourly median of the components; camera [pose] (pan, tilt, rotation, scale, sigma0);
# metrics {name: [(t, value)]}, all numeric metrics (sensor_CPU_deg_c, sensor_GPU_deg_c, BusVoltage…).
CONTEXT = {"temperature": load_temperature, "camera": load_camera, "metrics": load_metrics}
@functools.lru_cache(maxsize=None)
def _context(folder, key):
return CONTEXT[key](folder)
# The families of labeling/familles.md, in the order of the timeline rows; ignore: greyed zone (None: as its episodes
# say: a total loss of visibility, strong heat shimmer); process: Images button, nothing, or Images and a link to
# Diagnosis.
CATEGORIES = {
"Visibility": {"ignore": None, "process": "images"},
"Obstruction": {"ignore": True, "process": "images"},
"Target issue": {"ignore": True, "process": "images"},
"Thermal displacement": {"ignore": False, "process": "none"},
"No data": {"ignore": False, "process": "none"},
"Displacement": {"ignore": False, "process": "check"},
}
JUMP_BACK = "Sudden jump, back to normal" # a jump back: its cause, if it overlaps a host; otherwise Displacement
SHIFTS = {"Lasting shift", "Jump, not back yet", "Large shift"} # to be checked: never absorbed
HOSTS = {"Poor visibility", "Brief obstruction", "Heat shimmer", "Thermal expansion", "Thermal contraction",
"Camera thermal expansion", "Camera thermal contraction", "Camera thermal movement"} # give the cause of an
# overlapping jump back
MERGE = timedelta(hours=1) # same variety less than an hour apart: a single event (validated rule, 2026-10-24)
def detectors():
"""Modules of the *.py next to this file that have detect; a file that does not load is skipped with a 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"detector_{path.stem}", path)
mod = importlib.util.module_from_spec(spec)
spec.loader.exec_module(mod)
except Exception as e: # noqa: BLE001 (a broken detector does not block the page)
print(f"Detectors: {path.name} skipped ({type(e).__name__}: {e})", file=sys.stderr)
continue
if hasattr(mod, "detect"):
mods.append(mod)
return mods
def variety(ep):
"""The variety of an episode within its family: shifts together, the thermal effect without "Camera", the loss of
visibility by level."""
label = "shift" if ep["label"] in SHIFTS else ep["label"].removeprefix("Camera ").capitalize()
return ep["kind"], label, ep.get("level")
def is_thermal(ep):
return ep["kind"] == "Thermal displacement"
def overlap(a, b):
return a["start"] <= b["end"] and a["end"] >= b["start"] # data.iso times: text order is time order
def targets(n):
return "one target" if n == 1 else f"{n} targets"
def sentence(group, sensors, references):
"""Sentence of an event (validated by the user on 2026-10-24), from the variety of its main episode; an absorbed
jump adds that it has the same cause."""
n, one, ep = len(sensors), len(sensors) == 1, group[0]
jumps = [e for e in group[1:] if e["label"] == JUMP_BACK]
jumped = len({s for e in jumps for s in e["sensors"]})
lasting = len({s for e in group if e["label"] in SHIFTS for s in e.get("lasting", [])})
refs = ", including the reference targets" if references & set(sensors) else ""
camera = ep["label"].startswith("Camera")
large = any(e["label"] == "Large shift" for e in group)
sort = "shift" if ep["label"] in SHIFTS else f"{ep['label']} {ep['level']}" if ep.get("level") else ep["label"]
text = {
"Poor visibility none": f"The camera could not see {targets(n)} clearly{refs}. "
"The curves in this period are not reliable: ignore them.",
"Poor visibility reduced": f"The camera saw {targets(n)} less clearly than usual{refs}. "
"The data in this period are less precise: use them with care.",
"Brief obstruction": f"Something passed in front of {targets(n)} for a single measurement. Ignore this point on the curves.",
"Target obscured": 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.",
"Heat shimmer": "Warm air made the readings shake. The small fast wiggles are not movement.",
"expansion": ("The camera support expands in the day heat; the curves are corrected for it."
if camera else "The structure expands in the day heat.") + " This daily wave is normal: nothing to do.",
"contraction": ("The camera support contracts as it cools down; the curves are corrected for it."
if camera else "The structure contracts as it cools down.") + " This daily wave is normal: nothing to do.",
JUMP_BACK: f"{targets(n).capitalize()} jumped and came back. The cause is not established: look at the images.",
"shift": (f"{targets(n).capitalize()}, most of the targets, shifted together: everything moved." if large
else 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(sort.split()[-1] if is_thermal(ep) else sort, ep["text"]) # No data, Target issue, Slow drift: the detector's text
if ep["kind"] == "Target issue":
text += f" Ignore {'its curve' if one else 'their curves'} in this period and look at the images of the target."
if not jumped:
return text
return text + (f" The jump of {targets(jumped)} in this period has the same cause." if len(jumps) == 1
else f" The jumps of {targets(jumped)} in this period have the same cause.")
def event(group, references):
"""Episodes of the same event, the main one first -> event."""
cat, var = group[0]["kind"], variety(group[0])
c = CATEGORIES.get(cat, {"ignore": None, "process": "none"})
sensors = [] if any(not e["sensors"] for e in group) else list(dict.fromkeys(s for e in group for s in e["sensors"]))
main = [e for e in group if variety(e) == var] # the duration is the main episodes', not the absorbed jumps'
return {"start": min(e["start"] for e in main), "end": max(e["end"] for e in main), "category": cat,
"label": cat, "text": sentence(group, sensors, references),
"ignore": c["ignore"] if c["ignore"] is not None else any(e["ignore"] for e in main),
"sensors": sensors, "process": c["process"], "episodes": group}
def classify(episodes, references=frozenset()):
"""Episodes of all detectors -> events sorted by start (rules: module docstring); references: the global_ref
sensors, for the sentence."""
eps = sorted(episodes, key=lambda e: e["start"])
# a real movement is never taken for heat shimmer; the shift of a single target is not a movement of the scene
checks = [e for e in eps if e["label"] in SHIFTS and len(e["sensors"]) > 1]
eps = [e for e in eps if e["label"] != "Heat shimmer" or not any(overlap(e, c) for c in checks)]
# the thermal wave absorbs last (a jump of something passing or of rain goes to them), and only the jumps of several
# targets: the wave moves them together, a single target that jumps is not the wave (C2 of E-003)
hosts = sorted((e for e in eps if e["label"] in HOSTS), key=is_thermal)
host = {id(e): next((h for h in hosts if overlap(e, h) and (len(e["sensors"]) > 1 or not is_thermal(h))
and (h["label"] != "Heat shimmer" or h["start"] <= e["start"])
and (h["label"] != "Brief obstruction" or e["start"] == h["start"]
and datetime.fromisoformat(e["end"]) - datetime.fromisoformat(h["start"]) <= MERGE)), None)
for e in eps if e["label"] == JUMP_BACK}
# a drift or a jump back whose targets are all in an overlapping Target issue episode: its curve is to be ignored,
# it takes its family (learner session Displacement, mod. 1, S6)
host.update({id(e): h for e in eps if e["label"] in (JUMP_BACK, "Slow drift") and not host.get(id(e))
and (h := next((h for h in eps if h["kind"] == "Target issue" and overlap(e, h)
and set(e["sensors"]) <= set(h["sensors"])), None))})
groups = {id(e): [e] for e in eps if not host.get(id(e))}
for e in eps:
if host.get(id(e)):
groups[id(host[id(e)])].append(e)
merged = []
for g in groups.values():
prev = next((m for m in reversed(merged) if variety(m[0]) == variety(g[0]) and (g[0]["kind"] not in ("Obstruction", "Target issue")
or set(g[0]["sensors"]) & {s for e in m for s in e["sensors"]})), None)
end = max((e["end"] for e in prev if variety(e) == variety(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((event(g, references) for g in merged), key=lambda v: v["start"])
def events(measurements, end=None, folder=None):
"""Measurements (data.load) -> events of all detectors: what the page receives. A detector also receives what its
detect function declares: end, the end of the window read (batch run), for a hole touching it; a CONTEXT key, read
from the station folder (once per folder), empty without a folder."""
episodes = []
for mod in detectors():
try:
params = inspect.signature(mod.detect).parameters
kw = {k: _context(folder, k) if folder else {} if k == "metrics" else [] for k in CONTEXT if k in params}
if "end" in params:
kw["end"] = end
episodes += mod.detect(measurements, **kw)
except Exception as e: # noqa: BLE001
print(f"Detectors: {mod.__name__} skipped ({type(e).__name__}: {e})", file=sys.stderr)
return classify(episodes, {s for s, ms in measurements.items() if ms[0]["pattern_type"] == "global_ref"})
if __name__ == "__main__":
import argparse
p = argparse.ArgumentParser(description="One line per event; --chunk: each chunk classified alone.")
p.add_argument("folder")
p.add_argument("--from", dest="start", help="first UTC day, YYYY-MM-DD (default: start of the data)")
p.add_argument("--to", dest="end", help="last UTC day, excluded, YYYY-MM-DD (default: end of the data)")
p.add_argument("--chunk", type=int, default=0, help="days per chunk (default: a single pass)")
# without history, a chunk starting just before a real jump takes it for a jump back (PR17 at NORDEND, 08/10 02:30:
# absorbed into the fog); 3 days give it back; user's rule (2026-10-24): 3 days of history by default, in the
# learner as in the real application
p.add_argument("--history", type=int, default=3, help="days of earlier measurements given to the detectors (default 3)")
a = p.parse_args()
measurements = load(a.folder)
ts = [m["t"] for ms in measurements.values() for m in ms]
day = lambda d: datetime.strptime(d[:10], "%Y-%m-%d").replace(tzinfo=timezone.utc) # noqa: E731
start = day(a.start) if a.start else min(ts).replace(hour=0, minute=0, second=0, microsecond=0)
end = day(a.end) if a.end else max(ts) + timedelta(seconds=1)
t = start
while t < end:
b = min(t + timedelta(days=a.chunk), end) if a.chunk else end
h = t - timedelta(days=a.history)
chunk = {s: k for s, ms in measurements.items() if (k := [m for m in ms if h <= m["t"] < b])}
evs = [v for v in events(chunk, b, a.folder) if v["end"] >= iso(t)] if chunk else []
if a.chunk:
print(f"== {iso(t)} → {iso(b)}: {len(evs) or 'nothing'}")
for v in evs:
print(v["start"], "→", v["end"], f"{v['category']:<20}", "greyed" if v["ignore"] else "kept",
f"| {v['episodes'][0]['label']}", # the variety: the rule of the family's detector
f"| {len(v['sensors']) or 'all'} sensors", "| absorbed:", ", ".join(
f"{e['label']} {e['start'][5:16]}" for e in v["episodes"][1:]) or "—")
t = b
+140
View File
@@ -0,0 +1,140 @@
"""Reading a station folder (standard library only). Every time is UTC.
Column formats: labeling/connaissances/colonnes-des-deplacements.md in Diagnostic-app.
"""
import csv
import glob
import os
import re
import statistics
from datetime import datetime, timezone
# Numeric columns of the "advanced" export; an empty cell becomes None.
NUM = ("x", "y", "error_value", "error_threshold", "relative_x", "relative_y",
"corr_x", "corr_y", "reproj_err", "inlier", "sigma0",
"peak", "flux", "sharpness", "fwhm", "dominance", "snr") # image quality: recent cameras only (LENZSPITZE)
# Camera pose (camera/): pan, tilt, rotation [deg], scale, sigma0 (registration residual).
POSE = ("pan", "tilt", "rotation", "scale", "sigma0")
IDENTIFIERS = re.compile(r"^(SIM_CCID|ip(_.*)?)$") # station identifiers: never read
METRIC_RE = re.compile(r"^(.+?)_\d{4}_\d{2}_\d{2}_")
def _header(path):
with open(path, newline="") as f:
return next(csv.reader(f), [])
def find_files(folder):
"""Station folder -> {'advanced': [...], 'camera': [...]}: sorted CSV paths, subfolders included."""
out = {"advanced": [], "camera": []}
for p in sorted(glob.glob(os.path.join(folder, "**", "*.csv"), recursive=True)):
header = _header(p)
if "sensor_name" in header and "corr_x" in header: # quality/ (optical_emulator) has sensor_name, not corr_x
out["advanced"].append(p)
elif "median_pan" in header and "timestamp" not in header: # timestamp: the hourly export
out["camera"].append(p)
return out
def _number(v):
v = v.strip()
return float(v) if v else None
def load(folder):
""""advanced" exports of the folder -> {sensor: [measurement]}, sorted by t, one reading per instant.
Measurement: dict with t (UTC datetime), pattern_type, and the NUM columns (float or None).
A rejected measurement (see rejected) has empty corr_x, corr_y, as the column docs say: the station empties them
for a target but leaves some filled (often absurd) for a reference; they are emptied here.
"""
by = {}
for path in find_files(folder)["advanced"]:
with open(path, newline="") as f:
for r in csv.DictReader(f):
m = {c: _number(r.get(c) or "") for c in NUM} # inlier is missing from old exports
m["t"] = parse_time(r["time_utc"])
m["pattern_type"] = r["pattern_type"]
if rejected(m):
m["corr_x"] = m["corr_y"] = None
by.setdefault(r["sensor_name"].strip(), {})[m["t"]] = m # some exports end the name with a newline
return {s: [d[t] for t in sorted(d)] for s, d in by.items()}
def load_temperature(folder):
"""Station board temperatures (metrics/, sensor_*_deg_c) -> [(t, °C)] sorted: the median of the components at each
hour; [] without these metrics. The components rise and fall together; the median drops the spike of a single
one, the computing GPU (D-124)."""
by = {}
for path in glob.glob(os.path.join(folder, "metrics", "*_deg_c_*.csv")):
with open(path, newline="") as f:
for r in csv.DictReader(f):
if (v := _number(r.get("metric") or "")) is not None:
by.setdefault(parse_time(r["time_utc"]), []).append(v)
return [(t, statistics.median(v)) for t, v in sorted(by.items())]
def load_camera(folder):
"""Camera movements of the folder -> [pose] sorted by t; pose: t and the POSE columns (float or None).
One row per camera registration; the medians are read (min = max in the files received: one reading per minute).
A measurement instant without a pose: the camera was not registered.
"""
by = {}
for path in find_files(folder)["camera"]:
with open(path, newline="") as f:
for r in csv.DictReader(f):
p = {c: _number(r.get("median_" + c, "")) for c in POSE}
p["t"] = parse_time(r["time_utc"])
by[p["t"]] = p
return [by[t] for t in sorted(by)]
def load_metrics(folder):
"""Station metrics (metrics/, one CSV per metric and per day) -> {name: [(t, value)]} sorted: numeric values only
(BusVoltage, sensor_CPU_deg_c, rsrp_dBm…); text metrics (link, mode…) and identifiers (SIM_CCID, ip*) are not
read. Name: the file's, without the station or the date."""
# ponytail: text metrics are skipped; read them (link up/down) when a detector needs them
station, by = os.path.basename(os.path.normpath(folder)) + "_", {}
for path in glob.glob(os.path.join(folder, "metrics", "*.csv")):
if not (m := METRIC_RE.match(os.path.basename(path))):
continue
name = m.group(1).removeprefix(station)
if IDENTIFIERS.match(name):
continue
with open(path, newline="") as f:
for r in csv.DictReader(f):
try:
v = float((r.get("metric") or "").strip("[]'\" ")) # some metrics come as a list: ['-95']
except ValueError:
continue
by.setdefault(name, {})[parse_time(r["time_utc"])] = v
return {n: sorted(d.items()) for n, d in sorted(by.items())}
def is_reference(measurements):
"""Reference of the compensation network (pattern_type global_ref), otherwise a target. Some exports have an empty
pattern_type, over the whole period or at the start: the first filled pattern_type is read then and, if there is
none, filled reproj_err or inlier (references only)."""
t = next((m["pattern_type"] for m in measurements if m["pattern_type"]), None)
if t is not None:
return t == "global_ref"
return any(m["reproj_err"] is not None or m["inlier"] is not None for m in measurements)
def rejected(m):
"""Measurement rejected by the station: error_value above the sensor's threshold (error_threshold); without these
two values, an empty corr_x."""
if m["error_value"] is not None and m["error_threshold"] is not None:
return m["error_value"] > m["error_threshold"]
return m["corr_x"] is None
def parse_time(text):
"""'2026-01-01T00:00Z' or '2026-01-01 00:00' -> UTC datetime; a time without a zone is read as UTC."""
t = datetime.fromisoformat(text)
return t.astimezone(timezone.utc) if t.tzinfo else t.replace(tzinfo=timezone.utc)
def iso(t):
return t.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%MZ")
+327
View File
@@ -0,0 +1,327 @@
"""Detector of the Displacement family (labeling/familles.md): sudden jumps of corr_x / corr_y (px) of each target, at
the native cadence of the "advanced" export, and slow drift (end of file). A flipping target ("Target flipping")
belongs to the Target issue family: episodes() returns it, detect() leaves it to target_issue.py.
1. Noise of the series = median of the gaps from one measurement to the next; jump = measurement K noises or more away
from the level before (median of the BASE previous measurements); the first BASE measurements, lacking a level
before, are compared with the level after (median of the BASE next ones), a gap there is a jump back at once.
2. Back (an hour of measurements in a row within half the jump: BASE at 15 min, a single one at 4 h; learner
MICHIGAN, mod. 1) within a day, or one day later back at its usual place (first day of the export) or at the day
before's: "Sudden jump, back to normal", greyed; its cause is not established here (categories.py gives it the
cause of the category that overlaps it, otherwise: to be checked on the images).
3. Otherwise "Lasting shift", never greyed (maybe a real movement); less than a day of hindsight: "Jump, not back yet",
not greyed either.
4. Jumps following each other within GAP, all targets together, make a single episode (common mode); a single lasting
(or too recent) target is enough not to grey the episode.
5. Global references excluded; rejected measurements (empty corr) skipped.
6. Common peak (NORDEND, batch 01): at the same instant, at least PEAK_MIN targets move away by at least K_PEAK noises
from both neighbouring measurements, on the same side (the whole image shaken for one step): a jump back for each,
even under K. It joins the episodes of point 4 (next to a lasting jump, it greys nothing).
7. (CLARIDEN, batch 01) a jump that never comes back no longer ends the reading of the series, its new level becomes
the level before; an episode that is not greyed ends at its last jump, not at the returns; a flipping target
(REPEAT jumps back or more, each within a day of the previous one) makes a "back to normal" episode on its own, from
the first to the last flip, outside the common episodes. A target that flips for at least FLIP, with at most
MAX_FLIPPING targets at the same time, becomes "Target flipping" (Target issue, D-074); a lasting jump of at least
LARGE of the targets, "Large shift" (everything moved), always to be checked. Learner session Target issue, mod. 1,
S2: FLIP from 6 h to 36 h; a target flipping for a day during a nuisance of the whole scene (rain, fog, night of poor
visibility) is not a problem target; its jumps back go to the nuisance overlapping them, otherwise stay
Displacement.
8. Jump under K that stays (NIEDERHORN, batch 01): a jump of at least K_LASTING noises counts if it is lasting in the
sense of point 3 and the median of the day after moves away from that of the day before, on the jump's side, by at
least PLATEAU times the ordinary variation of the level from one UTC day to the next (median of the gaps between
daily levels); otherwise it is ignored (neither back nor too recent: only jumps of K noises or more are).
"""
import statistics
import sys
from datetime import timedelta
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parent)) # data.py, next to it
import data # noqa: E402
K = 20 # tuned on E-001: at 15, two healthy targets are greyed (17 and 18 noises); the trains of E-005 (17 and 19
# noises) are caught by visibility.py: do not lower K
K_LASTING = 7 # under K, a jump that stays counts from K_LASTING noises (NIEDERHORN, batch 01: e09, corr_y −0.18 px at
# once, 8 noises, stayed 5 days)
PLATEAU = 8 # ... if it stays: median of the day after, on the jump's side, PLATEAU times the ordinary variation of the
# level from one day to the next away from the day before (e09: 13; E-001, healthy targets: 6 at most)
K_PEAK = 6 # one-step peak common to several targets (NORDEND shakes, 6 to 11 noises, batch 01)
PEAK_MIN = 3 # targets peaking at the same step for a common peak (one or two: ordinary noise)
BASE = 4 # measurements that make the level before (1 h at 15 min)
GAP = timedelta(hours=1) # two jumps within an hour, all targets together: a single episode
BACK_H = 24 # back within a day = artefact (E-002: plateaus up to 11.5 h)
FLIP = timedelta(hours=36) # a problem target flips for several days (PR_BG: 2.5 days); less is an agitated morning
# (E-009: C8 and C13, 5 flips in 1 h 20 during the movement) or a night of nuisance (NORDEND, JUNGFRAU:
# 12 to 28 h within a loss of visibility), a jump back, absorbed by its host
MAX_FLIPPING = 2 # targets flipping at the same time, at most (FLORIDA: the two stuck ones; E-002, cobweb on the
# references: 15 at once)
LARGE = 0.5 # share of the targets of a lasting jump for a large shift (E-004: almost all)
REPEAT = 5 # jumps back of the same target, each within a day of the other, that make it a flipping target (PR_BG of
# CLARIDEN, batch 01: about thirty in 2.5 days)
def _jumps(t, v):
"""A series (instants, values) -> [(start i, end i, state)], state 'back', 'lasting' or 'recent'."""
day = timedelta(hours=BACK_H)
noise = statistics.median(abs(y - x) for x, y in zip(v, v[1:]))
step = statistics.median(b - a for a, b in zip(t, t[1:])) # cadence of the series
back_n = max(1, min(BASE, round(timedelta(hours=1) / step))) # measurements of an hour (BASE at 15 min, one at 4 h)
# ponytail: usual place = first day of the export, wrong if it starts within an artefact
ref = statistics.median(x for x, u in zip(v, t) if u < t[0] + day)
lv = {} # level of each UTC day; its ordinary variation from one day to the next judges a jump under K
for x, u in zip(v, t):
lv.setdefault(u.date(), []).append(x)
lv = [statistics.median(x) for _, x in sorted(lv.items())]
ordinary = statistics.median(abs(b - a) for a, b in zip(lv, lv[1:])) if len(lv) > 2 else 0
# the first BASE measurements, lacking a level before, face the level after: a gap there came back at once
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_LASTING * noise:
i += 1
continue
tol = abs(v[i] - base) / 2 # back: an hour of measurements in a row within half the jump from the level before
j = next((k for k in range(i + 1, len(v)) if all(abs(x - base) < tol for x in v[k:k + back_n])), 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: # the day after, the target is at its usual place,
state, j = "back", i + 1 # or where it was the day before: the jump ended a dip
else:
state = "lasting" if t[-1] - t[i] >= day else "recent" # less than a day of hindsight: not known yet
if abs(v[i] - base) < K * noise and (state != "lasting" or (after - before) * (v[i] - base) < 0
or not ordinary or abs(after - before) < PLATEAU * ordinary):
i += 1 # under K, only a jump that stays counts: the day after far from the day before, on its side
continue
out.append((i, j - 1, state))
# level before rebuilt after the return; never back: the new level becomes the level before, the rest is
# still read (PR_BG of CLARIDEN, batch 01: its flips after the 10:30 jump were invisible)
i = (j if j < len(v) else i) + BASE
return out
def _peaks(t, v):
"""Instants where the measurement moves away by at least K_PEAK noises from both neighbours, same side (one-step peak)."""
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_PEAK * noise]
def episodes(measurements):
"""{sensor: [measurement]} (data.load) -> jump episodes, sorted by start: Displacement, and Target issue for a
flipping target."""
found = [] # (start, end, state, sensor)
peaks = {} # instant -> targets peaking there for one step
for name, ms in measurements.items():
if data.is_reference(ms):
continue
for axis in ("corr_x", "corr_y"):
kept = [m for m in ms if m[axis] is not None]
if len(kept) <= BASE:
continue
t, v = [m["t"] for m in kept], [m[axis] for m in kept]
# a jump that did not come back ends with itself, not with the data (its bar hid the others)
found += [(t[a], t[b] if state == "back" else t[a], state, name) for a, b, state in _jumps(t, v)]
for u in _peaks(t, v):
peaks.setdefault(u, set()).add(name)
found += [(u, u, "back", s) for u, cs in peaks.items() if len(cs) >= PEAK_MIN for s in cs] # common peak: back
alone = _flips(found) # a target that keeps jumping and coming back: an episode on its own, outside the common ones
found = [f for f in found if f[2] != "back" or not any(f[3] in g["sensors"] and g["start"] <= f[0] <= g["end"]
for g in alone)]
groups = [] # a jump that did not come back only counts by its instant: its end is often the end of the data
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, "last": s, "sensors": {}}
groups.append(g)
g["end"], g["until"], g["last"] = max(g["end"], e), max(g["until"], e if state == "back" else s), s
g["sensors"].setdefault(name, set()).add(state)
long = [g for g in alone if g["flip"]] # flips of many targets at the same time: the compensation, not a
for g in long: # problem target
if sum(h["start"] <= g["end"] and h["end"] >= g["start"] for h in long) > MAX_FLIPPING:
g["flip"] = 0
total = sum(not data.is_reference(ms) for ms in measurements.values())
return sorted((_episode(g, total) for g in groups + alone), key=lambda ep: ep["start"])
def _flips(found):
"""Jumps back of the same target, each within BACK_H of the previous one: REPEAT or more -> a group, from the first
to the last flip."""
day, alone = timedelta(hours=BACK_H), []
for name in {f[3] for f in found}:
chain = [] # (start, end); corr_x and corr_y twice: counted by instant
for s, e in sorted({(s, e) for s, e, state, n in found if n == name and state == "back"}) + [(None, None)]:
if chain and s is not None and s <= max(c[1] for c in chain) + day:
chain.append((s, e))
continue
if len({c[0] for c in chain}) >= REPEAT:
alone.append({"start": chain[0][0], "end": max(c[1] for c in chain), "sensors": {name: {"back"}},
"flip": len({c[0] for c in chain}) if max(c[1] for c in chain) - chain[0][0] >= FLIP else 0})
chain = [(s, e)]
return alone
def _episode(g, total):
"""A group -> episode; a single lasting (or too recent) jump is enough not to grey; a flipping target: "Target
flipping" (Target issue, D-074); a lasting jump of LARGE targets or more: "Large shift"."""
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 g.get("flip"):
name = next(iter(g["sensors"]))
return {"start": data.iso(g["start"]), "end": data.iso(g["end"]), "kind": "Target issue", "label": "Target flipping",
"text": f"{name} jumped and came back {g['flip']} times: its tracking is not reliable, look at the images "
"of the target.", "ignore": True, "sensors": [name], "lasting": []}
if lasting and n >= LARGE * total:
label = "Large shift"
text = f"{n} targets jumped together and {lasting} of them stayed shifted: everything moved, please check it."
elif 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: the cause is not established, look at the images."
end = g["last"] if lasting or recent else g["end"] # not greyed: the last jump, not the returns
return {"start": data.iso(g["start"]), "end": data.iso(end), "kind": "Displacement", "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)} # stayed shifted (event sentence)
def detect(measurements):
return sorted([e for e in episodes(measurements) if e["kind"] == "Displacement"] + drift(measurements),
key=lambda ep: ep["start"])
# --- Slow drift ------------------------------------------------------------------------------------------------------
# A target that moves little by little, day after day. Takes up the trend of the Displacements tab (D-055) on the
# "advanced" export (corr_x, corr_y, px). Method, per target (global references excluded) and per axis:
# 1. Level of the day: median of the measurements of each UTC day with at least HOURS measured hours out of 24, as a
# share of the hours the station measures (learner MICHIGAN, mod. 1: at one measurement every 4 h, 5 of the 6 hours;
# before, no day counted); at least DAYS days.
# 2. Theil-Sen slope and Kendall tau of the daily levels; amplitude of the day: gap between its 9th and 1st deciles.
# 3. Drift: |slope| × duration ≥ SIZE times the median daily amplitude, |tau| ≥ STEADY, and no step from one day to the
# next of more than half the drift (a jump that lasts is not a drift: the jump rule takes it).
# 4. One episode per target (one axis is enough), from the first measurement of the first day to the last of the last
# day; not greyed.
# 4b. Piecewise (learner session Displacement, mod. 1, S1): a target without a drift over the whole window may drift for
# a few days, then settle or go back. On each run of at least DAYS kept days, drift = level of the last day minus
# that of the first, at least PIECE daily amplitudes (median of the series), |tau| ≥ STEADY with the same sign, no
# step from one kept day to the next of more than half the drift; pieces taken from the largest drift to the
# smallest, without overlapping (they may share the day where the level turns): each goes from one extreme of the
# level to the other, one episode per piece and per axis. At PIECE = 1, the thermal cycles of a few days and the
# noise of the levels get through (JUNGFRAU, NORDEND): 3.5 keeps the rows of CLARIDEN (3.8 to 8.3 amplitudes),
# drops JUNGFRAU (3.1 at most). The pieces do not replace step 3. A piece does not cross a hole: two consecutive kept
# days are at most MAX_HOLE days apart (mod. 2: the gap of a level across three days without a measurement is a
# step, not a slope; it made pieces of the whole window, CLARIDEN 09-28 → 11-01). A missing day does not cut.
# 5. Camera drift (same mod.): at least LARGE of the targets drift on the same side on corr_x or corr_y, and at least
# LARGE of the sensors, references included, on their raw positions x or y: only the pieces of point 4b are
# reported, not the trend over the whole window (mod. 1, S2: the badly compensated drifting camera, NEBRASKA, is a
# Displacement for the labels). The targets of a bridge following the season (JUNGFRAU, labelled Thermal
# displacement day after day) pass step 3 but not PIECE; NEBRASKA both.
HOURS = 20 # a day counts if it has at least 20 measured hours out of 24 (as D-055), as a share of the measured hours
DAYS = 5 # minimum days for a trend (D-055)
SIZE = 1.0 # drift ≥ SIZE daily amplitudes (D-055)
STEADY = 0.6 # |Kendall tau| of the daily levels (D-055)
PIECE = 3.5 # piecewise drift ≥ PIECE daily amplitudes (point 4b)
MAX_HOLE = 2 # a piece does not go from one kept day to the next more than MAX_HOLE days apart (point 4b)
def _decile(vs, q):
vs = sorted(vs)
return vs[min(len(vs) - 1, int(q * len(vs)))]
def _days(ms, col):
"""-> {UTC day: its measurements}, the kept days (point 1)."""
days = {}
for m in ms:
if m[col] is not None:
days.setdefault(m["t"].date(), []).append(m)
slots = len({m["t"].hour for dm in days.values() for m in dm}) # hours the station measures (6 at a 4 h step)
return {d: dm for d, dm in days.items() if len({m["t"].hour for m in dm}) >= HOURS / 24 * slots}
def _amplitude(days, col):
return statistics.median(_decile([m[col] for m in dm], 0.9) - _decile([m[col] for m in dm], 0.1) for dm in days.values())
def _drift(ms, col):
"""-> (drift in px, days, first instant, last) or None."""
days = _days(ms, col)
if len(days) < DAYS:
return None
lv = sorted((d.toordinal(), statistics.median(m[col] for m in dm)) for d, dm in days.items())
pairs = [(a, b) for k, a in enumerate(lv) for b in lv[k + 1:]]
slope = statistics.median((b[1] - a[1]) / (b[0] - a[0]) for a, b in pairs)
tau = sum((b[1] > a[1]) - (b[1] < a[1]) for a, b in pairs) / len(pairs)
drift = slope * (lv[-1][0] - lv[0][0])
step = max(abs(b[1] - a[1]) for a, b in zip(lv, lv[1:]))
if abs(drift) < SIZE * _amplitude(days, col) or abs(tau) < STEADY or step > abs(drift) / 2:
return None
d0, d1 = min(days), max(days)
return drift, len(days), min(m["t"] for m in days[d0]), max(m["t"] for m in days[d1])
def _pieces(ms, col):
"""-> [(drift in px, days, first instant, last)]: the drift pieces (point 4b)."""
days = _days(ms, col)
if len(days) < DAYS:
return []
ds = sorted(days)
lv = [statistics.median(m[col] for m in days[d]) for d in ds]
ampl = _amplitude(days, col)
pieces = [] # (drift, i, j)
for i in range(len(ds)):
signs = step = 0
for j in range(i + 1, len(ds)):
if (ds[j] - ds[j - 1]).days > MAX_HOLE:
break # a gap across a hole is a step (the jump rule takes it), not a slope
signs += sum((lv[j] > lv[k]) - (lv[j] < lv[k]) for k in range(i, j)) # Kendall tau, step by step
step = max(step, abs(lv[j] - lv[j - 1]))
n, d = j - i + 1, lv[j] - lv[i]
if n >= DAYS and d and abs(d) >= PIECE * ampl and step <= abs(d) / 2 \
and signs * (1 if d > 0 else -1) >= STEADY * n * (n - 1) / 2:
pieces.append((d, i, j))
taken = []
for d, i, j in sorted(pieces, key=lambda x: (-abs(x[0]), x[2] - x[1])):
if all(j <= a or i >= b for _, a, b in taken):
taken.append((d, i, j))
return [(d, j - i + 1, min(m["t"] for m in days[ds[i]]), max(m["t"] for m in days[ds[j]])) for d, i, j in taken]
def _common(measurements, cols):
"""At least LARGE of the sensors drift on the same side on the same axis of cols."""
for col in cols:
signs = [x[0] > 0 for ms in measurements.values() if (x := _drift(ms, col))]
if max(signs.count(True), signs.count(False)) >= LARGE * len(measurements):
return True
return False
def drift(measurements):
targets = {s: ms for s, ms in measurements.items() if not data.is_reference(ms)}
camera = _common(targets, ("corr_x", "corr_y")) and _common(measurements, ("x", "y")) # point 5: pieces only
out = []
for s, ms in sorted(targets.items()):
r = [] if camera else [x for col in ("corr_x", "corr_y") if (x := _drift(ms, col))]
r = [max(r, key=lambda x: abs(x[0]))] if r else [x for col in ("corr_x", "corr_y") for x in _pieces(ms, col)]
out += [{"start": data.iso(a), "end": data.iso(b), "kind": "Displacement", "label": "Slow drift",
"text": f"{s} drifts slowly and steadily: {d:+.2f} px in {n} days. Keep watching it.",
"ignore": False, "sensors": [s]} for d, n, a, b in r]
return out
if __name__ == "__main__":
for ep in detect(data.load(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"])
+49
View File
@@ -0,0 +1,49 @@
"""Benchmark of the learner (D-116): the detectors against all the labeller's labels (labeling/auto/).
For each station of labeling/auto/ that has its folder in data/, the score per family and per instant of score.py
(D-112), over the range of its labels: from the day of the first to the midnight after the last. Then the total, family
by family, which says whether the detectors do better overall from one session to the next. The block of the session's
station is its score; the other blocks, the non-regression: a family that goes back on a station is a regression, even
if the total rises.
Usage: python3 detectors/scripts/learner/regression.py [--stations A,B]
"""
import argparse
import json
from datetime import timedelta
import score # next to it
from data import iso, parse_time # on the path through score
def label_range(path):
"""labeling/auto/<STATION>.jsonl -> (start, end) iso, in whole UTC days, end excluded."""
with open(path, encoding="utf-8") as f:
labels = [json.loads(l) for l in f if l.strip()]
start = min(e["debut"] for e in labels)[:10]
# ponytail: the end of the batch is not written; midnight closest to the last bound (a label bound overflows by one
# measurement after midnight); the real end of the batch in labeling/auto/ if the gap matters
end = iso(parse_time(max(e["fin"] for e in labels)) + timedelta(hours=12))[:10]
return iso(parse_time(start)), iso(parse_time(end))
if __name__ == "__main__":
p = argparse.ArgumentParser(usage=__doc__)
p.add_argument("--stations", help="A,B: these stations only (a shorter run)")
a = p.parse_args()
total = {}
for path in sorted((score.WORK / "labeling" / "auto").glob("*.jsonl")):
station = path.stem
if a.stations and station not in a.stations.split(","):
continue
folder = score.WORK / "data" / station
if not folder.is_dir():
print(f"{station}: no data/{station}/, skipped\n")
continue
start, end = label_range(path)
n, labels = score.family_scores(str(folder), start, end)
score.show(f"{station}: {start} → {end}, {len(labels)} labels", n)
print()
for k, v in n.items():
total[k] = [x + y for x, y in zip(total.get(k, [0, 0, 0]), v)]
score.show("Total", total)
+97
View File
@@ -0,0 +1,97 @@
"""Score of the detectors on a range: the detectors' events against the labels of labeling/auto/<STATION>.jsonl that
touch the range, per family (labeling/familles.md) and per instant (D-112). An instant: an hour of the range where at
least one sensor has a measurement; it receives, on one side, the families of the labels covering it, bounds excluded
(except for a hole, without a measurement inside), on the other, those of the detectors' events (categories.py, the
range classified with its 3 days of history). The category of an event is its family.
found: labelled instants that the detectors also flagged (share of the labelled ones);
correct: flagged instants that a label also puts in the family (share of the flagged ones).
The score is a fact, not a verdict: the labels can be wrong too. No label on the range: exits with an error.
Label fields (written by Diagnostic-app): debut, fin, categorie (the family), description.
Run from the working repository, where detectors/ is mounted.
Usage: python3 detectors/scripts/learner/score.py <station folder> --from YYYY-MM-DD --to YYYY-MM-DD
"""
import argparse
import json
import os
import sys
from datetime import timedelta
from pathlib import Path
REPO = Path(os.path.abspath(__file__)).parents[2] # the detectors repository
WORK = REPO.parent # the working repository (labeling/, data/)
sys.path.insert(0, str(REPO / "scripts"))
import categories # noqa: E402
from data import iso, load, parse_time # noqa: E402
HISTORY = timedelta(days=3) # as the batch command (D-056)
def events(measurements, start, end, folder=None):
"""Detectors' events touching the range, classified with its days of history (as the batch command)."""
h, b = parse_time(start) - HISTORY, parse_time(end)
chunk = {s: k for s, ms in measurements.items() if (k := [m for m in ms if h <= m["t"] < b])}
return [v for v in (categories.events(chunk, folder=folder) if chunk else []) if v["end"] >= start]
def count(pairs):
"""[(labelled keys, flagged keys)], one pair per instant -> {key: [labelled, flagged, both]}."""
n = {}
for a, d in pairs:
for k in a | d:
x = n.setdefault(k, [0, 0, 0])
x[0], x[1], x[2] = x[0] + (k in a), x[1] + (k in d), x[2] + (k in a and k in d)
return n
def auto_labels(station, start, end):
"""labeling/auto/<STATION>.jsonl -> the labeller's labels touching [start, end)."""
path = WORK / "labeling" / "auto" / f"{station}.jsonl"
if not path.exists():
return []
with open(path, encoding="utf-8") as f:
return [e for e in map(json.loads, filter(str.strip, f)) if e["debut"] < end and e["fin"] >= start]
def family_scores(folder, start, end):
"""Score of a range per family and per instant -> ({family: [labelled, flagged, both]}, labels)."""
# ponytail: per instant and not per sensor, the labels only give their sensors in the text; a sensors field in the
# label if this precision is missing
measurements = load(folder)
labels = auto_labels(os.path.basename(os.path.normpath(folder)), start, end)
evts = events(measurements, start, end, folder)
instants = sorted({iso(m["t"]) for ms in measurements.values() for m in ms if start <= iso(m["t"]) < end})
# bounds excluded: they are the healthy measurement before and after (D-111); a hole, without a measurement
# inside, keeps them
empty = {i for i, e in enumerate(labels) if not any(e["debut"] < t < e["fin"] for t in instants)}
pairs = []
for t in instants:
a = {e.get("categorie", "no family") for i, e in enumerate(labels)
if e["debut"] < t < e["fin"] or (i in empty and e["debut"] <= t <= e["fin"])} - {"None"}
d = {v["category"] for v in evts if v["start"] <= t <= v["end"]}
pairs.append((a, d))
return count(pairs), labels
def pct(a, b):
return f"{a}/{b} ({round(100 * a / b)} %)" if b else "—"
def show(title, n):
print(title)
print(f" {'':<22}{'found':>20}{'correct':>20}")
for k in sorted(n):
labelled, flagged, both = n[k]
print(f" {k:<22}{pct(both, labelled):>20}{pct(both, flagged):>20}")
if __name__ == "__main__":
p = argparse.ArgumentParser(usage=__doc__)
p.add_argument("folder")
p.add_argument("--from", dest="start", required=True)
p.add_argument("--to", dest="end", required=True)
a = p.parse_args()
station, start, end = os.path.basename(os.path.normpath(a.folder)), iso(parse_time(a.start)), iso(parse_time(a.end))
n, labels = family_scores(a.folder, start, end)
if not labels:
sys.exit(f"No label of {station} on {start} → {end} in labeling/auto/{station}.jsonl: analyse the range first.")
show(f"{station}: {start} → {end}, {len(labels)} labels of labeling/auto/{station}.jsonl, per family and per instant", n)
+31
View File
@@ -0,0 +1,31 @@
"""For the upgrader: the cadence of the measurements of the range, the number of targets and references, then each event
of the range with its sensors (categories.py only gives their number). Same computation as categories.py without
--chunk (3 days of history).
Usage: python3 detectors/scripts/learner/sensors.py <folder> --from YYYY-MM-DD --to YYYY-MM-DD
"""
import argparse
import statistics
import sys
from datetime import datetime, timedelta, timezone
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
import categories # noqa: E402
from data import iso, load # noqa: E402
p = argparse.ArgumentParser(usage=__doc__)
p.add_argument("folder")
p.add_argument("--from", dest="start", required=True)
p.add_argument("--to", dest="end", required=True)
a = p.parse_args()
day = lambda d: datetime.strptime(d[:10], "%Y-%m-%d").replace(tzinfo=timezone.utc) # noqa: E731
start, end = day(a.start), day(a.end)
batch = {s: k for s, ms in load(a.folder).items() if (k := [m for m in ms if start - timedelta(days=3) <= m["t"] < end])}
ts = sorted({m["t"] for ms in batch.values() for m in ms if m["t"] >= start})
steps = [(y - x).total_seconds() / 60 for x, y in zip(ts, ts[1:])]
print(f"cadence: {statistics.median(steps):.0f} min (median of the steps between measurements)" if steps else "cadence: no measurement")
refs = sum(ms[0]["pattern_type"] == "global_ref" for ms in batch.values())
print(f"sensors: {len(batch) - refs} targets, {refs} references")
for v in (v for v in categories.events(batch, end, a.folder) if v["end"] >= iso(start)) if batch else []:
print(v["start"], "→", v["end"], f"{v['category']:<20}", "|", v["episodes"][0]["label"], "|",
", ".join(sorted(v["sensors"])) or "all sensors")
+45
View File
@@ -0,0 +1,45 @@
"""Detector of the No data family (labeling/familles.md): moments without a measurement (the cadence of the "advanced"
export is broken).
Cadence: median gap between two measurement instants, all sensors together. A hole: more than MISSING missing steps
between two measurements (gap > MISSING + 1 cadences); the episode runs from the last measurement to the next one.
End of the window read (end, when the caller gives it: the chunked run of categories.py): the same rule between the last
measurement and end, the episode running up to end (CLARIDEN, batch 01: 44 h without a measurement up to the end of
the batch, not reported). No measurement in the export does not mean the station stopped: the text only says that the
export has nothing.
Usage: python3 detectors/no_data.py <station folder> (prints the episodes)
"""
import os
import statistics
import sys
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) # data.py, next to it
from data import iso, load # noqa: E402
MISSING = 2 # more than 2 missing steps is a hole (user's rule, 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(measurements, end=None):
"""end: end of the window read (datetime, excluded), optional; without it, a final hole is not seen."""
ts = sorted({m["t"].replace(second=0, microsecond=0) for ms in measurements.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)
out = [(a, b, g, "") for a, b, g in zip(ts, ts[1:], gaps)]
if end: # end excluded: the last expected measurement is at end − 1 step, the gap counts as between two measurements
out.append((ts[-1], end, (end - ts[-1]).total_seconds(), ", up to the end of the period"))
return [{"start": iso(a), "end": iso(b), "kind": "No data", "label": "No data",
"text": f"No measurement in the export for {duration(g)}{tail} (usually one every {duration(step)}).",
"ignore": False, "sensors": []}
for a, b, g, tail in out if g > (MISSING + 1) * step]
if __name__ == "__main__":
for e in detect(load(sys.argv[1])):
print(e)
+36
View File
@@ -0,0 +1,36 @@
"""Detector of the Obstruction family (labeling/familles.md): an object hides one or a few targets, for an instant or
for long. It reuses two computations shared with other families:
- the error_value of visibility.py: Brief obstruction (something passing, one instant) and Target obscured (a target
rejected again and again while the others stay seen, or a nuisance that only touches a few targets, no reference);
- the day-by-day rejections of target_issue.py: a target rejected for less than a week, Target obscured.
A sensor already in an overlapping Target issue episode (Degraded target, Target stuck) is not returned as Obstruction:
its curve is already to be ignored, the family is Target issue (boundary "Target issue or an episode of another family"
of labeling/familles.md; learner session Obstruction, mod. 1: S1, problem targets of FLORIDA, NORDEND, SNCF01,
NIEDERHORN, JUNGFRAU, CLARIDEN cut into Target obscured; S3, their isolated rejections as Brief obstruction).
Usage: python3 detectors/obstruction.py <station folder> (prints the episodes)
"""
import os
import sys
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) # data.py and the detectors, next to it
import target_issue # noqa: E402
import visibility # noqa: E402
from data import load # noqa: E402
def detect(measurements):
ti = target_issue.episodes(measurements)
issues = [e for e in ti if e["kind"] == "Target issue"]
out = []
for e in visibility.episodes(measurements) + ti:
if e["kind"] != "Obstruction":
continue
taken = {s for h in issues if h["start"] <= e["end"] and h["end"] >= e["start"] for s in h["sensors"]}
if (e := {**e, "sensors": [s for s in e["sensors"] if s not in taken]})["sensors"]: # minus the sensors
out.append(e) # already in Target issue
return sorted(out, key=lambda e: e["start"])
if __name__ == "__main__":
for e in detect(load(sys.argv[1])):
print(e["start"], "→", e["end"], e["label"], f"| {len(e['sensors'])}:", ",".join(e["sensors"][:8]), "|", e["text"])
+184
View File
@@ -0,0 +1,184 @@
"""Detector of the Target issue family (labeling/familles.md): a persistently problematic target: rejected most of the
time, day after day, while the others are seen (degraded target), stuck (end of file), or flipping (the jumps of
displacement.py, "Target flipping"). A target rejected for less than a week is hidden at times (point 4): episodes()
returns it with the Obstruction family, which detect() leaves to obstruction.py.
visibility.py compares each sensor with its own usual level: a target that is almost always rejected looks normal to it
(FLORIDA, October 2026: Massif 2 and Sellette 6 rejected half the measurements or more, every day).
Method:
1. Calm instant for a sensor: at most CALM of the other sensors rejected (error_value > error_threshold); weather and
fog, which touch everyone, are thus set aside.
2. Per UTC day and per sensor, on its calm instants (at least MIN_HOURS hours of instants at the station's cadence,
median gap between two measurement instants; otherwise the day does not count): degraded day if at least SHARE of
them are rejected. Cadence (learner NEBRASKA, batch 01): 12 fixed instants, "3 h at 15 min", counted no day at one
measurement every 4 h; REFCOLH22, rejected all the time since it was lost, was not seen.
3. Episode: at least MIN_DAYS degraded days in a row (a day that does not count does not break the run), from the first
rejected measurement of these days to the last; ignore = True: the target's curve is not reliable.
4. Hindered all the time or at times (boundary "Target issue or Obstruction" of labeling/familles.md; learner
NEBRASKA, batch 01): a run of at least WEEK days is a problem target, "Degraded target"; shorter, a target hidden at
times, "Target obscured" (Obstruction family), one episode per run of rejected measurements (the hours when it is
seen are not part of it). BREITHORN: vehicles parked in front of COLI24 and POUI22, 2 to 5 days; NEBRASKA and
MICHIGAN: a lost reference, 25 days; JUNGFRAU: PM_G, 63.
For the problem target, the run is bridged: at most BRIDGE non-degraded days in a row do not break it, and it then
needs WEEK days from its first to its last degraded day, at SHARE_WEEK of rejections over all its days ("rejections
specific to the target almost every day of the range"); the Target obscured episodes it covers no longer exist
(learner session Obstruction, mod. 1, S1: FLORIDA Sellette 6 and Massif 2, SNCF01 F4.3 and F4.4, NORDEND CTR01,
NIEDERHORN e01, cut into Target obscured by a day under SHARE; BREITHORN, parked vehicles, unchanged).
The problem target judges regularity rather than the share of the day: a day is degraded from SHARE_WEEK (a quarter)
of its calm instants rejected, and BRIDGE is one day; the target hidden at times keeps SHARE. A target rejected every
day at the same hours, by day only or by night only, stays under half and was not seen (learner session Target
issue, mod. 1, S1: WILDSTRUBEL R3, 04:00 to 16:00 every day; NORDEND PR04 and CTR01, NIEDERHORN PWD_IMP_B08_024_C09
and e01, SNCF01 F4.3).
The cause (dirt, vegetation, setting) can only be read on the images.
Stuck target (E-011, FLORIDA: a target defined on the prism of a reference): per UTC day, the noise of its corr_x and
corr_y (median of the gaps from one measurement to the next) under STUCK times the median noise of the other targets, on
both axes; one day is enough (a day without noise does not happen by accident); label "Target stuck". On E-011: C2 at
7e-5 px and C3 at 2e-4 against 0.013 for the others.
Usage: python3 detectors/target_issue.py <station folder> (prints the episodes)
"""
import os
import statistics
import sys
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) # data.py and the detectors, next to it
import displacement # noqa: E402
from data import is_reference, iso, load # noqa: E402
CALM = 0.25 # share of the other sensors rejected, at most, for a calm instant
SHARE = 0.5 # half of the calm instants rejected: "most of the time"
SHARE_WEEK = 0.25 # a quarter of the calm instants rejected, each day of a week or more: a problem target, even when
# rejected by day only or by night only (learner session Target issue, mod. 1, S1)
MIN_HOURS = 3 # hours of calm instants, at the station's cadence: below that, the day does not count
MIN_DAYS = 2 # a single day is too often an accident (NORDEND: isolated days on 16 sensors)
BRIDGE = 1 # non-degraded days that do not break a run of degraded days (4); at 2, the parked vehicles of BREITHORN
# (two days, then nothing for two days, then one) would make a week at a quarter
WEEK = 7 # degraded days in a row for a problem target; below, a target hidden at times
STUCK = 0.05 # noise of a stuck target compared with the others (E-011: 0.006; NORDEND, E-001: 0.7 at the lowest)
def is_rejected(m):
return m["error_value"] is not None and m["error_threshold"] is not None and m["error_value"] > m["error_threshold"]
def cadence(measurements):
"""Median gap between two measurement instants, all sensors together, in hours (as no_data)."""
ts = sorted({m["t"].replace(second=0, microsecond=0) for ms in measurements.values() for m in ms})
return statistics.median((b - a).total_seconds() for a, b in zip(ts, ts[1:])) / 3600 if len(ts) > 1 else 1
def episodes(measurements):
"""Targets rejected day after day: Target issue (a week or more) and Obstruction (less), then the stuck ones."""
min_instants = MIN_HOURS / cadence(measurements)
by_t = {}
for s, ms in measurements.items():
for m in ms:
by_t.setdefault(m["t"], {})[s] = is_rejected(m)
days = {} # sensor -> day -> [rejected, calm, first measurement, last]
for t in sorted(by_t):
d = by_t[t]
for s, r in d.items():
others = [v for k, v in d.items() if k != s]
c = days.setdefault(s, {}).setdefault(t.date(), [0, 0, t, t])
c[3] = t
if others and sum(others) / len(others) <= CALM:
c[0] += r
c[1] += 1
out = []
for s, ds in sorted(days.items()):
covered = [] # bridged runs of at least WEEK days, at SHARE_WEEK of rejections: a problem target
for run in _runs(ds, min_instants, BRIDGE, SHARE_WEEK):
share = sum(c[0] for c in run) / sum(c[1] for c in run)
if len(run) < WEEK or share < SHARE_WEEK:
continue
n = sum(c[0] / c[1] >= SHARE_WEEK for c in run)
r = _rejections([m for m in measurements[s] if run[0][2] <= m["t"] <= run[-1][3]])
covered.append((run[0][2], run[-1][3]))
out.append({"start": iso(r[0][0]), "end": iso(r[-1][1]), "kind": "Target issue", "label": "Degraded target",
"text": f"{s} was rejected in {round(100 * share)} % of the measurements when the other targets were "
f"seen, on {n} of {len(run)} days.", "ignore": True, "sensors": [s]})
for run in _runs(ds, min_instants, 0, SHARE): # at times: one episode per run of rejected measurements
if len(run) < MIN_DAYS or any(a <= run[0][2] <= b for a, b in covered):
continue
share = round(100 * sum(c[0] for c in run) / sum(c[1] for c in run))
text = f"{s} was rejected in {share} % of the measurements when the other targets were seen, {len(run)} days in a row."
out += [{"start": iso(a), "end": iso(b), "kind": "Obstruction", "label": "Target obscured", "text": text,
"ignore": True, "sensors": [s]}
for a, b in _rejections([m for m in measurements[s] if run[0][2] <= m["t"] <= run[-1][3]])]
return sorted(out + stuck(measurements, min_instants), key=lambda e: e["start"])
def _runs(ds, min_instants, bridge, share):
"""{day: [rejected, calm, first, last]} -> runs of degraded days; at most `bridge` non-degraded days in a row between
two degraded days do not break the run (they belong to it); a day that does not count does not break it."""
runs, cur, gap = [], [], []
for j in sorted(ds):
rej, calm = ds[j][:2]
if calm < min_instants:
continue
if rej / calm >= share:
cur += gap + [ds[j]]
gap = []
elif cur:
gap.append(ds[j])
if len(gap) > bridge:
runs.append(cur)
cur, gap = [], []
return runs + ([cur] if cur else [])
def _rejections(ms):
"""Measurements of a sensor -> [(start, end)] of its runs of rejected measurements."""
out, cur = [], []
for m in ms + [None]:
if m and is_rejected(m):
cur.append(m["t"])
elif cur:
out.append((cur[0], cur[-1]))
cur = []
return out
def _noise(v):
return statistics.median(abs(y - x) for x, y in zip(v, v[1:])) if len(v) > 2 else None
def stuck(measurements, min_instants):
"""Targets whose corr_x and corr_y barely move, day after day, while the others move."""
days = {} # day -> target -> (x noise, y noise, first measurement, last)
for s, ms in measurements.items():
if is_reference(ms):
continue
by_day = {}
for m in ms:
by_day.setdefault(m["t"].date(), []).append(m)
for d, dm in by_day.items():
b = [_noise([m[c] for m in dm if m[c] is not None]) for c in ("corr_x", "corr_y")]
if None not in b and len(dm) >= min_instants:
days.setdefault(d, {})[s] = (*b, dm[0]["t"], dm[-1]["t"])
runs = {} # target -> [[stuck days in a row]]
for d in sorted(days):
cs = days[d]
for s, (bx, by, a, b) in cs.items():
others = [v for k, (x, y, *_) in cs.items() if k != s for v in (x, y)]
if len(others) < 4:
continue
ref = statistics.median(others)
ru = runs.setdefault(s, [[]])
if ref and max(bx, by) <= STUCK * ref:
ru[-1].append((a, b))
elif ru[-1]:
ru.append([])
return [{"start": iso(k[0][0]), "end": iso(k[-1][1]), "kind": "Target issue", "label": "Target stuck",
"text": f"{s} barely moved while the other targets did ({len(k)} day{'s' if len(k) > 1 else ''}): it may be "
"set on a reference prism.", "ignore": True, "sensors": [s]}
for s, ru in sorted(runs.items()) for k in ru if k]
def detect(measurements):
return sorted((e for e in episodes(measurements) + displacement.episodes(measurements) if e["kind"] == "Target issue"),
key=lambda e: e["start"])
if __name__ == "__main__":
for e in detect(load(sys.argv[1])):
print(e)
+292
View File
@@ -0,0 +1,292 @@
"""Detector of the Thermal displacement family (labeling/familles.md): the daily wave of the corrected displacements
(expansion by day, contraction in the evening).
Method, per target (global references excluded) and per axis (corr_x, corr_y):
1. Each UTC day of at least MIN_HOURS hours: mean of each hour minus the median of the day (removes jumps and drift).
2. Profile = median, hour by hour, over the days; "repeatability" = median, over the days, of the correlation between
the day and the profile of the other days. Axis concerned if repeatability ≥ REPRO. An incomplete day (at least
PARTIAL hours, fewer than MIN_HOURS) does not enter the profile, but its likeness is measured on the hours it has: a
hole of half a day no longer takes its episode away (learner session Thermal displacement, mod. 1, S4; at
MIN_HOURS = 12 or 16, the incomplete days distorted the profile, NIEDERHORN went back).
3. Cycle of the station if at least SHARE of the targets have an axis concerned, **and** (second method, asked by the
user) if a 24 h sinusoid, a + b·sin(2πt/24 h) + c·cos(2πt/24 h) by least squares, explains at least R2_MIN of the
curve of an axis for at least SHARE of the targets.
4. Warm hours: night level = median of the NIGHT flattest consecutive hours of the profile; an hour is warm if, as a
median over the axes concerned, the profile moves away from it by at least WARM times its amplitude.
5. Two episodes per complete day that looks like the others (median correlation ≥ DAY_MATCH over the axes concerned):
"Thermal expansion" from the start to the hour of the largest gap from the night level (the peak), then "Thermal
contraction" until the return. The warm hours say there is a cycle (at least MIN_WARM_HOURS of them); its bounds
are read lower, at EDGE times the amplitude: the start, going back from the peak while the gap stays ≥ EDGE (at most
to the calmest hour of the profile); the return, going down from the peak until it goes back under EDGE, after
midnight if needed, at most to the next day's start: a slow return at night chains the cycles (learner session
Thermal displacement, mod. 1, S1). The direction (a rising or falling curve) depends on the target's orientation:
it is not looked at, only the gap from the night level.
Reading: the cycle is almost everywhere in the raw positions (common mode) and the compensation removes it, except at
PS des Coudres where it stays in corr, with the same shape as in the raw positions.
Camera thermal effect (D-074): without a cycle in corr, the same method on the raw positions x, y gives "Camera thermal
expansion" and "Camera thermal contraction": the camera moves with the heat of its mount, the compensation removes it;
same categories, own sentence. On the raw positions the second method is not asked (WILDSTRUBEL, batch 01: the camera
rose by a 3 px block at sunrise, held 3 h and dropped in one step around 09:30, six days in a row, which the sinusoid
does not explain); in exchange, a single warm hour is not a cycle (MIN_WARM_HOURS: NIEDERHORN, E-005, hourly, would
otherwise have its noon hour as a camera contraction). The camera episode covers all sensors, references included: the
whole image moves.
Common slide, without a cycle (learner MICHIGAN, mod. 1): lacking a cycle in the corrected curves as in the raw
positions, an instant is a camera slide if the raw positions (x or y) of at least SHARE of the sensors, references
included, **and** the corrected curves (corr_x or corr_y) of at least SHARE of the targets move away on the same side by
at least SLIDE_K noises (median of the steps of the series) from their median of the day before; slides less than a
day apart make one episode, "Camera thermal movement", on all sensors, host of the jumps back (categories.HOSTS). The
condition on the raw positions leaves to the jumps a flip of the computed pose alone (raw positions still).
The camera moves with the cold (learner session Thermal displacement, mod. 1, S3): lacking a cycle, also a "Camera
thermal movement" where the camera pose (tilt, rotation or scale) moves away from its median of the day before by at
least COLD noises, while the station temperature (detect declares it, D-124) falls under its own by at least COLD
noises the same hour; noise: the median of the variations over an hour (over one step, at one measurement every 4 h),
so that the threshold does not depend on the cadence. The targets may move in opposite directions or stay almost still
(the compensation absorbs the movement): the slide rule does not see it. Consecutive pose instants make one episode.
Without a pose or without a temperature, nothing. The heat is not taken: in fine weather, it is the day's cycle.
"""
import math
import os
import statistics
import sys
from datetime import datetime, timedelta, timezone
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) # data.py, next to it
from data import iso, load # noqa: E402
MIN_HOURS = 20 # a UTC day counts in the profile if it has at least 20 measured hours
PARTIAL = 12 # an incomplete day of at least 12 hours gets its episode if it looks like the profile
REPRO = 0.6 # an axis has a cycle if each day looks like the others (pure noise ≈ 0)
SHARE = 0.5 # share of the targets concerned; 2026-10_NORDEND is just under (9/19)
WARM = 0.3 # gap from the night level, as a share of the profile's amplitude
DAY_MATCH = 0.5 # likeness of a day to the others to give it its episode
NIGHT = 8 # flattest consecutive hours of the profile = night level
R2_MIN = 0.3 # draft of 2026-10-24: PS des Coudres 14 axes out of 22 above, CLARIDEN 0 out of 48
MIN_WARM_HOURS = 2 # WILDSTRUBEL, batch 01; NIEDERHORN (E-005) has only one warm hour (noon)
EDGE = 0.1 # bounds of the wave (start, return), as a share of the amplitude; WARM says whether there is a cycle
SLIDE_K = 3 # common slide, in noises (median of the steps) away from the median of the day before
COLD = 4 # the camera moves with the cold, in one-hour noises away from the day before (pose, temperature)
W = 2 * math.pi / 86400 # angular frequency of a 24 h cycle, in 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 _axis(ms, col):
"""-> (24 h profile, {day: correlation with the profile of the other days}) or None."""
days = {}
for m in ms:
if m[col] is not None:
days.setdefault(m["t"].date(), {}).setdefault(m["t"].hour, []).append(m[col])
full, every = {}, {}
for d, hs in days.items():
if len(hs) >= PARTIAL:
med = statistics.median(v for l in hs.values() for v in l)
every[d] = {h: statistics.mean(l) - med for h, l in hs.items()}
if len(hs) >= MIN_HOURS:
full[d] = every[d]
if len(full) < 2:
return None
profile = [statistics.median(q[h] for q in full.values() if h in q) for h in range(24) if any(h in q for q in full.values())]
if len(profile) < 24:
return None
likeness = {}
for d, p in every.items():
others = [q for e, q in full.items() if e != d]
hs = [h for h in p if all(h in q for q in others)]
if len(hs) >= 3:
likeness[d] = _corr([p[h] for h in hs], [statistics.median(q[h] for q in others) for h in hs])
return profile, likeness
def sine_r2(ms, col):
"""Share of the curve explained by a 24 h sinusoid (least squares, 3 unknowns), or None if too short."""
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): # Gaussian elimination
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 sine(measurements, cols=("corr_x", "corr_y")):
"""-> (targets with an axis following a 24 h sinusoid, targets evaluated)."""
yes, evaluated = set(), set()
for s, ms in measurements.items():
if ms[0]["pattern_type"] == "global_ref":
continue
for col in cols:
r2 = sine_r2(ms, col)
if r2 is not None:
evaluated.add(s)
if r2 >= R2_MIN:
yes.add(s)
return yes, evaluated
def cycle(measurements, cols=("corr_x", "corr_y")):
"""-> (axes concerned [(sensor, col, profile, likeness)], number of targets evaluated)."""
concerned, targets = [], set()
for s, ms in measurements.items():
if ms[0]["pattern_type"] == "global_ref":
continue
for col in cols:
r = _axis(ms, col)
if r is None:
continue
targets.add(s)
if statistics.median(r[1].values()) >= REPRO:
concerned.append((s, col) + r)
return concerned, len(targets)
def gaps(concerned):
"""Median gap (over the axes concerned) from the night level, hour by hour, as a share of the profile's amplitude."""
def score(p, h):
start = min(range(24), key=lambda i: max(p[(i + k) % 24] for k in range(NIGHT)) - min(p[(i + k) % 24] for k in range(NIGHT)))
night = statistics.median(p[(start + k) % 24] for k in range(NIGHT))
return abs(p[h] - night) / (max(p) - min(p))
return [statistics.median(score(c[2], h) for c in concerned) for h in range(24)]
def warm_hours(concerned):
return [h for h, e in enumerate(gaps(concerned)) if e >= WARM]
def detect(measurements, temperature=(), camera=()):
"""Cycle of the corrected curves (the structure); otherwise, that of the raw positions (the camera moving with the
expansion of its mount, compensated: D-074); otherwise, the camera slides (with the cold)."""
return (_episodes(measurements, ("corr_x", "corr_y"), "Thermal", False) or
_episodes(measurements, ("x", "y"), "Camera thermal", True) or slides(measurements, temperature, camera))
def _signs(ms, col, hourly=False, k=None):
"""{instant: +1 or -1} where the measurement moves away by at least k (default SLIDE_K) noises from the median of the
day before; noise: the median of the steps from one measurement to the next or, hourly, of the variations over an
hour (one step if the cadence is slow)."""
pts = [(m["t"], m[col]) for m in ms if m[col] is not None]
if len(pts) < 3:
return {}
step = statistics.median((b - a).total_seconds() for (a, _), (b, _) in zip(pts, pts[1:])) if hourly else 0
n = max(1, round(3600 / step)) if step else 1
noise = statistics.median(abs(pts[i + n][1] - pts[i][1]) for i in range(len(pts) - n)) if len(pts) > n else 0
out, j = {}, 0
for i, (t, v) in enumerate(pts):
while pts[j][0] < t - timedelta(days=1):
j += 1
before = [w for _, w in pts[j:i]]
if noise and len(before) >= 3 and abs(v - statistics.median(before)) >= (k or SLIDE_K) * noise:
out[t] = 1 if v > statistics.median(before) else -1
return out
def _common(series):
"""[{instant: sign}] of a group of sensors -> instants where at least SHARE of them move away on the same side."""
n, count = len(series), {}
for sg in series:
for t, x in sg.items():
count[(t, x)] = count.get((t, x), 0) + 1
return {t for (t, x), c in count.items() if n and c >= SHARE * n}
def _cold(measurements, temperature, camera):
"""[(start, end)] of the runs of instants where the camera pose (tilt, rotation or scale) moves away from its day
before while the temperature falls under its own, by at least COLD one-hour noises; empty without one of them."""
ts = [m["t"] for ms in measurements.values() for m in ms]
hour = lambda t: t.replace(minute=0, second=0, microsecond=0) # noqa: E731
cold = {hour(t) for t, x in _signs([{"t": t, "T": v} for t, v in temperature], "T", True, COLD).items() if x < 0}
pose = [p for p in camera if min(ts) <= p["t"] <= max(ts)] if ts else []
seen = {t for c in ("tilt", "rotation", "scale") for t in _signs(pose, c, True, COLD) if hour(t) in cold}
episodes = [] # consecutive pose instants make one episode
for i, p in enumerate(pose):
if p["t"] in seen:
if episodes and episodes[-1][2] == i - 1:
episodes[-1][1:] = [p["t"], i]
else:
episodes.append([p["t"], p["t"], i])
return [(a, b) for a, b, _ in episodes]
def slides(measurements, temperature=(), camera=()):
"""Common camera slide, without a 24 h cycle: the raw positions of most sensors, references included, and the
corrected curves of most targets move away together, on the same side, from their day before; or the camera pose
moves away from it with the cold (_cold)."""
targets = [ms for ms in measurements.values() if ms[0]["pattern_type"] != "global_ref"]
raw = set().union(*(_common([_signs(ms, c) for ms in measurements.values()]) for c in ("x", "y")))
corr = set().union(*(_common([_signs(ms, c) for ms in targets]) for c in ("corr_x", "corr_y")))
episodes = []
for t in sorted(raw & corr):
if episodes and t - episodes[-1][1] <= timedelta(days=1): # less than a day between two: the same slide
episodes[-1][1] = t
else:
episodes.append([t, t])
return [{"start": iso(a), "end": iso(b), "kind": "Thermal displacement", "label": "Camera thermal movement",
"text": "The camera moved with a change of temperature and all the curves moved with it; this is not a "
"movement of the structure, nothing to do.", "ignore": False, "sensors": sorted(measurements)}
for a, b in episodes + _cold(measurements, temperature, camera)]
def _episodes(measurements, cols, name, camera):
concerned, n = cycle(measurements, cols)
sensors = sorted({c[0] for c in concerned})
if not n or len(sensors) < SHARE * n:
return []
if not camera: # second method, for the structure only: the sinusoid must see it too
yes, evaluated = sine(measurements, cols)
if not evaluated or len(yes) < SHARE * len(evaluated):
return []
warm = warm_hours(concerned)
if len(warm) < MIN_WARM_HOURS:
return []
e = gaps(concerned)
peak = max(warm, key=lambda h: e[h]) # the largest gap from the night level: end of the expansion
rest = min(range(24), key=lambda h: e[h])
a = peak # start: going back from the peak while the profile stays above EDGE, up to the calmest hour
while (a - 1) % 24 != rest and e[(a - 1) % 24] >= EDGE:
a -= 1
b = peak + 1 # return: until the profile goes back under EDGE, at most to the next start
while b < a + 24 and e[b % 24] >= EDGE:
b += 1
last = max(m["t"] for ms in measurements.values() for m in ms)
days = sorted({d for c in concerned for d in c[3]})
if camera: # the whole image moves, references included
sensors = sorted(measurements)
episodes = []
for d in days: # ponytail: days of at least PARTIAL hours, the export's ends (22:00 → midnight) get no episode
if statistics.median(c[3][d] for c in concerned if d in c[3]) < DAY_MATCH:
continue
midnight = datetime(d.year, d.month, d.day, tzinfo=timezone.utc)
for label, u, v in ((f"{name} expansion", a, peak), (f"{name} contraction", peak, b)):
start, end = midnight + timedelta(hours=u), min(midnight + timedelta(hours=v), last)
if end > start:
episodes.append({"start": iso(start), "end": iso(end),
"kind": "Thermal displacement", "label": label, "text": "", "ignore": False, "sensors": sensors})
return episodes
if __name__ == "__main__":
measurements = load(sys.argv[1])
for e in detect(measurements):
print(e["start"], "→", e["end"], e["label"], len(e["sensors"]), "targets")
for cols in (("corr_x", "corr_y"), ("x", "y")):
concerned, n = cycle(measurements, cols)
k = len({c[0] for c in concerned})
amp = statistics.median(max(c[2]) - min(c[2]) for c in concerned) if concerned else 0
yes, evaluated = sine(measurements, cols)
print(f"{cols[0][:-2] or 'raw'}: targets {k}/{n}, median amplitude {amp:.3f} px, warm hours (UTC) "
f"{warm_hours(concerned) if concerned else '-'}; sinusoid: targets {len(yes)}/{len(evaluated)}")
+342
View File
@@ -0,0 +1,342 @@
"""Detector of the Visibility family (labeling/familles.md): the camera sees less well, the image is faint or blurred
(error_value), or it trembles (heat shimmer, end of file). The same error_value computation also finds objects in front
of a few targets (Brief obstruction, Target obscured): episodes() returns them with the Obstruction family, which
detect() leaves to obstruction.py.
Method:
1. "High" measurement: error_value > median + K_MAD MAD of the sensor over the export, and > FACTOR × median, or
rejected (> error_threshold) and > REJECT_FACTOR × median: a sensor at a usual level of 0.6 never doubles, and
FLORIDA (batch 01) showed its fogs as Target obscured.
2. Brief obstruction: an instant where at least BRIEF_MIN sensors are high, SALIENCE times more than at the neighbouring
instants (train, vehicle), with no reference (global_ref) among them: a one-step peak touching the references is not
an obstacle in front of targets (peak of the whole image, NORDEND on 01.09 11:15, batch 01); it is not shown. Unless
at least BRIEF_MIN targets are rejected at this instant and neither at the instant before nor after: something
passing in front of them, a reference touched as well (learner session Displacement, mod. 1, S5: trains of
NIEDERHORN, 12 and 13 targets rejected).
Also, something passing in front of one or two targets, or a single reference: at an instant, fewer than BRIEF_MIN
sensors rejected at more than FACTOR times their median (without K_MAD: by day, heat shimmer inflates the MAD), at
most one reference, none of them rejected at the instant before or after, and fewer than BRIEF_MIN high sensors
(learner session Obstruction, mod. 1, S3: vehicles, passers-by, insects in front of one or two targets of
WILDSTRUBEL, NIEDERHORN, LENZSPITZE; a reference hidden by a truck at JUNGFRAU, BREITHORN).
3. Poor visibility: runs of at least RUN_MIN high measurements per sensor, joined across sensors (at least 2), reduced
to the instants where at least FRAC of the episode's peak is high.
4. Target obscured: a target (not a global_ref) rejected (> error_threshold) and above K_TARGET MAD, at least TARGET_MIN
times less than TARGET_GAP apart, mostly outside the episodes of 2 and 3 (leaves, snow, glare on a target). The gap
is at least two measurement steps, and two rejections are enough when TARGET_MIN steps do not fit in TARGET_GAP
(learner session Obstruction, mod. 1, S6: at one measurement every 4 h, vehicles parked at night in front of COLI22,
COLI24, POUI22 of BREITHORN make only two or three rejections). All episodes: ignore = True.
5. Level of a Poor visibility (validated 2026-10-24), measurement by measurement: "none" (nothing is seen) when at least
HALF of the usually seen targets (under their threshold at least half the time) are rejected, "reduced" (average
data) otherwise; one episode per period of the same level, with the level field.
6. Bounds of a Poor visibility (WILDSTRUBEL, batch 01): from the first to the last measurement where a target is
rejected (> error_threshold), and no episode without a rejected target. On a road in full sun, the daytime
error_value (×1.5 to ×3, heat shimmer) made reduced visibility last for hours without any rejection; references do
not count: R3 is above its threshold almost all day.
7. Poor visibility or object (boundary "Visibility or Obstruction" of labeling/familles.md; BREITHORN, batch 01): a
nuisance touching at most FEW targets, and no reference, is not diffuse: it is an object in front of them (a parked
vehicle), a "Target obscured" episode of its whole duration, without a level.
8. Diffuse nuisance, with or without rejections (learner session Visibility, mod. 1, S2): at each instant, the median,
over the sensors, of the error_value in MAD above each one's median; at least RUN_MIN instants in a row at K_DIFFUSE
or more make a Poor visibility "reduced". A diffuse nuisance entirely within heat shimmer is the heat shimmer: no
episode (otherwise it absorbed the jump back of the day before, WILDSTRUBEL on 04.10). Finds the drops of
visibility of the whole scene without rejection at JUNGFRAU, FLORIDA, NORDEND; at 2, nights labelled thermal at
JUNGFRAU; at 3, half the gain.
A simpler version (share of targets rejected above their threshold, without comparing each sensor with its own level)
was tried on 2026-10-24 and dropped: worse on five data sets out of six (git history of Support-Agent,
detectors/archive/visibilite_simple.py).
"""
import os
import statistics
import sys
from datetime import timedelta
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) # data.py, next to it
from data import iso, load # noqa: E402
K_MAD = 10 # tuned on E-001 (fog: 11 to 57 MAD) and E-005 (rain, trains: 10 to 70 MAD)
FACTOR = 2 # drops sensors with a near-zero MAD (E-004: PWD_REF10 ×1.6 at 14 MAD, E-005)
RUN_MIN = 3 # high measurements in a row for poor visibility (E-001, E-005 rain)
BRIEF_MIN = 3 # tuned on E-005 (trains: 5 to 17 sensors; the one with 2 targets is missed)
K_TARGET = 5 # tuned on E-005 (leaves: 6 to 25 MAD, rejected)
TARGET_MIN = 3 # repeated rejections of a target
FRAC = 0.15 # cuts the tails of PR09 + CTR01 (NORDEND October) without cutting the cobweb (E-002)
GAP_STEPS = 2.5 # steps tolerated between two high measurements of the same run (a missing step, clock to the second)
BREAK = timedelta(hours=2) # lull separating two episodes (NORDEND October, night of 13 to 14.10)
SALIENCE = 3 # a train stands out at least 3 times above the neighbouring instants (E-005: 5 to 17 against 0 to 2;
# the cobweb of E-002 varies from 2 to 9 from one step to the next)
TARGET_GAP = timedelta(hours=6) # tuned on E-005 (leaves: 7 rejections in 12 h, up to 5 h apart)
REJECT_FACTOR = 1.2 # a rejection at 10 MAD also counts (FLORIDA, batch 01: levels of 0.6, ×2 out of reach); drops C24
# of E-009 (level 0.68 just under the threshold 0.7, rejected at ×1.04)
HALF = 0.5 # "nothing is seen"; tuned on NORDEND (09.10 23:00: 68 % rejected) and E-005 (rain: 24 to 33 %)
K_DIFFUSE = 2.5 # diffuse nuisance (8); learner session Visibility, mod. 1, S2
FEW = 3 # Poor visibility on at most 3 targets, no reference: an object, Target obscured (7); BREITHORN,
# batch 01 (vehicles parked in front of 2 or 3 targets out of 12)
def _step(measurements):
ts = sorted({m["t"] for v in measurements.values() for m in v})
return statistics.median(b - a for a, b in zip(ts, ts[1:]))
def _group(points, gap):
"""[(t, sensor)] sorted by t -> groups [(start, end, {sensors}, [t])] whose points are ≤ gap from each other."""
groups = []
for t, s in points:
if groups and t - groups[-1][1] <= gap:
g = groups[-1]
groups[-1] = (g[0], t, g[2] | {s}, g[3] + [t])
else:
groups.append((t, t, {s}, [t]))
return groups
def _group_intervals(intervals, gap):
"""[(start, end, sensor)] sorted -> [(start, end, {sensors})] of the intervals that overlap (within gap)."""
out = []
for a, b, s in intervals:
if out and a - out[-1][1] <= gap:
out[-1] = (out[-1][0], max(out[-1][1], b), out[-1][2] | {s})
else:
out.append((a, b, {s}))
return out
def _episode(start, end, label, text, sensors, level=None):
e = {"start": iso(start), "end": iso(end), "kind": "Visibility" if label == "Poor visibility" else "Obstruction",
"label": label, "text": text,
"ignore": level != "reduced", "sensors": sorted(sensors)} # reduced visibility: average data, not greyed
return {**e, "level": level} if level else e
def _levels(measurements, instants):
"""t -> "none" if at least HALF of the usually seen targets are rejected at t, "reduced" otherwise."""
ratios = []
for v in measurements.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) >= HALF * max(1, sum(t in r for r in ratios)) else "reduced"
for t in instants}
def episodes(measurements):
"""All error_value episodes: Visibility (Poor visibility), Obstruction (Brief obstruction, Target obscured)."""
step = _step(measurements)
gap = GAP_STEPS * step
refs = {s for s, v in measurements.items() if v[0]["pattern_type"] == "global_ref"}
instants = sorted({m["t"] for v in measurements.values() for m in v})
high, rejections = {}, {} # sensor -> [t]
refused = set() # instants where a target (not a global_ref) is above its threshold
rejected_targets = {} # t -> {targets above their threshold}
strong, refusals = {}, {} # t -> {sensors rejected at more than FACTOR times their median}, {sensors rejected}
for s, v in measurements.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
rejected = m["error_threshold"] and x > m["error_threshold"]
if rejected and s not in refs:
refused.add(m["t"])
rejected_targets.setdefault(m["t"], set()).add(s)
if x > med + K_MAD * mad and (x > FACTOR * med or rejected and x > REJECT_FACTOR * med):
high.setdefault(s, []).append(m["t"])
if rejected:
refusals.setdefault(m["t"], set()).add(s)
if x > FACTOR * med:
strong.setdefault(m["t"], set()).add(s)
if s not in refs and rejected and x > med + K_TARGET * mad:
rejections.setdefault(s, []).append(m["t"])
by_t = {} # t -> {high sensors}
for s, ts in high.items():
for t in ts:
by_t.setdefault(t, set()).add(s)
n = lambda t: len(by_t.get(t, ())) # noqa: E731
out = []
# 2. Brief obstruction: an instant where many sensors are high, at least SALIENCE times more than the neighbours.
briefs = set()
for i, t in enumerate(instants):
neighbours = [n(instants[j]) for j in (i - 1, i + 1) if 0 <= j < len(instants)]
if n(t) >= BRIEF_MIN and n(t) >= SALIENCE * max(neighbours):
briefs.add(t)
only = rejected_targets.get(t, set()).difference(*(rejected_targets.get(instants[j], set()) for j in (i - 1, i + 1)
if 0 <= j < len(instants)))
if by_t[t] & refs and len(only) < BRIEF_MIN: # references touched without targets rejected at this instant
continue # alone: not an obstacle in front of targets, the whole image
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.", by_t[t]))
elif 0 < len(f := strong.get(t, set())) < BRIEF_MIN and n(t) < BRIEF_MIN and len(f & refs) <= 1 and not f & set().union(
*(refusals.get(instants[j], set()) for j in (i - 1, i + 1) if 0 <= j < len(instants))):
# one or two targets, or a reference, rejected at this single measurement, at FACTOR times their median
out.append(_episode(t, t, "Brief obstruction", f"{len(f)} point{'s were' if len(f) > 1 else ' was'} poorly seen "
"for a single measurement, then came back: probably something passing; ignore this point on the "
"curves.", f))
# 3. Poor visibility: long runs per sensor (without the brief instants), joined across sensors, then reduced to the
# instants where at least FRAC of the episode's peak is high (cuts the tails of one or two sensors and the long
# lulls, more than BREAK).
runs = []
for s, ts in high.items():
pts = [(t, s) for t in ts if t not in briefs]
runs += [(a, b, s) for a, b, _, l in _group(pts, gap) if len(l) >= RUN_MIN]
zones = [z for z in _group_intervals(sorted(runs), gap) if len(z[2]) >= 2]
kept = []
for a, b, _ in zones:
inside = [t for t in instants if a <= t <= b and t not in briefs]
peak = max(n(t) for t in inside)
pts = [(t, s) for t in inside if n(t) >= max(1, FRAC * peak) for s in by_t[t]]
kept += [(d, f, cs) for d, f, cs, l in _group(pts, max(gap, BREAK)) if len(cs) >= 2 and len(set(l)) >= RUN_MIN]
# Bounds: from the first to the last rejected target; without a rejection, no episode (6).
kept = [(r[0], r[-1], cs) for a, b, cs in kept if (r := [t for t in instants if a <= t <= b and t in refused])]
level = _levels(measurements, instants)
for a, b, cs in kept: # one episode per period of the same level (5); the text comes from categories.py
if len(cs) <= FEW and not cs & refs: # an object in front of a few targets, not a diffuse nuisance (7)
out.append(_episode(a, b, "Target obscured", "", cs))
continue
seg = []
for t in [t for t in instants if a <= t <= b] + [None]:
if seg and (t is None or level[t] != level[seg[0]]):
who = cs & set().union(*(by_t.get(u, set()) for u in seg)) or cs
out.append(_episode(seg[0], seg[-1], "Poor visibility", "", who, level[seg[0]]))
seg = []
if t is not None:
seg.append(t)
inside_any = lambda t: t in briefs or any(a <= t <= b for a, b, _ in kept) # noqa: E731
# 4. Target obscured: a target rejected again and again, mostly outside the episodes above.
targets = []
for s, ts in rejections.items():
for a, b, _, l in _group([(t, s) for t in ts], max(TARGET_GAP, 2 * step)):
if len(l) >= (TARGET_MIN if TARGET_MIN * step <= TARGET_GAP else 2) and sum(map(inside_any, l)) * 2 < len(l):
targets.append((a, b, s))
for a, b, cs in _group_intervals(sorted(targets), timedelta(0)):
who, 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"{who} 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 diffuse(measurements):
"""Diffuse nuisance (8): the runs of at least RUN_MIN instants where the median, over the sensors, of the error_value
in MAD above each one's median reaches K_DIFFUSE, with or without rejections -> Poor visibility "reduced"."""
z = {} # t -> {sensor: gap in MAD}
for s, v in measurements.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:
if m["error_value"] is not None:
z.setdefault(m["t"], {})[s] = (m["error_value"] - med) / mad
highs = [(t, None) for t in sorted(z) if statistics.median(z[t].values()) >= K_DIFFUSE]
return [_episode(a, b, "Poor visibility", "", {s for t in l for s, x in z[t].items() if x >= K_DIFFUSE}, "reduced")
for a, b, _, l in _group(highs, GAP_STEPS * _step(measurements)) if len(l) >= RUN_MIN]
def detect(measurements):
shimmer = heat_shimmer(measurements) # a diffuse nuisance during heat shimmer is the heat shimmer (8)
return ([e for e in episodes(measurements) if e["kind"] == "Visibility"] + shimmer
+ [e for e in diffuse(measurements) if not any(t["start"] <= e["start"] and e["end"] <= t["end"] for t in shimmer)])
# --- Heat shimmer ----------------------------------------------------------------------------------------------------
# Atmospheric turbulence (fast noise on the corrected displacements). Method:
# 1. Per sensor and per hour H, on the measurements of [H − 1 h, H + 2 h): agitation = median of |Δcorr_x| + |Δcorr_y|
# between successive measurements (robust to one-step jumps), and median of the error_value.
# 2. Each is divided by the sensor's calm: the lower quartile of its hourly values over the export (often the night).
# 3. Turbulent hour: at least SHARE of the sensors at ≥ RATIO times their calm agitation, and median error_value of the
# sensors at ≥ RATIO_ERR times the calm (warm air blurs the spots: E-003).
# 4. Neighbouring hours merged (a one-hour hole tolerated), episode of at least MIN_DURATION, dropped if more than
# REJECT_MAX of the measurements are rejected beyond their sensor's habit (its share of rejections over the export):
# it is then poor visibility, another rule. A target that is always rejected (Target issue) does not count (learner
# session Visibility, mod. 1, S1: WILDSTRUBEL, R3 rejected all day, the days of heat shimmer were dropped).
# Greyed if the median agitation ≥ STRONG.
RATIO = 1.5 # tuned on E-003 (WILDSTRUBEL: by day, corr ×1.7 to ×3 the night)
SHARE = 0.5 # share of the sensors agitated at the same time
RATIO_ERR = 1.5 # tuned on E-003 (error_value ×1.7 to ×3.2 the night; ≈ ×1 at noon elsewhere)
REJECT_MAX = 0.15 # E-003 ≤ 7 %; cobweb (E-002) and rain (E-005) ≥ 18 %; rejections beyond the habit since learner
# session Visibility, mod. 1, S1 (WILDSTRUBEL: 4 to 14 %, against 9 to 22 % raw)
STRONG = 2.0 # E-003 (×2.3 to ×2.6) is strong; an episode between ×1.5 and ×2 stays visible
MIN_DURATION = timedelta(hours=3) # E-003 lasts 10-11 h; drops the morning of the real movement of E-004 (2 h), which
# the classification drops too, whatever the duration
HOUR = timedelta(hours=1)
def _hour(t):
return t.replace(minute=0, second=0, microsecond=0)
def _ratios(points):
"""[(t, value)] -> {hour H: median over [H − 1 h, H + 2 h) / lower quartile of these medians}."""
by = {}
for t, v in points:
for k in (-1, 0, 1):
by.setdefault(_hour(t) + k * HOUR, []).append(v)
med = {h: statistics.median(v) for h, v in by.items() if len(v) >= 3}
if len(med) < 8:
return {}
calm = statistics.quantiles(med.values(), n=4)[0]
return {h: v / calm for h, v in med.items()} if calm > 0 else {}
def hours(measurements):
"""-> {hour: {sensor: (agitation / calm, error_value / calm)}}."""
out = {}
for s, ms in measurements.items():
ag = _ratios([(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 = _ratios([(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 _turbulent(r):
return (sum(a >= RATIO for a, _ in r.values()) >= SHARE * len(r)
and statistics.median(e for _, e in r.values()) >= RATIO_ERR)
def heat_shimmer(measurements):
H = hours(measurements)
blocks = []
for h in sorted(h for h, r in H.items() if _turbulent(r)):
if blocks and h - blocks[-1][-1] <= 2 * HOUR:
blocks[-1].append(h)
else:
blocks.append([h])
habit = {s: sum(m["corr_x"] is None for m in ms) / len(ms) for s, ms in measurements.items()} # usual rejections
episodes = []
for b in blocks:
start, end = b[0], b[-1] + HOUR
by = {s: [m for m in ms if start <= m["t"] < end] for s, ms in measurements.items()}
new = sum(max(0, sum(m["corr_x"] is None for m in d) - habit[s] * len(d)) for s, d in by.items())
if end - start < MIN_DURATION or new > REJECT_MAX * sum(map(len, by.values())):
continue
by_sensor = {}
for h in b:
for s, (a, _) in H[h].items():
by_sensor.setdefault(s, []).append(a)
agit = {s: statistics.median(v) for s, v in by_sensor.items()}
strength = statistics.median(agit.values())
episodes.append({
"start": iso(start), "end": iso(end), "kind": "Visibility",
"label": "Heat shimmer",
"text": f"Readings were about {strength:.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": strength >= STRONG,
"sensors": sorted(s for s, v in agit.items() if v >= RATIO),
})
return episodes
if __name__ == "__main__":
for e in detect(load(sys.argv[1])):
print(e["start"], "→", e["end"], e["label"], f"| {len(e['sensors'])}:", ",".join(e["sensors"][:8]), "|", e["text"])
-29
View File
@@ -1,29 +0,0 @@
"""Pour le critique de /detector-learner : la cadence des mesures du lot, puis chaque événement de la commande du lot avec
ses capteurs (categories.py n'en donne que le nombre) ; avant, le nombre de cibles et de références de la station. Même calcul que categories.py sans --tranche (3 jours d'historique).
Usage : python3 detectors/skills/detector-learner/capteurs.py <dossier> --du AAAA-MM-JJ --au AAAA-MM-JJ
"""
import argparse
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__)), "..", "..", "..", "detectors"))
import categories # noqa: E402
p = argparse.ArgumentParser(usage=__doc__)
p.add_argument("dossier")
p.add_argument("--du", required=True)
p.add_argument("--au", required=True)
a = p.parse_args()
jour = lambda d: datetime.strptime(d[:10], "%Y-%m-%d").replace(tzinfo=timezone.utc) # noqa: E731
debut, fin = jour(a.du), jour(a.au)
mesures = categories.charger(a.dossier)
lot = {s: k for s, ms in mesures.items() if (k := [m for m in ms if debut - timedelta(days=3) <= m["t"] < fin])}
ts = sorted({m["t"] for ms in lot.values() for m in ms if m["t"] >= debut})
pas = [(b - a).total_seconds() / 60 for a, b in zip(ts, ts[1:])]
print(f"cadence : {statistics.median(pas):.0f} min (médiane des pas entre mesures)" if pas else "cadence : pas de mesure")
refs = sum(ms[0]["pattern_type"] == "global_ref" for ms in lot.values())
print(f"capteurs : {len(lot) - refs} cibles, {refs} références")
for v in (v for v in categories.evenements(lot, fin, a.dossier) if v["end"] >= categories.iso(debut)) if lot else []:
print(v["start"], "→", v["end"], f"{v['category']:<20}", "|", v["episodes"][0]["label"], "|", ", ".join(sorted(v["sensors"])) or "tous les capteurs")
-69
View File
@@ -1,69 +0,0 @@
"""Benchmark de /detector-learner (D-116) : les détecteurs face à toutes les étiquettes de l'étiqueteur (labeling/auto/).
Pour chaque station de labeling/auto/ qui a son dossier dans data/, le score par famille et par instant de score.py
(D-112), sur la plage de ses étiquettes : du jour de la première à minuit après la dernière. Puis le total, famille par
famille, qui dit si les détecteurs font globalement mieux d'une séance à l'autre. Le bloc de la station de la séance est
son score ; les autres blocs, la non-régression : une famille qui recule sur une station est un recul, même si le total
monte. Avec --etape, chaque ligne (stations et Total) entre dans l'historique, detectors/detector-learner/historique.csv, avec la
version des détecteurs (score.version()).
Usage : python3 detectors/skills/detector-learner/regression.py [--seance <séance> --etape <étape>] [--stations A,B]
"""
import argparse
import csv
import glob
import json
import os
import sys
from datetime import datetime, timezone
RACINE = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", ".."))
import score # noqa: E402 (à côté)
HISTORIQUE = os.path.join(RACINE, "detectors", "detector-learner", "historique.csv")
def plage(chemin):
"""labeling/auto/<STATION>.jsonl -> (début, fin) iso, en jours entiers UTC, fin exclue."""
with open(chemin, encoding="utf-8") as f:
etiq = [json.loads(l) for l in f if l.strip()]
du = min(e["debut"] for e in etiq)[:10]
# ponytail: la fin du lot n'est pas écrite ; minuit le plus proche de la dernière borne (une borne d'étiquette déborde
# d'une mesure après minuit) ; la fin réelle du lot dans labeling/auto/ si l'écart compte
au = score.iso(score.instant(max(e["fin"] for e in etiq)) + score.timedelta(hours=12))[:10]
return score.iso(score.instant(du)), score.iso(score.instant(au))
if __name__ == "__main__":
p = argparse.ArgumentParser(usage=__doc__)
p.add_argument("--seance", default="")
p.add_argument("--etape")
p.add_argument("--stations", help="A,B : ces stations seules, sans historique (un essai plus court)")
a = p.parse_args()
total, res = {}, {}
for chemin in sorted(glob.glob(os.path.join(RACINE, "labeling", "auto", "*.jsonl"))):
station = os.path.basename(chemin)[:-len(".jsonl")]
if a.stations and station not in a.stations.split(","):
continue
dossier = os.path.join(RACINE, "data", station)
if not os.path.isdir(dossier):
print(f"{station} : pas de data/{station}/, sautée\n")
continue
du, au = plage(chemin)
n, etiq = score.familles_lot(dossier, du, au)
score.afficher(f"{station} : {du} → {au}, {len(etiq)} étiquettes", n)
print()
res[station] = n
for k, v in n.items():
total[k] = [a + b for a, b in zip(total.get(k, [0, 0, 0]), v)]
score.afficher("Total", total)
if a.etape and not a.stations:
res["Total"] = total
os.makedirs(os.path.dirname(HISTORIQUE), exist_ok=True)
neuf = not os.path.exists(HISTORIQUE)
date, ver = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%MZ"), score.version()
with open(HISTORIQUE, "a", newline="", encoding="utf-8") as f:
w = csv.writer(f)
if neuf:
w.writerow(("date", "seance", "etape", "version", "station", "famille", "etiquetees", "signalees", "les_deux"))
w.writerows((date, a.seance, a.etape, ver, st, k, *v) for st, n in res.items() for k, v in sorted(n.items()))
print(f"\nhistorique : {os.path.relpath(HISTORIQUE, RACINE)} (version {ver})")
-142
View File
@@ -1,142 +0,0 @@
"""Score des détecteurs sur une plage : les détecteurs du journal face aux étiquettes de labeling/auto/<STATION>.jsonl qui
touchent la plage, par famille (labeling/familles.md) et par instant. Une case : une mesure d'un capteur ; elle reçoit, d'un
côté, les familles des étiquettes qui la couvrent, de l'autre, celles des événements des détecteurs (categories.py, la plage
classée avec ses 3 jours d'historique) ; la catégorie d'un événement est sa famille (un détecteur par famille), un saut revenu
resté seul compris (Displacement). Pour chaque famille, et pour les deux niveaux de validité qui ne sont pas « fiable » :
trouvées : cases étiquetées que les détecteurs ont aussi signalées (part des étiquetées) ;
justes : cases signalées qu'une étiquette range aussi dans la famille (part des signalées).
Un trou n'a pas de mesure, donc pas de case. Le score est un fait, pas un verdict : les étiquettes peuvent se tromper aussi.
Aucune étiquette sur la plage : sortie en erreur. Lancé depuis le dépôt de travail, où detectors/ est monté.
Usage : python3 detectors/skills/detector-learner/score.py <dossier de station> --du AAAA-MM-JJ --au AAAA-MM-JJ
"""
import json
import os
import subprocess
import sys
from datetime import timedelta
RACINE = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", ".."))
sys.path.insert(0, os.path.join(RACINE, "detectors"))
import categories # noqa: E402 (il met lui-même donnees.py sur le chemin)
from donnees import charger, instant, iso # noqa: E402
HISTORIQUE = timedelta(days=3) # comme la commande du lot (D-056)
IGNORER = {"visibilite_nulle", "passage", "cible_masquee", "cible_a_probleme", "saut_bref"} # zones grisées (carte, section 4)
# ponytail: la turbulence est toujours « prudence » : l'étiquette ne dit pas si elle est forte (grisée alors dans le
# journal) ; un champ de force dans les étiquettes si cet écart compte
PRUDENCE = {"visibilite_reduite", "turbulence"}
NIVEAUX = ("à ignorer", "prudence")
def validite(cats):
return "à ignorer" if cats & IGNORER else "prudence" if cats & PRUDENCE else None
def cases(mesures, debut, fin):
"""Mesures -> [(capteur, instant iso)] du lot, fin exclue."""
return [(s, t) for s, ms in mesures.items() for m in ms if debut <= (t := iso(m["t"])) < fin]
def marquer(cs, spans):
"""Cases, [(début, fin, capteurs, catégorie)] -> {case: {catégories}} ; fin incluse, capteurs vides : tous."""
out = {c: set() for c in cs}
for d, f, capteurs, cat in spans:
for s, t in cs:
if d <= t <= f and (not capteurs or s in capteurs):
out[(s, t)].add(cat)
return out
def evenements(mesures, debut, fin, dossier=None):
"""Événements des détecteurs qui touchent le lot, classé avec ses jours d'historique (comme la commande du lot)."""
h, b = instant(debut) - HISTORIQUE, instant(fin)
tranche = {s: k for s, ms in mesures.items() if (k := [m for m in ms if h <= m["t"] < b])}
return [v for v in (categories.evenements(tranche, dossier=dossier) if tranche else []) if v["end"] >= debut]
def detectes(mesures, debut, fin):
"""Événements des détecteurs du lot -> spans de marquer."""
return [(v["start"], v["end"], v["sensors"], v["category"]) for v in evenements(mesures, debut, fin)]
def compter(paires):
"""[(clés étiquetées, clés signalées)], une paire par case -> {clé: [étiquetées, signalées, les deux]}."""
n = {}
for a, d in paires:
for k in a | d:
x = n.setdefault(k, [0, 0, 0])
x[0], x[1], x[2] = x[0] + (k in a), x[1] + (k in d), x[2] + (k in a and k in d)
return n
def version():
"""La version des détecteurs : le commit du dépôt detectors, suivi de « + » s'il a des changements non commités."""
def git(*a):
return subprocess.run(["git", "-C", os.path.join(RACINE, "detectors"), *a], capture_output=True, text=True).stdout.strip()
return git("rev-parse", "--short", "HEAD") + ("+" if git("status", "--porcelain", "--", ".") else "")
def score(etiq, det):
"""{case: catégories de l'analyste}, {case: catégories des détecteurs} -> {clé: [étiquetées, signalées, les deux]}."""
return compter([x | {v} if (v := validite(x)) else x for x in (etiq[c], det[c])] for c in etiq)
def familles():
"""{catégorie du journal: famille} : chaque famille est sa propre catégorie (D-119), dans l'ordre de categories.py."""
return {c: c for c in categories.CATEGORIES}
def etiquettes_auto(station, debut, fin):
"""labeling/auto/<STATION>.jsonl -> les étiquettes de l'étiqueteur qui touchent [début, fin)."""
chemin = os.path.join(RACINE, "labeling", "auto", f"{station}.jsonl")
if not os.path.exists(chemin):
return []
with open(chemin, encoding="utf-8") as f:
return [e for e in map(json.loads, filter(str.strip, f)) if e["debut"] < fin and e["fin"] >= debut]
def familles_lot(dossier, debut, fin, etiq=None):
"""Score d'un lot par famille et par instant (D-112) -> ({famille: [étiquetés, signalés, les deux]}, étiquettes).
Un instant : une heure du lot où un capteur au moins a une mesure ; il reçoit les familles des étiquettes qui le
couvrent, bornes exclues (sauf un trou, sans mesure dedans), et celles des événements des détecteurs. etiq : les étiquettes, sinon labeling/auto/."""
# ponytail: par instant et non par capteur, les étiquettes ne disent leurs capteurs que dans le texte ; un champ
# capteurs dans l'étiquette, si cette finesse manque
mesures = charger(dossier)
if etiq is None:
etiq = etiquettes_auto(os.path.basename(os.path.normpath(dossier)), debut, fin)
evts = evenements(mesures, debut, fin, dossier)
instants = sorted({t for _, t in cases(mesures, debut, fin)})
# bornes exclues : elles sont la mesure saine d'avant et d'après (D-111) ; un trou, sans mesure dedans, les garde
vides = {i for i, e in enumerate(etiq) if not any(e["debut"] < t < e["fin"] for t in instants)}
paires = []
for t in instants:
a = {e.get("categorie", "sans famille") for i, e in enumerate(etiq)
if e["debut"] < t < e["fin"] or (i in vides and e["debut"] <= t <= e["fin"])} - {"None"}
d = {v["category"] for v in evts if v["start"] <= t <= v["end"]}
paires.append((a, d))
return compter(paires), etiq
def pct(a, b):
return f"{a}/{b} ({round(100 * a / b)} %)" if b else "—"
def afficher(titre, n):
print(titre)
print(f" {'':<22}{'trouvées':>20}{'justes':>20}")
for k in [*NIVEAUX, *sorted(set(n) - set(NIVEAUX))]:
if k in n:
lab, sig, both = n[k]
print(f" {k:<22}{pct(both, lab):>20}{pct(both, sig):>20}")
if __name__ == "__main__":
if len(sys.argv) == 6 and sys.argv[2::2] == ["--du", "--au"]:
station, du, au = os.path.basename(os.path.normpath(sys.argv[1])), iso(instant(sys.argv[3])), iso(instant(sys.argv[5]))
n, etiq = familles_lot(sys.argv[1], du, au)
if not etiq:
sys.exit(f"Aucune étiquette de {station} sur {du} → {au} dans labeling/auto/{station}.jsonl : "
"analyser la plage d'abord.")
afficher(f"{station} : {du} → {au}, {len(etiq)} étiquettes de labeling/auto/{station}.jsonl, par famille et par instant", n)
else:
sys.exit(__doc__)
+91
View File
@@ -0,0 +1,91 @@
---
name: detector-learner
description: Séance automatique d'amélioration des détecteurs du journal du matin depuis une analyse de la page Data de Diagnostic-app (labeling/auto/analyses/<analyse>/) — detectors-critic, detectors-upgrader, detectors-control ; le but, des détecteurs plus proches des étiquettes de l'analyse sur sa plage, sans sur-apprentissage ; le garde-fou, le benchmark sur toutes les stations et toutes les familles de labeling/auto/. Lancé par le bouton « Optimiser les détecteurs » de l'app (claude -p --plugin-dir detectors), ou par l'utilisateur, /detectors:detector-learner <analyse>.
argument-hint: "<analyse>"
---
# detector-learner : les détecteurs depuis une analyse
Tu es l'orchestrateur. Tu tournes dans le **dépôt de travail** (Diagnostic-app, le dossier courant) : `labeling/` (les étiquettes, la vérité ; les analyses), `data/` (les données des stations), `agent-tools/`. Le dépôt **detectors** y est monté en `detectors/` (un sous-module) : les détecteurs, leur registre des seuils `detectors/seuils-du-journal.md`, les scripts de ce skill (`detectors/skills/detector-learner/`) et les séances (`detectors/detector-learner/`). Deux dépôts git, donc : ce qui touche les détecteurs se commite dans `detectors/` (`git -C detectors …`), l'analyse dans le dépôt de travail.
L'utilisateur a choisi une plage où les détecteurs le satisfont mal ; l'analyste l'a analysée dans la page Data : un rapport (`rapport.md`) et des étiquettes, versées dans `labeling/auto/<STATION>.jsonl`. L'utilisateur l'a relue, et lancer cette séance vaut son accord : il n'y a pas d'autre validation. Le but : des détecteurs **plus proches des étiquettes de l'analyse sur sa plage**, par un petit pas, **sans sur-apprentissage** : ils font un peu mieux là, et le benchmark sur toutes les stations et familles de `labeling/auto/` reste bon. Tu appelles les agents dans l'ordre, tu transmets leurs rendus et tu commites ; en fin de séance, le releveur note leurs difficultés. **Tu ne juges rien toi-même** : tu lis seulement les lignes de verdict. **Tu ne poses aucune question à l'utilisateur** : la séance tourne seule jusqu'au bout.
## 1. Mise en place
- Argument : le nom d'une analyse, un dossier de `labeling/auto/analyses/` (ex. `NORDEND_2026-11-04T2112_2026-11-07T1412`) ; un chemin vers ce dossier vaut son nom. `ANALYSE` = le nom, `A` = `labeling/auto/analyses/<ANALYSE>`. Sans `<A>/demande.json`, ou sans `detectors/.claude-plugin/plugin.json` : dis-le et arrête-toi, sans commit.
- De `<A>/demande.json` : `STATION`, `début`, `fin` (UTC). `DU` = le jour de `début`, `AU` = le lendemain du jour de `fin` (AAAA-MM-JJ) : la plage des commandes, en jours entiers.
- `SEANCE` = `date -u +%Y-%m-%dT%H%MZ` ; dossier de séance `detectors/detector-learner/<SEANCE>_<ANALYSE>/`, ci-dessous `<séance>`.
- **Commits** : dans les deux dépôts, la branche doit être `main` (`git branch --show-current` et `git -C detectors branch --show-current`), sinon dis-le et arrête-toi ; un sous-module détaché (aucune branche) : `git -C detectors checkout main` d'abord, s'il n'a aucun changement. Tu commites toujours par chemin (`git add <chemins> && git commit -m "<message>" -- <chemins>`, ou avec `git -C detectors`, les chemins relatifs à `detectors/`), jamais `git add -A`, `git stash` ni `git checkout` hors de tes chemins : une autre session peut travailler dans ces dépôts. Avant chaque commit, la branche ; si ce n'est plus `main`, ne commite plus rien et passe au bilan. Chaque message finit par une ligne vide puis `Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>`. Tu ne pousses rien.
- **Étape 0, l'analyse dans git** : l'app ne commite pas ; si `git status --porcelain -- <A> labeling/auto/<STATION>.jsonl` montre quelque chose, commite ces deux chemins dans le dépôt de travail (`git add` respecte `.gitignore` : `travail/` reste dehors), message `Detector-learner <ANALYSE>: étiquettes de l'analyse`. Puis note la **base de la séance** : `git -C detectors rev-parse HEAD`.
- `git -C detectors status --porcelain` et `git status --porcelain -- labeling/auto/ labeling/familles.md` (`familles.md` : les familles, une par détecteur, que compte le benchmark) : les fichiers déjà modifiés y restent tels quels, ni commités ni annulés ; liste-les sous « Erreurs » du bilan (les mesures tournent sur eux). Refais ce relevé avant le contrôle et avant le bilan, avec les données repompées (`find -L data/ -name '*.csv' -newer <séance>/benchmark-avant.txt | cut -d/ -f2 | sort -u`) : un fichier changé pendant la séance par une autre session (une étiquette retouchée dans la page Data, par exemple) va sous « Erreurs » ; avant le contrôle, relance alors le benchmark avant à la base de la séance (dans un dossier `mktemp -d` : `git -C detectors archive <base> --prefix=detectors/ | tar -x -C <dossier>`, des liens vers `data/`, `labeling/` et `agent-tools/` du dépôt de travail, puis `python3 <dossier>/detectors/skills/detector-learner/regression.py`) dans `<séance>/benchmark-avant-relance.txt`, et ajoute à la demande du contrôle : `Changé pendant la séance : <chemins ou stations> ; benchmark avant relancé : <séance>/benchmark-avant-relance.txt.`
**Les deux mesures** de la séance, à chaque étape :
- **le benchmark**, la non-régression : `python3 detectors/skills/detector-learner/regression.py --seance <SEANCE>_<ANALYSE> --etape <étape> > <séance>/benchmark-<étape>.txt 2>&1` (environ 1 min 30). Le score par famille et par instant sur chaque station de `labeling/auto/`, puis leur `Total`, versé dans `detectors/detector-learner/historique.csv` ;
- **le score de la plage**, le but : `python3 detectors/skills/detector-learner/score.py data/<STATION> --du <DU> --au <AU> > <séance>/plage-<étape>.txt 2>&1`. Les étiquettes de `labeling/auto/<STATION>.jsonl` qui touchent la plage (celles de l'analyse comprises), la vérité de la séance, face aux détecteurs, par famille. Il sort en erreur si aucune étiquette ne touche la plage : note-le sous « Erreurs » et va au bilan sans toucher aux détecteurs.
**Commandes**, données telles quelles aux agents : le journal, `python3 detectors/categories.py data/<STATION> --du <DU> --au <AU>` ; les capteurs, `python3 detectors/skills/detector-learner/capteurs.py data/<STATION> --du <DU> --au <AU>`. Pour le contrôle seulement, qui regarde toutes les stations, le journal avec `<STATION>`, `<du>` et `<au>` à remplir depuis l'en-tête du bloc de la station dans le benchmark : `python3 detectors/categories.py data/<STATION> --du <du> --au <au>`.
## 2. Dans l'ordre
Chaque agent est appelé par l'outil Agent avec son `subagent_type` (ceux de ce plugin : `detectors:detectors-critic`, `detectors:detectors-upgrader`, `detectors:detectors-control`, `detectors:releveur`) et la demande ci-dessous, rien d'autre, sauf une consigne de l'utilisateur donnée au lancement : ajoute-la telle quelle à la demande des agents (`Consigne de l'utilisateur : …`) et note-la au bilan ; elle passe avant leurs consignes, pas avant leur périmètre de fichiers. Un verdict se lit par `grep '^\*\*Verdict\*\* :' <rendu>` ; ce qui l'accompagne (« Réserves » du contrôle) ne change pas la suite, il va au bilan. Le but : des détecteurs qui font mieux, pas parfaits ; une autre lecture que les étiquettes, cohérente, est admise.
Les commits de séance (le dossier de séance, `detector-learner/historique.csv`, les détecteurs, `seuils-du-journal.md`) se font dans `detectors/` : `git -C detectors add <chemins relatifs> && git -C detectors commit -m "<message>" -- <chemins relatifs>`.
1. **Mesures avant** : étape `avant`, donc `<séance>/benchmark-avant.txt` et `<séance>/plage-avant.txt`.
Commit `detector-learner/<SEANCE>_<ANALYSE>/ detector-learner/historique.csv`, message `Detector-learner <ANALYSE>: benchmark`.
2. **Detectors-critic** : `Analyse : <A>/. Station : <STATION>, plage <début> → <fin> (UTC). Commande du journal : <commande>. Commande des capteurs : <commande des capteurs>. Score de la plage : <séance>/plage-avant.txt. Benchmark : <séance>/benchmark-avant.txt. Écris <séance>/critique.md.`
Commit du dossier de séance, message `Detector-learner <ANALYSE>: critique (<verdict>)`. Verdict `d'accord` : va au bilan.
3. **Detectors-upgrader**, un seul passage :
`Analyse : <A>/. Station : <STATION>. Commande du journal : <commande>. Critique : <séance>/critique.md. Benchmark avant : <séance>/benchmark-avant.txt, à relancer par python3 detectors/skills/detector-learner/regression.py (sans --etape). Score de la plage : python3 detectors/skills/detector-learner/score.py data/<STATION> --du <DU> --au <AU> (avant : <séance>/plage-avant.txt). Dossier de séance : <séance>. Fichiers déjà modifiés au début de la séance : <liste | aucun>. Écris <séance>/modification-1.md.`
L'upgrader commite lui-même, dans `detectors/`, chaque suggestion gardée, avec son benchmark `<séance>/benchmark-1-S<n>.txt`, message `Detector-learner <ANALYSE>: modification 1, S<n>` : le contrôle peut ainsi en faire retirer une seule.
Puis les mesures, étape `modification 1`, dans `<séance>/benchmark-1.txt` et `<séance>/plage-1.txt`.
Commit, dans `detectors/`, des détecteurs (`*.py` à la racine), de `seuils-du-journal.md`, du dossier de séance et de `detector-learner/historique.csv` (sans les fichiers déjà modifiés notés au §1), message `Detector-learner <ANALYSE>: modification 1`. Aucune suggestion gardée (pas de commit `, S<n>` : `git -C detectors log --format=%h --grep ', S[0-9]*$' <base>..HEAD`) : va au bilan.
4. **Detectors-control**, qui ne lit ni la critique ni le détail de la modification :
`Analyse : <ANALYSE>. Modification : <séance>/modification-1.md. Benchmark : <séance>/benchmark-avant.txt → <séance>/benchmark-1.txt, à relancer par python3 detectors/skills/detector-learner/regression.py (sans --etape) ; après chaque suggestion : <séance>/benchmark-1-S*.txt. Score de la plage : <séance>/plage-avant.txt → <séance>/plage-1.txt. Commande du journal : <commande du contrôle>. Base (dans detectors/) : <base de la séance>. Écris <séance>/validation-1.md.`
Commit du dossier de séance, message `Detector-learner <ANALYSE>: control (<verdict>)`.
- `garder` : va au bilan.
- `retirer` : pour chaque suggestion de la ligne `**Retirer** :`, ses commits de la séance (`git -C detectors log --format=%h --grep ', S<n>$' <base de la séance>..HEAD`), du plus récent au plus ancien : `git -C detectors revert --no-edit <commit>`, puis amende son message pour qu'il finisse par la ligne `Co-Authored-By` (`git -C detectors commit --amend -m "Detector-learner <ANALYSE>: S<n> retirée" -m "Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"`). Un conflit : `git -C detectors revert --abort`, et fais comme pour `annuler`. Puis va au bilan.
- `annuler`, ou tout autre mot : `git -C detectors checkout <base de la séance> -- '*.py' seuils-du-journal.md` (sans les fichiers déjà modifiés notés au §1 ; `skills/` n'est pas touché), commit de ces chemins, message `Detector-learner <ANALYSE>: modification annulée`.
Un rendu absent ou sans verdict lisible : note-le, remets les détecteurs comme pour `annuler` s'ils ont changé, passe au bilan. Ne relance pas un agent plus d'une fois.
## 3. Bilan
Les mesures, étape `fin`, dans `<séance>/benchmark-fin.txt` et `<séance>/plage-fin.txt`.
`<séance>/bilan.md`, que la page Data affiche sous le rapport :
```markdown
# Optimisation : <ANALYSE>
**Résultat** : modification gardée | gardée sans S<n>… | annulée | aucune | erreur
## La plage de l'analyse
<STATION>, <début> → <fin> ; le score de la plage, avant → fin, une ligne par famille (trouvées, justes)
## Toutes les stations
la ligne de chaque famille du `Total`, avant → fin ; puis les autres lignes changées (station, famille), avant → fin
## Ce qui a changé
<par suggestion gardée, une phrase (de « Ce qui a changé » de la modification)> ; la critique (d'accord / n suggestions), le contrôle (verdict)
## À trancher par l'utilisateur
<copiés tels quels : « Limites » de la critique, « À trancher par l'utilisateur » de la modification, « Réserves » du contrôle ; aucune s'il n'y a rien>
## Suggestions non traitées
<« Pas corrigé » de la modification ; aucune>
## Erreurs
<aucune, ou ce qui manquait ; la base de la séance et `git -C detectors log --oneline <base>..HEAD`>
```
Commit, dans `detectors/`, du dossier de séance et de `detector-learner/historique.csv`, message `Detector-learner <ANALYSE>: bilan`. Puis, dans le dépôt de travail, le sous-module à son nouveau commit : `git add detectors && git commit -m "Detector-learner <ANALYSE>: détecteurs" -- detectors`, si `git status --porcelain -- detectors` le montre changé.
## 4. Difficultés
**Releveur** (`detectors:releveur`), une fois, même si tout s'est bien passé : `Processus : /detector-learner (detectors/skills/detector-learner/SKILL.md). Séance : <séance>/ : la section « Difficultés » de chaque rendu, et « Erreurs » du bilan. Difficultés de l'orchestrateur : aucune | <…>.`
Si `git -C detectors status --short ameliorations-processus.md` montre un changement : commit de ce chemin dans `detectors/`, message `Detector-learner <ANALYSE>: process difficulties`.
## 5. Réponse finale
En 4 lignes au plus : la ligne `**Résultat**` du bilan, le score de la plage avant → fin (familles changées), le `Total` avant → fin s'il a changé, le chemin du bilan. Rien n'est poussé : l'utilisateur pousse `detectors` pour que tous aient les détecteurs à jour, ou annule ce qu'il ne garde pas par `git -C detectors revert`.
-193
View File
@@ -1,193 +0,0 @@
"""Journal du matin : le détecteur de la famille Target issue (labeling/familles.md) : une cible constamment
problématique : rejetée la plupart du temps, jour après jour, quand les autres sont vues (cible dégradée), collée (en
fin de fichier), ou qui bascule (les sauts de displacement.py, « Target flipping »). Une cible rejetée moins d'une
semaine est cachée par moments (point 4) : episodes() la rend avec la famille Obstruction, que detect() laisse à
obstruction.py.
Le détecteur visibilite compare chaque capteur à son propre niveau habituel : une cible presque toujours rejetée lui
paraît normale (FLORIDA, octobre 2026 : Massif 2 et Sellette 6 rejetées la moitié des mesures ou plus, chaque jour).
Méthode (seuils provisoires, Claude, 2026-10-27) :
1. Instant calme pour un capteur : au plus CALME des autres capteurs rejetés (error_value > error_threshold) ; la météo et
la buée, qui touchent tout le monde, sont ainsi mises de côté.
2. Par jour UTC et par capteur, sur ses instants calmes (au moins MIN_HEURES heures d'instants à la cadence de la
station, écart médian entre deux instants de mesure ; sinon le jour ne compte pas) : jour dégradé si au moins PART
d'entre eux sont rejetés. Cadence (boucle /detector-learner NEBRASKA, lot 01) : 12 instants fixes, « 3 h à 15 min »,
ne comptaient aucun jour à une mesure toutes les 4 h ; REFCOLH22, rejetée sans cesse depuis sa perte, n'était pas vue.
3. Épisode : au moins MIN_JOURS jours dégradés de suite (un jour qui ne compte pas ne coupe pas la suite), de la première
mesure rejetée de ces jours à la dernière ; ignore = True : la courbe de la cible n'est pas fiable.
4. Gênée tout le temps ou par moments (frontière « Target issue ou Obstruction » de labeling/familles.md ; boucle
/detector-learner NEBRASKA, lot 01) : une suite d'au moins SEMAINE jours est une cible à problème, « Degraded target » ;
plus courte, une cible cachée par moments, « Target obscured » (famille Obstruction), un épisode par suite de
mesures rejetées (les heures où elle est vue n'en sont pas). BREITHORN : véhicules garés
devant COLI24 et POUI22, 2 à 5 jours ; NEBRASKA et MICHIGAN : une référence perdue, 25 jours ; JUNGFRAU : PM_G, 63.
Pour la cible à problème, la suite est reliée : au plus PONT jours non dégradés de suite ne la coupent pas, et elle
demande alors SEMAINE jours de son premier à son dernier jour dégradé, à PART de rejets sur tous ses jours (« des rejets
propres à la cible presque chaque jour de la plage ») ; les Target obscured qu'elle couvre n'existent plus
(/detector-learner Obstruction, modification 1, S1 : FLORIDA Sellette 6 et Massif 2, SNCF01 F4.3 et F4.4, NORDEND
CTR01, NIEDERHORN e01, découpées en Target obscured par un jour sous PART ; BREITHORN, véhicules garés, inchangé).
La cible à problème juge la régularité plutôt que la part du jour : un jour y est dégradé dès PART_SEMAINE (le quart)
de ses instants calmes rejetés, et PONT vaut un jour ; la cible cachée par moments garde PART. Une cible rejetée chaque
jour aux mêmes heures, le jour seulement ou la nuit seulement, reste sous la moitié et n'était pas vue
(/detector-learner Target issue, modification 1, S1 : WILDSTRUBEL R3, de 04:00 à 16:00 chaque jour, vue seulement les
jours sans mesure de nuit ; NORDEND PR04 et CTR01, NIEDERHORN PWD_IMP_B08_024_C09 et e01, SNCF01 F4.3, plus tôt).
Sur les jeux de data/ (2026-10-27) : FLORIDA Massif 2 21 → 25.10, Sellette 6 16 → 17.10 et 19 → 20.10 ; NIEDERHORN e03 à
e12 toute la période (jamais vues) ; NORDEND CTR01 plusieurs suites en juin-juillet (déjà « souvent rejetée ») ; rien
sur LENZSPITZE ; CLARIDEN PR-283 du 12 au 16.09. La cause (salissure, végétation, réglage) ne se lit que sur les images.
Cible collée (E-011, FLORIDA : une cible définie sur le prisme d'une référence) : par jour UTC,
le bruit de ses corr_x et corr_y (médiane des écarts d'une mesure à la suivante) à moins de COLLE fois le bruit médian
des autres cibles, sur les deux axes, un jour suffit (une journée sans bruit n'arrive pas par accident) ; label « Target stuck ». Sur E-011 : C2 à
7e-5 px et C3 à 2e-4 contre 0,013 pour les autres ; FLORIDA : les mêmes, Pont Ernen et Sellette 3.
Usage : python3 detectors/target_issue.py <dossier de station> (affiche les épisodes)
"""
import os
import statistics
import sys
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) # donnees.py, à côté
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import displacement # noqa: E402
from donnees import charger, est_reference, iso # noqa: E402
CALME = 0.25 # part des autres capteurs rejetés au plus, pour un instant calme
PART = 0.5 # la moitié des instants calmes rejetés : « la plupart du temps »
PART_SEMAINE = 0.25 # le quart des instants calmes rejetés, chaque jour d'une semaine ou plus : une cible à problème,
# même rejetée seulement le jour ou seulement la nuit (/detector-learner Target issue, modification 1, S1)
MIN_HEURES = 3 # heures d'instants calmes, à la cadence de la station : en dessous, le jour ne compte pas
MIN_JOURS = 2 # un jour seul est trop souvent un accident (NORDEND : jours isolés sur 16 capteurs)
PONT = 1 # provisoire : jour non dégradé qui ne coupe pas une suite de jours dégradés (4) ; à 2, les véhicules garés
# de BREITHORN (deux jours, puis rien deux jours, puis un) feraient une semaine au quart
SEMAINE = 7 # provisoire : jours dégradés de suite pour une cible à problème ; en dessous, une cible cachée par moments
COLLE = 0.05 # provisoire : bruit d'une cible collée face aux autres (E-011 : 0,006 ; NORDEND, E-001 : 0,7 au plus bas)
def rejete(m):
return m["error_value"] is not None and m["error_threshold"] is not None and m["error_value"] > m["error_threshold"]
def cadence(mesures):
"""Écart médian entre deux instants de mesure, tous capteurs confondus, en heures (comme no_data)."""
ts = sorted({m["t"].replace(second=0, microsecond=0) for ms in mesures.values() for m in ms})
return statistics.median((b - a).total_seconds() for a, b in zip(ts, ts[1:])) / 3600 if len(ts) > 1 else 1
def episodes(mesures):
"""Cibles rejetées jour après jour : Target issue (une semaine ou plus) et Obstruction (moins), puis les collées."""
min_instants = MIN_HEURES / cadence(mesures)
par_t = {}
for s, ms in mesures.items():
for m in ms:
par_t.setdefault(m["t"], {})[s] = rejete(m)
jours = {} # capteur -> jour -> [rejetés, calmes, première mesure, dernière]
for t in sorted(par_t):
d = par_t[t]
for s, r in d.items():
autres = [v for k, v in d.items() if k != s]
c = jours.setdefault(s, {}).setdefault(t.date(), [0, 0, t, t])
c[3] = t
if autres and sum(autres) / len(autres) <= CALME:
c[0] += r
c[1] += 1
out = []
for s, js in sorted(jours.items()):
cache = [] # suites reliées d'au moins SEMAINE jours, à part de rejets PART_SEMAINE : une cible à problème
for su in _suites(js, min_instants, PONT, PART_SEMAINE):
part = sum(c[0] for c in su) / sum(c[1] for c in su)
if len(su) < SEMAINE or part < PART_SEMAINE:
continue
n = sum(c[0] / c[1] >= PART_SEMAINE for c in su)
r = _rejets([m for m in mesures[s] if su[0][2] <= m["t"] <= su[-1][3]])
cache.append((su[0][2], su[-1][3]))
out.append({"start": iso(r[0][0]), "end": iso(r[-1][1]), "kind": "Target issue", "label": "Degraded target",
"text": f"{s} was rejected in {round(100 * part)} % of the measurements when the other targets were "
f"seen, on {n} of {len(su)} days.", "ignore": True, "sensors": [s]})
for su in _suites(js, min_instants, 0, PART): # par moments : un épisode par suite de mesures rejetées
if len(su) < MIN_JOURS or any(a <= su[0][2] <= b for a, b in cache):
continue
part = round(100 * sum(c[0] for c in su) / sum(c[1] for c in su))
text = f"{s} was rejected in {part} % of the measurements when the other targets were seen, {len(su)} days in a row."
out += [{"start": iso(a), "end": iso(b), "kind": "Obstruction", "label": "Target obscured", "text": text,
"ignore": True, "sensors": [s]}
for a, b in _rejets([m for m in mesures[s] if su[0][2] <= m["t"] <= su[-1][3]])]
return sorted(out + colles(mesures, min_instants), key=lambda e: e["start"])
def _suites(js, min_instants, pont, part):
"""{jour: [rejetés, calmes, première, dernière]} -> suites de jours dégradés ; au plus pont jours non dégradés de suite
entre deux jours dégradés ne coupent pas la suite (ils en sont) ; un jour qui ne compte pas ne la coupe pas."""
suites, cur, creux = [], [], []
for j in sorted(js):
rej, calmes = js[j][:2]
if calmes < min_instants:
continue
if rej / calmes >= part:
cur += creux + [js[j]]
creux = []
elif cur:
creux.append(js[j])
if len(creux) > pont:
suites.append(cur)
cur, creux = [], []
return suites + ([cur] if cur else [])
def _rejets(ms):
"""Mesures d'un capteur -> [(début, fin)] de ses suites de mesures rejetées."""
out, cur = [], []
for m in ms + [None]:
if m and rejete(m):
cur.append(m["t"])
elif cur:
out.append((cur[0], cur[-1]))
cur = []
return out
def _bruit(v):
return statistics.median(abs(y - x) for x, y in zip(v, v[1:])) if len(v) > 2 else None
def colles(mesures, min_instants):
"""Cibles dont corr_x et corr_y ne bougent presque pas, jour après jour, quand les autres bougent."""
jours = {} # jour -> cible -> (bruit x, bruit y, première mesure, dernière)
for s, ms in mesures.items():
if est_reference(ms):
continue
par_j = {}
for m in ms:
par_j.setdefault(m["t"].date(), []).append(m)
for d, js in par_j.items():
b = [_bruit([m[c] for m in js if m[c] is not None]) for c in ("corr_x", "corr_y")]
if None not in b and len(js) >= min_instants:
jours.setdefault(d, {})[s] = (*b, js[0]["t"], js[-1]["t"])
suites = {} # cible -> [[jours collés de suite]]
for d in sorted(jours):
cs = jours[d]
for s, (bx, by, a, b) in cs.items():
autres = [v for k, (x, y, *_) in cs.items() if k != s for v in (x, y)]
if len(autres) < 4:
continue
ref = statistics.median(autres)
su = suites.setdefault(s, [[]])
if ref and max(bx, by) <= COLLE * ref:
su[-1].append((a, b))
elif su[-1]:
su.append([])
out = []
for s, su in sorted(suites.items()):
for k in su:
if k:
out.append({"start": iso(k[0][0]), "end": iso(k[-1][1]), "kind": "Target issue", "label": "Target stuck",
"text": f"{s} barely moved while the other targets did ({len(k)} day{'s' if len(k) > 1 else ''}): it may be "
"set on a reference prism.", "ignore": True, "sensors": [s]})
return out
def detect(mesures):
return sorted((e for e in episodes(mesures) + displacement.episodes(mesures) if e["kind"] == "Target issue"),
key=lambda e: e["start"])
if __name__ == "__main__":
for e in detect(charger(sys.argv[1])):
print(e)
-313
View File
@@ -1,313 +0,0 @@
"""Journal du matin : le détecteur de la famille Thermal displacement (labeling/familles.md) : 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. Un jour incomplet (au moins
PARTIEL heures, moins de 20) n'entre pas dans le profil, mais sa ressemblance se mesure sur les heures qu'il a : un
trou d'une demi-journée ne lui ôte plus son épisode (/detector-learner Thermal displacement, modification 1, S4 ;
à HEURES_MIN = 12 ou 16, les jours incomplets faussaient le profil, NIEDERHORN reculait).
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 » du départ à l'heure du plus grand écart au niveau de nuit (le pic), puis « Thermal
contraction » jusqu'au retour. Les heures chaudes disent qu'il y a un cycle ; ses bornes se lisent plus bas, à BORD
fois l'amplitude : le départ, en remontant du pic tant que l'écart reste ≥ BORD (au plus jusqu'à l'heure la plus
calme du profil) ; le retour, en descendant du pic jusqu'à ce qu'il repasse sous BORD, après minuit s'il le faut, au
plus jusqu'au départ du lendemain : un retour lent la nuit enchaîne les cycles (/detector-learner Thermal
displacement, modification 1, S1 : avant, la vague s'arrêtait à la dernière heure chaude, le soir et la nuit
manquaient). 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, E-002) | 2/18, rien | 18/19, 1,8 px, 06-18 h |
| WILDSTRUBEL (E-003) | 3/7, rien | 6/7, 3,2 px, 04-08 h |
| CLARIDEN (E-004) | 1/24, rien | 1/24, aucun cycle |
| NIEDERHORN (E-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.
Effet thermique (D-074, 2026-10-27) : sans cycle dans corr, la même méthode sur les positions brutes x, y donne
« Camera thermal expansion » et « Camera thermal contraction » : la caméra bouge avec la chaleur de son support, la
compensation l'enlève ; mêmes catégories du journal, phrase propre.
Caméra sans sinusoïde (boucle WILDSTRUBEL, lot 01) : sur les positions brutes, la seconde méthode n'est plus demandée ;
la caméra y montait d'un bloc de 3 px au lever, tenait 3 h et retombait en un pas vers 09:30, six jours de suite, que
la sinusoïde n'explique pas (une cible sur sept, les pointés faux de 30 px écrasent l'ajustement) ; la répétition
d'un jour à l'autre (méthode 1, 6 cibles sur 7) suffit. En échange, une seule heure chaude n'est pas un cycle
(CHAUDES_MIN) : NIEDERHORN (E-005, horaire) avait sinon son heure de midi (trains, trous) en contraction de la caméra.
L'épisode de la caméra porte sur tous les capteurs, références comprises : toute l'image bouge.
Glissade commune, sans cycle (boucle /detector-learner MICHIGAN, modification 1) : faute de cycle dans les courbes
corrigées comme dans les positions brutes, un instant est une glissade de la caméra si les positions brutes (x ou y) d'au
moins PART des capteurs, références comprises, **et** les courbes corrigées (corr_x ou corr_y) d'au moins PART des cibles
s'écartent du même côté d'au moins ECART bruits (médiane des pas de la série) de leur médiane du jour d'avant ; les
glissades à moins d'un jour l'une de l'autre font un épisode, « Camera thermal movement », sur tous les capteurs, hôte
des sauts revenus (categories.HOTES). La caméra bouge avec la température sans revenir chaque jour à la même heure (une
mesure toutes les 4 h, refroidissements brefs), et la compensation ne l'enlève pas toute. La condition sur les positions
brutes laisse aux sauts une bascule de la seule pose calculée (positions brutes immobiles). MICHIGAN : 9 épisodes du 09
au 30.10, tous dans la dérive thermique étiquetée ; NEBRASKA : 13 instants, tous justes ; BREITHORN, JUNGFRAU, NORDEND,
WILDSTRUBEL inchangés (cycle trouvé, ou rien) ; ECART = 2 prenait 2 instants Displacement de BREITHORN.
La caméra bouge avec le froid (/detector-learner Thermal displacement, modification 1, S3) : faute de cycle, aussi un
« Camera thermal movement » là où la pose de la caméra (tilt, rotation ou échelle) s'écarte de sa médiane du jour d'avant
d'au moins FROID bruits, pendant que la température de la station (detect la déclare, D-124) tombe sous la sienne d'au
moins FROID bruits la même heure ; bruit : la médiane des variations sur une heure (sur un pas, à une mesure toutes les
4 h), pour que le seuil ne dépende pas de la cadence. Les cibles peuvent s'écarter en sens opposés ou rester presque
immobiles (la compensation absorbe le mouvement) : la règle des glissades ne le voit pas. Les instants qui se suivent dans
la pose font un épisode. Sans pose ou sans température, rien. FROID = 3 prenait plus d'instants Displacement de NEBRASKA
et de MICHIGAN ; la chaleur n'est pas prise : par beau temps, c'est le cycle du jour.
"""
import math
import os
import statistics
import sys
from datetime import datetime, timedelta, timezone
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) # donnees.py, à côté
from donnees import charger, iso # noqa: E402
HEURES_MIN = 20 # provisoire : un jour UTC compte dans le profil s'il a au moins 20 heures mesurées
PARTIEL = 12 # provisoire : un jour incomplet d'au moins 12 heures reçoit son épisode s'il ressemble au profil
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
CHAUDES_MIN = 2 # provisoire : boucle WILDSTRUBEL, lot 01 ; NIEDERHORN (E-005) n'a qu'une heure chaude (midi)
BORD = 0.1 # provisoire : bornes de la vague (départ, retour), en part de l'amplitude ; CHAUD dit s'il y a un cycle
ECART = 3 # provisoire : glissade commune, en bruits (médiane des pas) d'écart à la médiane du jour d'avant
FROID = 4 # provisoire : la caméra bouge avec le froid, en bruits d'une heure d'écart au jour d'avant (pose, température)
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, tous = {}, {}
for d, hs in jours.items():
if len(hs) >= PARTIEL:
med = statistics.median(v for l in hs.values() for v in l)
tous[d] = {h: statistics.mean(l) - med for h, l in hs.items()}
if len(hs) >= HEURES_MIN:
J[d] = tous[d]
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 tous.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)]
if len(hs) >= 3:
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, temperature=(), camera=()):
"""Cycle des courbes corrigées (l'ouvrage) ; sinon, celui des positions brutes (la caméra qui bouge par dilatation
de son support, compensée : D-074, 2026-10-27) ; sinon, les glissades de la caméra (avec le froid)."""
return (_episodes(mesures, ("corr_x", "corr_y"), "Thermal", False) or
_episodes(mesures, ("x", "y"), "Camera thermal", True) or glissades(mesures, temperature, camera))
def _signes(ms, col, heure=False, seuil=None):
"""{instant: +1 ou -1} où la mesure s'écarte d'au moins ECART bruits de la médiane du jour d'avant ; bruit : la
médiane des pas d'une mesure à la suivante, ou, heure, des variations sur une heure (un pas si la cadence est lente)."""
k = [(m["t"], m[col]) for m in ms if m[col] is not None]
if len(k) < 3:
return {}
pas = statistics.median((b - a).total_seconds() for (a, _), (b, _) in zip(k, k[1:])) if heure else 0
n = max(1, round(3600 / pas)) if pas else 1
bruit = statistics.median(abs(k[i + n][1] - k[i][1]) for i in range(len(k) - n)) if len(k) > n else 0
out, j = {}, 0
for i, (t, v) in enumerate(k):
while k[j][0] < t - timedelta(days=1):
j += 1
avant = [w for _, w in k[j:i]]
if bruit and len(avant) >= 3 and abs(v - statistics.median(avant)) >= (seuil or ECART) * bruit:
out[t] = 1 if v > statistics.median(avant) else -1
return out
def _communs(series):
"""[{instant: signe}] d'un groupe de capteurs -> instants où au moins PART d'entre eux s'écartent du même côté."""
n, compte = len(series), {}
for sg in series:
for t, x in sg.items():
compte.setdefault((t, x), 0)
compte[(t, x)] += 1
return {t for (t, x), c in compte.items() if n and c >= PART * n}
def _froid(mesures, temperature, camera):
"""[(début, fin)] des suites d'instants où la pose de la caméra (tilt, rotation ou échelle) s'écarte de son jour
d'avant pendant que la température tombe sous le sien, d'au moins FROID bruits d'une heure ; vide sans l'une d'elles."""
ts = [m["t"] for ms in mesures.values() for m in ms]
heure = lambda t: t.replace(minute=0, second=0, microsecond=0) # noqa: E731
froid = {heure(t) for t, x in _signes([{"t": t, "T": v} for t, v in temperature], "T", True, FROID).items() if x < 0}
pose = [p for p in camera if min(ts) <= p["t"] <= max(ts)] if ts else []
vus = {t for c in ("tilt", "rotation", "scale") for t in _signes(pose, c, True, FROID) if heure(t) in froid}
episodes = [] # les instants qui se suivent dans la pose font un épisode
for i, p in enumerate(pose):
if p["t"] in vus:
if episodes and episodes[-1][2] == i - 1:
episodes[-1][1:] = [p["t"], i]
else:
episodes.append([p["t"], p["t"], i])
return [(a, b) for a, b, _ in episodes]
def glissades(mesures, temperature=(), camera=()):
"""Glissade commune de la caméra, sans cycle de 24 h : les positions brutes de la plupart des capteurs, références
comprises, et les courbes corrigées de la plupart des cibles s'écartent ensemble, du même côté, de leur jour d'avant ;
ou la pose de la caméra s'en écarte avec le froid (_froid)."""
cibles = [ms for ms in mesures.values() if ms[0]["pattern_type"] != "global_ref"]
brut = set().union(*(_communs([_signes(ms, c) for ms in mesures.values()]) for c in ("x", "y")))
corr = set().union(*(_communs([_signes(ms, c) for ms in cibles]) for c in ("corr_x", "corr_y")))
episodes = []
for t in sorted(brut & corr):
if episodes and t - episodes[-1][1] <= timedelta(days=1): # moins d'un jour entre deux : la même glissade
episodes[-1][1] = t
else:
episodes.append([t, t])
return [{"start": iso(a), "end": iso(b), "kind": "Thermal displacement", "label": "Camera thermal movement",
"text": "The camera moved with a change of temperature and all the curves moved with it; this is not a "
"movement of the structure, nothing to do.", "ignore": False, "sensors": sorted(mesures)}
for a, b in episodes + _froid(mesures, temperature, camera)]
def _episodes(mesures, cols, nom, camera):
concernes, n = cycle(mesures, cols)
capteurs = sorted({c[0] for c in concernes})
if not n or len(capteurs) < PART * n:
return []
if not camera: # seconde méthode, pour l'ouvrage seul : la sinusoïde doit le voir aussi
oui, evaluees = sinus(mesures, cols)
if not evaluees or len(oui) < PART * len(evaluees):
return []
chaudes = heures_chaudes(concernes)
if len(chaudes) < CHAUDES_MIN:
return []
e = ecarts(concernes)
pic = max(chaudes, key=lambda h: e[h]) # le plus grand écart au niveau de nuit : fin de la dilatation
repos = min(range(24), key=lambda h: e[h])
a = pic # départ : on remonte du pic tant que le profil reste au-dessus de BORD, jusqu'à l'heure la plus calme
while (a - 1) % 24 != repos and e[(a - 1) % 24] >= BORD:
a -= 1
b = pic + 1 # retour : jusqu'à ce que le profil repasse sous BORD, au plus jusqu'au départ suivant
while b < a + 24 and e[b % 24] >= BORD:
b += 1
derniere = max(m["t"] for ms in mesures.values() for m in ms)
jours = sorted({d for c in concernes for d in c[3]})
if camera: # toute l'image bouge, références comprises
capteurs = sorted(mesures)
episodes = []
for d in jours: # ponytail: jours d'au moins PARTIEL heures, 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, u, v in ((f"{nom} expansion", a, pic), (f"{nom} contraction", pic, b)):
debut, fin = minuit + timedelta(hours=u), min(minuit + timedelta(hours=v), derniere)
if fin > debut:
episodes.append({"start": iso(debut), "end": iso(fin),
"kind": "Thermal displacement", "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)}")
-377
View File
@@ -1,377 +0,0 @@
"""Journal du matin : le détecteur de la famille Visibility (labeling/familles.md) : on voit moins bien, l'image est faible
ou floue (error_value), ou elle tremble (turbulence, en fin de fichier). Le même calcul de l'error_value trouve aussi les
objets devant quelques cibles (Brief obstruction, Target obscured) : episodes() les rend avec la famille Obstruction, que
detect() laisse à obstruction.py.
Méthode (seuils provisoires ci-dessous) :
1. Mesure « haute » : error_value > médiane + 10 MAD du capteur sur l'export, et > 2 × médiane, ou rejetée (> error_threshold)
et > 1,2 × médiane : un capteur au niveau habituel de 0,6 ne double jamais, et FLORIDA (boucle, lot 01) montrait ses brouillards
en Target obscured.
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é. Sauf si au moins
BREF_MIN cibles sont rejetées (> error_threshold) à cet instant et ni à l'instant d'avant ni à celui d'après : un
passage devant elles, une référence touchée en plus (/detector-learner Displacement, modification 1, S5 : trains de
NIEDERHORN, 12 et 13 cibles rejetées ; NORDEND le 01.09 11:15 n'a aucun rejet).
Aussi, un passage devant une ou deux cibles, ou une seule référence : à un instant, moins de BREF_MIN capteurs
rejetés à plus de FACTEUR fois leur médiane (sans K_MAD : de jour, la turbulence gonfle la MAD), au plus une
référence, aucun d'eux rejeté à l'instant d'avant ni à celui d'après, et moins de BREF_MIN capteurs hauts
(/detector-learner Obstruction, modification 1, S3 : véhicules, passants, insectes devant une ou deux cibles de
WILDSTRUBEL, NIEDERHORN, LENZSPITZE ; une référence cachée par un camion à JUNGFRAU, BREITHORN).
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.
L'écart est d'au moins deux pas de mesure, et deux rejets suffisent quand CIBLE_MIN pas ne tiennent pas dans
CIBLE_ECART (/detector-learner Obstruction, modification 1, S6 : à une mesure toutes les 4 h, les véhicules garés
la nuit devant COLI22, COLI24, POUI22 de BREITHORN ne font que deux ou trois rejets).
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 E-001, toile de E-002, pluie
de E-005 en reduced.
6. Bornes d'une Poor visibility (boucle WILDSTRUBEL, lot 01) : de la première à la dernière mesure où une cible est
rejetée (> error_threshold), et pas d'épisode sans cible rejetée. Sur une chaussée en plein soleil, l'error_value de
jour (×1,5 à ×3, la turbulence) faisait durer la visibilité réduite des heures sans aucun rejet (28.09 10:00 → 12:15,
29.09 jusqu'à 14:15) ; les références ne comptent pas : R3 y passe son seuil presque toute la journée. Benchmark :
le seul épisode perdu est celui, faux, de E-010.
7. Poor visibility ou objet (frontière « Visibility ou Obstruction » de labeling/familles.md ; boucle /detector-learner
BREITHORN, lot 01) : une gêne qui ne touche qu'au plus QUELQUES cibles, et aucune référence, n'est pas diffuse : c'est
un objet devant elles (un véhicule stationné), un épisode « Target obscured » de toute sa durée, sans niveau.
8. Gêne diffuse, rejets ou non (/detector-learner Visibility, modification 1, S2) : à chaque instant, la médiane, sur les
capteurs, de l'error_value en MAD au-dessus de la médiane de chacun ; au moins SUITE_MIN instants de suite à K_DIFFUS
ou plus font une Poor visibility « reduced ». Une gêne diffuse tout entière dans une turbulence est la turbulence : pas
d'épisode (sinon elle absorbait le saut revenu de la veille, WILDSTRUBEL le 04.10). Trouve les baisses de visibilité de
toute la scène sans rejet de JUNGFRAU, FLORIDA, NORDEND ; à 2, des nuits étiquetées thermiques à JUNGFRAU, à 3 la
moitié du gain.
Résultats (2026-10-23) :
- PS_DES_COUDRES (E-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 (E-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 (E-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 (E-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 (E-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.
- FLORIDA (boucle, lot 01 ; cibles au niveau 0,6 pour un seuil de 0,7) : les brouillards du 18.10, du 20-21.10, du 23.10 et
du 24-25.10, avant en Target obscured, en Poor visibility (none et reduced en alternance, cœur seul : à 10 MAD) ; la référence
r1_r au-dessus de son seuil du 22.10 au 24.10 reste manquée (son MAD de 0,15 rend 10 MAD hors d'atteinte).
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 E-001 manquée,
toile de E-002 morcelée, turbulence de E-003 prise pour une perte de visibilité) et grisait le vrai mouvement de E-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.dirname(os.path.abspath(__file__))) # donnees.py, à côté
from donnees import charger, iso # noqa: E402
K_MAD = 10 # provisoire, réglé sur E-001 (buée : 11 à 57 MAD) et E-005 (pluie, trains : 10 à 70 MAD)
FACTEUR = 2 # provisoire : écarte les capteurs à MAD quasi nulle (E-004 : PWD_REF10 ×1,6 à 14 MAD, E-005)
SUITE_MIN = 3 # provisoire : mesures hautes d'affilée pour une mauvaise visibilité (E-001, E-005 pluie)
BREF_MIN = 3 # provisoire, réglé sur E-005 (trains : 5 à 17 capteurs ; celui de 2 cibles est manqué)
K_CIBLE = 5 # provisoire, réglé sur E-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 (E-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 (E-005 : 5 à 17 contre 0 à 2 ;
# la toile de E-002 varie de 2 à 9 d'un pas à l'autre)
CIBLE_ECART = timedelta(hours=6) # provisoire, réglé sur E-005 (feuilles : 7 rejets en 12 h, jusqu'à 5 h d'écart)
FACTEUR_REJET = 1.2 # provisoire : un rejet à 10 MAD compte aussi (boucle FLORIDA, lot 01 : niveaux de 0,6, ×2 hors d'atteinte) ;
# écarte C24 de E-009 (niveau 0,68 au ras du seuil 0,7, rejeté à ×1,04)
MOITIE = 0.5 # provisoire : « on ne voit rien » ; réglé sur NORDEND (09.10 23:00 : 68 % rejetées) et E-005 (pluie : 24 à 33 %)
K_DIFFUS = 2.5 # provisoire : gêne diffuse (8) ; /detector-learner Visibility, modification 1, S2
QUELQUES = 3 # provisoire : Poor visibility sur au plus 3 cibles, sans référence : un objet, Target obscured (7) ;
# boucle /detector-learner BREITHORN, lot 01 (véhicules stationnés devant 2 ou 3 cibles sur 12)
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": "Visibility" if label == "Poor visibility" else "Obstruction",
"label": label, "text": text,
"ignore": level != "reduced", "sensors": sorted(capteurs)} # visibilité réduite : données moyennes, pas grisées
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 episodes(mesures):
"""Tous les épisodes de l'error_value : Visibility (Poor visibility), Obstruction (Brief obstruction, Target obscured)."""
pas = _pas(mesures)
ecart = ECART * pas
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]
refuses = set() # instants où une cible (pas une global_ref) est au-dessus de son seuil
rejetees = {} # t -> {cibles au-dessus de leur seuil}
forts, refus = {}, {} # t -> {capteurs rejetés à plus de FACTEUR fois leur médiane}, {capteurs rejetés}
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
rejete = m["error_threshold"] and x > m["error_threshold"]
if rejete and s not in refs:
refuses.add(m["t"])
rejetees.setdefault(m["t"], set()).add(s)
if x > med + K_MAD * mad and (x > FACTEUR * med or rejete and x > FACTEUR_REJET * med):
hautes.setdefault(s, []).append(m["t"])
if rejete:
refus.setdefault(m["t"], set()).add(s)
if x > FACTEUR * med:
forts.setdefault(m["t"], set()).add(s)
if s not in refs and rejete 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)
seules = rejetees.get(t, set()).difference(*(rejetees.get(instants[j], set()) for j in (i - 1, i + 1)
if 0 <= j < len(instants)))
if par_t[t] & refs and len(seules) < BREF_MIN: # références touchées sans cibles rejetées à ce seul instant :
continue # pas un obstacle devant des cibles, l'image entière
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]))
elif 0 < len(f := forts.get(t, set())) < BREF_MIN and n(t) < BREF_MIN and len(f & refs) <= 1 and not f & set().union(
*(refus.get(instants[j], set()) for j in (i - 1, i + 1) if 0 <= j < len(instants))):
# une ou deux cibles, ou une référence, rejetées à cette seule mesure, à FACTEUR fois leur médiane
out.append(_episode(t, t, "Brief obstruction", f"{len(f)} point{'s were' if len(f) > 1 else ' was'} poorly seen "
"for a single measurement, then came back: probably something passing; ignore this point on the "
"curves.", f))
# 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]
# Bornes : de la première à la dernière cible rejetée ; sans rejet, pas d'épisode (6).
gardees = [(r[0], r[-1], cs) for a, b, cs in gardees if (r := [t for t in instants if a <= t <= b and t in refuses])]
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
if len(cs) <= QUELQUES and not cs & refs: # un objet devant quelques cibles, pas une gêne diffuse (7)
out.append(_episode(a, b, "Target obscured", "", cs))
continue
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], max(CIBLE_ECART, 2 * pas)):
if len(l) >= (CIBLE_MIN if CIBLE_MIN * pas <= CIBLE_ECART else 2) 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
def diffuse(mesures):
"""Gêne diffuse (8) : les suites d'au moins SUITE_MIN instants où la médiane, sur les capteurs, de l'error_value en MAD
au-dessus de la médiane de chacun atteint K_DIFFUS, rejets ou non -> Poor visibility « reduced »."""
z = {} # t -> {capteur: écart en MAD}
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:
if m["error_value"] is not None:
z.setdefault(m["t"], {})[s] = (m["error_value"] - med) / mad
hauts = [(t, None) for t in sorted(z) if statistics.median(z[t].values()) >= K_DIFFUS]
return [_episode(a, b, "Poor visibility", "", {s for t in l for s, x in z[t].items() if x >= K_DIFFUS}, "reduced")
for a, b, _, l in _grouper(hauts, ECART * _pas(mesures)) if len(l) >= SUITE_MIN]
def detect(mesures):
tremble = turbulence(mesures) # une gêne diffuse pendant une turbulence est la turbulence (8)
return ([e for e in episodes(mesures) if e["kind"] == "Visibility"] + tremble
+ [e for e in diffuse(mesures) if not any(t["start"] <= e["start"] and e["end"] <= t["end"] for t in tremble)])
# --- Turbulence ----------------------------------------------------------------------------------------------------
# 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 : E-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 en plus de l'habitude de leur capteur (sa part de rejets sur l'export) : c'est alors de la mauvaise
# visibilité, autre règle. Une cible toujours rejetée (Target issue) ne compte pas (/detector-learner Visibility,
# modification 1, S1 : WILDSTRUBEL, R3 rejetée toute la journée, les jours de turbulence étaient écartés).
# Grisé si l'agitation médiane ≥ 2×.
#
# Résultats (2026-10-23, seuils ci-dessous) :
# - WILDSTRUBEL (E-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.
RATIO = 1.5 # provisoire, réglé sur E-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 E-003 (error_value ×1,7 à ×3,2 la nuit ; ≈ ×1 à midi ailleurs)
REJET_MAX = 0.15 # provisoire : E-003 ≤ 7 % ; toile d'araignée (E-002) et pluie (E-005) ≥ 18 % ; rejets en plus de l'habitude
# depuis /detector-learner Visibility, modification 1, S1 (WILDSTRUBEL : 4 à 14 %, contre 9 à 22 % bruts)
FORT = 2.0 # provisoire : E-003 (×2,3 à ×2,6) est fort ; un épisode entre ×1,5 et ×2 reste visible
DUREE_MIN = timedelta(hours=3) # provisoire : E-003 dure 10-11 h ; écarte le matin du mouvement réel de E-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 turbulence(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])
taux = {s: sum(m["corr_x"] is None for m in ms) / len(ms) for s, ms in mesures.items()} # rejets habituels
episodes = []
for b in blocs:
debut, fin = b[0], b[-1] + HEURE
par = {s: [m for m in ms if debut <= m["t"] < fin] for s, ms in mesures.items()}
nouveaux = sum(max(0, sum(m["corr_x"] is None for m in d) - taux[s] * len(d)) for s, d in par.items())
if fin - debut < DUREE_MIN or nouveaux > REJET_MAX * sum(map(len, par.values())):
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": "Visibility",
"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"], f"| {len(e['sensors'])} :", ",".join(e["sensors"][:8]), "|", e["text"])