La instancia de Amazon EC2 DL2q para inferencia de IA rentable y de alto rendimiento ahora está disponible en general

¡Ya está disponible en general la instancia Amazon EC2 DL2q de alto rendimiento y bajo costo para inferencia de IA!

Este es un artículo invitado de A.K Roy de Qualcomm AI.

Amazon Elastic Compute Cloud (Amazon EC2) DL2q instancias, impulsadas por los aceleradores Qualcomm AI 100 Standard, se pueden utilizar para implementar de manera rentable cargas de trabajo de aprendizaje profundo (DL) en la nube. También se pueden utilizar para desarrollar y validar el rendimiento y la precisión de las cargas de trabajo de DL que se implementarán en dispositivos Qualcomm. Las instancias DL2q son las primeras instancias en llevar la tecnología de inteligencia artificial (IA) de Qualcomm a la nube.

Con ocho aceleradores Qualcomm AI 100 Standard y 128 GiB de memoria total del acelerador, los clientes también pueden utilizar las instancias DL2q para ejecutar aplicaciones populares de IA generativa, como generación de contenido, resumen de texto y asistentes virtuales, así como aplicaciones clásicas de IA para procesamiento de lenguaje natural y visión por computadora. Además, los aceleradores Qualcomm AI 100 cuentan con la misma tecnología de IA utilizada en teléfonos inteligentes, conducción autónoma, computadoras personales y auriculares de realidad extendida, por lo que las instancias DL2q se pueden utilizar para desarrollar y validar estas cargas de trabajo de IA antes de la implementación.

Nuevas características de la instancia DL2q

Cada instancia DL2q incorpora ocho aceleradores Qualcomm Cloud AI100, con un rendimiento agregado de más de 2.8 PetaOps de rendimiento de inferencia Int8 y 1.4 PetaFlops de rendimiento de inferencia FP16. La instancia tiene un total de 112 núcleos de IA, una capacidad de memoria de acelerador de 128 GB y un ancho de banda de memoria de 1.1 TB por segundo.

• Explorando la próxima gran tendencia en el Gen de IA con Sandeep Singh
• Microsoft Research presenta Florence-2 un nuevo modelo de base para la visión con una representación unificada basada en indicaciones para una variedad de tareas de visión por computadora y visión del lenguaje.
• Una versión mejorada del análisis de cómo las características del producto afectan a la retención

Cada instancia DL2q tiene 96 vCPUs, una capacidad de memoria del sistema de 768 GB y admite un ancho de banda de red de 100 Gbps, así como almacenamiento (Amazon EBS) de 19 Gbps.

Nombre de la instancia	vCPUs	Aceleradores Cloud AI100	Memoria del acelerador	Ancho de banda de memoria del acelerador (agregado)	Memoria de la instancia	Red de la instancia	Ancho de banda de almacenamiento (Amazon EBS)
DL2q.24xlarge	96	8	128 GB	1.088 TB/s	768 GB	100 Gbps	19 Gbps

Innovación del acelerador Qualcomm Cloud AI100

El sistema en chip (SoC) Cloud AI100 es una arquitectura multinúcleo escalable y diseñada específicamente, que admite una amplia gama de casos de uso de aprendizaje profundo, desde el centro de datos hasta el borde. El SoC utiliza núcleos de cómputo escalar, vectorial y tensorial, con una capacidad líder en la industria de 126 MB de memoria SRAM en el chip. Los núcleos están interconectados con una red en chip (NoC) de alta velocidad y baja latencia.

El acelerador AI100 admite una amplia y completa gama de modelos y casos de uso. La siguiente tabla destaca la variedad de soporte de modelos.

Categoría de modelo	Número de modelos	Ejemplos​
NLP​	157	BERT, BART, FasterTransformer, T5, Z-code MOE
Generative AI – NLP	40	LLaMA, CodeGen, GPT, OPT, BLOOM, Jais, Luminous, StarCoder, XGen
Generative AI – Imagen	3	Stable diffusion v1.5 y v2.1, OpenAI CLIP
CV – Clasificación de imagen	45	ViT, ResNet, ResNext, MobileNet, EfficientNet
CV – Detección de objetos	23	YOLO v2, v3, v4, v5 y v7, SSD-ResNet, RetinaNet
CV – Otros	15	LPRNet, Super-resolución/SRGAN, ByteTrack
Redes automotrices*	53	Detección de percepción y LIDAR, peatones, carril y semáforo
Total​	>300 ​	​

* La mayoría de las redes automotrices son redes compuestas que consisten en una fusión de redes individuales.

La gran SRAM en el acelerador DL2q permite una implementación eficiente de técnicas avanzadas de rendimiento como la precisión micro-exponente MX6 para almacenar los pesos y la precisión micro-exponente MX9 para la comunicación de acelerador a acelerador. La tecnología de micro-exponente se describe en el siguiente anuncio de la industria del Proyecto Open Compute (OCP): AMD, Arm, Intel, Meta, Microsoft, NVIDIA y Qualcomm estandarizan los formatos de datos de precisión estrecha de la siguiente generación para la inteligencia artificial » Proyecto Open Compute.

El usuario de la instancia puede utilizar la siguiente estrategia para maximizar el rendimiento por costo:

• Almacene los pesos utilizando la precisión micro-exponente MX6 en la memoria DDR en el acelerador. El uso de la precisión MX6 maximiza la utilización de la capacidad de memoria disponible y el ancho de banda de memoria para proporcionar el mejor rendimiento de su clase en términos de rendimiento y latencia.
• Realizar cálculos en FP16 para ofrecer la precisión requerida para el caso de uso, al tiempo que se utiliza la SRAM en el chip y los TOP adicionales en la tarjeta para implementar kernels MX6 a FP16 de alta velocidad y baja latencia.
• Utilizar una estrategia de procesamiento por lotes optimizada y un tamaño de lote mayor utilizando la SRAM en el chip disponible para maximizar la reutilización de los pesos, mientras se retienen las activaciones en el chip al máximo posible.

Stack y conjunto de herramientas de IA DL2q

El DL2q instance viene con el Qualcomm AI Stack que ofrece una experiencia de desarrollo consistente en Qualcomm AI en la nube y otros productos de Qualcomm. El mismo conjunto de herramientas de Qualcomm AI y la tecnología base de IA se ejecutan en los DL2q instances y dispositivos de borde de Qualcomm, proporcionando a los clientes una experiencia de desarrollo consistente, con una API unificada en sus entornos de desarrollo en la nube, automotrices, de PC personal, realidad extendida y smartphone.

La herramienta permite al usuario de la instancia incorporarse rápidamente a un modelo previamente entrenado, compilar y optimizar el modelo para las capacidades de la instancia y posteriormente implementar los modelos compilados para casos de uso de inferencia de producción en tres pasos que se muestran en la siguiente figura.

Para obtener más información sobre cómo ajustar el rendimiento de un modelo, consulte la documentación de Cloud AI 100 Key Performance Parameters.

Comienza con las instancias DL2q

En este ejemplo, compilarás e implementarás un modelo BERT previamente entrenado de BERT model de Hugging Face en una instancia EC2 DL2q utilizando una AMI de DL2q disponible previamente construida en cuatro pasos.

Puedes usar tanto una DLAMI de Qualcomm preconstruida en la instancia o comenzar con una AMI de Amazon Linux2 y construir tu propia AMI de DL2q con la Plataforma Cloud AI 100 y el SDK de aplicaciones disponibles en este Amazon Simple Storage Service (Amazon S3) bucket: s3://ec2-linux-qualcomm-ai100-sdks/latest/.

Los siguientes pasos utilizan la AMI de DL2q preconstruida, llamada Qualcomm Base AL2 DLAMI.

Usa SSH para acceder a tu instancia DL2q con la AMI de Qualcomm Base AL2 DLAMI y sigue los pasos del 1 al 4.

Paso 1. Configura el entorno e instala los paquetes requeridos

1. Instala Python 3.8.

   sudo amazon-linux-extras install python3.8

2. Configura el entorno virtual de Python 3.8.

   python3.8 -m venv /home/ec2-user/userA/pyenv

3. Activa el entorno virtual de Python 3.8.

   source /home/ec2-user/userA/pyenv/bin/activate

4. Instala los paquetes requeridos, mostrados en el documento requirements.txt disponible en el sitio de Github público de Qualcomm.

   pip3 install -r requirements.txt

5. Importa las librerías necesarias.

   import transformers from transformers import AutoTokenizer, AutoModelForMaskedLMimport sysimport qaicimport osimport torchimport onnxfrom onnxsim import simplifyimport argparseimport numpy as np

Paso 2. Importar el modelo

1. Importa y tokeniza el modelo.

   model_card = 'bert-base-cased'model = AutoModelForMaskedLM.from_pretrained(model_card)tokenizer = AutoTokenizer.from_pretrained(model_card)

2. Define una entrada de ejemplo y extrae los inputIds y attentionMask.

   sentence = "El perro [MASK] en la alfombra."encodings = tokenizer(sentence, max_length=128, truncation=True, padding="max_length", return_tensors='pt')inputIds = encodings["input_ids"]attentionMask = encodings["attention_mask"]

3. Convierte el modelo a ONNX, que luego se puede pasar al compilador.

   # Establecer dimensiones y ejes dinámicos.dynamic_dims = {0: 'batch', 1 : 'sequence'}dynamic_axes = {    "input_ids" : dynamic_dims,    "attention_mask" : dynamic_dims,    "logits" : dynamic_dims}input_names = ["input_ids", "attention_mask"]inputList = [inputIds, attentionMask]torch.onnx.export(    model,    args=tuple(inputList),    f=f"{gen_models_path}/{model_base_name}.onnx",    verbose=False,    input_names=input_names,    output_names=["logits"],    dynamic_axes=dynamic_axes,    opset_version=11,)

4. Ejecutarás el modelo con precisión FP16. Por lo tanto, debes verificar si el modelo contiene constantes fuera del rango FP16. Pasa el modelo a la función fix_onnx_fp16 para generar el nuevo archivo ONNX con las correcciones necesarias.

   from onnx import numpy_helper        def fix_onnx_fp16(    gen_models_path: str,    model_base_name: str,) -> str:    finfo = np.finfo(np.float16)    fp16_max = finfo.max    fp16_min = finfo.min    model = onnx.load(f"{gen_models_path}/{model_base_name}.onnx")    fp16_fix = False    for tensor in onnx.external_data_helper._get_all_tensors(model):        nptensor = numpy_helper.to_array(tensor, gen_models_path)        if nptensor.dtype == np.float32 and (            np.any(nptensor > fp16_max) or np.any(nptensor < fp16_min)        ):            # print(f'tensor value : {nptensor} above {fp16_max} or below {fp16_min}')            nptensor = np.clip(nptensor, fp16_min, fp16_max)            new_tensor = numpy_helper.from_array(nptensor, tensor.name)            tensor.CopyFrom(new_tensor)            fp16_fix = True                if fp16_fix:        # Guardar modelo FP16        print("Se encontraron constantes fuera del rango FP16, limitadas al rango FP16")        model_base_name += "_correccion_fuera_rango_fp16"        onnx.save(model, f=f"{gen_models_path}/{model_base_name}.onnx")        print(f"Guardando archivo ONNX modificado en {gen_models_path}/{model_base_name}.onnx")    return model_base_namefp16_model_name = fix_onnx_fp16(gen_models_path=gen_models_path, model_base_name=model_base_name)

Paso 3. Compilar el modelo

Se utiliza la herramienta de línea de comandos (CLI) del compilador qaic-exec para compilar el modelo. La entrada de este compilador es el archivo ONNX generado en el paso 2. El compilador produce un archivo binario (llamado QPC, para contenedor de programas Qualcomm) en la ruta definida por el argumento -aic-binary-dir.

En el comando de compilación a continuación, se utilizan cuatro núcleos de cálculo de IA y un tamaño de lote de uno para compilar el modelo.

/opt/qti-aic/exec/qaic-exec \-m=bert-base-cased/generatedModels/bert-base-cased_fix_outofrange_fp16.onnx \-aic-num-cores=4 \-convert-to-fp16 \-onnx-define-symbol=batch,1 -onnx-define-symbol=sequence,128 \-aic-binary-dir=bert-base-cased/generatedModels/bert-base-cased_fix_outofrange_fp16_qpc \-aic-hw -aic-hw-version=2.0 \-compile-only

El QPC se genera en la carpeta bert-base-cased/generatedModels/bert-base-cased_fix_outofrange_fp16_qpc.

Paso 4. Ejecutar el modelo

Configure una sesión para ejecutar la inferencia en un acelerador Qualcomm Cloud AI100 en la instancia DL2q.

La biblioteca Python qaic de Qualcomm es un conjunto de APIs que brinda soporte para ejecutar inferencias en el acelerador Qualcomm Cloud AI100.

1. Utilice la llamada de API Session para crear una instancia de sesión. La llamada de API Session es el punto de entrada para utilizar la biblioteca Python qaic.

   qpcPath = 'bert-base-cased/generatedModels/bert-base-cased_fix_outofrange_fp16_qpc'bert_sess = qaic.Session(model_path= qpcPath+'/programqpc.bin', num_activations=1)  bert_sess.setup() # Carga la red en el dispositivo. # Aquí estamos leyendo todas las formas/tipos de entrada y salidainput_shape, input_type = bert_sess.model_input_shape_dict['input_ids']attn_shape, attn_type = bert_sess.model_input_shape_dict['attention_mask']output_shape, output_type = bert_sess.model_output_shape_dict['logits']#crear el diccionario de entrada para una oración dadainput_dict = {"input_ids": inputIds.numpy().astype(input_type), "attention_mask" : attentionMask.numpy().astype(attn_type)}#ejecutar inferencia en Cloud AI 100output = bert_sess.run(input_dict)

2. Reestructure los datos de la memoria de salida con output_shape y output_type.

   token_logits = np.frombuffer(output['logits'], dtype=output_type).reshape(output_shape)

3. Decodifique la salida producida.

   mask_token_logits = torch.from_numpy(token_logits[0, mask_token_index, :]).unsqueeze(0)top_5_results = torch.topk(mask_token_logits, 5, dim=1)print("Salida del modelo (top5) de Qualcomm Cloud AI 100:")for i in range(5):    idx = top_5_results.indices[0].tolist()[i]    val = top_5_results.values[0].tolist()[i]    word = tokenizer.decode([idx])    print(f"{i+1} :(palabra={word}, índice={idx}, logit={round(val,2)})")

Aquí están las salidas para la oración de entrada “El perro [MASK] en la alfombra.”

1 :(palabra=sentado, índice=2068, logit=11.46)2 :(palabra=aterrizó, índice=4860, logit=11.11)3 :(palabra=escupió, índice=15732, logit=10.95)4 :(palabra=asentado, índice=3035, logit=10.84)5 :(palabra=era, índice=1108, logit=10.75)

Eso es todo. Con solo unos pocos pasos, compilaste y ejecutaste un modelo PyTorch en una instancia DL2q de Amazon EC2. Para obtener más información sobre el proceso de incorporación y compilación de modelos en la instancia DL2q, consulta la Documentación del Tutorial de Cloud AI100.

Para obtener más información sobre qué arquitecturas de modelos DL son adecuadas para las instancias DL2q de AWS y la matriz de soporte actual de modelos, consulta la Documentación de Qualcomm Cloud AI100.

Disponible ahora

Puedes lanzar instancias DL2q hoy en las regiones de AWS EE.UU. Oeste (Oregon) y Europa (Frankfurt) como Bajo demanda, Reservadas y Instancias Spot, o como parte de un Plan de Ahorros. Como es habitual en Amazon EC2, solo pagas por lo que utilizas. Para obtener más información, consulta Precios de Amazon EC2.

Las instancias de DL2q se pueden implementar utilizando las Imágenes de máquinas virtuales Deep Learning AMI (DLAMI) de AWS, y las imágenes de contenedores están disponibles a través de servicios administrados como Amazon SageMaker, Amazon Elastic Kubernetes Service (Amazon EKS), Amazon Elastic Container Service (Amazon ECS), y AWS ParallelCluster.

Para obtener más información, visita la página de la instancia DL2q de Amazon EC2, y envía tus comentarios a través de AWS re:Post para EC2 o mediante tus contactos habituales de soporte de AWS.

We will continue to update Zepes; if you have any questions or suggestions, please contact us!