146 lines
6.9 KiB
Python
146 lines
6.9 KiB
Python
"""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()
|