Amazon EC2 DL2q eksemplar kulutõhusaks ja suure jõudlusega AI järelduste tegemiseks on nüüd üldiselt saadaval | Amazoni veebiteenused

See on AK Roy külalispostitus Qualcomm AI-st.

Amazon Elastic Compute Cloud (Amazon EC2) DL2q eksemplare, mida toidavad Qualcomm AI 100 Standard kiirendid, saab kasutada sügava õppimise (DL) töökoormuse kulutõhusaks juurutamiseks pilves. Neid saab kasutada ka Qualcommi seadmetes juurutatud DL-i töökoormuse jõudluse ja täpsuse arendamiseks ja kinnitamiseks. DL2q eksemplarid on esimesed, mis toovad Qualcommi tehisintelligentse (AI) tehnoloogia pilve.

Kaheksa Qualcomm AI 100 Standard kiirendi ja 128 GiB kiirendi kogumäluga saavad kliendid kasutada ka DL2q eksemplare populaarsete generatiivsete AI-rakenduste (nt sisu genereerimine, teksti kokkuvõte ja virtuaalsed assistendid) käitamiseks, aga ka klassikalisi AI-rakendusi loomuliku keele töötlemiseks. ja arvutinägemine. Lisaks on Qualcomm AI 100 kiirenditel sama AI-tehnoloogia, mida kasutatakse nutitelefonides, autonoomses juhtimises, personaalarvutites ja laiendatud reaalsusega peakomplektides, nii et DL2q-eksemplare saab enne kasutuselevõttu kasutada nende tehisintellekti töökoormuse arendamiseks ja kinnitamiseks.

Uued DL2q eksemplari esiletõstmised

Iga DL2q eksemplar sisaldab kaheksat Qualcomm Cloud AI100 kiirendit, mille koondjõudlus on üle 2.8 PetaOpsi Int8 järelduste jõudluse ja 1.4 PetaFlopi FP16 järelduste jõudluse. Eksemplaril on kokku 112 AI südamikku, kiirendi mälumaht 128 GB ja mälu ribalaius 1.1 TB sekundis.

Igal DL2q-i eksemplaril on 96 vCPU-d, süsteemimälu maht 768 GB ja see toetab võrgu ribalaiust 100 Gbps ja Amazon Elastic Block Store (Amazon EBS) salvestuskiirus 19 Gbps.

Qualcomm Cloud AI100 kiirendi uuendus

Kiibil olev Cloud AI100 kiirendisüsteem (SoC) on spetsiaalselt loodud skaleeritav mitmetuumaline arhitektuur, mis toetab laia valikut süvaõppe kasutusjuhtumeid andmekeskusest servani. SoC kasutab skalaar-, vektor- ja tensorarvutussüdamike, mille valdkonna juhtiv on-die SRAM-i maht on 126 MB. Südamikud on omavahel ühendatud suure ribalaiusega väikese latentsusega kiibil (NoC) võrgusilmaga.

AI100 kiirendi toetab laia ja laia valikut mudeleid ja kasutusjuhtumeid. Allolev tabel toob esile mudeli toe ulatuse.

* Enamik autotööstuse võrke on liitvõrgud, mis koosnevad üksikute võrkude liitmisest.

DL2q kiirendi suur sisseehitatud SRAM võimaldab tõhusalt rakendada täiustatud jõudlustehnikaid, nagu MX6 mikroeksponenti täpsus kaalude salvestamiseks ja MX9 mikroeksponenti täpsus kiirendi ja kiirendi vaheliseks suhtluseks. Mikroeksponenttehnoloogiat kirjeldatakse järgmises avatud arvutusprojekti (OCP) tööstusharu teadaandes: AMD, Arm, Intel, Meta, Microsoft, NVIDIA ja Qualcomm standardivad AI jaoks järgmise põlvkonna kitsaid täpseid andmevorminguid » Ava arvutusprojekt.

Eksemplari kasutaja saab kulupõhise toimivuse maksimeerimiseks kasutada järgmist strateegiat.

• Salvestage kaalud MX6 mikroeksponenti täpsusega kiirendi DDR-mällu. MX6 täpsuse kasutamine maksimeerib olemasoleva mälumahu ja mälu ribalaiuse ärakasutamist, et pakkuda oma klassi parimat läbilaskevõimet ja latentsust.
• Arvutage FP16-s, et tagada nõutav kasutusjuhtumi täpsus, kasutades samal ajal parimat kiibipõhist SRAM-i ja varu-TOP-sid kaardil, et rakendada suure jõudlusega madala latentsusega MX6 kuni FP16 tuumasid.
• Kasutage optimeeritud partii strateegiat ja suuremat partii suurust, kasutades saadaolevat suurt kiibil asuvat SRAM-i, et maksimeerida raskuste taaskasutamist, säilitades samal ajal maksimaalselt võimalikud aktiveerimised kiibil.

DL2q AI virn ja tööriistaahel

DL2q eksemplariga on kaasas Qualcomm AI Stack, mis pakub pilves ja teistes Qualcommi toodetes järjepidevat arendajakogemust kogu Qualcommi AI-s. Sama Qualcommi AI pinu ja baastehnoloogia töötab DL2q eksemplaridel ja Qualcomm edge seadmetes, pakkudes klientidele ühtset arendajakogemust koos ühtse API-ga kogu nende pilve-, auto-, personaalarvuti-, laiendatud reaalsuse ja nutitelefoni arenduskeskkondades.

Tööriistaahel võimaldab eksemplari kasutajal kiiresti kasutusele võtta varem koolitatud mudeli, kompileerida ja optimeerida mudelit eksemplari võimaluste jaoks ning seejärel juurutada kompileeritud mudelid tootmise järelduste kasutusjuhtumite jaoks kolmes etapis, mis on näidatud järgmisel joonisel.

Mudeli jõudluse häälestamise kohta lisateabe saamiseks vaadake Cloud AI 100 peamised jõudlusparameetrid Dokumentatsioon.

Alustage DL2q eksemplaridega

Selles näites koostate ja juurutate eelkoolitatud BERT mudel Alates Kallistav nägu EC2 DL2q eksemplaril, kasutades eelehitatud saadaolevat DL2q AMI-d neljas etapis.

Võite kasutada kas eelnevalt ehitatud Qualcomm DLAMI või alustage Amazon Linux2 AMI-ga ja looge oma DL2q AMI platvormi Cloud AI 100 ja rakenduste SDK abil, mis on saadaval selles Amazon Simple Storage Service (Amazon S3) ämber: s3://ec2-linux-qualcomm-ai100-sdks/latest/.

Järgmised sammud kasutavad eelehitatud DL2q AMI-d, Qualcomm Base AL2 DLAMI.

Kasutage SSH-d, et pääseda juurde oma DL2q eksemplarile Qualcomm Base AL2 DLAMI AMI abil ja järgige samme 1–4.

Samm 1. Seadistage keskkond ja installige vajalikud paketid

1. Installige Python 3.8.

   sudo amazon-linux-extras install python3.8

2. Seadistage Python 3.8 virtuaalne keskkond.

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

3. Aktiveerige Python 3.8 virtuaalne keskkond.

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

4. Installige vajalikud paketid, mis on näidatud nõuded.txt dokument saadaval Qualcommi avalikul Githubi saidil.

   pip3 install -r requirements.txt

5. Importige vajalikud teegid.

   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

Samm 2. Importige mudel

1. Mudeli importimine ja märgistamine.

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

2. Määratlege näidissisend ja ekstraheerige inputIds ja 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. Teisendage mudel ONNX-iks, mille saab seejärel kompilaatorisse edastada.

   # 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. Käitate mudelit FP16 täpsusega. Seega peate kontrollima, kas mudel sisaldab konstante väljaspool FP16 vahemikku. Andke mudel edasi fix_onnx_fp16 funktsioon uue ONNX-faili genereerimiseks koos vajalike parandustega.

   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)

Samm 3. Koostage mudel

. qaic-exec Mudeli koostamiseks kasutatakse käsurea liidese (CLI) kompilaatori tööriista. Selle kompilaatori sisendiks on etapis 2 loodud ONNX-fail. Kompilaator loob binaarfaili (nn. QPCJaoks Qualcommi programmi konteiner) määratud teel -aic-binary-dir argument.

Allolevas kompileerimiskäskluses kasutate mudeli kompileerimiseks nelja AI arvutustuuma ja ühe partii suurust.

/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 genereeritakse bert-base-cased/generatedModels/bert-base-cased_fix_outofrange_fp16_qpc kausta.

Samm 4. Käivitage mudel

Seadistage seanss, et käitada järeldusi Cloud AI100 Qualcommi kiirendis DL2q eksemplaris.

Qualcomm qaic Pythoni teek on API-de komplekt, mis toetab Cloud AI100 kiirendis järelduste käitamist.

1. Seansi eksemplari loomiseks kasutage seansi API kutset. Seansi API kutse on qaic Pythoni teegi kasutamise sisenemispunkt.

   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. Restruktureerige väljundpuhvrist olevad andmed rakendusega output_shape ja output_type.

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

3. Dekodeerige toodetud väljund.

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

Siin on sisendlause "Koer [MASK] matil" väljundid.

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)

See on kõik. Vaid mõne sammuga kompileerisite ja käitasite PyTorchi mudeli Amazon EC2 DL2q eksemplaris. Lisateavet DL2q-eksemplari mudelite kasutuselevõtu ja kompileerimise kohta leiate aadressilt Cloud AI100 õpetuse dokumentatsioon.

Lisateavet selle kohta, millised DL-mudelite arhitektuurid sobivad hästi AWS DL2q-juhtumite ja praeguse mudeli tugimaatriksi jaoks, vaadake Qualcomm Cloud AI100 dokumentatsioon.

Nüüd saadaval

Saate täna käivitada DL2q eksemplare USA lääneosas (Oregon) ja Euroopas (Frankfurt) AWS-i piirkondades Nõudlusel, Reserveeritudja Kohtjuhtumidvõi osana a Säästuplaan. Nagu Amazon EC2 puhul tavaliselt, maksate ainult selle eest, mida kasutate. Lisateabe saamiseks vt Amazon EC2 hinnakujundus.

DL2q eksemplare saab juurutada kasutades AWS-i süvaõppe AMI-d (DLAMI)ja konteineri kujutised on saadaval hallatavate teenuste kaudu, nagu Amazon SageMaker, Amazon Elastic Kubernetes Service (Amazon EKS), Amazon Elastic Container Service (Amazon ECS)ja AWS ParallelCluster.

Lisateabe saamiseks külastage veebilehte Amazon EC2 DL2q eksemplar lehele ja saatke tagasisidet aadressile AWS re:Postitus EC2 jaoks või tavaliste AWS-i tugikontaktide kaudu.

Autoritest

AK Roy on Qualcommi pilve- ja andmekeskuse AI toodete ja lahenduste tootehalduse direktor. Tal on üle 20-aastane kogemus tootestrateegia ja -arenduse vallas, keskendudes praegu oma klassi parimatele jõudlusele ja jõudlusele / $ otsast lõpuni lahendustele tehisintellekti järelduste tegemiseks pilves, mitmesuguste kasutusjuhtude jaoks, sealhulgas GenAI, LLM-id, automaatne ja hübriid-AI.

Jianying Lang on AWS Worldwide Specialist Organisation (WWSO) peamine lahenduste arhitekt. Tal on üle 15-aastane töökogemus HPC ja AI valdkonnas. AWS-is keskendub ta sellele, et aidata klientidel kiirendatud andmetöötluseksemplaridel oma AI/ML töökoormust juurutada, optimeerida ja skaleerida. Ta on kirglik HPC ja AI valdkondade tehnikate kombineerimise vastu. Jianyingil on Boulderi Colorado ülikoolis doktorikraad arvutusfüüsikas.

• SEO-põhise sisu ja PR-levi. Võimenduge juba täna.
• PlatoData.Network Vertikaalne generatiivne Ai. Jõustage ennast. Juurdepääs siia.
• PlatoAiStream. Web3 luure. Täiustatud teadmised. Juurdepääs siia.
• PlatoESG. Süsinik, CleanTech, Energia, Keskkond päikeseenergia, Jäätmekäitluse. Juurdepääs siia.
• PlatoTervis. Biotehnoloogia ja kliiniliste uuringute luureandmed. Juurdepääs siia.
• Allikas: https://aws.amazon.com/blogs/machine-learning/amazon-ec2-dl2q-instance-for-cost-efficient-high-performance-ai-inference-is-now-generally-available/