From 1d9bfc20b31795bdbcf722d957b54d8d8d39ed27 Mon Sep 17 00:00:00 2001 From: maxime Date: Mon, 16 Nov 2026 09:55:48 +0100 Subject: [PATCH] =?UTF-8?q?precedents.py=20:=20le=20RAG=20des=20=C3=A9tiqu?= =?UTF-8?q?ettes=20(bge-m3=20par=20Ollama),=20index=20.index/=20hors=20de?= =?UTF-8?q?=20git?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 5.5 --- .gitignore | 1 + README.md | 1 + precedents.py | 146 ++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 148 insertions(+) create mode 100644 precedents.py diff --git a/.gitignore b/.gitignore index 3239a7d..60f626a 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,3 @@ __pycache__/ auto/analyses/*/travail/ +.index/ diff --git a/README.md b/README.md index b0ee664..e8e38f8 100644 --- a/README.md +++ b/README.md @@ -6,6 +6,7 @@ Les étiquettes des déplacements AIMsight et toute la connaissance métier pour - `auto/analyses/__/` : les analyses lancées depuis la page Data de Diagnostic-App (`travail/` hors de git). - `familles.md`, `regles-d-etiquetage.md`, `carte-des-etiquettes.md`, `connaissances/` : comment étiqueter, ce que les étiquettes ont appris. - `controle.py` (les étiquettes face aux règles), `ids.py` (l'id stable de chacune). +- `precedents.py` : le RAG des étiquettes. Les étiquettes de `manual/` et `auto/` les plus proches d'un texte par le sens, avec leur provenance ; `--exclure STATION DEBUT FIN` écarte la plage analysée. Modèle bge-m3 du conteneur Ollama `ollama-bge-m3` (`docker start ollama-bge-m3`, port 11435) ; l'index `.index/`, hors de git, se met à jour seul à chaque appel (seules les étiquettes nouvelles ou modifiées passent par le modèle ; ~8 min pour tout refaire sur CPU). Diagnostic-App et Optimizer y accèdent par un lien `labeling -> ~/labeling`, ignoré par git : Diagnostic-App y lit et écrit (étiquettes, analyses), Optimizer y lit seulement ; on commite ici. `controle.py` et `ids.py` se lancent d'ici ou par le lien (`python3 labeling/controle.py`). diff --git a/precedents.py b/precedents.py new file mode 100644 index 0000000..d3914dc --- /dev/null +++ b/precedents.py @@ -0,0 +1,146 @@ +"""Les précédents : les étiquettes (manual/ et auto/) les plus proches d'un texte, par le sens (RAG). + +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 (expert, auto relue, auto 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 "" --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 manual/ et auto/, avec leur station et leur provenance.""" + for f in sorted(glob.glob(str(racine / "manual" / "*.jsonl")) + glob.glob(str(racine / "auto" / "*.jsonl"))): + source, station = Path(f).parent.name, Path(f).stem + for ligne in open(f, encoding="utf-8"): + if ligne.strip(): + e = json.loads(ligne) + e["station"], e["provenance"] = station, provenance(source, e) + yield e + + +def provenance(source, e): + if source == "manual": + return "expert" + 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("manual", {}) == "expert" and provenance("auto", {"revue": "2026-11-04"}) == "auto, relue le 2026-11-04" + assert provenance("auto", {"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()