diff --git a/categories.py b/categories.py deleted file mode 100644 index 633b0cf..0000000 --- a/categories.py +++ /dev/null @@ -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 (une ligne par événement : famille, sorte, capteurs) - ... [--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 diff --git a/displacement.py b/displacement.py deleted file mode 100644 index 24263e9..0000000 --- a/displacement.py +++ /dev/null @@ -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"]) diff --git a/donnees.py b/donnees.py deleted file mode 100644 index cdae427..0000000 --- a/donnees.py +++ /dev/null @@ -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") diff --git a/no_data.py b/no_data.py deleted file mode 100644 index 1664437..0000000 --- a/no_data.py +++ /dev/null @@ -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 (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) diff --git a/obstruction.py b/obstruction.py deleted file mode 100644 index d6d5e26..0000000 --- a/obstruction.py +++ /dev/null @@ -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 (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"]) diff --git a/scripts/categories.py b/scripts/categories.py new file mode 100644 index 0000000..4cf9fd4 --- /dev/null +++ b/scripts/categories.py @@ -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 (one line per event: family, variety, sensors) + ... [--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 diff --git a/scripts/data.py b/scripts/data.py new file mode 100644 index 0000000..d833b6b --- /dev/null +++ b/scripts/data.py @@ -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") diff --git a/scripts/displacement.py b/scripts/displacement.py new file mode 100644 index 0000000..c2be504 --- /dev/null +++ b/scripts/displacement.py @@ -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"]) diff --git a/scripts/learner/regression.py b/scripts/learner/regression.py new file mode 100644 index 0000000..dfced01 --- /dev/null +++ b/scripts/learner/regression.py @@ -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/.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) diff --git a/scripts/learner/score.py b/scripts/learner/score.py new file mode 100644 index 0000000..723f420 --- /dev/null +++ b/scripts/learner/score.py @@ -0,0 +1,97 @@ +"""Score of the detectors on a range: the detectors' events against the labels of labeling/auto/.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 --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/.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) diff --git a/scripts/learner/sensors.py b/scripts/learner/sensors.py new file mode 100644 index 0000000..358dbf8 --- /dev/null +++ b/scripts/learner/sensors.py @@ -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 --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") diff --git a/scripts/no_data.py b/scripts/no_data.py new file mode 100644 index 0000000..ce803f1 --- /dev/null +++ b/scripts/no_data.py @@ -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 (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) diff --git a/scripts/obstruction.py b/scripts/obstruction.py new file mode 100644 index 0000000..435a8f1 --- /dev/null +++ b/scripts/obstruction.py @@ -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 (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"]) diff --git a/scripts/target_issue.py b/scripts/target_issue.py new file mode 100644 index 0000000..b459e6f --- /dev/null +++ b/scripts/target_issue.py @@ -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 (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) diff --git a/scripts/thermal_displacement.py b/scripts/thermal_displacement.py new file mode 100644 index 0000000..c09cb0a --- /dev/null +++ b/scripts/thermal_displacement.py @@ -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)}") diff --git a/scripts/visibility.py b/scripts/visibility.py new file mode 100644 index 0000000..3cf33b3 --- /dev/null +++ b/scripts/visibility.py @@ -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"]) diff --git a/skills/detector-learner/capteurs.py b/skills/detector-learner/capteurs.py deleted file mode 100644 index 6784e51..0000000 --- a/skills/detector-learner/capteurs.py +++ /dev/null @@ -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 --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") diff --git a/skills/detector-learner/regression.py b/skills/detector-learner/regression.py deleted file mode 100644 index 779991e..0000000 --- a/skills/detector-learner/regression.py +++ /dev/null @@ -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 --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/.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})") diff --git a/skills/detector-learner/score.py b/skills/detector-learner/score.py deleted file mode 100644 index 2a98288..0000000 --- a/skills/detector-learner/score.py +++ /dev/null @@ -1,142 +0,0 @@ -"""Score des détecteurs sur une plage : les détecteurs du journal face aux étiquettes de labeling/auto/.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 --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/.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__) diff --git a/skills/learner/SKILL.md b/skills/learner/SKILL.md new file mode 100644 index 0000000..e6c175d --- /dev/null +++ b/skills/learner/SKILL.md @@ -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//) — 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 . +argument-hint: "" +--- + +# 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/.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/`. Sans `/demande.json`, ou sans `detectors/.claude-plugin/plugin.json` : dis-le et arrête-toi, sans commit. +- De `/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/_/`, ci-dessous ``. +- **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 && git commit -m "" -- `, 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 `. Tu ne pousses rien. +- **Étape 0, l'analyse dans git** : l'app ne commite pas ; si `git status --porcelain -- labeling/auto/.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 : é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 /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 --prefix=detectors/ | tar -x -C `, des liens vers `data/`, `labeling/` et `agent-tools/` du dépôt de travail, puis `python3 /detectors/skills/detector-learner/regression.py`) dans `/benchmark-avant-relance.txt`, et ajoute à la demande du contrôle : `Changé pendant la séance : ; benchmark avant relancé : /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 _ --etape <étape> > /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/ --du --au > /plage-<étape>.txt 2>&1`. Les étiquettes de `labeling/auto/.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/ --du --au ` ; les capteurs, `python3 detectors/skills/detector-learner/capteurs.py data/ --du --au `. Pour le contrôle seulement, qui regarde toutes les stations, le journal avec ``, `` et `` à remplir depuis l'en-tête du bloc de la station dans le benchmark : `python3 detectors/categories.py data/ --du --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\*\* :' ` ; 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 && git -C detectors commit -m "" -- `. + +1. **Mesures avant** : étape `avant`, donc `/benchmark-avant.txt` et `/plage-avant.txt`. + Commit `detector-learner/_/ detector-learner/historique.csv`, message `Detector-learner : benchmark`. +2. **Detectors-critic** : `Analyse : /. Station : , plage → (UTC). Commande du journal : . Commande des capteurs : . Score de la plage : /plage-avant.txt. Benchmark : /benchmark-avant.txt. Écris /critique.md.` + Commit du dossier de séance, message `Detector-learner : critique ()`. Verdict `d'accord` : va au bilan. +3. **Detectors-upgrader**, un seul passage : + `Analyse : /. Station : . Commande du journal : . Critique : /critique.md. Benchmark avant : /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/ --du --au (avant : /plage-avant.txt). Dossier de séance : . Fichiers déjà modifiés au début de la séance : . Écris /modification-1.md.` + L'upgrader commite lui-même, dans `detectors/`, chaque suggestion gardée, avec son benchmark `/benchmark-1-S.txt`, message `Detector-learner : modification 1, S` : le contrôle peut ainsi en faire retirer une seule. + Puis les mesures, étape `modification 1`, dans `/benchmark-1.txt` et `/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 : modification 1`. Aucune suggestion gardée (pas de commit `, S` : `git -C detectors log --format=%h --grep ', S[0-9]*$' ..HEAD`) : va au bilan. +4. **Detectors-control**, qui ne lit ni la critique ni le détail de la modification : + `Analyse : . Modification : /modification-1.md. Benchmark : /benchmark-avant.txt → /benchmark-1.txt, à relancer par python3 detectors/skills/detector-learner/regression.py (sans --etape) ; après chaque suggestion : /benchmark-1-S*.txt. Score de la plage : /plage-avant.txt → /plage-1.txt. Commande du journal : . Base (dans detectors/) : . Écris /validation-1.md.` + Commit du dossier de séance, message `Detector-learner : control ()`. + - `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$' ..HEAD`), du plus récent au plus ancien : `git -C detectors revert --no-edit `, puis amende son message pour qu'il finisse par la ligne `Co-Authored-By` (`git -C detectors commit --amend -m "Detector-learner : S retirée" -m "Co-Authored-By: Claude Opus 5.5 "`). 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 -- '*.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 : 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 `/benchmark-fin.txt` et `/plage-fin.txt`. + +`/bilan.md`, que la page Data affiche sous le rapport : + +```markdown +# Optimisation : + +**Résultat** : modification gardée | gardée sans S… | annulée | aucune | erreur + +## La plage de l'analyse +, → ; 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é + ; la critique (d'accord / n suggestions), le contrôle (verdict) + +## À trancher par l'utilisateur + + +## Suggestions non traitées +<« Pas corrigé » de la modification ; aucune> + +## Erreurs +..HEAD`> +``` + +Commit, dans `detectors/`, du dossier de séance et de `detector-learner/historique.csv`, message `Detector-learner : bilan`. Puis, dans le dépôt de travail, le sous-module à son nouveau commit : `git add detectors && git commit -m "Detector-learner : 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 : / : 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 : 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`. diff --git a/target_issue.py b/target_issue.py deleted file mode 100644 index d3de7df..0000000 --- a/target_issue.py +++ /dev/null @@ -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 (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) diff --git a/thermal_displacement.py b/thermal_displacement.py deleted file mode 100644 index fc3c53e..0000000 --- a/thermal_displacement.py +++ /dev/null @@ -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)}") diff --git a/visibility.py b/visibility.py deleted file mode 100644 index f8fb6de..0000000 --- a/visibility.py +++ /dev/null @@ -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"])