Files
aimsight-labeling/precedents.py
T

152 lines
7.2 KiB
Python

"""Les précédents : les étiquettes de auto/ les plus proches d'un texte, par le sens (RAG). manual/ est à l'utilisateur
seul : aucun processus ne s'en sert.
L'analyste décrit ce qu'il voit sur sa plage ; l'outil rend les étiquettes déjà posées qui en parlent le plus, toutes
stations, avec leur provenance (relue, non relue) : à lui de juger si elles valent pour son cas.
python3 labeling/precedents.py "les cibles sautent ensemble quand une référence est rejetée par intermittence"
python3 labeling/precedents.py "<texte>" --exclure NORDEND 2026-11-04T21:12Z 2026-11-07T14:12Z --famille Obstruction --k 5
python3 labeling/precedents.py --index # met l'index à jour seulement
python3 labeling/precedents.py --check # contrôle de la logique, sans Ollama
L'index (.index/, hors de git) garde le vecteur de chaque texte : à chaque appel, seules les étiquettes nouvelles ou
modifiées passent par le modèle. Modèle : bge-m3 servi par Ollama, le conteneur ollama-bge-m3 (`docker start
ollama-bge-m3`) ; OLLAMA_URL et RAG_MODELE pour en changer. Bibliothèque standard seulement.
"""
import argparse
import glob
import hashlib
import json
import math
import os
import sys
import urllib.request
from datetime import datetime
from pathlib import Path
ICI = Path(__file__).resolve().parent
URL = os.environ.get("OLLAMA_URL", "http://10.0.2.140:11435") # le port publié par le conteneur ollama-bge-m3
MODELE = os.environ.get("RAG_MODELE", "bge-m3:567m")
INDEX = ICI / ".index" / f"{MODELE.replace(':', '_')}.json"
LOT = 32 # textes par appel au modèle
def etiquettes(racine=ICI):
"""Toutes les étiquettes de auto/, avec leur station et leur provenance ; jamais celles de manual/."""
for f in sorted(glob.glob(str(racine / "auto" / "*.jsonl"))):
station = Path(f).stem
for ligne in open(f, encoding="utf-8"):
if ligne.strip():
e = json.loads(ligne)
e["station"], e["provenance"] = station, provenance(e)
yield e
def provenance(e):
if e.get("revue"):
return f"auto, relue le {e['revue']}"
return "auto, non relue" + (f" (analyse {e['analyse']})" if e.get("analyse") else "")
def texte(e):
return f"{e.get('categorie', '')}. {e.get('description', '')}"
def cle(t):
return hashlib.sha1(t.encode("utf-8")).hexdigest()
def instant(s):
return datetime.fromisoformat(s.replace("Z", "+00:00"))
def recouvre(e, station, debut, fin):
"""L'étiquette touche-t-elle la plage exclue (même station, intervalles qui se chevauchent) ?"""
return e["station"] == station and instant(e["debut"]) <= instant(fin) and instant(e["fin"]) >= instant(debut)
def norme(v):
n = math.sqrt(sum(x * x for x in v)) or 1.0
return [round(x / n, 5) for x in v]
def vectoriser(textes):
corps = json.dumps({"model": MODELE, "input": textes}).encode()
req = urllib.request.Request(f"{URL}/api/embed", corps, {"Content-Type": "application/json"})
try:
with urllib.request.urlopen(req, timeout=300) as r:
return [norme(v) for v in json.load(r)["embeddings"]]
except OSError as err:
sys.exit(f"Ollama injoignable sur {URL} ({err}) : `docker start ollama-bge-m3`, ou OLLAMA_URL.")
def index_a_jour(toutes):
"""Les vecteurs de toutes les étiquettes ; calcule ceux qui manquent, oublie ceux des textes disparus."""
vecteurs = json.loads(INDEX.read_text()) if INDEX.exists() else {}
voulus = {cle(texte(e)): texte(e) for e in toutes}
manquants = [k for k in voulus if k not in vecteurs]
for i in range(0, len(manquants), LOT):
lot = manquants[i:i + LOT]
vecteurs.update(zip(lot, vectoriser([voulus[k] for k in lot])))
print(f"index : {min(i + LOT, len(manquants))}/{len(manquants)} nouveaux textes", file=sys.stderr)
if manquants or len(vecteurs) != len(voulus):
vecteurs = {k: vecteurs[k] for k in voulus}
INDEX.parent.mkdir(exist_ok=True)
INDEX.write_text(json.dumps(vecteurs))
return vecteurs
def chercher(requete, toutes, vecteurs, q, k=8, famille=None, exclure=None):
retenues = [e for e in toutes if (not famille or e.get("categorie") == famille) and not (exclure and recouvre(e, *exclure))]
notes = [(sum(a * b for a, b in zip(q, vecteurs[cle(texte(e))])), e) for e in retenues]
return sorted(notes, key=lambda n: -n[0])[:k]
def check():
e = {"station": "S", "debut": "2026-11-04T00:00Z", "fin": "2026-11-05T00:00Z"}
assert recouvre(e, "S", "2026-11-04T12:00Z", "2026-11-06T00:00Z")
assert recouvre(e, "S", "2026-11-03T00:00Z", "2026-11-04T00:00Z") # bord commun : exclue
assert not recouvre(e, "S", "2026-11-05T00:01Z", "2026-11-06T00:00Z")
assert not recouvre(e, "T", "2026-11-04T12:00Z", "2026-11-06T00:00Z")
assert provenance({"revue": "2026-11-04"}) == "auto, relue le 2026-11-04"
import tempfile # seules les étiquettes de auto/ servent : manual/ est à l'utilisateur seul
with tempfile.TemporaryDirectory() as d:
for sous, desc in (("manual", "de l'utilisateur"), ("auto", "d'un agent")):
(Path(d) / sous).mkdir()
(Path(d) / sous / "S.jsonl").write_text(json.dumps({**e, "description": desc}) + "\n", encoding="utf-8")
assert [x["description"] for x in etiquettes(Path(d))] == ["d'un agent"]
assert provenance({"analyse": "X"}) == "auto, non relue (analyse X)"
a, b = {**e, "categorie": "A", "description": "a"}, {**e, "station": "T", "categorie": "B", "description": "b"}
vec = {cle(texte(a)): [1.0, 0.0], cle(texte(b)): [0.6, 0.8]}
assert [x["categorie"] for _, x in chercher("", [a, b], vec, [0.0, 1.0])] == ["B", "A"]
assert [x["categorie"] for _, x in chercher("", [a, b], vec, [0.0, 1.0], exclure=("T", e["debut"], e["fin"]))] == ["A"]
assert [x["categorie"] for _, x in chercher("", [a, b], vec, [0.0, 1.0], famille="A")] == ["A"]
print("ok")
def main():
p = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
p.add_argument("requete", nargs="?", help="ce que tu vois, en français, comme une description d'étiquette")
p.add_argument("--k", type=int, default=8, help="nombre de précédents (8)")
p.add_argument("--famille", help="seulement cette famille (clé de familles.md)")
p.add_argument("--exclure", nargs=3, metavar=("STATION", "DEBUT", "FIN"),
help="la plage que tu analyses : ses étiquettes sont écartées")
p.add_argument("--index", action="store_true", help="met l'index à jour et s'arrête")
p.add_argument("--check", action="store_true", help="contrôle de la logique, sans Ollama")
a = p.parse_args()
if a.check:
return check()
toutes = list(etiquettes())
vecteurs = index_a_jour(toutes)
if a.index:
return print(f"{len(vecteurs)} étiquettes indexées ({MODELE}) : {INDEX}")
if not a.requete:
p.error("donne un texte, ou --index")
for note, e in chercher(a.requete, toutes, vecteurs, vectoriser([a.requete])[0], a.k, a.famille, a.exclure):
print(f"## {e.get('id', 'sans id')} — {e.get('categorie') or 'sans famille'} — {e['station']} {e['debut']} → {e['fin']}\n"
f"similarité {note:.2f} ; {e['provenance']}\n{e['description']}\n")
if __name__ == "__main__":
main()