Use SageMaker componentes - Amazon SageMaker

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Use SageMaker componentes

Neste tutorial, você executa um pipeline usando SageMaker Components for Kubeflow Pipelines para treinar um modelo de classificação usando o Kmeans com o conjunto de dados ativado. MNIST SageMaker O fluxo de trabalho usa o Kubeflow Pipelines como orquestrador e SageMaker para executar cada etapa do fluxo de trabalho. O exemplo foi retirado de um SageMaker exemplo existente e modificado para funcionar com SageMaker Components for Kubeflow Pipelines.

Você pode definir seu pipeline em Python usando AWS SDK for Python (Boto3) o KFP painel ou o Boto3 para compilar KFPCLI, implantar e executar seus fluxos de trabalho. O código completo do exemplo do pipeline de MNIST classificação está disponível no repositório Kubeflow Github. Para usá-lo, clone os arquivos Python no nó do gateway.

Você pode encontrar exemplos adicionais do SageMaker Kubeflow Pipelines em. GitHub Para obter informações sobre os componentes usados, consulte o GitHub repositório KubeFlow Pipelines.

Para executar o exemplo do pipeline de classificação, crie uma função de SageMaker IAM execução concedendo ao seu trabalho de treinamento a permissão para acessar AWS recursos e continue com as etapas que correspondem à sua opção de implantação.

Crie uma função SageMaker de execução

A kfp-example-sagemaker-execution-role IAM função é uma função de tempo de execução assumida por SageMaker trabalhos para acessar AWS recursos. No comando a seguir, você cria uma função de IAM execução chamadakfp-example-sagemaker-execution-role, anexa duas políticas gerenciadas (AmazonSageMakerFullAccess, AmazonS3FullAccess) e cria uma relação de confiança com SageMaker a qual conceder aos SageMaker trabalhos acesso a esses recursos. AWS

Você fornece essa função como um parâmetro de entrada ao executar o pipeline.

Execute o comando da a seguir para criar a função. Observe o ARN que é retornado em sua saída.

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'

Siga as instruções do tutorial do SageMaker Training Pipeline para MNIST classificação com K-Means.

Preparar conjuntos de dados

Para executar os pipelines, você precisa fazer upload do script de pré-processamento da extração de dados em um bucket do Amazon S3. Esse bucket e todos os recursos desse exemplo devem estar localizados na us-east-1 região. Para obter informações sobre como criar um bucket, consulte Criar um bucket.

Na mnist-kmeans-sagemaker pasta do repositório Kubeflow que você clonou no nó do gateway, execute o comando a seguir para fazer o upload do kmeans_preprocessing.py arquivo no bucket do Amazon S3. Altere <bucket-name> para o nome do bucket do Amazon S3.

aws s3 cp mnist-kmeans-sagemaker/kmeans_preprocessing.py s3://<bucket-name>/mnist_kmeans_example/processing_code/kmeans_preprocessing.py

Compile e implante seu pipeline

Depois de definir o pipeline, você deve compilá-lo em uma representação intermediária antes de enviá-lo ao serviço Kubeflow Pipelines em seu cluster. A representação intermediária é uma especificação de fluxo de trabalho na forma de um YAML arquivo compactado em um arquivo tar.gz. Você precisa do KFP SDK para compilar seu pipeline.

Instalar KFP SDK

Execute o seguinte na linha de comando do seu nó de gateway:

  1. Instale as instruções a KFP SDK seguir na documentação dos pipelines do Kubeflow.

  2. Verifique se o KFP SDK está instalado com o seguinte comando:

    pip show kfp
  3. Verifique se dsl-compile foi instalado corretamente da seguinte forma:

    which dsl-compile

Compilar seu pipeline

Você tem três opções para interagir com o Kubeflow Pipelines: KFP UI ou KFP CLI o. KFP SDK As seções a seguir ilustram o fluxo de trabalho usando a KFP interface do usuário e. CLI

Concluir as etapas a seguir no nó do gateway.

  1. Modifique seu arquivo Python com o nome e a função do bucket do Amazon S3. IAM ARN

  2. Use o comando dsl-compile da linha de comando para compilar seu pipeline da seguinte maneira. Substitua <path-to-python-file> pelo caminho para seu pipeline e <path-to-output> pelo local em que você deseja que seu arquivo tar.gz esteja.

    dsl-compile --py <path-to-python-file> --output <path-to-output>

Faça o upload e execute o pipeline usando o KFP CLI

Conclua as etapas a seguir na linha de comando do seu nó do gateway. KFPorganiza as execuções do seu pipeline como experimentos. Você tem a opção de especificar o nome do experimento. Se você não especificar uma, a execução será listada em Experimento padrão.

  1. Faça o upload do seu pipeline da seguinte forma:

    kfp pipeline upload --pipeline-name <pipeline-name> <path-to-output-tar.gz>

    A saída será semelhante a: Anote o 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 ... ...
  2. Criar uma execução usando o comando a seguir. Atualmente, o comando KFP CLI run não suporta a especificação de parâmetros de entrada ao criar a execução. Você precisa atualizar seus parâmetros no arquivo do AWS SDK for Python (Boto3) pipeline antes de compilar. Substitua <experiment-name> e <job-name> por qualquer nome. Substitua <pipeline-id> pelo ID do pipeline enviado. <your-role-arn>Substitua pelo ARN dekfp-example-pod-role. Substitua <your-bucket-name> pelo nome do bucket do Amazon S3 que você criou.

    kfp run submit --experiment-name <experiment-name> --run-name <job-name> --pipeline-id <pipeline-id> role_arn="<your-role-arn>" bucket_name="<your-bucket-name>"

    Você também pode enviar diretamente uma execução usando o pacote de pipeline compilado criado como saída do comando dsl-compile.

    kfp run submit --experiment-name <experiment-name> --run-name <job-name> --package-file <path-to-output> role_arn="<your-role-arn>" bucket_name="<your-bucket-name>"

    A saída será semelhante a:

    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 | +--------------------------------------+--------+----------+---------------------------+
  3. Navegue até a interface do usuário para verificar o progresso do trabalho.

Faça upload e execute o pipeline usando a KFP interface do usuário

  1. No painel à esquerda, selecione a guia Pipelines.

  2. No canto superior direito, escolha +. UploadPipeline

  3. Inserir um nome descrição de pipeline.

  4. Escolha Carregar um arquivo e insira o caminho para o arquivo tar.gz que você criou usando o CLI ou com AWS SDK for Python (Boto3).

  5. No painel à esquerda, selecione a guia Pipelines.

  6. Encontre o pipeline que você criou.

  7. Escolha + CreateRun.

  8. Insira seus parâmetros de entrada.

  9. Escolha Executar.

Execute previsões

Depois que seu pipeline de classificação for implantado, você poderá executar previsões de classificação em relação ao endpoint criado pelo componente Deploy. Use a KFP interface do usuário para verificar os artefatos de sagemaker-deploy-model-endpoint_name saída. Faça o download do arquivo.tgz para extrair o nome do endpoint ou verifique o SageMaker console na região que você usou.

Configurar permissões para executar previsões

Se você quiser executar previsões a partir do nó do gateway, pule esta seção.

Para usar qualquer outra máquina para executar previsões, atribua a sagemaker:InvokeEndpoint permissão à IAM função usada pela máquina cliente.
  1. No nó do gateway, execute o seguinte para criar um arquivo IAM de política:

    cat <<EoF > ./sagemaker-invoke.json {     "Version": "2012-10-17",     "Statement": [         {             "Effect": "Allow",             "Action": [                 "sagemaker:InvokeEndpoint"             ],             "Resource": "*"         }     ] } EoF
  2. Anexe a política à IAM função do nó do cliente.

    Execute o seguinte comando . <your-instance-IAM-role>Substitua pelo nome da IAM função. Substitua <path-to-sagemaker-invoke-json> pelo caminho para o arquivo de política que você criou.

    aws iam put-role-policy --role-name <your-instance-IAM-role> --policy-name sagemaker-invoke-for-worker --policy-document file://<path-to-sagemaker-invoke-json>

Execute previsões

  1. Crie um AWS SDK for Python (Boto3) arquivo da sua máquina cliente chamado mnist-predictions.py com o conteúdo a seguir. Substitua a variável ENDPOINT_NAME. O script carrega o MNIST conjunto de dados, cria um CSV a partir desses dígitos e os envia CSV para o endpoint para previsão e imprime os resultados.

    import boto3 import gzip import io import json import numpy import pickle ENDPOINT_NAME='<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)
  2. Execute o AWS SDK for Python (Boto3) arquivo da seguinte forma:

    python mnist-predictions.py

Exibir resultados e registros

Quando o pipeline está em execução, você pode escolher qualquer componente para verificar os detalhes da execução, como entradas e saídas. Isso lista os nomes dos recursos criados.

Se a KFP solicitação for processada com sucesso e um SageMaker trabalho for criado, os registros do componente na KFP interface do usuário fornecerão um link para o trabalho criado em SageMaker. Os CloudWatch registros também são fornecidos se o trabalho for criado com sucesso.

Se você executar muitos trabalhos de pipeline no mesmo cluster, poderá ver uma mensagem de erro indicando que você não tem pods suficientes disponíveis. Para corrigir isso, faça login no nó do gateway e exclua os pods criados pelos pipelines que você não está usando:

kubectl get pods -n kubeflow kubectl delete pods -n kubeflow <name-of-pipeline-pod>

Limpeza

Quando você terminar seu pipeline, precisará limpar seus recursos.

  1. No KFP painel, encerre as execuções do pipeline se elas não saírem corretamente escolhendo Encerrar.

  2. Se a opção Terminate não funcionar, faça login no nó do gateway e encerre manualmente todos os pods criados pela execução do pipeline da seguinte maneira:

    kubectl get pods -n kubeflow kubectl delete pods -n kubeflow <name-of-pipeline-pod>
  3. Usando sua AWS conta, faça login no SageMaker serviço. Interrompa manualmente todos os treinamentos, transformações em lotes e HPO trabalhos. Exclua modelos, compartimentos de dados e endpoints para evitar custos adicionais. O encerramento da execução do pipeline não interrompe os trabalhos. SageMaker