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 componentes de SageMaker IA
Neste tutorial, você executa um pipeline usando componentes de SageMaker IA para pipelines do Kubeflow para treinar um modelo de classificação usando o Kmeans com o conjunto de dados MNIST em IA. SageMaker O fluxo de trabalho usa o Kubeflow Pipelines como orquestrador e SageMaker IA para executar cada etapa do fluxo de trabalho. O exemplo foi retirado de um [exemplo de SageMaker IA](https://github.com/aws/amazon-sagemaker-examples/blob/8279abfcc78bad091608a4a7135e50a0bd0ec8bb/sagemaker-python-sdk/1P_kmeans_highlevel/kmeans_mnist.ipynb) existente e modificado para funcionar com componentes de SageMaker IA para pipelines do Kubeflow.
Você pode definir seu pipeline em Python usando o painel do KFP AWS SDK para Python (Boto3) , a CLI do KFP ou o Boto3 para compilar, implantar e executar seus fluxos de trabalho. O código completo do exemplo do pipeline de classificação MNIST está disponível no repositório [Kubeflow](https://github.com/kubeflow/pipelines/tree/master/samples/contrib/aws-samples/mnist-kmeans-sagemaker#mnist-classification-with-kmeans) Github. Para usá-lo, clone os arquivos Python no nó do gateway.
Você pode encontrar exemplos adicionais de [ SageMaker AI Kubeflow Pipelines](https://github.com/kubeflow/pipelines/tree/master/samples/contrib/aws-samples) em. GitHub Para obter informações sobre os componentes usados, consulte o [ GitHub repositório KubeFlow Pipelines](https://github.com/kubeflow/pipelines/tree/master/components/aws/sagemaker).
Para executar o exemplo do pipeline de classificação, crie uma função de execução do SageMaker AI IAM 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 de execução de SageMaker IA
A função `kfp-example-sagemaker-execution-role` do IAM é uma função de tempo de execução assumida pelos trabalhos de SageMaker IA para acessar AWS recursos. No comando a seguir, você cria uma função de execução do IAM chamada`kfp-example-sagemaker-execution-role`, anexa duas políticas gerenciadas (AmazonSageMakerFullAccess, AmazonS3FullAccess) e cria uma relação de confiança com a SageMaker IA para conceder aos trabalhos de SageMaker IA 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. Anote o ID do ARN retornado na 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'
```
## Kubeflow completo na implantação AWS
Siga as instruções do [tutorial do SageMaker Training Pipeline para classificação MNIST com K-Means](https://awslabs.github.io/kubeflow-manifests/docs/amazon-sagemaker-integration/sagemaker-components-for-kubeflow-pipelines/).
## Implantação autônoma do Kubeflow Pipelines
### 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](https://docs.aws.amazon.com/AmazonS3/latest/gsg/CreatingABucket.html).
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 `` para o nome do bucket do Amazon S3.
```
aws s3 cp mnist-kmeans-sagemaker/kmeans_preprocessing.py s3://{{}}/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 arquivo YAML compactado em um arquivo tar.gz. Você precisa do SDK do KFP para compilar seu pipeline.
#### Instalar o SDK do KFP
Execute o seguinte na linha de comando do seu nó de gateway:
1. Instale o SDK do KFP seguindo as instruções na documentação dos pipelines do [Kubeflow](https://www.kubeflow.org/docs/pipelines/sdk/install-sdk/).
1. Verifique se o SDK do KFP está instalado com o seguinte comando:
```
pip show kfp
```
1. 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, KFP CLI ou KFP SDK. As seções a seguir ilustram o fluxo de trabalho usando a interface de usuário e a CLI do KFP.
Concluir as etapas a seguir no nó do gateway.
1. Modifique seu arquivo Python com o nome do bucket do Amazon S3 e o ARN da perfil do IAM.
1. Use o comando `dsl-compile` da linha de comando para compilar seu pipeline da seguinte maneira: Substitua `` pelo caminho para seu pipeline e `` pelo local em que você deseja que seu arquivo tar.gz esteja.
```
dsl-compile --py {{}} --output {{}}
```
#### Carregue e execute o pipeline usando a CLI do KFP
Conclua as etapas a seguir na linha de comando do seu nó do gateway. O KFP organiza 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 {{}} {{}}
```
A saída será semelhante à seguinte: 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
...
...
```
1. Criar uma execução usando o comando a seguir. Atualmente, o comando de execução da CLI do KFP não é compatível com a especificação de parâmetros de entrada ao criar a execução. Você precisa atualizar seus parâmetros no arquivo do AWS SDK para Python (Boto3) pipeline antes de compilar. Substitua `` e `` por qualquer nome. Substitua `` pelo ID do pipeline enviado. Substitua `` pelo ARN de `kfp-example-pod-role`. Substitua `` pelo nome do bucket do Amazon S3 que você criou.
```
kfp run submit --experiment-name {{}} --run-name {{}} --pipeline-id {{}} role_arn="{{}}" 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 {{}} --run-name {{}} --package-file {{}} role_arn="{{}}" 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 |
+--------------------------------------+--------+----------+---------------------------+
```
1. Navegue até a interface do usuário para verificar o progresso do trabalho.
#### Faça o upload e execute o pipeline usando a interface do usuário do KFP
1. No painel à esquerda, selecione a guia **Pipelines**.
1. **No canto superior direito, escolha \+. UploadPipeline**
1. Inserir um nome descrição de pipeline.
1. Escolha **Fazer upload de um arquivo** e insira o caminho para o arquivo tar.gz que você criou usando a CLI ou com AWS SDK para Python (Boto3).
1. No painel à esquerda, selecione a guia **Pipelines**.
1. Encontre o pipeline que você criou.
1. Escolha **\+CreateRun**.
1. Insira seus parâmetros de entrada.
1. Escolha **Executar**.
### Execute predições
Depois que seu pipeline de classificação for implantado, você poderá executar predições de classificação em relação ao endpoint criado pelo componente Deploy. Use a interface do usuário do KFP para verificar os artefatos de saída `sagemaker-deploy-model-endpoint_name`. Faça o download do arquivo.tgz para extrair o nome do endpoint ou verifique o console de SageMaker IA na região que você usou.
#### Configurar permissões para executar predições
Se você quiser executar predições a partir do nó do gateway, pule esta seção.
**Para usar qualquer outra máquina para executar predições, atribua a permissão `sagemaker:InvokeEndpoint` ao perfil do IAM usada pela máquina cliente.**
1. No nó do gateway, execute o seguinte para criar um arquivo de política do IAM:
```
cat < ./sagemaker-invoke.json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sagemaker:InvokeEndpoint"
],
"Resource": "*"
}
]
}
EoF
```
1. Anexe a política ao perfil do IAM do nó do cliente.
Execute o seguinte comando: Substitua `` pelo nome da perfil do IAM. Substitua `` pelo caminho para o arquivo de política que você criou.
```
aws iam put-role-policy --role-name {{}} --policy-name sagemaker-invoke-for-worker --policy-document file://{{}}
```
#### Execute predições
1. Crie um AWS SDK para 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 conjunto de dados MNIST, cria um CSV a partir desses dígitos e, em seguida, envia o CSV ao endpoint para predição e imprime os resultados.
```
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. Execute o AWS SDK para Python (Boto3) arquivo da seguinte forma:
```
python mnist-predictions.py
```
### Exibir resultados e logs
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 solicitação do KFP for processada com sucesso e um trabalho de SageMaker IA for criado, os registros do componente na interface do usuário do KFP fornecerão um link para o trabalho criado no AI. 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 {{}}
```
### Limpeza
Quando você terminar seu pipeline, precisará limpar seus recursos.
1. **No painel do KFP, encerre as execuções do seu pipeline se elas não saírem corretamente, escolhendo Encerrar.**
1. 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 {{}}
```
1. Usando sua AWS conta, faça login no serviço de SageMaker IA. Interrompa manualmente todos os trabalhos de treinamento, transformação em lote e HPO. Exclua modelos, buckets de dados e endpoints para evitar custos adicionais. Encerrar as execuções do pipeline não interrompe os trabalhos na SageMaker IA.