Optimización de la inferencia del modelo PyTorch en AWS Graviton

Los modelos de IA/ML pueden ser una tarea extremadamente costosa. Muchas de nuestras publicaciones se han centrado en una amplia variedad de consejos, trucos y técnicas para analizar y optimizar el rendimiento en tiempo de ejecución de cargas de trabajo de IA/ML. Nuestro argumento ha sido doble:

El análisis y las optimizaciones del rendimiento deben ser un proceso integral de cada proyecto de desarrollo de IA/ML, y alcanzar aumentos significativos del rendimiento y reducción de costos no requiere un alto grado de especialización. Cualquier desarrollador de IA/ML puede hacerlo. Todo desarrollador de IA/ML debería hacerlo.

, abordamos el desafío de optimizar una carga de trabajo de inferencia de ML en un procesador Intel® Xeon®. Comenzamos revisando una serie de escenarios en los que una CPU podría ser la mejor opción para la inferencia de IA/ML incluso en una era de múltiples chips de inferencia de IA dedicados. Luego presentamos un modelo PyTorch de clasificación de imágenes de juguete y procedimos a demostrar una amplia cantidad de técnicas para aumentar su rendimiento en tiempo de ejecución en una instancia Amazon EC2 c7i.xlarge, impulsada por procesadores escalables Intel Xeon de cuarta generación. En esta publicación, ampliamos nuestra discusión a las CPU Graviton basadas en Arm de cosecha propia de AWS. Revisaremos muchas de las optimizaciones que discutimos en nuestras publicaciones anteriores (algunas de las cuales requerirán adaptación al procesador Arm) y evaluaremos su impacto en el mismo modelo de juguete. Dadas las profundas diferencias entre los procesadores Arm e Intel, los caminos hacia la configuración de mejor rendimiento pueden tomar caminos diferentes.

AWS Gravitón

AWS Graviton es una familia de procesadores basados ​​en CPU Arm Neoverse, que AWS diseña y construye a medida para lograr una relación precio-rendimiento y una eficiencia energética óptimas. Sus motores dedicados para procesamiento de vectores (NEON y SVE/SVE2) y multiplicación de matrices (MMLA), y su soporte para operaciones Bfloat16 (a partir de Graviton3), los convierten en un candidato convincente para ejecutar cargas de trabajo informáticas intensivas, como la inferencia AI/ML. Para facilitar la IA/ML de alto rendimiento en Graviton, toda la pila de software se ha optimizado para su uso:

Los núcleos de computación de bajo nivel de Arm Compute Library (ACL) están altamente optimizados para aprovechar los aceleradores de hardware Graviton (por ejemplo, SVE y MMLA). Las bibliotecas de middleware de aprendizaje automático, como oneDNN y OpenBLAS, dirigen el aprendizaje profundo y las operaciones de álgebra lineal a los núcleos ACL especializados. Los marcos de IA/ML como PyTorch y TensorFlow se compilan y configuran para utilizar estos backends optimizados.

En esta publicación utilizaremos una instancia Amazon EC2 c8g.xlarge impulsada por cuatro procesadores AWS Graviton4 y una AMI de aprendizaje profundo PyTorch (DLAMI) de AWS ARM64.

La intención de esta publicación es demostrar consejos para mejorar el rendimiento en una instancia de AWS Graviton. Es importante destacar que nuestra intención no es establecer una comparación entre AWS Graviton y chips alternativos, ni abogar por el uso de un chip sobre el otro. La mejor elección de procesador depende de una gran cantidad de consideraciones que van más allá del alcance de esta publicación. Una de las consideraciones importantes será el rendimiento máximo de ejecución de su modelo en cada chip. En otras palabras: ¿cuánto podemos obtener por nuestro dinero? Así, tomar una decisión informada sobre el mejor procesador es una de las motivaciones para optimizar el rendimiento en tiempo de ejecución de cada uno.

Otra motivación para optimizar el rendimiento de nuestro modelo para múltiples dispositivos de inferencia es aumentar su portabilidad. El campo de juego de AI/ML es extremadamente dinámico y la resiliencia a las circunstancias cambiantes es crucial para el éxito. No es raro que instancias informáticas de ciertos tipos de repente dejen de estar disponibles o sean escasas. Por el contrario, un aumento en la capacidad de las instancias de AWS Graviton podría implicar su disponibilidad con grandes descuentos, por ejemplo, en el mercado de instancias puntuales de Amazon EC2, lo que presenta oportunidades de ahorro de costos que no querrá perderse.

Descargos de responsabilidad

El código de bloques que compartiremos, los pasos de optimización que analizaremos y los resultados que alcanzaremos pretenden ser un ejemplo de los beneficios que puede ver de la optimización del rendimiento de ML en una instancia de AWS Graviton. Estos pueden diferir considerablemente de los resultados que podría ver con su propio modelo y entorno de ejecución. No confíe en la exactitud u optimidad del contenido de esta publicación. No interprete la mención de ninguna biblioteca, marco o plataforma como una aprobación de su uso.

Optimización de inferencia en AWS Graviton

Como en nuestra publicación anterior, demostraremos los pasos de optimización en un modelo de clasificación de imágenes de juguetes:

importar antorcha, torchvision importar tiempo def get_model(channels_last=False, compile=False): modelo = torchvision.models.resnet50() if canales_last: model= model.to(memory_format=torch.channels_last) model = model.eval() if compilar: model = torch.compile(model) devolver modelo def get_input(batch_size, canales_last=False): lote = torch.randn(batch_size, 3, 224, 224) if canales_last: lote = lote.to(memory_format=torch.channels_last) devolver lote def get_inference_fn(modelo, enable_amp=False): def infer_fn(batch): con torch.inference_mode(), torch.amp.autocast( 'cpu', dtype=torch.bfloat16, habilitado=enable_amp ): salida = modelo(lote) retorno salida retorno infer_fn def benchmark(infer_fn, lote): # calentamiento para _ en rango(20): _ = infer_fn(lote) iters = 100 inicio = time.time() para _ en rango(iters): _ = infer_fn(lote) fin = time.time() retorno (fin – inicio) / iters tamaño_lote = 1 modelo = get_model() lote = get_input(batch_size) infer_fn = get_inference_fn(model) avg_time = benchmark(infer_fn, lote) print(f"nMuestras promedio por segundo: {(batch_size/avg_time):.2f}")

El rendimiento inicial es de 12 muestras por segundo (SPS).

Actualice a la versión más reciente de PyTorch

Mientras que la versión de PyTorch en nuestra DLAMI es 2.8, la última versión de PyTorch, al momento de escribir este artículo, es 2.9. Dado el rápido ritmo de desarrollo en el campo de AI/ML, se recomienda encarecidamente utilizar los paquetes de biblioteca más actualizados. Como primer paso, actualizamos a PyTorch 2.9, que incluye actualizaciones clave para su backend Arm.

pip3 instalar -U antorcha torchvision –index-url https://download.pytorch.org/whl/cpu

En el caso de nuestro modelo en su configuración inicial, actualizar la versión de PyTorch no tiene ningún efecto. Sin embargo, este paso es crucial para aprovechar al máximo las técnicas de optimización que evaluaremos.

Inferencia por lotes

Para reducir los gastos generales de lanzamiento y aumentar la utilización de los aceleradores de HW, agrupamos muestras y aplicamos inferencia por lotes. La siguiente tabla demuestra cómo varía el rendimiento del modelo en función del tamaño del lote:

Rendimiento de inferencia para diferentes tamaños de lotes (por autor)

Optimizaciones de memoria

Aplicamos una serie de técnicas de nuestra publicación anterior para optimizar la asignación y el uso de la memoria. Estos incluyen el formato de memoria del último canal, precisión mixta automática con el tipo de datos bfloat16 (compatible con Graviton3), la biblioteca de asignación TCMalloc y una enorme asignación de páginas. Consulte el para más detalles. También habilitamos el modo matemático rápido de los núcleos ACL GEMM y el almacenamiento en caché de las primitivas del núcleo: dos optimizaciones que aparecen en las pautas oficiales para ejecutar la inferencia de PyTorch en Graviton.

Las instrucciones de la línea de comando necesarias para habilitar estas optimizaciones se muestran a continuación:

# instalar TCMalloc sudo apt-get install google-perftools # Programar el uso de TCMalloc export LD_PRELOAD=/usr/lib/aarch64-linux-gnu/libtcmalloc.so.4 # Habilitar exportación de asignación de memoria de página enorme THP_MEM_ALLOC_ENABLE=1 # Habilitar el modo matemático rápido de exportación de kernels GEMM DNNL_DEFAULT_FPMATH_MODE=BF16 # Establece la capacidad de caché LRU para almacenar en caché las primitivas del kernel exportar LRU_CACHE_CAPACITY=1024

La siguiente tabla captura el impacto de las optimizaciones de memoria, aplicadas sucesivamente:

Resultados de optimización de memoria ResNet-50 (por autor)

En el caso de nuestro modelo de juguete, las optimizaciones de precisión mixtas de canales últimos y bfloat16 tuvieron el mayor impacto. Después de aplicar todas las optimizaciones de memoria, el rendimiento promedio es 53,03 SPS.

Compilación de modelos

El soporte de la compilación de PyTorch para AWS Graviton es un área de esfuerzo enfocado del equipo de AWS Graviton. Sin embargo, en el caso de nuestro modelo de juguete, se produce una ligera reducción en el rendimiento, de 53,03 SPS a 52,23.

Inferencia de múltiples trabajadores

Aunque normalmente se aplica en entornos con más de cuatro vCPU, demostramos la implementación de la inferencia de múltiples trabajadores modificando nuestro script para admitir la fijación de núcleos:

if __name__ == '__main__': # pin CPU según el rango de trabajador import os, psutil ranking = int(os.environ.get('RANK','0')) world_size = int(os.environ.get('WORLD_SIZE','1')) cores = list(range(psutil.cpu_count(logic=True))) num_cores = len(cores) cores_per_process = num_cores // tamaño_mundial start_index = rango * cores_per_process end_index = (rango + 1) * cores_per_process pid = os.getpid() p = psutil.Process(pid) p.cpu_affinity(cores[start_index:end_index]) tamaño_lote = 8 modelo = get_model(channels_last=True) lote = get_input(batch_size,channels_last=True) infer_fn = get_inference_fn(model, enable_amp=True) avg_time = benchmark(infer_fn, lote) print(f"nMuestras promedio por segundo: {(batch_size/avg_time):.2f}")

Observamos que, a diferencia de otros tipos de instancias de CPU de AWS EC2, cada vCPU de Graviton se asigna directamente a un único núcleo de CPU físico. Usamos la utilidad torchrun para iniciar cuatro trabajadores, cada uno de los cuales se ejecuta en un único núcleo de CPU:

exportar OMP_NUM_THREADS=1 #establecer un subproceso OpenMP por trabajador torchrun –nproc_per_node=4 main.py

Esto da como resultado un rendimiento de 55,15 SPS, una mejora del 4 % con respecto a nuestro mejor resultado anterior.

Cuantización INT8 para Arm

Otra área de desarrollo activo y mejora continua en Arm es la cuantificación INT8. Las herramientas de cuantificación INT8 suelen estar fuertemente ligadas al tipo de instancia de destino. En nuestra publicación anterior demostramos la cuantificación de exportación de PyTorch 2 con backend X86 a través de Inductor usando la biblioteca TorchAO (0.12.1). Afortunadamente, las versiones recientes de TorchAO incluyen un cuantificador dedicado para Arm. La secuencia de cuantificación actualizada se muestra a continuación. Como en nuestra publicación anterior, solo nos interesa el impacto potencial en el rendimiento. En la práctica, la cuantificación INT8 puede tener un impacto significativo en la calidad del modelo y puede requerir una estrategia de cuantificación más sofisticada.

de torchao.quantization.pt2e.quantize_pt2e importar prepare_pt2e, convert_pt2e importar torchao.quantization.pt2e.quantizer.arm_inductor_quantizer como aiq def quantize_model(modelo): x = torch.randn(4, 3, 224, 224).contiguous( Memory_format=torch.channels_last) example_inputs = (x,) lote_dim = torch.export.Dim("batch") con torch.no_grad(): exported_model = torch.export.export( model, example_inputs,dynamic_shapes=((batch_dim, torch.export.Dim.STATIC, torch.export.Dim.STATIC, torch.export.Dim.STATIC), ) ).module() cuantificador = aiq.ArmInductorQuantizer() quantizer.set_global(aiq.get_default_arm_inductor_quantization_config()) modelo_preparado = prepare_pt2e(modelo_exportado, cuantificador) modelo_preparado(*example_inputs) modelo_convertido = convert_pt2e(modelo_preparado) modelo_optimizado = torch.compile(modelo_convertido) return modelo_optimizado tamaño_lote = 8 modelo = get_model(channels_last=True) model = quantize_model(model) lote = get_input(batch_size, canales_last=True) infer_fn = get_inference_fn(model, enable_amp=True) avg_time = benchmark(infer_fn, lote) print(f"nMuestras promedio por segundo: {(batch_size/avg_time):.2f}")

El rendimiento resultante es de 56,77 SPS, lo que supone una mejora del 7,1 % con respecto a la solución bfloat16.

Compilación de AOT usando ONNX y OpenVINO

En nuestra publicación anterior, exploramos técnicas de compilación de modelos anticipados (AOT) utilizando Open Neural Network Exchange (ONNX) y OpenVINO. Ambas bibliotecas incluyen soporte dedicado para ejecutarse en AWS Graviton (por ejemplo, consulte aquí y aquí). Los experimentos de esta sección requieren las siguientes instalaciones de biblioteca:

pip instalar onnxruntime onnxscript openvino nncf

El siguiente bloque de código demuestra la compilación y ejecución del modelo en Arm usando ONNX:

def export_to_onnx(modelo, onnx_path="resnet50.onnx"): entrada_dummy = torch.randn(4, 3, 224, 224) lote = torch.export.Dim("batch") torch.onnx.export( modelo, entrada_dummy, ruta_onnx, nombres_entrada=["entrada"], nombres_salida=["salida"], formas_dinámicas=((batch, torch.export.Dim.STATIC, torch.export.Dim.STATIC, torch.export.Dim.STATIC), ), dynamo=True ) return onnx_path def onnx_infer_fn(onnx_path): importar onnxruntime como ort sess = ort.InferenceSession( onnx_path, proveedores=["CPUExecutionProvider"] ) sess_options = ort.SessionOptions() sess_options.add_session_config_entry( "mlas.enable_gemm_fastmath_arm64_bfloat16", "1") input_name = sess.get_inputs()[0].name def infer_fn(batch): resultado = sess.run(Ninguno, {input_name: lote}) devolver resultado return infer_fn tamaño_batch = 8 modelo = get_model() onnx_path = export_to_onnx(modelo) lote = get_input(batch_size).numpy() infer_fn = onnx_infer_fn(onnx_path) avg_time = benchmark(infer_fn, lote) print(f"nMuestras promedio por segundo: {(batch_size/avg_time):.2f}")

Cabe señalar que el tiempo de ejecución de ONNX admite un ACL-ExecutionProvider dedicado para ejecutarse en Arm, pero esto requiere una compilación de ONNX personalizada (al momento de escribir este artículo), que está fuera del alcance de esta publicación.

Alternativamente, podemos compilar el modelo usando OpenVINO. El siguiente bloque de código demuestra su uso, incluida una opción para la cuantificación INT8 usando NNCF:

importar openvino como ov importar nncf def openvino_infer_fn(modelo_compilado): def infer_fn(lote): resultado = modelo_compilado([lote])[0]devolver resultado devolver infer_fn clase RandomDataset(torch.utils.data.Dataset): def __len__(self): devolver 10000 def __getitem__(self, idx): devolver torch.randn(3, 224, 224) quantize_model = False tamaño_de_lote = 8 modelo = get_model() cargador_de_calibración = torch.utils.data.DataLoader(RandomDataset()) calibración_dataset = nncf.Dataset(calibration_loader) if quantize_model: # cuantificar modelo PyTorch modelo = nncf.quantize(modelo, calibración_dataset) ovm = ov.convert_model(modelo, example_input=torch.randn(1, 3, 224, 224)) ovm = ov.compile_model(ovm) lote = get_input(batch_size).numpy() infer_fn = openvino_infer_fn(ovm) avg_time = benchmark(infer_fn, lote) print(f"nMuestras promedio por segundo: {(batch_size/avg_time):.2f}")

En el caso de nuestro modelo de juguete, la compilación OpenVINO da como resultado un aumento adicional del rendimiento a 63,48 SPS, pero la cuantificación NNCF decepciona, lo que resulta en solo 55,18 SPS.

Resultados

Los resultados de nuestros experimentos se resumen en la siguiente tabla:

Resultados de optimización de inferencia ResNet50 (por autor)

Como en nuestro, volvimos a realizar nuestros experimentos en un segundo modelo, un Vision Transformer (ViT) de la biblioteca timm, para demostrar cómo el impacto de las optimizaciones del tiempo de ejecución que analizamos puede variar según los detalles del modelo. Los resultados se capturan a continuación:

Resultados de optimización de inferencia de ViT (por autor)

Resumen

En esta publicación, revisamos una serie de técnicas de optimización relativamente simples y las aplicamos a dos modelos de juguete de PyTorch. Como demostraron los resultados, el impacto de cada paso de optimización puede variar mucho según los detalles del modelo, y el camino hacia el máximo rendimiento puede tomar muchos caminos diferentes. Los pasos que presentamos en este post fueron sólo un aperitivo; Sin duda, hay muchas más optimizaciones que pueden desbloquear un rendimiento aún mayor.

En el camino, notamos las numerosas bibliotecas de IA/ML que han introducido un soporte profundo para la arquitectura Graviton y el esfuerzo comunitario aparentemente continuo de optimización continua. Las mejoras de rendimiento que logramos, combinadas con esta aparente dedicación, demuestran que AWS Graviton está firmemente en las "grandes ligas" cuando se trata de ejecutar cargas de trabajo de IA/ML con uso intensivo de computación.