banc reecrit : sonde non bloquante, partiels gardes, raisonnement coupe

aides/banc_t4.py

@@ -4,25 +4,32 @@
 # POURQUOI SUR T4 ET PAS SUR LA 2060. La carte de l'utilisateur fait aussi
 # tourner son bureau : un OOM GPU y est une session perdue, pas un test rate --
 # c'est arrive. Le T4 est la MEME generation (sm75) avec 16 Go au lieu de 6 :
-# on peut y sonder sans risque, mesurer l'allocation REELLE, puis appliquer la
+# on y sonde sans risque, on mesure l'allocation REELLE, puis on applique la
 # contrainte des 6 Go sur le papier.
 #
-# METHODE. Le KV est lineaire en contexte : une seule mesure par (modele, dtype
-# de cache) suffit a en deduire les octets par jeton, et donc tous les
-# contextes. Inutile de sonder jusqu'a l'OOM -- c'est precisement l'erreur qui
-# a fait tomber la machine.
+# TROIS DEFAUTS DU PREMIER PASSAGE, TOUS DANS LA SONDE ET PAS DANS LE MODELE :
+#   1. `for ligne in p.stdout` bufferise et bloque dans readline, donc le
+#      timeout place DANS la boucle ne s'executait jamais -> 15 min de T4 fige.
+#      On ecrit desormais dans un FICHIER qu'on relit a l'horloge.
+#   2. On exigeait les TROIS tampons pour conclure ; quand le tampon de calcul
+#      n'etait pas annonce, la sonde expirait et JETAIT le KV et les poids
+#      deja lus. On garde les partiels, et on affiche la fin du log en cas
+#      d'echec pour diagnostiquer sans relancer un job.
+#   3. Ces modeles RAISONNENT. Sans couper le raisonnement, le budget partait
+#      dans <think> et `content` revenait VIDE ; le ratio de 4-grammes affichait
+#      alors 0,000 et j'ai failli conclure "radotage". Une reponse vide est une
+#      mesure ABSENTE, pas une mauvaise reponse -- elle ne se compte pas.
 import json
 import os
 import re
 import subprocess
-import sys
 import time
 import urllib.request
 
-BIN = "/app"                      # image ggml-org/llama.cpp
+BIN = "/app"
 RACINE = "/tmp/modeles"
-VRAM_2060 = 6144                  # Mio
-RESERVE = 700                     # contexte CUDA + bureau, mesure chez lui
+VRAM_2060 = 6144
+RESERVE = 700
 BUDGET = VRAM_2060 - RESERVE
 
 MODELES = [
@@ -30,10 +37,14 @@ MODELES = [
     ("Qwen3.5-4B", "unsloth/Qwen3.5-4B-GGUF", "*Q5_K_M*"),
 ]
 
+RE_KV = re.compile(r"KV (?:self )?(?:buffer )?size\s*=\s*([\d.]+) MiB")
+RE_POIDS = re.compile(r"CUDA0 model buffer size\s*=\s*([\d.]+) MiB")
+RE_CALC = re.compile(r"CUDA0 compute buffer size\s*=\s*([\d.]+) MiB")
+
 
 def outil(nom):
-    for p in (os.path.join(BIN, nom), os.path.join(BIN, "bin", nom), nom):
-        if os.path.exists(p) or p == nom:
+    for p in (os.path.join(BIN, nom), os.path.join(BIN, "bin", nom)):
+        if os.path.exists(p):
             return p
     return nom
 
@@ -46,22 +57,20 @@ def trouver_gguf(d):
     return None
 
 
-def charger(chemin, ctx, kv, timeout=240):
-    """Charge le modele et rend les tailles de tampons annoncees, en Mio.
+def cmd_serveur(chemin, ctx, kv):
+    c = [outil("llama-server"), "-m", chemin, "-ngl", "99", "-fa", "1",
+         "-c", str(ctx), "--host", "127.0.0.1", "--port", "8081", "--no-webui"]
+    if kv != "f16":
+        c += ["-ctk", kv, "-ctv", kv]
+    return c
+
 
-    La sortie du serveur va dans un FICHIER, jamais dans un pipe qu'on itere :
-    `for ligne in p.stdout` bufferise en interne et bloque sur readline, donc
-    un timeout place DANS la boucle ne se declenche jamais. C'est ce qui a fige
-    le premier passage pendant quinze minutes. On sonde le fichier a l'horloge.
-    """
+def charger(chemin, ctx, kv, timeout=240):
+    """Rend les tailles de tampons annoncees au chargement, en Mio."""
     journal = "/tmp/srv-%s-%s.log" % (ctx, kv)
-    cmd = [outil("llama-server"), "-m", chemin, "-ngl", "99", "-fa", "1",
-           "-c", str(ctx), "--host", "127.0.0.1", "--port", "8081",
-           "--no-webui"]
-    if kv != "f16":
-        cmd += ["-ctk", kv, "-ctv", kv]
     f = open(journal, "w")
-    p = subprocess.Popen(cmd, stdout=f, stderr=subprocess.STDOUT)
+    p = subprocess.Popen(cmd_serveur(chemin, ctx, kv), stdout=f,
+                         stderr=subprocess.STDOUT)
     res = {"kv": None, "poids": None, "calcul": None, "erreur": None}
     t0 = time.time()
     try:
@@ -71,32 +80,15 @@ def charger(chemin, ctx, kv, timeout=240):
                 txt = open(journal, errors="replace").read()
             except Exception:
                 continue
-            m = re.search(r"KV (?:self )?(?:buffer )?size\s*=\s*([\d.]+) MiB", txt)
-            if m:
-                res["kv"] = float(m.group(1))
-            m = re.search(r"CUDA0 model buffer size\s*=\s*([\d.]+) MiB", txt)
-            if m:
-                res["poids"] = float(m.group(1))
-            m = re.search(r"CUDA0 compute buffer size\s*=\s*([\d.]+) MiB", txt)
-            if m:
-                res["calcul"] = float(m.group(1))
+            for cle, rx in (("kv", RE_KV), ("poids", RE_POIDS), ("calcul", RE_CALC)):
+                m = rx.search(txt)
+                if m:
+                    res[cle] = float(m.group(1))
             bas = txt.lower()
             if "out of memory" in bas or "failed to allocate" in bas:
                 res["erreur"] = "OOM"
                 break
-            # Le tampon de calcul n'est pas toujours annonce : exiger les TROIS
-            # faisait expirer la sonde alors que KV et poids etaient deja lus,
-            # et le script jetait ensuite les valeurs partielles. Deux jobs
-            # perdus pour ca.
             if res["kv"] is not None and res["poids"] is not None:
-                time.sleep(3)
-                try:
-                    txt2 = open(journal, errors="replace").read()
-                    m2 = re.search(r"CUDA0 compute buffer size\s*=\s*([\d.]+) MiB", txt2)
-                    if m2:
-                        res["calcul"] = float(m2.group(1))
-                except Exception:
-                    pass
                 break
             if p.poll() is not None:
                 if res["kv"] is None:
@@ -104,31 +96,27 @@ def charger(chemin, ctx, kv, timeout=240):
                 break
         else:
             if res["kv"] is None:
-                extrait = ""
+                bout = ""
                 try:
-                    extrait = open(journal, errors="replace").read()[-500:].replace("
-", " | ")
+                    brut = open(journal, errors="replace").read()[-400:]
+                    bout = " | ".join(brut.splitlines()[-4:])
                 except Exception:
                     pass
-                res["erreur"] = "timeout %ds ; fin de log : %s" % (timeout, extrait)
+                res["erreur"] = "timeout %ds ; fin de log : %s" % (timeout, bout)
     finally:
         try:
-            p.terminate(); p.wait(timeout=20)
+            p.terminate()
+            p.wait(timeout=20)
         except Exception:
             p.kill()
         f.close()
-    if res["erreur"] is None and res["kv"] is None:
-        res["erreur"] = "tampons non annonces"
     return res
 
 
 def serveur(chemin, ctx, kv):
-    cmd = [outil("llama-server"), "-m", chemin, "-ngl", "99", "-fa", "1",
-           "-c", str(ctx), "--host", "127.0.0.1", "--port", "8081", "--no-webui"]
-    if kv != "f16":
-        cmd += ["-ctk", kv, "-ctv", kv]
-    p = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-    for _ in range(120):
+    p = subprocess.Popen(cmd_serveur(chemin, ctx, kv),
+                         stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    for _ in range(150):
         time.sleep(2)
         try:
             urllib.request.urlopen("http://127.0.0.1:8081/health", timeout=5)
@@ -140,42 +128,35 @@ def serveur(chemin, ctx, kv):
 
 
 def demander(prompt, maxtok=640, temp=0.2):
-    """Coupe le raisonnement, et rattrape le cas ou il sort quand meme.
-
-    Au premier passage, `max_tokens=320` sans desactiver le raisonnement a
-    donne des `content` VIDES : le modele depensait tout son budget dans
-    <think>. Mon ratio de 4-grammes a alors affiche 0,000 et j'ai failli
-    conclure "radotage" -- alors que la sonde ne mesurait rien du tout.
-    """
-    corps = json.dumps({"messages": [{"role": "user", "content": prompt}],
-                        "max_tokens": maxtok, "temperature": temp,
-                        "stream": False,
-                        "chat_template_kwargs": {"enable_thinking": False}}).encode()
+    corps = json.dumps({
+        "messages": [{"role": "user", "content": prompt}],
+        "max_tokens": maxtok, "temperature": temp, "stream": False,
+        "chat_template_kwargs": {"enable_thinking": False},
+    }).encode()
     r = urllib.request.Request("http://127.0.0.1:8081/v1/chat/completions",
                                data=corps,
                                headers={"content-type": "application/json"})
     t = time.time()
     d = json.loads(urllib.request.urlopen(r, timeout=300).read())
-    msg = d["choices"][0]["message"]
+    ch = d["choices"][0]
+    msg = ch["message"]
     texte = (msg.get("content") or "").strip()
     raison = (msg.get("reasoning_content") or "").strip()
     if not texte and raison:
         texte = "[raisonnement seul] " + raison
-    fin = d["choices"][0].get("finish_reason")
     u = d.get("usage") or {}
-    return texte, time.time() - t, fin, u.get("completion_tokens", 0)
+    return (texte, time.time() - t, ch.get("finish_reason"),
+            u.get("completion_tokens", 0))
 
 
 def distinct4(texte):
-    """Le garde-fou contre la degenerescence.
-
-    Un depot de chez nous affichait un debit honorable avec des 4-grammes
-    distincts a 0,000 : le texte etait du radotage et le chiffre de vitesse,
-    lui, etait exact. On ne publie pas un debit sans ce ratio.
-    """
+    """Garde-fou contre la degenerescence : un depot de chez nous affichait un
+    debit honorable avec ce ratio a 0,000, du pur radotage. Rend None quand il
+    n'y a pas assez de mots pour conclure -- ne jamais confondre 'pas de
+    mesure' et 'mauvaise mesure'."""
     mots = re.findall(r"\w+", texte.lower())
     if len(mots) < 8:
-        return 0.0
+        return None
     g = [tuple(mots[i:i + 4]) for i in range(len(mots) - 3)]
     return len(set(g)) / len(g)
 
@@ -185,20 +166,21 @@ EPREUVES = [
      "Calcule 17 * 23 + 145. Reponds uniquement par le nombre.",
      lambda r: "536" in r),
     ("code-python",
-     "Ecris une fonction Python `est_premier(n)` qui renvoie True si n est "
+     "Ecris une fonction Python est_premier(n) qui renvoie True si n est "
      "premier. Code seulement, pas d'explication.",
-     lambda r: "def est_premier" in r.replace(" ", "").replace("def est_premier", "def est_premier") or "def est_premier" in r),
+     lambda r: "est_premier" in r and "def" in r),
     ("lecture-erreur",
-     "Voici une erreur : `TypeError: unsupported operand type(s) for +: "
-     "'int' and 'str'` a la ligne 12 de app.py. En une phrase, quelle est la "
-     "cause et comment la corriger ?",
-     lambda r: any(k in r.lower() for k in ("str(", "int(", "conver", "cast", "chaine", "type"))),
+     "Voici une erreur : TypeError: unsupported operand type(s) for +: "
+     "'int' and 'str', ligne 12 de app.py. En une phrase : la cause et le "
+     "correctif ?",
+     lambda r: any(k in r.lower() for k in
+                   ("str(", "int(", "conver", "cast", "chaine", "type"))),
     ("instruction-stricte",
      "Reponds exactement par le mot MANGUE, rien d'autre.",
      lambda r: r.strip().strip(".").upper().startswith("MANGUE")),
     ("json",
      'Donne un objet JSON avec les cles "nom" (chaine) et "age" (entier) pour '
-     'une personne nommee Ada agee de 36 ans. JSON seul.',
+     'une personne nommee Ada, 36 ans. JSON seul.',
      lambda r: "ada" in r.lower() and "36" in r),
 ]
 
@@ -210,7 +192,7 @@ def main():
                     "--format=csv,noheader"])
     print("budget equivalent RTX 2060 : %d Mio (6144 - %d de reserve)"
           % (BUDGET, RESERVE))
-    print("=" * 74)
+    print("=" * 74, flush=True)
 
     for nom, repo, motif in MODELES:
         d = os.path.join(RACINE, nom)
@@ -222,14 +204,13 @@ def main():
         taille = os.path.getsize(chemin) / (1024 * 1024)
         print("\n" + "=" * 74)
         print("### %s  (%.0f Mio sur disque)" % (nom, taille))
-        print("=" * 74)
+        print("=" * 74, flush=True)
 
-        # --- capacite : une mesure par dtype de cache, le reste se deduit
         CTX_SONDE = 8192
         for kv in ("f16", "q8_0"):
             r = charger(chemin, CTX_SONDE, kv)
-            if r["erreur"]:
-                print("  KV %-5s : ECHEC %s" % (kv, r["erreur"]))
+            if r["kv"] is None:
+                print("  KV %-5s : ECHEC %s" % (kv, r["erreur"]), flush=True)
                 continue
             par_jeton = r["kv"] * 1024 * 1024 / CTX_SONDE
             fixe = (r["poids"] or 0) + (r["calcul"] or 0)
@@ -237,15 +218,16 @@ def main():
             ctx_max = int(dispo * 1024 * 1024 / par_jeton) if dispo > 0 else 0
             print("  KV %-5s : %6.0f o/jeton | poids %6.0f + calcul %5.0f = %6.0f Mio fixes"
                   % (kv, par_jeton, r["poids"] or 0, r["calcul"] or 0, fixe))
-            print("           -> sur 6 Go il reste %6.0f Mio  =>  CONTEXTE MAX %s jetons"
-                  % (dispo, "{:,}".format(max(ctx_max, 0)).replace(",", " ")))
+            print("           -> il reste %6.0f Mio sur 6 Go  =>  CONTEXTE MAX %s jetons"
+                  % (dispo, "{:,}".format(max(ctx_max, 0)).replace(",", " ")),
+                  flush=True)
 
-        # --- qualite, a un contexte confortable
-        print("\n  --- qualite (contexte 8192, KV q8_0) ---")
+        print("\n  --- qualite (contexte 8192, KV q8_0, raisonnement coupe) ---",
+              flush=True)
         try:
             p = serveur(chemin, 8192, "q8_0")
         except Exception as e:
-            print("  serveur KO :", repr(e)[:100])
+            print("  serveur KO :", repr(e)[:100], flush=True)
             continue
         try:
             score = 0
@@ -253,24 +235,34 @@ def main():
             textes = []
             for etiquette, prompt, verif in EPREUVES:
                 try:
-                    rep, dt = demander(prompt)
+                    rep, dt, fin, ntok = demander(prompt)
                 except Exception as e:
-                    print("    %-18s ERREUR %s" % (etiquette, repr(e)[:60]))
+                    print("    %-19s ERREUR %s" % (etiquette, repr(e)[:60]))
+                    vides += 1
+                    continue
+                if not rep:
+                    print("    %-19s VIDE  %5.1fs  (fin=%s, %d jetons emis)"
+                          % (etiquette, dt, fin, ntok))
+                    vides += 1
                     continue
                 textes.append(rep)
                 ok = bool(verif(rep))
                 score += ok
-                court = rep.strip().replace("\n", " ")[:64]
-                print("    %-18s %-4s %5.1fs  %s" % (etiquette, "OK" if ok else "faux", dt, court))
-            d4 = distinct4(" ".join(textes))
+                court = rep.replace("\n", " ")[:66]
+                print("    %-19s %-4s %5.1fs  %s"
+                      % (etiquette, "OK" if ok else "faux", dt, court))
             print("    ---")
             juges = len(EPREUVES) - vides
+            d4 = distinct4(" ".join(textes))
             if juges == 0:
                 print("    AUCUNE REPONSE EXPLOITABLE -- sonde cassee, pas de verdict")
             else:
-                print("    SCORE %d/%d juges (%d vides, non comptes)   4-grammes %.3f  %s"
-                      % (score, juges, vides, d4,
-                         "(sain)" if d4 > 0.8 else "(!! RADOTAGE)" if d4 < 0.5 else "(a surveiller)"))
+                etat = "(?)" if d4 is None else (
+                    "(sain)" if d4 > 0.8 else "(!! RADOTAGE)" if d4 < 0.5
+                    else "(a surveiller)")
+                print("    SCORE %d/%d juges  (%d vides, non comptes)  4-grammes %s %s"
+                      % (score, juges, vides,
+                         "n/a" if d4 is None else "%.3f" % d4, etat))
         finally:
             p.kill()