text generation inference
v2.4.1
Un serveur Rust, Python et gRPC pour l'inférence de génération de texte. Utilisé en production chez Hugging Face pour alimenter Hugging Chat, l'API d'inférence et le point de terminaison d'inférence.
Text Generation Inference (TGI) est une boîte à outils permettant de déployer et de servir des grands modèles linguistiques (LLM). TGI permet une génération de texte hautes performances pour les LLM open source les plus populaires, notamment Llama, Falcon, StarCoder, BLOOM, GPT-NeoX, etc. TGI implémente de nombreuses fonctionnalités, telles que :
Pour un guide de démarrage détaillé, veuillez consulter la visite guidée rapide. Le moyen le plus simple de commencer consiste à utiliser le conteneur Docker officiel :
model=HuggingFaceH4/zephyr-7b-beta
# share a volume with the Docker container to avoid downloading weights every run
volume= $PWD /data
docker run --gpus all --shm-size 1g -p 8080:80 -v $volume :/data
ghcr.io/huggingface/text-generation-inference:2.4.1 --model-id $modelEt puis vous pouvez faire des demandes comme
curl 127.0.0.1:8080/generate_stream
-X POST
-d ' {"inputs":"What is Deep Learning?","parameters":{"max_new_tokens":20}} '
-H ' Content-Type: application/json 'Vous pouvez également utiliser l'API Messages de TGI pour obtenir des réponses compatibles avec l'API Open AI Chat Completion.
curl localhost:8080/v1/chat/completions
-X POST
-d ' {
"model": "tgi",
"messages": [
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "What is deep learning?"
}
],
"stream": true,
"max_tokens": 20
} '
-H ' Content-Type: application/json ' Remarque : Pour utiliser les GPU NVIDIA, vous devez installer NVIDIA Container Toolkit. Nous vous recommandons également d'utiliser les pilotes NVIDIA avec CUDA version 12.2 ou supérieure. Pour exécuter le conteneur Docker sur une machine sans GPU ni support CUDA, il suffit de supprimer l'indicateur --gpus all et d'ajouter --disable-custom-kernels . Veuillez noter que le CPU n'est pas la plate-forme prévue pour ce projet, donc les performances pourrait être médiocre.
Remarque : TGI prend en charge les GPU AMD Instinct MI210 et MI250. Les détails peuvent être trouvés dans la documentation sur le matériel pris en charge. Pour utiliser les GPU AMD, veuillez utiliser docker run --device /dev/kfd --device /dev/dri --shm-size 1g -p 8080:80 -v $volume:/data ghcr.io/huggingface/text-generation-inference:2.4.1-rocm --model-id $model au lieu de la commande ci-dessus.
Pour voir toutes les options pour servir vos modèles (dans le code ou dans le cli) :
text-generation-launcher --help
Vous pouvez consulter la documentation OpenAPI de l'API REST text-generation-inference en utilisant la route /docs . L'interface utilisateur Swagger est également disponible sur : https://huggingface.github.io/text-Generation-inference.
Vous avez la possibilité d'utiliser la variable d'environnement HF_TOKEN pour configurer le jeton utilisé par text-generation-inference . Cela vous permet d'accéder à des ressources protégées.
Par exemple, si vous souhaitez diffuser les variantes du modèle gated Llama V2 :
HF_TOKEN=ou avec Docker :
model=meta-llama/Meta-Llama-3.1-8B-Instruct
volume= $PWD /data # share a volume with the Docker container to avoid downloading weights every run
token= < your cli READ token >
docker run --gpus all --shm-size 1g -e HF_TOKEN= $token -p 8080:80 -v $volume :/data ghcr.io/huggingface/text-generation-inference:2.4.1 --model-id $model NCCL est un cadre de communication utilisé par PyTorch pour effectuer une formation/inférence distribuée. text-generation-inference utilise NCCL pour permettre au parallélisme tensoriel d'accélérer considérablement l'inférence pour les grands modèles de langage.
Afin de partager des données entre les différents périphériques d'un groupe NCCL , NCCL peut recourir à la mémoire hôte si le peer-to-peer utilisant NVLink ou PCI n'est pas possible.
Pour permettre au conteneur d'utiliser 1 Go de mémoire partagée et prendre en charge le partage SHM, nous ajoutons --shm-size 1g à la commande ci-dessus.
Si vous exécutez text-generation-inference dans Kubernetes . Vous pouvez également ajouter de la mémoire partagée au conteneur en créant un volume avec :
- name : shm
emptyDir :
medium : Memory
sizeLimit : 1Gi et le monter sur /dev/shm .
Enfin, vous pouvez également désactiver le partage SHM en utilisant la variable d'environnement NCCL_SHM_DISABLE=1 . Notez cependant que cela aura un impact sur les performances.
text-generation-inference est instrumentée avec un traçage distribué à l'aide d'OpenTelemetry. Vous pouvez utiliser cette fonctionnalité en définissant l'adresse sur un collecteur OTLP avec l'argument --otlp-endpoint . Le nom du service par défaut peut être remplacé par l'argument --otlp-service-name
Article de blog détaillé d'Adyen sur le fonctionnement interne de TGI : inférence LLM à grande échelle avec TGI (Martin Iglesias Goyanes - Adyen, 2024)
Vous pouvez également choisir d’installer text-generation-inference localement.
Installez d'abord Rust et créez un environnement virtuel Python avec au moins Python 3.9, par exemple en utilisant conda :
curl --proto ' =https ' --tlsv1.2 -sSf https://sh.rustup.rs | sh
conda create -n text-generation-inference python=3.11
conda activate text-generation-inferenceVous devrez peut-être également installer Protoc.
Sous Linux :
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_ZIPSous MacOS, en utilisant Homebrew :
brew install protobufPuis exécutez :
BUILD_EXTENSIONS=True make install # Install repository and HF/transformer fork with CUDA kernels
text-generation-launcher --model-id mistralai/Mistral-7B-Instruct-v0.2Remarque : sur certaines machines, vous aurez peut-être également besoin des bibliothèques OpenSSL et de gcc. Sur les machines Linux, exécutez :
sudo apt-get install libssl-dev gcc -y Une autre option consiste à installer text-generation-inference localement à l'aide de Nix. Actuellement, nous prenons uniquement en charge Nix sur Linux x86_64 avec les GPU CUDA. Lors de l'utilisation de Nix, toutes les dépendances peuvent être extraites d'un cache binaire, éliminant ainsi le besoin de les créer localement.
Suivez d’abord les instructions pour installer Cachix et activer le cache TGI. La configuration du cache est importante, sinon Nix créera de nombreuses dépendances localement, ce qui peut prendre des heures.
Après cela, vous pouvez exécuter TGI avec nix run :
nix run . -- --model-id meta-llama/Llama-3.1-8B-InstructRemarque : lorsque vous utilisez Nix sur un système non-NixOS, vous devez créer des liens symboliques pour rendre les bibliothèques de pilotes CUDA visibles pour les packages Nix.
Pour le développement TGI, vous pouvez utiliser le shell de développement impure :
nix develop . # impure
# Only needed the first time the devshell is started or after updating the protobuf.
(
cd server
mkdir text_generation_server/pb || true
python -m grpc_tools.protoc -I../proto/v3 --python_out=text_generation_server/pb
--grpc_python_out=text_generation_server/pb --mypy_out=text_generation_server/pb ../proto/v3/generate.proto
find text_generation_server/pb/ -type f -name " *.py " -print0 -exec sed -i -e ' s/^(import.*pb2)/from . 1/g ' {} ;
touch text_generation_server/pb/__init__.py
)Toutes les dépendances de développement (cargo, Python, Torch), etc. sont disponibles dans ce shell de développement.
TGI fonctionne immédiatement pour proposer des modèles optimisés pour tous les modèles modernes. Ils peuvent être trouvés dans cette liste.
D'autres architectures sont prises en charge au mieux en utilisant :
AutoModelForCausalLM.from_pretrained(
ou
AutoModelForSeq2SeqLM.from_pretrained(
text-generation-launcher --model-id mistralai/Mistral-7B-Instruct-v0.2Vous pouvez également exécuter des poids pré-quantifiés (AWQ, GPTQ, Marlin) ou quantifier des poids à la volée avec des bits et des octets, EETQ, fp8, pour réduire les besoins en VRAM :
text-generation-launcher --model-id mistralai/Mistral-7B-Instruct-v0.2 --quantize La quantification 4 bits est disponible en utilisant les types de données NF4 et FP4 de bitsandbytes. Il peut être activé en fournissant --quantize bitsandbytes-nf4 ou --quantize bitsandbytes-fp4 comme argument de ligne de commande à text-generation-launcher .
En savoir plus sur la quantification dans la documentation sur la quantification.
make server-dev
make router-dev # python
make python-server-tests
make python-client-tests
# or both server and client tests
make python-tests
# rust cargo tests
make rust-tests
# integration tests
make integration-tests
