Files
Support-Agent/detectors/thermal_displacement.py
2026-11-05 13:18:24 +01:00

314 lines
19 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""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.join(os.path.dirname(os.path.abspath(__file__)), "..", "agent-tools"))
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)}")