Die Amazon EC2 DL2q-Instanz für kosteneffiziente, leistungsstarke KI-Inferenz ist jetzt allgemein verfügbar | Amazon Web Services

Dies ist ein Gastbeitrag von AK Roy von Qualcomm AI.

Amazon Elastic Compute Cloud (Amazon EC2) DL2q-Instanzen, die auf Qualcomm AI 100 Standard-Beschleunigern basieren, können zur kosteneffizienten Bereitstellung von Deep-Learning-Workloads (DL) in der Cloud verwendet werden. Sie können auch zur Entwicklung und Validierung der Leistung und Genauigkeit von DL-Workloads verwendet werden, die auf Qualcomm-Geräten bereitgestellt werden. DL2q-Instanzen sind die ersten Instanzen, die die künstliche Intelligenz (KI) von Qualcomm in die Cloud bringen.

Mit acht Qualcomm AI 100 Standard-Beschleunigern und 128 GiB Gesamtbeschleunigerspeicher können Kunden DL2q-Instanzen auch zum Ausführen beliebter generativer KI-Anwendungen wie Inhaltsgenerierung, Textzusammenfassung und virtueller Assistenten sowie klassischer KI-Anwendungen für die Verarbeitung natürlicher Sprache verwenden und Computer Vision. Darüber hinaus verfügen die Qualcomm AI 100-Beschleuniger über dieselbe KI-Technologie, die auch für Smartphones, autonomes Fahren, PCs und Extended-Reality-Headsets verwendet wird, sodass DL2q-Instanzen zur Entwicklung und Validierung dieser KI-Workloads vor der Bereitstellung verwendet werden können.

Highlights der neuen DL2q-Instanz

Jede DL2q-Instanz umfasst acht Qualcomm Cloud AI100-Beschleuniger mit einer Gesamtleistung von über 2.8 PetaOps der Int8-Inferenzleistung und 1.4 PetaFlops der FP16-Inferenzleistung. Die Instanz verfügt über insgesamt 112 KI-Kerne, eine Beschleunigerspeicherkapazität von 128 GB und eine Speicherbandbreite von 1.1 TB pro Sekunde.

Jede DL2q-Instanz verfügt über 96 vCPUs, eine Systemspeicherkapazität von 768 GB und unterstützt eine Netzwerkbandbreite von 100 Gbit/s Amazon Elastic Block Store (Amazon EBS) Speicher von 19 Gbit/s.

Qualcomm Cloud AI100-Beschleuniger-Innovation

Das Cloud AI100 Accelerator System-on-Chip (SoC) ist eine speziell entwickelte, skalierbare Multi-Core-Architektur, die eine breite Palette von Deep-Learning-Anwendungsfällen unterstützt, die vom Rechenzentrum bis zum Edge reichen. Der SoC verwendet Skalar-, Vektor- und Tensor-Rechenkerne mit einer branchenführenden On-Die-SRAM-Kapazität von 126 MB. Die Kerne sind über ein Network-on-Chip-Netz (NoC) mit hoher Bandbreite und geringer Latenz miteinander verbunden.

Der AI100-Beschleuniger unterstützt ein breites und umfassendes Spektrum an Modellen und Anwendungsfällen. Die folgende Tabelle zeigt den Umfang der Modellunterstützung.

* Die meisten Automobilnetzwerke sind zusammengesetzte Netzwerke, die aus der Fusion einzelner Netzwerke bestehen.

Der große On-Die-SRAM des DL2q-Beschleunigers ermöglicht die effiziente Implementierung fortschrittlicher Leistungstechniken wie MX6-Mikroexponentenpräzision zum Speichern der Gewichte und MX9-Mikroexponentenpräzision für die Beschleuniger-zu-Beschleuniger-Kommunikation. Die Mikroexponenten-Technologie wird in der folgenden Branchenankündigung des Open Compute Project (OCP) beschrieben: AMD, Arm, Intel, Meta, Microsoft, NVIDIA und Qualcomm standardisieren Narrow-Precision-Datenformate der nächsten Generation für KI » Open Compute Project.

Der Instanzbenutzer kann die folgende Strategie verwenden, um die Leistung pro Kosten zu maximieren:

• Speichern Sie Gewichte mit der MX6-Mikroexponentengenauigkeit im On-Accelerator-DDR-Speicher. Der Einsatz der MX6-Präzision maximiert die Nutzung der verfügbaren Speicherkapazität und der Speicherbandbreite, um den besten Durchsatz und die beste Latenz seiner Klasse zu liefern.
• Berechnen Sie in FP16, um die erforderliche Anwendungsfallgenauigkeit zu liefern, und nutzen Sie gleichzeitig das überlegene On-Chip-SRAM und Ersatz-TOPs auf der Karte, um hochleistungsfähige MX6- bis FP16-Kernel mit geringer Latenz zu implementieren.
• Nutzen Sie eine optimierte Batch-Strategie und eine höhere Batch-Größe, indem Sie den großen verfügbaren On-Chip-SRAM nutzen, um die Wiederverwendung von Gewichten zu maximieren und gleichzeitig die On-Chip-Aktivierungen so weit wie möglich beizubehalten.

DL2q AI Stack und Toolchain

Die DL2q-Instanz wird vom Qualcomm AI Stack begleitet, der ein konsistentes Entwicklererlebnis für Qualcomm AI in der Cloud und andere Qualcomm-Produkte bietet. Derselbe Qualcomm-KI-Stack und die gleiche Basis-KI-Technologie laufen auf den DL2q-Instanzen und Qualcomm-Edge-Geräten und bieten Kunden ein konsistentes Entwicklererlebnis mit einer einheitlichen API in ihren Entwicklungsumgebungen für Cloud, Automotive, Personal Computer, Extended Reality und Smartphone.

Die Toolchain ermöglicht es dem Instanzbenutzer, ein zuvor trainiertes Modell schnell zu integrieren, das Modell für die Instanzfunktionen zu kompilieren und zu optimieren und anschließend die kompilierten Modelle für Produktionsinferenz-Anwendungsfälle in drei Schritten bereitzustellen, die in der folgenden Abbildung dargestellt sind.

Weitere Informationen zum Optimieren der Leistung eines Modells finden Sie unter Wichtige Leistungsparameter von Cloud AI 100 Dokumentation.

Beginnen Sie mit DL2q-Instanzen

In diesem Beispiel kompilieren und stellen Sie eine vorab trainierte Version bereit BERT-Modell für Gesicht umarmen auf einer EC2 DL2q-Instanz mithilfe eines vorgefertigten verfügbaren DL2q-AMI in vier Schritten.

Sie können entweder eine vorgefertigte Version verwenden Qualcomm DLAMI auf der Instanz oder beginnen Sie mit einem Amazon Linux2 AMI und erstellen Sie Ihr eigenes DL2q AMI mit dem darin verfügbaren Cloud AI 100 Platform and Apps SDK Einfacher Amazon-Speicherdienst (Amazon S3) Eimer: s3://ec2-linux-qualcomm-ai100-sdks/latest/.

Die folgenden Schritte verwenden das vorgefertigte DL2q-AMI. Qualcomm Base AL2 DLAMI.

Verwenden Sie SSH, um mit dem Qualcomm Base AL2 DLAMI AMI auf Ihre DL2q-Instanz zuzugreifen, und befolgen Sie die Schritte 1 bis 4.

Schritt 1: Richten Sie die Umgebung ein und installieren Sie die erforderlichen Pakete

1. Installieren Sie Python 3.8.

   sudo amazon-linux-extras install python3.8

2. Richten Sie die virtuelle Python 3.8-Umgebung ein.

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

3. Aktivieren Sie die virtuelle Umgebung von Python 3.8.

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

4. Installieren Sie die erforderlichen Pakete, wie in der Abbildung gezeigt Anforderungen.txt-Dokument verfügbar auf der öffentlichen Github-Website von Qualcomm.

   pip3 install -r requirements.txt

5. Importieren Sie die erforderlichen Bibliotheken.

   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

Schritt 2. Importieren Sie das Modell

1. Importieren und tokenisieren Sie das Modell.

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

2. Definieren Sie eine Beispieleingabe und extrahieren Sie sie inputIds und 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. Konvertieren Sie das Modell in ONNX, das dann an den Compiler übergeben werden kann.

   # 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. Sie führen das Modell mit FP16-Präzision aus. Sie müssen also prüfen, ob das Modell Konstanten enthält, die über den FP16-Bereich hinausgehen. Übergeben Sie das Modell an die fix_onnx_fp16 Funktion zum Generieren der neuen ONNX-Datei mit den erforderlichen Korrekturen.

   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)

Schritt 3. Kompilieren Sie das Modell

Das qaic-exec Zum Kompilieren des Modells wird das Befehlszeilenschnittstellen-Compilertool (CLI) verwendet. Die Eingabe für diesen Compiler ist die in Schritt 2 generierte ONNX-Datei. Der Compiler erzeugt eine Binärdatei (genannt QPCZ. Qualcomm-Programmcontainer) im durch definierten Pfad -aic-binary-dir Argument.

Im folgenden Kompilierungsbefehl verwenden Sie vier KI-Rechenkerne und eine Stapelgröße von eins, um das Modell zu kompilieren.

/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

Der QPC wird im generiert bert-base-cased/generatedModels/bert-base-cased_fix_outofrange_fp16_qpc -Ordner.

Schritt 4: Führen Sie das Modell aus

Richten Sie eine Sitzung ein, um die Inferenz auf einem Cloud AI100 Qualcomm-Beschleuniger in der DL2q-Instanz auszuführen.

Die Qaic-Python-Bibliothek von Qualcomm besteht aus einer Reihe von APIs, die Unterstützung für die Ausführung von Inferenzen auf dem Cloud AI100-Beschleuniger bieten.

1. Verwenden Sie den Session-API-Aufruf, um eine Sitzungsinstanz zu erstellen. Der Session-API-Aufruf ist der Einstiegspunkt zur Verwendung der qaic-Python-Bibliothek.

   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. Restrukturieren Sie die Daten aus dem Ausgabepuffer mit output_shape und output_type.

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

3. Dekodieren Sie die erzeugte Ausgabe.

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

Hier sind die Ausgaben für den Eingabesatz „Der Hund [MASKE] auf der Matte“.

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)

Das ist es. Mit nur wenigen Schritten haben Sie ein PyTorch-Modell kompiliert und auf einer Amazon EC2 DL2q-Instanz ausgeführt. Weitere Informationen zum Onboarding und Kompilieren von Modellen auf der DL2q-Instanz finden Sie unter Cloud AI100-Tutorial-Dokumentation.

Weitere Informationen darüber, welche DL-Modellarchitekturen gut für AWS DL2q-Instanzen geeignet sind, und die aktuelle Modellunterstützungsmatrix finden Sie unter Qualcomm Cloud AI100-Dokumentation.

Sofort verfügbar

Sie können DL2q-Instanzen noch heute in den AWS-Regionen USA West (Oregon) und Europa (Frankfurt) starten Auf Nachfrage, Reserviert und Spot Instances, oder als Teil eines Sparplan. Wie bei Amazon EC2 üblich, zahlen Sie nur für das, was Sie nutzen. Weitere Informationen finden Sie unter Amazon EC2-Preise.

DL2q-Instanzen können mit bereitgestellt werden AWS Deep Learning AMIs (DLAMI), und Container-Images sind über verwaltete Dienste wie verfügbar Amazon Sage Maker, Amazon Elastic Kubernetes-Dienst (Amazon EKS), Amazon Elastic Container-Service (Amazon ECS) und AWS-ParallelCluster.

Um mehr zu erfahren, besuchen Sie die Amazon EC2 DL2q-Instanz Seite und senden Sie Feedback an AWS re:Post für EC2 oder über Ihre üblichen AWS-Supportkontakte.

Über die Autoren

AK Roy ist Director of Product Management bei Qualcomm für Cloud- und Datacenter-KI-Produkte und -Lösungen. Er verfügt über mehr als 20 Jahre Erfahrung in der Produktstrategie und -entwicklung, mit dem aktuellen Schwerpunkt auf erstklassiger Leistung und Performance/$-End-to-End-Lösungen für KI-Inferenz in der Cloud für ein breites Spektrum an Anwendungsfällen. einschließlich GenAI, LLMs, Auto- und Hybrid-KI.

Jianying Lang ist Principal Solutions Architect bei AWS Worldwide Specialist Organization (WWSO). Sie verfügt über mehr als 15 Jahre Berufserfahrung im HPC- und KI-Bereich. Bei AWS konzentriert sie sich darauf, Kunden bei der Bereitstellung, Optimierung und Skalierung ihrer KI/ML-Workloads auf Accelerated-Computing-Instanzen zu unterstützen. Ihre Leidenschaft liegt in der Kombination der Techniken in den Bereichen HPC und KI. Jianying hat einen Doktortitel in Computerphysik von der University of Colorado in Boulder.

• SEO-gestützte Content- und PR-Distribution. Holen Sie sich noch heute Verstärkung.
• PlatoData.Network Vertikale generative KI. Motiviere dich selbst. Hier zugreifen.
• PlatoAiStream. Web3-Intelligenz. Wissen verstärkt. Hier zugreifen.
• PlatoESG. Kohlenstoff, CleanTech, Energie, Umwelt, Solar, Abfallwirtschaft. Hier zugreifen.
• PlatoHealth. Informationen zu Biotechnologie und klinischen Studien. Hier zugreifen.
• Quelle: https://aws.amazon.com/blogs/machine-learning/amazon-ec2-dl2q-instance-for-cost-efficient-high-performance-ai-inference-is-now-generally-available/