Dit is een gastpost van AK Roy van Qualcomm AI.

Amazon Elastic Compute Cloud (Amazon EC2) DL2q-instances, mogelijk gemaakt door Qualcomm AI 100 Standard-accelerators, kunnen worden gebruikt om op kostenefficiënte wijze deep learning (DL)-workloads in de cloud te implementeren. Ze kunnen ook worden gebruikt voor het ontwikkelen en valideren van de prestaties en nauwkeurigheid van DL-workloads die op Qualcomm-apparaten zullen worden geïmplementeerd. DL2q-instances zijn de eerste instances die de kunstmatige intelligente (AI)-technologie van Qualcomm naar de cloud brengen.

Met acht Qualcomm AI 100 Standard-accelerators en 128 GiB totaal acceleratorgeheugen kunnen klanten DL2q-instances ook gebruiken om populaire generatieve AI-toepassingen uit te voeren, zoals het genereren van inhoud, tekstsamenvatting en virtuele assistenten, evenals klassieke AI-toepassingen voor natuurlijke taalverwerking en computervisie. Bovendien beschikken de Qualcomm AI 100-accelerators over dezelfde AI-technologie die wordt gebruikt op smartphones, autonoom rijden, personal computers en uitgebreide reality-headsets, zodat DL2q-instances kunnen worden gebruikt om deze AI-workloads te ontwikkelen en te valideren voordat ze worden ingezet.

Nieuwe hoogtepunten van DL2q-instanties

Elke DL2q-instantie bevat acht Qualcomm Cloud AI100-accelerators, met een totale prestatie van meer dan 2.8 PetaOps aan Int8-inferentieprestaties en 1.4 PetaFlops aan FP16-inferentieprestaties. De instantie heeft in totaal 112 AI-kernen, een acceleratorgeheugencapaciteit van 128 GB en een geheugenbandbreedte van 1.1 TB per seconde.

Elke DL2q-instance heeft 96 vCPU's, een systeemgeheugencapaciteit van 768 GB en ondersteunt een netwerkbandbreedte van 100 Gbps en Amazon Elastic Block Store (Amazon EBS) opslag van 19 Gbps.

Qualcomm Cloud AI100 accelerator-innovatie

De Cloud AI100 accelerator system-on-chip (SoC) is een speciaal gebouwde, schaalbare multi-core architectuur, die een breed scala aan deep-learning use-cases ondersteunt, variërend van het datacenter tot de edge. De SoC maakt gebruik van scalaire, vector- en tensorcomputerkernen met een toonaangevende on-die SRAM-capaciteit van 126 MB. De kernen zijn met elkaar verbonden via een netwerk-op-chip (NoC) mesh met hoge bandbreedte en lage latentie.

De AI100-accelerator ondersteunt een breed en uitgebreid scala aan modellen en gebruiksscenario's. Onderstaande tabel geeft het bereik van de modelondersteuning weer.

* De meeste autonetwerken zijn samengestelde netwerken die bestaan ​​uit een samensmelting van individuele netwerken.

Het grote on-die SRAM op de DL2q-accelerator maakt een efficiënte implementatie van geavanceerde prestatietechnieken mogelijk, zoals MX6 micro-exponentprecisie voor het opslaan van de gewichten en MX9 micro-exponentprecisie voor accelerator-naar-acceleratorcommunicatie. De micro-exponenttechnologie wordt beschreven in de volgende brancheaankondiging van het Open Compute Project (OCP): AMD, Arm, Intel, Meta, Microsoft, NVIDIA en Qualcomm standaardiseren volgende generatie smalle precisie dataformaten voor AI »Open Compute Project.

De exemplaargebruiker kan de volgende strategie gebruiken om de prestaties per kosten te maximaliseren:

• Sla gewichten op met behulp van de MX6-micro-exponentprecisie in het DDR-geheugen op de versneller. Het gebruik van de MX6-precisie maximaliseert het gebruik van de beschikbare geheugencapaciteit en de geheugenbandbreedte om de beste doorvoer en latentie in zijn klasse te leveren.
• Reken in FP16 om de vereiste gebruiksnauwkeurigheid te leveren, terwijl u gebruik maakt van de superieure on-chip SRAM en reserve TOP's op de kaart, om krachtige MX6 tot FP16-kernels met lage latentie te implementeren.
• Gebruik een geoptimaliseerde batchstrategie en een hogere batchgrootte door gebruik te maken van het grote beschikbare SRAM op de chip om het hergebruik van gewichten te maximaliseren, terwijl de activeringen op de chip zoveel mogelijk behouden blijven.

DL2q AI Stack en toolchain

De DL2q-instantie wordt vergezeld door de Qualcomm AI Stack die een consistente ontwikkelaarservaring biedt voor Qualcomm AI in de cloud en andere Qualcomm-producten. Dezelfde Qualcomm AI-stack en basis-AI-technologie draait op de DL2q-instanties en Qualcomm edge-apparaten, waardoor klanten een consistente ontwikkelaarservaring krijgen, met een uniforme API in hun cloud-, auto-, personal computer-, uitgebreide realiteit- en smartphone-ontwikkelomgevingen.

Met de toolchain kan de instancegebruiker snel een eerder getraind model aan boord nemen, het model compileren en optimaliseren voor de instancemogelijkheden, en vervolgens de gecompileerde modellen implementeren voor gebruiksscenario's voor productie-inferentie in drie stappen, weergegeven in de volgende afbeelding.

Voor meer informatie over het afstemmen van de prestaties van een model raadpleegt u de Cloud AI 100 belangrijke prestatieparameters Documentatie.

Ga aan de slag met DL2q-instanties

In dit voorbeeld compileert en implementeert u een vooraf getraind BERT-model oppompen van Gezicht knuffelen op een EC2 DL2q-instantie met behulp van een vooraf gebouwde beschikbare DL2q AMI, in vier stappen.

U kunt een vooraf gebouwde versie gebruiken Qualcomm DLAMI op de instance of begin met een Amazon Linux2 AMI en bouw uw eigen DL2q AMI met de Cloud AI 100 Platform en Apps SDK die beschikbaar is in deze Eenvoudige opslagservice van Amazon (Amazon S3) emmer: s3://ec2-linux-qualcomm-ai100-sdks/latest/.

De stappen die volgen gebruiken de vooraf gebouwde DL2q AMI, Qualcomm Basis AL2 DLAMI.

Gebruik SSH om toegang te krijgen tot uw DL2q-instantie met de Qualcomm Base AL2 DLAMI AMI en volg stap 1 tot en met 4.

Stap 1. Stel de omgeving in en installeer de vereiste pakketten

1. Installeer Python 3.8.

   sudo amazon-linux-extras install python3.8

2. Stel de virtuele Python 3.8-omgeving in.

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

3. Activeer de virtuele Python 3.8-omgeving.

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

4. Installeer de vereiste pakketten, weergegeven in het vereisten.txt-document beschikbaar op de openbare Github-site van Qualcomm.

   pip3 install -r requirements.txt

5. Importeer de benodigde bibliotheken.

   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

Stap 2. Importeer het model

1. Importeer en tokeniseer het model.

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

2. Definieer een voorbeeldinvoer en extraheer de inputIds en 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. Converteer het model naar ONNX, dat vervolgens kan worden doorgegeven aan de compiler.

   # 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. U voert het model uit met FP16-precisie. U moet dus controleren of het model constanten bevat die buiten het FP16-bereik liggen. Geef het model door aan de fix_onnx_fp16 functie om het nieuwe ONNX-bestand met de vereiste fixes te genereren.

   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)

Stap 3. Compileer het model

De qaic-exec Command Line Interface (CLI) compilertool wordt gebruikt om het model te compileren. De invoer voor deze compiler is het ONNX-bestand dat in stap 2 is gegenereerd. De compiler produceert een binair bestand (genaamd QPCvoor Qualcomm-programmacontainer) in het pad gedefinieerd door -aic-binary-dir argument.

In de onderstaande compileeropdracht gebruikt u vier AI-rekenkernen en een batchgrootte van één om het model te compileren.

/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

De QPC wordt gegenereerd in het bert-base-cased/generatedModels/bert-base-cased_fix_outofrange_fp16_qpc map.

Stap 4. Voer het model uit

Zet een sessie op om de gevolgtrekking uit te voeren op een Cloud AI100 Qualcomm-accelerator in de DL2q-instantie.

De Qualcomm Qaic Python-bibliotheek is een set API's die ondersteuning biedt voor het uitvoeren van gevolgtrekkingen op de Cloud AI100-accelerator.

1. Gebruik de Session API-aanroep om een ​​sessie-exemplaar te maken. De Session API-aanroep is het startpunt voor het gebruik van de qaic Python-bibliotheek.

   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. Herstructureer de gegevens uit de uitvoerbuffer met output_shape en output_type.

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

3. Decodeer de geproduceerde uitvoer.

   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)})")

Hier zijn de uitvoer voor de invoerzin 'De hond [MASK] op de mat.'

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)

Dat is het. Met slechts een paar stappen heeft u een PyTorch-model gecompileerd en uitgevoerd op een Amazon EC2 DL2q-instantie. Voor meer informatie over het onboarden en compileren van modellen op de DL2q-instantie, zie de Cloud AI100-tutorialdocumentatie.

Voor meer informatie over welke DL-modelarchitecturen goed passen bij AWS DL2q-instanties en de huidige modelondersteuningsmatrix, zie de Qualcomm Cloud AI100-documentatie.

Nu beschikbaar

U kunt vandaag DL2q-instanties lanceren in de AWS-regio's VS West (Oregon) en Europa (Frankfurt) als Op aanvraag, Gereserveerd en Spotinstanties, of als onderdeel van een Spaarplan. Zoals gebruikelijk bij Amazon EC2 betaal je alleen voor wat je gebruikt. Voor meer informatie, zie Amazon EC2-prijzen.

DL2q-instanties kunnen worden geïmplementeerd met behulp van AWS Deep Learning AMI's (DLAMI), en containerimages zijn beschikbaar via beheerde services zoals Amazon Sage Maker, Amazon Elastic Kubernetes-service (Amazon EKS), Amazon Elastic Container-service (Amazon ECS) en AWS ParallelCluster.

Ga voor meer informatie naar de Amazon EC2 DL2q-instantie pagina en stuur feedback naar AWS re:Post voor EC2 of via uw gebruikelijke AWS-ondersteuningscontacten.

Over de auteurs

AK Roy is directeur Product Management bij Qualcomm, voor Cloud- en Datacenter AI-producten en -oplossingen. Hij heeft meer dan 20 jaar ervaring in productstrategie en -ontwikkeling, met de huidige focus op de beste prestaties en end-to-end oplossingen voor AI-inferentie in de cloud, voor een breed scala aan gebruiksscenario's. inclusief GenAI, LLM's, automatische en hybride AI.

Jianying Lang is een Principal Solutions Architect bij AWS Worldwide Specialist Organization (WWSO). Ze heeft meer dan 15 jaar werkervaring op het gebied van HPC en AI. Bij AWS richt ze zich op het helpen van klanten bij het implementeren, optimaliseren en schalen van hun AI/ML-workloads op versnelde computerinstances. Ze heeft een passie voor het combineren van technieken op het gebied van HPC en AI. Jianying heeft een doctoraat in Computational Physics behaald aan de Universiteit van Colorado in Boulder.

• Door SEO aangedreven content en PR-distributie. Word vandaag nog versterkt.
• PlatoData.Network Verticale generatieve AI. Versterk jezelf. Toegang hier.
• PlatoAiStream. Web3-intelligentie. Kennis versterkt. Toegang hier.
• PlatoESG. carbon, CleanTech, Energie, Milieu, Zonne, Afvalbeheer. Toegang hier.
• Plato Gezondheid. Intelligentie op het gebied van biotech en klinische proeven. Toegang hier.
• Bron: https://aws.amazon.com/blogs/machine-learning/amazon-ec2-dl2q-instance-for-cost-efficient-high-performance-ai-inference-is-now-generally-available/