L’istanza DL2q di Amazon EC2 per l’inferenza di IA ad alte prestazioni ed a basso costo è ora disponibile in generale.

L'istanza DL2q di Amazon EC2 inferenza di IA ad alte prestazioni e basso costo, finalmente disponibile per tutti.

Questo è un post degli ospiti di A.K Roy da Qualcomm AI.

Amazon Elastic Compute Cloud (Amazon EC2) DL2q, dotate di acceleratori Standard Qualcomm AI 100, possono essere utilizzate per distribuire in modo efficiente in termini di costi i carichi di lavoro di deep learning (DL) in cloud. Possono anche essere utilizzate per sviluppare e convalidare le prestazioni e l’accuratezza dei carichi di lavoro di DL che saranno distribuiti sui dispositivi Qualcomm. Le istanze DL2q sono le prime istanze a portare la tecnologia di intelligenza artificiale (AI) di Qualcomm nel cloud.

Con otto acceleratori Standard Qualcomm AI 100 e una memoria totale di acceleratore di 128 GiB, i clienti possono utilizzare anche le istanze DL2q per eseguire applicazioni AI generative popolari, come la generazione di contenuti, la sintesi del testo e gli assistenti virtuali, così come applicazioni AI classiche per l’elaborazione del linguaggio naturale e la visione artificiale. Inoltre, gli acceleratori Qualcomm AI 100 utilizzano la stessa tecnologia AI utilizzata su smartphone, guida autonoma, personal computers e visori per la realtà estesa, quindi le istanze DL2q possono essere utilizzate per sviluppare e convalidare questi carichi di lavoro di AI prima della distribuzione.

Nuovi highlights delle istanze DL2q

Ogni istanza DL2q incorpora otto acceleratori Qualcomm Cloud AI100, con una performance aggregata di oltre 2,8 PetaOps di performance di inferenza Int8 e 1,4 PetaFlops di performance di inferenza FP16. L’istanza ha un totale di 112 core AI, una capacità di memoria di acceleratore di 128 GB e una larghezza di banda di memoria di acceleratore di 1,1 TB al secondo.

• Definire l’Intelligenza Artificiale Generale
• Esplorando la prossima grande tendenza in Gen AI con Sandeep Singh
• Microsoft Research presenta Florence-2 un nuovo modello di base visionaria con una rappresentazione unificata basata su prompt per una varietà di compiti di visione informatica e visione del linguaggio

Ogni istanza DL2q ha 96 vCPUs, una capacità di memoria di sistema di 768 GB e supporta una larghezza di banda di rete di 100 Gbps, oltre allo storage Amazon Elastic Block Store (Amazon EBS) di 19 Gbps.

Nome istanza	vCPUs	Acceleratori Cloud AI100	Memoria acceleratore	Larghezza di banda memoria acceleratore (aggregata)	Memoria istanza	Networking istanza	Larghezza di banda storage (Amazon EBS)
DL2q.24xlarge	96	8	128 GB	1,088 TB/s	768 GB	100 Gbps	19 Gbps

Innovazione dell’acceleratore Qualcomm Cloud AI100

L’acceleratore Cloud AI100 system-on-chip (SoC) è un’architettura multi-core scalabile appositamente progettata che supporta una vasta gamma di casi d’uso di deep learning, dal datacenter all’edge. Il SoC utilizza core di calcolo scalari, vettoriali e tensori con una capacità di SRAM on-die leader nel settore di 126 MB. I core sono interconnessi con una rete mesh NoC (network-on-chip) ad alta larghezza di banda e bassa latenza.

L’acceleratore AI100 supporta un’ampia e completa gamma di modelli e casi d’uso. La tabella di seguito evidenzia la gamma di supporto dei modelli.

Categoria del modello	Numero di modelli	Esempi
NLP	157	BERT, BART, FasterTransformer, T5, Z-code MOE
Generative AI – NLP	40	LLaMA, CodeGen, GPT, OPT, BLOOM, Jais, Luminous, StarCoder, XGen
Generative AI – Immagine	3	Stable diffusion v1.5 e v2.1, OpenAI CLIP
CV – Classificazione immagini	45	ViT, ResNet, ResNext, MobileNet, EfficientNet
CV – Rilevamento oggetti	23	YOLO v2, v3, v4, v5 e v7, SSD-ResNet, RetinaNet
CV – Altro	15	LPRNet, Super-resolution/SRGAN, ByteTrack
Reti Automotive*	53	Percezione e LIDAR, rilevamento di pedoni, corsie e semafori
Totale	>300	​

* La maggior parte delle reti automotive sono reti composite composte da una fusione di reti individuali.

La grande SRAM on-die sull’acceleratore DL2q consente un’implementazione efficiente di tecniche avanzate di prestazioni come la precisione micro-esponente MX6 per memorizzare i pesi e la precisione micro-esponente MX9 per la comunicazione tra acceleratori. La tecnologia micro-esponente è descritta nell’annuncio di settore del progetto Open Compute Project (OCP) seguente: AMD, Arm, Intel, Meta, Microsoft, NVIDIA e Qualcomm standardizzano i formati di dati di precisione stretta di prossima generazione per l’IA » Open Compute Project.

L’utente può utilizzare la seguente strategia per massimizzare le prestazioni per costo:

• Memorizzare i pesi utilizzando la precisione micro-esponente MX6 nella memoria DDR sull’acceleratore. L’utilizzo della precisione MX6 massimizza l’utilizzo della capacità di memoria disponibile e la larghezza di banda della memoria per offrire throughput e latenza di livello superiore.
• Calcolare in FP16 per ottenere l’accuratezza del caso d’uso richiesta, utilizzando la superiore SRAM on-chip e i TOPs di riserva sulla scheda, per implementare kernel MX6 a FP16 ad alta performance e bassa latenza.
• Utilizzare una strategia di batch ottimizzata e una dimensione del batch superiore utilizzando la grande SRAM on-chip disponibile per massimizzare il riutilizzo dei pesi, mantenendo contemporaneamente le attivazioni on-chip al massimo possibile.

Stack e toolchain DL2q AI

L’istanza DL2q è accompagnata dallo stack AI di Qualcomm che offre un’esperienza di sviluppo coerente tra Qualcomm AI nel cloud e altri prodotti Qualcomm. Lo stesso stack Qualcomm AI e la tecnologia AI di base vengono eseguiti sulle istanze DL2q e sui dispositivi edge Qualcomm, fornendo ai clienti un’esperienza di sviluppo coerente, con un’API unificata in tutti i loro ambienti di sviluppo cloud, automotive, personal computer, realtà estesa e smartphone.

La toolchain consente all’utente dell’istanza di accedere rapidamente a un modello precedentemente addestrato, compilare e ottimizzare il modello per le capacità dell’istanza e successivamente distribuire i modelli compilati per casi d’uso di inferenza di produzione in tre passaggi indicati nella figura seguente.

Per saperne di più sul miglioramento delle prestazioni di un modello, consultare la Documentazione sulle chiavi di prestazione principali di Cloud AI 100 qui.

Inizia con le istanze DL2q

In questo esempio, si compila e distribuisce un modello BERT pre-addestrato da Hugging Face su un’istanza EC2 DL2q utilizzando una AMI DL2q disponibile pre-construita, in quattro passaggi.

È possibile utilizzare sia una DLAMI Qualcomm pre-costruita sull’istanza, sia partire con una AMI Amazon Linux2 e creare la propria AMI DL2q con Cloud AI 100 Platform e Apps SDK disponibili in questo bucket Amazon Simple Storage Service (Amazon S3): s3://ec2-linux-qualcomm-ai100-sdks/latest/.

I passaggi seguenti utilizzano la AMI DL2q pre-costruita, Qualcomm Base AL2 DLAMI.

Utilizzare SSH per accedere all’istanza DL2q con la AMI Qualcomm Base AL2 DLAMI e seguire i passaggi dal 1 al 4.

Passaggio 1. Impostare l’ambiente e installare i pacchetti richiesti

1. Installare Python 3.8.

   sudo amazon-linux-extras install python3.8

2. Configurare l’ambiente virtuale di Python 3.8.

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

3. Attivare l’ambiente virtuale di Python 3.8.

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

4. Installare i pacchetti richiesti, indicati nel documento requirements.txt disponibile sul sito pubblico di Github di Qualcomm.

   pip3 install -r requirements.txt

5. Importare le librerie necessarie.

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

Passo 2. Importa il modello

1. Importa e tokenizza il modello.

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

2. Definisci un esempio di input ed estrai inputIds e attentionMask.

   sentence = "Il cane [MASK] sul tappeto."encodings = tokenizer(sentence, max_length=128, truncation=True, padding="max_length", return_tensors='pt')inputIds = encodings["input_ids"]attentionMask = encodings["attention_mask"]

3. Converte il modello in ONNX, che può poi essere passato al compilatore.

   # Imposta dimensioni e assi dinamici.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. Eseguirai il modello con precisione FP16. Quindi, devi verificare se il modello contiene costanti al di là dell’intervallo FP16. Passa il modello alla funzione fix_onnx_fp16 per generare il nuovo file ONNX con le correzioni richieste.

   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:        # Salva il modello FP16        print("Hai trovato costanti al di fuori dell'intervallo FP16, limitato all'intervallo FP16")        model_base_name += "_fix_outofrange_fp16"        onnx.save(model, f=f"{gen_models_path}/{model_base_name}.onnx")        print(f"Salvataggio del file onnx modificato in {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)

Passo 3. Compila il modello

Il compilatore della linea di comando (CLI) qaic-exec viene utilizzato per compilare il modello. L’input di questo compilatore è il file ONNX generato al passaggio 2. Il compilatore produce un file binario (chiamato QPC, per contenitore di programma Qualcomm) nel percorso definito dall’argomento -aic-binary-dir.

Nel comando di compilazione sottostante, vengono utilizzati quattro core di calcolo AI e una dimensione batch di uno per compilare il modello.

/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

Il QPC è generato nella cartella bert-base-cased/generatedModels/bert-base-cased_fix_outofrange_fp16_qpc.

Passaggio 4. Esegui il modello

Imposta una sessione per eseguire l’inferenza su un acceleratore Qualcomm Cloud AI100 nell’istanza DL2q.

La libreria Python Qualcomm qaic è un insieme di API che forniscono supporto per l’esecuzione dell’inferenza sull’acceleratore Cloud AI100.

1. Utilizza la chiamata API Session per creare un’istanza della sessione. La chiamata API Session è il punto di ingresso per utilizzare la libreria 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() # Carica la rete sul dispositivo. # Qui stiamo leggendo tutte le forme/tipi di input e outputinput_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']#crea il dizionario di input per la frase di input datainput_dict = {"input_ids": inputIds.numpy().astype(input_type), "attention_mask" : attentionMask.numpy().astype(attn_type)}#esegui l'inferenza su Cloud AI 100output = bert_sess.run(input_dict)

2. Ristruttura i dati dal buffer di output con output_shape e output_type.

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

3. Decodifica l’output prodotto.

   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("Output del modello (top 5) da 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} :(parola={word}, indice={idx}, logit={round(val,2)})")

Ecco gli output per la frase di input “Il cane [MASK] sul tappeto.”

1 :(parola=seduto, indice=2068, logit=11.46)2 :(parola=atterrato, indice=4860, logit=11.11)3 :(parola=sputato, indice=15732, logit=10.95)4 :(parola=appoggiato, indice=3035, logit=10.84)5 :(parola=era, indice=1108, logit=10.75)

Ecco fatto. Con pochi semplici passaggi, hai compilato ed eseguito un modello PyTorch su un’istanza Amazon EC2 DL2q. Per saperne di più su come implementare e compilare modelli sull’istanza DL2q, consulta la Documentazione del Tutorial Cloud AI100.

Per saperne di più su quali architetture di modelli DL sono adatte alle istanze AWS DL2q e sulla matrice di supporto attuale dei modelli, consulta la Documentazione Qualcomm Cloud AI100.

Disponibile ora

Puoi lanciare istanze DL2q oggi nelle regioni AWS degli Stati Uniti Ovest (Oregon) e Europa (Francoforte) come On-demand, Reserved e Spot Instances, o come parte di un Savings Plan. Come sempre con Amazon EC2, paghi solo per ciò che usi. Per ulteriori informazioni, consulta Amazon EC2 pricing.

Le istanze DL2q possono essere implementate utilizzando le AWS Deep Learning AMIs (DLAMI), e le immagini dei container sono disponibili tramite servizi gestiti come Amazon SageMaker, Amazon Elastic Kubernetes Service (Amazon EKS), Amazon Elastic Container Service (Amazon ECS), e AWS ParallelCluster.

Per saperne di più, visita la pagina dell’istanza Amazon EC2 DL2q e invia un feedback tramite AWS re:Post for EC2 o tramite i tuoi contatti di supporto AWS di riferimento.