¿Qué es vLLM? Cómo instalar y usar vLLM, explicado

¡Bienvenido a la guía completa sobre vLLM! Si estás involucrado en el mundo de los Modelos de Lenguaje Grandes (LLMs), es probable que te hayas encontrado con los desafíos de la velocidad de inferencia y el rendimiento. Servir estos modelos masivos de manera eficiente puede ser un cuello de botella. Aquí es donde vLLM entra en juego como una solución revolucionaria. Este tutorial te guiará a través de todo lo que necesitas saber como principiante: qué es vLLM, por qué es importante, cómo instalarlo y cómo usarlo tanto para el procesamiento por lotes fuera de línea como para el servicio en línea.

¿Qué es Exactamente vLLM?

En esencia, vLLM es una biblioteca de alto rendimiento y eficiencia de memoria diseñada específicamente para la inferencia y el servicio de Modelos de Lenguaje Grandes (LLM). Desarrollado por investigadores e ingenieros que buscan superar las limitaciones de rendimiento de los sistemas de servicio existentes, vLLM acelera significativamente el proceso de obtener predicciones (inferencia) de los LLM.

Los métodos tradicionales para la inferencia de LLM a menudo tienen dificultades para gestionar la gran huella de memoria del mecanismo de atención del modelo (específicamente, la caché KV) y para procesar eficientemente por lotes las solicitudes entrantes. vLLM introduce técnicas novedosas, sobre todo PagedAttention, para abordar estos desafíos de frente. Permite un rendimiento mucho mayor (más solicitudes procesadas por segundo) y puede servir modelos de forma más rápida y rentable en comparación con muchas implementaciones estándar de Hugging Face Transformers u otros marcos de servicio cuando se trata de solicitudes concurrentes.

Piensa en vLLM como un motor altamente optimizado para ejecutar LLM pre-entrenados. Proporcionas el modelo y los prompts, y vLLM se encarga de la compleja tarea de generar texto de forma rápida y eficiente, ya sea para un único lote grande de prompts o para muchos usuarios simultáneos que interactúan con un modelo implementado.

¿Por Qué Elegir vLLM para la Inferencia de LLM?

Varias razones convincentes hacen de vLLM una opción preferida para los desarrolladores y las organizaciones que trabajan con LLM:

1. Rendimiento de Última Generación: vLLM ofrece un rendimiento significativamente mayor en comparación con muchas implementaciones de referencia. Esto significa que puedes gestionar más solicitudes de usuario simultáneamente o procesar grandes conjuntos de datos más rápido con el mismo hardware.
2. Gestión Eficiente de la Memoria: La innovación central, PagedAttention, reduce drásticamente el desperdicio de memoria al gestionar la caché KV de forma más eficaz. Esto te permite ajustar modelos más grandes en tus GPU o servir modelos existentes con menos sobrecarga de memoria, lo que podría reducir los costes de hardware.
3. Procesamiento Continuo por Lotes: A diferencia del procesamiento estático por lotes (donde el servidor espera un lote completo antes de procesar), vLLM utiliza el procesamiento continuo por lotes. Procesa las solicitudes dinámicamente a medida que llegan, lo que mejora significativamente la utilización de la GPU y reduce la latencia de las solicitudes individuales.
4. Servidor Compatible con OpenAI: vLLM incluye un servidor integrado que imita la API de OpenAI. Esto hace que sea increíblemente fácil usar vLLM como un reemplazo directo para las aplicaciones ya construidas con el cliente de Python de OpenAI o herramientas compatibles. A menudo puedes cambiar la URL de tu endpoint y la clave API, y tu código existente funcionará con tu instancia de vLLM auto-hospedada.
5. Facilidad de Uso: A pesar de sus sofisticados componentes internos, vLLM ofrece una API relativamente sencilla tanto para la inferencia fuera de línea (clase LLM) como para el servicio en línea (comando vllm serve).
6. Amplia Compatibilidad de Modelos: vLLM admite una amplia gama de LLM de código abierto populares disponibles en Hugging Face Hub (y potencialmente ModelScope).
7. Desarrollo Activo y Comunidad: vLLM es un proyecto de código abierto que se mantiene activamente con una comunidad en crecimiento, lo que garantiza mejoras continuas, correcciones de errores y soporte para nuevos modelos y características.
8. Kernels Optimizados: vLLM utiliza kernels CUDA altamente optimizados para diversas operaciones, lo que aumenta aún más el rendimiento en las GPU NVIDIA.

Si la velocidad, la eficiencia y la escalabilidad son cruciales para tu aplicación LLM, vLLM es una tecnología que deberías considerar seriamente.

¿Qué Modelos Admite vLLM?

vLLM admite una amplia gama de modelos populares basados en transformadores alojados en Hugging Face Hub. Esto incluye muchas variantes de:

• Llama (Llama, Llama 2, Llama 3)
• Mistral & Mixtral
• Qwen & Qwen2
• GPT-2, GPT-J, GPT-NeoX
• OPT
• Bloom
• Falcon
• MPT
• Y muchos otros, incluidos los modelos multi-modales.

La lista está en constante crecimiento. Para obtener la lista más actualizada y completa de modelos admitidos oficialmente, consulta siempre la documentación oficial de vLLM:

Lista de Modelos Admitidos por vLLM

Si un modelo no aparece explícitamente en la lista, podría seguir funcionando si su arquitectura es similar a una admitida, pero la compatibilidad no está garantizada sin soporte o pruebas oficiales. Añadir nuevas arquitecturas de modelos normalmente requiere contribuciones de código al proyecto vLLM.

Algunas Terminologías Clave de vLLM:

Si bien vLLM es fácil de usar en la superficie, comprender un par de sus conceptos centrales ayuda a apreciar por qué es tan eficaz:

• PagedAttention: Esta es la característica estrella de vLLM. En los mecanismos de atención tradicionales, la caché Key-Value (KV) (que almacena los resultados intermedios para la generación) requiere bloques de memoria contiguos. Esto conduce a la fragmentación y al desperdicio de memoria (interna y externa). PagedAttention funciona como la memoria virtual en los sistemas operativos. Divide la caché KV en bloques no contiguos (páginas), lo que permite una gestión de la memoria mucho más flexible y eficiente. Reduce significativamente la sobrecarga de memoria (hasta en un 90% en algunos casos informados por los desarrolladores) y permite características como los prefijos compartidos sin duplicación de memoria.
• Procesamiento Continuo por Lotes: En lugar de esperar a que llegue un número fijo de solicitudes antes de iniciar el cálculo (procesamiento estático por lotes), el procesamiento continuo por lotes permite que el motor vLLM comience a procesar nuevas secuencias tan pronto como las antiguas terminen de generar tokens dentro de un lote. Esto mantiene la GPU constantemente ocupada, maximizando el rendimiento y reduciendo el tiempo de espera promedio de las solicitudes.

Estas dos técnicas trabajan juntas sinérgicamente para proporcionar las impresionantes características de rendimiento de vLLM.

Antes de Empezar con vLLM, Debes Comprobar:

Antes de que puedas instalar y ejecutar vLLM, asegúrate de que tu sistema cumple con los siguientes requisitos:

1. Sistema Operativo: Linux es el sistema operativo principal admitido. Si bien pueden existir esfuerzos de la comunidad para otros sistemas operativos (como WSL2 en Windows o macOS), Linux proporciona la experiencia más sencilla y oficialmente admitida.
2. Versión de Python: vLLM requiere Python 3.9, 3.10, 3.11 o 3.12. Se recomienda encarecidamente utilizar un entorno virtual para gestionar tus dependencias de Python.
3. GPU NVIDIA con CUDA: Para un rendimiento óptimo y acceso a las características principales, necesitas una GPU NVIDIA con una capacidad de cálculo admitida por PyTorch y el kit de herramientas CUDA necesario instalado. vLLM depende en gran medida de CUDA para sus kernels optimizados. Si bien la inferencia solo con CPU y el soporte para otros aceleradores (como las GPU AMD o AWS Inferentia/Trainium) están disponibles o en desarrollo, la ruta principal implica hardware NVIDIA. Consulta el sitio web oficial de PyTorch para la compatibilidad de CUDA con tu versión específica del controlador de la GPU.
4. PyTorch: vLLM está construido sobre PyTorch. El proceso de instalación normalmente se encarga de instalar una versión compatible, pero asegúrate de tener una instalación de PyTorch que funcione y que sea compatible con tu versión de CUDA si encuentras problemas.

Guía Paso a Paso para Instalar vLLM

La forma recomendada de instalar vLLM es utilizar un gestor de paquetes dentro de un entorno virtual. Esto evita conflictos con otros proyectos de Python. Aquí están los pasos utilizando herramientas populares:

Usando pip con vLLM

pip es el instalador de paquetes estándar de Python.

Crear y Activar un Entorno Virtual (Recomendado):

python -m venv vllm-env
source vllm-env/bin/activate
# On Windows use: vllm-env\\\\Scripts\\\\activate

Instalar vLLM:

pip install vllm

Este comando descargará e instalará la última versión estable de vLLM y sus dependencias principales, incluida una versión compatible de PyTorch para tu configuración de CUDA detectada (si es posible).

Usando Conda con vLLM

Conda es otro gestor de entornos y paquetes popular, especialmente en la comunidad de la ciencia de datos.

Crear y Activar un Entorno Conda:

conda create -n vllm-env python=3.11 -y # Or use 3.9, 3.10, 3.12
conda activate vllm-env

Instalar vLLM usando pip dentro de Conda: Generalmente se recomienda usar pip para instalar vLLM incluso dentro de un entorno Conda para asegurarte de obtener la última compilación compatible fácilmente.

pip install vllm

Es posible que primero debas instalar PyTorch por separado a través de Conda si prefieres gestionarlo de esa manera, asegurando la compatibilidad: conda install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch -c nvidia (ajusta la versión de CUDA según sea necesario). Luego ejecuta pip install vllm.

Usando uv con vLLM

uv es un instalador y resolutor de paquetes de Python más nuevo y extremadamente rápido.

Instalar uv (si aún no lo has hecho): Sigue las instrucciones en la documentación oficial de uv.

Crear y Activar un Entorno usando uv:

uv venv vllm-env --python 3.12 --seed # Or use 3.9, 3.10, 3.11
source vllm-env/bin/activate
# On Windows use: vllm-env\\\\Scripts\\\\activate

Instalar vLLM usando uv:

uv pip install vllm

Verificando tu Instalación de vLLM

Después de la instalación, puedes verificarlo rápidamente intentando importar vLLM en un intérprete de Python o ejecutando un comando básico:

# Activate your virtual environment first (e.g., source vllm-env/bin/activate)
python -c "import vllm; print(vllm.__version__)"

Esto debería imprimir la versión de vLLM instalada sin errores.

Alternativamente, prueba el comando de ayuda para el servidor (requiere una instalación exitosa):

vllm --help

Realizando la Inferencia por Lotes Fuera de Línea con vLLM

La inferencia por lotes fuera de línea se refiere a la generación de texto para una lista predefinida de prompts de entrada todos a la vez. Esto es útil para tareas como evaluar un modelo, generar respuestas para un conjunto de datos o pre-calcular resultados. vLLM hace que esto sea eficiente utilizando su clase LLM.

Comprendiendo la Clase LLM de vLLM

La clase vllm.LLM es el punto de entrada principal para la inferencia fuera de línea. La inicializas especificando el modelo que deseas utilizar.

from vllm import LLM

# Initialize the LLM engine with a model from Hugging Face Hub
# Make sure you have enough GPU memory for the chosen model!
# Example: Using a smaller model like OPT-125m
llm = LLM(model="facebook/opt-125m")

# Example: Using a larger model like Llama-3-8B-Instruct (requires significant GPU memory)
# llm = LLM(model="meta-llama/Meta-Llama-3-8B-Instruct")

print("vLLM engine initialized.")

De forma predeterminada, vLLM descarga modelos de Hugging Face Hub. Si tu modelo está alojado en ModelScope, debes establecer la variable de entorno VLLM_USE_MODELSCOPE=1 antes de ejecutar tu script de Python.

Configurando los Parámetros de Muestreo de vLLM

Para controlar cómo se genera el texto, utilizas la clase vllm.SamplingParams. Esto te permite establecer parámetros como:

• temperature: Controla la aleatoriedad. Los valores más bajos (por ejemplo, 0.2) hacen que la salida sea más determinista y enfocada; los valores más altos (por ejemplo, 0.8) aumentan la aleatoriedad.
• top_p (Muestreo de Núcleo): Considera solo los tokens más probables cuya probabilidad acumulada exceda top_p. Un valor común es 0.95.
• top_k: Considera solo los top_k tokens más probables en cada paso.
• max_tokens: El número máximo de tokens para generar para cada prompt.
• stop: Una lista de cadenas que, cuando se generan, detendrán el proceso de generación para ese prompt específico.

from vllm import SamplingParams

# Define sampling parameters
# If not specified, vLLM might use defaults from the model's generation_config.json
sampling_params = SamplingParams(
    temperature=0.7,
    top_p=0.9,
    max_tokens=100, # Limit the length of the generated text
    stop=["\\\\n", " Human:", " Assistant:"] # Stop generation if these tokens appear
)

print("Sampling parameters configured.")

Nota Importante: De forma predeterminada, vLLM intenta cargar y utilizar la configuración del archivo generation_config.json asociado con el modelo en Hugging Face Hub. Si deseas ignorar esto y utilizar los parámetros de muestreo predeterminados de vLLM a menos que tu objeto SamplingParams los anule, inicializa la clase LLM de esta manera: llm = LLM(model="...", generation_config="vllm"). Si proporcionas un objeto SamplingParams al método generate, esos parámetros siempre tendrán prioridad sobre la configuración del modelo y los valores predeterminados de vLLM.

Ejecutando tu Primer Trabajo por Lotes de vLLM

Ahora, combinemos el objeto LLM, SamplingParams y una lista de prompts para generar texto.

from vllm import LLM, SamplingParams

# 1. Define your input prompts
prompts = [
    "The capital of France is",
    "Explain the theory of relativity in simple terms:",
    "Write a short poem about a rainy day:",
    "Translate 'Hello, world!' to German:",
]

# 2. Configure sampling parameters
sampling_params = SamplingParams(temperature=0.7, top_p=0.95, max_tokens=150)

# 3. Initialize the vLLM engine (use a model suitable for your hardware)
try:
    # Using a relatively small, capable model
    llm = LLM(model="mistralai/Mistral-7B-Instruct-v0.1")
    # Or for smaller GPUs:
    # llm = LLM(model="facebook/opt-1.3b")
    # llm = LLM(model="facebook/opt-125m")
except Exception as e:
    print(f"Error initializing LLM: {e}")
    print("Please ensure you have enough GPU memory and CUDA is set up correctly.")
    exit()

# 4. Generate text for the prompts
# The generate method takes the list of prompts and sampling parameters
print("Generating responses...")
outputs = llm.generate(prompts, sampling_params)
print("Generation complete.")

# 5. Print the results
# The output is a list of RequestOutput objects
for output in outputs:
    prompt = output.prompt
    generated_text = output.outputs[0].text # Get the text from the first generated sequence
    print("-" * 20)
    print(f"Prompt: {prompt!r}")
    print(f"Generated Text: {generated_text!r}")
    print("-" * 20)

Este script inicializa vLLM, define prompts y parámetros, ejecuta el proceso de generación de manera eficiente en un lote y luego imprime la salida para cada prompt. La llamada llm.generate() gestiona las complejidades del procesamiento por lotes y la ejecución de la GPU internamente.

Configurando el Servidor Compatible con OpenAI de vLLM

Una de las características más poderosas de vLLM es su capacidad para actuar como un servidor backend de alto rendimiento que habla el mismo idioma que la API de OpenAI. Esto te permite alojar fácilmente tus propios modelos de código abierto e integrarlos en aplicaciones diseñadas para OpenAI.

Lanzando el Servidor vLLM

Iniciar el servidor es sencillo utilizando el comando vllm serve en tu terminal.

Activa tu entorno virtual donde está instalado vLLM.

source vllm-env/bin/activate

Ejecuta el comando vllm serve: Debes especificar el modelo que deseas servir.

# Example using Mistral-7B-Instruct
vllm serve mistralai/Mistral-7B-Instruct-v0.1

# Example using a smaller model like Qwen2-1.5B-Instruct
# vllm serve Qwen/Qwen2-1.5B-Instruct

Este comando hará lo siguiente:

• Descargará el modelo especificado (si aún no está en caché).
• Cargará el modelo en tu(s) GPU(s).
• Iniciará un servidor web (utilizando Uvicorn de forma predeterminada).
• Escuchará las solicitudes API entrantes, normalmente en http://localhost:8000.

Opciones Comunes:

• -model <model_name_or_path>: (Obligatorio) El modelo a servir.
• -host <ip_address>: La dirección IP a la que se enlazará el servidor (por ejemplo, 0.0.0.0 para que sea accesible en tu red). El valor predeterminado es localhost.
• -port <port_number>: El puerto en el que se escuchará. El valor predeterminado es 8000.
• -tensor-parallel-size <N>: Para el servicio multi-GPU, divide el modelo en N GPU.
• -api-key <your_key>: Si se establece, el servidor esperará esta clave API en el encabezado Authorization: Bearer <your_key> de las solicitudes entrantes. También puedes establecer la variable de entorno VLLM_API_KEY.
• -generation-config vllm: Utiliza los parámetros de muestreo predeterminados de vLLM en lugar del generation_config.json del modelo.
• -chat-template <path_to_template_file>: Utiliza un archivo de plantilla de chat Jinja personalizado en lugar del definido en la configuración del tokenizador.

El servidor mostrará registros que indican que se está ejecutando y está listo para aceptar solicitudes.

Interactuando con el Servidor vLLM: API de Completions

Una vez que el servidor está en funcionamiento, puedes enviar solicitudes a su endpoint /v1/completions, tal como lo harías con la API de completions más antigua de OpenAI.

Usando curl:

curl <http://localhost:8000/v1/completions> \\\\
    -H "Content-Type: application/json" \\\\
    -d '{
        "model": "mistralai/Mistral-7B-Instruct-v0.1",
        "prompt": "San Francisco is a city in",
        "max_tokens": 50,
        "temperature": 0.7
    }'

(Reemplaza "mistralai/Mistral-7B-Instruct-v0.1" con el modelo real que estás sirviendo)

Usando la Biblioteca de Python openai:

from openai import OpenAI

# Point the client to your vLLM server endpoint
client = OpenAI(
    api_key="EMPTY", # Use "EMPTY" or your actual key if you set one with --api-key
    base_url="<http://localhost:8000/v1>"
)

print("Sending request to vLLM server (Completions)...")

try:
    completion = client.completions.create(
        model="mistralai/Mistral-7B-Instruct-v0.1", # Model name must match the one served
        prompt="Explain the benefits of using vLLM:",
        max_tokens=150,
        temperature=0.5
    )

    print("Response:")
    print(completion.choices[0].text)

except Exception as e:
    print(f"An error occurred: {e}")

(Recuerda reemplazar el nombre del modelo si estás sirviendo uno diferente)

Interactuando con el Servidor vLLM: API de Chat Completions

vLLM también admite el endpoint /v1/chat/completions más moderno, adecuado para modelos conversacionales y formatos de mensajes estructurados (roles de sistema, usuario, asistente).

Usando curl:

curl <http://localhost:8000/v1/chat/completions> \\\\
    -H "Content-Type: application/json" \\\\
    -d '{
        "model": "mistralai/Mistral-7B-Instruct-v0.1",
        "messages": [
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": "What is the main advantage of PagedAttention in vLLM?"}
        ],
        "max_tokens": 100,
        "temperature": 0.7
    }'

(Reemplaza el nombre del modelo según sea necesario)

Usando la Biblioteca de Python openai:

from openai import OpenAI

# Point the client to your vLLM server endpoint
client = OpenAI(
    api_key="EMPTY", # Use "EMPTY" or your actual key
    base_url="<http://localhost:8000/v1>"
)

print("Sending request to vLLM server (Chat Completions)...")

try:
    chat_response = client.chat.completions.create(
        model="mistralai/Mistral-7B-Instruct-v0.1", # Model name must match the one served
        messages=[
            {"role": "system", "content": "You are a helpful programming assistant."},
            {"role": "user", "content": "Write a simple Python function to calculate factorial."}
        ],
        max_tokens=200,
        temperature=0.5
    )

    print("Response:")
    print(chat_response.choices[0].message.content)

except Exception as e:
    print(f"An error occurred: {e}")

(Recuerda reemplazar el nombre del modelo si es necesario)

Usar el servidor compatible con OpenAI es una forma poderosa de implementar endpoints de inferencia LLM de alto rendimiento con cambios mínimos en la lógica de tu aplicación existente.

Hablemos de los Backends de Atención de vLLM

vLLM utiliza "backends" especializados para calcular el mecanismo de atención de manera eficiente. Estos backends son implementaciones optimizadas que aprovechan diferentes bibliotecas o técnicas, principalmente dirigidas a las GPU NVIDIA. La elección del backend puede afectar el rendimiento y el uso de la memoria. Los principales incluyen:

1. FlashAttention: Utiliza la biblioteca FlashAttention (versiones 1 y 2). FlashAttention es un algoritmo de atención altamente optimizado que acelera significativamente el cálculo y reduce el uso de memoria al evitar la necesidad de materializar la gran matriz de atención intermedia en la memoria de alto ancho de banda (HBM) de la GPU. A menudo es la opción más rápida para muchas GPU modernas (como las arquitecturas Ampere, Hopper) y longitudes de secuencia. vLLM normalmente incluye ruedas precompiladas con soporte para FlashAttention.
2. Xformers: Aprovecha la biblioteca xFormers, desarrollada por Meta AI. xFormers también proporciona implementaciones de atención optimizadas y eficientes en memoria (como MemoryEfficientAttention). Ofrece una amplia compatibilidad con varias arquitecturas de GPU y puede ser una buena alternativa o respaldo si FlashAttention no está disponible u óptimo para un escenario específico. La instalación estándar de vLLM a menudo incluye soporte para xFormers.
3. FlashInfer: Una opción de backend más reciente que utiliza la biblioteca FlashInfer. FlashInfer proporciona kernels altamente optimizados diseñados específicamente para implementar LLM, centrándose en varios escenarios de prellenado y decodificación, incluidas características como la decodificación especulativa y el manejo eficiente de las cachés KV paginadas. Normalmente no hay ruedas vLLM precompiladas que contengan FlashInfer, lo que significa que debes instalarlo por separado en tu entorno antes de que vLLM pueda usarlo. Consulta la documentación oficial de FlashInfer o los Dockerfiles de vLLM para obtener instrucciones de instalación si tienes la intención de utilizar este backend.

Selección Automática de Backend: De forma predeterminada, vLLM detecta automáticamente el backend de atención más adecuado y de mejor rendimiento en función de tu hardware (arquitectura de la GPU), las bibliotecas instaladas (¿está disponible FlashAttention/xFormers/FlashInfer?) y el modelo específico que se está utilizando. Realiza comprobaciones para garantizar la compatibilidad y tiene como objetivo proporcionar el mejor rendimiento listo para usar sin configuración manual.

Selección Manual de Backend: En algunos casos de uso avanzados o con fines de evaluación comparativa, es posible que desees forzar a vLLM a utilizar un backend específico. Puedes hacerlo configurando la variable de entorno VLLM_ATTENTION_BACKEND antes de iniciar tu proceso vLLM (ya sea el script fuera de línea o el servidor).

# Example: Force using FlashAttention (if installed and compatible)
export VLLM_ATTENTION_BACKEND=FLASH_ATTN
python your_offline_script.py
# or
# export VLLM_ATTENTION_BACKEND=FLASH_ATTN
# vllm serve your_model ...

# Example: Force using xFormers
export VLLM_ATTENTION_BACKEND=XFORMERS
python your_offline_script.py

# Example: Force using FlashInfer (requires prior installation)
export VLLM_ATTENTION_BACKEND=FLASHINFER
python your_offline_script.py

Para la mayoría de los principiantes, se recomienda confiar en la selección automática de backend de vLLM. La configuración manual del backend normalmente se reserva para la experimentación o la resolución de problemas de rendimiento específicos.

Solución de Problemas Comunes de Instalación y Uso de vLLM

Si bien vLLM tiene como objetivo ser fácil de usar, es posible que encuentres algunos obstáculos comunes, especialmente durante la configuración. Aquí hay algunos problemas frecuentes y sus posibles soluciones:

1. Errores de Falta de Memoria CUDA (OOM):

• Problema: Ves errores como torch.cuda.OutOfMemoryError: CUDA out of memory.
• Causa: El LLM que estás intentando cargar requiere más VRAM de la GPU de la que está disponible en tu hardware. Los modelos más grandes (por ejemplo, 7B de parámetros y superiores) consumen una cantidad significativa de memoria.
• Soluciones:
• Utiliza un Modelo Más Pequeño: Intenta cargar primero una variante más pequeña (por ejemplo, opt-1.3b, Qwen/Qwen2-1.5B-Instruct) para confirmar que tu configuración funciona.
• Reduce el Tamaño del Lote (Servidor): Si bien vLLM gestiona el procesamiento por lotes dinámicamente, una concurrencia muy alta aún puede exceder la memoria. Supervisa el uso.
• Utiliza la Cuantización: Carga versiones cuantificadas del modelo (por ejemplo, AWQ, GPTQ, GGUF - consulta la documentación de vLLM para conocer los tipos de cuantización admitidos). La cuantización reduce la huella de memoria, a menudo con una pequeña compensación en la precisión. Ejemplo: llm = LLM(model="TheBloke/Mistral-7B-Instruct-v0.1-AWQ"). Ten en cuenta que es posible que sea necesario instalar bibliotecas de cuantización específicas.
• Paralelismo de Tensores: Si tienes varias GPU, utiliza el argumento -tensor-parallel-size N al iniciar el servidor o tensor_parallel_size=N al inicializar la clase LLM para distribuir el modelo en N GPU.
• Comprueba si hay Otros Procesos: Asegúrate de que ninguna otra aplicación esté consumiendo una cantidad significativa de memoria de la GPU. Utiliza nvidia-smi en la terminal para comprobar el uso de la memoria.

1. Errores de Instalación (Compatibilidad CUDA/PyTorch):

• Problema: pip install vllm falla con errores relacionados con CUDA, PyTorch o la compilación de extensiones.
• Causa: Desajuste entre el controlador NVIDIA instalado, la versión del kit de herramientas CUDA y la versión de PyTorch que vLLM está intentando instalar o utilizar.
• Soluciones:
• Comprueba la Compatibilidad: Asegúrate de que la versión de tu controlador NVIDIA sea compatible con la versión del kit de herramientas CUDA requerida por la compilación de PyTorch que pretendes utilizar. Consulta la matriz de instalación del sitio web de PyTorch.
• Instala PyTorch Manualmente: A veces, instalar explícitamente una versión compatible de PyTorch antes de instalar vLLM ayuda. Ve al sitio web oficial de PyTorch, selecciona tu sistema operativo, gestor de paquetes (pip/conda), plataforma de cálculo (versión de CUDA) y ejecuta el comando proporcionado. Luego, pip install vllm.
• Utiliza la Imagen Oficial de Docker: Considera la posibilidad de utilizar las imágenes oficiales de Docker de vLLM. Vienen preconfiguradas con versiones compatibles de CUDA, PyTorch y vLLM, evitando las molestias de la instalación local. Consulta Docker Hub para vllm/vllm-openai.
• Comprueba las Herramientas de Compilación: Asegúrate de tener instaladas las herramientas de compilación necesarias (build-essential en Debian/Ubuntu, o equivalente).

1. Fallos de Carga del Modelo:

• Problema: vLLM no puede cargar el modelo especificado, tal vez con errores de "no encontrado" o problemas de configuración.
• Causa: Nombre/ruta del modelo incorrectos, el