One detector per family, family keys equal to their names (D-119)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
0666d59e7d
commit
98be20a2bc
34 files changed
+551
-516
No files matched your search
+81
-90
@@ -1,20 +1,18 @@
|
||||
"""Journal du matin : des épisodes des détecteurs aux événements catégorisés.
|
||||
"""Journal du matin : des épisodes des détecteurs aux événements, un par famille.
|
||||
|
||||
Les catégories du journal (CATEGORIES, validées, D-074) se rangent dans les familles des étiquettes, labeling/familles.md :
|
||||
sa section « Correspondance » fait foi (score.py la lit) ; le champ famille de CATEGORIES la recopie, pour lire ce fichier
|
||||
seul. Un saut bref n'a pas de famille fixe : il a celle de sa cause (familles.md, « Un saut puis le retour »).
|
||||
|
||||
Chaque épisode reçoit sa catégorie d'après son détecteur et son label (LABELS, puis KINDS). Règles :
|
||||
- un saut revenu à la normale qui chevauche une catégorie de HOSTS (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
|
||||
un saut bref sans cause établie, à vérifier sur les images, pas grisé (familles.md : sans cause établie, Displacement) ;
|
||||
- un saut qui dure, ou trop récent pour savoir, n'est jamais absorbé ;
|
||||
- une turbulence qui chevauche un saut à vérifier n'est pas gardée : un vrai mouvement agite aussi les courbes ;
|
||||
- deux événements de même catégorie à moins de MERGE n'en font qu'un.
|
||||
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 décalage qui dure, ou trop récent pour savoir (DECALAGES), n'est jamais absorbé ;
|
||||
- une turbulence qui chevauche un décalage n'est pas gardée : un vrai mouvement agite aussi les courbes ;
|
||||
- deux événements de même sorte à moins de MERGE n'en font qu'un.
|
||||
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 catégorie l'établit, sinon les images la montrent.
|
||||
« Pour le client » de familles.md ; la cause n'est dite que si la sorte l'établit, sinon les images la montrent.
|
||||
Pas de fonction detect : le chargeur ne prend pas ce fichier pour un détecteur.
|
||||
Usage : python3 detectors/categories.py <dossier de station> (une ligne par événement)
|
||||
Usage : python3 detectors/categories.py <dossier de station> (une ligne par événement : famille, sorte, capteurs)
|
||||
... <dossier> [--du AAAA-MM-JJ] [--au AAAA-MM-JJ] [--tranche 3] [--historique N] (tri en lot : chaque tranche
|
||||
de N jours classée seule, avec les jours d'historique d'avant s'ils existent ; seuls les événements qui touchent
|
||||
la tranche sont montrés ; « rien » pour une tranche calme)
|
||||
@@ -28,40 +26,22 @@ from pathlib import Path
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "agent-tools"))
|
||||
from donnees import charger, iso # noqa: E402
|
||||
|
||||
# famille : celle de labeling/familles.md (None : la famille de sa cause) ; ignore : zone grisée (None : comme le dit le
|
||||
# détecteur, la turbulence n'est grisée que forte) ; process : bouton Images, rien, ou Images et lien vers Diagnosis.
|
||||
# L'ordre est celui des lignes de la frise.
|
||||
# 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 = {
|
||||
"visibilite_reduite": {"label": "Reduced visibility", "famille": "visibilite", "ignore": False, "process": "images"},
|
||||
"visibilite_nulle": {"label": "No visibility", "famille": "visibilite", "ignore": True, "process": "images"},
|
||||
"passage": {"label": "Passing obstacle", "famille": "obstruction", "ignore": True, "process": "images"},
|
||||
"cible_masquee": {"label": "Target hidden", "famille": "obstruction", "ignore": True, "process": "images"},
|
||||
"cible_a_probleme": {"label": "Target issue", "famille": "cible_a_probleme", "ignore": True, "process": "images"},
|
||||
"turbulence": {"label": "Heat haze", "famille": "visibilite", "ignore": None, "process": "aucun"},
|
||||
"dilatation_thermique": {"label": "Thermal expansion", "famille": "deplacement_thermique", "ignore": False,
|
||||
"process": "aucun"},
|
||||
"contraction_thermique": {"label": "Thermal contraction", "famille": "deplacement_thermique", "ignore": False,
|
||||
"process": "aucun"},
|
||||
"trou": {"label": "No data", "famille": "trou", "ignore": False, "process": "aucun"},
|
||||
"saut_bref": {"label": "Brief jump", "famille": None, "ignore": False, "process": "images"},
|
||||
"a_verifier": {"label": "Shift to check", "famille": "deplacement", "ignore": False, "process": "verifier"},
|
||||
"derive_lente": {"label": "Slow drift", "famille": "deplacement", "ignore": False, "process": "verifier"},
|
||||
"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"},
|
||||
}
|
||||
# (détecteur, label, niveau de l'épisode) -> catégorie ; puis détecteur seul ; un détecteur inconnu garde son nom
|
||||
LABELS = {("visibilite", "Poor visibility", "reduced"): "visibilite_reduite",
|
||||
("visibilite", "Poor visibility", "none"): "visibilite_nulle",
|
||||
("visibilite", "Brief obstruction", None): "passage", ("visibilite", "Target obscured", None): "cible_masquee",
|
||||
("sauts", "Sudden jump, back to normal", None): "saut_bref", ("sauts", "Lasting shift", None): "a_verifier",
|
||||
("sauts", "Jump, not back yet", None): "a_verifier", ("sauts", "Large shift", None): "a_verifier",
|
||||
("sauts", "Target flipping", None): "cible_a_probleme", ("degradee", "Target obscured", None): "cible_masquee",
|
||||
("thermique", "Thermal expansion", None): "dilatation_thermique",
|
||||
("thermique", "Thermal contraction", None): "contraction_thermique",
|
||||
("thermique", "Camera thermal expansion", None): "dilatation_thermique",
|
||||
("thermique", "Camera thermal contraction", None): "contraction_thermique"}
|
||||
KINDS = {"turbulence": "turbulence", "trous": "trou", "degradee": "cible_a_probleme", "derive": "derive_lente"}
|
||||
HOSTS = {"visibilite_reduite", "visibilite_nulle", "passage", "turbulence", "dilatation_thermique",
|
||||
"contraction_thermique"} # disent la cause d'un saut revenu qui les chevauche, et l'absorbent
|
||||
MERGE = timedelta(hours=1) # même catégorie à moins d'une heure : un seul événement (règle validée, 2026-10-24)
|
||||
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"} # 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():
|
||||
@@ -84,7 +64,18 @@ def detecteurs():
|
||||
|
||||
|
||||
def categorie(ep):
|
||||
return LABELS.get((ep["kind"], ep["label"], ep.get("level"))) or KINDS.get(ep["kind"]) or ep["kind"]
|
||||
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):
|
||||
@@ -95,37 +86,38 @@ def targets(n):
|
||||
return "one target" if n == 1 else f"{n} targets"
|
||||
|
||||
|
||||
def phrase(cat, groupe, sensors, references):
|
||||
"""Phrase du journal d'un événement (validées par l'utilisateur le 2026-10-24) ; un saut absorbé ajoute qu'il a la
|
||||
même cause."""
|
||||
n, one = len(sensors), len(sensors) == 1
|
||||
sauts = [e for e in groupe[1:] if categorie(e) == "saut_bref"]
|
||||
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 categorie(e) == "a_verifier" for s in e.get("lasting", [])})
|
||||
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 = groupe[0]["label"].startswith("Camera")
|
||||
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 = {
|
||||
"visibilite_nulle": f"The camera could not see {targets(n)} clearly{refs}. "
|
||||
"The curves in this period are not reliable: ignore them.",
|
||||
"visibilite_reduite": f"The camera saw {targets(n)} less clearly than usual{refs}. "
|
||||
"The data in this period are less precise: use them with care.",
|
||||
"passage": f"Something passed in front of {targets(n)} for a single measurement. Ignore this point on the curves.",
|
||||
"cible_masquee": f"{', '.join(sensors)} {'was' if one else 'were'} hidden several times while the targets around "
|
||||
f"{'it' if one else 'them'} stayed clear. Ignore {'its curve' if one else 'their curves'} in this period.",
|
||||
"turbulence": "Warm air made the readings shake. The small fast wiggles are not movement.",
|
||||
"dilatation_thermique": ("The 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_thermique": ("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_bref": f"{targets(n).capitalize()} jumped and came back. The cause is not established: look at the images.",
|
||||
"a_verifier": (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(cat, groupe[0]["text"]) # trou, cible à problème, dérive, détecteur inconnu : le texte du détecteur
|
||||
if cat == "cible_a_probleme":
|
||||
"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
|
||||
@@ -135,13 +127,13 @@ def phrase(cat, groupe, sensors, references):
|
||||
|
||||
def evenement(groupe, references):
|
||||
"""Épisodes d'un même événement, le principal en tête -> événement."""
|
||||
cat = categorie(groupe[0])
|
||||
c = CATEGORIES.get(cat, {"label": groupe[0]["label"], "ignore": None, "process": "aucun"})
|
||||
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 categorie(e) == cat] # la durée est celle des épisodes principaux, pas des sauts absorbés
|
||||
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": c["label"], "text": phrase(cat, groupe, sensors, references),
|
||||
"ignore": c["ignore"] if c["ignore"] is not None else any(e["ignore"] for e in groupe if categorie(e) == cat),
|
||||
"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}
|
||||
|
||||
|
||||
@@ -149,22 +141,21 @@ def classer(episodes, references=frozenset()):
|
||||
"""Épisodes de tous les détecteurs -> événements triés par début (règles : docstring du module) ; references : les
|
||||
capteurs global_ref, pour la phrase."""
|
||||
eps = sorted(episodes, key=lambda e: e["start"])
|
||||
checks = [e for e in eps if categorie(e) == "a_verifier"] # un vrai mouvement n'est jamais pris pour de la turbulence
|
||||
eps = [e for e in eps if categorie(e) != "turbulence" or not any(overlap(e, c) for c in checks)]
|
||||
checks = [e for e in eps if e["label"] in DECALAGES] # un vrai mouvement n'est jamais pris pour de la turbulence
|
||||
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)
|
||||
thermique = lambda e: categorie(e).endswith("_thermique") # noqa: E731
|
||||
hosts = sorted((e for e in eps if categorie(e) in HOSTS), key=thermique)
|
||||
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))), None)
|
||||
for e in eps if categorie(e) == "saut_bref"}
|
||||
for e in eps if e["label"] == SAUT}
|
||||
groupes = {id(e): [e] for e in eps if not host.get(id(e))}
|
||||
for e in eps:
|
||||
if host.get(id(e)):
|
||||
groupes[id(host[id(e)])].append(e)
|
||||
merged = []
|
||||
for g in groupes.values():
|
||||
prev = next((m for m in reversed(merged) if categorie(m[0]) == categorie(g[0])), None)
|
||||
end = max((e["end"] for e in prev if categorie(e) == categorie(g[0])), default=None) if prev else None
|
||||
prev = next((m for m in reversed(merged) if sorte(m[0]) == sorte(g[0])), 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:
|
||||
@@ -178,7 +169,7 @@ def evenements(mesures, fin=None):
|
||||
episodes = []
|
||||
for mod in detecteurs():
|
||||
try:
|
||||
episodes += mod.detect(mesures, fin) if mod.__name__ == "journal_trous" else mod.detect(mesures)
|
||||
episodes += mod.detect(mesures, fin) if mod.__name__ == "journal_no_data" else mod.detect(mesures)
|
||||
except Exception as e: # noqa: BLE001
|
||||
print(f"Journal : {mod.__name__} sauté ({type(e).__name__}: {e})", file=sys.stderr)
|
||||
return classer(episodes, {s for s, ms in mesures.items() if ms[0]["pattern_type"] == "global_ref"})
|
||||
@@ -210,8 +201,8 @@ if __name__ == "__main__":
|
||||
if a.tranche:
|
||||
print(f"== {iso(t)} → {iso(b)} : {len(evs) or 'rien'}")
|
||||
for v in evs:
|
||||
print(v["start"], "→", v["end"], f"{v['category']:<17}", "grisé" if v["ignore"] else "gardé",
|
||||
f"| {v['episodes'][0]['kind']}", # le détecteur, pour que la critique le nomme
|
||||
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['kind']} {e['start'][5:16]}" for e in v["episodes"][1:]) or "—")
|
||||
f"{e['label']} {e['start'][5:16]}" for e in v["episodes"][1:]) or "—")
|
||||
t = b
|
||||
@@ -1,70 +0,0 @@
|
||||
"""Journal du matin : dérive lente, une cible qui bouge peu à peu, jour après jour (sous-groupe de « À vérifier », D-074).
|
||||
|
||||
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 ; 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é.
|
||||
Usage : python3 detectors/derive.py <dossier de station> (affiche les épisodes)
|
||||
"""
|
||||
import os
|
||||
import statistics
|
||||
import sys
|
||||
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "agent-tools"))
|
||||
from donnees import charger, est_reference, iso # noqa: E402
|
||||
|
||||
HEURES = 20 # un jour compte s'il a au moins 20 heures mesurées (comme D-055)
|
||||
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)
|
||||
|
||||
|
||||
def _decile(vs, q):
|
||||
vs = sorted(vs)
|
||||
return vs[min(len(vs) - 1, int(q * len(vs)))]
|
||||
|
||||
|
||||
def _derive(ms, col):
|
||||
"""-> (dérive en px, jours, premier instant, dernier) ou None."""
|
||||
jours = {}
|
||||
for m in ms:
|
||||
if m[col] is not None:
|
||||
jours.setdefault(m["t"].date(), []).append(m)
|
||||
jours = {d: js for d, js in jours.items() if len({m["t"].hour for m in js}) >= HEURES}
|
||||
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 detect(mesures):
|
||||
out = []
|
||||
for s, ms in sorted(mesures.items()):
|
||||
if est_reference(ms):
|
||||
continue
|
||||
r = [x for col in ("corr_x", "corr_y") if (x := _derive(ms, col))]
|
||||
if not r:
|
||||
continue
|
||||
derive, n, a, b = max(r, key=lambda x: abs(x[0]))
|
||||
out.append({"start": iso(a), "end": iso(b), "kind": "derive", "label": "Slow drift",
|
||||
"text": f"{s} drifts slowly and steadily: {derive:+.2f} px in {n} days. Keep watching it.",
|
||||
"ignore": False, "sensors": [s]})
|
||||
return out
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
for e in detect(charger(sys.argv[1])):
|
||||
print(e["start"], "→", e["end"], e["sensors"][0], "|", e["text"])
|
||||
@@ -1,4 +1,7 @@
|
||||
"""Sauts brutaux du journal du matin : corr_x / corr_y (px) de chaque cible, cadence native de l'export « advanced ».
|
||||
"""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
|
||||
@@ -128,8 +131,9 @@ def _pics(t, v):
|
||||
and min(abs(v[i] - v[i - 1]), abs(v[i] - v[i + 1])) >= K_PIC * noise]
|
||||
|
||||
|
||||
def detect(mesures):
|
||||
"""{capteur: [mesure]} (donnees.charger) -> épisodes du journal, triés par début."""
|
||||
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():
|
||||
@@ -192,7 +196,7 @@ def _episode(g, total):
|
||||
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": "sauts", "label": "Target flipping",
|
||||
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:
|
||||
@@ -210,11 +214,73 @@ def _episode(g, total):
|
||||
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": "sauts", "label": label,
|
||||
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 ; 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é.
|
||||
HEURES = 20 # un jour compte s'il a au moins 20 heures mesurées (comme D-055)
|
||||
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)
|
||||
|
||||
|
||||
def _decile(vs, q):
|
||||
vs = sorted(vs)
|
||||
return vs[min(len(vs) - 1, int(q * len(vs)))]
|
||||
|
||||
|
||||
def _derive(ms, col):
|
||||
"""-> (dérive en px, jours, premier instant, dernier) ou None."""
|
||||
jours = {}
|
||||
for m in ms:
|
||||
if m[col] is not None:
|
||||
jours.setdefault(m["t"].date(), []).append(m)
|
||||
jours = {d: js for d, js in jours.items() if len({m["t"].hour for m in js}) >= HEURES}
|
||||
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 derive(mesures):
|
||||
out = []
|
||||
for s, ms in sorted(mesures.items()):
|
||||
if donnees.est_reference(ms):
|
||||
continue
|
||||
r = [x for col in ("corr_x", "corr_y") if (x := _derive(ms, col))]
|
||||
if not r:
|
||||
continue
|
||||
derive, n, a, b = max(r, key=lambda x: abs(x[0]))
|
||||
out.append({"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]})
|
||||
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"]),
|
||||
@@ -1,11 +1,11 @@
|
||||
"""Journal du matin : moments sans mesure (cadence de l'export « advanced » rompue).
|
||||
"""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/trous.py <dossier de station> (affiche les épisodes)
|
||||
Usage : python3 detectors/no_data.py <dossier de station> (affiche les épisodes)
|
||||
"""
|
||||
import os
|
||||
import statistics
|
||||
@@ -32,7 +32,7 @@ def detect(mesures, fin=None):
|
||||
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": "trous", "label": "No data",
|
||||
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]
|
||||
@@ -0,0 +1,25 @@
|
||||
"""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.
|
||||
Usage : python3 detectors/obstruction.py <dossier de station> (affiche les épisodes)
|
||||
"""
|
||||
import os
|
||||
import sys
|
||||
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "agent-tools"))
|
||||
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):
|
||||
return sorted((e for e in visibility.episodes(mesures) + target_issue.episodes(mesures) if e["kind"] == "Obstruction"),
|
||||
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"])
|
||||
@@ -1,4 +1,8 @@
|
||||
"""Journal du matin : cible rejetée la plupart du temps, jour après jour, quand les autres sont vues (cible dégradée).
|
||||
"""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).
|
||||
@@ -13,23 +17,25 @@ Méthode (seuils provisoires, Claude, 2026-10-27) :
|
||||
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 » (catégorie cible_masquee), un épisode par suite de
|
||||
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.
|
||||
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 (Target issue, D-074 ; E-011, FLORIDA : une cible définie sur le prisme d'une référence) : par jour UTC,
|
||||
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/degradee.py <dossier de station> (affiche les épisodes)
|
||||
Usage : python3 detectors/target_issue.py <dossier de station> (affiche les épisodes)
|
||||
"""
|
||||
import os
|
||||
import statistics
|
||||
import sys
|
||||
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "agent-tools"))
|
||||
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
|
||||
@@ -45,12 +51,13 @@ def rejete(m):
|
||||
|
||||
|
||||
def cadence(mesures):
|
||||
"""Écart médian entre deux instants de mesure, tous capteurs confondus, en heures (comme trous)."""
|
||||
"""É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 detect(mesures):
|
||||
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():
|
||||
@@ -89,7 +96,8 @@ def detect(mesures):
|
||||
bornes, label = [(r[0][0], r[-1][1])], "Degraded target"
|
||||
else: # par moments : un épisode par suite de mesures rejetées
|
||||
bornes, label = r, "Target obscured"
|
||||
out += [{"start": iso(a), "end": iso(b), "kind": "degradee", "label": label, "text": text, "ignore": True,
|
||||
out += [{"start": iso(a), "end": iso(b), "kind": "Target issue" if label == "Degraded target" else "Obstruction",
|
||||
"label": label, "text": text, "ignore": True,
|
||||
"sensors": [s]} for a, b in bornes]
|
||||
return sorted(out + colles(mesures, min_instants), key=lambda e: e["start"])
|
||||
|
||||
@@ -140,12 +148,18 @@ def colles(mesures, min_instants):
|
||||
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": "degradee", "label": "Target stuck",
|
||||
out.append({"start": iso(k[0][0]), "end": iso(k[-1][1]), "kind": "Target issue", "label": "Target stuck",
|
||||
"text": f"{s} barely moved while the other targets did ({len(k)} day{'s' if len(k) > 1 else ''}): it may be "
|
||||
"set on a reference prism.", "ignore": True, "sensors": [s]})
|
||||
return out
|
||||
|
||||
|
||||
|
||||
def detect(mesures):
|
||||
return sorted((e for e in episodes(mesures) + displacement.episodes(mesures) if e["kind"] == "Target issue"),
|
||||
key=lambda e: e["start"])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
for e in detect(charger(sys.argv[1])):
|
||||
print(e)
|
||||
@@ -1,5 +1,5 @@
|
||||
"""Journal du matin : effet périodique, la vague quotidienne des déplacements corrigés (dilatation le jour, contraction
|
||||
le soir : l'utilisateur, 2026-10-24 ; point 41 du plan).
|
||||
"""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).
|
||||
@@ -188,7 +188,7 @@ def _episodes(mesures, cols, nom, camera):
|
||||
for label, a, b in ((f"{nom} expansion", chaudes[0], pic), (f"{nom} contraction", pic, chaudes[-1] + 1)):
|
||||
if b > a:
|
||||
episodes.append({"start": iso(minuit + timedelta(hours=a)), "end": iso(minuit + timedelta(hours=b)),
|
||||
"kind": "thermique", "label": label, "text": "", "ignore": False, "sensors": capteurs})
|
||||
"kind": "Thermal displacement", "label": label, "text": "", "ignore": False, "sensors": capteurs})
|
||||
return episodes
|
||||
|
||||
|
||||
@@ -1,107 +0,0 @@
|
||||
"""Journal du matin : turbulence atmosphérique (bruit rapide sur les déplacements corrigés).
|
||||
|
||||
Méthode :
|
||||
1. Par capteur et par heure H, sur les mesures de [H − 1 h, H + 2 h) : agitation = médiane de |Δcorr_x| + |Δcorr_y|
|
||||
entre mesures successives (robuste aux sauts d'un seul pas), et médiane de l'error_value.
|
||||
2. Chacune est rapportée au calme du capteur : le quartile bas de ses valeurs horaires sur l'export (souvent la nuit).
|
||||
3. Heure turbulente : au moins la moitié des capteurs à ≥ 1,5 fois leur agitation calme, et error_value médiane
|
||||
des capteurs à ≥ 1,5 fois la calme (l'air chaud brouille les taches : 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 (c'est alors de la mauvaise visibilité, autre détecteur). Grisé si l'agitation médiane ≥ 2×.
|
||||
|
||||
Résultats (2026-10-23, seuils ci-dessous) :
|
||||
- WILDSTRUBEL (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.
|
||||
"""
|
||||
import os
|
||||
import statistics
|
||||
import sys
|
||||
from datetime import timedelta
|
||||
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "agent-tools"))
|
||||
from donnees import charger, iso # noqa: E402
|
||||
|
||||
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 %
|
||||
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 detect(mesures):
|
||||
H = heures(mesures)
|
||||
blocs = []
|
||||
for h in sorted(h for h, r in H.items() if _turbulente(r)):
|
||||
if blocs and h - blocs[-1][-1] <= 2 * HEURE:
|
||||
blocs[-1].append(h)
|
||||
else:
|
||||
blocs.append([h])
|
||||
episodes = []
|
||||
for b in blocs:
|
||||
debut, fin = b[0], b[-1] + HEURE
|
||||
dedans = [m for ms in mesures.values() for m in ms if debut <= m["t"] < fin]
|
||||
if fin - debut < DUREE_MIN or sum(m["corr_x"] is None for m in dedans) > REJET_MAX * len(dedans):
|
||||
continue
|
||||
par_capteur = {}
|
||||
for h in b:
|
||||
for s, (a, _) in H[h].items():
|
||||
par_capteur.setdefault(s, []).append(a)
|
||||
agit = {s: statistics.median(v) for s, v in par_capteur.items()}
|
||||
fort = statistics.median(agit.values())
|
||||
episodes.append({
|
||||
"start": iso(debut), "end": iso(fin), "kind": "turbulence",
|
||||
"label": "Heat shimmer",
|
||||
"text": f"Readings were about {fort:.1f}× noisier than in calm hours because of heat shimmer "
|
||||
"(warm air trembling in the line of sight); the small fast wiggles are not movement.",
|
||||
"ignore": fort >= FORT,
|
||||
"sensors": sorted(s for s, v in agit.items() if v >= RATIO),
|
||||
})
|
||||
return episodes
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
for e in detect(charger(sys.argv[1])):
|
||||
print(e["start"], "→", e["end"], e["label"], "(grisé)" if e["ignore"] else "",
|
||||
f"{len(e['sensors'])} capteurs |", e["text"])
|
||||
@@ -1,4 +1,7 @@
|
||||
"""Journal du matin : visibilité / taux d'erreur de reconnaissance (error_value), un épisode grisé par moment douteux.
|
||||
"""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)
|
||||
@@ -25,7 +28,7 @@ Méthode (seuils provisoires ci-dessous) :
|
||||
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.
|
||||
|
||||
Résultats (2026-10-23 ; vérité : events/INDEX.md) :
|
||||
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)
|
||||
@@ -97,8 +100,9 @@ def _grouper(points, ecart):
|
||||
|
||||
|
||||
def _episode(debut, fin, label, text, capteurs, level=None):
|
||||
e = {"start": iso(debut), "end": iso(fin), "kind": "visibilite", "label": label, "text": text,
|
||||
"ignore": True, "sensors": sorted(capteurs)}
|
||||
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
|
||||
|
||||
|
||||
@@ -113,7 +117,8 @@ def _niveaux(mesures, instants):
|
||||
for t in instants}
|
||||
|
||||
|
||||
def detect(mesures):
|
||||
def episodes(mesures):
|
||||
"""Tous les épisodes de l'error_value : Visibility (Poor visibility), Obstruction (Brief obstruction, Target obscured)."""
|
||||
ecart = ECART * _pas(mesures)
|
||||
refs = {s for s, v in mesures.items() if v[0]["pattern_type"] == "global_ref"}
|
||||
instants = sorted({m["t"] for v in mesures.values() for m in v})
|
||||
@@ -209,6 +214,104 @@ def _grouper_intervalles(intervalles, ecart):
|
||||
return out
|
||||
|
||||
|
||||
def detect(mesures):
|
||||
return [e for e in episodes(mesures) if e["kind"] == "Visibility"] + turbulence(mesures)
|
||||
|
||||
|
||||
# --- 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 (c'est alors de la mauvaise visibilité, autre détecteur). Grisé si l'agitation médiane ≥ 2×.
|
||||
#
|
||||
# Résultats (2026-10-23, seuils ci-dessous) :
|
||||
# - WILDSTRUBEL (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 %
|
||||
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])
|
||||
episodes = []
|
||||
for b in blocs:
|
||||
debut, fin = b[0], b[-1] + HEURE
|
||||
dedans = [m for ms in mesures.values() for m in ms if debut <= m["t"] < fin]
|
||||
if fin - debut < DUREE_MIN or sum(m["corr_x"] is None for m in dedans) > REJET_MAX * len(dedans):
|
||||
continue
|
||||
par_capteur = {}
|
||||
for h in b:
|
||||
for s, (a, _) in H[h].items():
|
||||
par_capteur.setdefault(s, []).append(a)
|
||||
agit = {s: statistics.median(v) for s, v in par_capteur.items()}
|
||||
fort = statistics.median(agit.values())
|
||||
episodes.append({
|
||||
"start": iso(debut), "end": iso(fin), "kind": "Visibility",
|
||||
"label": "Heat shimmer",
|
||||
"text": f"Readings were about {fort:.1f}× noisier than in calm hours because of heat shimmer "
|
||||
"(warm air trembling in the line of sight); the small fast wiggles are not movement.",
|
||||
"ignore": fort >= FORT,
|
||||
"sensors": sorted(s for s, v in agit.items() if v >= RATIO),
|
||||
})
|
||||
return episodes
|
||||
|
||||
if __name__ == "__main__":
|
||||
for e in detect(charger(sys.argv[1])):
|
||||
print(e["start"], "→", e["end"], e["label"], f"| {len(e['sensors'])} :", ",".join(e["sensors"][:8]), "|", e["text"])
|
||||
Reference in new issue
Block a user