Amazon EC2 DL2q-instans til omkostningseffektiv, højtydende AI-inferens er nu generelt tilgængelig | Amazon Web Services

Dette er et gæsteindlæg af AK Roy fra Qualcomm AI.

Amazon Elastic Compute Cloud (Amazon EC2) DL2q-instanser, drevet af Qualcomm AI 100 Standard-acceleratorer, kan bruges til omkostningseffektivt at implementere deep learning (DL)-arbejdsbelastninger i skyen. De kan også bruges til at udvikle og validere ydeevne og nøjagtighed af DL-arbejdsbelastninger, der vil blive implementeret på Qualcomm-enheder. DL2q-instanser er de første instanser, der bringer Qualcomms kunstige intelligente (AI) teknologi til skyen.

Med otte Qualcomm AI 100 Standard-acceleratorer og 128 GiB total acceleratorhukommelse kan kunder også bruge DL2q-instanser til at køre populære generative AI-applikationer, såsom indholdsgenerering, tekstresumé og virtuelle assistenter, såvel som klassiske AI-applikationer til naturlig sprogbehandling og computersyn. Derudover har Qualcomm AI 100-acceleratorer den samme AI-teknologi, der bruges på tværs af smartphones, autonom kørsel, personlige computere og udvidede reality-headsets, så DL2q-instanser kan bruges til at udvikle og validere disse AI-arbejdsbelastninger før implementering.

Nye DL2q-instanshøjdepunkter

Hver DL2q-instans inkorporerer otte Qualcomm Cloud AI100-acceleratorer med en samlet ydeevne på over 2.8 PetaOps af Int8-inferens ydeevne og 1.4 PetaFlops af FP16-inferens ydeevne. Forekomsten har i alt 112 AI-kerner, acceleratorhukommelseskapacitet på 128 GB og hukommelsesbåndbredde på 1.1 TB pr. sekund.

Hver DL2q-instans har 96 vCPU'er, en systemhukommelseskapacitet på 768 GB og understøtter en netværksbåndbredde på 100 Gbps samt Amazon Elastic Block Store (Amazon EBS) lagring på 19 Gbps.

Qualcomm Cloud AI100 accelerator innovation

Cloud AI100 acceleratoren system-on-chip (SoC) er en specialbygget, skalerbar multi-core arkitektur, der understøtter en bred vifte af deep-learning use-cases, der spænder fra datacenteret til kanten. SoC'en anvender skalar-, vektor- og tensorcomputerkerner med en brancheførende on-die SRAM-kapacitet på 126 MB. Kernerne er forbundet med et netværk-på-chip (NoC) mesh med høj båndbredde og lav latens.

AI100 acceleratoren understøtter et bredt og omfattende udvalg af modeller og use-cases. Tabellen nedenfor fremhæver rækkevidden af ​​modelstøtten.

* De fleste bilnetværk er sammensatte netværk, der består af en sammensmeltning af individuelle netværk.

Den store on-die SRAM på DL2q-acceleratoren muliggør effektiv implementering af avancerede ydeevneteknikker såsom MX6 mikro-eksponent-præcision til lagring af vægte og MX9 mikro-eksponent-præcision til accelerator-til-accelerator-kommunikation. Mikroeksponentteknologien er beskrevet i følgende Open Compute Project (OCP) branchemeddelelse: AMD, Arm, Intel, Meta, Microsoft, NVIDIA og Qualcomm standardiserer næste generations smalle præcisionsdataformater til AI » Open Compute Project.

Forekomstbrugeren kan bruge følgende strategi til at maksimere ydeevnen pr. omkostning:

• Gem vægte ved hjælp af MX6-mikroeksponentpræcisionen i DDR-hukommelsen på acceleratoren. Brug af MX6-præcisionen maksimerer udnyttelsen af ​​den tilgængelige hukommelseskapacitet og hukommelsesbåndbredden for at levere klassens bedste gennemløb og latens.
• Beregn i FP16 for at levere den krævede use case-nøjagtighed, mens du bruger den overlegne on-chip SRAM og ekstra TOP'er på kortet, til at implementere højtydende lav-latency MX6 til FP16 kerner.
• Brug en optimeret batchstrategi og en højere batchstørrelse ved at bruge den store on-chip SRAM til rådighed for at maksimere genbrugen af ​​vægte, samtidig med at aktiveringerne på chip bevares til det maksimale muligt.

DL2q AI stak og værktøjskæde

DL2q-instansen er ledsaget af Qualcomm AI-stakken, der leverer en ensartet udvikleroplevelse på tværs af Qualcomm AI i skyen og andre Qualcomm-produkter. Den samme Qualcomm AI stack og base AI-teknologi kører på DL2q-instanserne og Qualcomm edge-enheder, hvilket giver kunderne en ensartet udvikleroplevelse med en samlet API på tværs af deres cloud-, bil-, personlige computer-, udvidede virkeligheds- og smartphone-udviklingsmiljøer.

Værktøjskæden gør det muligt for instansbrugeren hurtigt at ombord på en tidligere trænet model, kompilere og optimere modellen til instanskapaciteterne og efterfølgende implementere de kompilerede modeller til produktionsinferensbrugssager i tre trin vist i den følgende figur.

For at lære mere om justering af en models ydeevne, se Cloud AI 100 Key Performance Parameters Dokumentation.

Kom godt i gang med DL2q-instanser

I dette eksempel kompilerer og implementerer du en foruddannet BERT model fra Knusende ansigt på en EC2 DL2q-instans ved hjælp af en forudbygget tilgængelig DL2q AMI, i fire trin.

Du kan bruge enten en præ-bygget Qualcomm DLAMI på instansen eller start med en Amazon Linux2 AMI og byg din egen DL2q AMI med Cloud AI 100 Platform og Apps SDK tilgængelig i denne Amazon Simple Storage Service (Amazon S3) spand: s3://ec2-linux-qualcomm-ai100-sdks/latest/.

De følgende trin bruger den præbyggede DL2q AMI, Qualcomm Base AL2 DLAMI.

Brug SSH til at få adgang til din DL2q-instans med Qualcomm Base AL2 DLAMI AMI, og følg trin 1 til 4.

Trin 1. Konfigurer miljøet og installer de nødvendige pakker

1. Installer Python 3.8.

   sudo amazon-linux-extras install python3.8

2. Konfigurer det virtuelle Python 3.8-miljø.

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

3. Aktiver det virtuelle Python 3.8-miljø.

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

4. Installer de nødvendige pakker, vist i krav.txt-dokument tilgængelig på Qualcomm's offentlige Github-websted.

   pip3 install -r requirements.txt

5. Importer de nødvendige biblioteker.

   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

Trin 2. Importer modellen

1. Importer og tokenize modellen.

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

2. Definer et eksempelinput og udtræk inputIds , 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. Konverter modellen til ONNX, som derefter kan overføres til compileren.

   # 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. Du vil køre modellen i FP16-præcision. Så du skal kontrollere, om modellen indeholder konstanter ud over FP16-området. Send modellen til fix_onnx_fp16 funktion til at generere den nye ONNX-fil med de nødvendige rettelser.

   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)

Trin 3. Kompiler modellen

qaic-exec kompileringsværktøj til kommandolinjegrænseflade (CLI) bruges til at kompilere modellen. Inputtet til denne compiler er ONNX-filen genereret i trin 2. Compileren producerer en binær fil (kaldet QPC, For Qualcomm program container) i stien defineret af -aic-binary-dir argument.

I kompileringskommandoen nedenfor bruger du fire AI-beregningskerner og en batchstørrelse på én til at kompilere modellen.

/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'en genereres i bert-base-cased/generatedModels/bert-base-cased_fix_outofrange_fp16_qpc mappe.

Trin 4. Kør modellen

Konfigurer en session for at køre inferensen på en Cloud AI100 Qualcomm-accelerator i DL2q-instansen.

Qualcomm qaic Python-biblioteket er et sæt API'er, der understøtter at køre inferens på Cloud AI100-acceleratoren.

1. Brug Session API-kaldet til at oprette en forekomst af session. Session API-kaldet er indgangspunktet for at bruge det qaic Python-bibliotek.

   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. Omstrukturer dataene fra outputbuffer med output_shape , output_type.

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

3. Afkod det producerede output.

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

Her er output for inputsætningen "Hunden [MASK] på måtten."

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)

Det er det. Med blot et par trin kompilerede og kørte du en PyTorch-model på en Amazon EC2 DL2q-instans. For at lære mere om onboarding og kompilering af modeller på DL2q-instansen, se Cloud AI100 tutorial dokumentation.

For at lære mere om, hvilke DL-modelarkitekturer der passer godt til AWS DL2q-instanser og den aktuelle modelunderstøttelsesmatrix, se Qualcomm Cloud AI100 dokumentation.

Fås nu

Du kan lancere DL2q-forekomster i dag i AWS-regionerne i USA vest (Oregon) og Europa (Frankfurt) som On-demand, Reserveretog Spot-forekomstereller som en del af en Opsparingsplan. Som sædvanligt med Amazon EC2 betaler du kun for det, du bruger. For mere information, se Amazon EC2-priser.

DL2q-instanser kan implementeres ved hjælp af AWS Deep Learning AMI'er (DLAMI), og containerbilleder er tilgængelige via administrerede tjenester som f.eks Amazon SageMaker, Amazon Elastic Kubernetes Service (Amazon EKS), Amazon Elastic Container Service (Amazon ECS)og AWS ParallelCluster.

For at lære mere, besøg Amazon EC2 DL2q forekomst side, og send feedback til AWS re:Post til EC2 eller gennem dine sædvanlige AWS-supportkontakter.

Om forfatterne

AK Roy er direktør for Product Management hos Qualcomm, for Cloud og Datacenter AI-produkter og -løsninger. Han har over 20 års erfaring inden for produktstrategi og udvikling, med det nuværende fokus på klassens bedste ydeevne og ydeevne/$ end-to-end-løsninger til AI-inferens i skyen, til den brede vifte af use-cases, herunder GenAI, LLM'er, Auto og Hybrid AI.

Jianying Lang er Principal Solutions Architect hos AWS Worldwide Specialist Organisation (WWSO). Hun har over 15 års erhvervserfaring inden for HPC og AI-området. Hos AWS fokuserer hun på at hjælpe kunder med at implementere, optimere og skalere deres AI/ML-arbejdsbelastninger på accelererede computerforekomster. Hun brænder for at kombinere teknikkerne inden for HPC og AI områder. Jianying har en ph.d.-grad i Computational Physics fra University of Colorado i Boulder.

• SEO Powered Content & PR Distribution. Bliv forstærket i dag.
• PlatoData.Network Vertical Generative Ai. Styrk dig selv. Adgang her.
• PlatoAiStream. Web3 intelligens. Viden forstærket. Adgang her.
• PlatoESG. Kulstof, CleanTech, Energi, Miljø, Solenergi, Affaldshåndtering. Adgang her.
• PlatoHealth. Bioteknologiske og kliniske forsøgs intelligens. Adgang her.
• Kilde: https://aws.amazon.com/blogs/machine-learning/amazon-ec2-dl2q-instance-for-cost-efficient-high-performance-ai-inference-is-now-generally-available/