Files
aimsight-labeling/labeling.py
T

370 lines
20 KiB
Python
Raw Normal View History

"""L'outil d'étiquetage de l'expert (D-098, point 68 du plan du journal du matin) : se repérer dans le temps et écrire ce qu'on
voit, en langage naturel, sans catégorie ; les données se consultent sur le monitoring. En haut, le data loader de la page
Status ; un menu déroulant, un plot à la fois, comme le menu Advanced d'Explore, plus les métriques système numériques de
metrics/ (« System: … », sans les identifiants) ; dessous, une barre de temps aux mêmes abscisses, qui suit le zoom : y glisser sélectionne une plage, puis du texte et Add. Add écrit aussitôt une ligne dans
labeling/<STATION>.jsonl : {"debut": "2026-10-08T01:00Z", "fin": "2026-10-08T02:45Z", "description": "…"}, en UTC, les noms
de champs de l'analyste (etiquettes.json). Les zones étiquetées sont grisées sur tous les plots ; sur la barre, une barre
chacune, son texte au survol, celles qui se chevauchent l'une sous l'autre. Un clic sur l'une l'affiche dessous, et Save y
enregistre son nouveau texte ; ses bornes se corrigent, et elle se retire, dans ce fichier, puis recharger la page. Son serveur
local (http://127.0.0.1:8767, lancé en tâche de fond) sert out/ et data/, plus /analyse (ce script lancé à chaque fois, comme
le data loader) et /labels (lire, ajouter, modifier) ; un changement de son code demande de l'arrêter (run.md).
Usage : python3 labeling/labeling.py [<dossier de station> [--du AAAA-MM-JJ] [--au AAAA-MM-JJ]]
(sans dossier : le data loader seul ; --au exclu ; sans dates, toute la période du dossier ; page :
out/labeling_<STATION>_<du>_<au>.html, ouverte)
"""
import argparse
import glob
import html
import http.server
import json
import os
import re
import sys
from datetime import datetime
from pathlib import Path
from urllib.parse import parse_qs, urlsplit
ICI = Path(__file__).resolve().parent
sys.path[:0] = [str(ICI.parent / "detectors-view"), str(ICI.parent / "detectors-view" / "data-loader")]
import chargeur # noqa: E402 (son formulaire, son serveur ; bascule seule sur .venv si plotly manque)
import detecteurs # noqa: E402 (les couleurs et les références de la page Status)
from common.stations import load_csv, parse_name # noqa: E402
from detecteurs import ROOT, donnees # noqa: E402
from plotly.offline import get_plotlyjs_version # noqa: E402
PORT = 8767 # ni celui de common.page (8765), ni celui du data loader (8766)
# Le menu Advanced d'Explore (select_graph, Dashboard/layouts/ExploreLayout.py de l'application de référence), dans son ordre
PLOTS = (("error_value", "Error value"), ("x", "X [px]"), ("y", "Y [px]"),
("relative_x", "Relative Horizontal Shift"), ("relative_y", "Relative Vertical Shift"),
("corr_x", "Relative Corrected Horizontal Shift"), ("corr_y", "Relative Corrected Vertical Shift"),
("reproj_err", "References (reproj. error)"))
CAMERA = "Camera movement"
# Pas de copie des identifiants (CLAUDE.md, « data/ ») : ces fichiers ne sont pas lus ; SIM_CCID a souvent l'air d'un nombre.
IDENTIFIANT = re.compile(r"SIM_CCID$|ip(_|$)")
FORMAT = "%Y-%m-%dT%H:%MZ"
# Une figure Plotly n'a qu'un mode de glissement : le plot zoome, la barre, figure à part, sélectionne. Elle reprend à chaque
# changement du plot sa plage et ses marges, la légende pouvant les élargir : c'est ce qui garde les abscisses alignées.
PAGE_JS = """
const GRIS = '#6b6b66', BLEU = '#2a78d6', VOIE = 22; // VOIE : px par rangée d'étiquettes
const fig = document.getElementById('fig'), barre = document.getElementById('barre'), menu = document.getElementById('plot');
const texte = document.getElementById('texte'), add = document.getElementById('add'), plage = document.getElementById('plage');
const edition = document.getElementById('edition'), editPlage = document.getElementById('edit-plage'), editTexte = document.getElementById('edit-texte');
const save = document.getElementById('save'), note = document.getElementById('edit-note');
const AIDE = plage.textContent;
// choix : la plage sélectionnée, [debut, fin] au format des étiquettes ; tries : les étiquettes dans l'ordre de la barre ;
// ouverte : celle affichée sous la barre
let labels = [], choix = null, tries = [], ouverte = null;
const lisible = s => s.slice(0, 16).replace('T', ' ');
const marge = () => ({l: 60, r: 20, t: 10, b: 30});
function zones() {
const z = (a, b, couleur, o) => ({type: 'rect', xref: 'x', yref: 'paper', x0: lisible(a), x1: lisible(b), y0: 0, y1: 1,
fillcolor: couleur, opacity: o, line: {width: 0}, layer: 'below'});
return labels.map(l => z(l.debut, l.fin, GRIS, 0.2)).concat(choix ? [z(choix[0], choix[1], BLEU, 0.25)] : []);
}
function aligne() {
const f = fig._fullLayout;
if (!barre._fullLayout) return; // au chargement, la barre se dessine juste après le plot
return Plotly.relayout(barre, {'xaxis.range': f.xaxis.range.slice(), 'margin.l': f._size.l, 'margin.r': f._size.r});
}
function dessineFig() {
const p = PLOTS[menu.value];
// uirevision : le zoom et les capteurs cachés restent d'un plot à l'autre ; l'ordonnée, propre à chaque plot, se recale
// uid sans espace ni parenthèse : Plotly s'en sert comme d'un sélecteur CSS
return Plotly.react(fig, p.traces.map(t => ({type: 'scatter', mode: t.mode || 'lines', marker: {size: 4}, x: T[t.t], y: t.y, name: t.name, uid: t.name.replace(/\\W/g, '_'),
line: t.line, hovertemplate: `${t.name}: %{y}<extra></extra>`})),
{height: 460, hovermode: 'closest', plot_bgcolor: 'white', margin: marge(), legend: {x: 1.01, y: 1}, uirevision: 1, shapes: zones(),
xaxis: {type: 'date', range: [lisible(A), lisible(B)], gridcolor: '#e6e6e2'},
yaxis: {title: {text: p.titre}, uirevision: p.titre, gridcolor: '#eeeeea', zeroline: false}},
{responsive: true, doubleClick: 'reset'}).then(aligne);
}
function dessineBarre() {
tries = [...labels].sort((a, b) => a.debut < b.debut ? -1 : 1);
const voies = [], voie = tries.map(l => { // la première rangée libre, sinon une nouvelle, comme les status
const r = voies.findIndex(f => f <= l.debut), i = r < 0 ? voies.length : r;
voies[i] = l.fin;
return i;
});
const n = Math.max(1, voies.length), f = fig._fullLayout;
return Plotly.react(barre, [{type: 'bar', orientation: 'h', y: voie, base: tries.map(l => lisible(l.debut)),
x: tries.map(l => Date.parse(l.fin) - Date.parse(l.debut)), width: 0.85, marker: {color: GRIS}, text: tries.map(l => l.description),
textposition: 'inside', insidetextanchor: 'start', textangle: 0, unselected: {marker: {opacity: 1}}, // sinon une sélection les pâlit
hoverinfo: 'text', hovertext: tries.map(l => `${lisible(l.debut)} → ${lisible(l.fin)} UTC<br>${l.description.replace(/\\n/g, '<br>')}<br><i>click: read, edit</i>`)}],
{height: 40 + VOIE * n, dragmode: 'select', selectdirection: 'h', hovermode: 'closest', plot_bgcolor: '#f2f2ef', showlegend: false,
margin: {...marge(), l: f._size.l, r: f._size.r}, uniformtext: {minsize: 9, mode: 'hide'},
xaxis: {type: 'date', range: f.xaxis.range.slice(), showgrid: false},
yaxis: {range: [n - 0.5, -0.5], fixedrange: true, showticklabels: false, showgrid: false, zeroline: false},
newselection: {line: {color: BLEU, width: 1}}, activeselection: {fillcolor: BLEU, opacity: 0.25}},
{responsive: true, displayModeBar: false, doubleClick: false});
}
function maj() {
plage.textContent = choix ? `${lisible(choix[0])} → ${lisible(choix[1])} UTC` : AIDE;
add.disabled = !(choix && choix[0] < choix[1] && texte.value.trim());
}
function choisit(c) {
choix = c;
maj();
return Plotly.relayout(fig, {shapes: zones()});
}
const modifiee = () => ouverte && editTexte.value.trim() !== ouverte.description;
function majEdition(message = '') {
save.disabled = !modifiee() || !editTexte.value.trim();
note.textContent = message;
}
function ouvre(l) { // l : l'étiquette à afficher, null pour fermer ; un texte modifié, non enregistré, ne se perd pas sans le dire
if (modifiee() && !confirm('Discard your changes to this label?')) return;
ouverte = l;
edition.hidden = !l;
if (!l) return;
editPlage.textContent = `${lisible(l.debut)} → ${lisible(l.fin)} UTC`;
editTexte.value = l.description;
majEdition();
edition.scrollIntoView({block: 'nearest'});
}
editTexte.oninput = () => majEdition();
document.getElementById('fermer').onclick = () => ouvre(null);
save.onclick = async () => {
save.disabled = true;
const corps = {station: STATION, avant: ouverte, description: editTexte.value.trim()};
const r = await fetch('/labels', {method: 'PUT', body: JSON.stringify(corps)}).catch(e => e);
if (!r.ok) { // rien n'est perdu : le texte reste dans la fenêtre
majEdition();
return alert('Not saved: ' + (r.statusText || r.message));
}
ouverte.description = (await r.json()).description;
editTexte.value = ouverte.description;
await dessineBarre();
majEdition('Saved');
};
menu.onchange = dessineFig;
texte.oninput = maj;
add.onclick = async () => {
add.disabled = true;
const corps = {station: STATION, debut: choix[0], fin: choix[1], description: texte.value.trim()};
const r = await fetch('/labels', {method: 'POST', body: JSON.stringify(corps)}).catch(e => e);
if (!r.ok) { // rien n'est perdu : le texte et la plage restent dans la page
maj();
return alert('Not saved: ' + (r.statusText || r.message));
}
labels.push(await r.json());
texte.value = '';
await dessineBarre();
await Plotly.relayout(barre, {selections: []});
await choisit(null);
};
dessineFig().then(dessineBarre).then(() => {
fig.on('plotly_relayout', aligne);
barre.on('plotly_selected', ev => {
const r = ev && ev.range && ev.range.x;
if (r) choisit(r.map(v => String(v).slice(0, 16).replace(' ', 'T') + 'Z'));
});
barre.on('plotly_deselect', () => choisit(null));
barre.on('plotly_click', ev => ouvre(tries[ev.points[0].pointIndex]));
// Lues à chaque chargement, pas écrites dans la page : recharger montre toujours le fichier.
fetch('/labels?station=' + encodeURIComponent(STATION))
.then(r => r.ok ? r.json() : Promise.reject(new Error(r.statusText)))
.then(l => {
labels = l.filter(x => x.debut < B && x.fin > A);
return dessineBarre().then(() => Plotly.relayout(fig, {shapes: zones()}));
})
.catch(e => alert('Labels not read: ' + e.message));
});
"""
def metriques(dossier, a, b):
"""Les métriques système numériques de metrics/ sur [a, b) -> {nom: {t: valeur ou None}}, sans celles qui n'ont aucune valeur."""
series = {}
for p in sorted(glob.glob(os.path.join(dossier, "metrics", "*.csv"))):
n = parse_name(p)
if n and not IDENTIFIANT.match(n[1]):
try:
series.setdefault(n[1], {}).update(load_csv(p)) # à heure égale, le dernier fichier, comme load_stations
except ValueError: # une métrique texte (link, mode…) : pas de courbe
pass
dans = {m: {t: v if isinstance(v, float) else None for t, v in sorted(s.items()) if a <= t < b} for m, s in series.items()}
return {m: s for m, s in dans.items() if any(v is not None for v in s.values())}
def plots(mesures, poses, systeme, a, b):
"""-> (T, [plot]) : T, les heures de chaque série, une fois, elles reviennent dans chaque plot (clé : le capteur, "" pour la
caméra, « system: » et son nom pour une métrique) ; plot : titre et traces (name, t : sa clé dans T, y, line ; mode pour
les métriques, horaires : une valeur seule entre deux trous ne se verrait pas sans marqueur), sans les plots ni les capteurs vides."""
heure = lambda t: t.strftime("%Y-%m-%d %H:%M") # noqa: E731 (UTC, sans fuseau : comme l'affiche Plotly)
valeurs = lambda s, c: [None if m[c] is None else round(m[c], 5) for m in s] # noqa: E731
dans = {s: [m for m in mesures[s] if a <= m["t"] < b] for s in sorted(mesures)}
refs = detecteurs.references(mesures, a, b)
out = []
for col, titre in PLOTS:
series = {s: valeurs(ms, col) for s, ms in dans.items()}
traces = [{"name": s + " (ref.)" * (s in refs), "t": s, "y": y,
"line": {"width": 1.2, "color": detecteurs.COULEURS[i % len(detecteurs.COULEURS)], "dash": "dot" if s in refs else "solid"}}
for i, (s, y) in enumerate(series.items()) if any(v is not None for v in y)]
if traces:
out.append({"titre": titre, "traces": traces})
if poses:
out.append({"titre": CAMERA + " (deg)", "traces": [{"name": c, "t": "", "y": valeurs(poses, c), "line": {"width": 1.2, "color": couleur}}
for c, couleur in detecteurs.POSE]})
T = {"": [heure(p["t"]) for p in poses], **{s: [heure(m["t"]) for m in ms] for s, ms in dans.items()}}
for nom in sorted(systeme, key=str.lower):
s = systeme[nom]
T["system:" + nom] = [heure(t) for t in s]
out.append({"titre": "System: " + nom, "traces": [{"name": nom, "t": "system:" + nom, "mode": "lines+markers",
"y": [None if v is None else round(v, 5) for v in s.values()],
"line": {"width": 1.2, "color": detecteurs.COULEURS[0]}}]})
return T, out
def page(dossier, du=None, au=None):
mesures = donnees.charger(dossier)
if not mesures:
raise SystemExit(f"Aucun export « advanced » dans {dossier}.")
tous = sorted({m["t"] for ms in mesures.values() for m in ms})
a = donnees.instant(du) if du else tous[0]
b = donnees.instant(au) if au else tous[-1] + (tous[-1] - tous[-2])
T, liste = plots(mesures, [p for p in donnees.charger_camera(dossier) if a <= p["t"] < b], metriques(dossier, a, b), a, b)
if not liste:
raise SystemExit(f"Aucune mesure dans {dossier} du {du} au {au}.")
station = os.path.basename(os.path.normpath(dossier))
nom = f"{station}_{donnees.iso(a)[:10]}_{donnees.iso(b)[:10]}"
chemin = ROOT / "out" / f"labeling_{nom}.html"
chemin.parent.mkdir(exist_ok=True)
js = lambda v: json.dumps(v, separators=(",", ":")).replace("</", "<\\/") # noqa: E731
options = "".join(f'<option value="{i}">{html.escape(p["titre"])}</option>' for i, p in enumerate(liste))
chemin.write_text(f"""<!doctype html><html lang="en"><head><meta charset="utf-8"><title>Labeling {html.escape(nom)}</title>
<script src="https://cdn.plot.ly/plotly-{get_plotlyjs_version()}.min.js"></script>
<style>body{{font-family:system-ui,sans-serif;margin:16px;background:#fff;color:#1a1a19}}
textarea{{width:100%;box-sizing:border-box;font:inherit;padding:6px}} select,button{{font:inherit}} #plage{{margin:8px 0}}
#edition{{border:1px solid #d5d5d0;border-radius:6px;padding:8px 12px;margin:8px 0;background:#f7f7f4}} #edition textarea{{margin-top:6px}} #edition p{{margin:6px 0 0}}</style></head><body>
<h2>Labeling, {html.escape(station)}</h2>
{chargeur.formulaire(station, du or "", au or "")}
<label>Plot <select id="plot">{options}</select></label>
<div id="fig"></div>
<div id="barre"></div>
<section id="edition" hidden><b id="edit-plage"></b>
<textarea id="edit-texte" rows="3"></textarea>
<p><button id="save" disabled>Save</button> <button id="fermer">Close</button> <span id="edit-note"></span></p></section>
<p id="plage">Drag on the bar above to select a time range.</p>
<textarea id="texte" rows="3" placeholder="What do we see in this range?"></textarea>
<p><button id="add" disabled>Add</button></p>
<script>const T = {js(T)}, PLOTS = {js(liste)}, STATION = {js(station)}, A = {js(donnees.iso(a))}, B = {js(donnees.iso(b))};
{PAGE_JS}</script>
</body></html>""", encoding="utf-8")
return chemin
def fichier(station):
return ICI / f"{station}.jsonl"
def lire(station):
f = fichier(station)
# split et non splitlines : celui-ci couperait aussi sur les séparateurs Unicode que le texte peut contenir
return [json.loads(l) for l in f.read_text(encoding="utf-8").split("\n") if l.strip()] if f.exists() else []
def ajouter(corps):
"""Le corps d'un Add (station, debut, fin, description) -> l'étiquette écrite ; ValueError s'il n'est pas bon."""
station, debut, fin, description = corps["station"], corps["debut"], corps["fin"], corps["description"].strip()
if station not in chargeur.stations(): # le nom devient un chemin : une station de data/, rien d'autre
raise ValueError("unknown station")
if not description or datetime.strptime(debut, FORMAT) >= datetime.strptime(fin, FORMAT):
raise ValueError("empty text or range")
label = {"debut": debut, "fin": fin, "description": description}
f = fichier(station)
# Une ligne retirée à la main peut laisser le fichier sans fin de ligne : la suivante se collerait à elle.
avant = f.read_bytes() if f.exists() else b""
with open(f, "ab") as sortie:
sortie.write(b"\n" * bool(avant and not avant.endswith(b"\n")) + json.dumps(label, ensure_ascii=False).encode() + b"\n")
return label
def modifier(corps):
"""Le corps d'un Save (station, avant : l'étiquette telle que la page l'a lue, description : le nouveau texte) -> l'étiquette
écrite ; ValueError s'il n'est pas bon. Retrouvée par son contenu, pas par son rang : le fichier a pu changer à la main
depuis le chargement de la page. Les autres lignes restent telles quelles."""
station, avant, description = corps["station"], corps["avant"], corps["description"].strip()
if station not in chargeur.stations():
raise ValueError("unknown station")
if not description:
raise ValueError("empty text")
f = fichier(station)
lignes = f.read_text(encoding="utf-8").split("\n") if f.exists() else []
for i, ligne in enumerate(lignes):
if ligne.strip() and json.loads(ligne) == avant:
label = {**avant, "description": description}
label.pop("revue", None) # texte changé : à revoir par le label-reviewer (D-101)
lignes[i] = json.dumps(label, ensure_ascii=False)
provisoire = f.with_name(f.name + ".tmp") # écrit à côté puis remplacé : une coupure ne peut pas abîmer le fichier
provisoire.write_text("\n".join(lignes), encoding="utf-8")
os.replace(provisoire, f)
return label
raise ValueError("this label is no longer in the file, reload the page")
class Serveur(chargeur.Chargeur):
SCRIPT = __file__
def repond(self, valeur):
corps = json.dumps(valeur, ensure_ascii=False).encode()
self.send_response(200)
self.send_header("Content-Type", "application/json; charset=utf-8")
self.send_header("Content-Length", str(len(corps)))
self.end_headers()
self.wfile.write(corps)
def do_GET(self):
url = urlsplit(self.path)
if url.path != "/labels":
return super().do_GET()
station = parse_qs(url.query).get("station", [""])[0]
if station not in chargeur.stations():
return self.send_error(400, "Unknown station")
try:
self.repond(lire(station))
except ValueError as e: # une ligne abîmée à la main : le dire, sans toucher au fichier
self.send_error(500, f"labeling/{station}.jsonl unreadable: {e}")
def ecrit(self, action):
if self.path != "/labels":
return self.send_error(404)
# Ce fichier sera lu par l'analyste : une autre page du navigateur ne doit pas pouvoir y écrire.
if self.headers.get("Origin") not in (None, f"http://127.0.0.1:{PORT}"):
return self.send_error(403)
try:
self.repond(action(json.loads(self.rfile.read(int(self.headers["Content-Length"])))))
except (KeyError, TypeError, AttributeError, ValueError) as e:
self.send_error(400, str(e))
def do_POST(self):
self.ecrit(ajouter)
def do_PUT(self):
self.ecrit(modifier)
if __name__ == "__main__":
if sys.argv[1:] == ["serve"]:
http.server.ThreadingHTTPServer(("127.0.0.1", PORT), Serveur).serve_forever()
p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
p.add_argument("dossier", nargs="?", help="sans dossier : le data loader seul")
p.add_argument("--du")
p.add_argument("--au")
p.add_argument("--sans-ouvrir", action="store_true", help="écrit la page sans l'ouvrir")
o = p.parse_args()
chemin = page(o.dossier, o.du, o.au) if o.dossier else chargeur.accueil("Labeling", "labeling-loader")
print(chemin)
if not o.sans_ouvrir:
chargeur.open_served(chemin, PORT, __file__)