2026-11-16 11:37:50 +01:00
|
|
|
"""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.
|
2026-11-16 09:55:48 +01:00
|
|
|
|
|
|
|
|
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
|
2026-11-16 11:37:50 +01:00
|
|
|
stations, avec leur provenance (relue, non relue) : à lui de juger si elles valent pour son cas.
|
2026-11-16 09:55:48 +01:00
|
|
|
|
|
|
|
|
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
|
2026-11-16 12:13:17 +01:00
|
|
|
modifiées passent par le modèle. Modèle : bge-m3 servi par Ollama, le conteneur ollama-bge-m3, que l'outil démarre
|
|
|
|
|
lui-même s'il ne répond pas (`docker start`) ; OLLAMA_URL et RAG_MODELE pour en changer. Bibliothèque standard seulement.
|
2026-11-16 09:55:48 +01:00
|
|
|
"""
|
|
|
|
|
import argparse
|
|
|
|
|
import glob
|
|
|
|
|
import hashlib
|
|
|
|
|
import json
|
|
|
|
|
import math
|
|
|
|
|
import os
|
2026-11-16 12:13:17 +01:00
|
|
|
import subprocess
|
2026-11-16 09:55:48 +01:00
|
|
|
import sys
|
2026-11-16 12:13:17 +01:00
|
|
|
import time
|
2026-11-16 09:55:48 +01:00
|
|
|
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")
|
2026-11-16 12:13:17 +01:00
|
|
|
CONTENEUR = "ollama-bge-m3" # démarré par l'outil s'il ne répond pas
|
2026-11-16 09:55:48 +01:00
|
|
|
INDEX = ICI / ".index" / f"{MODELE.replace(':', '_')}.json"
|
|
|
|
|
LOT = 32 # textes par appel au modèle
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def etiquettes(racine=ICI):
|
2026-11-16 11:37:50 +01:00
|
|
|
"""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
|
2026-11-16 09:55:48 +01:00
|
|
|
for ligne in open(f, encoding="utf-8"):
|
|
|
|
|
if ligne.strip():
|
|
|
|
|
e = json.loads(ligne)
|
2026-11-16 11:37:50 +01:00
|
|
|
e["station"], e["provenance"] = station, provenance(e)
|
2026-11-16 09:55:48 +01:00
|
|
|
yield e
|
|
|
|
|
|
|
|
|
|
|
2026-11-16 11:37:50 +01:00
|
|
|
def provenance(e):
|
2026-11-16 09:55:48 +01:00
|
|
|
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]
|
|
|
|
|
|
|
|
|
|
|
2026-11-16 12:13:17 +01:00
|
|
|
def demarrer_ollama(attente=120):
|
|
|
|
|
"""Le conteneur ollama-bge-m3 arrêté : `docker start`, puis attendre qu'il réponde -> True s'il répond."""
|
|
|
|
|
if subprocess.run(["docker", "start", CONTENEUR], capture_output=True).returncode:
|
|
|
|
|
return False
|
|
|
|
|
fin = time.monotonic() + attente
|
|
|
|
|
while time.monotonic() < fin:
|
|
|
|
|
try:
|
|
|
|
|
with urllib.request.urlopen(f"{URL}/api/version", timeout=5):
|
|
|
|
|
return True
|
|
|
|
|
except OSError:
|
|
|
|
|
time.sleep(2)
|
|
|
|
|
return False
|
|
|
|
|
|
|
|
|
|
|
2026-11-16 09:55:48 +01:00
|
|
|
def vectoriser(textes):
|
|
|
|
|
corps = json.dumps({"model": MODELE, "input": textes}).encode()
|
|
|
|
|
req = urllib.request.Request(f"{URL}/api/embed", corps, {"Content-Type": "application/json"})
|
2026-11-16 12:13:17 +01:00
|
|
|
for essai in (1, 2): # Ollama arrêté : on démarre son conteneur, une fois, puis on relance
|
|
|
|
|
try:
|
|
|
|
|
with urllib.request.urlopen(req, timeout=300) as r:
|
|
|
|
|
return [norme(v) for v in json.load(r)["embeddings"]]
|
|
|
|
|
except OSError as err:
|
|
|
|
|
if essai == 2 or not demarrer_ollama():
|
|
|
|
|
sys.exit(f"Ollama injoignable sur {URL} ({err}) : `docker start {CONTENEUR}`, ou OLLAMA_URL.")
|
2026-11-16 09:55:48 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
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")
|
2026-11-16 11:37:50 +01:00
|
|
|
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)"
|
2026-11-16 09:55:48 +01:00
|
|
|
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"]
|
2026-11-16 12:13:17 +01:00
|
|
|
appels, reponses = [], iter([OSError("refusé"), {"embeddings": [[3.0, 4.0]]}]) # Ollama arrêté : démarré, puis la relance passe
|
|
|
|
|
|
|
|
|
|
class Reponse:
|
|
|
|
|
def __init__(self, r):
|
|
|
|
|
self.r = r
|
|
|
|
|
|
|
|
|
|
def __enter__(self):
|
|
|
|
|
return self
|
|
|
|
|
|
|
|
|
|
def __exit__(self, *a):
|
|
|
|
|
return False
|
|
|
|
|
|
|
|
|
|
def read(self):
|
|
|
|
|
return json.dumps(self.r).encode()
|
|
|
|
|
|
|
|
|
|
def ouvrir(*a, **k):
|
|
|
|
|
r = next(reponses)
|
|
|
|
|
if isinstance(r, Exception):
|
|
|
|
|
raise r
|
|
|
|
|
return Reponse(r)
|
|
|
|
|
avant = urllib.request.urlopen, globals()["demarrer_ollama"]
|
|
|
|
|
urllib.request.urlopen, globals()["demarrer_ollama"] = ouvrir, lambda: appels.append(1) or True
|
|
|
|
|
try:
|
|
|
|
|
assert vectoriser(["x"]) == [[0.6, 0.8]] and appels == [1], appels
|
|
|
|
|
finally:
|
|
|
|
|
urllib.request.urlopen, globals()["demarrer_ollama"] = avant
|
2026-11-16 09:55:48 +01:00
|
|
|
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()
|