File size: 8,111 Bytes
a462430
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
"""Compare un modèle d'embeddings (et/ou de reranker) au service actuel, sans tricher sur la rampe.



Pour le modèle testé (variables MODEL_NAME, MODEL_PROMPT, RERANKER_MODEL) :

  1. la rampe SIM_BAS / SIM_HAUT est réglée sur le jeu de RÉGLAGE (exemples/cv_list.json, 23 CV,

     comme pour bge-m3) : chaque modèle a sa propre échelle de similarité ;

  2. il est mesuré sur le jeu d'ÉVALUATION n° 2 (exemples/cv_eval.json, 68 CV notés 0..3), jamais

     utilisé pour régler ;

  3. comparaison APPARIÉE avec le service actuel : mêmes CV, bootstrap sur la différence. Un écart

     dont l'intervalle contient 0 n'est pas un progrès démontré.



Le service actuel doit avoir été mesuré avant (python -m scripts.evaluer_jeu). Les similarités

sont gardées dans resultats/jeu_eval/ : relancer ne recalcule rien.



Exemple (PowerShell) :

  $env:MODEL_NAME="Qwen/Qwen3-Embedding-0.6B"

  $env:MODEL_PROMPT="Instruct: Retrieve semantically similar text`nQuery: "

  python -m scripts.comparer_modeles

"""
from __future__ import annotations

import hashlib
import json
import os
import pickle

import numpy as np

os.environ.setdefault("DATASET_REVISION", "1bb92a09a4ff6aa6e9488ee954085019abba7747")

from app import config, scoring  # noqa: E402
from scripts.evaluer_classement import charger_attendus, matrice  # noqa: E402
from scripts.evaluer_jeu import CACHE, JEU, RACINE, mesures, notes  # noqa: E402

REFERENCE = "BAAI_bge-m3+BAAI_bge-reranker-v2-m3"


def etiquette() -> str:
    import re
    nom = f"{config.MODEL_NAME}+{config.RERANKER_MODEL or 'sans-reranker'}"
    if config.MODEL_PROMPT:
        nom += "+p" + hashlib.sha1(config.MODEL_PROMPT.encode()).hexdigest()[:6]
    return re.sub(r"[^\w.+-]", "_", nom)


def calculer(jeux: dict[str, list[dict]]):
    """{nom du jeu: CV} -> {nom: (ids, poids, poids_sf, sims)} ; modèles chargés une seule fois."""
    CACHE.mkdir(parents=True, exist_ok=True)
    fichiers = {n: CACHE / (f"{etiquette()}.pkl" if n == "eval" else f"{etiquette()}_{n}.pkl") for n in jeux}
    sortie, a_faire = {}, {}
    for n, cvs in jeux.items():
        if fichiers[n].exists():
            d = pickle.loads(fichiers[n].read_bytes())
            if d["cvs"] == [c.get("_id", k) for k, c in enumerate(cvs)]:
                sortie[n] = (d["ids"], d["poids"], d["poids_sf"], d["sims"])
                continue
        a_faire[n] = cvs
    if not a_faire:
        return sortie
    from app.avp_store import AVPStore
    from app.cv_texte import phrases_du_cv
    from app.encodeur import Encodeur
    from app.outils import textes_pour_calcul
    if config.RERANKER_MODEL:
        from app.reranker import Reranker
        scoring.RERANKER = Reranker(config.RERANKER_MODEL)
    encodeur = Encodeur(config.MODEL_NAME)
    store = AVPStore(encodeur)
    store.charger()
    ids = list(store.prepares)
    poids = [store.prepares[i].poids for i in ids]
    poids_sf = [store.prepares[i].poids * ~store.prepares[i].savoir_etre for i in ids]
    for n, cvs in a_faire.items():
        sims = []
        for k, cv in enumerate(cvs, 1):
            phrases = phrases_du_cv(cv)
            textes = textes_pour_calcul(phrases)
            vecs = encodeur.encoder(textes) if phrases else None
            rr = scoring.probas_reranker_avps(store.prepares, textes, vecs) if vecs is not None else {}
            sims.append([(store.prepares[i].vecs_attendus @ vecs.T, rr.get(i))
                         if vecs is not None and len(store.prepares[i].attendus) else None for i in ids])
            print(f"\r  {n} : CV {k}/{len(cvs)}", end="", flush=True)
        print()
        fichiers[n].write_bytes(pickle.dumps({"cvs": [c.get("_id", k) for k, c in enumerate(cvs)], "ids": ids,
                                              "poids": poids, "poids_sf": poids_sf, "sims": sims}))
        sortie[n] = (ids, poids, poids_sf, sims)
    return sortie


def mesurer_strict(m, ids, attendus) -> dict:
    """Comme evaluer_classement.mesurer, mais un ex aequo compte comme une défaite : sinon une rampe

    très basse (tous les scores à 100, tous ex aequo) passe pour parfaite."""
    hors = [c for c, a in attendus.items() if a is None]
    rr, rc, marges = [], [], []
    for c, cibles in attendus.items():
        if cibles is None:
            continue
        cols = [ids.index(a) for a in cibles]
        for a in cols:
            rr.append(int(np.sum(m[:, a] >= m[c, a])))
            marges += [float(m[c, a] - max(m[h, a] for h in hors))] if hors else []
        rc.append(min(int(np.sum(m[c] >= m[c, a])) for a in cols))
    rr, rc = np.array(rr), np.array(rc)
    return {"rec_top1": round(float(np.mean(rr == 1)), 3), "rec_mrr": round(float(np.mean(1 / rr)), 3),
            "cand_top1": round(float(np.mean(rc == 1)), 3), "cand_mrr": round(float(np.mean(1 / rc)), 3),
            "marge_min": round(min(marges), 3) if marges else None, "faux_positifs": int(sum(x <= 0 for x in marges))}


def regler_rampe(ids, poids, sims) -> tuple[float, float, dict]:
    """Même recherche que scripts/evaluer_classement, sur le jeu de réglage (ex aequo = défaite)."""
    attendus = charger_attendus(ids)
    essais = []
    for bas in np.arange(0.20, 0.96, 0.025):
        for haut in np.arange(bas + 0.025, 1.0, 0.0125):
            res = mesurer_strict(matrice(sims, poids, bas, haut), ids, attendus)
            essais.append(((res["rec_mrr"] + res["cand_mrr"], res["marge_min"] or 0), round(float(bas), 3),
                           round(float(haut), 3), res))
    essais.sort(key=lambda e: e[0], reverse=True)
    return essais[0][1], essais[0][2], essais[0][3]


def compare(m_ref, m_new, R, poste_avp, n=1000, graine=11) -> dict:
    """Différence appariée nouveau - référence, intervalle à 95 % (bootstrap sur les CV)."""
    rng = np.random.default_rng(graine)
    diffs = []
    for _ in range(n):
        lignes = rng.integers(0, len(R), len(R))
        a, b = mesures(m_ref, R, poste_avp, lignes), mesures(m_new, R, poste_avp, lignes)
        diffs.append({k: b[k] - a[k] for k in a})
    return {k: (float(np.mean([d[k] for d in diffs])), float(np.percentile([d[k] for d in diffs], 2.5)),
                float(np.percentile([d[k] for d in diffs], 97.5))) for k in diffs[0]}


def main():
    jeu = json.loads(JEU.read_text(encoding="utf-8"))
    reglage = json.loads((RACINE / "exemples/cv_list.json").read_text(encoding="utf-8"))
    print(f"Modèle testé : {config.MODEL_NAME} · instruction {config.MODEL_PROMPT!r} · "
          f"reranker {config.RERANKER_MODEL or 'aucun'}")
    d = calculer({"reglage": reglage, "eval": jeu["cvs"]})

    ids_r, poids_r, _, sims_r = d["reglage"]
    bas, haut, res_r = regler_rampe(ids_r, poids_r, sims_r)
    print(f"\nRampe réglée sur le jeu de réglage : {bas} / {haut}  ->  {res_r}")

    ids, poids, _, sims = d["eval"]
    R, poste_avp = notes(jeu, ids)
    m_new = matrice(sims, poids, bas, haut)
    ref = pickle.loads((CACHE / f"{REFERENCE}.pkl").read_bytes())
    assert ref["ids"] == ids, "AVP différents de la référence"
    m_ref = matrice(ref["sims"], ref["poids"], 0.575, 0.775)

    a, b = mesures(m_ref, R, poste_avp), mesures(m_new, R, poste_avp)
    diff = compare(m_ref, m_new, R, poste_avp)
    print(f"\nJeu d'évaluation n° 2 (68 CV) : service actuel -> modèle testé, écart [IC 95 % apparié]")
    for k in a:
        moy, lo, hi = diff[k]
        verdict = "MIEUX" if lo > 0 else "MOINS BIEN" if hi < 0 else "pas de différence démontrée"
        print(f"  {k:20s} {a[k]:.3f} -> {b[k]:.3f}   {moy:+.3f} [{lo:+.3f} ; {hi:+.3f}]  {verdict}")
    (CACHE / f"{etiquette()}_comparaison.json").write_text(json.dumps(
        {"modele": config.MODEL_NAME, "prompt": config.MODEL_PROMPT, "reranker": config.RERANKER_MODEL,
         "rampe": [bas, haut], "reglage": res_r, "reference": a, "teste": b, "ecarts": diff}, indent=1,
        ensure_ascii=False), encoding="utf-8")


if __name__ == "__main__":
    main()