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:
1 parent
9b3ac0ecfe
commit
969637499f
23 files changed
+1877
-1971
No files matched your search
-246
@@ -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
@@ -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
@@ -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
@@ -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)
|
||||
@@ -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"])
|
||||
@@ -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
@@ -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")
|
||||
@@ -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"])
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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")
|
||||
@@ -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)
|
||||
@@ -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"])
|
||||
@@ -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)
|
||||
@@ -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)}")
|
||||
@@ -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"])
|
||||
@@ -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")
|
||||
@@ -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})")
|
||||
@@ -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__)
|
||||
@@ -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
@@ -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)
|
||||
@@ -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
@@ -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"])
|
||||
Reference in new issue
Block a user