194 lines
12 KiB
Python
194 lines
12 KiB
Python
"""Journal du matin : le détecteur de la famille Target issue (labeling/familles.md) : une cible constamment
|
|
problématique : rejetée la plupart du temps, jour après jour, quand les autres sont vues (cible dégradée), collée (en
|
|
fin de fichier), ou qui bascule (les sauts de displacement.py, « Target flipping »). Une cible rejetée moins d'une
|
|
semaine est cachée par moments (point 4) : episodes() la rend avec la famille Obstruction, que detect() laisse à
|
|
obstruction.py.
|
|
|
|
Le détecteur visibilite compare chaque capteur à son propre niveau habituel : une cible presque toujours rejetée lui
|
|
paraît normale (FLORIDA, octobre 2026 : Massif 2 et Sellette 6 rejetées la moitié des mesures ou plus, chaque jour).
|
|
Méthode (seuils provisoires, Claude, 2026-10-27) :
|
|
1. Instant calme pour un capteur : au plus CALME des autres capteurs rejetés (error_value > error_threshold) ; la météo et
|
|
la buée, qui touchent tout le monde, sont ainsi mises de côté.
|
|
2. Par jour UTC et par capteur, sur ses instants calmes (au moins MIN_HEURES heures d'instants à la cadence de la
|
|
station, écart médian entre deux instants de mesure ; sinon le jour ne compte pas) : jour dégradé si au moins PART
|
|
d'entre eux sont rejetés. Cadence (boucle /detector-learner NEBRASKA, lot 01) : 12 instants fixes, « 3 h à 15 min »,
|
|
ne comptaient aucun jour à une mesure toutes les 4 h ; REFCOLH22, rejetée sans cesse depuis sa perte, n'était pas vue.
|
|
3. Épisode : au moins MIN_JOURS jours dégradés de suite (un jour qui ne compte pas ne coupe pas la suite), de la première
|
|
mesure rejetée de ces jours à la dernière ; ignore = True : la courbe de la cible n'est pas fiable.
|
|
4. Gênée tout le temps ou par moments (frontière « Target issue ou Obstruction » de labeling/familles.md ; boucle
|
|
/detector-learner NEBRASKA, lot 01) : une suite d'au moins SEMAINE jours est une cible à problème, « Degraded target » ;
|
|
plus courte, une cible cachée par moments, « Target obscured » (famille Obstruction), un épisode par suite de
|
|
mesures rejetées (les heures où elle est vue n'en sont pas). BREITHORN : véhicules garés
|
|
devant COLI24 et POUI22, 2 à 5 jours ; NEBRASKA et MICHIGAN : une référence perdue, 25 jours ; JUNGFRAU : PM_G, 63.
|
|
Pour la cible à problème, la suite est reliée : au plus PONT jours non dégradés de suite ne la coupent pas, et elle
|
|
demande alors SEMAINE jours de son premier à son dernier jour dégradé, à PART de rejets sur tous ses jours (« des rejets
|
|
propres à la cible presque chaque jour de la plage ») ; les Target obscured qu'elle couvre n'existent plus
|
|
(/detector-learner Obstruction, modification 1, S1 : FLORIDA Sellette 6 et Massif 2, SNCF01 F4.3 et F4.4, NORDEND
|
|
CTR01, NIEDERHORN e01, découpées en Target obscured par un jour sous PART ; BREITHORN, véhicules garés, inchangé).
|
|
La cible à problème juge la régularité plutôt que la part du jour : un jour y est dégradé dès PART_SEMAINE (le quart)
|
|
de ses instants calmes rejetés, et PONT vaut un jour ; la cible cachée par moments garde PART. Une cible rejetée chaque
|
|
jour aux mêmes heures, le jour seulement ou la nuit seulement, reste sous la moitié et n'était pas vue
|
|
(/detector-learner Target issue, modification 1, S1 : WILDSTRUBEL R3, de 04:00 à 16:00 chaque jour, vue seulement les
|
|
jours sans mesure de nuit ; NORDEND PR04 et CTR01, NIEDERHORN PWD_IMP_B08_024_C09 et e01, SNCF01 F4.3, plus tôt).
|
|
Sur les jeux de data/ (2026-10-27) : FLORIDA Massif 2 21 → 25.10, Sellette 6 16 → 17.10 et 19 → 20.10 ; NIEDERHORN e03 à
|
|
e12 toute la période (jamais vues) ; NORDEND CTR01 plusieurs suites en juin-juillet (déjà « souvent rejetée ») ; rien
|
|
sur LENZSPITZE ; CLARIDEN PR-283 du 12 au 16.09. La cause (salissure, végétation, réglage) ne se lit que sur les images.
|
|
Cible collée (E-011, FLORIDA : une cible définie sur le prisme d'une référence) : par jour UTC,
|
|
le bruit de ses corr_x et corr_y (médiane des écarts d'une mesure à la suivante) à moins de COLLE fois le bruit médian
|
|
des autres cibles, sur les deux axes, un jour suffit (une journée sans bruit n'arrive pas par accident) ; label « Target stuck ». Sur E-011 : C2 à
|
|
7e-5 px et C3 à 2e-4 contre 0,013 pour les autres ; FLORIDA : les mêmes, Pont Ernen et Sellette 3.
|
|
Usage : python3 detectors/target_issue.py <dossier de station> (affiche les épisodes)
|
|
"""
|
|
import os
|
|
import statistics
|
|
import sys
|
|
|
|
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) # donnees.py, à côté
|
|
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
|
import displacement # noqa: E402
|
|
from donnees import charger, est_reference, iso # noqa: E402
|
|
|
|
CALME = 0.25 # part des autres capteurs rejetés au plus, pour un instant calme
|
|
PART = 0.5 # la moitié des instants calmes rejetés : « la plupart du temps »
|
|
PART_SEMAINE = 0.25 # le quart des instants calmes rejetés, chaque jour d'une semaine ou plus : une cible à problème,
|
|
# même rejetée seulement le jour ou seulement la nuit (/detector-learner Target issue, modification 1, S1)
|
|
MIN_HEURES = 3 # heures d'instants calmes, à la cadence de la station : en dessous, le jour ne compte pas
|
|
MIN_JOURS = 2 # un jour seul est trop souvent un accident (NORDEND : jours isolés sur 16 capteurs)
|
|
PONT = 1 # provisoire : jour non dégradé qui ne coupe pas une suite de jours dégradés (4) ; à 2, les véhicules garés
|
|
# de BREITHORN (deux jours, puis rien deux jours, puis un) feraient une semaine au quart
|
|
SEMAINE = 7 # provisoire : jours dégradés de suite pour une cible à problème ; en dessous, une cible cachée par moments
|
|
COLLE = 0.05 # provisoire : bruit d'une cible collée face aux autres (E-011 : 0,006 ; NORDEND, E-001 : 0,7 au plus bas)
|
|
|
|
|
|
def rejete(m):
|
|
return m["error_value"] is not None and m["error_threshold"] is not None and m["error_value"] > m["error_threshold"]
|
|
|
|
|
|
def cadence(mesures):
|
|
"""Écart médian entre deux instants de mesure, tous capteurs confondus, en heures (comme no_data)."""
|
|
ts = sorted({m["t"].replace(second=0, microsecond=0) for ms in mesures.values() for m in ms})
|
|
return statistics.median((b - a).total_seconds() for a, b in zip(ts, ts[1:])) / 3600 if len(ts) > 1 else 1
|
|
|
|
|
|
def episodes(mesures):
|
|
"""Cibles rejetées jour après jour : Target issue (une semaine ou plus) et Obstruction (moins), puis les collées."""
|
|
min_instants = MIN_HEURES / cadence(mesures)
|
|
par_t = {}
|
|
for s, ms in mesures.items():
|
|
for m in ms:
|
|
par_t.setdefault(m["t"], {})[s] = rejete(m)
|
|
jours = {} # capteur -> jour -> [rejetés, calmes, première mesure, dernière]
|
|
for t in sorted(par_t):
|
|
d = par_t[t]
|
|
for s, r in d.items():
|
|
autres = [v for k, v in d.items() if k != s]
|
|
c = jours.setdefault(s, {}).setdefault(t.date(), [0, 0, t, t])
|
|
c[3] = t
|
|
if autres and sum(autres) / len(autres) <= CALME:
|
|
c[0] += r
|
|
c[1] += 1
|
|
out = []
|
|
for s, js in sorted(jours.items()):
|
|
cache = [] # suites reliées d'au moins SEMAINE jours, à part de rejets PART_SEMAINE : une cible à problème
|
|
for su in _suites(js, min_instants, PONT, PART_SEMAINE):
|
|
part = sum(c[0] for c in su) / sum(c[1] for c in su)
|
|
if len(su) < SEMAINE or part < PART_SEMAINE:
|
|
continue
|
|
n = sum(c[0] / c[1] >= PART_SEMAINE for c in su)
|
|
r = _rejets([m for m in mesures[s] if su[0][2] <= m["t"] <= su[-1][3]])
|
|
cache.append((su[0][2], su[-1][3]))
|
|
out.append({"start": iso(r[0][0]), "end": iso(r[-1][1]), "kind": "Target issue", "label": "Degraded target",
|
|
"text": f"{s} was rejected in {round(100 * part)} % of the measurements when the other targets were "
|
|
f"seen, on {n} of {len(su)} days.", "ignore": True, "sensors": [s]})
|
|
for su in _suites(js, min_instants, 0, PART): # par moments : un épisode par suite de mesures rejetées
|
|
if len(su) < MIN_JOURS or any(a <= su[0][2] <= b for a, b in cache):
|
|
continue
|
|
part = round(100 * sum(c[0] for c in su) / sum(c[1] for c in su))
|
|
text = f"{s} was rejected in {part} % of the measurements when the other targets were seen, {len(su)} days in a row."
|
|
out += [{"start": iso(a), "end": iso(b), "kind": "Obstruction", "label": "Target obscured", "text": text,
|
|
"ignore": True, "sensors": [s]}
|
|
for a, b in _rejets([m for m in mesures[s] if su[0][2] <= m["t"] <= su[-1][3]])]
|
|
return sorted(out + colles(mesures, min_instants), key=lambda e: e["start"])
|
|
|
|
|
|
def _suites(js, min_instants, pont, part):
|
|
"""{jour: [rejetés, calmes, première, dernière]} -> suites de jours dégradés ; au plus pont jours non dégradés de suite
|
|
entre deux jours dégradés ne coupent pas la suite (ils en sont) ; un jour qui ne compte pas ne la coupe pas."""
|
|
suites, cur, creux = [], [], []
|
|
for j in sorted(js):
|
|
rej, calmes = js[j][:2]
|
|
if calmes < min_instants:
|
|
continue
|
|
if rej / calmes >= part:
|
|
cur += creux + [js[j]]
|
|
creux = []
|
|
elif cur:
|
|
creux.append(js[j])
|
|
if len(creux) > pont:
|
|
suites.append(cur)
|
|
cur, creux = [], []
|
|
return suites + ([cur] if cur else [])
|
|
|
|
|
|
def _rejets(ms):
|
|
"""Mesures d'un capteur -> [(début, fin)] de ses suites de mesures rejetées."""
|
|
out, cur = [], []
|
|
for m in ms + [None]:
|
|
if m and rejete(m):
|
|
cur.append(m["t"])
|
|
elif cur:
|
|
out.append((cur[0], cur[-1]))
|
|
cur = []
|
|
return out
|
|
|
|
|
|
def _bruit(v):
|
|
return statistics.median(abs(y - x) for x, y in zip(v, v[1:])) if len(v) > 2 else None
|
|
|
|
|
|
def colles(mesures, min_instants):
|
|
"""Cibles dont corr_x et corr_y ne bougent presque pas, jour après jour, quand les autres bougent."""
|
|
jours = {} # jour -> cible -> (bruit x, bruit y, première mesure, dernière)
|
|
for s, ms in mesures.items():
|
|
if est_reference(ms):
|
|
continue
|
|
par_j = {}
|
|
for m in ms:
|
|
par_j.setdefault(m["t"].date(), []).append(m)
|
|
for d, js in par_j.items():
|
|
b = [_bruit([m[c] for m in js if m[c] is not None]) for c in ("corr_x", "corr_y")]
|
|
if None not in b and len(js) >= min_instants:
|
|
jours.setdefault(d, {})[s] = (*b, js[0]["t"], js[-1]["t"])
|
|
suites = {} # cible -> [[jours collés de suite]]
|
|
for d in sorted(jours):
|
|
cs = jours[d]
|
|
for s, (bx, by, a, b) in cs.items():
|
|
autres = [v for k, (x, y, *_) in cs.items() if k != s for v in (x, y)]
|
|
if len(autres) < 4:
|
|
continue
|
|
ref = statistics.median(autres)
|
|
su = suites.setdefault(s, [[]])
|
|
if ref and max(bx, by) <= COLLE * ref:
|
|
su[-1].append((a, b))
|
|
elif su[-1]:
|
|
su.append([])
|
|
out = []
|
|
for s, su in sorted(suites.items()):
|
|
for k in su:
|
|
if k:
|
|
out.append({"start": iso(k[0][0]), "end": iso(k[-1][1]), "kind": "Target issue", "label": "Target stuck",
|
|
"text": f"{s} barely moved while the other targets did ({len(k)} day{'s' if len(k) > 1 else ''}): it may be "
|
|
"set on a reference prism.", "ignore": True, "sensors": [s]})
|
|
return out
|
|
|
|
|
|
|
|
def detect(mesures):
|
|
return sorted((e for e in episodes(mesures) + displacement.episodes(mesures) if e["kind"] == "Target issue"),
|
|
key=lambda e: e["start"])
|
|
|
|
|
|
if __name__ == "__main__":
|
|
for e in detect(charger(sys.argv[1])):
|
|
print(e)
|