precedents.py : le RAG des étiquettes (bge-m3 par Ollama), index .index/ hors de git

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
maximeandClaude Opus 5.5 committed 2026-11-16 09:55:48 +01:00
1 parent 1f32cf8198
commit 1d9bfc20b3
3 files changed
+148

No files matched your search

+1
View File
@@ -1,2 +1,3 @@
__pycache__/
auto/analyses/*/travail/
.index/
+1
View File
@@ -6,6 +6,7 @@ Les étiquettes des déplacements AIMsight et toute la connaissance métier pour
- `auto/analyses/<STATION>_<début>_<fin>/` : 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`).
+146
View File
@@ -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 "<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 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()