Acelere la carga del modelo LLM y aumente las ventanas de contexto con GPUDirect en Amazon FSx para Lustre y TurboQuant

Si está iterando sobre la implementación de modelos de lenguaje grande (LLM) en instancias de GPU de AWS, probablemente haya notado que cuanto más grande sea el modelo que se cargará en la memoria de alto ancho de banda (HBM) de la GPU, más larga será la dolorosa espera hasta que las GPU estén listas para la inferencia. A medida que los modelos crecen hasta alcanzar cientos de miles de millones de parámetros y los entornos de GPU crecen cada vez más, el tiempo de carga del modelo afecta negativamente el tiempo total de extremo a extremo hasta el primer token (TTFT). Esta publicación explora cómo Amazon FSx para Lustre, combinado con NVIDIA GPUDirect Storage (GDS), además de un poco de planificación inteligente, puede cambiar fundamentalmente la ecuación TTFT de arranque en frío. Reduce los minutos de tiempo de carga improductivo a segundos cada vez que se inicia su modelo. Mientras estamos en el tema de la optimización, esta publicación también cubrirá el efecto del caché TurboQuant KV recientemente anunciado en términos de un aumento masivo en el tamaño de la ventana de contexto.

Antecedentes: arquitectura NVIDIA Blackwell en AWS

AWS lanzó recientemente las familias de instancias Amazon EC2 P6e y P6, impulsadas por la arquitectura Blackwell de NVIDIA (vea el anuncio). El buque insignia P6e UltraServer incluye 72 GPU NVIDIA Blackwell en un único dominio NVLink con 130 TB/s de ancho de banda de bisección, 13,4 TB de HBM3e y 360 petaflops de cómputo FP8 (720 en FP4). Estos UltraServers se utilizan normalmente para el entrenamiento distribuido a gran escala de modelos de frontera en una escala de parámetros de varios billones.

En esta publicación, nos centramos en mejorar el TTFT de arranque en frío para una única instancia P6 o P5en. Específicamente, cubrimos cómo llevar los pesos de los modelos en el formato correcto a la memoria de HBM lo más rápido posible. Para UltraClusters con múltiples nodos, este mismo proceso se realizaría en paralelo en todos los nodos del clúster. Cada nodo en UltraServer carga el modelo independientemente del sistema de archivos compartido de FSx for Lustre, aprovechando el enorme rendimiento escalable habilitado para GDS que FSx for Lustre puede proporcionar.

El cuello de botella en la carga del modelo

Primero, considere la diferencia básica entre GPUDirect Storage y la carga de modelos basada en CPU. La carga de modelos tradicional basada en CPU (izquierda) transmite el punto de control a través de la memoria de la CPU y copia los pesos a cada GPU secuencialmente a través de PCIe. La carga de almacenamiento GPUDirect fragmentado (derecha) divide previamente el punto de control en rangos paralelos al tensor en Amazon FSx para Lustre, y las ocho GPU leen sus fragmentos en paralelo directamente en HBM a través de EFA, sin pasar por la CPU, como se muestra en la Figura 1.

Figura 1: Carga de modelo basada en CPU frente a carga de almacenamiento GPUDirect fragmentado en una instancia de 8 GPU.

Considere un modelo de parámetros 405B como Llama 3.1 405B, que son aproximadamente 800 GB de datos de puntos de control en BF16. La ruta de carga del modelo tradicional se parece a la siguiente:

Leer el archivo del modelo con puntos de control desde el almacenamiento en la memoria del sistema de la CPU Deserializar los pesos (análisis de torch.load o tensores de seguridad) Cuantizar opcionalmente en la CPU (BF16 → FP8 o INT4): esto reduce los requisitos de HBM. Copie los pesos de la memoria de la CPU a cada GPU a través de PCIe, uno a la vez.

Esta canalización está limitada en gran medida por ser de un solo subproceso, secuencial y vinculada a la CPU. En una implementación típica sin GDS, una carga de modelo de un solo subproceso con cuantificación del lado de la CPU tarda entre 10 y 20 minutos para Llama 3.1 405B. Incluso con puntos de control previamente fragmentados, todavía estás esperando varios minutos. Durante todo ese tiempo, sus GPU (el recurso más caro de la pila) permanecen inactivas, lo que aumenta el tiempo de arranque en frío del primer token.

Vale la pena señalar que las versiones recientes de marcos de servicio como vLLM han realizado mejoras significativas en la carga de modelos. El motor vLLM V1 (predeterminado desde vLLM 0.19) introdujo la carga de peso paralela en las GPU, lo que redujo considerablemente los tiempos de carga en comparación con versiones anteriores. Sin embargo, incluso con estas mejoras, los datos todavía fluyen a través de la memoria de la CPU y el bus PCIe. GDS elimina este cuello de botella por completo.

Para el servicio de inferencias, esto no es sólo un inconveniente. Los tiempos prolongados de carga del modelo impactan directamente:

Latencia de arranque en frío: las nuevas instancias no pueden atender el tráfico hasta que se carga el modelo Capacidad de respuesta de escalado automático: los eventos de escalado se retrasan en minutos, no en segundos Recuperación de fallas: si una instancia de servicio falla, la capacidad de reemplazo tarda unos minutos en ponerse en línea Rentabilidad: las horas de GPU consumidas durante la carga son horas de GPU que no atienden solicitudes

Un camino directo: FSx para Lustre con GPUDirect Storage

Amazon FSx for Lustre es un sistema de archivos paralelo de alto rendimiento y totalmente administrado diseñado para cargas de trabajo con uso intensivo de computación. Cuando se combina con la compatibilidad con NVIDIA GPUDirect Storage, FSx for Lustre establece múltiples rutas de datos directas directamente a la memoria de la GPU, sin pasar por la CPU y la memoria del sistema por completo.

Esta integración se basa en dos tecnologías clave que trabajan juntas:

Amazon Elastic Fabric Adapter (EFA) utiliza el protocolo de datagrama confiable escalable (SRD) de AWS para evitar la sobrecarga del sistema operativo. La instancia P5en tiene 16 interfaces EFA a 200 Gbps cada una, lo que proporciona 3200 Gbps (400 GB/s) de ancho de banda de red agregado. FSx for Lustre puede utilizar ocho o más de estas interfaces EFA para la transferencia directa de datos de almacenamiento a GPU. NVIDIA GPUDirect Storage (GDS) permite transferencias DMA directamente desde la interfaz de red a GPU HBM, eliminando el búfer de rebote de memoria de la CPU que crea el cuello de botella tradicional.

El resultado es una mejora significativa del rendimiento con respecto al acceso al almacenamiento tradicional basado en TCP. Pero el rendimiento bruto es sólo una parte de la historia. El verdadero desbloqueo proviene de lo que esta ruta directa permite arquitectónicamente: omitir la CPU cuando se utiliza la carga de modelos paralelos fragmentados.

Para nuestra configuración de prueba, utilizamos un sistema de archivos EFA Persistent_2 a 1000 MBps/TiB con 20 objetivos de almacenamiento de objetos (OST) (capacidad de 96 TiB), lo que ofrece aproximadamente 94 GiB/s de rendimiento del sistema de archivos. El rendimiento aumenta linealmente con la capacidad del sistema de archivos. Un sistema de archivos más grande significa más OST y más rutas de E/S paralelas. Para obtener un tutorial sobre cómo crear FSx de alto rendimiento para sistemas de archivos Lustre, consulte un blog anterior, Construya e implemente un sistema de archivos de 1 TB/s en menos de una hora. Consulte la Etapa 0 en la siguiente sección para conocer los comandos de configuración.

Para configurar su cliente P5en para acceso habilitado para GDS a FSx for Lustre, siga los pasos en Configuración de clientes EFA en la Guía del usuario de FSx for Lustre. El script de configuración proporcionado por AWS (setup.sh –optimized-for-gds) detecta automáticamente su tipo de instancia, configura las interfaces EFA correctas con partición de CPU compatible con NUMA y crea un servicio systemd para que la configuración persista durante los reinicios. El P5en de forma predeterminada solo usa 8 de sus interfaces EFA para FSx para Lustre, que proporciona la ruta de datos GDS directa desde el almacenamiento al HBM de cada GPU.

Carga paralela fragmentada en P5en (8x H200)

Para ilustrar el enfoque de carga fragmentada, usaremos la instancia P5en (p5en.48xlarge): 8 GPU NVIDIA H200 con 141 GB de HBM3e cada una, conectadas mediante NVSwitch con 3,6 TB/s de ancho de banda de bisección. El P5en es compatible con GDS y tiene la misma red SRD EFA de 3200 Gbps que el P6-B200, lo que lo convierte en una plataforma muy adecuada para demostrar este patrón. Las características de rendimiento para la etapa de lectura de almacenamiento serían idénticas en un nodo P6 porque cada nodo tiene el mismo ancho de banda de red por instancia.

Para cualquier modelo suficientemente grande (como Llama 3.1 405B con 400 GB en FP8), los pesos no caben en una sola GPU HBM (141 GB en el H200). Se requiere paralelismo tensorial, dividiendo el modelo en varias GPU. Esto implica una comunicación de baja latencia entre GPU a través de NVLink durante la inferencia (para operaciones de reducción total después de la atención y capas de perceptrón multicapa (MLP), por lo que las instancias conectadas a NVSwitch como P5en y P6 son esenciales para servir estos modelos. El enfoque funciona en cuatro etapas: si bien usamos Llama 3.1 405B como nuestro modelo de referencia, este patrón se aplica a cualquier modelo que admita fragmentación tensor-paralela, incluido Mixtral. DeepSeek y arquitecturas personalizadas. El requisito clave es que el marco de servicio pueda dividir el modelo en fragmentos por GPU.

Etapa 0: Aprovisionamiento de la infraestructura. Antes de cargar cualquier modelo, necesita dos cosas en la misma nube privada virtual de Amazon (Amazon VPC) y zona de disponibilidad (AZ): un sistema de archivos FSx para Lustre habilitado para EFA y una instancia de GPU P5en (o P6) configurada para almacenamiento GPUDirect. Proporcionamos plantillas de AWS CloudFormation y scripts de configuración en el repositorio de muestras de aws adjunto que automatizan el aprovisionamiento de infraestructura y la configuración de GDS que se describen en la siguiente sección.

El sistema de archivos FSx para Lustre debe ser una implementación SSD Persistent_2 con EFA habilitado y una configuración de rendimiento de 1000 MBps/TiB, como se describe en la sección anterior Una ruta directa. La capacidad del sistema de archivos determina su rendimiento de lectura agregado. Más capacidad significa más OST y más rutas de E/S paralelas.

La instancia P5en necesita configurar todas sus interfaces EFA, instalar el controlador EFA, crear y cargar el módulo del kernel NVIDIA GDS nvidia-fs.ko, configurar la red del cliente Lustre compatible con NUMA para un rendimiento óptimo y configurar el tiempo de ejecución de GDS (cufile.json). Esto implica varios pasos: construir el módulo NVIDIA nvidia-fs.ko, alinear las interfaces EFA con las particiones de la CPU según la topología NUMA de la instancia y ajustar los parámetros del cliente Lustre. Siga la guía Configuración de clientes EFA en la Guía del usuario de FSx for Lustre para conocer el procedimiento de configuración completo.

Una vez que la infraestructura esté lista, configure la creación de bandas Lustre en el directorio de salida para garantizar que las lecturas GDS simultáneas de varias GPU se distribuyan en todos los OST:

# Separación en todos los OST con un tamaño de franja de 16 MB (coincide con el tamaño de bloque GDS óptimo) mkdir -p /fsx/model_shards/Llama-3.1-405B-FP8-8way lfs setstripe -c -1 -S 16M /fsx/model_shards/Llama-3.1-405B-FP8-8way

Etapa 1: fragmentación previa y cuantificación previa de los pesos del modelo. Sin conexión, use vLLM para dividir el modelo en 8 fragmentos de tensor paralelo con cuantización FP8 y guárdelos en FSx para Lustre. El punto de control de origen está en BF16 (el formato estándar para Llama 3.1 en HuggingFace). El paso previo a la fragmentación cuantifica los pesos en FP8, reduciendo a la mitad los datos que deben cargarse a través de GDS:

python save_sharded_state.py –model /fsx/models/Llama-3.1-405B –quantization fp8 –tensor-parallel-size 8 –output /fsx/model_shards/Llama-3.1-405B-FP8-8way

Esto produce 8 fragmentos compatibles con tensores paralelos (TP), donde cada fragmento contiene exactamente los segmentos de peso que la GPU necesita para la inferencia. Los encabezados de atención y las columnas MLP se dividen correctamente entre las GPU. Los fragmentos están precuantizados para FP8, lo que reduce el tamaño total del punto de control de ~800 GB a ~400 GB. El directorio de salida se verá así:

/fsx/model_shards/Llama-3.1-405B-FP8-8way/ ├── model-rank-0-part-0.safetensors # ~51 GB — Porciones de GPU 0 ├── model-rank-1-part-0.safetensors # ~51 GB — Porciones de GPU 1 ├──… ├── model-rank-7-part-0.safetensors # ~51 GB — Porciones de GPU 7 ├── config.json ├── tokenizer.json └── tokenizer_config.json

Este paso previo a la fragmentación debe repetirse cada vez que actualice el punto de control del modelo base, por ejemplo, después de realizar un ajuste fino o cambiar a una nueva versión del modelo. Debido a que se ejecuta sin conexión y la salida fragmentada se reutiliza en cada carga posterior, el costo amortizado es mínimo.

Si controlas el proceso de capacitación, puedes eliminar este paso por completo. Los marcos como Megatron-LM y NeMo pueden guardar puntos de control directamente en el diseño paralelo al tensor y la precisión que espera su pila de servicio. Por ejemplo, fragmentos TP de 8 vías en formato de tensores de seguridad FP8. Cuando el entrenamiento se guarda en el formato de publicación, el punto de control está listo para la carga paralela de GDS sin posprocesamiento. Tenga en cuenta que Megatron-LM guarda los puntos de control en formato torch_dist de forma predeterminada, lo que requiere una conversión mediante Megatron Bridge antes de que los fragmentos puedan usarse con cargadores basados ​​en tensores de seguridad, un paso de conversión único que agrega una sobrecarga mínima.

Elegimos FP8 para esta publicación porque es un tipo de datos de primera clase en H200 y B200 con soporte nativo de Tensor Core, requiere un solo indicador en vLLM (–cuantización fp8) y ofrece una pérdida de precisión cercana a cero en modelos de clase Llama. Los métodos de cuantificación de peso de 4 bits más agresivos (AWQ, GPTQ y HQQ), combinados con kernels de servicio W4A16 optimizados en vLLM, pueden reducir el tamaño del punto de control en otras 2 veces y mejorar el rendimiento de generación en cargas de trabajo con ancho de banda limitado (2 a 3 veces frente a FP8 en tamaños de lotes pequeños en H100/H200). AWQ y GPTQ requieren un breve paso de calibración sobre datos representativos. HQQ no tiene datos. El patrón de carga de GDS en esta publicación es independiente del método de cuantificación. Cualquiera que sea el formato que admita su marco de servicio, la carga fragmentada paralela de FSx para Lustre se aplica de la misma manera. Un punto de control 405B de 4 bits se carga en aproximadamente la mitad del tiempo que los resultados del FP8 informados en la siguiente sección.

La cuantificación del FP8 reduce a la mitad el tamaño del punto de control y, por tanto, el tiempo de carga, pero la cuantificación del peso no es la única palanca disponible. Las técnicas emergentes como TurboQuant (Google Research, ICLR 2026) y su método PolarQuant subyacente tienen como objetivo la caché de valor clave (KV). La memoria que crece con la longitud del contexto durante la inferencia. TurboQuant comprime la caché KV a aproximadamente 3 bits por valor (una reducción de 6x), con una aceleración de hasta 8x en el cálculo de la atención en las GPU NVIDIA H100 y cero pérdida de precisión, todo sin ajustes, según los autores. Si bien estos métodos no reducen directamente el tamaño del punto de control o el tiempo de carga del modelo, reducen significativamente el consumo de HBM durante la inferencia, limpiando la memoria de la GPU para ventanas de contexto más largas o tamaños de lote más grandes. Combinada con la cuantificación de peso del FP8 utilizada en esta publicación, la compresión de caché KV reduce aún más los requisitos generales de HBM. Esto puede ayudarle a atender modelos más grandes o más solicitudes simultáneas en el mismo hardware.

Etapa 2: lecturas GDS paralelas. En el momento de la carga, las 8 GPU leen simultáneamente su fragmento asignado directamente desde FSx for Lustre a la GPU HBM a través de GDS. Debido a que los fragmentos fueron precuantificados para FP8, los datos totales a leer son aproximadamente 400 GB, o alrededor de 50 GB por GPU. GDS omite por completo la memoria de la CPU, por lo que no hay serialización a través del host. Las 8 lecturas ocurren en paralelo.

Para la ruta de lectura de GDS, utilizamos fastsafetensors, una biblioteca de código abierto que lee archivos de safetensors directamente en la memoria de la GPU utilizando NVIDIA cuFile (la API de GDS) y reconstruye los tensores de PyTorch sin ninguna deserialización del lado de la CPU. Cada GPU abre su archivo de fragmento, realiza una única lectura GDS grande en un búfer de GPU y luego extrae todos los tensores del búfer utilizando los metadatos del encabezado de los tensores seguros. El paso de extracción del tensor toma menos de un milisegundo porque es aritmética de punteros en el búfer de la GPU ya cargado.

Antes de cargar el modelo, verifique que el módulo del kernel GDS esté cargado y que el cliente Lustre esté configurado para EFA:

# Verificar que el módulo del kernel GDS esté cargado lsmod | grep nvidia_fs # Verifique que las interfaces EFA estén activas para Lustre sudo lnetctl net show | grep -c "nid:.*@efa" # Debe mostrar 16 (una por interfaz EFA configurada para Lustre; no todas las NIC de instancia) # En implementaciones de un solo nodo, el script de configuración configura las 16 interfaces EFA para Lustre. # En configuraciones de múltiples nodos de UltraCluster, puede configurar 8 interfaces para FSx # y reservar las 8 restantes para el tráfico colectivo NCCL entre nodos.

Si nvidia_fs no está cargado, las lecturas de GDS volverán silenciosamente a la ruta del búfer de rebote de la CPU. Seguirá obteniendo resultados correctos, pero sin el beneficio de rendimiento. Cargue el módulo con sudo modprobe nvidia_fs. Usando fastsafetensors, cada GPU carga su fragmento en paralelo:

from fastsafetensors import SafeTensorsFileLoader # Cada GPU carga su propio fragmento a través del cargador GDS = SafeTensorsFileLoader(pg=None, device=f"cuda:{rank}", nogds=False) loader.add_filenames({0: [f"/fsx/model_shards/Llama-3.1-405B-FP8-8way/model-rank-{rank}-part-0.safetensors"]}) fbuf = loader.copy_files_to_device() # Lectura de GDS: almacenamiento → GPU HBM directamente # Extrae tensores: submilisegundo, solo apunta los cálculos al búfer de GPU tensores = {nombre: fbuf.get_tensor(nombre) para nombre en loader.get_keys()}

Etapa 3: Verificar y servir. Una vez que los tensores se cargan en la GPU HBM a través de GDS, todos los cálculos de inferencia se ejecutan completamente desde la memoria de la GPU. El sistema de archivos sólo participa durante la carga inicial. El diccionario de tensores de la Etapa 2 contiene todos los pesos para este rango, ya en el dispositivo GPU correcto y en el diseño paralelo de tensores correcto. No se tocó ninguna memoria de la CPU, no se produjo ninguna deserialización. Los pesos pasaron directamente de FSx para el almacenamiento Lustre a GPU HBM.

Estos tensores están listos para cualquier motor de inferencia de tensores paralelos que acepte diccionarios de pesos precargados. El punto de integración es específico del marco: vLLM, TensorRT-LLM y SGLang tienen API internas para inyectar pesos en sus gráficos de modelo compatibles con TP. A medida que estos marcos adoptan la carga de peso compatible con GDS de forma nativa (fastsafetensors fue creado exactamente para esta integración por el equipo de Foundation Model Stack), la ruta GDS completa que se muestra en la Etapa 2 se convertirá en una operación de un solo comando.

Para el servicio de producción actual, vLLM puede cargar los mismos puntos de control previamente fragmentados desde FSx para Lustre:

vllm servir /fsx/model_shards/Llama-3.1-405B-FP8-8way –load-format sharded_state –quantization fp8 –tensor-parallel-size 8

El cargador de peso integrado de vLLM utiliza la ruta de lectura estándar basada en CPU en lugar de GDS. El formato prefragmentado aún elimina la sobrecarga de deserialización y división de peso por GPU que domina la carga de punto de control estándar, lo que reduce el tiempo de carga de aproximadamente 18 minutos a aproximadamente 2 minutos para Llama 3.1 405B (consulte las tablas de rendimiento en la siguiente sección). La ruta paralela GDS en la Etapa 2 lleva esto más lejos, reduciendo aproximadamente 2 minutos a aproximadamente 6 segundos.

La diferencia de rendimiento

Estos son los resultados medidos. Las siguientes tablas comparan los tiempos de carga del modelo entre diferentes métodos de carga en una instancia P5en (8x H200) con un sistema de archivos EFA Persistent_2 de 96 TiB (20 OST, rendimiento del sistema de archivos de ~94 GiB/s).

Medido: Llama 3.1 70B Instruct (TP de 8 vías, caché en frío)

Método de carga Tiempo de carga total Aceleración Carga vLLM estándar (punto de control BF16, cuantificación en carga FP8, sin GDS) ~3 min Carga paralela 1x GDS: fragmentos BF16 (141 GB) 2,17 s ~83x Carga paralela GDS: fragmentos FP8 (72 GB) 1,28 s ~141x

Los tiempos de carga de GDS son por rango (las 8 GPU se cargan en paralelo) utilizando fastsafetensors, que lee archivos de safetensors directamente en la memoria de la GPU a través de GDS y reconstruye los tensores. No hay búfer de rebote de CPU ni sobrecarga de deserialización. Cada rango carga su fragmento y tiene los 1124 tensores listos en el dispositivo GPU correcto en poco más de un segundo. Los tiempos de referencia incluyen la inicialización y el calentamiento del motor vLLM además de la carga de peso, por lo que las filas de GDS representan específicamente el tiempo de transferencia de almacenamiento a GPU.

Medido: Llama 3.1 405B Instruct (TP de 8 vías, caché en frío)

Método de carga Tiempo de carga total Aceleración Carga vLLM estándar (punto de control BF16, cuantificación en carga FP8, sin GDS) ~18 min 1 carga paralela GDS: fragmentos BF16 (812 GB) 10,4 s ~104x Carga paralela GDS: fragmentos FP8 (408 GB) 6,4 s ~169x

Estos resultados se midieron en un sistema de archivos de 96 TiB (20 OST). Dado que el rendimiento de GDS aumenta linealmente con el recuento de OST, un sistema de archivos más grande reduciría los tiempos de carga proporcionalmente. Por ejemplo, un sistema de archivos de 342 TiB con 57 OST podría reducir el tiempo de carga del FP8 a menos de 3 segundos. La matemática de escala: 94 GiB/s × 57/20 OST ≈ techo teórico de 268 GiB/s. De manera conservadora, ~190 GiB/s que representan la sobrecarga por OST significa 408 GB ÷ 190 GiB/s ≈ 2,0 segundos. El rendimiento de carga sería idéntico en un nodo P6, que tiene el mismo ancho de banda EFA por instancia. Este patrón es más impactante para modelos lo suficientemente grandes como para requerir paralelismo tensorial en múltiples GPU. Ahí es donde entra en juego la ventaja de la lectura paralela. Para los modelos más pequeños que caben en una sola GPU, el cuello de botella de carga tradicional es la CPU (deserialización, cuantificación y transferencia PCIe en serie), y GDS con lecturas paralelas tiene menos que ofrecer. Después de dividirse en varias GPU, cada una puede leer su fragmento de forma independiente a través de GDS y la CPU ya no se encuentra en la ruta crítica. Incluso con puntos de control precuantizados, la ruta de un solo subproceso aún dedica mucho tiempo a la deserialización y copias seriales de host a dispositivo en las 8 GPU a través de PCIe. Esto explica la brecha entre el tiempo de lectura del almacenamiento sin procesar y el tiempo de carga total. El enfoque GDS fragmentado carga 408 GB de pesos del modelo FP8 en 8 GPU en 6,4 segundos. Esto es aproximadamente 169 veces más rápido que una carga vLLM estándar sin GDS y en un sistema de archivos de 96 TiB. Un sistema de archivos más grande aumentaría aún más la velocidad. Esta es la diferencia entre "ir a almorzar" y "ya está hecho". La aceleración proviene de eliminar todos los cuellos de botella en el camino tradicional simultáneamente:

Sin búfer de rebote de CPU: GDS lee directamente en GPU HBM Sin deserialización en serie: los pesos de los modelos previamente fragmentados están listos para cargarse tal cual Sin cuantificación de CPU: precuantizado fuera de línea, no en el momento de la carga Sin carga secuencial de GPU: las 8 GPU se leen en paralelo No es necesario reunir todo: los fragmentos compatibles con TP significan que cada GPU ya tiene exactamente los pesos que necesita

Pero la carga rápida es sólo la mitad de la historia. La cuantificación del FP8 no solo reduce el tiempo de carga, sino que también reduce a la mitad la huella de HBM de los pesos del modelo, liberando memoria para el caché y el servicio de KV. Combinada con la compresión de caché KV de TurboQuant (3 a 4 bits por valor), la memoria GPU utilizable para inferencia aumenta drásticamente:

P5en (8x H200) Nodo P6 (8x B200) HBM por GPU 141 GB (HBM3e) 192 GB (HBM3e) HBM total 1128 GB 1536 GB Pesos 405B FP8 por GPU ~51 GB ~51 GB HBM libre por GPU para caché KV ~85 GB ~136 GB Capacidad de contexto de caché KV FP16 ~82K tokens ~131.000 tokens Con TurboQuant K4/V4 (~3,76x) ~310.000 tokens ~495.000 tokens Con TurboQuant K4/V3 (~5x) ~412.000 tokens ~660.000 tokens

La combinación de pesos FP8 y compresión de caché TurboQuant KV significa que puede ofrecer Llama 3.1 405B con ventanas de contexto que superen los 400 000 tokens en un solo P5en, o casi 500 000 tokens en un nodo P6. Ésta es la diferencia entre manejar unos pocos documentos y procesar un libro completo en una sola solicitud.

También vale la pena señalar que el sistema de archivos FSx para Lustre no es una infraestructura de propósito único. El mismo sistema de archivos que acelera la carga de modelos puede servir como almacenamiento compartido para datos de entrenamiento, puntos de control, conjuntos de datos y artefactos de modelos en todo su equipo. Al reducir el tiempo de inactividad de la GPU durante las cargas del modelo, aumenta la velocidad a la que puede iterar en las pruebas y evaluaciones del modelo. Cargar una nueva variante de modelo en segundos en lugar de minutos significa más experimentos por día. Consulte FSx para conocer los precios de Lustre para conocer las tarifas actuales.

Integración con marcos de servicio.

Este patrón funciona con los marcos de servicio de inferencia que probablemente ya esté utilizando.

TensorRT-LLM admite de forma nativa la carga de puntos de control paralelos a tensores. Usted convierte y construye motores con paralelismo tensorial de 8 vías y los lanza en todas las GPU con mpirun. Cuando el sistema de archivos subyacente admite GDS, TensorRT-LLM puede aprovechar la ruta directa de almacenamiento a GPU automáticamente.

vLLM admite el paralelismo tensor entre GPU y se puede configurar para servir modelos con –tensor-parallel-size 8. Si bien la ruta de carga predeterminada de vLLM está basada en CPU, el enfoque de punto de control previamente fragmentado combinado con el almacenamiento habilitado para GDS proporciona aceleración de E/S a nivel del sistema de archivos.

Resumen

Al combinar Amazon FSx for Lustre con NVIDIA GPUDirect Storage y puntos de control de modelo previamente fragmentados y cuantificados, redujimos los tiempos de carga de Llama 3.1 405B de 10 a 20 minutos sin GDS a 6 segundos con GDS en un sistema de archivos de 96 TiB. Se pueden obtener más beneficios escalando a sistemas de archivos más grandes. Además, al aplicar la compresión de caché TurboQuant KV (de 3 a 4 bits por valor), la ventana de contexto disponible para Llama 3.1 405B aumenta de aproximadamente 82 000 tokens a más de 400 000 tokens en un P5en, o de aproximadamente 131 000 a aproximadamente 660 000 tokens en un P6. Esta es una mejora 5 veces mayor con respecto al mismo hardware.

Los beneficios clave de este enfoque:

Arranques en frío dramáticamente más rápidos: las nuevas instancias de inferencia están listas en segundos, no en minutos Escalado automático mejorado: los eventos de escalamiento responden casi en tiempo real a los picos de demanda Menor costo por token: las GPU dedican su tiempo a realizar inferencias, no a esperar a que se carguen los pesos Recuperación de fallas más rápida: las instancias fallidas se reemplazan y atienden el tráfico en segundos Escala con el clúster: cada nodo en un UltraCluster se carga independientemente del mismo sistema de archivos compartido en paralelo Ventanas de contexto enormemente aumentadas: la compresión de caché TurboQuant KV permite Contexto 5 veces más largo en el mismo hardware

Este patrón funciona hoy en instancias P5en y P6 con FSx para sistemas de archivos Lustre Persistent_2 EFA, utilizando marcos de servicio estándar como vLLM y TensorRT-LLM. Comience hoy cargando sus modelos más grandes más rápido.

Sobre el autor

Randy C Seamans

Randy es un veterano de la industria de HPC/AI/Almacenamiento y es arquitecto principal de sistemas en AWS, y se especializa en almacenamiento de alto rendimiento, computación (HPC/AI) y almacenamiento empresarial y recuperación de desastres. Randy posee una patente relacionada con la IA. Puede encontrar más información valiosa de Randy en los canales de almacenamiento de AWS, HPC o aprendizaje automático.