Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Usa i componenti AI SageMaker In questo tutorial, esegui una pipeline utilizzando SageMaker AI Components for Kubeflow Pipelines per addestrare un modello di classificazione utilizzando Kmeans con il set di dati MNIST su AI. SageMaker Il flusso di lavoro utilizza Kubeflow Pipelines come orchestratore e l'intelligenza artificiale per eseguire ogni fase del flusso di lavoro. SageMaker L'esempio è stato tratto da un esempio di [ SageMaker intelligenza artificiale esistente e modificato per funzionare con SageMaker AI Components](https://github.com/aws/amazon-sagemaker-examples/blob/8279abfcc78bad091608a4a7135e50a0bd0ec8bb/sagemaker-python-sdk/1P_kmeans_highlevel/kmeans_mnist.ipynb) for Kubeflow Pipelines. Puoi definire la tua pipeline in Python AWS SDK per Python (Boto3) utilizzando quindi la dashboard KFP, la CLI KFP o Boto3 per compilare, distribuire ed eseguire i flussi di lavoro. Il codice completo per l'esempio della pipeline di classificazione MNIST è disponibile nel [Repository Github di Kubeflo.](https://github.com/kubeflow/pipelines/tree/master/samples/contrib/aws-samples/mnist-kmeans-sagemaker#mnist-classification-with-kmeans). Per usarlo, clona i file Python sul tuo nodo gateway. Puoi trovare altri esempi GitHub di AI Kubeflow [ SageMaker Pipelines](https://github.com/kubeflow/pipelines/tree/master/samples/contrib/aws-samples) su. [Per informazioni sui componenti utilizzati, consulta il repository Pipelines. KubeFlow GitHub ](https://github.com/kubeflow/pipelines/tree/master/components/aws/sagemaker) Per eseguire l'esempio della pipeline di classificazione, crea un ruolo di esecuzione IAM SageMaker AI che conceda al tuo processo di formazione l'autorizzazione ad accedere alle AWS risorse, quindi continua con i passaggi corrispondenti all'opzione di implementazione che hai scelto. ## Crea un ruolo di SageMaker esecuzione AI Il ruolo `kfp-example-sagemaker-execution-role` IAM è un ruolo di runtime assunto dai lavori di SageMaker intelligenza artificiale per accedere alle AWS risorse. Nel comando seguente, crei un ruolo di esecuzione IAM denominato`kfp-example-sagemaker-execution-role`, alleghi due policy gestite (AmazonSageMakerFullAccessAmazonS3FullAccess) e crei una relazione di fiducia con l' SageMaker IA per concedere SageMaker ai lavori di IA l'accesso a tali risorse. AWS Fornisci questo ruolo come parametro di input durante l'esecuzione della pipeline. Per creare un ruolo, esegui il comando seguente. Tieni presente che l'ARN viene restituito nell'output. ``` 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' ``` ## Kubeflow completo su Deployment AWS Segui le istruzioni del [tutorial SageMaker Training Pipeline per la classificazione MNIST](https://awslabs.github.io/kubeflow-manifests/docs/amazon-sagemaker-integration/sagemaker-components-for-kubeflow-pipelines/) con K-Means. ## Implementazione standalone di Kubeflow Pipelines ### Preparazione di set di dati Per eseguire le pipeline, è necessario caricare lo script di pre-elaborazione dell'estrazione dei dati in un bucket Amazon S3. Questo bucket e tutte le risorse esemplificative devono trovarsi nella Regione `us-east-1`. Per informazioni sulla creazione di un bucket, consulta [Creazione di un bucket](https://docs.aws.amazon.com/AmazonS3/latest/gsg/CreatingABucket.html). Dalla cartella `mnist-kmeans-sagemaker` del repository Kubeflow che hai clonato sul nodo gateway, esegui il comando seguente per caricare il file `kmeans_preprocessing.py` nel tuo bucket Amazon S3. Cambia con `` il nome del bucket Amazon S3. ``` aws s3 cp mnist-kmeans-sagemaker/kmeans_preprocessing.py s3://{{}}/mnist_kmeans_example/processing_code/kmeans_preprocessing.py ``` ### Compilazione e implementazione della pipeline Dopo aver definito la pipeline, è necessario compilarla in una rappresentazione intermedia prima di sottoporla al servizio Kubeflow Pipelines sul cluster. La rappresentazione intermedia è una specifica del flusso di lavoro sotto forma di file YAML compresso in un file tar.gz. È necessario l'SDK KFP per compilare la pipeline. #### Installazione dell'SDK KFP Svolgi le seguenti operazioni dalla riga di comando del nodo gateway: 1. Installa l'SDK KFP seguendo le istruzioni contenute nella [Documentazione di Kubeflow Pipelines](https://www.kubeflow.org/docs/pipelines/sdk/install-sdk/). 1. Verificare che l'SDK KFP sia installato con il seguente comando: ``` pip show kfp ``` 1. Verifica che `dsl-compile` sia stato installato correttamente, secondo quanto segue: ``` which dsl-compile ``` #### Compilazione della pipeline Sono disponibili tre opzioni per interagire con Kubeflow Pipelines: UI, CLI o SDK di KFP. Le seguenti sezioni illustrano il flusso di lavoro utilizzando l'interfaccia utente e la CLI di KFP. Completa la seguente procedura dal nodo gateway. 1. Modifica il tuo file Python con il nome del bucket Amazon S3 e l'ARN del ruolo IAM. 1. Usa il comando `dsl-compile` dalla riga di comando per compilare la pipeline come segue. Sostituisci `` con il percorso della pipeline e `` con la posizione in cui desideri che si trovi il file tar.gz. ``` dsl-compile --py {{}} --output {{}} ``` #### Caricamento ed esecuzione della pipeline utilizzando la CLI KFP Completa la seguente procedura dalla riga di comando del nodo gateway. KFP organizza le esecuzioni della pipeline sotto forma di esperimenti. Hai la possibilità di specificare il nome di un esperimento. Se non ne specifichi uno, l'esecuzione verrà elencata nell’esperimento **Predefinito**. 1. Carica la tua pipeline come segue: ``` kfp pipeline upload --pipeline-name {{}} {{}} ``` L'aspetto dell'output sarà simile al seguente. Prendi nota della 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. Crea un’esecuzione utilizzando il comando seguente. Il comando di esecuzione della CLI di KFP attualmente non supporta la specifica dei parametri di input durante la creazione dell'esecuzione. È necessario aggiornare i parametri nel file della AWS SDK per Python (Boto3) pipeline prima della compilazione. Sostituisci `` e `` con qualsiasi nome. Sostituisci `` con l'ID della pipeline inviata. Sostituisci `` con l'ARN di `kfp-example-pod-role`. Sostituisci `` con il nome del bucket Amazon S3 creato. ``` kfp run submit --experiment-name {{}} --run-name {{}} --pipeline-id {{}} role_arn="{{}}" bucket_name="{{}}" ``` È inoltre possibile inviare direttamente un'esecuzione utilizzando il pacchetto di pipeline compilato creato come output del comando `dsl-compile`. ``` kfp run submit --experiment-name {{}} --run-name {{}} --package-file {{}} role_arn="{{}}" bucket_name="{{}}" ``` L'aspetto dell'output deve essere simile al seguente: ``` 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. Accedi all'interfaccia utente per verificare lo stato di avanzamento del processo. #### Caricamento ed esecuzione della pipeline utilizzando l’UI di KFP 1. Nel pannello a sinistra, scegli la scheda **Pipelines**. 1. **Nell'angolo in alto a destra, scegli \+. UploadPipeline** 1. Inserisci il nome e la descrizione della pipeline. 1. Scegli **Carica file** e inserisci il percorso del file tar.gz creato utilizzando la CLI o AWS SDK per Python (Boto3). 1. Nel pannello a sinistra, scegli la scheda **Pipelines**. 1. Trova la pipeline creata. 1. **Scegli \+. CreateRun** 1. Inserisci i parametri di input. 1. Scegli **Esegui**. ### Esecuzione di previsioni Una volta implementata la pipeline di classificazione, puoi eseguire previsioni di classificazione sull'endpoint creato dal componente Deploy. Usa l'interfaccia utente KFP per controllare gli artefatti di output per `sagemaker-deploy-model-endpoint_name`. Scarica il file.tgz per estrarre il nome dell'endpoint o controlla la console SageMaker AI nella regione che hai utilizzato. #### Configurazione delle autorizzazioni per l’esecuzione di previsioni Se desideri eseguire previsioni dal tuo nodo gateway, ignora questa sezione. **Per utilizzare qualsiasi altro computer per eseguire previsioni, assegna l'autorizzazione `sagemaker:InvokeEndpoint` al ruolo IAM usato dal computer client.** 1. Sul nodo gateway, svolgi le seguenti operazioni per creare un file di policy IAM: ``` cat < ./sagemaker-invoke.json {     "Version": "2012-10-17",     "Statement": [         {             "Effect": "Allow",             "Action": [                 "sagemaker:InvokeEndpoint"             ],             "Resource": "*"         }     ] } EoF ``` 1. Collega la policy al ruolo IAM del nodo client. Eseguire il seguente comando seguente. Sostituisci `` con il nome del ruolo IAM. Sostituisci `` con il percorso del file di policy creato. ``` aws iam put-role-policy --role-name {{}} --policy-name sagemaker-invoke-for-worker --policy-document file://{{}} ``` #### Esecuzione di previsioni 1. Crea un AWS SDK per Python (Boto3) file dal tuo computer client denominato `mnist-predictions.py` con il seguente contenuto. Sostituisci la variabile `ENDPOINT_NAME`. Lo script carica il set di dati MNIST, crea un file CSV a partire da quelle cifre, quindi invia il file CSV all'endpoint per la previsione e stampa i risultati. ``` 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. Esegui il AWS SDK per Python (Boto3) file come segue: ``` python mnist-predictions.py ``` ### Visualizzazione di risultati e registri Quando la pipeline è in esecuzione, puoi scegliere qualsiasi componente per controllare i dettagli di esecuzione, come input e output. Vengono elencati i nomi delle risorse create. Se la richiesta KFP viene elaborata correttamente e viene creato un lavoro SageMaker AI, i registri dei componenti nell'interfaccia utente KFP forniscono un collegamento al lavoro creato in AI. SageMaker I CloudWatch log vengono forniti anche se il lavoro viene creato correttamente. Se esegui troppi processi relativi alla pipeline sullo stesso cluster, potresti visualizzare un messaggio di errore, a indicare la mancata disponibilità di un numero sufficiente di pod. Per risolvere questo problema, accedi al tuo nodo gateway ed elimina i pod creati dalle pipeline che non stai utilizzando: ``` kubectl get pods -n kubeflow kubectl delete pods -n kubeflow {{}} ``` ### Rimozione Al termine del processo relativo alla pipeline, è necessario rimuovere le risorse. 1. Dal dashboard di KFP, interrompi i percorsi della pipeline se non è possibile uscirne correttamente selezionando **Termina**. 1. Se l'opzione **Termina** non funziona, accedi al nodo gateway e interrompi manualmente tutti i pod creati dalla pipeline, svolgendo le seguenti operazioni: ``` kubectl get pods -n kubeflow kubectl delete pods -n kubeflow {{}} ``` 1. Utilizzando il tuo AWS account, accedi al servizio SageMaker AI. Interrompi manualmente tutti i processi di addestramento, trasformazione in batch e HPO. Elimina modelli, bucket di dati ed endpoint per evitare che influiscano sulle tue risorse. L'interruzione delle operazioni della pipeline non interrompe i lavori nell' SageMaker intelligenza artificiale.