Amazon EC2 DL2q-forekomst for kostnadseffektiv, høyytelses AI-slutning er nå generelt tilgjengelig | Amazon Web Services

Dette er et gjesteinnlegg av AK Roy fra Qualcomm AI.

Amazon Elastic Compute Cloud (Amazon EC2) DL2q-forekomster, drevet av Qualcomm AI 100 Standard-akseleratorer, kan brukes til kostnadseffektivt distribusjon av deep learning (DL) arbeidsbelastninger i skyen. De kan også brukes til å utvikle og validere ytelsen og nøyaktigheten til DL-arbeidsbelastninger som vil bli distribuert på Qualcomm-enheter. DL2q-forekomster er de første forekomstene som bringer Qualcomms kunstige intelligente (AI)-teknologi til skyen.

Med åtte Qualcomm AI 100 Standard-akseleratorer og 128 GiB totalt akseleratorminne, kan kunder også bruke DL2q-forekomster til å kjøre populære generative AI-applikasjoner, som innholdsgenerering, tekstoppsummering og virtuelle assistenter, samt klassiske AI-applikasjoner for naturlig språkbehandling og datasyn. I tillegg har Qualcomm AI 100-akseleratorer den samme AI-teknologien som brukes på smarttelefoner, autonom kjøring, personlige datamaskiner og utvidede reality-headset, slik at DL2q-forekomster kan brukes til å utvikle og validere disse AI-arbeidsbelastningene før distribusjon.

Nye DL2q-forekomsthøydepunkter

Hver DL2q-forekomst inneholder åtte Qualcomm Cloud AI100-akseleratorer, med en samlet ytelse på over 2.8 PetaOps av Int8-inferensytelse og 1.4 PetaFlops av FP16-slutningsytelse. Forekomsten har totalt 112 AI-kjerner, akseleratorminnekapasitet på 128 GB og minnebåndbredde på 1.1 TB per sekund.

Hver DL2q-forekomst har 96 vCPUer, en systemminnekapasitet på 768 GB og støtter en nettverksbåndbredde på 100 Gbps samt Amazon Elastic Block Store (Amazon EBS) lagring på 19 Gbps.

Qualcomm Cloud AI100 akseleratorinnovasjon

Cloud AI100-akseleratoren system-på-brikke (SoC) er en spesialbygd, skalerbar flerkjernearkitektur, som støtter et bredt spekter av bruksområder for dyp læring som strekker seg fra datasenteret til kanten. SoC bruker skalar-, vektor- og tensordatakjerner med en bransjeledende SRAM-kapasitet på 126 MB. Kjernene er sammenkoblet med et nettverk-på-brikke (NoC) mesh med høy båndbredde og lav latens.

AI100-akseleratoren støtter et bredt og omfattende utvalg av modeller og bruksområder. Tabellen nedenfor fremhever rekkevidden til modellstøtten.

* De fleste bilnettverk er sammensatte nettverk som består av en fusjon av individuelle nettverk.

Den store SRAM-en på DL2q-akseleratoren muliggjør effektiv implementering av avanserte ytelsesteknikker som MX6 mikro-eksponentpresisjon for lagring av vekter og MX9 mikro-eksponentpresisjon for akselerator-til-akselerator-kommunikasjon. Mikro-eksponentteknologien er beskrevet i følgende Open Compute Project (OCP) bransjekunngjøring: AMD, Arm, Intel, Meta, Microsoft, NVIDIA og Qualcomm standardiserer neste generasjons smale presisjonsdataformater for AI » Open Compute Project.

Forekomstbrukeren kan bruke følgende strategi for å maksimere ytelsen per kostnad:

• Lagre vekter ved hjelp av MX6 mikro-eksponentpresisjon i DDR-minnet på akseleratoren. Bruk av MX6-presisjon maksimerer utnyttelsen av den tilgjengelige minnekapasiteten og minnebåndbredden for å levere klassens beste gjennomstrømning og ventetid.
• Beregn i FP16 for å levere den nødvendige nøyaktigheten til brukstilfeller, mens du bruker den overlegne SRAM-en på brikken og ekstra TOP-er på kortet, for å implementere høyytelses MX6 til FP16-kjerner med lav latens.
• Bruk en optimalisert batchstrategi og en høyere batchstørrelse ved å bruke den store SRAM-en på brikken som er tilgjengelig for å maksimere gjenbruken av vekter, samtidig som aktiveringene på brikken beholdes maksimalt.

DL2q AI Stack og verktøykjede

DL2q-forekomsten er ledsaget av Qualcomm AI Stack som gir en konsistent utvikleropplevelse på tvers av Qualcomm AI i skyen og andre Qualcomm-produkter. Den samme Qualcomm AI stack and base AI-teknologien kjører på DL2q-forekomster og Qualcomm edge-enheter, og gir kundene en konsistent utvikleropplevelse, med en enhetlig API på tvers av deres sky-, bil-, personlige datamaskin-, utvidede virkelighets- og smarttelefonutviklingsmiljøer.

Verktøykjeden gjør det mulig for instansbrukeren å raskt ombord på en tidligere opplært modell, kompilere og optimalisere modellen for instansfunksjonene, og deretter distribuere de kompilerte modellene for brukstilfeller for produksjonsslutninger i tre trinn vist i følgende figur.

For å lære mer om hvordan du justerer ytelsen til en modell, se Cloud AI 100 Key Performance Parameters Dokumentasjon.

Kom i gang med DL2q-forekomster

I dette eksemplet kompilerer og distribuerer du en forhåndsopplært BERT modell fra Klemme ansiktet på en EC2 DL2q-forekomst ved hjelp av en forhåndsbygd tilgjengelig DL2q AMI, i fire trinn.

Du kan bruke enten en forhåndsbygd Qualcomm DLAMI på forekomsten eller start med en Amazon Linux2 AMI og bygg din egen DL2q AMI med Cloud AI 100 Platform og Apps SDK tilgjengelig i denne Amazon Simple Storage Service (Amazon S3) bøtte: s3://ec2-linux-qualcomm-ai100-sdks/latest/.

Trinnene som følger bruker den forhåndsbygde DL2q AMI, Qualcomm Base AL2 DLAMI.

Bruk SSH for å få tilgang til DL2q-forekomsten din med Qualcomm Base AL2 DLAMI AMI og følg trinn 1 til 4.

Trinn 1. Sett opp miljøet og installer nødvendige pakker

1. Installer Python 3.8.

   sudo amazon-linux-extras install python3.8

2. Sett opp det virtuelle Python 3.8-miljøet.

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

3. Aktiver det virtuelle Python 3.8-miljøet.

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

4. Installer de nødvendige pakkene, vist i krav.txt-dokument tilgjengelig på Qualcomm offentlige Github-nettsted.

   pip3 install -r requirements.txt

5. Importer de nødvendige bibliotekene.

   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

Trinn 2. Importer modellen

1. Importer og tokeniser modellen.

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

2. Definer en prøveinngang og trekk ut inputIds og 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 deretter kan sendes til kompilatoren.

   # 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 kjøre modellen i FP16-presisjon. Så du må sjekke om modellen inneholder konstanter utenfor FP16-området. Send modellen til fix_onnx_fp16 funksjon for å generere den nye ONNX-filen med de nødvendige rettelsene.

   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)

Trinn 3. Kompiler modellen

De qaic-exec kommandolinjegrensesnitt (CLI) kompilatorverktøy brukes til å kompilere modellen. Inndata til denne kompilatoren er ONNX-filen generert i trinn 2. Kompilatoren produserer en binær fil (kalt QPCFor Qualcomm-programbeholder) i banen definert av -aic-binary-dir argument.

I kompileringskommandoen nedenfor bruker du fire AI-beregningskjerner og en batchstørrelse på én for å 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 genereres i bert-base-cased/generatedModels/bert-base-cased_fix_outofrange_fp16_qpc mappe.

Trinn 4. Kjør modellen

Sett opp en økt for å kjøre slutningen på en Cloud AI100 Qualcomm-akselerator i DL2q-forekomsten.

Qualcomm qaic Python-biblioteket er et sett med APIer som gir støtte for å kjøre slutninger på Cloud AI100-akseleratoren.

1. Bruk Session API-kallet til å opprette en sesjonsforekomst. Session API-kallet er inngangspunktet for å bruke qaic Python-biblioteket.

   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 utgangsbuffer med output_shape og output_type.

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

3. Dekode utgangen som produseres.

   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 utdataene for inngangssetningen "Hunden [MASK] på matten."

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 bare noen få trinn kompilerte og kjørte du en PyTorch-modell på en Amazon EC2 DL2q-forekomst. For å lære mer om onboarding og kompilering av modeller på DL2q-forekomsten, se Cloud AI100 opplæringsdokumentasjon.

For å lære mer om hvilke DL-modellarkitekturer som passer godt for AWS DL2q-forekomster og gjeldende modellstøttematrise, se Qualcomm Cloud AI100 dokumentasjon.

Tilgjengelig nå

Du kan lansere DL2q-forekomster i dag i AWS-regionene i USA vest (Oregon) og Europa (Frankfurt) som På etterspørsel, RESERVERTog Spotforekomster, eller som en del av en Spareplan. Som vanlig med Amazon EC2 betaler du kun for det du bruker. For mer informasjon, se Amazon EC2-priser.

DL2q-forekomster kan distribueres ved hjelp av AWS Deep Learning AMI (DLAMI), og containerbilder er tilgjengelige gjennom administrerte tjenester som Amazon SageMaker, Amazon Elastic Kubernetes Service (Amazon EKS), Amazon Elastic Container Service (Amazon ECS)og AWS ParallelCluster.

For å lære mer, besøk Amazon EC2 DL2q-forekomst side, og send tilbakemelding til AWS re: Post for EC2 eller gjennom dine vanlige AWS -støttekontakter.

Om forfatterne

AK Roy er direktør for produktadministrasjon hos Qualcomm, for Cloud and Datacenter AI-produkter og -løsninger. Han har over 20 års erfaring innen produktstrategi og utvikling, med det nåværende fokuset på klassens beste ytelse og ytelse/$ ende-til-ende-løsninger for AI-slutning i skyen, for det brede spekteret av brukstilfeller, inkludert GenAI, LLMs, Auto og Hybrid AI.

Jianying Lang er en Principal Solutions Architect ved AWS Worldwide Specialist Organization (WWSO). Hun har over 15 års arbeidserfaring innen HPC og AI-feltet. Hos AWS fokuserer hun på å hjelpe kunder med å distribuere, optimalisere og skalere AI/ML-arbeidsmengdene deres på akselererte databehandlingsinstanser. Hun brenner for å kombinere teknikkene innen HPC og AI-felt. Jianying har en doktorgrad i beregningsfysikk fra University of Colorado i Boulder.

• SEO-drevet innhold og PR-distribusjon. Bli forsterket i dag.
• PlatoData.Network Vertical Generative Ai. Styrk deg selv. Tilgang her.
• PlatoAiStream. Web3 Intelligence. Kunnskap forsterket. Tilgang her.
• PlatoESG. Karbon, CleanTech, Energi, Miljø, Solenergi, Avfallshåndtering. Tilgang her.
• PlatoHelse. Bioteknologisk og klinisk etterretning. Tilgang her.
• kilde: https://aws.amazon.com/blogs/machine-learning/amazon-ec2-dl2q-instance-for-cost-efficient-high-performance-ai-inference-is-now-generally-available/