Esta es una publicación invitada de AK Roy de Qualcomm AI.

Nube informática elástica de Amazon (Amazon EC2) Las instancias DL2q, 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 que llevan 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 usar 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 el procesamiento del lenguaje natural. y visión por computadora. Además, los aceleradores Qualcomm AI 100 cuentan con la misma tecnología de IA que se utiliza en teléfonos inteligentes, conducción autónoma, computadoras personales y cascos de realidad extendida, por lo que las instancias DL2q se pueden usar para desarrollar y validar estas cargas de trabajo de IA antes de su implementación.

Aspectos destacados de la nueva 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 del acelerador de 128 GB y un ancho de banda de memoria de 1.1 TB por segundo.

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

Innovación del acelerador Qualcomm Cloud AI100

El sistema en chip (SoC) del acelerador 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 que abarcan desde el centro de datos hasta el borde. El SoC emplea núcleos de computación escalares, vectoriales y tensoriales con una capacidad SRAM integrada líder en la industria de 126 MB. Los núcleos están interconectados con una malla de red en chip (NoC) de baja latencia y alto ancho de banda.

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

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

La gran SRAM integrada en el acelerador DL2q permite la implementación eficiente de técnicas de rendimiento avanzadas, como la precisión de microexponente MX6 para almacenar los pesos y la precisión de microexponente MX9 para la comunicación entre aceleradores. La tecnología de microexponentes se describe en el siguiente anuncio de la industria Open Compute Project (OCP): AMD, Arm, Intel, Meta, Microsoft, NVIDIA y Qualcomm estandarizan formatos de datos de precisión estrecha de próxima generación para IA » Open Compute Project.

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

• Almacene pesos utilizando la precisión del microexponente 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 la memoria para ofrecer el mejor rendimiento y latencia de su clase.
• Calcule en FP16 para ofrecer la precisión requerida en el caso de uso, mientras utiliza la SRAM superior en el chip y los TOP de repuesto en la tarjeta, para implementar núcleos MX6 a FP16 de alto rendimiento y baja latencia.
• Utilice una estrategia de procesamiento por lotes optimizada y un tamaño de lote mayor mediante el uso de la SRAM en chip grande disponible para maximizar la reutilización de pesos, manteniendo al mismo tiempo las activaciones en el chip al máximo posible.

Pila de IA y cadena de herramientas de DL2q

La instancia DL2q está acompañada por Qualcomm AI Stack, que ofrece una experiencia de desarrollador consistente en Qualcomm AI en la nube y otros productos de Qualcomm. La misma pila de IA de Qualcomm y la misma tecnología de IA base se ejecutan en las instancias DL2q y en los dispositivos de borde de Qualcomm, brindando a los clientes una experiencia de desarrollador consistente, con una API unificada en sus entornos de desarrollo de nube, automoción, computadoras personales, realidad extendida y teléfonos inteligentes.

La cadena de herramientas permite al usuario de la instancia incorporar rápidamente 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 Parámetros clave de rendimiento de Cloud AI 100 Documentación.

Comience con las instancias DL2q

En este ejemplo, compilará e implementará un programa previamente entrenado modelo BERT en Abrazando la cara en una instancia EC2 DL2q utilizando una AMI DL2q disponible prediseñada, en cuatro pasos.

Puedes usar un prediseñado Qualcomm DLAMI en la instancia o comience con una AMI de Amazon Linux2 y cree su propia AMI DL2q con la plataforma Cloud AI 100 y el SDK de aplicaciones disponibles en este Servicio de almacenamiento simple de Amazon (Amazon S3) Cubeta: s3://ec2-linux-qualcomm-ai100-sdks/latest/.

Los pasos que siguen utilizan la AMI DL2q prediseñada, Base Qualcomm AL2 DLAMI.

Utilice SSH para acceder a su instancia DL2q con la AMI Qualcomm Base AL2 DLAMI y siga los pasos del 1 al 4.

Paso 1. Configure el entorno e instale los paquetes necesarios

1. Instale Python 3.8.

   sudo amazon-linux-extras install python3.8

2. Configure el entorno virtual Python 3.8.

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

3. Active el entorno virtual Python 3.8.

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

4. Instale los paquetes necesarios, que se muestran en la documento requisitos.txt disponible en el sitio público de Github de Qualcomm.

   pip3 install -r requirements.txt

5. Importe las bibliotecas necesarias.

   import transformers 
   from transformers import AutoTokenizer, AutoModelForMaskedLM
   import sys
   import qaic
   import os
   import torch
   import onnx
   from onnxsim import simplify
   import argparse
   import numpy as np

Paso 2. Importa el modelo

1. Importe y tokenice el modelo.

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

2. Defina una entrada de muestra y extraiga la inputIds y attentionMask.

   sentence = "The dog [MASK] on the mat."
   encodings = tokenizer(sentence, max_length=128, truncation=True, padding="max_length", return_tensors='pt')
   inputIds = encodings["input_ids"]
   attentionMask = encodings["attention_mask"]

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

   # Set dynamic dims and axes.
   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á el modelo con precisión FP16. Por lo tanto, debe verificar si el modelo contiene constantes más allá del rango FP16. Pasar el modelo al fix_onnx_fp16 función 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:
           # Save FP16 model
           print("Found constants out of FP16 range, clipped to FP16 range")
           model_base_name += "_fix_outofrange_fp16"
           onnx.save(model, f=f"{gen_models_path}/{model_base_name}.onnx")
           print(f"Saving modified onnx file at {gen_models_path}/{model_base_name}.onnx")
       return model_base_name
   
   fp16_model_name = fix_onnx_fp16(gen_models_path=gen_models_path, model_base_name=model_base_name)

Paso 3. Compila el modelo.

El qaic-exec La herramienta de compilación de interfaz de línea de comandos (CLI) se utiliza para compilar el modelo. La entrada a este compilador es el archivo ONNX generado en el paso 2. El compilador produce un archivo binario (llamado QPC, Para Contenedor del programa Qualcomm) en el camino definido por -aic-binary-dir argumento.

En el siguiente comando de compilación, utiliza cuatro núcleos de computación 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 el bert-base-cased/generatedModels/bert-base-cased_fix_outofrange_fp16_qpc carpeta.

Paso 4. Ejecute el modelo

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

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

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

   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() # Loads the network to the device. 
   
   # Here we are reading out all the input and output shapes/types
   input_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']
   
   #create the input dictionary for given input sentence
   input_dict = {"input_ids": inputIds.numpy().astype(input_type), "attention_mask" : attentionMask.numpy().astype(attn_type)}
   
   #run inference on Cloud AI 100
   output = bert_sess.run(input_dict)

2. Reestructurar los datos del buffer de salida con output_shape y output_type.

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

3. Decodificar 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("Model output (top5) from 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} :(word={word}, index={idx}, logit={round(val,2)})")

Estos son los resultados de la oración de entrada "El perro [MASCARA] en el tapete".

1 :(word=sat, index=2068, logit=11.46)
2 :(word=landed, index=4860, logit=11.11)
3 :(word=spat, index=15732, logit=10.95)
4 :(word=settled, index=3035, logit=10.84)
5 :(word=was, index=1108, logit=10.75)

Eso es todo. Con solo unos pocos pasos, compiló y ejecutó un modelo de PyTorch en una instancia Amazon EC2 DL2q. Para obtener más información sobre la incorporación y compilación de modelos en la instancia DL2q, consulte la Documentación del tutorial de Cloud AI100.

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

Disponible ahora

Puede lanzar instancias DL2q hoy en las regiones de AWS de EE. UU. Oeste (Oregón) y Europa (Frankfurt) como On-demand, RESERVADOy Instancias puntuales, o como parte de un Plan de ahorro. Como es habitual con Amazon EC2, pagas sólo por lo que usas. Para más información, ver Precios de Amazon EC2.

Las instancias DL2q se pueden implementar usando AMI de aprendizaje profundo de AWS (DLAMI)y las imágenes de contenedores están disponibles a través de servicios administrados como Amazon SageMaker, Servicio Amazon Elastic Kubernetes (Amazon EKS), Servicio de contenedor elástico de Amazon (Amazon ECS)y Clúster paralelo de AWS.

Para obtener más información, visite el Instancia Amazon EC2 DL2q página y enviar comentarios a AWS re: Publicación para EC2 o a través de sus contactos habituales de AWS Support.

Sobre los autores

AK Roy es director de gestión de productos en Qualcomm, para productos y soluciones de inteligencia artificial para centros de datos y nube. Tiene más de 20 años de experiencia en estrategia y desarrollo de productos, con el enfoque actual en el mejor rendimiento y soluciones de extremo a extremo de rendimiento/$ para la inferencia de IA en la nube, para una amplia gama de casos de uso. incluyendo GenAI, LLM, IA automática e híbrida.

Jianying Lang es arquitecto principal de soluciones en AWS Worldwide Specialist Organization (WWSO). Tiene más de 15 años de experiencia laboral en el campo de HPC e IA. En AWS, se centra en ayudar a los clientes a implementar, optimizar y escalar sus cargas de trabajo de IA/ML en instancias informáticas aceleradas. Le apasiona combinar las técnicas en los campos de HPC e IA. Jianying tiene un doctorado en Física Computacional de la Universidad de Colorado en Boulder.

• Distribución de relaciones públicas y contenido potenciado por SEO. Consiga amplificado hoy.
• PlatoData.Network Vertical Generativo Ai. Empodérate. Accede Aquí.
• PlatoAiStream. Inteligencia Web3. Conocimiento amplificado. Accede Aquí.
• PlatoESG. Carbón, tecnología limpia, Energía, Ambiente, Solar, Gestión de residuos. Accede Aquí.
• PlatoSalud. Inteligencia en Biotecnología y Ensayos Clínicos. Accede Aquí.
• Fuente: https://aws.amazon.com/blogs/machine-learning/amazon-ec2-dl2q-instance-for-cost-efficient-high-performance-ai-inference-is-now-generally-available/