text generation inference
v2.4.1
Un servidor Rust, Python y gRPC para inferencia de generación de texto. Se utiliza en producción en Hugging Face para impulsar Hugging Chat, la API de inferencia y el punto final de inferencia.
Text Generation Inference (TGI) es un conjunto de herramientas para implementar y servir modelos de lenguajes grandes (LLM). TGI permite la generación de texto de alto rendimiento para los LLM de código abierto más populares, incluidos Llama, Falcon, StarCoder, BLOOM, GPT-NeoX y más. TGI implementa muchas características, tales como:
Para obtener una guía inicial detallada, consulte el Tour rápido. La forma más sencilla de empezar es utilizar el contenedor oficial de Docker:
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 $modelY luego puedes hacer solicitudes como
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 'También puede utilizar la API de mensajes de TGI para obtener respuestas compatibles con la 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 ' Nota: Para utilizar las GPU NVIDIA, debe instalar NVIDIA Container Toolkit. También recomendamos utilizar controladores NVIDIA con CUDA versión 12.2 o superior. Para ejecutar el contenedor Docker en una máquina sin GPU ni compatibilidad con CUDA, es suficiente eliminar el indicador --gpus all y agregar --disable-custom-kernels . Tenga en cuenta que la CPU no es la plataforma prevista para este proyecto, por lo que el rendimiento podría ser mediocre.
Nota: TGI admite las GPU AMD Instinct MI210 y MI250. Los detalles se pueden encontrar en la documentación de hardware compatible. Para utilizar GPU AMD, utilice 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 en lugar del comando anterior.
Para ver todas las opciones para servir sus modelos (en el código o en el cli):
text-generation-launcher --help
Puede consultar la documentación de OpenAPI de la API REST text-generation-inference utilizando la ruta /docs . La interfaz de usuario de Swagger también está disponible en: https://huggingface.github.io/text-generation-inference.
Tiene la opción de utilizar la variable de entorno HF_TOKEN para configurar el token empleado por text-generation-inference . Esto le permite obtener acceso a recursos protegidos.
Por ejemplo, si desea ofrecer las variantes del modelo cerrado Llama V2:
HF_TOKEN=o con 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 es un marco de comunicación utilizado por PyTorch para realizar capacitación/inferencia distribuida. text-generation-inference utiliza NCCL para permitir que el paralelismo tensorial acelere drásticamente la inferencia para modelos de lenguaje grandes.
Para compartir datos entre los diferentes dispositivos de un grupo NCCL , NCCL podría recurrir a la memoria del host si no es posible el uso de igual a igual mediante NVLink o PCI.
Para permitir que el contenedor use 1G de memoria compartida y admita el uso compartido de SHM, agregamos --shm-size 1g en el comando anterior.
Si está ejecutando text-generation-inference dentro de Kubernetes . También puedes agregar Memoria Compartida al contenedor creando un volumen con:
- name : shm
emptyDir :
medium : Memory
sizeLimit : 1Gi y montándolo en /dev/shm .
Finalmente, también puede deshabilitar el uso compartido de SHM utilizando la variable de entorno NCCL_SHM_DISABLE=1 . Sin embargo, tenga en cuenta que esto afectará el rendimiento.
text-generation-inference está instrumentada con seguimiento distribuido utilizando OpenTelemetry. Puede utilizar esta función configurando la dirección en un recopilador OTLP con el argumento --otlp-endpoint . El nombre del servicio predeterminado se puede anular con el argumento --otlp-service-name
Entrada de blog detallada de Adyen sobre el funcionamiento interno de TGI: inferencia LLM a escala con TGI (Martin Iglesias Goyanes - Adyen, 2024)
También puede optar por instalar text-generation-inference localmente.
Primero instale Rust y cree un entorno virtual Python con al menos Python 3.9, por ejemplo, usando 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-inferenceEs posible que también necesites instalar Protoc.
En 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_ZIPEn MacOS, usando Homebrew:
brew install protobufLuego ejecuta:
BUILD_EXTENSIONS=True make install # Install repository and HF/transformer fork with CUDA kernels
text-generation-launcher --model-id mistralai/Mistral-7B-Instruct-v0.2Nota: en algunas máquinas, es posible que también necesites las bibliotecas OpenSSL y gcc. En máquinas Linux, ejecute:
sudo apt-get install libssl-dev gcc -y Otra opción es instalar text-generation-inference localmente usando Nix. Actualmente, solo admitimos Nix en Linux x86_64 con GPU CUDA. Cuando se usa Nix, todas las dependencias se pueden extraer de un caché binario, lo que elimina la necesidad de compilarlas localmente.
Primero siga las instrucciones para instalar Cachix y habilitar el caché TGI. Configurar el caché es importante; de lo contrario, Nix creará muchas de las dependencias localmente, lo que puede llevar horas.
Después de eso puedes ejecutar TGI con nix run :
nix run . -- --model-id meta-llama/Llama-3.1-8B-InstructNota: cuando utiliza Nix en un sistema que no es NixOS, debe crear algunos enlaces simbólicos para que las bibliotecas del controlador CUDA sean visibles para los paquetes Nix.
Para el desarrollo de TGI, puedes usar el shell de desarrollo 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
)Todas las dependencias de desarrollo (cargo, Python, Torch), etc. están disponibles en este shell de desarrollo.
TGI funciona desde el primer momento para ofrecer modelos optimizados para todos los modelos modernos. Se pueden encontrar en esta lista.
Otras arquitecturas se admiten en la medida de lo posible mediante:
AutoModelForCausalLM.from_pretrained(
o
AutoModelForSeq2SeqLM.from_pretrained(
text-generation-launcher --model-id mistralai/Mistral-7B-Instruct-v0.2También puede ejecutar pesos precuantizados (AWQ, GPTQ, Marlin) o pesos cuantizados sobre la marcha con bitsandbytes, EETQ, fp8, para reducir el requisito de VRAM:
text-generation-launcher --model-id mistralai/Mistral-7B-Instruct-v0.2 --quantize La cuantificación de 4 bits está disponible utilizando los tipos de datos NF4 y FP4 de bitsandbytes. Se puede habilitar proporcionando --quantize bitsandbytes-nf4 o --quantize bitsandbytes-fp4 como argumento de línea de comando para text-generation-launcher .
Lea más sobre la cuantización en la documentación de Cuantización.
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
