Intermédiaire
🧠 Fondamentaux
20 XP
0 personnes ont réussi
Évaluer avant et après fine-tuning
Fine-tuner un modèle sans l'évaluer, c'est comme cuisiner sans goûter. Comment tu sais si c'est mieux qu'avant ? Il faut comparer les réponses du modèle de base et du modèle fine-tuné sur les mêmes questions, puis mesurer la qualité.
En production, l'évaluation se fait souvent avec un "juge" (un LLM plus puissant qui note les réponses) ou avec des métriques automatiques. Ici on va simuler avec une approche simple : on compare les réponses générées avec des réponses attendues en utilisant la similarité textuelle.
La similarité qu'on va utiliser est basique mais efficace pour une première évaluation : le pourcentage de mots de la réponse attendue qu'on retrouve dans la réponse générée.
Un score de 1.0 signifie que tous les mots attendus sont présents. Un score de 0.5 signifie que la moitié manque.
Écris une fonction evaluer_modeles(test_set, reponses_base, reponses_ft) qui prend : 1. test_set : une liste de dicts avec "question" et "reponse_attendue" 2. reponses_base : une liste de chaînes (réponses du modèle de base) 3. reponses_ft : une liste de chaînes (réponses du modèle fine-tuné)
La fonction renvoie un dictionnaire avec "score_base" (moyenne des scores du modèle de base), "score_ft" (moyenne du fine-tuné), "amelioration" (score_ft - score_base) et "details" (liste de dicts avec question, score_base, score_ft pour chaque exemple). Tous les scores sont arrondis à 2 décimales.
Exemple :
tests = [{"question": "Que fait le chat ?", "reponse_attendue": "le chat noir mange"}] base = ["je ne sais pas"] ft = ["le chat noir dort"] evaluer_modeles(tests, base, ft) renvoie {"score_base": 0.0, "score_ft": 0.75, "amelioration": 0.75, "details": [...]}
Tests (4/5)
Fine-tuné meilleur
tests = [{'question': 'Q', 'reponse_attendue': 'le chat est noir'}]
base = ['je sais pas']
ft = ['le chat est noir et blanc']
r = evaluer_modeles(tests, base, ft)
assert r['score_ft'] > r['score_base']
assert r['amelioration'] > 0
Réponse parfaite
tests = [{'question': 'Q', 'reponse_attendue': 'bonjour le monde'}]
base = ['bonjour le monde']
ft = ['bonjour le monde']
r = evaluer_modeles(tests, base, ft)
assert r['score_base'] == 1.0
assert r['score_ft'] == 1.0
assert r['amelioration'] == 0.0
Plusieurs questions
tests = [
{'question': 'Q1', 'reponse_attendue': 'python est super'},
{'question': 'Q2', 'reponse_attendue': 'django est un framework'}
]
base = ['python est nul', 'flask est cool']
ft = ['python est super bien', 'django est un framework web']
r = evaluer_modeles(tests, base, ft)
assert len(r['details']) == 2
assert r['score_ft'] > r['score_base']
Détails par question
tests = [{'question': 'Test', 'reponse_attendue': 'a b c d'}]
base = ['a b']
ft = ['a b c d']
r = evaluer_modeles(tests, base, ft)
assert r['details'][0]['question'] == 'Test'
assert r['details'][0]['score_base'] == 0.5
assert r['details'][0]['score_ft'] == 1.0
+ 0 tests cachés
Indices (3 disponibles)
Solution officielle
def evaluer_modeles(test_set, reponses_base, reponses_ft):
def similarite(attendue, generee):
mots_attendus = set(attendue.lower().split())
mots_generee = set(generee.lower().split())
if not mots_attendus:
return 1.0
return len(mots_attendus & mots_generee) / len(mots_attendus)
details = []
total_base = 0
total_ft = 0
for i, test in enumerate(test_set):
attendue = test["reponse_attendue"]
s_base = round(similarite(attendue, reponses_base[i]), 2)
s_ft = round(similarite(attendue, reponses_ft[i]), 2)
total_base += s_base
total_ft += s_ft
details.append({
"question": test["question"],
"score_base": s_base,
"score_ft": s_ft,
})
n = len(test_set) if test_set else 1
score_base = round(total_base / n, 2)
score_ft = round(total_ft / n, 2)
return {
"score_base": score_base,
"score_ft": score_ft,
"amelioration": round(score_ft - score_base, 2),
"details": details,
}