Les Modèles de Langage à Grande Échelle (LLM) représentent une avancée majeure en intelligence artificielle, dotés d'une capacité remarquable à comprendre et générer du langage humain. Leur potentiel de transformation est immense, impactant des domaines variés tels que le traitement du langage naturel, la traduction automatique, la création de contenu et le service client. Cette puissance suscite un vif intérêt pour l'intégration des LLM dans diverses applications afin d'en décupler la compétitivité. Des problèmes auparavant ardus en PNL deviennent étonnamment simples avec les LLM.

Cependant, l'adoption de LLM commerciaux dans un environnement de production soulève des questions de coût et de confidentialité des données. Les modèles phares comme GPT-4 d'OpenAI ou PaLM 2 de Google, bien que performants, sont onéreux. Le coût par millier de jetons peut rapidement s'accumuler, représentant des milliers de dollars par jour pour une entreprise de taille moyenne avec des interactions fréquentes. De plus, la confidentialité des données est une préoccupation majeure. Malgré les assurances des fournisseurs concernant la non-utilisation des données API pour l'entraînement, la sensibilité de certaines informations rend risquée la dépendance vis-à-vis de services tiers. Enfin, même si les LLM commerciaux sont polyvalents, ils sont entraînés sur des ensembles de données généraux. Pour des comportements ou des réponses spécifiques basés sur des données ou cas d'usage internes, un modèle personnalisé devient indispensable.

Pour contourner ces défis, une solution consiste à opérer un modèle LLM auto-hébergé et entièrement contrôlable. Cette approche permet de définir les politiques de censure et d'adapter les réponses en fonction des connaissances spécifiques de l'entreprise. Cette démarche s'appuie sur le principe du "transfert d'apprentissage" (ou transfer learning), une technique qui permet d'exploiter un modèle pré-entraîné existant et de l'adapter à des besoins particuliers. Nous verrons comment affiner un modèle pour qu'il adopte le comportement désiré, même avec des jeux de données de taille modeste.

Qu'est-ce que le Transfert d'Apprentissage ?

Le transfert d'apprentissage est une méthode en apprentissage automatique qui consiste à réutiliser un modèle déjà entraîné sur une tâche pour résoudre un nouveau problème, souvent dans un domaine différent de celui de l'entraînement initial. Au lieu de partir de zéro, on utilise ce modèle pré-entraîné comme base, ce qui permet d'économiser un temps et des ressources considérables.

Les Modèles de Langage à Grande Échelle (LLM) tels que GPT, BERT, MPT ou XLNet sont des exemples puissants de modèles pré-entraînés. Ils ont été formés sur des volumes massifs de données textuelles, acquérant une connaissance approfondie de la langue. Cependant, leur compréhension de ressources ou de contextes très spécifiques peut être limitée.

L'opération d'affinage (fine-tuning) d'un LLM pré-entraîné adapte ce modèle à une nouvelle tâche en l'entraînant sur un ensemble de données spécifique à cette tâche. Cela implique de mettre à jour les paramètres du modèle pré-entraîné via la rétropropagation. L'idée fondamentale est que le modèle a déjà assimilé de nombreuses structures linguistiques et sémantiques ; il suffit de l'ajuster pour qu'il excelle dans le domaine ou la tâche d'intérêt.

L'affinage d'un LLM pré-entraîné se déroule généralement en trois phases principales :

1. Initialisation du modèle pré-entraîné : La première étape consiste à télécharger et initialiser le LLM pré-entraîné. Cela inclut le chargement de son architecture et des poids appris sur de vastes corpus textuels.
2. Affinage du LLM : Ensuite, le modèle pré-entraîné est ajusté sur un jeu de données plus petit et spécifique à la tâche. Cette phase met à jour les poids du LLM via rétropropagation et descente de gradient, tout en pouvant conserver fixes les poids des couches inférieures du modèle.
3. Évaluation du LLM affiné : Enfin, le modèle est évalué sur un ensemble de test pour déterminer ses performances sur la tâche ciblée.

QLoRA : Affinage Efficace des LLM

Traditionnellement, l'affinage des LLM est un processus gourmand en ressources, nécessitant l'ajustement de nombreux paramètres. Cependant, la communauté open source a développé QLoRA, une méthode d'affinage très efficace qui réduit considérablement l'utilisation de la mémoire. Elle permet d'affiner un modèle de 65 milliards de paramètres sur un seul GPU de 48 Go, tout en maintenant les performances d'un affinage en 16 bits.

La famille de modèles Guanaco a été la première à être entraînée avec QLoRA. Ces modèles ont surpassé tous les modèles précédemment publiés sur le benchmark Vicuna, atteignant une performance comparable à 99,3% de ChatGPT, avec seulement 24 heures d'affinage sur un GPU unique.

Comparé aux mois et aux millions de dollars nécessaires pour entraîner des modèles comme GPT, QLoRA représente un avantage considérable. Nous choisirons donc d'utiliser la technique d'affinage QLoRA. Plutôt que d'explorer en profondeur les mécanismes techniques de QLoRA, nous nous concentrerons sur son application pour atteindre nos objectifs d'entraînement.

Sélection du Modèle de Base Approprié

Conformément à notre approche, nous n'allons pas entraîner un LLM à partir de zéro, mais plutôt utiliser la méthode d'affinage QLoRA pour enrichir un modèle de base généraliste existant avec nos capacités spécifiques.

Deux options principales s'offrent à nous pour le choix d'un modèle de base :

1. Utiliser un modèle GPT via API : Les modèles GPT sont parmi les plus performants, et OpenAI propose une API d'affinage robuste. Cependant, pour les raisons de confidentialité et de coût évoquées précédemment, cette option n'est pas retenue ici.
2. Choisir un modèle LLM open source : La communauté open source innove constamment et propose des centaines de modèles performants, certains rivalisant avec GPT. Bien qu'aucun modèle open source n'atteigne encore intrinsèquement le niveau des meilleurs GPT, un affinage ciblé peut permettre de dépasser leurs performances sur des tâches spécifiques.

Pour cette voie, Hugging Face est une ressource incontournable. Cette plateforme a développé des outils, des bibliothèques et des modèles open source populaires pour les passionnés de PNL et d'IA. Leur bibliothèque Transformers sert de fondation à de nombreux LLM. De plus, Hugging Face anime une communauté dynamique qui a considérablement fait progresser l'apprentissage automatique et l'intelligence artificielle.

Hugging Face met à disposition un classement des meilleurs modèles LLM open source, consultable à l'adresse suivante :
https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard

Le classement Hugging Face évalue les LLM selon plusieurs benchmarks et une moyenne agrégée. Voici les benchmarks principaux :

• ARC (AI Reasoning Challenge) : Un ensemble de 7787 questions de niveau élémentaire pour évaluer les capacités de connaissance et de raisonnement.
• HellaSwag : Teste la capacité d'inférence de langage de bon sens. Un score élevé indique une meilleure compréhension du sens et de l'intention du langage.
• MMLU (Massive Multitask Language Understanding) : Comprend 57 tâches couvrant divers domaines (mathématiques, histoire américaine, informatique, droit, etc.). Nécessite une vaste connaissance générale et des compétences en résolution de problèmes.
• TruthfulQA : 817 questions dans 38 catégories (santé, droit, finance, politique, etc.) pour évaluer la véracité des réponses du modèle.

Vous pouvez trier ce classement en fonction de la métrique la plus pertinente pour votre tâche. Par exemple, si votre application implique beaucoup de raisonnement, le score ARC pourrait être prioritaire. En général, les modèles performants excellent sur tous les benchmarks. Un tri par la moyenne globale est souvent suffisant pour la plupart des cas d'usage.

Outre les benchmarks, trois autres aspects sont à considérer :

1. Modèles "Instruct" : Certains modèles, comme falcon-40b-instruct, sont spécifiquement entraînés pour les instructions/conversations. Ils sont moins adaptés à un entraînement ou un affinage ultérieur pour d'autres tâches.
2. Taille du modèle : Les LLM sont constitués de couches et de paramètres. Plus il y a de paramètres, plus le modèle est complexe. Les modèles plus petits sont plus faciles à affiner et moins coûteux à exécuter. Un modèle de 6,5 milliards de paramètres nécessite environ 48 Go de mémoire GPU ou plus. Il est conseillé de choisir le modèle le plus petit qui répond à vos besoins.
3. Licence : Comme pour tout logiciel, il est crucial de vérifier les conditions d'utilisation. Pour les trouver, cliquez sur le modèle dans le classement et cherchez la section "License". Les modèles sur Hugging Face sont souvent utilisables à des fins de recherche. Les modèles basés sur Llama interdisent généralement l'usage commercial. La famille de modèles "falcon" est publiée sous la licence Apache 2.0, ce qui en fait un bon point de départ pour les applications commerciales.

Principes de Sélection de Modèle

• Utiliser le classement Hugging Face et trier par la moyenne des benchmarks.
• Exclure les modèles "Instruct".
• Vérifier la licence et sa compatibilité avec votre usage commercial.
• Privilégier les modèles avec moins de paramètres pour faciliter l'entraînement et réduire les coûts.

Bien que le classement des LLM évolue constamment, les modèles Falcon restent une excellente option open source. Ils sont disponibles en deux tailles (40 milliards et 7 milliards de paramètres), affichent d'excellents résultats de benchmark et sont publiés sous la licence Apache 2.0, favorable aux applications commerciales. Plus précisément, le modèle Falcon-7b offre un excellent compromis entre performance et coût, ce qui en fait un choix judicieux et économiquement viable.

Préparation des Données d'Entraînement du Modèle

Une fois le modèle de base choisi, l'étape suivante, souvent la plus complexe, la plus chronophage et la plus cruciale, est la sélection des données d'entraînement. La qualité des données fournies au LLM influence directement la qualité des résultats obtenus. Pour comprendre le type de données à préparer, il faut d'abord appréhender le processus d'entraînement du modèle.

À un niveau élevé, l'entraînement consiste à fournir au modèle de base des exemples de conversations, incluant des questions et des réponses. Le modèle apprendra ainsi le type de dialogue attendu et la forme des réponses souhaitées.

Par exemple, si vous souhaitez que le modèle rédige des textes de style "réseau social viral", vous lui fournirez des questions d'utilisateurs et des exemples de réponses parfaites dans ce style.

Entrée	Sortie
Créer un post viral sur la mode pour un réseau social.	<Insérer un texte rédigé dans le style viral souhaité>
Rédiger un post accrocheur pour présenter un tutoriel maquillage.	<Insérer un texte rédigé dans le style viral souhaité>
Écrire un post divertissant pour recommander les derniers lieux de restauration branchés.	<Insérer un texte rédigé dans le style viral souhaité>

Exemples de données pour l'affinage de posts de réseaux sociaux.

Si vous voulez entraîner votre modèle à devenir un chatbot expert en Q&A, fournissez des exemples de questions d'utilisateurs et les réponses correspondantes.

Entrée	Sortie
Quelles sont les principales responsabilités d'un chef de produit ?	Les principales responsabilités d'un chef de produit incluent la planification, la conception et la promotion du produit. Il collabore avec les équipes de développement, de design et de marketing pour s'assurer que le produit répond aux besoins des utilisateurs et atteint le succès commercial.
Quelles compétences sont essentielles pour un chef de produit ?	Un chef de produit doit posséder une expertise technique, des compétences en analyse de marché, des techniques de gestion de projet et des connaissances en conception d'expérience utilisateur. De plus, la communication, la résolution de problèmes et le leadership sont des compétences indispensables.
Comment collecter efficacement les besoins produits ?	Pour une collecte efficace des besoins produits, diverses méthodes peuvent être employées : entretiens en face à face, enquêtes auprès des utilisateurs, analyse concurrentielle et analyse de données. Il est crucial de maintenir une communication étroite avec les utilisateurs et les parties prenantes pour que les exigences du produit reflètent précisément les besoins du marché.

Exemples de données pour l'affinage d'un chatbot Q&A.

Combien d'Exemples de Données Faut-il Préparer ?

Il n'existe pas de règle universelle pour le nombre d'exemples requis, mais quelques directives peuvent être utiles :

• Pour des tâches simples, comme un chatbot FAQ, une centaine d'exemples peuvent suffire.
• Pour des tâches et des sorties plus complexes, davantage d'exemples sont nécessaires. Par exemple, si vous souhaitez modifier le style d'écriture du modèle pour qu'il imite un auteur spécifique, vous pourriez avoir besoin de milliers d'exemples.
• En général, plus il y a d'exemples non redondants, mieux c'est, mais sans excès. Pour de nombreuses tâches, quelques centaines d'exemples peuvent être suffisants.

Il n'est pas nécessaire de couvrir toutes les questions ou interactions possibles. Le LLM doit simplement pouvoir "identifier et comprendre" l'intention générale de vos exemples et trouver des réponses appropriées pour des questions similaires, même si elles ne sont pas exactement identiques.

Comment Créer un Jeu de Données ?

Selon la tâche d'entraînement, plusieurs approches semi-automatiques peuvent être envisagées pour créer votre jeu de données :

1. Pour un chatbot FAQ, exportez les questions les plus fréquentes de votre système et les réponses fournies par votre équipe de support client, au format Excel ou CSV.
2. Pour un modèle capable de répondre à la plupart des questions de votre base de connaissances, utilisez un modèle existant (comme GPT-4) pour générer automatiquement des questions et des réponses. Divisez votre base de connaissances en fragments de 3000 mots maximum, puis envoyez ces fragments à un modèle comme GPT-3.5-16k en lui demandant de créer des questions que de nouveaux utilisateurs pourraient poser. Enfin, fusionnez toutes les sorties pour obtenir un ensemble de données unique. Ce processus peut être fortement automatisé par script, générant des milliers de questions et réponses en quelques minutes.
3. Il existe peut-être déjà des jeux de données prédéfinis pertinents pour votre cas d'usage. Le Hugging Face Dataset Hub est un excellent point de départ, proposant plus de 42 000 jeux de données. Ses puissantes fonctions de filtrage et de recherche vous aideront à trouver ce qu'il vous faut.

Quel Format pour les Données ?

L'un des atouts des LLM est leur capacité à comprendre le langage humain sans être contraints par des structures de données rigides. Par conséquent, votre jeu de données d'entraînement n'a pas besoin de respecter des exigences de format strictes. Cependant, l'expérience montre qu'une bonne pratique est d'utiliser un jeu de données simple à deux colonnes : une pour la question ou le prompt, l'autre pour la réponse idéale, comme illustré précédemment.

Ce format est privilégié pour sa simplicité et parce que la séparation claire entre les deux colonnes permet de le formater aisément pour les étapes d'entraînement ultérieures. Cette flexibilité est essentielle pour s'adapter aux différents besoins de traitement et d'entraînement des données.

Choix de l'Environnement d'Entraînement du Modèle

Une fois le modèle de base sélectionné et le jeu de données préparé, il est temps de choisir l'environnement pour l'entraînement. Bien que l'entraînement puisse se faire sur n'importe quelle machine, un GPU performant accélère considérablement le processus. Certaines méthodes d'entraînement modernes nécessitent même un GPU, car l'exécution sur CPU serait prohibitive en temps. Nous avons donc besoin d'un GPU, idéalement de NVIDIA avec son architecture CUDA, qui est la plus répandue. La mémoire du GPU est également un facteur clé.

Voici un aperçu des options GPU en fonction de l'échelle :

• Petits GPU : Comme les GPU de la série RTX de Nvidia, adaptés au développement, aux tests et aux projets à petite échelle ou expérimentaux. Ils ont généralement moins de 24 Go de mémoire.
• GPU moyens : Tels que le Nvidia A40, parfaits pour les projets de taille moyenne à grande. Ils offrent un équilibre entre coût et puissance de calcul, souvent idéaux pour la plupart des tâches d'entraînement de LLM, avec environ 48 Go de mémoire.
• Grands GPU : Comme le Nvidia A100, essentiels pour les tâches d'entraînement massives et gourmandes en mémoire, comme celles requises par les LLM. Ces GPU sont coûteux, mais l'accélération de l'entraînement dans les projets critiques en vaut souvent la peine. Le modèle A100 phare offre 80 Go de mémoire.
• Clusters de GPU : Si les options précédentes ne suffisent pas, les frameworks d'entraînement modernes permettent d'utiliser plusieurs GPU en parallèle pour charger et entraîner des LLM gigantesques.

D'après cette liste, nous devons choisir un GPU adapté à notre modèle et à notre budget. La plupart des modèles ne spécifient pas la taille de mémoire d'entraînement requise, ce qui en fait un processus d'essai et erreur. Voici quelques estimations pour l'entraînement avec QLoRA :

• Un modèle de 7 milliards de paramètres peut être entraîné sur un GPU avec 12 Go de mémoire.
• Un modèle de 30 milliards de paramètres est adapté à un GPU avec 24 Go de mémoire.
• Un modèle de 65 milliards de paramètres peut être entraîné sur un GPU avec 48 Go de mémoire.

Choisissez le GPU en fonction de vos exigences d'entraînement et de votre budget.

Où Obtenir ces GPU ?

Plusieurs options s'offrent à vous, du gratuit au coûteux :

• Google Colab : Une plateforme Jupyter Notebook gratuite de Google. Nos scripts d'entraînement étant en Python, c'est un excellent choix. Colab offre des ressources matérielles puissantes ; les utilisateurs gratuits ont accès à un GPU NVIDIA T4 avec 12 Go de RAM, suffisant pour entraîner des modèles de 7 milliards de paramètres. Des plans payants (environ 12 $ par mois) donnent accès à du matériel plus performant et plus de mémoire.
• RunPod : Un fournisseur de GPU NVIDIA à la demande, offrant des tarifs horaires très attractifs. Lancer une machine virtuelle compatible GPU est simple, avec accès SSH, une console web puissante et un serveur Jupyter préinstallé. Bien que non gratuit, RunPod propose des tarifs GPU abordables et une grande facilité d'utilisation.
• Fournisseurs de services cloud : Les grands fournisseurs comme Azure, GCP et AWS proposent tous des machines virtuelles avec GPU. Ils sont généralement plus complexes à utiliser pour l'entraînement de modèles que Colab ou RunPod, et vous n'aurez peut-être pas besoin de faire tourner une machine en continu.
• Serveur auto-hébergé : Acheter un GPU et l'opérer chez vous ou en entreprise. Cela représente un investissement initial conséquent (un NVIDIA RTX 3080, considéré comme le minimum pour un entraînement LLM sérieux, coûte environ 1000 $, un A100 environ 4000 $). Cependant, si vous prévoyez de nombreuses opérations d'entraînement, cela peut s'avérer rentable à long terme.

Pour la plupart des tâches, l'entraînement ne nécessite qu'un ou deux jours de GPU haute performance. Les solutions de location sont donc souvent plus économiques.

Dans cet article, nous utiliserons Google Colab pour entraîner un modèle de 7 milliards de paramètres. Nous opterons pour Colab Pro, car nous aurons besoin de plus de 13 Go de mémoire système (la limite de mémoire du Colab gratuit est de 13 Go).

Démarrer l'Entraînement de votre Modèle LLM

Une fois l'environnement d'entraînement configuré, nous pouvons commencer. Assurez-vous de disposer d'un GPU dédié avec au moins 13 Go de mémoire GPU, accessible via l'une des méthodes mentionnées précédemment. Vous aurez également besoin de 16 Go de mémoire système et d'un environnement Python 3.9+ pour exécuter le code d'entraînement.

1. Installation des Dépendances Requises

pip install -qqq bitsandbytes
pip install -qqq datasets

# Nous utilisons une version spécifique de transformers pour contourner un bug de la branche principale actuelle
pip install -qqq git+https://github.com/huggingface/transformers@de9255de27abfcae4a1f816b904915f0b1e2
pip install -qqq git+https://github.com/huggingface/peft.git
pip install -qqq git+https://github.com/huggingface/accelerate.git

pip install -qqq einops
pip install -qqq scipy

2. Importation des Modules Nécessaires

import bitsandbytes as bnb
import torch
import torch.nn as nn
import transformers
from datasets import load_dataset

from peft import LoraConfig, PeftConfig, get_peft_model, prepare_model_for_kbit_training
from transformers import AutoTokenizer, BitsAndBytesConfig, AutoModelForCausalLM

3. Initialisation du Modèle

nom_modele = "tiiuae/falcon-7b"
config_bnb = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_use_double_quant=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16
)

modele = AutoModelForCausalLM.from_pretrained(
    nom_modele,
    trust_remote_code=True,
    quantization_config=config_bnb,
    device_map="auto"
)

• nom_modele : Le nom exact du modèle à utiliser, tel que trouvé sur Hugging Face.
• load_in_4bit : Charge le modèle en mode de quantification 4 bits, essentiel pour l'entraînement avec une mémoire GPU limitée. La technique QLoRA permet de le faire sans perte de performance.
• bnb_4bit_quant_type : Spécifie le type de quantification, soit fp4 (float point 4) ou nf4 (NormalFloat), le type de virgule flottante spécifique à QLoRA.
• bnb_4bit_compute_dtype : Définit le type de calcul, qui peut différer du type d'entrée (par exemple, entrée en fp32, calcul en bf16 pour l'accélération). Pour QLoRA, utilisez bfloat16.
• trust_remote_code : Nécessaire pour charger le modèle Falcon, car il exécute du code spécifique (configuration_RW.py et modelling_RW.py) pour s'adapter à l'interface Transformers.
• device_map : Affecte la charge de travail au GPU. Réglé sur auto pour une répartition optimale des ressources.

4. Initialisation du Tokeniseur

tokeniseur = AutoTokenizer.from_pretrained(nom_modele)
tokeniseur.pad_token = tokeniseur.eos_token

• AutoTokenizer : Une classe de l'API Hugging Face Transformers qui crée automatiquement l'instance de tokeniseur correcte pour l'architecture de votre modèle.
• pad_token : Un jeton spécial utilisé pour ajuster la taille des tableaux de jetons afin de permettre le traitement par lots. Nous le définissons sur le jeton de fin de phrase (eos_token).

5. Activation du Gradient Checkpointing et Préparation

modele.gradient_checkpointing_enable()
modele = prepare_model_for_kbit_training(modele)

• Gradient Checkpointing : Une technique qui réduit l'utilisation de la mémoire lors de l'entraînement de réseaux neuronaux profonds, au prix d'une légère augmentation du temps de calcul.
• prepare_model_for_kbit_training : Cette méthode encapsule l'ensemble du protocole de préparation du modèle avant d'exécuter un entraînement par affinage efficace en paramètres (PEFT), dont QLoRA est une méthode.

6. Initialisation de la Configuration d'Entraînement LoRA

config_lora = LoraConfig(
    r=8,
    lora_alpha=32,
    target_modules=["query_key_value"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)
modele = get_peft_model(modele, config_lora)

• r, lora_alpha, et lora_dropout sont des hyperparamètres LoRA ajustables. Pour la famille Falcon, ces paramètres sont souvent un bon point de départ.
• task_type : Décrit le type de modélisation linguistique (causale ou masquée). Pour les Transformers comme GPT, Llama ou Falcon, il s'agit d'une modélisation causale.
• target_modules : Les modules du modèle Transformer qui doivent être entraînés avec QLoRA. D'après la littérature, il s'agit presque toujours des modules de requête/clé/valeur (query/key/value).

Chargement du Jeu de Données

L'étape suivante consiste à charger le jeu de données. Le module datasets de Hugging Face offre la méthode pratique load_dataset pour charger des données à partir d'un chemin local ou du Hugging Face Dataset Hub. Cette méthode divise également le jeu de données en caractéristiques, prêtes pour l'entraînement.

Pour cet entraînement, nous utiliserons un célèbre jeu de données FAQ d'e-commerce, contenant des informations sur un produit hypothétique. Le fichier original est disponible sur Kaggle. J'ai adapté le fichier pour qu'il corresponde au format de paires question/réponse décrit précédemment. Le fichier JSON contient les informations suivantes :

[{
  "question": "Comment puis-je créer un compte ?",
  "answer": "Pour créer un compte, cliquez sur le bouton [S'inscrire] en haut à droite du site web et suivez le processus."
},...]

Si vous souhaitez suivre cet exemple, téléchargez le jeu de données préparé depuis datascienceengineer.com/datasets/ecommerce_faq.json. Vous pouvez aussi utiliser votre propre jeu de données, en respectant le format.

# Charge le fichier JSON et le convertit en caractéristiques d'entraînement
donnees = load_dataset("json", data_files="ecommerce_faq.json")

Nous allons ensuite ajouter un format d'invite à notre jeu de données. Le modèle doit être entraîné à reconnaître le style d'invite qu'il rencontrera en production. Nous utiliserons donc les préfixes <human> pour nos questions et <assistant> pour nos réponses.

def generer_invite(question_reponse):
    return f"""
<human>: {question_reponse["question"]}
<assistant>: {question_reponse["answer"]}
    """.strip()

def tokeniser_invite(question_reponse):
    invite = generer_invite(question_reponse)
    invite_tokenise = tokeniseur(invite, padding=True, truncation=True)
    return invite_tokenise

# Utilise shuffle pour réorganiser la liste et éliminer les biais de tri potentiels
donnees_invite = donnees["train"].shuffle().map(tokeniser_invite)

Configuration et Exécution de l'Entraînement

Nous arrivons à la dernière étape : configurer l'entraîneur et lancer l'entraînement du modèle.

Les paramètres de l'objet Trainer ci-dessous sont des hyperparamètres qui peuvent (et devraient) être ajustés pour obtenir de meilleurs résultats. Pour l'entraînement du modèle falcon-7b, ces paramètres se sont avérés efficaces sur divers jeux de données. Pour d'autres types de modèles, des ajustements pourraient être nécessaires.

Consultez la documentation de l'API Hugging Face Trainer pour plus de détails : huggingface.co/transformers/v3.0.2/main_classes/trainer.html

entraineur = transformers.Trainer(
    model=modele,
    train_dataset=donnees_invite,
    args=transformers.TrainingArguments(
        per_device_train_batch_size=1,
        gradient_accumulation_steps=4,
        num_train_epochs=1,
        warmup_ratio=0.05,
        max_steps=80,
        learning_rate=2e-4,
        fp16=True,
        logging_steps=1,
        output_dir="sorties",
        optim="paged_adamw_8bit",
        lr_scheduler_type="cosine"
    ),
    data_collator=transformers.DataCollatorForLanguageModeling(tokeniseur, mlm=False),
)

modele.config.use_cache = False
entraineur.train()

Lors de l'ajustement des paramètres du modèle, ne modifiez pas le paramètre optim="paged_adamw_8bit". Il s'agit d'une technique d'optimisation qui prévient les pics de mémoire, évitant ainsi la surcharge de la mémoire GPU.

Le paramètre max_steps ne doit pas être beaucoup plus élevé que le nombre de lignes dans votre jeu de données d'entraînement. Surveillez la perte d'entraînement pour déterminer s'il doit être réduit ou augmenté.

Après quelques minutes, votre modèle est entraîné avec succès ! Enregistrez-le sur le disque.

modele.save_pretrained("mon-falcon")

Le paramètre (ici, "mon-falcon") détermine le chemin du dossier où vos fichiers de modèle seront stockés.

Inférence du Modèle

Maintenant que notre modèle est créé et enregistré, voyons comment le charger et l'interroger.

Tout d'abord, chargeons la configuration et le modèle :

# Charge la configuration LoRA de notre modèle affiné
config_lora = PeftConfig.from_pretrained('mon-falcon')

# Instancie une classe de modèle Transformer, inférée automatiquement à partir de notre modèle
modele_personnalise = AutoModelForCausalLM.from_pretrained(
    config_lora.base_model_name_or_path,
    return_dict=True,
    quantization_config=config_bnb, # Utilisez la même config bnb que pour l'entraînement
    device_map="auto",
    trust_remote_code=True,
    load_in_8bit=True # Ce réglage peut réduire la quantification à 8 bits pour accélérer l'inférence et réduire l'empreinte mémoire
)

tokeniseur = AutoTokenizer.from_pretrained(config_lora.base_model_name_or_path)
tokeniseur.pad_token = tokeniseur.eos_token

# Instancie un modèle LoRA basé sur la configuration et les poids LoRA
modele_personnalise = PeftModel.from_pretrained(modele_personnalise, "mon-falcon")

Ensuite, créons l'invite. Rappelez-vous que nous avons spécifiquement entraîné notre LLM à utiliser la syntaxe d'invite <human>: / <assistant>:. Nous l'inclurons donc dans l'invite. (Ce n'est pas une exigence stricte, car les LLM peuvent généralement déduire les rôles. Cependant, puisque nous l'avons inclus dans l'entraînement, les performances pourraient être meilleures en l'incluant également dans l'invite.)

invite = f"""
<human>: Comment puis-je créer un compte ?
<assistant>:
""".strip()

Configurons les paramètres d'inférence du modèle :

config_generation = modele_personnalise.generation_config
config_generation.temperature = 0
config_generation.top_p = 0.7
config_generation.max_new_tokens = 200
config_generation.num_return_sequences = 1
config_generation.pad_token_id = tokeniseur.eos_token_id
config_generation.eos_token_id = tokeniseur.eos_token_id

• temperature : Entre 0 et 1, détermine la "créativité" de la sortie. Une valeur plus élevée rend les réponses plus variées pour des questions similaires ; une valeur plus faible rend la sortie plus déterministe.
• top_p : Entre 0 et 1, contrôle le nombre de jetons suivants considérés. Par exemple, si réglé sur 0.5, seuls les 50% des jetons les plus probables seront pris en compte.
• max_new_tokens : Nombre maximal de nouveaux jetons à générer.
• num_return_sequences : Nombre de séquences candidates à retourner pour chaque entrée.

Préparons ensuite les entrées du modèle avec notre invite et envoyons les tenseurs au périphérique d'inférence (ici, "cuda:0" pour le GPU).

entrees = tokeniseur(invite, return_tensors="pt").to("cuda:0")

Enfin, effectuons l'inférence :

with torch.inference_mode():
    sorties = modele_personnalise.generate(
        input_ids=entrees.input_ids,
        attention_mask=entrees.attention_mask,
        generation_config=config_generation,
        do_sample=False,
        use_cache=True
    )

print(tokeniseur.decode(sorties[0], skip_special_tokens=True))

Votre modèle prendra quelques secondes pour générer les jetons, en utilisant les données d'affinage sur lesquelles il a été entraîné.

Le transfert d'apprentissage et le framework QLoRA offrent des outils puissants pour exploiter efficacement les LLM pré-entraînés afin de résoudre des tâches spécifiques. En choisissant un modèle de base LLM approprié, évalué selon des benchmarks pertinents, nous assurons des performances optimales pour notre travail d'affinage.

La génération de données d'entraînement de haute qualité est essentielle car elle permet de capturer les nuances spécifiques de la tâche cible. Nous avons vu le format recommandé et constaté qu'une quantité massive de données n'est pas toujours nécessaire ; quelques centaines d'exemples peuvent suffire.

Grâce aux bibliothèques Hugging Face Transformer et PEFT, nous avons affiné le LLM de base pour qu'il s'adapte spécifiquement à la tâche désirée. Enfin, en réalisant une inférence avec le LLM affiné, nous pouvons déployer un modèle de langage performant capable de faire des prédictions précises et de générer des informations précieuses dans des applications concrètes.