Note:

Configuración de un sistema de referencia de inferencia de LLM simple con vLLM en Oracle Cloud Infrastructure Compute

Introducción

Comprender las características de rendimiento de un sistema le permite tomar decisiones informadas sobre sus componentes y qué esperar de ellos. En este tutorial, configuraremos un sistema de evaluación comparativa completo para la inferencia del modelo de lenguaje grande (LLM) de IA. Con esto, puede ejecutar varios experimentos desde la evaluación de la idoneidad de una unidad de Oracle Cloud Infrastructure (OCI) Compute concreta para el LLM y los requisitos de rendimiento en mente hasta la comparación de varios LLM entre sí.

En este tutorial, utilizamos el popular servidor de inferencia de código abierto vLLM, que admite muchos LLM de última generación y ofrece optimizaciones de rendimiento cruciales para servir eficientemente estos modelos y es capaz de manejar miles de solicitudes simultáneas. Además, utilizamos Ray LLMPerf para ejecutar las referencias.

Nota: En este tutorial se asume que tiene un arrendamiento de OCI con una cuota de GPU. Para obtener más información sobre las cuotas, consulte Cuotas de Compute.

Objetivos

Requisitos

Tarea 1: Configuración de la red

En esta tarea, configure la red virtual en la nube (VCN) para proporcionar una configuración funcional y segura que permita ejecutar las referencias. En este ejemplo, necesitamos una VCN con una subred pública y una subred privada. Puede utilizar el asistente de configuración de VCN o configurar manualmente todos los componentes, asegurándose de que las listas de seguridad permitan el acceso SSH y de que se asigne un gateway de NAT a la subred privada.

Visión general de la arquitectura de la solución que comprende una subred privada y pública, un host bastión y la máquina virtual de GPU en prueba

Antes de aprovisionar instancias de OCI Compute y continuar con la configuración de referencia, es importante asegurarse de que la configuración de red esté correctamente configurada. Por defecto, la red aprovisionada solo permite el tráfico esencial entre subredes. Para permitir el tráfico de red necesario para la evaluación comparativa, deberá ajustar esta configuración para permitir el tráfico HTTP entre las subredes públicas y privadas. Específicamente, agregue una regla de entrada a la lista de seguridad de la subred privada que permita el tráfico del bloque CIDR de la VCN al puerto de destino 8000.

Tarea 2: Aprovisionamiento de instancias informáticas de OCI

En esta tarea, aprovisione dos instancias de OCI Compute para nuestra configuración de referencia. Una es una instancia de máquina virtual (VM) sólo de CPU que actúa como bastión y la máquina cliente de referencia, la otra es la instancia equipada con GPU en prueba.

  1. Aprovisione una instancia VM.Flex.E5 con ocho OCPU y Oracle Linux 8. El cliente de bastión/referencia no necesita una GPU, ya que solo enviará solicitudes al modelo alojado en una máquina independiente, de ahí la elección de una unidad de CPU. Asegúrese de seleccionar la subred pública en los parámetros de red y no olvide cargar la clave pública SSH (o descargar la clave privada proporcionada si lo prefiere).

  2. Aprovisione una instancia VM.GPU.A10.1. Para optimizar la configuración, aprovisione la instancia mediante una imagen de Oracle Linux 8 que incluya controladores NVIDIA y el marco CUDA. Comience seleccionando la unidad deseada y, a continuación, vuelva al menú de selección de imágenes y seleccione la variante de Oracle Linux 8 con soporte de GPU incorporado. Esta instancia se debe aprovisionar en la subred privada, lo que significa que solo se puede acceder a ella mediante el host bastión. Asegúrese de configurar la clave SSH también.

Captura de pantalla de la selección de la imagen de Oracle Linux 8 con soporte de GPU incorporado

Tarea 3: Configuración del cliente de referencia

En esta tarea, instalaremos todos los componentes necesarios para nuestras referencias de rendimiento y configuraremos el host de GPU.

  1. Conéctese al bastión con la clave SSH y configure todos los requisitos para LLMPerf con el siguiente comando.

    sudo dnf install epel-release -y
sudo yum-config-manager --enable ol8_baseos_latest ol8_appstream ol8_addons ol8_developer_EPEL
sudo dnf install git python3.11 python3.11-devel python3.11-pip -y

  2. Clone el repositorio LLMPerf de Ray, configure un venv de Python e instale LLMPerf con el siguiente comando.

    git clone https://github.com/ray-project/llmperf.git
cd llmperf
mkdir venv && python3.11 -mvenv venv && source venv/bin/activate

  3. Antes de instalar LLMPerf (y sus dependencias de Python), edite el archivo pyproject.toml y elimine la cláusula de requisito de Python. La cláusula limita innecesariamente la versión de Python a menos de 3.11.

    diff --git a/pyproject.toml b/pyproject.toml
index 7687fb2..521a2a7 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -8,7 +8,6 @@ version = "0.1.0"
 description = "A framework for load testing LLM APIs"
 authors = [{name="Avnish Narayan", email="avnish@anyscale.com"}]
 license = {text= "Apache-2.0"}
-requires-python = ">=3.8, <3.11"
 dependencies = ["pydantic<2.5",
                 "ray",
                 "pytest>=6.0",

  4. Ejecute el comando pip install -e para finalizar la configuración.

Tarea 4: Configuración del destino de referencia

En esta tarea, configuraremos el objetivo de referencia en sí. Como ya hemos aprovisionado el nodo con los controladores necesarios y el marco de Compute Unified Device Architecture (CUDA), simplemente tenemos que instalar vLLM y sus dependencias de python e implementar el modelo que deseamos comparar.

Nota: La instancia informática de GPU aprovisionada reside en una subred privada. Por lo tanto, para acceder a él, primero debe iniciar sesión en el host bastión y configurar la clave SSH privada que eligió para el destino de referencia. Solo entonces podrá conectarse al destino de referencia mediante su dirección IP privada.

  1. Instale los paquetes necesarios, como la configuración inicial en el host bastión. Además, actualice el firewall del host para permitir el tráfico entrante en el puerto 8000 mediante el siguiente comando.

    sudo dnf install epel-release -y
sudo yum-config-manager --enable ol8_baseos_latest ol8_appstream ol8_addons ol8_developer_EPEL
sudo dnf install git python3.11 python3.11-devel python3.11-pip -y
sudo firewall-cmd --permanent --zone=public --add-port=8000/tcp
sudo firewall-cmd --reload

  2. Ejecute el siguiente comando para instalar vLLM y sus requisitos.

    mkdir venv
python3.11 -mvenv venv && source venv/bin/activate
pip install -U pip "bitsandbytes>=0.44.0" vllm gpustat mistral_common

  3. Estamos listos para iniciar vLLM con el modelo que nos gustaría probar.

    export HF_TOKEN=<your huggingface token>
export MODEL="meta-llama/Llama-3.2-3B-Instruct"
ulimit -Sn 65536 # increase limits to avoid running out of files that can be opened
vllm serve $MODEL --tokenizer-mode auto --config-format hf --load-format auto \
                  --enforce-eager --max-model-len 65536

    Nota: Necesitamos reducir la longitud de contexto del modelo para que se ajuste a la memoria de GPU A10. Reducimos la longitud de contexto del tamaño por defecto de los tokens 128k a los tokens 64k. Después de la carga, el modelo vLLM debe comenzar a generar sus estadísticas de inferencia a intervalos regulares.

    INFO 12-09 15:46:36 metrics.py:449] Avg prompt throughput: 0.0 tokens/s, Avg generation throughput: 0.0 tokens/s, Running: 0 reqs, Swapped: 0 reqs, Pending: 0 reqs, GPU KV cache usage: 0.0%, CPU KV cache usage: 0.0%.

  4. Dejamos que el servidor continúe funcionando en segundo plano mientras cambiamos a otro terminal donde ahora probaremos y compararemos nuestra configuración. Se puede ejecutar una prueba simple con curl de la siguiente manera.

    export HOST="<the ip address of the benchmark machine"
export MODEL="meta-llama/Llama-3.2-3B-Instruct"
curl --location "http://${HOST}:8000/v1/chat/completions"     --header 'Content-Type: application/json'     --header 'Authorization: Bearer token'     --data '{
        "model": "'"$MODEL"'",
        "messages": [
          {
            "role": "user",
            "content": "What is the question to the answer to the ultimate question of life, the universe, and everything. You may give a humorous response."
          }
        ]
    }' -s | jq

    La salida será:

    {
  "id": "chatcmpl-f11306f943604d41bad84be1dadd9da6",
  "object": "chat.completion",
  "created": 1733997638,
  "model": "meta-llama/Llama-3.2-3B-Instruct",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "You want to know the ultimate question to the answer of 42?\n\nWell, after years of intense research and contemplation, I've discovered that the answer is actually a giant, cosmic joke. The question is: \"What's for lunch?\"",
        "tool_calls": []
      },
      "logprobs": null,
      "finish_reason": "stop",
      "stop_reason": null
    }
  ],
  "usage": {
    "prompt_tokens": 62,
    "total_tokens": 112,
    "completion_tokens": 50,
    "prompt_tokens_details": null
  },
  "prompt_logprobs": null
}

Tarea 5: Ejecución de la referencia

Ahora, estamos listos para ejecutar nuestro benchmark. Teniendo en cuenta un escenario de aplicación concreto con un modelo de lenguaje grande seleccionado, nos gustaría comprender en el sistema de destino cuáles son las características de rendimiento de la ejecución de solicitudes de inferencia simultáneas.

Veamos el siguiente escenario:

PARAMETER VALOR
MODEL Meta LLaMa 3.2 3B Instrucción
CASO DE USO chat
TOKENS DE ENTRADA N(200, 40)
TOKENS DE SALIDA N(100, 10)
SOLICITUDES SIMULTÁNEAS 1 - 32

  1. Cree la siguiente secuencia de comandos denominada llm_benchmark.sh en el cliente de referencia (host bastión) dentro del directorio raíz.

    #!/usr/bin/env bash

set -xe

# Use vLLM OpenAPI endpoint
export OPENAI_API_BASE="http://<benchmark host>:8000/v1"
# API key is not in use, but needs to be set for llmbench
export OPENAI_API_KEY="none"

model="meta-llama/Llama-3.2-3B-Instruct"

modelname="${model##*/}"
mkdir "$modelname"

concurrent_requests=(1 2 4 8 16 32)

pushd llmperf

source venv/bin/activate

for cr in "${concurrent_requests[@]}"
do
    python3 token_benchmark_ray.py --model $model \
        --mean-input-tokens 200 --stddev-input-tokens 40 \
        --mean-output-tokens 100 --stddev-output-tokens 10 \
        --max-num-completed-requests $((cr * 100)) --num-concurrent-requests $cr \
        --metadata "use_case=chatbot" \
        --timeout 1800 --results-dir "../$modelname/result_outputs_chat_creq_$cr" --llm-api openai
done
popd

    Este script le permitirá ejecutar automáticamente una serie de referencias con llmperf con un número creciente de solicitudes simultáneas (a partir de 1 y duplicando sucesivamente hasta 32). Como puede ver en los argumentos transferidos al script token_benchmark_ray.py, estamos definiendo entradas y salidas de token como se define en la tabla anterior.

  2. Ejecute la secuencia de comandos de referencia con el siguiente comando.

    bash -x llm_benchmark.sh

Una vez hecho esto, encontrarás un nuevo directorio llamado Llama-3.2-3B-Instruct en tu directorio de inicio, donde todos los resultados del experimento se almacenarán en formato JSON, que puedes descargar y postprocesar usando tu herramienta de análisis de datos favorita.

Nota: Una forma sencilla de convertir las referencias en un gráfico es extraer las figuras que más le interesan mediante un pequeño script de shell y jq en formato .csv, que se puede copiar y pegar fácilmente en Excel.

echo "concurrent_requests,token_throughput"
for i in *; do
    cat $i/*_summary.json | jq -r '[.num_concurrent_requests, .results_request_output_throughput_token_per_s_mean] | join(",")'
done;

Agradecimientos

Más recursos de aprendizaje

Explore otros laboratorios en docs.oracle.com/learn o acceda a más contenido de formación gratuita en el canal YouTube de Oracle Learning. Además, visite education.oracle.com/learning-explorer para convertirse en un explorador de Oracle Learning.

Para obtener documentación sobre el producto, visite Oracle Help Center.