Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # Verwenden Sie KI-Komponenten SageMaker In diesem Tutorial führen Sie eine Pipeline mit SageMaker KI-Komponenten für Kubeflow-Pipelines aus, um ein Klassifikationsmodell mithilfe von Kmeans mit dem MNIST-Datensatz auf KI zu trainieren. SageMaker Der Workflow verwendet Kubeflow Pipelines als Orchestrator und SageMaker KI, um jeden Schritt des Workflows auszuführen. Das Beispiel wurde einem vorhandenen [ SageMaker KI-Beispiel entnommen und so geändert, dass es mit SageMaker KI-Komponenten](https://github.com/aws/amazon-sagemaker-examples/blob/8279abfcc78bad091608a4a7135e50a0bd0ec8bb/sagemaker-python-sdk/1P_kmeans_highlevel/kmeans_mnist.ipynb) für Kubeflow-Pipelines funktioniert. Sie können Ihre Pipeline in Python definieren, indem Sie AWS SDK für Python (Boto3) dann das KFP-Dashboard, die KFP-CLI oder Boto3 verwenden, um Ihre Workflows zu kompilieren, bereitzustellen und auszuführen. Der vollständige Code für das Beispiel für die MNIST-Klassifizierungspipeline ist im [Kubeflow Github-Repository](https://github.com/kubeflow/pipelines/tree/master/samples/contrib/aws-samples/mnist-kmeans-sagemaker#mnist-classification-with-kmeans) verfügbar. Um es zu verwenden, klonen Sie die Python-Dateien auf Ihren Gateway-Knoten. Weitere Beispiele für [ SageMaker KI Kubeflow](https://github.com/kubeflow/pipelines/tree/master/samples/contrib/aws-samples) Pipelines finden Sie unter. GitHub [Informationen zu den verwendeten Komponenten finden Sie im Pipelines-Repository. KubeFlow GitHub ](https://github.com/kubeflow/pipelines/tree/master/components/aws/sagemaker) Um das Beispiel für eine Klassifizierungspipeline auszuführen, erstellen Sie eine SageMaker AI IAM-Ausführungsrolle, die Ihrem Trainingsjob die Berechtigung zum Zugriff auf AWS Ressourcen gewährt, und fahren Sie dann mit den Schritten fort, die Ihrer Bereitstellungsoption entsprechen. ## Erstellen Sie eine SageMaker AI-Ausführungsrolle Die `kfp-example-sagemaker-execution-role` IAM-Rolle ist eine Runtime-Rolle, die SageMaker KI-Jobs für den Zugriff auf AWS Ressourcen übernehmen. Im folgenden Befehl erstellen Sie eine IAM-Ausführungsrolle mit dem Namen`kfp-example-sagemaker-execution-role`, fügen zwei verwaltete Richtlinien (AmazonSageMakerFullAccess, AmazonS3FullAccess) hinzu und richten eine Vertrauensbeziehung mit SageMaker KI ein, um SageMaker KI-Jobs Zugriff auf diese Ressourcen zu gewähren. AWS Sie geben diese Rolle als Eingabeparameter an, wenn Sie die Pipeline ausführen. Führen Sie den folgenden -Befehl aus, um die Rolle zu erstellen. Beachten Sie den ARN, der in Ihrer Ausgabe zurückgegeben wird. ``` SAGEMAKER_EXECUTION_ROLE_NAME=kfp-example-sagemaker-execution-role TRUST="{ \"Version\": \"2012-10-17 \", \"Statement\": [ { \"Effect\": \"Allow\", \"Principal\": { \"Service\": \"sagemaker.amazonaws.com\" }, \"Action\": \"sts:AssumeRole\" } ] }" aws iam create-role --role-name ${SAGEMAKER_EXECUTION_ROLE_NAME} --assume-role-policy-document "$TRUST" aws iam attach-role-policy --role-name ${SAGEMAKER_EXECUTION_ROLE_NAME} --policy-arn arn:aws:iam::aws:policy/AmazonSageMakerFullAccess aws iam attach-role-policy --role-name ${SAGEMAKER_EXECUTION_ROLE_NAME} --policy-arn arn:aws:iam::aws:policy/AmazonS3FullAccess aws iam get-role --role-name ${SAGEMAKER_EXECUTION_ROLE_NAME} --output text --query 'Role.Arn' ``` ## Vollständiger Kubeflow bei der Bereitstellung AWS Folgen Sie den Anweisungen im [SageMaker Training Pipeline-Tutorial zur MNIST-Klassifizierung](https://awslabs.github.io/kubeflow-manifests/docs/amazon-sagemaker-integration/sagemaker-components-for-kubeflow-pipelines/) mit K-Means. ## Bereitstellung eigenständiger Kubeflow-Pipelines ### Datensätze vorbereiten Um die Pipelines auszuführen, müssen Sie das Vorverarbeitungsskript für die Datenextraktion in einen Amazon-S3-Bucket hochladen. Dieser Bucket und alle Ressourcen für dieses Beispiel müssen sich in der Region `us-east-1` befinden. Informationen zum Erstellen eines Buckets finden Sie unter [Erstellen eines Buckets](https://docs.aws.amazon.com/AmazonS3/latest/gsg/CreatingABucket.html). Führen Sie aus dem `mnist-kmeans-sagemaker` Ordner des Kubeflow-Repositorys, das Sie auf Ihrem Gateway-Knoten geklont haben, den folgenden Befehl aus, um die `kmeans_preprocessing.py` Datei in Ihren Amazon-S3-Bucket hochzuladen. Ändern Sie `` in den Namen Ihres Amazon-S3-Buckets. ``` aws s3 cp mnist-kmeans-sagemaker/kmeans_preprocessing.py s3://{{}}/mnist_kmeans_example/processing_code/kmeans_preprocessing.py ``` ### Kompilieren und implementieren Sie Ihre Pipeline Nachdem Sie die Pipeline definiert haben, müssen Sie sie in eine Zwischendarstellung kompilieren, bevor Sie sie an den Kubeflow Pipelines Service auf Ihrem Cluster senden. Die Zwischendarstellung ist eine Workflow-Spezifikation in Form einer YAML-Datei, die in eine Datei tar.gz komprimiert ist. Sie benötigen das KFP SDK, um Ihre Pipeline zu kompilieren. #### Installieren des KFP SDK Führen Sie in der Befehlszeile Ihres Gateway-Knotens Folgendes aus: 1. Installieren Sie das KFP SDK gemäß den Anweisungen in der [Kubeflow-Pipelines Dokumentation](https://www.kubeflow.org/docs/pipelines/sdk/install-sdk/). 1. Stellen Sie sicher, dass das KFP SDK installiert ist, indem Sie mit dem folgenden Befehl überprüfen: ``` pip show kfp ``` 1. Stellen Sie wie folgt sicher, dass `dsl-compile` korrekt installiert wurde: ``` which dsl-compile ``` #### Kompilieren Ihrer Pipeline Sie haben drei Möglichkeiten, mit Kubeflow Pipelines zu interagieren: KFP UI, KFP CLI oder das KFP SDK. In den folgenden Abschnitten wird der Arbeitsablauf mit der KFP-Benutzeroberfläche und CLI veranschaulicht. Führen Sie die folgenden Schritte von Ihrem Gateway-Knoten aus. 1. Ändern Sie Ihre Python-Datei mit Ihrem Amazon-S3-Bucket-Namen und Ihrem IAM-Rollen-ARN. 1. Verwenden Sie den `dsl-compile` Befehl von der Befehlszeile aus, um Ihre Pipeline wie folgt zu kompilieren. Ersetzen Sie `` durch den Pfad zu Ihrer Pipeline und `` durch den Speicherort, an dem sich Ihre Datei tar.gz befinden soll. ``` dsl-compile --py {{}} --output {{}} ``` #### Laden Sie die Pipeline mit der KFP-CLI hoch und führen Sie sie aus Führen Sie die folgenden Schritte von der Befehlszeile Ihres Gateway-Nodes aus. KFP organisiert die Durchläufe Ihrer Pipeline in Form von Experimenten. Sie haben die Möglichkeit, einen Namen für das Experiment anzugeben. Wenn Sie keinen angeben, wird der Durchlauf unter **Standardexperiment** aufgeführt. 1. Laden Sie Ihre Pipeline wie folgt hoch: ``` kfp pipeline upload --pipeline-name {{}} {{}} ``` Die Ausgabe sollte wie folgt aussehen. Beachten Sie die Pipeline `ID`. ``` Pipeline 29c3ff21-49f5-4dfe-94f6-618c0e2420fe has been submitted Pipeline Details ------------------ ID           29c3ff21-49f5-4dfe-94f6-618c0e2420fe Name         sm-pipeline Description Uploaded at  2020-04-30T20:22:39+00:00 ... ... ``` 1. Erstellen Sie einen Lauf mit dem folgenden Befehl. Der KFP-CLI-Run-Befehl unterstützt derzeit nicht die Angabe von Eingabeparametern bei der Erstellung des Laufs. Sie müssen Ihre Parameter in der AWS SDK für Python (Boto3) Pipeline-Datei vor dem Kompilieren aktualisieren. Ersetzen Sie `` und `` durch beliebige Namen. Ersetzen Sie `` durch die ID Ihrer eingereichten Pipeline. Ersetzen Sie `` durch den ARN von `kfp-example-pod-role`. Ersetzen Sie `` durch den Namen des von Ihnen erstellten Amazon-S3-Buckets. ``` kfp run submit --experiment-name {{}} --run-name {{}} --pipeline-id {{}} role_arn="{{}}" bucket_name="{{}}" ``` Sie können einen Lauf auch direkt einreichen, indem Sie das kompilierte Pipeline-Paket verwenden, das als Ausgabe des `dsl-compile` Befehls erstellt wurde. ``` kfp run submit --experiment-name {{}} --run-name {{}} --package-file {{}} role_arn="{{}}" bucket_name="{{}}" ``` Die Ausgabe sollte folgendermaßen aussehen: ``` Creating experiment aws. Run 95084a2c-f18d-4b77-a9da-eba00bf01e63 is submitted +--------------------------------------+--------+----------+---------------------------+ | run id                               | name   | status   | created at                | +======================================+========+==========+===========================+ | 95084a2c-f18d-4b77-a9da-eba00bf01e63 | sm-job |          | 2020-04-30T20:36:41+00:00 | +--------------------------------------+--------+----------+---------------------------+ ``` 1. Navigieren Sie zur Benutzeroberfläche, um den Fortschritt des Auftrags zu überprüfen. #### Laden Sie die Pipeline mit der KFP-Benutzeroberfläche hoch und führen Sie sie aus 1. Wählen Sie im linken Bereich die Registerkarte **Pipelines** aus. 1. **Wählen Sie in der oberen rechten Ecke \+. UploadPipeline** 1. Geben Sie den Namen und die Beschreibung der Pipeline ein. 1. Wählen Sie **Datei hochladen** und geben Sie den Pfad zu der Datei tar.gz ein, die Sie mit der CLI oder mit AWS SDK für Python (Boto3) erstellt haben. 1. Wählen Sie im linken Bereich die Registerkarte **Pipelines** aus. 1. Suchen Sie die Pipeline, die Sie erstellt haben. 1. **Wählen Sie \+. CreateRun** 1. Geben Sie Ihre Eingabeparameter ein. 1. Klicken Sie auf **Ausführen**. ### Vorhersagen ausführen Sobald Ihre Klassifizierungspipeline bereitgestellt ist, können Sie Klassifizierungsvorhersagen für den Endpunkt ausführen, der von der Deploy-Komponente erstellt wurde. Verwenden Sie die KFP-Benutzeroberfläche, um nach den Ausgabeartefakten zu suchen. `sagemaker-deploy-model-endpoint_name` Laden Sie die .tgz-Datei herunter, um den Endpunktnamen zu extrahieren, oder überprüfen Sie die SageMaker AI-Konsole in der Region, die Sie verwendet haben. #### Konfigurieren Sie die Berechtigungen für die Ausführung von Vorhersagen Wenn Sie Vorhersagen von Ihrem Gateway-Knoten aus ausführen möchten, überspringen Sie diesen Abschnitt. **Um Vorhersagen auf einem anderen Computer auszuführen, weisen Sie die `sagemaker:InvokeEndpoint` entsprechende Berechtigung der IAM-Rolle zu, die vom Client-Computer verwendet wird.** 1. Führen Sie auf Ihrem Gateway-Knoten den folgenden Befehl aus, um eine IAM-Richtliniendatei zu erstellen: ``` cat < ./sagemaker-invoke.json {     "Version": "2012-10-17",     "Statement": [         {             "Effect": "Allow",             "Action": [                 "sagemaker:InvokeEndpoint"             ],             "Resource": "*"         }     ] } EoF ``` 1. Fügen Sie die Richtlinie der IAM-Rolle des Client-Knotens an. Führen Sie den folgenden Befehl aus. Ersetzen Sie `` durch den Namen der IAM-Rolle. Ersetzen Sie `` durch den Pfad zu der von Ihnen erstellten Richtliniendatei. ``` aws iam put-role-policy --role-name {{}} --policy-name sagemaker-invoke-for-worker --policy-document file://{{}} ``` #### Vorhersagen ausführen 1. Erstellen Sie auf Ihrem Client-Computer eine AWS SDK für Python (Boto3) Datei `mnist-predictions.py` mit dem folgenden Inhalt. Ersetzen Sie die `ENDPOINT_NAME` Variable. Das Skript lädt den MNIST-Datensatz, erstellt aus diesen Ziffern eine CSV-Datei, sendet die CSV-Datei dann zur Vorhersage an den Endpunkt und druckt die Ergebnisse aus. ``` import boto3 import gzip import io import json import numpy import pickle ENDPOINT_NAME='{{}}' region = boto3.Session().region_name # S3 bucket where the original mnist data is downloaded and stored downloaded_data_bucket = f"jumpstart-cache-prod-{region}" downloaded_data_prefix = "1p-notebooks-datasets/mnist" # Download the dataset s3 = boto3.client("s3") s3.download_file(downloaded_data_bucket, f"{downloaded_data_prefix}/mnist.pkl.gz", "mnist.pkl.gz") # Load the dataset with gzip.open('mnist.pkl.gz', 'rb') as f:     train_set, valid_set, test_set = pickle.load(f, encoding='latin1') # Simple function to create a csv from our numpy array def np2csv(arr):     csv = io.BytesIO()     numpy.savetxt(csv, arr, delimiter=',', fmt='%g')     return csv.getvalue().decode().rstrip() runtime = boto3.Session(region).client('sagemaker-runtime') payload = np2csv(train_set[0][30:31]) response = runtime.invoke_endpoint(EndpointName=ENDPOINT_NAME,                                    ContentType='text/csv',                                    Body=payload) result = json.loads(response['Body'].read().decode()) print(result) ``` 1. Führen Sie die AWS SDK für Python (Boto3) Datei wie folgt aus: ``` python mnist-predictions.py ``` ### Ergebnisse und Protokolle anzeigen Wenn die Pipeline läuft, können Sie eine beliebige Komponente auswählen, um Ausführungsdetails wie Eingaben und Ausgaben zu überprüfen. Dies listet die Namen der erstellten Ressourcen auf. Wenn die KFP-Anfrage erfolgreich verarbeitet und ein SageMaker AI-Job erstellt wurde, enthalten die Komponentenprotokolle in der KFP-Benutzeroberfläche einen Link zu dem in SageMaker AI erstellten Job. Die CloudWatch Protokolle werden auch bereitgestellt, wenn der Job erfolgreich erstellt wurde. Wenn Sie zu viele Pipeline-Aufträge auf demselben Cluster ausführen, wird möglicherweise eine Fehlermeldung angezeigt, die darauf hinweist, dass nicht genügend Pods verfügbar sind. Um dieses Problem zu beheben, melden Sie sich bei Ihrem Gateway-Knoten an und löschen Sie die Pods, die von den Pipelines erstellt wurden, die Sie nicht verwenden: ``` kubectl get pods -n kubeflow kubectl delete pods -n kubeflow {{}} ``` ### Bereinigen Wenn Sie mit Ihrer Pipeline fertig sind, müssen Sie Ihre Ressourcen bereinigen. 1. Beenden Sie im KFP-Dashboard Ihre Pipeline-Läufe, falls sie nicht ordnungsgemäß beendet werden, indem Sie **Terminieren** wählen. 1. Wenn die Option **Terminieren** nicht funktioniert, melden Sie sich bei Ihrem Gateway-Knoten an und beenden Sie manuell alle Pods, die durch Ihre Pipeline-Ausführung erstellt wurden, wie folgt: ``` kubectl get pods -n kubeflow kubectl delete pods -n kubeflow {{}} ``` 1. Melden Sie sich mit Ihrem AWS Konto beim SageMaker AI-Service an. Beenden Sie manuell alle Trainings-, Batch-Transform- und HPO-Aufträge. Löschen Sie Modelle, Daten-Buckets und Endpunkte, um zusätzliche Kosten zu vermeiden. Durch das Beenden der Pipeline-Läufe werden die Jobs in SageMaker AI nicht gestoppt.