Uruchamiaj obciążenia wnioskowania uczenia maszynowego w instancjach opartych na AWS Graviton za pomocą Amazon SageMaker

Dziś startujemy Amazon Sage Maker wnioskować o Grawiton AWS aby umożliwić Ci skorzystanie z korzyści związanych z ceną, wydajnością i efektywnością chipów Graviton.

Instancje oparte na grawitonie są dostępne do wnioskowania o modelu w SageMaker. Ten post pomoże Ci przeprowadzić migrację i wdrożyć obciążenie wnioskowania uczenia maszynowego (ML) z instancji x86 do instancji opartych na Graviton w SageMaker. Zapewniamy przewodnik krok po kroku, jak wdrożyć wyszkolony model SageMaker w instancjach opartych na Graviton, omówimy najlepsze praktyki podczas pracy z Graviton, omówimy stosunek ceny do wydajności oraz zademonstrujemy, jak wdrożyć model TensorFlow w instancji SageMaker Graviton.

Krótki przegląd Gravitona

AWS Graviton to rodzina procesorów zaprojektowanych przez AWS, które zapewniają najlepszy stosunek ceny do wydajności i są bardziej energooszczędne niż ich odpowiedniki x86. Procesory AWS Graviton 3 są najnowszymi procesorami z rodziny Graviton i są zoptymalizowane pod kątem obciążeń ML, w tym obsługują bfloat16 i dwukrotnie większą przepustowość pojedynczej instrukcji wielu danych (SIMD). Gdy te dwie funkcje zostaną połączone, Graviton 3 może zapewnić nawet trzykrotnie lepszą wydajność w porównaniu z instancjami Graviton 2. Graviton 3 zużywa również do 60% mniej energii przy takiej samej wydajności jak porównywalne Elastyczna chmura obliczeniowa Amazon (Amazon EC2). Jest to świetna funkcja, jeśli chcesz zmniejszyć swój ślad węglowy i osiągnąć cele w zakresie zrównoważonego rozwoju.

Omówienie rozwiązania

Aby wdrożyć swoje modele w instancjach Graviton, użyj albo Kontenery AWS Deep Learning or przynieść własne pojemniki kompatybilny z architekturą ARM v8.2.

Migracja (lub nowe wdrożenie) modeli z instancji opartych na architekturze x86 do instancji Graviton jest prosta, ponieważ AWS zapewnia kontenery do hostowania modeli z PyTorch, TensorFlow, Scikit-learn i XGBoost, a modele są niezależne od architektury. Niemniej jednak, jeśli chcesz przynieść własne biblioteki, możesz to zrobić, po prostu upewnij się, że Twój kontener jest zbudowany w środowisku obsługującym architekturę Arm64. Aby uzyskać więcej informacji, zobacz Budowanie własnego kontenera algorytmów.

Aby wdrożyć model, musisz wykonać trzy kroki:

1. Utwórz model SageMaker: Będzie on zawierał między innymi informacje o lokalizacji pliku modelu, kontenerze, który zostanie użyty do wdrożenia, oraz lokalizacji skryptu wnioskowania. (Jeśli masz już wdrożony istniejący model w wystąpieniu wnioskowania opartym na architekturze x86, możesz pominąć ten krok).
2. Utwórz konfigurację punktu końcowego: Będzie ona zawierać informacje o typie instancji dla punktu końcowego (na przykład ml.c7g.xlarge dla Graviton3), nazwę modelu utworzonego w kroku 1 oraz liczbę instancji na punkt końcowy.
3. Uruchom punkt końcowy z konfiguracją punktu końcowego utworzoną w kroku 2.

Wymagania wstępne

Przed rozpoczęciem rozważ następujące wymagania wstępne:

1. Wypełnij wymagania wstępne wymienione w Wymagania wstępne.
2. Twój model powinien być oparty na PyTorch, TensorFlow, XGBoost lub Scikit-learn. W poniższej tabeli podsumowano wersje obsługiwane obecnie w chwili pisania tego tekstu. Aby uzyskać najnowsze aktualizacje, patrz Kontenery SageMaker Framework (tylko obsługa SM).
   

   .	Python	TensorFlow	PyTorch	Nauka scikitu	XGBoost
   Obsługiwane wersje	3.8	2.9.1	1.12.1	1.0-1	1.3-1 do 1.5-1

3. Skrypt wnioskowania jest przechowywany w Usługa Amazon Simple Storage (Amazonka S3).

W poniższych sekcjach przeprowadzimy Cię przez kroki wdrażania.

Stwórz model SageMakera

Jeśli masz już wdrożony model w wystąpieniu wnioskowania opartym na architekturze x86, możesz pominąć ten krok. W przeciwnym razie wykonaj następujące kroki, aby utworzyć model SageMaker:

1. Znajdź model przechowywany w zasobniku S3. Skopiuj identyfikator URI.
   Użyjesz identyfikatora URI modelu później w MODEL_S3_LOCATION.
2. Zidentyfikuj wersję platformy i wersję języka Python, które były używane podczas uczenia modelu.
   Musisz wybrać kontener z listy dostępnych kontenerów AWS Deep Learning dla twojego frameworka i wersji Pythona. Aby uzyskać więcej informacji, patrz Przedstawiamy wieloarchitekturowe obrazy kontenerów dla Amazon ECR.
3. Znajdź identyfikator URI skryptu wnioskowania w języku Python w zasobniku S3 (powszechna nazwa pliku to inference.py).
   Identyfikator URI skryptu wnioskowania jest potrzebny w pliku INFERENCE_SCRIPT_S3_LOCATION.
4. Dzięki tym zmiennym możesz następnie wywołać interfejs API SageMaker za pomocą następującego polecenia:

   client = boto3.client("sagemaker")
   
   client.create_model(
       ModelName="Your model name",
       PrimaryContainer={
           "Image": ,
           "ModelDataUrl": ,
           "Environment": {
           "SAGEMAKER_PROGRAM": "inference.py",
           "SAGEMAKER_SUBMIT_DIRECTORY": ,
           "SAGEMAKER_CONTAINER_LOG_LEVEL": "20",
           "SAGEMAKER_REGION": 
           }
       },
       ExecutionRoleArn= 
   )

Możesz także tworzyć obrazy o wielu architekturach i używać tego samego obrazu, ale z różnymi tagami. Możesz wskazać, na jakiej architekturze zostanie wdrożona Twoja instancja. Aby uzyskać więcej informacji, patrz Przedstawiamy wieloarchitekturowe obrazy kontenerów dla Amazon ECR.

Utwórz konfigurację punktu końcowego

Po utworzeniu modelu musisz utworzyć konfigurację punktu końcowego, uruchamiając następujące polecenie (zwróć uwagę na typ używanej instancji):

client.create_endpoint_config(
    EndpointConfigName= ,
    ProductionVariants=[
        {
         "VariantName": "v0",
         "ModelName": "Your model name",
         "InitialInstanceCount": 1,
         "InstanceType": "ml.c7g.xlarge",
        },
    ]
)

Poniższy zrzut ekranu pokazuje szczegóły konfiguracji punktu końcowego w konsoli SageMaker.

Uruchom punkt końcowy

Mając konfigurację punktu końcowego utworzoną w poprzednim kroku, możesz wdrożyć punkt końcowy:

client.create_endpoint(
    EndpointName = "",
    EndpointConfigName = ""
    )

Poczekaj, aż punkt końcowy modelu zostanie wdrożony. Prognozy można żądać w ten sam sposób, w jaki żądasz prognoz dla punktów końcowych wdrożonych w instancjach opartych na architekturze x86.

Poniższy zrzut ekranu pokazuje punkt końcowy w konsoli SageMaker.

Co jest obsługiwane

SageMaker zapewnia zoptymalizowane pod kątem wydajności głębokie kontenery Graviton dla frameworków TensorFlow i PyTorch. Te kontenery obsługują wizję komputerową, przetwarzanie języka naturalnego, zalecenia oraz ogólne, głębokie i szerokie przypadki użycia wnioskowania opartego na modelu. Oprócz kontenerów uczenia głębokiego SageMaker udostępnia również kontenery dla klasycznych platform ML, takich jak XGBoost i Scikit-learn. Kontenery są kompatybilne binarnie w instancjach c6g/m6g i c7g, dlatego migracja aplikacji wnioskowania z jednej generacji do drugiej jest bezproblemowa.

C6g/m6g obsługuje fp16 (half-precision float) i dla zgodnych modeli zapewnia równoważną lub lepszą wydajność w porównaniu z instancjami c5. C7g znacznie zwiększa wydajność ML, podwajając szerokość SIMD i obsługując bfloat-16 (bf16), który jest najbardziej opłacalną platformą do uruchamiania twoich modeli.

Zarówno c6g/m6g, jak i c7g zapewniają dobrą wydajność klasycznego ML (na przykład XGBoost) w porównaniu z innymi instancjami procesora w SageMaker. Obsługa Bfloat-16 na c7g umożliwia wydajne wdrażanie modeli przeszkolonych w trybie bf16 lub AMP (Automatic Mixed Precision). Backend Arm Compute Library (ACL) w Graviton zapewnia jądra bfloat-16, które mogą przyspieszyć nawet operatorów fp32 poprzez szybki tryb matematyczny, bez kwantyzacji modelu.

Zalecane najlepsze praktyki

W instancjach Graviton każdy vCPU jest rdzeniem fizycznym. Nie ma rywalizacji o wspólne zasoby procesora (w przeciwieństwie do SMT), a skalowanie wydajności obciążenia jest liniowe z każdym dodaniem vCPU. W związku z tym zaleca się używanie wnioskowania wsadowego zawsze, gdy pozwala na to przypadek użycia. Umożliwi to efektywne wykorzystanie vCPU poprzez równoległe przetwarzanie partii na każdym fizycznym rdzeniu. Jeśli wnioskowanie wsadowe nie jest możliwe, wymagany jest optymalny rozmiar wystąpienia dla danego ładunku, aby upewnić się, że obciążenie związane z planowaniem wątków systemu operacyjnego nie przewyższa mocy obliczeniowej dostarczanej z dodatkowymi procesorami wirtualnymi.

TensorFlow jest domyślnie dostarczany z jądrami Eigen i zaleca się przejście na OneDNN z ACL, aby uzyskać najbardziej zoptymalizowany backend wnioskowania. Backend OneDNN i szybki tryb matematyczny bfloat-16 można włączyć podczas uruchamiania usługi kontenera:

docker run -p 8501:8501 --name tfserving_resnet 
--mount type=bind,source=/tmp/resnet,target=/models/resnet 
-e MODEL_NAME=resnet -e TF_ENABLE_ONEDNN_OPTS=1 
-e DNNL_DEFAULT_FPMATH_MODE=BF16 -e -t tfs:mkl_aarch64

Poprzednie polecenie udostępniania obsługuje standardowy model resnet50 z dwiema ważnymi konfiguracjami:

-e TF_ENABLE_ONEDNN_OPTS=1
-e DNNL_DEFAULT_FPMATH_MODE=BF16

Można je przekazać do kontenera wnioskowania w następujący sposób:

client.create_model(
    ModelName="Your model name",
    PrimaryContainer={
    "Image": ,
    "ModelDataUrl": ,
    "Environment": {
        "SAGEMAKER_PROGRAM": "inference.py",
        "SAGEMAKER_SUBMIT_DIRECTORY": "",
        "SAGEMAKER_CONTAINER_LOG_LEVEL": "20",
        "SAGEMAKER_REGION": ,
        "TF_ENABLE_ONEDNN_OPTS": "1",
        "DNNL_DEFAULT_FPMATH_MODE": "BF16"
         }
     },
     ExecutionRoleArn='ARN for AmazonSageMaker-ExecutionRole'
)

Przykład wdrożenia

W tym poście pokazujemy, jak wdrożyć model TensorFlow, przeszkolony w SageMaker, na instancji wnioskowania SageMaker zasilanej przez Graviton.

Przykładowy kod można uruchomić w instancji notatnika SageMaker, a Studio Amazon SageMaker notebook lub notebook Jupyter w trybie lokalnym. Musisz pobrać rolę wykonawczą SageMaker, jeśli używasz notatnika Jupyter w trybie lokalnym.

Poniższy przykład dotyczy zestawu danych CIFAR-10. Możesz śledzić przykład notatnika z przykładów SageMaker GitHub repo aby odtworzyć model, który jest używany w tym poście. Używamy wyszkolonego modelu i cifar10_keras_main.py Skrypt Pythona do wnioskowania.

Model jest przechowywany w wiaderku S3: s3://aws-ml-blog/artifacts/run-ml-inference-on-graviton-based-instances-with-amazon-sagemaker/model.tar.gz

Połączenia cifar10_keras_main.py skrypt, którego można użyć do wnioskowania, jest przechowywany pod adresem:s3://aws-ml-blog/artifacts/run-ml-inference-on-graviton-based-instances-with-amazon-sagemaker/script/cifar10_keras_main.py

Używamy us-east-1 Region i wdróż model w wystąpieniu ml.c7g.xlarge Graviton. Na tej podstawie identyfikator URI naszego kontenera do głębokiego uczenia AWS to 763104351884.dkr.ecr.us-east-1.amazonaws.com/tensorflow-inference-graviton:2.9.1-cpu-py38-ubuntu20.04-sagemaker

1. Skonfiguruj za pomocą następującego kodu:

   import sagemaker
   import boto3
   import datetime
   import json
   import gzip
   import os
   
   sagemaker_session = sagemaker.Session()
   bucket = sagemaker_session.default_bucket()
   role = sagemaker.get_execution_role()
   region = sagemaker_session.boto_region_name

2. Pobierz zestaw danych do testowania punktów końcowych:

   from keras.datasets import cifar10
   (x_train, y_train), (x_test, y_test) = cifar10.load_data()

3. Utwórz konfigurację modelu i punktu końcowego, a następnie wdróż punkt końcowy:

   timestamp = "{:%Y-%m-%d-%H-%M-%S}".format(datetime.datetime.now())
   
   client = boto3.client("sagemaker")
   
   MODEL_NAME = f"graviton-model-{timestamp}"
   ENDPOINT_NAME = f"graviton-endpoint-{timestamp}"
   ENDPOINT_CONFIG_NAME = f"graviton-endpoint-config-{timestamp}"
   
   # create sagemaker model
   create_model_response = client.create_model(
       ModelName=MODEL_NAME,
       PrimaryContainer={
       "Image":  "763104351884.dkr.ecr.us-east-1.amazonaws.com/tensorflow-inference-graviton:2.9.1-cpu-py38-ubuntu20.04-sagemaker ",
       "ModelDataUrl":  "s3://aws-ml-blog/artifacts/run-ml-inference-on-graviton-based-instances-with-amazon-sagemaker/model.tar.gz",
       "Environment": {
           "SAGEMAKER_CONTAINER_LOG_LEVEL": "20",
           "SAGEMAKER_REGION": region
           }
       },
       ExecutionRoleArn=role
   )
   print ("create_model API response", create_model_response)

4. Opcjonalnie możesz dodać swój skrypt wnioskowania do Environment in create_model jeśli pierwotnie nie dodałeś go jako artefaktu do swojego modelu SageMaker podczas treningu:

   "SAGEMAKER_PROGRAM": "inference.py",
   "SAGEMAKER_SUBMIT_DIRECTORY": ,
   		
   # create sagemaker endpoint config
   create_endpoint_config_response = client.create_endpoint_config(
       EndpointConfigName=ENDPOINT_CONFIG_NAME,
       ProductionVariants=[
           {
            "VariantName": "v0",
            "ModelName": MODEL_NAME,
            "InitialInstanceCount": 1,
            "InstanceType": "ml.c7g.xlarge" 
           },
       ]
   )
   print ("ncreate_endpoint_config API response", create_endpoint_config_response)
   
   # create sagemaker endpoint
   create_endpoint_response = client.create_endpoint(
       EndpointName = ENDPOINT_NAME,
       EndpointConfigName = ENDPOINT_CONFIG_NAME,
   )
   print ("ncreate_endpoint API response", create_endpoint_response)   
   

   Musisz poczekać kilka minut na wdrożenie.

5. Sprawdź stan punktu końcowego za pomocą następującego kodu:

   describe_response = client.describe_endpoint(EndpointName=ENDPOINT_NAME)
   print(describe_response["EndpointStatus"]

   Możesz również sprawdzić Konsola zarządzania AWS aby zobaczyć, kiedy Twój model zostanie wdrożony.

6. Skonfiguruj środowisko wykonawcze, aby wywołać punkty końcowe:

   runtime = boto3.Session().client(service_name="runtime.sagemaker")

   Teraz przygotowujemy ładunek do wywołania punktu końcowego. Używamy tego samego typu obrazów, które są używane do szkolenia modelu. Zostały one pobrane w poprzednich krokach.

7. Rzuć ładunek na tensory i ustaw poprawny format, którego oczekuje model. W tym przykładzie żądamy tylko jednej prognozy.

   input_image = x_test[0].reshape(1,32,32,3)

   Otrzymujemy dane wyjściowe modelu jako tablicę.

8. Możemy przekształcić ten wynik w prawdopodobieństwa, jeśli zastosujemy do niego softmax:

   CONTENT_TYPE = 'application/json'
   ACCEPT = 'application/json'
   PAYLOAD = json.dumps(input_image.tolist())
   
   response = runtime.invoke_endpoint(
       EndpointName=ENDPOINT_NAME, 
       ContentType=CONTENT_TYPE,
       Accept=ACCEPT,
       Body=PAYLOAD
   )
       
   print(response['Body'].read().decode())

Oczyść zasoby

Usługi związane z tym rozwiązaniem wiążą się z kosztami. Po zakończeniu korzystania z tego rozwiązania wyczyść następujące zasoby:

client.delete_endpoint(EndpointName=ENDPOINT_NAME)
client.delete_endpoint_config(EndpointConfigName=ENDPOINT_CONFIG_NAME)
client.delete_model(ModelName=MODEL_NAME)

Porównanie ceny do wydajności

Instancje oparte na grawitonie oferują najniższą cenę i najlepszy stosunek ceny do wydajności w porównaniu z instancjami opartymi na architekturze x86. Podobnie jak w przypadku instancji EC2, punkty końcowe wnioskowania SageMaker z instancjami ml.c6g (Graviton 2) oferują o 20% niższą cenę w porównaniu z instancjami ml.c5, a instancje Graviton 3 ml.c7g są o 15% tańsze niż instancje ml.c6. Aby uzyskać więcej informacji, patrz Cennik Amazon SageMaker.

Wnioski

W tym poście zaprezentowaliśmy nowo uruchomioną funkcję SageMaker do wdrażania modeli w instancjach wnioskowania opartych na Gravitonie. Udzieliliśmy wskazówek dotyczących najlepszych praktyk i pokrótce omówiliśmy korzyści związane z ceną i wydajnością nowego typu wystąpień wnioskowania.

Aby dowiedzieć się więcej o Gravitonie, zobacz Procesor grawitonowy AWS. Możesz zacząć z instancjami EC2 opartymi na AWS Graviton na konsoli Amazon EC2 i odwołując się do Przewodnik techniczny AWS Graviton. Możesz wdrożyć punkt końcowy modelu Sagemaker do wnioskowania na Graviton z przykładowym kodem w tym poście na blogu.

O autorach

dr Victor Jaramillo, jest starszym inżynierem uczenia maszynowego w AWS Professional Services. Zanim dołączył do AWS, był profesorem uniwersyteckim i naukowcem zajmującym się konserwacją zapobiegawczą. W wolnym czasie lubi jeździć na swoim motocyklu i majsterkować jako mechanik motocyklowy.

dr Zmnako Awrahman, jest kierownikiem praktyki, członkiem ML SME i członkiem Machine Learning Technical Field Community (TFC) w Amazon Web Services. Pomaga klientom wykorzystać moc chmury do wydobywania wartości z ich danych dzięki analizie danych i uczeniu maszynowemu.

Sunita Nadampalli jest kierownikiem ds. rozwoju oprogramowania w AWS. Prowadzi optymalizacje wydajności oprogramowania Graviton pod kątem obciążeń maszynowych, HPC i multimedialnych. Pasjonuje się rozwojem oprogramowania typu open source i dostarczaniem opłacalnych rozwiązań programowych z układami Arm SoC.

Jana Liu jest inżynierem rozwoju oprogramowania w zespole Amazon SageMaker. Jej obecna praca koncentruje się na pomaganiu programistom w efektywnym hostowaniu modeli uczenia maszynowego i poprawie wydajności wnioskowania. Pasjonuje się analizą danych przestrzennych i wykorzystaniem AI do rozwiązywania problemów społecznych.

Alana Tana jest starszym menedżerem produktu w firmie SageMaker, kierując pracami nad wnioskowaniem na dużych modelach. Pasjonuje go zastosowanie uczenia maszynowego w obszarze analityki. Poza pracą lubi przebywać na świeżym powietrzu.