Amazon EC2 DL2q-instans för kostnadseffektiv, högpresterande AI-inferens är nu allmänt tillgänglig | Amazon webbtjänster

Detta är ett gästinlägg av AK Roy från Qualcomm AI.

Amazon Elastic Compute Cloud (Amazon EC2) DL2q-instanser, som drivs av Qualcomm AI 100 Standardacceleratorer, kan användas för att kostnadseffektivt distribuera arbetsbelastningar för djupinlärning (DL) i molnet. De kan också användas för att utveckla och validera prestanda och noggrannhet för DL-arbetsbelastningar som kommer att distribueras på Qualcomm-enheter. DL2q-instanser är de första instanserna som tar med Qualcomms artificiella intelligenta (AI)-teknik till molnet.

Med åtta Qualcomm AI 100 Standard-acceleratorer och 128 GiB totalt acceleratorminne kan kunder också använda DL2q-instanser för att köra populära generativa AI-applikationer, såsom innehållsgenerering, textsammanfattning och virtuella assistenter, såväl som klassiska AI-applikationer för naturlig språkbehandling och datorseende. Dessutom har Qualcomm AI 100-acceleratorer samma AI-teknik som används för smartphones, autonom körning, persondatorer och utökade verklighetsheadset, så DL2q-instanser kan användas för att utveckla och validera dessa AI-arbetsbelastningar före implementering.

Nya höjdpunkter för DL2q-instanser

Varje DL2q-instans innehåller åtta Qualcomm Cloud AI100-acceleratorer, med en sammanlagd prestanda på över 2.8 PetaOps av Int8-inferensprestanda och 1.4 PetaFlops av FP16-inferensprestanda. Förekomsten har sammanlagt 112 AI-kärnor, acceleratorminneskapacitet på 128 GB och minnesbandbredd på 1.1 TB per sekund.

Varje DL2q-instans har 96 vCPU:er, en systemminneskapacitet på 768 GB och stöder en nätverksbandbredd på 100 Gbps samt Amazon Elastic Block Store (Amazon EBS) lagring på 19 Gbps.

Qualcomm Cloud AI100 acceleratorinnovation

Cloud AI100 accelerator system-on-chip (SoC) är en specialbyggd, skalbar flerkärnig arkitektur som stöder ett brett utbud av djupinlärning användningsfall som sträcker sig från datacenter till kanten. SoC använder skalära, vektor- och tensorberäkningskärnor med en branschledande on-die SRAM-kapacitet på 126 MB. Kärnorna är sammankopplade med ett nätverk-på-chip-nät (NoC) med hög bandbredd och låg latens.

AI100-acceleratorn stöder ett brett och omfattande utbud av modeller och användningsområden. Tabellen nedan belyser utbudet av modellstödet.

* De flesta fordonsnätverk är sammansatta nätverk som består av en sammansmältning av enskilda nätverk.

Det stora SRAM-minnet på DL2q-acceleratorn möjliggör effektiv implementering av avancerade prestandatekniker som MX6-mikroexponentprecision för lagring av vikterna och MX9-mikroexponentprecision för accelerator-till-acceleratorkommunikation. Mikroexponenttekniken beskrivs i följande branschmeddelande om Open Compute Project (OCP): AMD, Arm, Intel, Meta, Microsoft, NVIDIA och Qualcomm standardiserar nästa generations smala precisionsdataformat för AI » Open Compute Project.

Förekomstanvändaren kan använda följande strategi för att maximera prestanda per kostnad:

• Lagra vikter med MX6-mikroexponentprecisionen i DDR-minnet på acceleratorn. Genom att använda MX6-precisionen maximeras utnyttjandet av den tillgängliga minneskapaciteten och minnesbandbredden för att leverera klassens bästa genomströmning och latens.
• Beräkna i FP16 för att leverera den nödvändiga användningsfallets noggrannhet, samtidigt som du använder det överlägsna SRAM-minnet på chipet och extra TOP:s på kortet, för att implementera högpresterande MX6 till FP16-kärnor med låg latens.
• Använd en optimerad batchstrategi och en högre batchstorlek genom att använda det stora on-chip SRAM som finns tillgängligt för att maximera återanvändningen av vikter, samtidigt som aktiveringarna på chipet bibehålls så mycket som möjligt.

DL2q AI Stack och verktygskedja

DL2q-instansen åtföljs av Qualcomm AI Stack som ger en konsekvent utvecklarupplevelse över Qualcomm AI i molnet och andra Qualcomm-produkter. Samma Qualcomm AI stack och bas AI-teknik körs på DL2q-instanserna och Qualcomm edge-enheter, vilket ger kunderna en konsekvent utvecklarupplevelse, med ett enhetligt API över deras moln-, fordons-, persondator-, utökade verklighets- och smartphoneutvecklingsmiljöer.

Verktygskedjan gör det möjligt för instansanvändaren att snabbt gå ombord på en tidigare utbildad modell, kompilera och optimera modellen för instansfunktionerna och därefter distribuera de kompilerade modellerna för produktionsinferensanvändningsfall i tre steg som visas i följande figur.

För att lära dig mer om hur du ställer in en modells prestanda, se Cloud AI 100 nyckelprestandaparametrar Dokumentation.

Kom igång med DL2q-instanser

I det här exemplet kompilerar och distribuerar du en förutbildad BERT modell från Kramande ansikte på en EC2 DL2q-instans med en förbyggd tillgänglig DL2q AMI, i fyra steg.

Du kan använda antingen en förbyggd Qualcomm DLAMI på instansen eller börja med en Amazon Linux2 AMI och bygg din egen DL2q AMI med Cloud AI 100 Platform och Apps SDK som är tillgänglig i denna Amazon Simple Storage Service (Amazon S3) hink: s3://ec2-linux-qualcomm-ai100-sdks/latest/.

Stegen som följer använder den förbyggda DL2q AMI, Qualcomm Base AL2 DLAMI.

Använd SSH för att komma åt din DL2q-instans med Qualcomm Base AL2 DLAMI AMI och följ steg 1 till 4.

Steg 1. Konfigurera miljön och installera nödvändiga paket

1. Installera Python 3.8.

   sudo amazon-linux-extras install python3.8

2. Konfigurera den virtuella Python 3.8-miljön.

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

3. Aktivera den virtuella Python 3.8-miljön.

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

4. Installera de nödvändiga paketen, som visas i krav.txt-dokument tillgänglig på Qualcomms offentliga Github-webbplats.

   pip3 install -r requirements.txt

5. Importera nödvändiga bibliotek.

   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

Steg 2. Importera modellen

1. Importera och tokenisera modellen.

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

2. Definiera en provinmatning och extrahera inputIds och 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. Konvertera modellen till ONNX, som sedan kan skickas till kompilatorn.

   # 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 kommer att köra modellen i FP16-precision. Så du måste kontrollera om modellen innehåller några konstanter utanför FP16-intervallet. Skicka modellen till fix_onnx_fp16 funktion för att generera den nya ONNX-filen med de korrigeringar som krävs.

   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)

Steg 3. Kompilera modellen

Smakämnen qaic-exec kompilatorverktyg för kommandoradsgränssnitt (CLI) används för att kompilera modellen. Indata till denna kompilator är ONNX-filen som genererades i steg 2. Kompilatorn producerar en binär fil (kallas QPC, För Qualcomm programbehållare) i sökvägen som definieras av -aic-binary-dir argument.

I kompileringskommandot nedan använder du fyra AI-beräkningskärnor och en batchstorlek på en för att kompilera 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 genereras i bert-base-cased/generatedModels/bert-base-cased_fix_outofrange_fp16_qpc mapp.

Steg 4. Kör modellen

Ställ in en session för att köra inferensen på en Cloud AI100 Qualcomm-accelerator i DL2q-instansen.

Qualcomm qaic Python-biblioteket är en uppsättning API:er som ger stöd för att köra slutledning på Cloud AI100-acceleratorn.

1. Använd Session API-anropet för att skapa en sessionsinstans. Session API-anropet är startpunkten för att använda 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. Omstrukturera data från utgångsbuffert med output_shape och output_type.

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

3. Avkoda den producerade produktionen.

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

Här är utdata för inmatningsmeningen "Hunden [MASK] på mattan."

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 är allt. Med bara några få steg kompilerade och körde du en PyTorch-modell på en Amazon EC2 DL2q-instans. För att lära dig mer om introduktion och kompilering av modeller på DL2q-instansen, se Cloud AI100 Handledningsdokumentation.

För att lära dig mer om vilka DL-modellarkitekturer som passar bra för AWS DL2q-instanser och den aktuella modellstödsmatrisen, se Qualcomm Cloud AI100 dokumentation.

Tillgänglig nu

Du kan lansera DL2q-instanser idag i västra USA (Oregon) och Europa (Frankfurt) AWS-regioner som På begäran, Reserveradoch Spotinstanser, eller som en del av en Sparplan. Som vanligt med Amazon EC2 betalar du bara för det du använder. För mer information, se Amazon EC2-prissättning.

DL2q-instanser kan distribueras med hjälp av AWS Deep Learning AMI (DLAMI), och behållarbilder är tillgängliga via hanterade tjänster som t.ex Amazon SageMaker, Amazon Elastic Kubernetes Service (Amazon EKS), Amazon Elastic Container Service (Amazon ECS)och AWS ParallelCluster.

För mer information, besök Amazon EC2 DL2q-instans sida och skicka feedback till AWS re:Post för EC2 eller genom dina vanliga AWS-supportkontakter.

Om författarna

AK Roy är en direktör för produkthantering på Qualcomm, för moln- och datacenter AI-produkter och -lösningar. Han har över 20 års erfarenhet av produktstrategi och utveckling, med nuvarande fokus på klassens bästa prestanda och prestanda/$ end-to-end-lösningar för AI-inferens i molnet, för det breda utbudet av användningsfall, inklusive GenAI, LLMs, Auto och Hybrid AI.

Jianying Lang är en Principal Solutions Architect vid AWS Worldwide Specialist Organization (WWSO). Hon har över 15 års arbetslivserfarenhet inom HPC och AI-området. På AWS fokuserar hon på att hjälpa kunder att distribuera, optimera och skala sina AI/ML-arbetsbelastningar på accelererade beräkningsinstanser. Hon brinner för att kombinera teknikerna inom HPC och AI. Jianying har en doktorsexamen i beräkningsfysik från University of Colorado i Boulder.

• SEO-drivet innehåll och PR-distribution. Bli förstärkt idag.
• PlatoData.Network Vertical Generative Ai. Styrka dig själv. Tillgång här.
• PlatoAiStream. Web3 Intelligence. Kunskap förstärkt. Tillgång här.
• Platoesg. Kol, CleanTech, Energi, Miljö, Sol, Avfallshantering. Tillgång här.
• PlatoHealth. Biotech och kliniska prövningar Intelligence. Tillgång här.
• Källa: https://aws.amazon.com/blogs/machine-learning/amazon-ec2-dl2q-instance-for-cost-efficient-high-performance-ai-inference-is-now-generally-available/