Włączanie hybrydowych przepływów pracy ML w Amazon EKS i Amazon SageMaker za pomocą jednego kliknięcia Kubeflow we wdrożeniu AWS

Obecnie wielu klientów AWS buduje na nich gotowe do zastosowania w przedsiębiorstwach platformy uczenia maszynowego (ML). Elastyczna usługa Amazon Kubernetes (Amazon EKS) za pomocą Kubeflow w AWS (dystrybucja Kubeflow specyficzna dla AWS) w wielu przypadkach użycia, w tym widzenia komputerowego, rozumienia języka naturalnego, tłumaczenia mowy i modelowania finansowego.

Z najnowsza wersja otwartego oprogramowania Kubeflow v1.6.1, społeczność Kubeflow nadal wspiera tę masową adaptację Kubeflow do przypadków użycia w przedsiębiorstwach. Najnowsza wersja zawiera wiele nowych, ekscytujących funkcji, takich jak obsługa Kubernetes v1.22, połączony zestaw Python SDK dla PyTorch, MXNet, MPI, XGBoost w rozproszonym operatorze szkoleniowym Kubeflow, nowe ClusterServingRuntime i ServingRuntime CRD do obsługi modeli i wiele innych.

Wkład AWS do Kubeflow wraz z niedawnym uruchomieniem Kubeflow na AWS 1.6.1 obsługuje wszystkie funkcje Kubeflow typu open source i obejmuje wiele nowych integracji z wysoce zoptymalizowanymi, natywnymi dla chmury, gotowymi do zastosowania w przedsiębiorstwach usługami AWS, które pomogą Ci zbudować wysoce niezawodne, bezpieczne, przenośne i skalowalne systemy uczenia maszynowego.

W tym poście omawiamy nowe funkcje Kubeflow w AWS v1.6.1 i podkreślamy trzy ważne integracje, które zostały połączone na jednej platformie, aby zaoferować:

• Infrastruktura jako kod (IaaC) rozwiązanie jednym kliknięciem, które automatyzuje kompleksową instalację Kubeflow, w tym tworzenie klastra EKS
• Obsługa szkoleń rozproszonych nt Amazon Sage Maker za pomocą Operatorzy Amazon SageMaker dla Kubernetes (ACK) i Komponenty SageMaker dla potoków Kubeflow i lokalnie na Kubernetes przy użyciu Operatorzy szkolenia Kubeflow. Wielu klientów korzysta z tej możliwości do tworzenia hybrydowych architektur uczenia maszynowego, w których wykorzystują zarówno obliczenia Kubernetes w fazie eksperymentów, jak i SageMaker do uruchamiania obciążeń na skalę produkcyjną.
• Ulepszone monitorowanie i obserwowalność obciążeń ML, w tym Amazon EKS, metryki Kubeflow i dzienniki aplikacji przy użyciu Prometheus, Grafana i Amazon Cloud Watch integracje

Przypadek użycia w tym blogu skupi się w szczególności na integracji SageMaker z Kubeflow na AWS, którą można dodać do istniejących przepływów pracy Kubernetes, umożliwiając budowanie hybrydowych architektur uczenia maszynowego.

Kubeflow w AWS

Kubeflow w AWS 1.6.1 zapewnia przejrzystą ścieżkę korzystania z Kubeflow, dodając następujące usługi AWS do istniejących możliwości:

• Integracja SageMaker z Kubeflow w celu uruchamiania hybrydowych przepływów pracy ML przy użyciu SageMaker Operators for Kubernetes (ACK) i SageMaker Components for Kubeflow Pipelines.
• Opcje zautomatyzowanego wdrażania zostały ulepszone i uproszczone przy użyciu skryptów Kustomize i wykresów Helm.
• Dodano obsługę wdrożenia Infrastructure as Code (IaC) jednym kliknięciem dla Kubeflow na AWS przy użyciu Terraform dla wszystkich dostępnych opcje wdrażania. Ten skrypt automatyzuje tworzenie następujących zasobów AWS:
• Wsparcie dla Prywatny link AWS dla Amazon S3, umożliwiając użytkownikom regionu niekomercyjnego łączenie się z ich odpowiednimi punktami końcowymi S3.
• Dodano integrację z Usługa zarządzana przez Amazon dla Prometheusa (AMP) i Grafana zarządzana przez Amazon do monitorowania metryk za pomocą Kubeflow na AWS.
• Zaktualizowano kontenery serwerów notebooków Kubeflow o najnowsze obrazy kontenerów głębokiego uczenia oparte na TensorFlow 2.10.0 i PyTorch 1.12.1.
• Integracja z pakietami DLC AWS w celu uruchamiania rozproszonego trening i wnioskowanie obciążenia.

Poniższy diagram architektury to szybki przegląd wszystkich integracji usług (w tym wspomnianych już), które są dostępne dla kontroli Kubeflow i komponentów płaszczyzny danych w Kubeflow na AWS. Płaszczyzna kontrolna Kubeflow jest instalowana na Amazon EKS, która jest zarządzaną usługą kontenerową używaną do uruchamiania i skalowania aplikacji Kubernetes w chmurze. Te integracje usług AWS umożliwiają oddzielenie krytycznych części płaszczyzny kontrolnej Kubeflow od Kubernetes, zapewniając bezpieczny, skalowalny, odporny i zoptymalizowany pod względem kosztów projekt. Aby uzyskać więcej informacji na temat wartości, jaką te integracje usług dodają w stosunku do rozwiązania Kubeflow typu open source, zapoznaj się z artykułem Twórz i wdrażaj skalowalny system uczenia maszynowego na Kubernetes za pomocą Kubeflow na AWS.

Omówmy bardziej szczegółowo, w jaki sposób kluczowe funkcje Kubeflow w AWS 1.6.1 mogą być pomocne dla Twojej organizacji.

Kubeflow w szczegółach funkcji AWS

W wersji Kubeflow 1.6.1 staraliśmy się zapewnić lepsze narzędzia dla różnego rodzaju klientów, które ułatwią rozpoczęcie korzystania z Kubeflow bez względu na wybrane opcje. Te narzędzia stanowią dobry punkt wyjścia i można je modyfikować, aby dokładnie odpowiadały Twoim potrzebom.

Opcje wdrażania

Zapewniamy różne opcje wdrażania dla różnych przypadków użycia klientów. Tutaj możesz wybrać, z którymi usługami AWS chcesz zintegrować swoje wdrożenie Kubeflow. Jeśli zdecydujesz się później zmienić opcje wdrażania, zalecamy wykonanie nowej instalacji dla nowego wdrożenia. Dostępne są następujące opcje wdrażania:

Jeśli chcesz wdrożyć Kubeflow z minimalnymi zmianami, rozważ wanilia opcja wdrożenia. Wszystkie dostępne opcje wdrażania można zainstalować za pomocą Kustomize, Helm lub Terraform.

Oferujemy również różne wdrożenia dodatkowe, które można zainstalować na dowolnej z poniższych opcji wdrażania:

Opcje instalacji

Po podjęciu decyzji, która opcja wdrożenia najlepiej odpowiada Twoim potrzebom, możesz wybrać sposób instalacji tych wdrożeń. Starając się służyć zarówno ekspertom, jak i nowicjuszom, oferujemy różne poziomy automatyzacji i konfiguracji.

Opcja 1: Terraform (IAC)

Spowoduje to utworzenie klastra EKS i wszystkich powiązanych zasobów infrastruktury AWS, a następnie wdrożenie Kubeflow w jednym poleceniu przy użyciu Terraform. Wewnętrznie wykorzystuje to plany EKS i wykresy Helm.

Ta opcja ma następujące zalety:

• Zapewnia przedsiębiorstwom elastyczność w zakresie wdrażania Amazon EKS i Kubeflow za pomocą jednego polecenia bez konieczności martwienia się o określone konfiguracje komponentów Kubeflow. To ogromnie pomoże przyspieszyć ocenę technologii, prototypowanie i cykl rozwoju produktu, zapewniając elastyczność w korzystaniu z modułów terraform i modyfikowaniu ich w celu spełnienia wszelkich potrzeb specyficznych dla projektu.
• Wiele organizacji, dla których Terraform stanowi centrum strategii chmurowej, może teraz korzystać z rozwiązania Kubeflow na platformie AWS Terraform, aby osiągnąć swoje cele związane z chmurą.

Opcja 2: Wykresy Kustomize lub Helm:

Ta opcja umożliwia wdrożenie Kubeflow w dwuetapowym procesie:

1. Twórz zasoby AWS, takie jak Amazon EKS, Amazon RDS, Amazon S3 i Amazon Cognito, za pomocą zautomatyzowanych skryptów zawartych w dystrybucji AWS lub ręcznie postępując zgodnie z krok-po-kroku.
2. Zainstaluj wdrożenia Kubeflow za pomocą wykresów Helm lub Kustomize.

Ta opcja ma następujące zalety:

• Głównym celem tej opcji instalacji jest zapewnienie konfiguracji Kubernetes związanych z Kubeflow. Dlatego możesz utworzyć lub przenieść istniejące klastry EKS lub dowolne powiązane zasoby AWS, takie jak Amazon RDS, Amazon S3 i Amazon Cognito, oraz skonfigurować je i zarządzać nimi do pracy z Kubeflow na AWS.
• Łatwiej jest przejść z manifestu Kustomize Kubeflow typu open source do dystrybucji AWS Kubeflow.

Poniższy diagram ilustruje architektury obu opcji.

Integracja z SageMakerem

SageMaker to w pełni zarządzana usługa zaprojektowana i zoptymalizowana specjalnie do zarządzania przepływami pracy ML. Eliminuje niezróżnicowane ciężkie zarządzanie infrastrukturą i eliminuje potrzebę inwestowania w IT i DevOps w celu zarządzania klastrami w celu budowania modeli ML, szkolenia i wnioskowania.

Wielu klientów AWS, którzy mają wymagania dotyczące przenośności lub lokalne standardowe ograniczenia, używa Amazon EKS do konfigurowania powtarzalnych potoków ML obsługujących obciążenia szkoleniowe i wnioskowania. Wymaga to jednak od programistów napisania niestandardowego kodu w celu optymalizacji podstawowej infrastruktury uczenia maszynowego, zapewnienia wysokiej dostępności i niezawodności oraz zgodności z odpowiednimi wymogami bezpieczeństwa i przepisami. Dlatego ci klienci chcą używać SageMaker do zoptymalizowanej pod względem kosztów i zarządzanej infrastruktury do szkolenia modeli i wdrożeń oraz nadal używać Kubernetes do orkiestracji i potoków ML, aby zachować standaryzację i przenośność.

Aby zaspokoić tę potrzebę, AWS umożliwia trenowanie, dostrajanie i wdrażanie modeli w SageMaker z Amazon EKS przy użyciu następujących dwóch opcji:

• Amazon SageMaker ACK Operators dla Kubernetes, które są oparte na Kontrolery AWS dla Kubernetes (ACK). ACK to strategia AWS, która wprowadza standaryzację do budowania niestandardowych kontrolerów Kubernetes, które umożliwiają użytkownikom Kubernetes udostępnianie zasobów AWS, takich jak bazy danych lub kolejki komunikatów, po prostu za pomocą interfejsu API Kubernetes. SageMaker ACK Operators ułatwiają programistom ML i analitykom danych, którzy używają Kubernetes jako swojej płaszczyzny kontrolnej, trenowanie, dostrajanie i wdrażanie modeli ML w SageMaker bez konieczności logowania się do konsoli SageMaker.
• Połączenia Komponenty SageMaker dla rurociągów Kubeflow, które pozwalają zintegrować SageMaker z przenośnością i orkiestracją Kubeflow Pipelines. Dzięki komponentom SageMaker każde zadanie w przepływie pracy potoku jest uruchamiane w SageMaker zamiast w lokalnym klastrze Kubernetes. Pozwala to na tworzenie i monitorowanie natywnych zadań szkoleniowych SageMaker, dostrajanie, wdrażanie punktów końcowych i transformację wsadową z potoków Kubeflow, umożliwiając w ten sposób przeniesienie pełnych obliczeń, w tym zadań przetwarzania danych i zadań szkoleniowych, z klastra Kubernetes do usługi zarządzanej SageMaker zoptymalizowanej pod kątem uczenia maszynowego.

Począwszy od Kubeflow na AWS v1.6.1, wszystkie dostępne opcje wdrażania Kubeflow domyślnie łączą obie opcje integracji Amazon SageMaker na jednej platformie. Oznacza to, że możesz teraz przesyłać zadania SageMaker przy użyciu operatorów SageMaker ACK z samego serwera Kubeflow Notebook, przesyłając niestandardowy zasób SageMaker lub z etapu potoku Kubeflow przy użyciu komponentów SageMaker.

Istnieją dwie wersje SageMaker Components – Boto3 (AWS SDK for AWS SDK for Python) komponenty oparte na wersji 1 i komponenty SageMaker Operator for K8s (ACK) oparte na wersji 2. Nowe komponenty SageMaker w wersji 2 obsługują najnowsze interfejsy szkoleniowe SageMaker i będziemy nadal dodawać więcej funkcji SageMaker do tej wersji komponentu. Masz jednak swobodę łączenia komponentów Sagemaker w wersji 2 do celów szkoleniowych i wersji 1 w przypadku innych funkcji SageMaker, takich jak strojenie hiperparametrów, zadania przetwarzania, hosting i wiele innych.

Integracja z Prometheusem i Grafaną

Prometheus to narzędzie do agregacji metryk typu open source, które można skonfigurować do uruchamiania w klastrach Kubernetes. Podczas działania w klastrach Kubernetes główny serwer Prometheus okresowo usuwa punkty końcowe podów.

Komponenty Kubeflow, takie jak Kubeflow Pipelines (KFP) i Notebook, emitują metryki Prometheus, aby umożliwić monitorowanie zasobów komponentów, takich jak liczba uruchomionych eksperymentów lub liczba notatników.

Metryki te mogą być agregowane przez serwer Prometheus działający w klastrze Kubernetes i przeszukiwane przy użyciu Prometheus Query Language (PromQL). Aby uzyskać więcej informacji na temat funkcji obsługiwanych przez Prometheus, sprawdź Dokumentacja Prometeusza.

Dystrybucja Kubeflow w AWS zapewnia obsługę integracji z następującymi usługami zarządzanymi AWS:

1. Amazon Managed Prometheus (AMP), czyli Prometheuskompatybilna usługa monitorowania infrastruktury kontenerów i metryk aplikacji dla kontenerów, która ułatwia klientom bezpieczne monitorowanie środowisk kontenerów na dużą skalę. Korzystając z AMP, możesz wizualizować, analizować i alarmować swoje metryki, dzienniki i ślady zebrane z wielu źródeł danych w swoim systemie obserwowalności, w tym AWS, zewnętrznych niezależnych dostawców oprogramowania i innych zasobów w całym portfolio IT.
2. Amazon Managed Grafana, w pełni zarządzana i bezpieczna usługa wizualizacji danych oparta na open source grafana projekt, który umożliwia klientom natychmiastowe wyszukiwanie, korelowanie i wizualizację metryk operacyjnych, dzienników i śladów dla ich aplikacji z wielu źródeł danych. Amazon Managed Grafana odciąża zarządzanie operacyjne Grafana poprzez automatyczne skalowanie infrastruktury obliczeniowej i bazy danych wraz ze wzrostem wymagań użytkowania, dzięki automatycznym aktualizacjom wersji i łataniu zabezpieczeń.

Dystrybucja Kubeflow na platformie AWS zapewnia obsługę integracji Amazon Managed Service for Prometheus i Amazon Managed Grafana w celu ułatwienia bezpiecznego pozyskiwania i wizualizacji wskaźników Prometheus na dużą skalę.

Następujące metryki są przetwarzane i można je wizualizować:

• Metryki emitowane z komponentów Kubeflow, takich jak Kubeflow Pipelines i serwer Notebook
• KubeFlow metryki płaszczyzny kontrolnej

Aby skonfigurować Amazon Managed Service dla Prometheus i Amazon Managed Grafana dla klastra Kubeflow, zapoznaj się z Użyj Prometheus, Amazon Managed Service for Prometheus i Amazon Managed Grafana do monitorowania wskaźników za pomocą Kubeflow na AWS.

Omówienie rozwiązania

W tym przypadku używamy waniliowego wdrożenia Kubeflow przy użyciu opcji instalacji Terraform. Po zakończeniu instalacji logujemy się do dashboardu Kubeflow. Z pulpitu nawigacyjnego uruchamiamy serwer notebooków Kubeflow Jupyter w celu zbudowania potoku Kubeflow, który wykorzystuje SageMaker do uruchamiania rozproszonego szkolenia dla modelu klasyfikacji obrazów i punktu końcowego SageMaker do wdrażania modelu.

Wymagania wstępne

Upewnij się, że spełniasz następujące wymagania wstępne:

• Masz Konto AWS.
• Upewnij się, że jesteś w us-west-2 Region do uruchomienia tego przykładu.
• Użyj Google Chrome do interakcji z Konsola zarządzania AWS i Kubeflow.
• Upewnij się, że Twoje konto ma limit typów zasobów SageMaker Training dla ml.p3.2xlarge zwiększony do 2 za pomocą konsoli limitów usług.
• Opcjonalnie możesz użyć Chmura AWS9, zintegrowane środowisko programistyczne (IDE) oparte na chmurze, które umożliwia wykonywanie wszystkich prac z poziomu przeglądarki internetowej. Aby uzyskać instrukcje dotyczące konfiguracji, zobacz Skonfiguruj IDE Cloud9. Wybierz Ubuntu Server 18.04 jako platformę w ustawieniach AWS Cloud9.Następnie ze środowiska AWS Cloud9 wybierz znak plus i otwórz nowy terminal.

Konfigurujesz również plik Interfejs wiersza poleceń AWS (AWS CLI). Aby to zrobić, potrzebujesz identyfikatora klucza dostępu i tajnego klucza dostępu typu an AWS Zarządzanie tożsamością i dostępem (JESTEM) użytkownik konto z uprawnieniami administracyjnymi (dołącz istniejącą zarządzaną politykę) i dostępem programistycznym. Zobacz następujący kod:

aws configure --profile=kubeflow

AWS Access Key ID [None]: 
AWS Secret Access Key [None]: 
Default region name [None]: us-west-2
Default output format [None]: json

# (In Cloud9, select “Cancel” and “Permanently disable” when the AWS managed temporary credentials dialog pops up)

export AWS_PROFILE=kubeflow

Sprawdź uprawnienia, których cloud9 będzie używać do wywoływania zasobów AWS.

aws sts get-caller-identity

Sprawdź na podstawie poniższych danych wyjściowych, czy widzisz arn użytkownika administratora, którego skonfigurowałeś w profilu AWS CLI. W tym przykładzie jest to „użytkownik kubeflow”

{
    "UserId": "*******",
    "Account": "********",
    "Arn": "arn:aws:iam::*******:user/kubeflow-user"
}

Zainstaluj Amazon EKS i Kubeflow na AWS

Aby zainstalować Amazon EKS i Kubeflow na AWS, wykonaj następujące kroki:

1. Skonfiguruj swoje środowisko do wdrażania Kubeflow na AWS:

   #Clone the awslabs/kubeflow-manifests and the kubeflow/manifests repositories and check out the release branches of your choosing
   export KUBEFLOW_RELEASE_VERSION=v1.6.1
   export AWS_RELEASE_VERSION=v1.6.1-aws-b1.0.0
   git clone https://github.com/awslabs/kubeflow-manifests.git && cd kubeflow-manifests
   git checkout ${AWS_RELEASE_VERSION}
   git clone --branch ${KUBEFLOW_RELEASE_VERSION} https://github.com/kubeflow/manifests.git upstream
   
   export MANIFEST_DIR=$PWD

   #Install the necessary tools with the following command:
   make install-tools
   source ~/.bash_profile

2. Wdróż podstawową wersję Kubeflow na AWS i powiązane zasoby AWS, takie jak EKS, używając Terraform. Należy pamiętać, że woluminy EBS używane w grupie węzłów EKS nie są domyślnie szyfrowane:

   #Define the following environment variables
   
   #Region to create the cluster in
   export CLUSTER_REGION=us-west-2
   #Name of the cluster to create
   export CLUSTER_NAME=

   cd deployments/vanilla/terraform
   
   #Save the variables to a .tfvars file
   cat < sample.auto.tfvars
   cluster_name="${CLUSTER_NAME}"
   cluster_region="${CLUSTER_REGION}"
   EOF
   
   #Run the following one-click command to deploy terraform to install EKS infrastructure and Kubeflow
   make deploy

Skonfiguruj uprawnienia Kubeflow

1. Dodaj uprawnienia do poda notebooka i poda komponentu Pipeline, aby wykonywać wywołania api SageMaker, S3 i IAM za pomocą kubeflow_iam_permissions.sh skrypt.

   export NAMESPACE=kubeflow-user-example-com
   
   wget https://raw.githubusercontent.com/aws-samples/eks-kubeflow-cloudformation-quick-start/9e46662d97e1be7edb0be7fc31166e545655636a/utils/kubeflow_iam_permissions.sh
   chmod +x kubeflow_iam_permissions.sh
   ./kubeflow_iam_permissions.sh $NAMESPACE $CLUSTER_NAME $CLUSTER_REGION

2. Utwórz rolę wykonawczą SageMaker, aby umożliwić zadaniu szkoleniowemu SageMaker dostęp do zestawu danych szkoleniowych z usługi S3 za pomocą sagemaker_role.sh skrypt.

   wget https://raw.githubusercontent.com/aws-samples/eks-kubeflow-cloudformation-quick-start/9e46662d97e1be7edb0be7fc31166e545655636a/utils/sagemaker_role.sh
   chmod +x sagemaker_role.sh
   ./sagemaker_role.sh

Uzyskaj dostęp do pulpitu nawigacyjnego Kubeflow

Aby uzyskać dostęp do pulpitu nawigacyjnego Kubeflow, wykonaj następujące czynności:

1. Możesz uruchomić dashboard Kubeflow lokalnie w środowisku Cloud9 bez ujawniania swoich adresów URL w publicznym Internecie, uruchamiając poniższe polecenia.

   # Configure Kubecontext
   $(terraform output -raw configure_kubectl)
   
   cd ${MANIFEST_DIR}
   make port-forward

2. Dodaj Podgląd uruchomionej aplikacji.
3. Wybierz ikonę w rogu pulpitu nawigacyjnego Kubeflow, aby otworzyć go jako oddzielną kartę w przeglądarce Chrome.
4. Wprowadź domyślne poświadczenia (user@example.com/12341234), aby zalogować się do pulpitu nawigacyjnego Kubeflow.

Skonfiguruj Kubeflow w środowisku AWS

Po zalogowaniu się do pulpitu nawigacyjnego Kubeflow upewnij się, że masz odpowiednią przestrzeń nazw (kubeflow-user-example-com) wybrany. Wykonaj następujące kroki, aby skonfigurować środowisko Kubeflow w AWS:

1. W panelu Kubeflow wybierz Notebooki w okienku nawigacji.
2. Dodaj Nowy notatnik.
3. W razie zamówieenia projektu Imię, wchodzić aws-nb.
4. W razie zamówieenia projektu Obraz kwitów Jupyter, wybierz obraz jupyter-pytorch:1.12.0-cpu-py38-ubuntu20.04-ec2-2022-09-20 (ostatni dostępny jupyter-pytorch obraz DLC).
5. W razie zamówieenia projektu CPU, wchodzić 1.
6. W razie zamówieenia projektu Pamięć, wchodzić 5.
7. W razie zamówieenia projektu GPU, zostaw jako żaden.
8. Nie wprowadzaj żadnych zmian do Workspace i Woluminy danych działy.
9. Wybierz Zezwól na dostęp do potoków Kubeflow Konfiguracje sekcję i wybierz opcję Uruchom.
10. Sprawdź, czy Twój notes został pomyślnie utworzony (może to potrwać kilka minut).
11. Dodaj Skontaktuj się aby zalogować się do JupyterLab.
12. Sklonuj repozytorium, wprowadzając https://github.com/aws-samples/eks-kubeflow-cloudformation-quick-start.git Sklonuj repozytorium pole.
13. Dodaj Clone.

Uruchom rozproszony przykład szkoleniowy

Po skonfigurowaniu notatnika Jupyter możesz uruchomić całe demo, wykonując następujące wysokopoziomowe kroki z folderu eks-kubeflow-cloudformation-quick-start/workshop/pytorch-distributed-training w sklonowanym repozytorium:

1. Uruchom skrypt szkoleniowy PyTorch Distributed Data Parallel (DDP). – Zapoznaj się ze skryptem szkoleniowym PyTorch DDP cifar10-distributed-gpu-final.py, który obejmuje przykładową konwolucyjną sieć neuronową i logikę do dystrybucji szkolenia w wielowęzłowym klastrze CPU i GPU.
2. Utwórz potok Kubeflow – Uruchom notatnik STEP1.0_create_pipeline_k8s_sagemaker.ipynb aby utworzyć potok, który uruchamia i wdraża modele w SageMaker. Upewnij się, że zainstalowałeś bibliotekę SageMaker jako część pierwszej komórki notatnika i zrestartuj jądro przed uruchomieniem pozostałych komórek notatnika.
3. Wywołaj punkt końcowy SageMaker – Uruchom notatnik STEP1.1_invoke_sagemaker_endpoint.ipynb aby wywołać i przetestować punkt końcowy wnioskowania o modelu SageMaker utworzony w poprzednim notatniku.

W kolejnych sekcjach szczegółowo omawiamy każdy z tych kroków.

Uruchom skrypt szkoleniowy PyTorch DDP

W ramach szkolenia rozproszonego trenujemy model klasyfikacji stworzony przez prostą splotową sieć neuronową działającą na zbiorze danych CIFAR10. Skrypt szkoleniowy cifar10-distributed-gpu-final.py zawiera tylko biblioteki open-source i jest kompatybilny do uruchamiania zarówno w klastrach szkoleniowych Kubernetes, jak i SageMaker na urządzeniach GPU lub instancjach CPU. Przyjrzyjmy się kilku ważnym aspektom skryptu szkoleniowego, zanim uruchomimy nasze przykłady zeszytów.

Używamy torch.distributed moduł, który zawiera obsługę PyTorch i prymitywy komunikacji dla wieloprocesowej równoległości między węzłami w klastrze:

...
import torch
import torch.distributed as dist
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import torch.utils.data
import torch.utils.data.distributed
import torchvision
from torchvision import datasets, transforms
...

Tworzymy prosty model klasyfikacji obrazów przy użyciu kombinacji warstw konwolucyjnych, maksymalnych pul i liniowych, do których a relu funkcja aktywacji jest stosowana w podaniu do przodu treningu modelu:

# Define models
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)

def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
x = x.view(-1, 16 * 5 * 5)
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x

Jeśli klaster szkoleniowy ma procesory GPU, skrypt uruchamia szkolenie na urządzeniach CUDA, a zmienna device przechowuje domyślne urządzenie CUDA:

device = "cuda" if torch.cuda.is_available() else "cpu"
...

Zanim uruchomisz rozproszone szkolenie przy użyciu PyTorch DistributedDataParallel aby uruchomić przetwarzanie rozproszone na wielu węzłach, musisz zainicjować środowisko rozproszone, wywołując init_process_group. Jest to inicjowane na każdym komputerze klastra szkoleniowego.

dist.init_process_group(backend=args.backend, rank=host_rank, world_size=world_size)
...

Tworzymy wystąpienie modelu klasyfikatora i kopiujemy go na urządzenie docelowe. Jeśli szkolenie rozproszone jest włączone w wielu węzłach, DistributedDataParallel class jest używany jako obiekt opakowujący wokół obiektu modelu, co umożliwia synchroniczne szkolenie rozproszone na wielu komputerach. Dane wejściowe są dzielone na wymiar partii, a replika modelu jest umieszczana na każdej maszynie i każdym urządzeniu. Zobacz następujący kod:

model = Net().to(device)

if is_distributed:
model = torch.nn.parallel.DistributedDataParallel(model)

...

Utwórz potok Kubeflow

Notebook wykorzystuje tzw Pakiet SDK potoków Kubeflow oraz dostarczony zestaw pakietów języka Python do określania i uruchamiania potoków przepływu pracy ML. W ramach tego zestawu SDK używamy dekoratora pakietów języka specyficznego dla domeny (DSL). dsl.pipeline, który ozdabia funkcje Pythona w celu zwrócenia potoku.

Potok Kubeflow wykorzystuje komponent SageMaker V2 do przesyłania szkoleń do SageMaker przy użyciu SageMaker ACK Operators. Tworzenie i wdrażanie modeli SageMaker wykorzystuje komponent SageMaker V1, który jest komponentem SageMaker opartym na Boto3. W tym przykładzie używamy kombinacji obu komponentów, aby zademonstrować elastyczność wyboru.

1. Załaduj komponenty SageMaker, używając następującego kodu:

   # Loads SageMaker training components v2 for Kubeflow pipeline from the URL
   sagemaker_train_ack_op = components.load_component_from_url('https://raw.githubusercontent.com/kubeflow/pipelines/d4aaa03035f221351ebe72fbd74fcfccaf25bb66/components/aws/sagemaker/TrainingJob/component.yaml')
   
   # Loads SageMaker components v1 for Kubeflow pipeline from the URL
   sagemaker_model_op = components.load_component_from_url('https://raw.githubusercontent.com/kubeflow/pipelines/cb36f87b727df0578f4c1e3fe9c24a30bb59e5a2/components/aws/sagemaker/model/component.yaml')
   sagemaker_deploy_op = components.load_component_from_url('https://raw.githubusercontent.com/kubeflow/pipelines/cb36f87b727df0578f4c1e3fe9c24a30bb59e5a2/components/aws/sagemaker/deploy/component.yaml')

   W poniższym kodzie tworzymy potok Kubeflow, w którym przeprowadzamy rozproszone szkolenie SageMaker przy użyciu dwóch ml.p3.2xlarge instancje:

   # Create Kubeflow Pipeline using Amazon SageMaker Service
   @dsl.pipeline(name="PyTorch Training pipeline", description="Sample training job test")
   def pytorch_cnn_pipeline(region=target_region,
   train_image=aws_dlc_sagemaker_train_image,
   serving_image=aws_dlc_sagemaker_serving_image,
   learning_rate='0.01',
   pytorch_backend='gloo',
   training_job_name=pytorch_distributed_jobname,
   instance_type='ml.p3.2xlarge',
   instance_count='2',
   network_isolation='False',
   traffic_encryption='False',
   ):
   
   # Step to run training on SageMaker using SageMaker Components V2 for Pipeline.
   training = sagemaker_train_ack_op(
   region=region,
   algorithm_specification=(f'{{ '
   f'"trainingImage": "{train_image}",'
   '"trainingInputMode": "File"'
   f'}}'),
   training_job_name=training_job_name,
   hyper_parameters=(f'{{ '
   f'"backend": "{pytorch_backend}",'
   '"batch-size": "64",'
   '"epochs": "10",'
   f'"lr": "{learning_rate}",'
   '"model-type": "custom",'
   '"sagemaker_container_log_level": "20",'
   '"sagemaker_program": "cifar10-distributed-gpu-final.py",'
   f'"sagemaker_region": "{region}",'
   f'"sagemaker_submit_directory": "{source_s3}"'
   f'}}'),
   resource_config=(f'{{ '
   f'"instanceType": "{instance_type}",'
   f'"instanceCount": {instance_count},'
   '"volumeSizeInGB": 50'
   f'}}'),
   input_data_config=training_input(datasets),
   output_data_config=training_output(bucket_name),
   enable_network_isolation=network_isolation,
   enable_inter_container_traffic_encryption=traffic_encryption,
   role_arn=role,
   stopping_condition={"maxRuntimeInSeconds": 3600}
   )
   
   model_artifact_url = get_s3_model_artifact_op(
   training.outputs["model_artifacts"]
   ).output
   
   # This step creates SageMaker Model which refers to model artifacts and inference script to deserialize the input image
   create_model = sagemaker_model_op(
   region=region,
   model_name=training_job_name,
   image=serving_image,
   model_artifact_url=model_artifact_url,
   network_isolation=network_isolation,
   environment=(f'{{ '
   '"SAGEMAKER_CONTAINER_LOG_LEVEL": "20",'
   '"SAGEMAKER_PROGRAM": "inference.py",'
   f'"SAGEMAKER_REGION": "{region}",'
   f'"SAGEMAKER_SUBMIT_DIRECTORY": "{model_artifact_url}"'
   f'}}'),
   role=role
   )
   
   # This step creates SageMaker Endpoint which will be called to run inference
   prediction = sagemaker_deploy_op(
   region=region,
   model_name_1=create_model.output,
   instance_type_1='ml.c5.xlarge'
   )
   
   #Disable pipeline cache
   training.execution_options.caching_strategy.max_cache_staleness = "P0D"

   Po zdefiniowaniu potoku możesz skompilować potok do specyfikacji Argo YAML za pomocą pakietu Kubeflow Pipelines SDK kfp.compiler pakiet. Ten potok można uruchomić przy użyciu klienta Kubeflow Pipelines SDK, który wywołuje punkt końcowy usługi Pipelines i przekazuje odpowiednie nagłówki uwierzytelniania bezpośrednio z notesu. Zobacz następujący kod:

   # DSL Compiler that compiles pipeline functions into workflow yaml.
   kfp.compiler.Compiler().compile(pytorch_cnn_pipeline, "pytorch_cnn_pipeline.yaml")
   
   # Connect to Kubeflow Pipelines using the Kubeflow Pipelines SDK client
   client = kfp.Client()
   
   experiment = client.create_experiment(name="ml_workflow")
   
   # Run a specified pipeline
   my_run = client.run_pipeline(experiment.id, "pytorch_cnn_pipeline", "pytorch_cnn_pipeline.yaml")
   
   # Please click “Run details” link generated below this cell to view your pipeline. You can click every pipeline step to see logs.

2. Wybierz Uruchom szczegóły link pod ostatnią komórką, aby wyświetlić potok Kubeflow. Poniższy zrzut ekranu pokazuje szczegóły naszego potoku dla komponentu szkolenia i wdrażania SageMaker.
3. Wybierz etap szkolenia i na Dzienniki wybierz link Logi CloudWatch, aby uzyskać dostęp do logów SageMaker.
   Poniższy zrzut ekranu przedstawia logi CloudWatch dla każdej z dwóch instancji ml.p3.2xlarge.
4. Wybierz dowolną grupę, aby zobaczyć dzienniki.
5. Przechwyć punkt końcowy SageMaker, wybierając Sagemaker – wdrożenie modelu krok i kopiowanie endpoint_name wyjściowa wartość artefaktu.

Wywołaj punkt końcowy SageMaker

Notatnik STEP1.1_invoke_sagemaker_endpoint.ipynb wywołuje punkt końcowy wnioskowania SageMaker utworzony w poprzednim kroku. Upewnij się, że zaktualizowałeś nazwę punktu końcowego:

# Invoke SageMaker Endpoint. * Ensure you update the endpoint
# You can grab the SageMaker Endpoint name by either 1) going to the pipeline visualization of Kubeflow console and click the component for deployment, or 2) Go to SageMaker console and go to the list of endpoints, and then substitute the name to the EndpointName='...' in this cell.

endpointName=''

response = client.invoke_endpoint(EndpointName=endpointName,
ContentType='application/x-image',
Body=payload)

pred = json.loads(response['Body'].read().decode())

output_vector_list=pred['score']

# Get outout vector of 10 classes
output_vector = output_vector_list[0]

# Find the class with highest probability
max=output_vector[0]
index = 0
for i in range(1,len(output_vector)):
if output_vector[i] > max:
max = output_vector[i]
index = i

print(f'Index of the maximum value is : {index}')

labels = ['airplane','automobile','bird','cat','deer','dog','frog','horse','ship','truck']

print(labels[index])

Sprzątać

Aby wyczyścić zasoby, wykonaj następujące kroki:

1. Uruchom następujące polecenia w AWS Cloud9, aby usunąć zasoby AWS:

   cd ${MANIFEST_DIR}/deployments/vanilla/terraform
   make delete

2. Usuń rolę IAM „sagemakerrole” używając następującego polecenia AWS CLI:

   aws iam detach-role-policy --role-name sagemakerrole --policy-arn arn:aws:iam::aws:policy/AmazonSageMakerFullAccess
   aws iam detach-role-policy --role-name sagemakerrole --policy-arn arn:aws:iam::aws:policy/AmazonS3FullAccess
   aws iam delete-role --role-name sagemakerrole

3. Usuń punkt końcowy SageMaker za pomocą następującego polecenia AWS CLI:

   aws sagemaker delete-endpoint --endpoint-name  --region us-west-2

Podsumowanie

W tym poście podkreśliliśmy wartość, jaką Kubeflow w AWS 1.6.1 zapewnia dzięki natywnym integracjom usług zarządzanych przez AWS w celu zaspokojenia potrzeb przypadków użycia sztucznej inteligencji i uczenia maszynowego na poziomie przedsiębiorstwa. Możesz wybrać spośród kilku opcji wdrażania, aby zainstalować Kubeflow na AWS z różnymi integracjami usług przy użyciu Terraform, Kustomize lub Helm. Przypadek użycia w tym poście zademonstrował integrację Kubeflow z SageMaker, która używa zarządzanego klastra szkoleniowego SageMaker do uruchamiania rozproszonego szkolenia dla modelu klasyfikacji obrazu i punktu końcowego SageMaker do wdrażania modelu.

Udostępniliśmy również a przykładowy przykład potoku który wykorzystuje najnowsze komponenty SageMaker; możesz uruchomić to bezpośrednio z pulpitu nawigacyjnego Kubeflow. Ten potok wymaga Dane Amazona S3 i SageMaker wykonanie roli IAM jako wymagane dane wejściowe.

Aby rozpocząć korzystanie z Kubeflow w AWS, zapoznaj się z dostępnymi opcjami wdrażania zintegrowanego z AWS w Kubeflow w AWS. Możesz śledzić Repozytorium AWS Labs do śledzenia wszystkich wkładów AWS do Kubeflow. Możesz nas również znaleźć na Kanał Kubeflow #AWS Slack; Twoja opinia pomoże nam ustalić priorytety dla kolejnych funkcji, które wniosą wkład do projektu Kubeflow.

O autorach

Kanwaljit Khurmi jest starszym architektem rozwiązań w Amazon Web Services. Współpracuje z klientami AWS, zapewniając wskazówki i pomoc techniczną, pomagając im podnieść wartość ich rozwiązań podczas korzystania z AWS. Kanwaljit specjalizuje się w pomaganiu klientom w aplikacjach konteneryzowanych i uczących się maszynowo.

Kartika Kalamadiego jest inżynierem rozwoju oprogramowania w Amazon AI. Obecnie koncentruje się na projektach open source Kubernetes Machine Learning, takich jak Kubeflow i AWS SageMaker Controller dla k8s. W wolnym czasie lubię grać w gry komputerowe i bawić się VR na silniku Unity.

Rahula Kharse’a jest inżynierem rozwoju oprogramowania w Amazon Web Services. Jego praca koncentruje się na integracji usług AWS z kontenerowymi platformami ML Ops open source w celu poprawy ich skalowalności, niezawodności i bezpieczeństwa. Oprócz skupiania się na żądaniach klientów dotyczących funkcji, Rahul lubi także eksperymentować z najnowszymi osiągnięciami technologicznymi w tej dziedzinie.