Affiner le modèle Code GenAI sur le GPU Google Colab T4 : un guide étape par étape

Introduction

La mise au point de grands modèles de langage pour la génération de code nécessite généralement une puissance de calcul importante. De nombreux modèles populaires, tels que Code LLaMA ou CodeT5, exigent des GPU hautes performances comme NVIDIA A100, ce qui les rend moins accessibles pour la plupart des utilisateurs. Cependant, en tirant parti de LoRA (Low-Rank Adaptation) et des techniques de quantification avec des bibliothèques telles que « BitsAndNytes » et « PEFT », vous pouvez affiner Starcoder2 sur une instance gratuite de Google Colab T4.

Ce blog explore comment obtenir des résultats de génération de code de haute qualité sur un matériel limité, ce qui en fait une option abordable pour ceux intéressés par la formation de modèles mais limités par la disponibilité des ressources.

En savoir plus: Comprendre l’IA générative et l’analyse prédictive

Conditions préalables et configuration

Commencez par installer les bibliothèques requises directement dans votre environnement Colab. Les bibliothèques principales utilisées dans ce didacticiel sont les ensembles de données, trl, bitsandbytes et peft.

!pip install -q datasets trl bitsandbytes peft

Ensuite, connectez-vous à Hugging Face pour accéder aux modèles et aux ensembles de données pré-entraînés.

from huggingface_hub import notebook_login

notebook_login()

Chargement du modèle Starcoder2

Nous utiliserons la variante 3B de Starcoder2. Malgré sa taille, en exploitant les bits et octets, nous pouvons le charger avec une précision de 4 bits pour économiser de la mémoire et accélérer l’entraînement.

from transformers import AutoModelForCausalLM, BitsAndBytesConfig
from accelerate import PartialState


bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
)
model = AutoModelForCausalLM.from_pretrained("bigcode/starcoder2-3b",
    quantization_config=bnb_config,
    device_map={"": PartialState().process_index})

Considération clé

• L’utilisation de bnb_4bit_quant_type permet de réduire la consommation de mémoire en utilisant une précision de 4 bits pour les poids du modèle.
• La classe PartialState attribue automatiquement le modèle au périphérique GPU approprié.

Configuration de LoRA (adaptation de bas rang)

from peft import LoraConfig, TaskType

lora_config = LoraConfig(
r=8,
target_modules=[
"q_proj",
"o_proj",
"k_proj",
"v_proj",
"gate_proj",
"up_proj",
"down_proj",
],
task_type="CAUSAL_LM",
)

LoRA est essentiel ici car il nous permet d’affiner le modèle sans modifier l’architecture de base, ce qui est parfait pour les configurations à ressources limitées comme une instance Colab T4.

Chargement et prétraitement des données

Nous utilisons l’ensemble de données BigCode, qui contient des extraits de code, et nous nous concentrons sur le sous-ensemble Python. Vous pouvez ajuster l’ensemble de données selon vos besoins.

from datasets import load_dataset
import pandas as pd

data = load_dataset("bigcode/the-stack-smol", data_dir="data/python", split="train")
pd.DataFrame(data['content']).to_csv('python_code_snippet_custom.csv', index=False)

Pourquoi Python ?

Python reste l’un des langages les plus populaires pour les tâches de génération de code, et la formation d’un modèle sur des extraits de code Python peut apporter des améliorations significatives dans la génération de code précis et optimisé.

Configuration du formateur

Nous utilisons le SFTTrainer (Supervised Fine-Tuning Trainer) de Hugging Face pour gérer le processus de réglage fin.

from trl import SFTTrainer
import transformers

trainer = SFTTrainer(
    model=model,
    train_dataset=data,
    max_seq_length=512,
    args=transformers.TrainingArguments(
        per_device_train_batch_size=1,
        gradient_accumulation_steps=4,
        warmup_steps=100,
        max_steps=100,
        learning_rate=2e-4,
        lr_scheduler_type="cosine",
        weight_decay=0.01,
        bf16=True,
        logging_strategy="steps",
        logging_steps=10,
        output_dir="finetune_starcoder2-3b",
        optim="paged_adamw_8bit",
        seed=0,
    ),
    peft_config=lora_config,
    dataset_text_field="content",

)

Configurations importantes

• Taille du lot : une taille de micro-lot de 1 est utilisée avec une accumulation de gradient pour simuler des tailles de lots plus grandes.
• Planificateur : la planification du taux d’apprentissage du cosinus garantit une convergence plus fluide.
• Optimisation : paged_adamw_8bit est un optimiseur économe en mémoire.

Processus de réglage fin

Une fois la configuration prête, vous pouvez commencer à peaufiner le modèle. Le processus enregistrera automatiquement les résultats toutes les 10 étapes.

print("Training...")
trainer.train()

print("Saving the last checkpoint of the model")
model.save_pretrained("finetune_starcoder2-3b/final_checkpoint/")

étapes de réglage fin

Téléchargez le mode sur huggingface

if args.push_to_hub:
 trainer.push_to_hub("Upload model")

Tester le modèle affiné

Après un réglage fin, vous pouvez charger le modèle pour générer des extraits de code Python basés sur des entrées en langage naturel.

from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import PeftConfig, PeftModel
import torch

config = PeftConfig.from_pretrained("TRV30/finetune_starcoder2-3b")
base_model = "bigcode/starcoder2-3b"
model = AutoModelForCausalLM.from_pretrained(base_model,
    load_in_4bit=True,
    torch_dtype=torch.float16,
    device_map="cuda",
)
model = PeftModel.from_pretrained(model, "hfusername/finetune_starcoder2-3b")
tokenizer = AutoTokenizer.from_pretrained("hfusername/finetune_starcoder2-3b")

Vous pouvez ensuite saisir une question et le modèle générera du code Python en fonction de l’invite :

def generate_python_code(question):

    eval_prompt = f"""You are a powerful code generator model. Your job is to create a code about a module. You are given a question, convert it into a python code.
    ### Input:
    {question}
    ### Response:
    """
    model_input = tokenizer(eval_prompt, return_tensors="pt").to("cuda")
    model.eval()
    with torch.no_grad():
        output = model.generate(
            **model_input,
            max_length=300,
            eos_token_id=tokenizer.eos_token_id,
        )
        response = tokenizer.decode(output[0], skip_special_tokens=True)
        return response.split("### Response:")[-1].strip()

print(generate_python_code('how to load json'))

Sortir:

réglage fin de la sortie

Conclusion

L’avantage unique de cette approche réside dans la mise au point d’un grand modèle de génération de code comme Starcoder2 sur une instance gratuite de Google Colab T4. D’autres modèles, tels que Code LLaMA, nécessitent souvent plus de ressources de calcul, mais avec LoRA et la quantification, vous pouvez obtenir des résultats compétitifs sans avoir besoin d’accéder aux GPU A100 ou à des instances de calcul cloud coûteuses. En vous concentrant sur des optimisations telles que la quantification 4 bits et le réglage efficace des paramètres via LoRA, ce guide vous permet de créer modèles de haute qualité pour des tâches de codage réelles, de manière efficace et abordable.

En savoir plus: Copilote avec Xcode : utilisez genAI pour accélérer votre développement iOS.

Points clés à retenir

• L’instance T4 gratuite de Google Colab est suffisante pour affiner Starcoder2 à l’aide de la quantification et de LoRA.
• LoRA réduit considérablement le besoin de machines à hautes ressources en adaptant des projections spécifiques lors du réglage fin.
• En utilisant des outils tels que « bitsandbytes », le réglage fin des modèles avec une précision de 4 bits réduit considérablement l’utilisation de la mémoire tout en maintenant les performances.

Désormais, vous pouvez facilement adapter et utiliser ce processus pour affiner les modèles pour vos projets de génération de code ! TO THE NEW, un leader des services de technologie numérique permet aux entreprises de tous les secteurs de tirer parti de la pouvoir transformateur de l’IA et du Machine Learning. Notre équipe de plus de 2 000 experts passionnés combine la puissance du Cloud, des données et de l’IA pour concevoir et construire des plateformes numériques innovantes qui ouvrent de nouvelles possibilités. Tendez la main à nous pour vos prochains besoins de projet.