Comment exécuter Alpaca-LoRA sur votre appareil

À mesure que l’IA générative gagne du terrain, les développeurs du monde entier saisissent l’occasion de créer des applications innovantes en langage naturel. Un outil en particulier a récemment attiré beaucoup d’attention : ChatGPT.

ChatGPT est un modèle de langage développé par OpenAI. Son objectif est d’offrir un chatbot dopé à l’IA, capable de dialoguer comme un humain. Bien qu’il soit extrêmement utile, il n’est pas exempt de limites. ChatGPT n’est pas open source : son code n’est pas accessible et ne peut pas être modifié. Il est aussi très gourmand en ressources, ce qui rend peu réaliste toute implémentation maison.

Ces limites ont donné naissance à une série d’alternatives à ChatGPT, comme Alpaca-LoRA, capables d’offrir des fonctionnalités proches, avec une licence open source et des besoins matériels réduits.

Dans ce tutoriel, nous allons nous concentrer sur Alpaca-LoRA : ce que c’est, les prérequis pour l’exécuter sur votre appareil, et les étapes à suivre.

Qu’est-ce qu’Alpaca LoRA ?

Début mars 2023, Eric J. Wang a publié le projet Alpaca-LoRA. Il fournit le code pour reproduire les résultats de Standford Alpaca en utilisant la Parameter-Efficient Fine-Tuning (PEFT) : une bibliothèque qui permet d’affiner des modèles transformeurs avec LoRA.

Comprendre LoRA

La Low-Rank Adaptation des grands modèles de langage (LoRA) est une méthode qui accélère l’entraînement de modèles de grande taille tout en consommant moins de mémoire.

Voici le principe :

• Geler les poids existants. Imaginez le modèle comme un réseau complexe de nœuds interconnectés (les « poids »). Normalement, on ajuste tous ces nœuds pendant l’entraînement. LoRA propose de ne pas y toucher : on les laisse tels quels.
• Ajouter de nouveaux poids. LoRA ajoute ensuite quelques connexions supplémentaires, plus simples (de nouveaux poids), à ce réseau.
• N’entraîner que les nouveaux poids. Plutôt que d’ajuster tout le réseau, on se concentre uniquement sur ces nouvelles connexions plus simples.

Résultat : on gagne du temps et de la mémoire, tout en améliorant les performances du modèle sur ses tâches.

Avantages de LoRA

Parmi les avantages de LoRA :

• Portabilité : les matrices de poids décomposées en rangs contiennent beaucoup moins de paramètres entraînables que le modèle d’origine ; les poids LoRA entraînés sont donc faciles à transporter et peuvent même tourner sur un Raspberry Pi.
• Accessibilité : comparée à un fine-tuning classique, LoRA réduit considérablement l’utilisation de la mémoire GPU ; il devient possible d’affiner un modèle sur des GPU grand public comme les Tesla T4, RTX 3080, voire RTX 2080 Ti.

Alpaca : le modèle open source

Alpaca est un modèle de langage open source, affiné par instruction, basé sur le Large Language Model Meta AI (LLaMA). Il a été développé par une équipe de Stanford pour rendre les grands modèles de langage (LLM) plus accessibles.

C’est là qu’intervient Alpaca-LoRA.

Alpaca-LoRA est une version moins gourmande en ressources du modèle Stanford Alpaca, qui s’appuie sur LoRA pour accélérer l’entraînement tout en consommant moins de mémoire.

Prérequis pour Alpaca-LoRA

Pour exécuter Alpaca-LoRA en local, vous devez disposer d’un GPU. Il peut s’agir d’un GPU modeste comme un NVIDIA T4 ou d’une carte grand public comme une 4090. D’après Eric J. Wang, créateur du projet, le modèle « tourne en quelques heures sur une seule RTX 4090 ».

Remarque : les instructions de cet article reprennent celles du dépôt Alpaca-LoRA d’Eric J. Wang.

Comment exécuter Alpaca-LoRA en 4 étapes

Étape 1 : créer l’environnement virtuel (optionnel)

Les environnements virtuels sont des espaces isolés qui stockent les dépendances Python nécessaires à un projet donné. Ils permettent de séparer les dépendances entre projets, de faciliter le partage et de limiter les conflits.

Ce n’est pas obligatoire pour exécuter Alpaca-LoRA, mais c’est recommandé.

Pour créer un environnement virtuel via l’invite de commandes sous Windows, exécutez :

py -m venv venv

Cela créera un environnement virtuel nommé venv dans votre répertoire de travail actuel.

Remarque : vous pouvez choisir un autre nom en remplaçant le second venv par l’intitulé de votre choix.

Avant d’installer des dépendances, vous devez activer l’environnement virtuel. Lancez la commande suivante :

venv\Scripts\activate.bat

Lorsque vous n’en avez plus besoin, désactivez-le avec :

deactivate

Vous êtes prêt à passer à l’exécution d’Alpaca-LoRA.

Étape 2 : configuration

Commencez par cloner le dépôt depuis GitHub et installez les dépendances nécessaires.

Utilisez la commande suivante pour cloner le dépôt :

git clone https://github.com/tloen/alpaca-lora.git

Accédez ensuite au dossier alpaca-lora que vous venez de cloner :

cd alpaca-lora

Puis installez les dépendances :

pip install -r requirements.txt

Étape 3 : affiner le modèle (optionnel)

Le dépôt alpaca-lora contient un fichier nommé finetune.py. Ce script propose une mise en œuvre simple de la Parameter-Efficient Fine-Tuning (PEFT) appliquée à LLaMA, entre autres.

C’est le fichier à exécuter si vous souhaitez ajuster les hyperparamètres du modèle, mais ce n’est pas indispensable. Selon l’auteur du dépôt, « Sans réglage d’hyperparamètres, le modèle LoRA produit des sorties comparables au modèle Stanford Alpaca. Un réglage plus poussé pourrait améliorer les performances [...]. »

Voici un exemple d’utilisation de finetune.py :

python -m finetune.py \
    --base_model 'decapoda-research/llama-7b-hf' \
    --data_path 'yahma/alpaca-cleaned' \
    --output_dir './lora-alpaca' \
    --batch_size 128 \
    --micro_batch_size 4 \
    --num_epochs 3 \
    --learning_rate 1e-4 \
    --cutoff_len 512 \
    --val_set_size 2000 \
    --lora_r 8 \
    --lora_alpha 16 \
    --lora_dropout 0.05 \
    --lora_target_modules '[q_proj,v_proj]' \
    --train_on_inputs \
    --group_by_length

Étape 4 : exécuter le modèle / inférence

Le dépôt alpaca-lora contient aussi un fichier generate.py. L’exécution de generate.py permet de :

• lire le modèle de base depuis le hub de modèles Hugging Face ;
• charger les poids du modèle depuis tloen/alpaca-lora-7b ;
• démarrer une interface Gradio pour réaliser l’inférence sur une entrée donnée.

Au moment de la rédaction, l’adaptateur Alpaca-LoRA le plus récent utilisé pour l’entraînement est alpaca-lora-7b. Cet entraînement a été effectué le 26 mars 2023 avec la commande suivante :

python finetune.py \
    --base_model='decapoda-research/llama-7b-hf' \
    --num_epochs=10 \
    --cutoff_len=512 \
    --group_by_length \
    --output_dir='./lora-alpaca' \
    --lora_target_modules='[q_proj,k_proj,v_proj,o_proj]' \
    --lora_r=16 \
    --micro_batch_size=8

Si vous souhaitez utiliser un autre adaptateur, exécutez generate.py en indiquant l’emplacement de l’adaptateur de votre choix.

python generate.py \
    --load_8bit \
    --base_model 'decapoda-research/llama-7b-hf' \
    --lora_weights 'tloen/alpaca-lora-7b'

Pour conclure

Alpaca-LoRA est une version allégée en ressources du modèle Stanford Alpaca. Il atteint cet objectif grâce à l’adaptation de rang faible (LoRA) appliquée aux grands modèles de langage, ce qui accélère l’entraînement tout en consommant bien moins de mémoire que le modèle Alpaca d’origine.

Approfondissez les grands modèles de langage (LLM) et l’IA générative avec ces tutoriels :

• Introduction à Meta AI LLaMA
• Comment entraîner un LLM avec PyTorch : guide pas à pas