Tutoriel Llama.cpp : Un guide complet pour l'inférence et l'implémentation efficaces de LLM

Qu'est-ce que Llama.cpp ?

LLaMa.cpp a été développé par Georgi Gerganov. Il implémente l'architecture LLaMa de Meta en C/C++ efficace, et c'est l'une des communautés open-source les plus dynamiques autour de l'inférence LLM avec plus de 390 contributeurs, 43000+ étoiles sur le dépôt officiel GitHub, et 930+ versions.

Quelques avantages clés de l'utilisation de LLama.cpp pour l'inférence LLM

• Compatibilité universelle : La conception de Llama.cpp en tant que bibliothèque C++ centrée sur le processeur signifie moins de complexité et une intégration transparente dans d'autres environnements de programmation. Cette large compatibilité a accéléré son adoption sur différentes plateformes.

• Intégration complète des fonctionnalités : Agissant comme un référentiel pour les fonctionnalités critiques de bas niveau, Llama.cpp reflète l'approche de LangChain pour les capacités de haut niveau, rationalisant le processus de développement, bien qu'il y ait des défis potentiels d'extensibilité.

• Optimisation ciblée : Llama.cpp se concentre sur un modèle unique d'architecture, ce qui permet des améliorations précises et efficaces. Son engagement en faveur des modèles lamas par le biais de formats tels que GGML et GGUF a permis de réaliser des gains d'efficacité substantiels.

Avec cette compréhension de Llama.cpp, les sections suivantes de ce tutoriel passent en revue le processus de mise en œuvre d'un cas d'utilisation de génération de texte. Nous commençons par explorer les bases de LLama.cpp, en comprenant le déroulement global du projet et en analysant certaines de ses applications dans différentes industries.

Architecture Llama.cpp

L'épine dorsale de Llama.cpp est le modèle original de Llama, qui est également basé sur l'architecture des transformateurs. Les auteurs de Llama tirent parti de diverses améliorations qui ont été proposées par la suite et utilisent différents modèles tels que PaLM.

Différence entre les transformateurs et l'architecture des lamas (Architecture des lamas par Umar Jamil)

La principale différence entre l'architecture LLaMa et celle des transformateurs :

• Pré-normalisation (GPT3) : utilisée pour améliorer la stabilité de l'apprentissage en normalisant l'entrée de chaque sous-couche de transformateur à l'aide de l'approche RMSNorm, au lieu de normaliser la sortie.
• Fonction d'activation SwigGLU (PaLM) : la fonction d'activation non linéaire ReLU d'origine est remplacée par la fonction d'activation SwiGLU, ce qui permet d'améliorer les performances.
• Encastrements rotatifs (GPTNeao) : les encastrements positionnels rotatifs (RoPE) ont été ajoutés à chaque couche du réseau après avoir supprimé les encastrements positionnels absolus.

Mise en place de l'environnement

Les conditions préalables pour commencer à travailler avec LLama.cpp sont les suivantes :

• PythonPour les autres pays de l'Union européenne, vous pouvez utiliser le logiciel pip, qui est le gestionnaire de paquets de Python.
• Llama-cpp-python: le binding Python pour llama.cpp

Créer l'environnement virtuel

Il est recommandé de créer un environnement virtuel pour éviter tout problème lié au processus d'installation, et conda peut être un bon candidat pour la création d'un environnement.

Toutes les commandes de cette section sont exécutées à partir d'un terminal. En utilisant l'instruction conda create, nous créons un environnement virtuel appelé llama-cpp-env.

conda create --name llama-cpp-env

Après avoir créé avec succès l'environnement virtuel, nous l'activons à l'aide de l'instruction conda activate, comme suit :

conda activate llama-cpp-env

L'instruction ci-dessus doit afficher le nom de la variable d'environnement entre crochets au début du terminal, comme suit :

Nom de l'environnement virtuel après activation

Nous pouvons maintenant installer le paquetage Llama-cpp-python comme suit :

pip install llama-cpp-python
or
pip install llama-cpp-python==0.1.48

L'exécution réussie du site llama_cpp_script.py signifie que la bibliothèque est correctement installée.

Pour nous assurer que l'installation est réussie, créons et ajoutons la déclaration import, puis exécutons le script.

• Tout d'abord, ajoutez le from llama_cpp import Llama au fichier llama_cpp_script.py, puis
• Lancez le programme Python llama_cpp_script.py pour exécuter le fichier. Une erreur est générée si la bibliothèque ne parvient pas à être importée ; elle doit donc faire l'objet d'un diagnostic plus approfondi pour le processus d'installation.

Comprendre les bases de Llama.cpp

A ce stade, le processus d'installation devrait être réussi, et nous allons nous plonger dans la compréhension des bases de LLama.cpp.

La classe Llama importée ci-dessus est le constructeur principal utilisé lors de l'utilisation de Llama.cpp, et elle prend plusieurs paramètres qui ne sont pas limités aux suivants. La liste complète des paramètres est fournie dans la documentation officielle :

• model_path: Le chemin d'accès au fichier du modèle Llama utilisé
• rapide : L'invite d'entrée du modèle. Ce texte est symbolisé et transmis au modèle.
• l'appareil : Le dispositif à utiliser pour exécuter le modèle Llama ; il peut s'agir d'un processeur ou d'un processeur graphique.
• max_tokens: Le nombre maximum de jetons à générer dans la réponse du modèle.
• s'arrêter : Une liste de chaînes de caractères qui entraîneront l'arrêt du processus de génération du modèle.
• température : Cette valeur est comprise entre 0 et 1. Plus la valeur est faible, plus le résultat final est déterministe. D'autre part, une valeur plus élevée conduit à plus d'aléatoire, et donc à une production plus diversifiée et plus créative.
• top_p : Est utilisé pour contrôler la diversité des prédictions, ce qui signifie qu'il sélectionne les tokens les plus probables dont la probabilité cumulée dépasse un seuil donné. En partant de zéro, une valeur plus élevée augmente les chances de trouver un meilleur résultat, mais nécessite des calculs supplémentaires.
• écho : Un booléen utilisé pour déterminer si le modèle inclut l'invite originale au début (True) ou ne l'inclut pas (False).

Par exemple, si nous voulons utiliser un grand modèle de langage appelé <MY_AWESOME_MODEL> stocké dans le répertoire de travail actuel, le processus d'instanciation se déroulera comme suit :

# Instanciate the model
my_aweseome_llama_model = Llama(model_path="./MY_AWESOME_MODEL")


prompt = "This is a prompt"
max_tokens = 100
temperature = 0.3
top_p = 0.1
echo = True
stop = ["Q", "\n"]


# Define the parameters
model_output = my_aweseome_llama_model(
       prompt,
       max_tokens=max_tokens,
       temperature=temperature,
       top_p=top_p,
       echo=echo,
       stop=stop,
   )
final_result = model_output["choices"][0]["text"].strip()

Le code est explicite et peut être facilement compris à partir des points initiaux indiquant la signification de chaque paramètre.

Le résultat du modèle est un dictionnaire contenant la réponse générée ainsi que quelques métadonnées supplémentaires. Le format de sortie est étudié dans les sections suivantes de l'article.

Votre premier projet Llama.cpp

Il est maintenant temps de commencer à mettre en œuvre le projet de génération de texte. Pour démarrer un nouveau projet Llama.cpp, il suffit de suivre le modèle de code Python ci-dessus qui explique toutes les étapes, depuis le chargement du grand modèle linguistique d'intérêt jusqu'à la génération de la réponse finale.

Le projet s'appuie sur la version GGUF du Zephyr-7B-Beta de Hugging Face. Il s'agit d'une version affinée de mistralai/Mistral-7B-v0.1 qui a été entraînée sur un ensemble d'ensembles de données synthétiques accessibles au public à l'aide de l'optimisation directe des préférences (DPO).

Notre introduction à l'utilisation des transformateurs et de Hugging Face permet de mieux comprendre les transformateurs et d'exploiter leur puissance pour résoudre des problèmes de la vie réelle. Nous avons également un tutoriel sur le Mistral 7B.

Modèle Zephyr de Hugging Face(source)

Une fois le modèle téléchargé localement, nous pouvons le déplacer vers l'emplacement du projet dans le dossier model. Avant de plonger dans la mise en œuvre, il convient de comprendre la structure du projet :

La structure du projet

La première étape consiste à charger le modèle à l'aide du constructeur Llama. Comme il s'agit d'un modèle de grande taille, il est important de spécifier la taille maximale du contexte du modèle à charger. Dans ce projet spécifique, nous utilisons 512 jetons.

from llama_cpp import Llama


# GLOBAL VARIABLES
my_model_path = "./model/zephyr-7b-beta.Q4_0.gguf"
CONTEXT_SIZE = 512


# LOAD THE MODEL
zephyr_model = Llama(model_path=my_model_path,
                    n_ctx=CONTEXT_SIZE)

Une fois le modèle chargé, l'étape suivante est la phase de génération du texte, en utilisant le modèle de code original, mais nous utilisons une fonction d'aide appelée generate_text_from_prompt.

def generate_text_from_prompt(user_prompt,
                             max_tokens = 100,
                             temperature = 0.3,
                             top_p = 0.1,
                             echo = True,
                             stop = ["Q", "\n"]):




   # Define the parameters
   model_output = zephyr_model(
       user_prompt,
       max_tokens=max_tokens,
       temperature=temperature,
       top_p=top_p,
       echo=echo,
       stop=stop,
   )


   return model_output

Dans la clause __main__, la fonction peut être exécutée à l'aide d'une invite donnée.

if __name__ == "__main__":


   my_prompt = "What do you think about the inclusion policies in Tech companies?"


   zephyr_model_response = generate_text_from_prompt(my_prompt)


   print(zephyr_model_response)

La réponse du modèle est fournie ci-dessous :

La réponse du modèle

La réponse générée par le modèle est et la réponse exacte du modèle est mise en évidence dans la boîte orange.

• L'invite originale comporte 12 jetons
• Les jetons de réponse ou d'achèvement ont 10 jetons et,
• Le total des jetons est la somme des deux jetons ci-dessus, soit 22.

Même si cette sortie complète peut être utile pour une utilisation ultérieure, il se peut que nous ne soyons intéressés que par la réponse textuelle du modèle. Nous pouvons formater la réponse pour obtenir un tel résultat en sélectionnant le champ “text” de l'élément "choices” " comme suit :

final_result = model_output["choices"][0]["text"].strip()

La fonction strip() est utilisée pour supprimer les espaces blancs de début et de fin d'une chaîne de caractères et le résultat est le suivant :

Tech companies want diverse workforces to build better products.

Llama.CPP Applications dans le monde réel

Cette section présente une application réelle de LLama.cpp et fournit le problème sous-jacent, la solution possible et les avantages de l'utilisation de Llama.cpp.

Problème

Imaginez ETP4Africa, une startup technologique qui a besoin d'un modèle linguistique capable de fonctionner efficacement sur différents appareils pour son application éducative, sans causer de retards.

Solution avec Llama.cpp

Ils implémentent Llama.cpp, profitant de ses performances optimisées pour le processeur et de sa capacité à s'interfacer avec leur backend basé sur Go.

Avantages

• Portabilité et rapidité : La conception légère de Llama.cpp garantit des réponses rapides et la compatibilité avec de nombreux appareils.
• Personnalisation : Des fonctions de bas niveau adaptées permettent à l'application de fournir une aide au codage en temps réel de manière efficace.

L'intégration de Llama.cpp permet à l'application ETP4Africa d'offrir des conseils de programmation immédiats et interactifs, améliorant ainsi l'expérience et l'engagement de l'utilisateur.

L'ingénierie des données est un élément clé de tout projet de science des données et d'IA, et notre tutoriel Introduction à LangChain pour l'ingénierie des données et les applications de données fournit un guide complet pour inclure l'IA à partir de grands modèles de langage dans les pipelines de données et les applications.

Conclusion

En résumé, cet article a fourni une vue d'ensemble complète de la configuration et de l'utilisation de grands modèles de langage avec LLama.cpp.

Des instructions détaillées ont été fournies pour comprendre les bases de Llama.cpp, mettre en place l'environnement de travail, installer la bibliothèque requise et mettre en œuvre un cas d'utilisation de génération de texte (question-réponse).

Enfin, des aperçus pratiques ont été fournis pour une application réelle et la manière dont Llama.cpp peut être utilisé pour résoudre efficacement le problème sous-jacent.

Prêt à plonger plus profondément dans le monde des grands modèles linguistiques ? Améliorez vos compétences avec les puissants frameworks d'apprentissage profond LangChain et Pytorch utilisés par les professionnels de l'IA grâce à nos tutoriels Comment construire des applications LLM avec LangChain et Comment entraîner un LLM avec PyTorch.