Instanța Amazon EC2 DL2q pentru inferență AI rentabilă și de înaltă performanță este acum disponibilă în general | Amazon Web Services

Aceasta este o postare pentru oaspeți de AK Roy de la Qualcomm AI.

Amazon Elastic Compute Cloud (Amazon EC2) Instanțele DL2q, alimentate de acceleratoarele Qualcomm AI 100 Standard, pot fi utilizate pentru a implementa în mod eficient sarcinile de lucru de învățare profundă (DL) în cloud. Ele pot fi, de asemenea, utilizate pentru a dezvolta și valida performanța și acuratețea sarcinilor de lucru DL care vor fi implementate pe dispozitivele Qualcomm. Instanțele DL2q sunt primele instanțe care au adus tehnologia inteligentă artificială (AI) Qualcomm în cloud.

Cu opt acceleratoare Qualcomm AI 100 Standard și 128 GiB de memorie totală a acceleratorului, clienții pot folosi, de asemenea, instanțe DL2q pentru a rula aplicații AI generative populare, cum ar fi generarea de conținut, rezumatul textului și asistenții virtuali, precum și aplicațiile AI clasice pentru procesarea limbajului natural. și viziunea computerizată. În plus, acceleratoarele Qualcomm AI 100 dispun de aceeași tehnologie AI folosită pe smartphone-uri, conducere autonomă, computere personale și căști de realitate extinsă, astfel încât instanțe DL2q pot fi folosite pentru a dezvolta și valida aceste sarcini de lucru AI înainte de implementare.

Noi evidențieri ale instanței DL2q

Fiecare instanță DL2q încorporează opt acceleratoare Qualcomm Cloud AI100, cu o performanță agregată de peste 2.8 PetaOps de performanță de inferență Int8 și 1.4 PetaFlops de performanță de inferență FP16. Instanța are un total de 112 de nuclee AI, capacitate de memorie acceleratoare de 128 GB și lățime de bandă de memorie de 1.1 TB pe secundă.

Fiecare instanță DL2q are 96 vCPU-uri, o capacitate de memorie de sistem de 768 GB și acceptă o lățime de bandă de rețea de 100 Gbps, precum și Magazin Amazon Elastic Block (Amazon EBS) stocare de 19 Gbps.

Inovație acceleratoare Qualcomm Cloud AI100

Sistemul pe cip (SoC) accelerator Cloud AI100 este o arhitectură multi-core, scalabilă, construită special, care acceptă o gamă largă de cazuri de utilizare pentru învățare profundă, de la centrul de date până la periferie. SoC folosește nuclee de calcul scalare, vectoriale și tensoare cu o capacitate SRAM on-die de 126 MB de lider în industrie. Miezurile sunt interconectate cu o rețea de rețea pe cip (NoC) cu lățime de bandă mare și latență scăzută.

Acceleratorul AI100 acceptă o gamă largă și cuprinzătoare de modele și cazuri de utilizare. Tabelul de mai jos evidențiază gama de suport pentru model.

* Majoritatea rețelelor de automobile sunt rețele compozite care constau dintr-o fuziune a rețelelor individuale.

SRAM mare pe matriță de pe acceleratorul DL2q permite implementarea eficientă a tehnicilor avansate de performanță, cum ar fi precizia micro-exponentului MX6 pentru stocarea greutăților și precizia micro-exponentului MX9 pentru comunicarea de la accelerator la accelerator. Tehnologia micro-exponent este descrisă în următorul anunț al industriei Open Compute Project (OCP): AMD, Arm, Intel, Meta, Microsoft, NVIDIA și Qualcomm standardizează formatele de date de precizie îngustă de nouă generație pentru AI » Open Compute Project.

Utilizatorul instanței poate folosi următoarea strategie pentru a maximiza performanța-pe-cost:

• Stocați greutăți folosind precizia micro-exponentului MX6 în memoria DDR de pe accelerator. Utilizarea preciziei MX6 maximizează utilizarea capacității de memorie disponibilă și a lățimii de bandă a memoriei pentru a oferi cea mai bună capacitate de transfer și latență din clasă.
• Calculați în FP16 pentru a oferi precizia necesară pentru cazurile de utilizare, folosind în același timp SRAM superioară pe cip și topuri de rezervă de pe card, pentru a implementa nuclee de înaltă performanță, cu latență scăzută, de la MX6 la FP16.
• Utilizați o strategie de loturi optimizată și o dimensiune mai mare a lotului folosind SRAM-ul mare pe cip disponibil pentru a maximiza reutilizarea greutăților, păstrând în același timp activările pe cip la maximum posibil.

DL2q AI Stack și lanț de instrumente

Instanța DL2q este însoțită de Qualcomm AI Stack, care oferă o experiență constantă pentru dezvoltatori în Qualcomm AI în cloud și alte produse Qualcomm. Aceeași tehnologie Qualcomm AI și tehnologie AI de bază rulează pe instanțele DL2q și dispozitivele edge Qualcomm, oferind clienților o experiență de dezvoltator consistentă, cu un API unificat în mediile lor de dezvoltare cloud, auto, computer personal, realitate extinsă și smartphone.

Lanțul de instrumente permite utilizatorului instanței să integreze rapid un model antrenat anterior, să compileze și să optimizeze modelul pentru capacitățile de instanță și, ulterior, să implementeze modelele compilate pentru cazurile de utilizare a inferenței de producție în trei pași prezentati în figura următoare.

Pentru a afla mai multe despre reglarea performanței unui model, consultați Cloud AI 100 parametri cheie de performanță Documentație.

Începeți cu instanțe DL2q

În acest exemplu, compilați și implementați un program pre-antrenat modelul BERT din Fata îmbrățișată pe o instanță EC2 DL2q folosind un AMI DL2q pre-construit, în patru pași.

Puteți folosi fie un pre-construit Qualcomm DLAMI pe instanță sau începeți cu o AMI Amazon Linux2 și creați-vă propriul AMI DL2q cu Cloud AI 100 Platform and Apps SDK disponibil în acest Serviciul Amazon de stocare simplă (Amazon S3) găleată: s3://ec2-linux-qualcomm-ai100-sdks/latest/.

Pașii care urmează folosesc AMI-ul DL2q pre-construit, Qualcomm Base AL2 DLAMI.

Utilizați SSH pentru a vă accesa instanța DL2q cu Qualcomm Base AL2 DLAMI AMI și urmați pașii de la 1 la 4.

Pasul 1. Configurați mediul și instalați pachetele necesare

1. Instalați Python 3.8.

   sudo amazon-linux-extras install python3.8

2. Configurați mediul virtual Python 3.8.

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

3. Activați mediul virtual Python 3.8.

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

4. Instalați pachetele necesare, afișate în documentul cerințe.txt disponibil pe site-ul public Qualcomm Github.

   pip3 install -r requirements.txt

5. Importați bibliotecile necesare.

   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

Pasul 2. Importați modelul

1. Importați și tokenizați modelul.

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

2. Definiți o intrare de probă și extrageți inputIds și 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. Convertiți modelul în ONNX, care poate fi apoi transmis compilatorului.

   # 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. Veți rula modelul cu precizie FP16. Deci, trebuie să verificați dacă modelul conține constante dincolo de intervalul FP16. Transmite modelul la fix_onnx_fp16 funcția de a genera noul fișier ONNX cu corecțiile necesare.

   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)

Pasul 3. Compilați modelul

qaic-exec Instrumentul de compilare a interfeței de linie de comandă (CLI) este utilizat pentru a compila modelul. Intrarea acestui compilator este fișierul ONNX generat la pasul 2. Compilatorul produce un fișier binar (numit QPC, Pentru Container de program Qualcomm) în calea definită de -aic-binary-dir a susținut.

În comanda de compilare de mai jos, utilizați patru nuclee de calcul AI și o dimensiune a lotului de unul pentru a compila modelul.

/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

QPC-ul este generat în bert-base-cased/generatedModels/bert-base-cased_fix_outofrange_fp16_qpc dosar.

Pasul 4. Rulați modelul

Configurați o sesiune pentru a rula inferența pe un accelerator Cloud AI100 Qualcomm în instanța DL2q.

Biblioteca Qualcomm qaic Python este un set de API-uri care oferă suport pentru rularea inferenței pe acceleratorul Cloud AI100.

1. Utilizați apelul API Session pentru a crea o instanță de sesiune. Apelul Session API este punctul de intrare în utilizarea bibliotecii qaic 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. Restructurați datele din bufferul de ieșire cu output_shape și output_type.

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

3. Decodați rezultatul produs.

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

Iată ieșirile pentru propoziția de intrare „Câinele [MASCA] pe covor.”

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)

Asta este. Cu doar câțiva pași, ați compilat și rulat un model PyTorch pe o instanță Amazon EC2 DL2q. Pentru a afla mai multe despre integrarea și compilarea modelelor pe instanța DL2q, consultați Documentația tutorialului Cloud AI100.

Pentru a afla mai multe despre arhitecturile modelului DL care sunt potrivite pentru instanțe AWS DL2q și matricea actuală de suport pentru model, consultați Documentația Qualcomm Cloud AI100.

Disponibil acum

Puteți lansa instanțe DL2q astăzi în regiunile AWS din vestul SUA (Oregon) și Europa (Frankfurt) ca La cerere, Rezervat, și Instanțe spot, sau ca parte a unui Plan de economii. Ca de obicei cu Amazon EC2, plătești doar pentru ceea ce folosești. Pentru mai multe informații, vezi Prețul Amazon EC2.

Instanțele DL2q pot fi implementate folosind AMI-uri AWS Deep Learning (DLAMI), iar imaginile containerului sunt disponibile prin intermediul serviciilor gestionate, cum ar fi Amazon SageMaker, Serviciul Amazon Elastic Kubernetes (Amazon EKS), Amazon Elastic Container Service (Amazon ECS), și AWS ParallelCluster.

Pentru a afla mai multe, vizitați Instanță Amazon EC2 DL2q pagina și trimiteți feedback la AWS re:Post pentru EC2 sau prin contactele dvs. obișnuite de asistență AWS.

Despre autori

AK Roy este Director de Product Management la Qualcomm, pentru produse și soluții AI pentru Cloud și Datacenter. Are peste 20 de ani de experiență în strategia și dezvoltarea de produse, cu accent actual pe performanță și performanță de cea mai bună calitate/soluții end-to-end pentru inferența AI în cloud, pentru o gamă largă de cazuri de utilizare, inclusiv GenAI, LLMs, Auto și Hybrid AI.

Jianying Lang este arhitect principal de soluții la AWS Worldwide Specialist Organization (WWSO). Ea are peste 15 ani de experiență de lucru în domeniul HPC și AI. La AWS, ea se concentrează pe a ajuta clienții să implementeze, să optimizeze și să-și scaleze sarcinile de lucru AI/ML pe instanțe de calcul accelerate. Este pasionată de combinarea tehnicilor din domeniile HPC și AI. Jianying deține un doctorat în fizică computațională de la Universitatea din Colorado din Boulder.

• Distribuție de conținut bazat pe SEO și PR. Amplifică-te astăzi.
• PlatoData.Network Vertical Generative Ai. Împuterniciți-vă. Accesați Aici.
• PlatoAiStream. Web3 Intelligence. Cunoștințe amplificate. Accesați Aici.
• PlatoESG. carbon, CleanTech, Energie, Mediu inconjurator, Solar, Managementul deșeurilor. Accesați Aici.
• PlatoHealth. Biotehnologie și Inteligență pentru studii clinice. Accesați Aici.
• Sursa: https://aws.amazon.com/blogs/machine-learning/amazon-ec2-dl2q-instance-for-cost-efficient-high-performance-ai-inference-is-now-generally-available/