Tutoriel simplifié pour exécuter des LLMs (Llama 3) localement avec llama.cpp

Exécuter des LLM localement llama.cpp Llama 3 Windows MAC OS

Avec l’essor des modèles de langage de grande taille (LLMs) en open-source, la capacité à les exécuter efficacement sur des appareils locaux devient une véritable révolution. Ce guide explore l’utilisation de llama.cpp, une bibliothèque open-source en C++ qui permet d’exécuter des LLMs comme Llama 3 localement. Que vous soyez un développeur ou un passionné d’apprentissage automatique, ce tutoriel étape par étape vous aidera à démarrer avec llama.cpp, une bibliothèque facile à installer qui optimise l’inférence LLM sur votre matériel, qu’il s’agisse d’un ordinateur de bureau ou d’une infrastructure basée sur le cloud.

Ce qu’il vous faut pour commencer

Avant de plonger dans les détails, il est important de vérifier que votre matériel est prêt. Pour suivre ce guide, il est recommandé d’avoir au moins 8 Go de VRAM. Cependant, llama.cpp offre une flexibilité avec des optimisations, notamment en ce qui concerne la quantification des modèles, que nous aborderons plus tard.

Ce tutoriel fonctionne avec des modèles comme Llama-3–8B-Instruct, mais vous pouvez choisir d’autres modèles disponibles sur Hugging Face.

Comprendre llama.cpp

Alors, qu’est-ce que llama.cpp ? Il s’agit essentiellement d’une bibliothèque légère en C++ conçue pour simplifier le processus d’exécution des LLMs localement. Elle permet une inférence efficace sur différents types de matériel, allant des ordinateurs de bureau de base aux serveurs cloud haute performance.

Avec llama.cpp, vous bénéficierez de plusieurs fonctionnalités :

  • Performances de pointe : Il offre une inférence à la pointe de la technologie pour les modèles de grande taille.
  • Installation facile : L’installation de llama.cpp est simple et ne nécessite aucune dépendance externe.
  • Support de quantification : Il réduit la taille des modèles en les convertissant en une précision plus faible, aidant à exécuter les modèles sur des appareils avec une mémoire limitée.
  • Compatibilité multiplateforme : Il fonctionne sur MacOS, Windows et Linux, avec prise en charge de Docker et FreeBSD.
  • Utilisation efficace des ressources : llama.cpp tire pleinement parti des ressources CPU et GPU, rendant possible l’inférence hybride.

Les défis que vous pourriez rencontrer

Bien que llama.cpp soit un outil incroyable, il n’est pas sans défis :

  • Documentation limitée : Étant open-source, la documentation disponible peut parfois être insuffisante. Cependant, la communauté active est une excellente ressource.
  • Expertise technique : Configurer et exécuter des modèles, en particulier avec des configurations personnalisées, peut être un peu complexe, surtout pour les utilisateurs novices en C++ ou en infrastructure de machine learning.

Guide d’installation étape par étape

Voyons maintenant le processus d’installation et de configuration pour que vous puissiez démarrer avec llama.cpp et le modèle Llama 3.

1. Cloner le dépôt

Tout d’abord, vous devez télécharger le dépôt llama.cpp depuis GitHub. Vous pouvez le faire avec les commandes suivantes :

$ git clone https://github.com/ggerganov/llama.cpp
$ cd llama.cpp

2. Construire llama.cpp

Ensuite, vous devrez construire le projet. Le processus de compilation varie légèrement selon que vous utilisez MacOS ou Windows.

Pour MacOS, avec le support Metal, exécutez :

$ make llama-server

Ou utilisez CMake :

$ cmake -B build
$ cmake --build build --config Release

Pour Windows, avec le support CUDA, les commandes sont légèrement différentes :

C:\Users\Bob> make llama-server LLAMA_CUDA=1

Ou avec CMake :

C:\Users\Bob> cmake -B build -DLLAMA_CUDA=ON
C:\Users\Bob> cmake --build build --config Release

Vous pouvez également télécharger une version précompilée sur la page officielle des releases :

Page des Releases de LLAMA CPP

Une fois terminé, vous êtes prêt à commencer à utiliser le modèle.

Télécharger et préparer le modèle

Dans cet exemple, nous allons utiliser le modèle Meta-Llama-3–8B-Instruct, bien que vous puissiez l’adapter à tout autre modèle de votre choix.

1. Installer le CLI Hugging Face

Pour commencer, installez l’interface de ligne de commande Hugging Face :

$ pip install -U "huggingface_hub[cli]"

Créez un compte sur Hugging Face si vous n’en avez pas déjà un, et générez votre jeton d’accès à partir de la page des paramètres. Vous en aurez besoin pour accéder aux modèles.

2. Se connecter à Hugging Face

Connectez-vous avec vos identifiants Hugging Face :

$ huggingface-cli login

Une fois connecté, acceptez les conditions du modèle Llama-3–8B-Instruct et attendez l’approbation d’accès.

3. Télécharger le modèle

Vous avez deux options principales pour télécharger le modèle : non quantifié ou quantifié GGUF.

  • Option 1 : Modèle non quantifié

Pour télécharger le modèle non quantifié :

$ huggingface-cli download meta-llama/Meta-Llama-3-8B-Instruct --exclude "original/*"  --local-dir models/Meta-Llama-3-8B-Instruct

Après le téléchargement, vous devrez installer les dépendances Python et convertir le modèle au format GGUF :

$ python -m pip install -r requirements.txt
$ python convert-hf-to-gguf.py models/Meta-Llama-3-8B-Instruct
  • Option 2 : Modèle quantifié

Si vous avez des contraintes matérielles, vous pouvez télécharger une version quantifiée directement :

$ huggingface-cli download path_to_gguf_model --exclude "original/*" --local-dir models/Meta-Llama-3-8B-Instruct

Utiliser la quantification pour optimiser le matériel

La quantification vous permet d’exécuter des modèles sur des appareils avec moins de mémoire, comme des systèmes avec moins de 16 Go de VRAM. En réduisant la précision des poids des modèles de 16 bits à 4 bits, vous économisez beaucoup de mémoire sans sacrifier trop de performances.

Pour quantifier le modèle :

$ ./llama-quantize ./models/Meta-Llama-3-8B-Instruct/ggml-model-f16.gguf ./models/Meta-Llama-3-8B-Instruct/ggml-model-Q4_K_M.gguf Q4_K_M

Cela produira un modèle quantifié prêt pour l’inférence locale.

Exécuter le serveur llama

Une fois votre modèle configuré, vous pouvez lancer le llama-server pour gérer les requêtes HTTP, vous permettant d’interagir avec le modèle à l’aide d’API standard.

Pour MacOS :

$ ./llama-server -m models/Meta-Llama-3-8B-Instruct/ggml-model-Q4_K_M.gguf -c 2048

Sous Windows, utilisez :

C:\Users\Bob> llama-server.exe -m models\\Meta-Llama-3-8B-Instruct\\ggml-model-Q4_K_M.gguf -c 2048

Vous pouvez maintenant commencer à envoyer des requêtes à http://localhost:8080.

Créer un chatbot en Python

Vous pouvez également créer un chatbot Python simple pour interagir avec votre modèle. Voici un script de base pour envoyer des requêtes au serveur llama :

import requests
import json
def get_response(server_url, messages, temperature=0.7, max_tokens=4096, stream=True):
    data = {
        "messages": messages,
        "temperature": temperature,
        "max_tokens": max_tokens,
        "stream": stream,
    }
    response = requests.post(f"{server_url}/v1/chat/completions", json=data)
    return response.json()
def chatbot(server_url):
    messages = [{"role": "system", "content": "You are a helpful assistant."}]
    while True:
        user_input = input("You: ")
        if user_input.lower() == "exit":
            break
        messages.append({"role": "user", "content": user_input})
        print("Assistant: ", get_response(server_url, messages))
if __name__ == "__main__":
    chatbot("http://localhost:8080")

Ce script simple crée un chatbot qui communique avec le serveur llama pour générer des réponses.

Conclusion :

L’utilisation de llama.cpp pour exécuter des modèles de langage de grande taille comme Llama 3 localement peut être une solution puissante et efficace, en particulier lorsque des performances d’inférence élevées sont requises. Malgré sa complexité, llama.cpp offre une flexibilité avec une prise en charge multiplateforme, la quantification et l’accélération matérielle. Bien que cela puisse représenter un défi pour les débutants, sa communauté croissante et ses fonctionnalités étendues en font un choix de premier plan pour les développeurs et les chercheurs.

Pour ceux qui sont prêts à s’investir, llama.cpp offre d’innombrables possibilités pour l’inférence de LLMs localement ou dans le cloud.

Laisser un commentaire