Humaneval: une référence pour évaluer les capacités de génération de code LLM

Humaneval: Évaluation de la génération de code avec pass @ k

Ce tutoriel explore Humaneval, une référence OpenAI pour évaluer les capacités de génération de code de modèle de grande langue (LLM), en se concentrant sur la métrique pass@k. Nous utiliserons l'écosystème de face étreint pour évaluer le modèle codeparrot-small sur 164 problèmes Python. Cela fournit une évaluation pratique et fonctionnelle de l'exactitude, contrastant avec les mesures traditionnelles de texte-similitude.

Image par auteur

Comprendre le passage @ k

Humaneval utilise une approche d'exactitude fonctionnelle, mesurant la probabilité qu'au moins un des échantillons de code générés au moins k résout correctement un problème. Ceci est plus pertinent que la simple correspondance de texte, reflétant les tests de développeurs du monde réel.

La formule pass@k est: 1 - c (n-c, k) / c (n, k)

où:

• n: échantillons générés totaux.
• c: nombre d'échantillons corrects.
• k: Nombre d'échantillons supérieurs considérés.

La formule calcule la probabilité que tous les échantillons k soient incorrects, puis soustrait cela de 1 pour obtenir la probabilité d'au moins un échantillon correct. Des scores plus élevés pass@k indiquent de meilleures performances de génération de code. Les classements utilisent souvent pass@10 et pass@100.

Évaluation humaineVal avec le visage étreint

Cette section détaille le processus d'évaluation à l'aide de la bibliothèque evaluate de Hugging Face. Nous utiliserons le modèle codeparrot-small plus petit pour une évaluation plus rapide.

1. Configuration:

Installez la bibliothèque nécessaire:

pip install evaluate

Définir les variables d'environnement:

import os
os.environ["HF_ALLOW_CODE_EVAL"] = "1"
os.environ["TOKENIZERS_PARALLELISM"] = "false"

2. Chargement de données et métrique:

Chargez l'ensemble de données openai_humaneval et la métrique code_eval:

from datasets import load_dataset
from evaluate import load
human_eval = load_dataset("openai_humaneval")['test']
code_eval_metric = load("code_eval")

3. Modèle de chargement et jetons:

Chargez le modèle codeparrot/codeparrot-small et le tokenizer:

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch
model_name = "codeparrot/codeparrot-small"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)
model.eval()

4. Réglage des tokenzer:

Assurez-vous que le tokenizer a pad_token_id et eos_token_id, redimensionner les incorporations du modèle si nécessaire:

if tokenizer.pad_token_id is None: tokenizer.pad_token_id = 0
if tokenizer.eos_token_id is None: tokenizer.eos_token_id = 2
if tokenizer.pad_token is None: tokenizer.add_special_tokens({'pad_token': '<pad>'})
if tokenizer.eos_token is None: tokenizer.add_special_tokens({'eos_token': ''})
if len(tokenizer) > model.config.vocab_size: model.resize_token_embeddings(len(tokenizer))</pad>

5. Génération de code:

Générer 5 échantillons de code par problème (164 problèmes totaux):

num_samples_per_problem = 5
test_cases = []
candidates = []
for problem in tqdm(human_eval, desc="Problems", unit="problem"):
    prompt = problem['prompt']
    test_code = problem['test']
    test_cases.append(test_code)
    problem_candidates = []
    for _ in range(num_samples_per_problem):
        inputs = tokenizer(prompt, return_tensors="pt").to("cuda" if torch.cuda.is_available() else "cpu")
        with torch.no_grad():
            outputs = model.generate(input_ids=inputs['input_ids'], attention_mask=inputs['attention_mask'], max_length=512, do_sample=True, temperature=0.7, top_p=0.95, num_return_sequences=1, pad_token_id=tokenizer.pad_token_id, eos_token_id=tokenizer.eos_token_id)
        generated_code = tokenizer.decode(outputs[0], skip_special_tokens=True)
        generated_code = generated_code[len(prompt):]
        problem_candidates.append(generated_code)
    candidates.append(problem_candidates)

6. Pass de calcul @ k:

calculer pass@1 et pass@5:

pip install evaluate

La sortie affichera les scores pass@1 et pass@5, indiquant les performances du modèle. N'oubliez pas que les résultats peuvent varier en raison de la nature stochastique de la génération de code. La comparaison de ces résultats à ceux des modèles plus puissants (comme GPT-4) fournit un contexte pour les capacités du modèle codeparrot-small. Une analyse plus approfondie pourrait impliquer d'explorer différents hyperparamètres ou d'utiliser des techniques de génération de code plus sophistiquées.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!