File size: 8,211 Bytes
e01a936
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6044352
 
e01a936
 
6044352
e01a936
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6044352
 
e01a936
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
"""Compare le service à des systèmes plus simples, sur un jeu de réglage et un jeu de test.



Systèmes (du plus simple au service) :

  1. Mots-clés, CV entier      TF-IDF du CV entier contre TF-IDF de l'AVP entier (comme un ATS classique)

  2. Mots-clés par compétence  pour chaque compétence de l'AVP, la phrase du CV la plus proche en

                               TF-IDF ; même moyenne pondérée que le service

  3. Embeddings, CV entier     bge-m3, CV entier contre AVP entier (recette de l'OPT-NC)

  4. Embeddings par compétence bge-m3 phrase à phrase avec la rampe, sans reranker

  5. Reranker seul             bge-reranker-v2-m3 sur les 3 phrases les plus proches

  6. Service                   meilleure note entre 4 et 5 (le service en ligne)

  7. Service + mots-clés (max)  par compétence, meilleure note entre le service et les mots-clés

  8. Service + mots-clés (moy.) par compétence, moyenne des deux notes

  (7 et 8 : combinaisons fixées à l'avance, sans réglage, comme le « mots-clés + embeddings » du guide)



Jeux :

  réglage  exemples/cv_list.json + attendus.json : 23 CV, ont servi à régler la rampe et les seuils

           des libellés (résultat optimiste pour le service)

  test     exemples/cv_banc.json : 18 CV écrits avec leurs propres mots, JAMAIS utilisés pour régler

           (champs _cible et _niveau : parfait, bon, partiel, hors)

Aucun réglage n'est fait ici : chaque système est mesuré tel quel, une seule fois.



Lancer depuis la racine du projet (archive des 24 AVP) :

  $env:DATASET_REVISION="1bb92a09a4ff6aa6e9488ee954085019abba7747"; $env:DATASET_DERNIERE="false"

  python -m scripts.comparer_systemes

"""
import json
from pathlib import Path

import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer

from app import config, scoring
from app.avp_store import AVPStore, texte_embedding
from app.cv_texte import phrases_du_cv
from app.encodeur import Encodeur
from app.outils import textes_pour_calcul
from app.reranker import Reranker
from scripts.evaluer_classement import charger_attendus, mesurer

RACINE = Path(__file__).resolve().parent.parent
MOTS_VIDES = ("de du des la le les l d et à a au aux en par pour sur dans un une avec sans ou est sont son sa ses "
              "leur leurs ce cette ces qui que dont il elle ils elles se ne pas plus tout tous toute toutes être "
              "avoir faire afin selon lors ainsi etre").split()


def ligne(nom, r):
    return (f"  {nom:30s} | {r['cand_top1']:.2f}    {r['cand_top3']:.2f}    {r['cand_mrr']:.2f} | "
            f"{r['rec_top1']:.2f}    {r['rec_mrr']:.2f} | {r['marge_min']:+.3f}  {r['faux_positifs']}")


NOMS = ["Mots-clés, CV entier", "Mots-clés par compétence", "Embeddings, CV entier", "Embeddings par compétence",
        "Reranker seul", "Service (embeddings + reranker)", "Service + mots-clés (max)", "Service + mots-clés (moy.)"]


def charger():
    scoring.RERANKER = Reranker(config.RERANKER_MODEL)
    enc = Encodeur(config.MODEL_NAME)
    store = AVPStore(enc)
    store.charger()
    return store, enc


def apprendre_tfidf(store, cvs):
    """TF-IDF appris sur tout le vocabulaire (AVP + CV), sans accents ni mots vides."""
    textes = [texte_embedding(p.avp) for p in store.prepares.values()]
    textes += [t for cv in cvs for t, _ in phrases_du_cv(cv)]
    return TfidfVectorizer(strip_accents="unicode", lowercase=True, stop_words=MOTS_VIDES, token_pattern=r"(?u)\b\w\w+\b",
                           sublinear_tf=True).fit(textes)


def calculer(store, enc, tfidf, cvs) -> dict[str, np.ndarray]:
    """m[système][c, a] = score du CV c pour l'AVP a (ordre de store.prepares), pour chaque système.

    En plus : m["Service, pourcentage"], le pourcentage affiché (sans les savoir-être), qui fixe le libellé."""
    ids = list(store.prepares)
    avec = [i for i in ids if len(store.prepares[i].attendus)]
    m = {n: np.zeros((len(cvs), len(ids))) for n in NOMS + ["Service, pourcentage"]}
    t_avp = tfidf.transform([texte_embedding(store.prepares[i].avp) for i in ids])
    for c, cv in enumerate(cvs):
        ph = phrases_du_cv(cv)
        textes = [t for t, _ in ph]
        calcul = textes_pour_calcul(ph)
        vecs = enc.encoder(calcul)
        v_global = enc.encoder(["\n".join(textes)])[0]
        t_cv = tfidf.transform(["\n".join(textes)])
        t_ph = tfidf.transform(textes)
        rr = scoring.probas_reranker_avps({i: store.prepares[i] for i in avec}, calcul, vecs)
        m["Mots-clés, CV entier"][c] = (t_avp @ t_cv.T).toarray().ravel()
        for a, i in enumerate(ids):
            p = store.prepares[i]
            m["Embeddings, CV entier"][c, a] = float(p.vec_global @ v_global)
            if not len(p.attendus):
                continue
            w = p.poids
            kw = (tfidf.transform([t for t, _ in p.attendus]) @ t_ph.T).toarray().max(axis=1)
            sims = p.vecs_attendus @ vecs.T
            rampe = scoring.degre(sims.max(axis=1))
            proba = rr[i][0]
            service, _ = scoring.couvertures(sims, rr.get(i))
            for nom, d in [("Mots-clés par compétence", kw), ("Embeddings par compétence", rampe),
                           ("Reranker seul", proba), ("Service (embeddings + reranker)", service),
                           ("Service + mots-clés (max)", np.maximum(service, kw)), ("Service + mots-clés (moy.)", (service + kw) / 2)]:
                m[nom][c, a] = float(np.sum(w * d) / w.sum())
            w_sf = w * ~p.savoir_etre
            m["Service, pourcentage"][c, a] = float(np.sum(w_sf * service) / w_sf.sum()) if w_sf.sum() > 0 else 0.0
        print(".", end="", flush=True)
    print()
    return m


def main():
    store, enc = charger()
    ids = list(store.prepares)
    cvs = json.loads((RACINE / "exemples/cv_list.json").read_text(encoding="utf-8"))
    banc = json.loads((RACINE / "exemples/cv_banc.json").read_text(encoding="utf-8"))
    m = calculer(store, enc, apprendre_tfidf(store, cvs + banc), cvs + banc)
    noms = NOMS

    # ---------------------------------------------------------------- jeu de réglage
    attendus = charger_attendus(ids)
    n = len(cvs)
    print(f"\nJEU DE RÉGLAGE : {n} CV (exemples/cv_list.json), {sum(v is not None for v in attendus.values())} avec bon poste connu, "
          f"{sum(v is None for v in attendus.values())} hors domaine ; a servi à régler le service")
    print(f"  {'système':30s} | candidat : 1er   top 3   MRR | recruteur : 1er  MRR | marge   faux positifs")
    for nom in noms:
        print(ligne(nom, mesurer(m[nom][:n], ids, attendus)))

    # ---------------------------------------------------------------- jeu de test
    print(f"\nJEU DE TEST : {len(banc)} CV (exemples/cv_banc.json), jamais utilisés pour régler")
    print(f"  {'système':30s} | poste visé 1er  top 3  MRR | parfaits 1er | pire parfait / bon > meilleur hors domaine ?")
    for nom in noms:
        mt = m[nom][n:]
        rangs, parfaits, ok = [], [], []
        for k, cv in enumerate(banc):
            if not cv["_cible"]:
                continue
            cols = [a for a, i in enumerate(ids) if any(i.startswith(x) for x in cv["_cible"])]
            r = min(1 + int(np.sum(mt[k] > mt[k, a])) for a in cols)
            rangs.append(r)
            if cv["_niveau"] in ("parfait", "bon"):
                parfaits.append(r)
                ok.append(max(mt[k, a] for a in cols))
        hors = [mt[k].max() for k, cv in enumerate(banc) if cv["_niveau"] == "hors"]
        rangs = np.array(rangs)
        print(f"  {nom:30s} | {np.mean(rangs == 1):.2f}           {np.mean(rangs <= 3):.2f}   {np.mean(1 / rangs):.2f} | "
              f"{sum(r == 1 for r in parfaits)}/{len(parfaits)}          | {min(ok):.3f} / {max(hors):.3f} "
              f"{'oui' if min(ok) > max(hors) else 'NON'}")
    print("\nNB : les scores des systèmes n'ont pas la même échelle (TF-IDF, cosinus, moyenne de degrés) : on compare"
          " des rangs et des séparations, pas les valeurs.")


if __name__ == "__main__":
    main()