Instancja Amazon EC2 DL2q do ekonomicznego i wydajnego wnioskowania AI jest teraz ogólnie dostępna | Usługi internetowe Amazona

To jest post gościnny autorstwa AK Roya z Qualcomm AI.

Amazon Elastic Compute Cloud (Amazon EC2) Instancje DL2q, obsługiwane przez akceleratory Qualcomm AI 100 Standard, mogą być wykorzystywane do ekonomicznego wdrażania obciążeń głębokiego uczenia się (DL) w chmurze. Można ich również używać do opracowywania i sprawdzania wydajności i dokładności obciążeń DL, które zostaną wdrożone na urządzeniach Qualcomm. Instancje DL2q to pierwsze instancje, które wprowadzają technologię sztucznej inteligencji (AI) firmy Qualcomm do chmury.

Dzięki ośmiu akceleratorom Qualcomm AI 100 Standard i 128 GiB całkowitej pamięci akceleratora klienci mogą również używać instancji DL2q do uruchamiania popularnych aplikacji generatywnych AI, takich jak generowanie treści, podsumowywanie tekstu i wirtualni asystenci, a także klasycznych aplikacji AI do przetwarzania języka naturalnego i wizja komputerowa. Ponadto akceleratory Qualcomm AI 100 wykorzystują tę samą technologię sztucznej inteligencji, która jest stosowana w smartfonach, pojazdach autonomicznych, komputerach osobistych i zestawach słuchawkowych o rozszerzonej rzeczywistości, dzięki czemu instancje DL2q można wykorzystywać do opracowywania i sprawdzania obciążeń AI przed wdrożeniem.

Nowe najważniejsze informacje dotyczące instancji DL2q

Każda instancja DL2q zawiera osiem akceleratorów Qualcomm Cloud AI100, których łączna wydajność wynosi ponad 2.8 PetaOps w przypadku wnioskowania Int8 i 1.4 PetaFlops w przypadku wnioskowania FP16. Instancja ma łącznie 112 rdzeni AI, pojemność pamięci akceleratora na poziomie 128 GB i przepustowość pamięci na poziomie 1.1 TB na sekundę.

Każda instancja DL2q ma 96 procesorów vCPU, pojemność pamięci systemowej 768 GB i obsługuje przepustowość sieci 100 Gb/s, a także Sklep z blokami elastycznymi Amazon (Amazon EBS) pamięć o przepustowości 19 Gb/s.

Innowacyjny akcelerator Qualcomm Cloud AI100

System-on-chip (SoC) akceleratora Cloud AI100 to specjalnie zaprojektowana, skalowalna architektura wielordzeniowa, obsługująca szeroką gamę zastosowań głębokiego uczenia się, od centrum danych po brzeg. SoC wykorzystuje rdzenie obliczeniowe skalarne, wektorowe i tensorowe z wiodącą w branży pojemnością wbudowanej pamięci SRAM wynoszącą 126 MB. Rdzenie są połączone siatką typu „sieć na chipie” (NoC) o dużej przepustowości i niskim opóźnieniu.

Akcelerator AI100 obsługuje szeroką i kompleksową gamę modeli i przypadków użycia. Poniższa tabela przedstawia zakres wsparcia modelu.

* Większość sieci motoryzacyjnych to sieci złożone, składające się z połączenia pojedynczych sieci.

Duża pamięć SRAM w akceleratorze DL2q umożliwia efektywne wdrażanie zaawansowanych technik wydajności, takich jak precyzja mikrowykładnika MX6 do przechowywania ciężarów i precyzja mikrowykładnika MX9 do komunikacji między akceleratorami. Technologia mikrowykładników została opisana w następującym ogłoszeniu branżowym Open Compute Project (OCP): AMD, Arm, Intel, Meta, Microsoft, NVIDIA i Qualcomm standaryzują wąskie precyzyjne formaty danych nowej generacji dla sztucznej inteligencji » Projekt Open Compute.

Użytkownik instancji może zastosować następującą strategię, aby zmaksymalizować stosunek wydajności do kosztu:

• Przechowuj ciężary z precyzją mikrowykładnika MX6 w pamięci DDR wbudowanej w akcelerator. Korzystanie z precyzji MX6 maksymalizuje wykorzystanie dostępnej pojemności pamięci i przepustowości pamięci, aby zapewnić najlepszą w swojej klasie przepustowość i opóźnienia.
• Obliczenia w FP16, aby zapewnić wymaganą dokładność przypadku użycia, przy użyciu doskonałej wbudowanej pamięci SRAM i zapasowych TOPów na karcie, aby wdrożyć wysokowydajne jądra MX6 do FP16 o niskim opóźnieniu.
• Użyj zoptymalizowanej strategii dozowania i większego rozmiaru partii, korzystając z dużej dostępnej pamięci SRAM na chipie, aby zmaksymalizować ponowne wykorzystanie obciążników, zachowując jednocześnie maksymalnie możliwe aktywacje na chipie.

Stos AI DL2q i łańcuch narzędzi

Instancji DL2q towarzyszy Qualcomm AI Stack, który zapewnia spójne środowisko programistyczne w ramach Qualcomm AI w chmurze i innych produktach Qualcomm. Ten sam stos Qualcomm AI i podstawowa technologia AI działa na instancjach DL2q i urządzeniach brzegowych Qualcomm, zapewniając klientom spójne środowisko programistyczne dzięki ujednoliconemu interfejsowi API w środowiskach chmurowych, motoryzacyjnych, komputerów osobistych, rozszerzonej rzeczywistości i środowisk programistycznych smartfonów.

Łańcuch narzędzi umożliwia użytkownikowi instancji szybkie wdrożenie wcześniej wyszkolonego modelu, skompilowanie i zoptymalizowanie modelu pod kątem możliwości instancji, a następnie wdrożenie skompilowanych modeli na potrzeby wnioskowania produkcyjnego w trzech krokach pokazanych na poniższym rysunku.

Aby dowiedzieć się więcej na temat dostrajania wydajności modelu, zobacz Kluczowe parametry wydajności Cloud AI 100 Dokumentacja.

Rozpocznij pracę z instancjami DL2q

W tym przykładzie kompilujesz i wdrażasz wstępnie przeszkolony modelu BERT od Przytulanie Twarzy na instancji EC2 DL2q przy użyciu wstępnie zbudowanego, dostępnego DL2q AMI, w czterech krokach.

Możesz użyć gotowego Qualcomm DLAMI na instancji lub zacznij od Amazon Linux2 AMI i zbuduj własny DL2q AMI z platformą Cloud AI 100 i pakietem SDK aplikacji dostępnym w tym Usługa Amazon Simple Storage (Amazon S3) wiaderko: s3://ec2-linux-qualcomm-ai100-sdks/latest/.

W poniższych krokach wykorzystano wstępnie zbudowany moduł AMI DL2q, Qualcomm Base AL2 DLAMI.

Użyj protokołu SSH, aby uzyskać dostęp do instancji DL2q za pomocą Qualcomm Base AL2 DLAMI AMI i wykonaj kroki od 1 do 4.

Krok 1. Skonfiguruj środowisko i zainstaluj wymagane pakiety

1. Zainstaluj Pythona 3.8.

   sudo amazon-linux-extras install python3.8

2. Skonfiguruj środowisko wirtualne Python 3.8.

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

3. Aktywuj środowisko wirtualne Python 3.8.

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

4. Zainstaluj wymagane pakiety pokazane w pliku dokument wymagania.txt dostępne w publicznej witrynie Github firmy Qualcomm.

   pip3 install -r requirements.txt

5. Zaimportuj niezbędne biblioteki.

   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

Krok 2. Zaimportuj model

1. Zaimportuj i tokenizuj model.

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

2. Zdefiniuj przykładowe dane wejściowe i wyodrębnij plik inputIds i 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. Konwertuj model na ONNX, który można następnie przekazać do kompilatora.

   # 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. Uruchomisz model z precyzją FP16. Należy więc sprawdzić, czy model zawiera jakieś stałe spoza zakresu FP16. Przekaż model do fix_onnx_fp16 funkcję wygenerowania nowego pliku ONNX z wymaganymi poprawkami.

   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)

Krok 3. Skompiluj model

Połączenia qaic-exec Do kompilowania modelu używane jest narzędzie kompilatora interfejsu wiersza poleceń (CLI). Dane wejściowe tego kompilatora to plik ONNX wygenerowany w kroku 2. Kompilator tworzy plik binarny (tzw. QPC, Dla Kontener programu Qualcomm) w ścieżce zdefiniowanej przez -aic-binary-dir argumenty.

W poniższym poleceniu kompilacji do skompilowania modelu używasz czterech rdzeni obliczeniowych AI i partii o wielkości jednego.

/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 jest generowany w pliku bert-base-cased/generatedModels/bert-base-cased_fix_outofrange_fp16_qpc teczka.

Krok 4. Uruchom model

Skonfiguruj sesję, aby uruchomić wnioskowanie na akceleratorze Cloud AI100 Qualcomm w instancji DL2q.

Biblioteka Qualcomm qaic Python to zestaw interfejsów API zapewniający obsługę uruchamiania wnioskowania w akceleratorze Cloud AI100.

1. Użyj wywołania API sesji, aby utworzyć instancję sesji. Wywołanie API sesji jest punktem wyjścia do korzystania z biblioteki Pythona qaic.

   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. Zrestrukturyzuj dane z bufora wyjściowego za pomocą output_shape i output_type.

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

3. Dekoduj wygenerowany wynik.

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

Oto wyniki dla zdania wejściowego „Pies [MASKA] na macie”.

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)

Otóż ​​to. W kilku krokach skompilowałeś i uruchomiłeś model PyTorch na instancji Amazon EC2 DL2q. Aby dowiedzieć się więcej na temat dołączania i kompilowania modeli w instancji DL2q, zobacz Dokumentacja samouczka Cloud AI100.

Aby dowiedzieć się więcej o tym, które architektury modeli DL dobrze pasują do instancji AWS DL2q i o aktualnej macierzy obsługi modeli, zobacz Dokumentacja Qualcomm Cloud AI100.

Już dostępny

Możesz już dziś uruchomić instancje DL2q w regionach AWS w zachodnich stanach USA (Oregon) i Europie (Frankfurt) jako Na żądanie, Zarezerwowane, Instancje Spotlub jako część Plan oszczędnościowy. Jak zwykle w przypadku Amazon EC2 płacisz tylko za to, z czego korzystasz. Aby uzyskać więcej informacji, zobacz Ceny Amazon EC2.

Instancje DL2q można wdrożyć przy użyciu AMI głębokiego uczenia się AWS (DLAMI), a obrazy kontenerów są dostępne za pośrednictwem usług zarządzanych, takich jak Amazon Sage Maker, Usługa Amazon Elastic Kubernetes (Amazon EKS), Usługa elastycznych pojemników Amazon (Amazon ECS), Klaster równoległy AWS.

Aby dowiedzieć się więcej, odwiedź stronę Instancja Amazon EC2 DL2q stronę i wyślij opinię na adres AWS re:Post dla EC2 lub za pośrednictwem zwykłych kontaktów pomocy technicznej AWS.

O autorach

AK Roy jest dyrektorem ds. zarządzania produktami w Qualcomm ds. produktów i rozwiązań AI w chmurze i Datacenter. Ma ponad 20-letnie doświadczenie w strategii i rozwoju produktów, obecnie koncentruje się na najlepszej w swojej klasie wydajności i wydajności/kompleksowych rozwiązaniach do wnioskowania AI w chmurze, dla szerokiego zakresu przypadków użycia, w tym GenAI, LLM, automatyczna i hybrydowa sztuczna inteligencja.

Jianying Langa jest głównym architektem rozwiązań w Światowej Organizacji Specjalistycznej AWS (WWSO). Ma ponad 15-letnie doświadczenie zawodowe w dziedzinie HPC i AI. W AWS koncentruje się na pomaganiu klientom we wdrażaniu, optymalizowaniu i skalowaniu obciążeń AI/ML w instancjach z przyspieszonym przetwarzaniem. Jej pasją jest łączenie technik z obszarów HPC i AI. Jianying posiada stopień doktora fizyki obliczeniowej uzyskany na Uniwersytecie Kolorado w Boulder.

• Dystrybucja treści i PR oparta na SEO. Uzyskaj wzmocnienie już dziś.
• PlatoData.Network Pionowe generatywne AI. Wzmocnij się. Dostęp tutaj.
• PlatoAiStream. Inteligencja Web3. Wiedza wzmocniona. Dostęp tutaj.
• PlatonESG. Węgiel Czysta technologia, Energia, Środowisko, Słoneczny, Gospodarowanie odpadami. Dostęp tutaj.
• Platon Zdrowie. Inteligencja w zakresie biotechnologii i badań klinicznych. Dostęp tutaj.
• Źródło: https://aws.amazon.com/blogs/machine-learning/amazon-ec2-dl2q-instance-for-cost-efficient-high-performance-ai-inference-is-now-generally-available/