Introduction
La génération de texte est devenue une capacité révolutionnaire, transformant la façon dont les machines interprètent et produisent du texte semblable à celui des humains. Cette popularité croissante a conduit au développement de nombreux outils conçus pour simplifier et améliorer le travail avec les LLM.
L’expansion rapide des grands modèles de langage, avec de nouvelles versions apparaissant presque chaque semaine, a entraîné une augmentation concomitante des options d’hébergement pour soutenir cette technologie. Parmi les nombreux outils disponibles, Text Generation Inference (TGI) de Hugging Face se démarque, nous permettant d’exécuter un LLM en tant que service sur nos machines locales.
Ce guide explorera pourquoi Hugging Face TGI est une innovation significative et comment vous pouvez l’utiliser pour développer des modèles d’IA sophistiqués capables de générer du texte de plus en plus indiscernable de l’écriture humaine.
Qu’est-ce que Hugging Face Text Generation Inference ?
Hugging Face Text Generation Inference (TGI) est un cadre écrit en Rust et Python pour déployer et servir les grands modèles de langage. C’est une boîte à outils prête pour la production conçue à cet effet.
Hugging Face développe et distribue TGI sous la licence HFOILv1.0, autorisant une utilisation commerciale tant qu’il fonctionne comme un outil auxiliaire dans le produit ou service, plutôt que d’en être la fonctionnalité principale. Les principaux défis qu’il résout sont :
Principales fonctionnalités de Hugging Face Text Generation Inference (TGI)
1. Génération de texte haute performance
— TGI utilise des techniques comme le parallélisme tensoriel, qui distribue les grands modèles sur plusieurs GPU, et le regroupement dynamique, qui regroupe les invites à la volée dans le serveur, pour optimiser les performances des LLM open source populaires, notamment StarCoder, BLOOM, GPT-NeoX, Llama et T5.
2. Utilisation efficace des ressources
— TGI utilise le regroupement continu, du code optimisé et le parallélisme tensoriel pour gérer plusieurs requêtes simultanément tout en minimisant l’utilisation des ressources.
3. Flexibilité et sécurité
— TGI prend en charge diverses fonctionnalités de sécurité, telles que le tatouage numérique (watermarking), la déformation logit (modification des logits de tokens spécifiques en y injectant une valeur de biais) et les séquences d’arrêt, pour garantir une utilisation responsable et contrôlée des LLM.
Hugging Face a optimisé l’architecture de certains LLM pour qu’ils fonctionnent plus rapidement avec TGI, y compris des modèles populaires comme LLaMA, Falcon7B et Mistral. Une liste complète des modèles pris en charge se trouve dans leur documentation.
Pourquoi utiliser Hugging Face TGI ?
Hugging Face est devenu la plateforme de référence pour développer l’IA avec des capacités de langage naturel. Elle héberge une multitude de modèles open source de premier plan, ce qui en fait un moteur d’innovation en PNL. Traditionnellement, ces modèles étaient trop volumineux pour être exécutés localement, nécessitant le recours à des services cloud.
Cependant, les récentes avancées dans les techniques de quantification comme QLoRa et GPTQ ont rendu certains LLM gérables sur des appareils du quotidien, y compris les ordinateurs locaux.
Hugging Face TGI est spécifiquement conçu pour permettre l’exécution de LLM en tant que service sur des machines locales. Cette approche résout le problème du démarrage d’un LLM en maintenant le modèle prêt en arrière-plan pour des réponses rapides, évitant les longues attentes pour chaque invite. Imaginez avoir un point d’accès avec une collection de modèles de langage de premier plan prêts à générer du texte à la demande.
Ce qui distingue TGI, c’est sa mise en œuvre simple. Il prend en charge diverses architectures de modèles simplifiées, rendant le déploiement rapide et facile.
De plus, TGI alimente déjà plusieurs projets en production. Voici quelques exemples :
- Hugging Chat, une interface open source pour les modèles en accès libre.
- OpenAssistant, une initiative communautaire open source pour l’entraînement des LLM.
- nat.dev, une plateforme d’exploration et de comparaison des LLM.
Il y a toutefois une limitation notable : TGI n’est pas encore compatible avec les Mac à GPU ARM, y compris la série M1 et les modèles ultérieurs.
Configuration de Hugging Face TGI
Tout d’abord, configurez le point d’accès Hugging Face TGI.
Pour installer et exécuter Hugging Face TGI localement, commencez par installer Rust. Ensuite, mettez en place un environnement virtuel Python avec Python version 3.9 ou supérieure, par exemple en utilisant conda :
Installation de Rust
curl --proto ‘=https’ --tlsv1.2 -sSf https://sh.rustup.rs | sh
Création d’un environnement virtuel Python
conda create -n text-generation-inference python=3.9
conda activate text-generation-inference
De plus, il est essentiel d’installer Protoc. Hugging Face recommande d’utiliser la version 21.12 pour une meilleure compatibilité. Veuillez noter que vous aurez besoin des privilèges sudo pour effectuer cette installation.
PROTOC_ZIP=protoc-21.12-linux-x86_64.zip
curl -OL https://github.com/protocolbuffers/protobuf/releases/download/v21.12/$PROTOC\_ZIP
sudo unzip -o $PROTOC_ZIP -d /usr/local bin/protoc
sudo unzip -o $PROTOC_ZIP -d /usr/local ‘include/*’
rm -f $PROTOC_ZIP
Tout d’abord, je vais décrire le processus d’installation à partir de zéro, qui peut ne pas être simple. Si vous rencontrez des problèmes au cours de ce processus, vous pouvez passer directement à l’utilisation d’une image Docker, ce qui est plus simple. Les deux scénarios seront abordés.
Une fois toutes les conditions préalables remplies, nous pouvons procéder à la configuration de TGI. Commencez par cloner le dépôt GitHub :
git clone https://github.com/huggingface/text-generation-inference.git
Ensuite, accédez au répertoire TGI sur votre machine locale et installez-le à l’aide des commandes suivantes :
cd text-generation-inference/
BUILD_EXTENSIONS=False make install
Voyons maintenant comment utiliser TGI, avec et sans Docker. Pour la démonstration, j’utiliserai le modèle Falcon-7B, sous licence Apache 2.0.
Lancer un modèle sans Docker
Le processus d’installation a généré une nouvelle commande, text-generation-launcher, qui démarre le serveur TGI. Pour activer un point d’accès avec le modèle Falcon-7B, exécutez simplement la commande suivante :
text-generation-launcher --model-id tiiuae/falcon-7b-instruct --num-shard 1 --port 8080 --quantize bitsandbytes
Voici la signification de chaque paramètre d’entrée :
model-id: Il s’agit du nom spécifique du modèle tel qu’il apparaît sur le Hub Hugging Face. Dans notre cas, pour Falcon-7B, il s’agit de « tiiuae/falcon-7b-instruct ».num-shard: Ajustez ce paramètre en fonction du nombre de GPU disponibles. La valeur par défaut est 1.port: Ceci spécifie le port sur lequel le serveur écoutera les requêtes. Le port par défaut est 8080.quantize: Pour les utilisateurs disposant de GPU avec moins de 24 Go de VRAM, la quantification du modèle est nécessaire pour éviter une surcharge mémoire. Dans les commandes précédentes, « bitsandbytes » est sélectionné pour une quantification immédiate. Une autre option, « GPTQ » (« gptq »), est également disponible, bien que son fonctionnement soit moins familier.
Applications de TGI
Il existe plusieurs façons d’intégrer le serveur Text Generation Inference (TGI) dans vos applications. Une fois qu’il est opérationnel, vous pouvez interagir avec lui en envoyant une requête POST au point d’accès /generate pour obtenir des résultats.
Si vous optez pour le streaming continu de tokens avec TGI, utilisez plutôt le point d’accès, comme illustré dans la section suivante. Ces requêtes peuvent être effectuées à l’aide de votre outil préféré, tel que curl, Python ou TypeScript. Pour interroger le modèle servi par TGI avec un script Python, vous devez installer la bibliothèque text-generation suivante. Vous pouvez le faire facilement en exécutant la commande pip suivante :
pip install text-generation
Après avoir lancé le serveur TGI, créez une instance de InferenceClient() avec l’URL pointant vers le point d’accès du modèle. Ensuite, vous pouvez invoquer text_generation() pour envoyer des requêtes au point d’accès en utilisant Python.
from text_generation import Client
client = Client("http://127.0.0.1:8080")
client.text_generation(prompt="Votre invite ici !")
Pour activer le streaming avec InferenceClient, définissez simplement stream=True. Cela vous permettra de recevoir les tokens en temps réel au fur et à mesure qu’ils sont générés sur le serveur. Voici comment utiliser le streaming :
for token in client.text_generation("Votre invite ici !", max_new_tokens=12, stream=True):
print(token)
Interroger un modèle via TGI
Gardez à l’esprit que vous allez interagir avec le modèle déployé sur votre point d’accès, qui dans notre cas est Falcon-7B. Grâce à TGI, nous établissons un point d’accès en direct qui facilite l’obtention de réponses du LLM choisi.
Ainsi, avec Python, les invites peuvent être envoyées directement au LLM via le client hébergé sur notre appareil local, accessible via le port 8080. Par conséquent, le script Python correspondant ressemblerait à ceci :
from text_generation import Client
client = Client("http://127.0.0.1:8080")
print(client.generate("Traduis la phrase suivante en espagnol : « Que signifie Large Language Model ? »", max_new_tokens=500).generated_text)
Nous recevrons une réponse du modèle sans avoir besoin de l’installer dans notre environnement. Plutôt que d’utiliser Python, nous pouvons interroger le LLM avec CURL, comme dans l’exemple suivant :
curl 127.0.0.1:8080/generate \
-X POST \
-d '{"inputs":"Code en Javascript une fonction pour supprimer tous les espaces dans une chaîne puis afficher la chaîne deux fois.","parameters":{"max_new_tokens":500}}' \
-H 'Content-Type: application/json'
Après avoir expérimenté avec TGI, il démontre une vitesse impressionnante. Avec Falcon-7B (avec une limite de 500 tokens), cela ne prend que quelques secondes. En revanche, l’approche d’inférence classique avec la bibliothèque transformers nécessite environ 30 secondes.
Intégration avec novita.ai à l’aide du LLM de novita.ai
À partir de la version 1.4.0, TGI a introduit une API compatible avec l’API LLM de novita.ai. Cette nouvelle API Messages permet une transition transparente pour les clients et les utilisateurs des modèles novita.ai vers les LLM open source. L’API est conçue pour une intégration directe avec les bibliothèques clientes de novita.ai ou avec des outils tiers comme LangChain ou LlamaIndex.
La prise en charge des Messages par TGI garantit que ses points d’accès d’inférence sont entièrement compatibles avec l’API LLM de novita.ai. Cette compatibilité permet aux utilisateurs de remplacer facilement tous les scripts existants qui utilisaient des modèles novita.ai par des LLM ouverts hébergés sur des points d’accès TGI, sans aucune difficulté.
Cette mise à niveau facilite le changement, donnant un accès immédiat aux nombreux avantages des modèles open source, notamment :
- Contrôle et transparence complets concernant les modèles et les données.
- Élimination des préoccupations liées aux limites de taux.
- Flexibilité pour adapter les systèmes afin de répondre à des exigences uniques.
Un exemple d’intégration de TGI dans le protocole de complétion de chat de novita.ai est fourni ci-dessous :
from openai import OpenAI
client = OpenAI(
base_url="https://api.novita.ai/v3/openai",
# Obtenez la clé API NovitaAI en vous référant à : https://novita.ai/get-started/Quick_Start.html#_3-create-an-api-key
api_key="<VOTRE CLÉ API NovitaAI>",
)
model = "meta-llama/llama-3-8b-instruct"
stream = True # ou False
max_tokens = 512
chat_completion_res = client.chat.completions.create(
model=model,
messages=[
{
"role": "system",
"content": "Agis comme un assistant utile.",
},
{
"role": "user",
"content": "Bonjour !",
}
],
stream=stream,
max_tokens=max_tokens,
)
if stream:
for chunk in chat_completion_res:
print(chunk.choices[0].delta.content or "", end="")
else:
print(chat_completion_res.choices[0].message.content)
Comme vous pouvez le voir, la bibliothèque novita.ai peut être utilisée pour spécifier notre POINT D’ACCÈS et notre mot de passe Hugging Face. Pour plus d’informations sur cette intégration, référez-vous à la documentation Hugging Face TGI.
Conseils pratiques lors de l’utilisation de TGI
Concepts de base des LLM
Avant de plonger dans HuggingFace TGI, il est important d’avoir une bonne compréhension des grands modèles de langage. Familiarisez-vous avec des concepts clés tels que la tokenisation, les mécanismes d’attention et l’architecture Transformer. Ces fondamentaux sont essentiels pour adapter les modèles et améliorer les résultats de génération de texte.
Préparation et optimisation des modèles — comprendre Hugging Face
Apprenez à préparer et optimiser les modèles pour vos besoins spécifiques. Cela implique de sélectionner le modèle approprié, de personnaliser les tokeniseurs et d’appliquer des techniques pour améliorer les performances sans compromettre la qualité.
Familiarisez-vous avec le fonctionnement de HuggingFace et l’utilisation de son Hub pour le développement en PNL. Un bon point de départ est le tutoriel « An Introduction to Using Transformers and Hugging Face ».
Comprendre le concept de fine-tuning est également essentiel, car les modèles ont souvent besoin d’être optimisés pour des objectifs spécifiques. Vous pouvez apprendre à fine-tuner un modèle avec le guide « An Introductory Guide to Fine-Tuning LLMs ».
Stratégies de génération
Examinez différentes approches de génération de texte, notamment la recherche gloutonne (greedy search), la recherche par faisceau (beam search) et l’échantillonnage top-k. Chaque méthode a ses avantages et ses inconvénients, affectant la cohérence, la créativité et la pertinence du texte généré.
Conclusion
La boîte à outils TGI de Hugging Face permet aux individus d’explorer la génération de texte par IA. Elle fournit une boîte à outils conviviale pour déployer et héberger des LLM destinés à des applications de PNL sophistiquées nécessitant un texte semblable à celui des humains.
Bien que l’auto-hébergement de grands modèles de langage offre la confidentialité des données et le contrôle des coûts, il nécessite un matériel robuste. Néanmoins, les récentes avancées dans le domaine permettent d’utiliser des modèles plus petits directement sur nos machines locales.
novita.ai, la plateforme tout-en-un pour une créativité sans limites qui vous donne accès à plus de 100 API. De la génération d’images au traitement du langage, en passant par l’amélioration audio et la manipulation vidéo, avec un paiement à l’utilisation avantageux, elle vous libère de la maintenance GPU tout en construisant vos propres produits. Essayez-la gratuitement.
Lectures recommandées
Moteur d’inférence LLM Novita AI : le plus grand débit et l’inférence la moins chère disponibles
