Sirviendo LLM utilizando instancias vLLM y Amazon EC2 con chips de IA de AWS

El uso de grandes modelos de lenguaje (LLM) y la IA generativa se ha disparado durante el último año. Con el lanzamiento de potentes modelos básicos disponibles públicamente, las herramientas para capacitar, ajustar y alojar su propio LLM también se han democratizado. Usando vllm en AWS trenio y inferencia hace posible alojar LLM para lograr inferencia y escalabilidad de alto rendimiento.

En esta publicación, le explicaremos cómo puede implementar rápidamente Los últimos modelos de Llama de Metausando vLLM en un Instancia Inf2 de Amazon Elastic Compute Cloud (Amazon EC2). Para este ejemplo, usaremos la versión 1B, pero se pueden implementar otros tamaños siguiendo estos pasos, junto con otros LLM populares.

Implemente vLLM en instancias AWS Trainium e Inferentia EC2

En estas secciones, se le guiará a través del uso de vLLM en una instancia AWS Inferentia EC2 para implementar el modelo Llama 3.2 más nuevo de Meta. Aprenderá cómo solicitar acceso al modelo, crear un contenedor Docker para usar vLLM para implementar el modelo y cómo ejecutar inferencias en línea y fuera de línea en el modelo. También hablaremos sobre el ajuste del rendimiento del gráfico de inferencia.

Requisito previo: cuenta de Hugging Face y acceso a modelo

Para usar el meta-llama/Llama-3.2-1B modelo, necesitarás una cuenta de Hugging Face y acceso al modelo. Por favor ve al tarjeta modeloregístrese y acepte la licencia del modelo. Luego necesitarás una ficha de Hugging Face, que puedes obtener siguiendo estos pasos. Cuando llegues al Guarde su token de acceso pantalla, como se muestra en la siguiente figura, asegúrese de copiar el token porque no se volverá a mostrar.

Crear una instancia EC2

Puede crear una instancia EC2 siguiendo las instrucciones guía. Algunas cosas a tener en cuenta:

1. Si es la primera vez que utiliza instancias inf/trn, deberá solicitar un aumento de cuota.
2. usarás inf2.xlarge como su tipo de instancia. inf2.xlarge Las instancias solo están disponibles en estas regiones de AWS.
3. Aumente el volumen del gp3 a 100 G.
4. usarás Deep Learning AMI Neuron (Ubuntu 22.04) como su AMI, como se muestra en la siguiente figura.

Una vez lanzada la instancia, puede conéctate a él para acceder a la línea de comando. En el siguiente paso, utilizará Docker (preinstalado en esta AMI) para ejecutar una Imagen de contenedor vLLM para neurona.

Iniciar el servidor vLLM

Utilizará Docker para crear un contenedor con todas las herramientas necesarias para ejecutar vLLM. Cree un Dockerfile usando el siguiente comando:

cat > Dockerfile <<\EOF
# default base image
ARG BASE_IMAGE="public.ecr.aws/neuron/pytorch-inference-neuronx:2.1.2-neuronx-py310-sdk2.20.0-ubuntu20.04"
FROM $BASE_IMAGE
RUN echo "Base image is $BASE_IMAGE"
# Install some basic utilities
RUN apt-get update && \
    apt-get install -y \
        git \
        python3 \
        python3-pip \
        ffmpeg libsm6 libxext6 libgl1
### Mount Point ###
# When launching the container, mount the code directory to /app
ARG APP_MOUNT=/app
VOLUME [ ${APP_MOUNT} ]
WORKDIR ${APP_MOUNT}/vllm
RUN python3 -m pip install --upgrade pip
RUN python3 -m pip install --no-cache-dir fastapi ninja tokenizers pandas
RUN python3 -m pip install sentencepiece transformers==4.36.2 -U
RUN python3 -m pip install transformers-neuronx --extra-index-url=https://pip.repos.neuron.amazonaws.com -U
RUN python3 -m pip install --pre neuronx-cc==2.15.* --extra-index-url=https://pip.repos.neuron.amazonaws.com -U
ENV VLLM_TARGET_DEVICE neuron
RUN git clone https://github.com/vllm-project/vllm.git && \
    cd vllm && \
    git checkout v0.6.2 && \
    python3 -m pip install -U \
        cmake>=3.26 ninja packaging setuptools-scm>=8 wheel jinja2 \
        -r requirements-neuron.txt && \
    pip install --no-build-isolation -v -e . && \
    pip install --upgrade triton==3.0.0
CMD ["/bin/bash"]
EOF

Luego ejecuta:

docker build . -t vllm-neuron

Construir la imagen tardará unos 10 minutos. Una vez hecho esto, use la nueva imagen de Docker (reemplace YOUR_TOKEN_HERE con la ficha de Hugging Face):

export HF_TOKEN="YOUR_TOKEN_HERE"
docker run \
        -it \
        -p 8000:8000 \
        --device /dev/neuron0 \
        -e HF_TOKEN=$HF_TOKEN \
        -e NEURON_CC_FLAGS=-O1 \
        vllm-neuron

Ahora puede iniciar el servidor vLLM con el siguiente comando:

vllm serve meta-llama/Llama-3.2-1B --device neuron --tensor-parallel-size 2 --block-size 8 --max-model-len 4096 --max-num-seqs 32

Este comando ejecuta vLLM con los siguientes parámetros:

• serve meta-llama/Llama-3.2-1B: La cara que abraza modelID del modelo que se está implementando para la inferencia.
• --device neuron: Configura vLLM para ejecutarse en el dispositivo neuronal.
• --tensor-parallel-size 2: establece el número de particiones para el paralelismo tensorial. inf2.xlarge tiene 1 dispositivo neuronal y cada dispositivo neuronal tiene 2 núcleos neuronales.
• --max-model-len 4096: Se establece en la longitud máxima de secuencia (tokens de entrada más tokens de salida) para compilar el modelo.
• --block-size 8: Para dispositivos neuronales, esto se configura internamente en max-model-len.
• --max-num-seqs 32: Esto se establece en el tamaño del lote de hardware o en un nivel deseado de simultaneidad que el servidor modelo necesita manejar.

La primera vez que carga un modelo, si no hay un modelo previamente compilado, será necesario compilarlo. Este modelo compilado se puede guardar opcionalmente, por lo que el paso de compilación no es necesario si se vuelve a crear el contenedor. Una vez hecho todo y el servidor modelo esté ejecutándose, debería ver los siguientes registros:

Avg prompt throughput: 0.0 tokens/s ...

Esto significa que el servidor modelo se está ejecutando, pero aún no está procesando solicitudes porque no se ha recibido ninguna. Ahora puede separarse del contenedor presionando ctrl + p y ctrl + q.

Inferencia

Cuando inició el contenedor Docker, lo ejecutó con el comando -p 8000:8000. Esto le indicó a Docker que reenviara el puerto 8000 desde el contenedor al puerto 8000 de su máquina local. Cuando ejecuta el siguiente comando, debería ver que el servidor modelo con meta-llama/Llama-3.2-1B está corriendo.

curl localhost:8000/v1/models

Esto debería devolver algo como:

{"object":"list","data":[{"id":"meta-llama/Llama-3.2-1B","object":"model","created":1732552038,"owned_by":"vllm","root":"meta-llama/Llama-3.2-1B","parent":null,"max_model_len":4096,"permission":[{"id":"modelperm-6d44a6f6e52447eb9074b13ae1e9e285","object":"model_permission","created":1732552038,"allow_create_engine":false,"allow_sampling":true,"allow_logprobs":true,"allow_search_indices":false,"allow_view":true,"allow_fine_tuning":false,"organization":"*","group":null,"is_blocking":false}]}]}ubuntu@ip-172-31-12-216:~$ 

Ahora, envíale un mensaje:

curl localhost:8000/v1/completions \
-H "Content-Type: application/json" \
-d '{"model": "meta-llama/Llama-3.2-1B", "prompt": "What is Gen AI?", "temperature":0, "max_tokens": 128}' | jq '.choices[0].text'

Debería recibir una respuesta similar a la siguiente de vLLM:

ubuntu@ip-172-31-13-178:~$ curl localhost:8000/v1/completions \
-H "Content-Type: application/json" \
-d '{"model": "meta-llama/Llama-3.2-1B", "prompt": "What is Gen AI?", "temperature":0, "max_tokens": 128}' | jq '.choices[0].text'
  % Total    % Received % Xferd  Average Speed   Time    Time    Time  Current
                                 Dload  Upload   Total   Spent  Left  Speed
100  1067  100   966  100   101    108     11  0:00:09  0:00:08 0:00:01   258
" How does it work?\nGen AI is a new type of artificial intelligence that is designed to learn and adapt to new situations and environments. It is based on the idea that the human brain is a complex system 
that can learn and adapt to new situations and environments. Gen AI is designed to be able to learn and adapt to new situations and environments in a way that is similar to how the human brain does.\nGen AI is 
a new type of artificial intelligence that is designed to learn and adapt to new situations and environments. It is based on the idea that the human brain is a complex system that can learn and adapt to new 
situations and environments."

Inferencia fuera de línea con vLLM

Otra forma de utilizar vLLM en Inferentia es enviando algunas solicitudes al mismo tiempo en un script. Esto es útil para la automatización o cuando tiene un lote de mensajes que desea enviar todos al mismo tiempo.

Puede volver a conectarse a su contenedor Docker y detener el servidor de inferencia en línea con lo siguiente:

docker attach $(docker ps --format "{{.ID}}")

En este punto, debería ver un cursor en blanco, presione ctrl + c para detener el servidor y debería volver al indicador de bash en el contenedor. Cree un archivo para usar el motor de inferencia sin conexión:

cat > offline_inference.py <<EOF
from vllm.entrypoints.llm import LLM
from vllm.sampling_params import SamplingParams

# Sample prompts.
prompts = [
    "Hello, my name is",
    "The president of the United States is",
    "The capital of France is",
    "The future of AI is",
]
# Create a sampling params object.
sampling_params = SamplingParams(temperature=0.8, top_p=0.95)

# Create an LLM.
llm = LLM(model="meta-llama/Llama-3.2-1B",
        max_num_seqs=32,
        max_model_len=4096,
        block_size=8,
        device="neuron",
        tensor_parallel_size=2)
# Generate texts from the prompts. The output is a list of RequestOutput objects
# that contain the prompt, generated text, and other information.
outputs = llm.generate(prompts, sampling_params)
# Print the outputs.
for output in outputs:
    prompt = output.prompt
    generated_text = output.outputs[0].text
    print(f"Prompt: {prompt!r}, Generated text: {generated_text!r}")

EOF

Ahora, ejecuta el script. python offline_inference.py y debería recibir respuestas a las cuatro indicaciones. Esto puede tardar un minuto ya que es necesario reiniciar el modelo.

Processed prompts: 100%|
█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 4/4 [00:01<00:00,  2.53it/s, est. speed input: 16.46 toks/s, output: 40.51 toks/s]
Prompt: 'Hello, my name is', Generated text: ' Anna and I am the 4th year student of the Bachelor of Engineering at'
Prompt: 'The president of the United States is', Generated text: ' the head of state and head of government of the United States of America. A'
Prompt: 'The capital of France is', Generated text: ' also the most expensive city to live in. The average cost of living in Paris'
Prompt: 'The future of AI is', Generated text: ' now\nThe 10 most influential AI professionals to watch in 2019\n'

Ahora puedes escribir exit y presione regresar y luego presione ctrl + c para cerrar el contenedor Docker y volver a su instancia inf2.

Limpiar

Ahora que ha terminado de probar Llama 3.2 1B LLM, debe terminar su instancia EC2 para evitar cargos adicionales.

Ajuste de rendimiento para longitudes de secuencia variables

Probablemente tendrá que procesar secuencias de longitud variable durante la inferencia LLM. El SDK de Neuron genera depósitos y un gráfico de cálculo que funciona con la forma y el tamaño de los depósitos. Para ajustar el rendimiento en función de la longitud de los tokens de entrada y salida en las solicitudes de inferencia, puede configurar dos tipos de depósitos correspondientes a las dos fases de la inferencia LLM a través de las siguientes variables de entorno como una lista de números enteros:

• NEURON_CONTEXT_LENGTH_BUCKETS Corresponde a la fase de codificación del contexto. Establezca esto en la duración estimada de las indicaciones durante la inferencia.
• NEURON_TOKEN_GEN_BUCKETS Corresponde a la fase de generación de tokens. Establezca esto en un rango de potencias de dos dentro de la duración de su generación.

Puede usar el comando de ejecución de Docker para configurar las variables de entorno al iniciar el servidor vLLM (recuerde reemplazar YOUR_TOKEN_HERE con tu ficha de Cara Abrazada):

export HF_TOKEN="YOUR_TOKEN_HERE"
docker run \
        -it \
        -p 8000:8000 \
        --device /dev/neuron0 \
        -e HF_TOKEN=$HF_TOKEN \
        -e NEURON_CC_FLAGS=-O1 \
        -e NEURON_CONTEXT_LENGTH_BUCKETS="1024,1280,1536,1792,2048" \
        -e NEURON_TOKEN_GEN_BUCKETS="256,512,1024" \
        vllm-neuron

Luego puede iniciar el servidor usando el mismo comando:

vllm serve meta-llama/Llama-3.2-1B --device neuron --tensor-parallel-size 2 --block-size 8 --max-model-len 4096 --max-num-seqs 32

Como el gráfico del modelo ha cambiado, será necesario volver a compilar el modelo. Si se canceló el contenedor, el modelo se descargará nuevamente. Luego puede enviar una solicitud separándose del contenedor presionando ctrl + p y ctrl + q y usando el mismo comando:

curl localhost:8000/v1/completions \
-H "Content-Type: application/json" \
-d '{"model": "meta-llama/Llama-3.2-1B", "prompt": "What is Gen AI?", "temperature":0, "max_tokens": 128}' | jq '.choices[0].text'

Para obtener más información sobre cómo configurar los depósitos, consulte la guía para desarrolladores sobre el agrupamiento. Nota, NEURON_CONTEXT_LENGTH_BUCKETS corresponde a context_length_estimate en la documentación y NEURON_TOKEN_GEN_BUCKETS corresponde a n_positions en la documentación.

Conclusión

Acabas de ver cómo implementar meta-llama/Llama-3.2-1B utilizando vLLM en una instancia Amazon EC2 Inf2. Si está interesado en implementar otros LLM populares de Hugging Face, puede reemplazar el modelID en el vLLM serve dominio. Se pueden encontrar más detalles sobre la integración entre Neuron SDK y vLLM en Guía del usuario de Neuron para procesamiento por lotes continuo y el Guía vLLM para Neuron.

Una vez que haya identificado un modelo que desea utilizar en producción, querrá implementarlo con escalado automático, observabilidad y tolerancia a fallas. También puedes consultar esto. publicación de blog comprender cómo implementar vLLM en Inferentia a través de Servicio Amazon Elastic Kubernetes (Amazon EKS). En la próxima publicación de esta serie, analizaremos el uso de Amazon EKS con Ray Serve para implementar vLLM en producción con escalado automático y observabilidad.

Sobre los autores

Omri Shiva es un ingeniero de aprendizaje automático de código abierto que se centra en ayudar a los clientes en su viaje de IA/ML. En su tiempo libre, le gusta cocinar, jugar con código abierto y hardware abierto, y escuchar y tocar música.

Panigrahi rosa trabaja con clientes para crear soluciones basadas en ML para resolver problemas comerciales estratégicos en AWS. En su puesto actual, trabaja en la optimización del entrenamiento y la inferencia de modelos de IA generativa en chips de IA de AWS.