Acompanhe seus experimentos de ML de ponta a ponta com o Data Version Control e o Amazon SageMaker Experiments

Os cientistas de dados geralmente trabalham para compreender os efeitos de vários pré-processamento de dados e estratégias de engenharia de recursos em combinação com diferentes arquiteturas de modelo e hiperparâmetros. Fazer isso exige que você cubra grandes espaços de parâmetros de forma iterativa e pode ser complicado acompanhar configurações e resultados executados anteriormente e, ao mesmo tempo, manter os experimentos reproduzíveis.

Esta postagem mostra um exemplo de como rastrear seus experimentos em código, dados, artefatos e métricas usando Experimentos Amazon SageMaker em conjunção com Controle de versão de dados (DVC). Mostramos como você pode usar o DVC lado a lado com Amazon Sage Maker trabalhos de processamento e treinamento. Treinamos diferentes modelos CatBoost no conjunto de dados habitacionais da Califórnia do Repositório StatLibe alterar estratégias de validação enquanto acompanha a versão dos dados com DVC. Em cada experimento individual, rastreamos artefatos de entrada e saída, código e métricas usando Experimentos SageMaker.

Experimentos SageMaker

SageMaker Experiments é um serviço da AWS para rastrear experimentos de aprendizado de máquina (ML). O SDK do Python para experimentos do SageMaker é uma interface de alto nível para este serviço que ajuda a rastrear informações de experimentos usando Python.

O objetivo do SageMaker Experiments é simplificar ao máximo a criação de experimentos, preenchê-los com testes, adicionar informações de rastreamento e linhagem e executar análises em testes e experimentos.

Ao discutir os experimentos SageMaker, nos referimos aos seguintes conceitos:

• Experiência – Uma coleção de ensaios relacionados. Você adiciona testes a um experimento que deseja comparar.
• Trial – Uma descrição de um fluxo de trabalho de ML de várias etapas. Cada etapa do fluxo de trabalho é descrita por um componente de avaliação.
• Componente de teste – Uma descrição de uma única etapa em um fluxo de trabalho de ML, como limpeza de dados, extração de recursos, treinamento de modelo ou avaliação de modelo.
• Tracker – Um gerenciador de contexto Python para registrar informações sobre um único componente de avaliação (por exemplo, parâmetros, métricas ou artefatos).

Controle de versão de dados

O Data Version Control (DVC) é um novo tipo de software de controle de versão de dados, fluxo de trabalho e gerenciamento de experimentos que se baseia Git (embora possa funcionar de forma independente). O DVC reduz a lacuna entre os conjuntos de ferramentas de engenharia estabelecidos e as necessidades da ciência de dados, permitindo que você aproveite novas vantagens características enquanto reutiliza habilidades e intuição existentes.

O compartilhamento e a colaboração de experimentos de ciência de dados podem ser feitos por meio de um fluxo Git regular (confirmações, ramificações, marcação, solicitações pull), da mesma forma que funciona para engenheiros de software. Com Git e DVC, as equipes de ciência de dados e ML podem criar versões de experimentos, gerenciar grandes conjuntos de dados e tornar os projetos reproduzíveis.

DVC possui os seguintes recursos:

• O DVC é um sem, Código aberto linha de comando ferramenta.
• O DVC funciona sobre repositórios Git e possui uma interface de linha de comando e fluxo semelhantes aos do Git. O DVC também pode funcionar de forma independente, mas sem versionamento capacidades.
• O versionamento de dados é habilitado pela substituição de arquivos grandes, diretórios de conjuntos de dados, modelos de ML e assim por diante por pequenos metarquivos (fácil de manusear com Git). Esses espaços reservados apontam para os dados originais, que são dissociados do gerenciamento do código-fonte.
• Você pode usar armazenamento local ou em nuvem para armazenar os dados do projeto separados de sua base de código. É assim que os cientistas de dados podem transferir grandes conjuntos de dados ou compartilhar um modelo treinado em GPU com outras pessoas.
• O DVC torna os projetos de ciência de dados reproduzíveis criando soluções leves dutos usando gráficos de dependência implícita e codificando os dados e artefatos envolvidos.
• DVC é independente de plataforma. Ele é executado em todos os principais sistemas operacionais (Linux, macOS e Windows) e funciona independentemente das linguagens de programação (Python, R, Julia, scripts de shell e assim por diante) ou bibliotecas de ML (Keras, TensorFlow, PyTorch, Scipy e mais) usados ​​no projeto.
• DVC é rápido para instalar e não requer infraestrutura especial, nem depende de APIs ou serviços externos. É uma ferramenta CLI independente.

Experimentos SageMaker e amostra DVC

Os seguintes Exemplo do GitHub mostra como usar DVC no ambiente SageMaker. Em particular, veremos como construir uma imagem personalizada com bibliotecas DVC instaladas por padrão para fornecer um ambiente de desenvolvimento consistente aos seus cientistas de dados em Estúdio Amazon SageMakere como executar o DVC junto com a infraestrutura gerenciada do SageMaker para processamento e treinamento. Além disso, mostramos como enriquecer as informações de rastreamento do SageMaker com informações de controle de versão de dados do DVC e visualizá-las no console do Studio.

O diagrama a seguir ilustra a arquitetura e o fluxo de trabalho da solução.

Crie uma imagem personalizada do Studio com o DVC já instalado

Neste curso Repositório GitHub, explicamos como criar uma imagem personalizada para o Studio que já possui o DVC instalado. A vantagem de criar uma imagem e disponibilizá-la para todos os usuários do Studio é que isso cria um ambiente consistente para os usuários do Studio, que eles também podem executar localmente. Embora a amostra seja baseada em Nuvem AWS9, você também pode criar o contêiner em sua máquina local, desde que tenha o Docker instalado e em execução. Este exemplo é baseado no seguinte dockerfile e ambiente.yml. A imagem Docker resultante é armazenada em Registro do Amazon Elastic Container (Amazon EMR) em sua conta da AWS. Veja o seguinte código:

# Login to ECR
aws --region ${REGION} ecr get-login-password | docker login --username AWS --password-stdin ${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com/smstudio-custom

# Create the ECR repository
aws --region ${REGION} ecr create-repository --repository-name smstudio-custom

# Build the image - it might take a few minutes to complete this step
docker build . -t ${IMAGE_NAME} -t ${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com/smstudio-custom:${IMAGE_NAME}

# Push the image to ECR
docker push ${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com/smstudio-custom:${IMAGE_NAME}

Agora você pode crie um novo domínio do Studio or atualizar um domínio existente do Studio que tem acesso à imagem Docker recém-criada.

Usamos Kit de desenvolvimento em nuvem da AWS (AWS CDK) para criar os seguintes recursos por meio de Formação da Nuvem AWS:

• Uma função de execução do SageMaker com as permissões corretas para seu domínio novo ou existente do Studio
• Uma imagem do SageMaker e uma versão da imagem do SageMaker da imagem do Docker conda-env-dvc-kernel que criamos anteriormente
• An AppImageConfig que especifica como o gateway do kernel deve ser configurado
• Um usuário do Studio (data-scientist-dvc) com a função de execução correta do SageMaker e a imagem personalizada do Studio disponível para ele

Para instruções detalhadas, consulte Associe uma imagem personalizada ao SageMaker Studio.

Execute o laboratório

Para executar o laboratório, conclua as seguintes etapas:

1. No domínio Studio, inicie o Studio para o data-scientist-dvc usuário.
2. Escolha o ícone do Git e escolha Clonar um repositório.
   
3. Insira a URL do repositório (https://github.com/aws-samples/amazon-sagemaker-experiments-dvc-demo) e escolha clone.
4. No navegador de arquivos, escolha o amazon-sagemaker-experiments-dvc-demo repositório.
5. Abra o dvc_sagemaker_script_mode.ipynb notebook.
6. Escolha Imagem personalizada, escolha a imagem conda-env-dvc-kernel.
7. Escolha Selecionar.
   

Configurar DVC para controle de versão de dados

Criamos um subdiretório onde preparamos os dados: sagemaker-dvc-sample. Dentro deste subdiretório, inicializamos um novo repositório Git e configuramos o remoto para um repositório que criamos em AWS CodeCommit. O objetivo é ter configurações e arquivos DVC para rastreamento de dados versionados neste repositório. No entanto, o Git oferece recursos nativos para gerenciar subprojetos por meio, por exemplo, de submódulos e subárvores git, e você pode estender este exemplo para usar qualquer uma das ferramentas mencionadas que melhor se adapta ao seu fluxo de trabalho.

A principal vantagem de usar CodeCommit com SageMaker no nosso caso é a sua integração com Gerenciamento de acesso e identidade da AWS (IAM) para autenticação e autorização, o que significa que podemos usar funções IAM para enviar e extrair dados sem a necessidade de buscar credenciais (ou chaves SSH). Definir as permissões apropriadas na função de execução do SageMaker também permite que o notebook Studio e o trabalho de treinamento e processamento do SageMaker interajam de forma segura com o CodeCommit.

Embora você possa substituir o CodeCommit por qualquer outro serviço de controle de origem, como GitHub, Gitlab ou Bitbucket, você precisa considerar como lidar com as credenciais do seu sistema. Uma possibilidade é armazenar essas credenciais em Gerenciador de segredos da AWS e buscá-los em tempo de execução no notebook Studio, bem como nos trabalhos de processamento e treinamento do SageMaker.

Processe e treine com DVC e SageMaker

Nesta seção, exploramos duas abordagens diferentes para resolver nosso problema e como podemos acompanhar os dois testes usando Experimentos SageMaker de acordo com a arquitetura conceitual de alto nível que mostramos anteriormente.

Configure um experimento SageMaker

Para acompanhar este teste no SageMaker, precisamos criar um experimento. Precisamos também definir o ensaio dentro do experimento. Por uma questão de simplicidade, consideramos apenas uma tentativa para o experimento, mas você pode ter qualquer número de tentativas dentro de um experimento, por exemplo, se quiser testar algoritmos diferentes.

Criamos um experimento chamado DEMO-sagemaker-experiments-dvc com duas tentativas, dvc-trial-single-file e dvc-trial-multi-files, cada um representando uma versão diferente do conjunto de dados.

Vamos criar o DEMO-sagemaker-experiments-dvc experimentar:

from smexperiments.experiment import Experiment
from smexperiments.trial import Trial
from smexperiments.trial_component import TrialComponent
from smexperiments.tracker import Tracker

experiment_name = 'DEMO-sagemaker-experiments-dvc'

# create the experiment if it doesn't exist
try:
    my_experiment = Experiment.load(experiment_name=experiment_name)
    print("existing experiment loaded")
except Exception as ex:
    if "ResourceNotFound" in str(ex):
        my_experiment = Experiment.create(
            experiment_name = experiment_name,
            description = "How to integrate DVC"
        )
        print("new experiment created")
    else:
        print(f"Unexpected {ex}=, {type(ex)}")
        print("Dont go forward!")
        raise

Teste 1: Gere arquivos únicos para treinamento e validação

Nesta seção, criamos um script de processamento que busca os dados brutos diretamente do Serviço de armazenamento simples da Amazon (Amazon S3) como entrada; processa-o para criar os conjuntos de dados de treinamento, validação e teste; e armazena os resultados no Amazon S3 usando DVC. Além disso, mostramos como você pode rastrear artefatos de saída gerados pelo DVC com o SageMaker ao executar trabalhos de processamento e treinamento e por meio de experimentos do SageMaker.

Primeiro, criamos o dvc-trial-single-file teste e adicione-o ao DEMO-sagemaker-experiments-dvc experimentar. Ao fazer isso, mantemos todos os componentes do teste relacionados a este teste organizados de maneira significativa.

first_trial_name = "dvc-trial-single-file"

try:
    my_first_trial = Trial.load(trial_name=first_trial_name)
    print("existing trial loaded")
except Exception as ex:
    if "ResourceNotFound" in str(ex):
        my_first_trial = Trial.create(
            experiment_name=experiment_name,
            trial_name=first_trial_name,
        )
        print("new trial created")
    else:
        print(f"Unexpected {ex}=, {type(ex)}")
        print("Dont go forward!")
        raise

Use DVC em um trabalho de processamento do SageMaker para criar a versão de arquivo único

Nesta seção, criamos um script de processamento que obtém os dados brutos diretamente do Amazon S3 como entrada usando o recurso gerenciado de carregamento de dados do SageMaker; processa-o para criar os conjuntos de dados de treinamento, validação e teste; e armazena os resultados no Amazon S3 usando DVC. É muito importante entender que, ao usar o DVC para armazenar dados no Amazon S3 (ou extrair dados do Amazon S3), estamos perdendo os recursos de carregamento de dados gerenciados do SageMaker, o que pode potencialmente ter um impacto no desempenho e nos custos de nossos trabalhos de processamento e treinamento. , especialmente ao trabalhar com conjuntos de dados muito grandes. Para obter mais informações sobre os diferentes recursos do modo de entrada nativo do SageMaker, consulte Acessar dados de treinamento.

Por fim, unificamos os recursos de rastreamento DVC com os recursos de rastreamento do SageMaker ao executar trabalhos de processamento por meio do SageMaker Experiments.

O script de processamento espera o endereço do repositório Git e o branch que queremos criar para armazenar os metadados DVC passados ​​​​por variáveis ​​ambientais. Os próprios conjuntos de dados são armazenados no Amazon S3 pela DVC. Embora as variáveis ​​ambientais sejam rastreadas automaticamente no SageMaker Experiments e visíveis nos parâmetros do componente de teste, podemos querer enriquecer os componentes de teste com mais informações, que então ficam disponíveis para visualização na UI do Studio usando um objeto rastreador. No nosso caso, os parâmetros dos componentes de teste incluem o seguinte:

• DVC_REPO_URL
• DVC_BRANCH
• USER
• data_commit_hash
• train_test_split_ratio

O script de pré-processamento clona o repositório Git; gera os conjuntos de dados de treinamento, validação e teste; e sincroniza-o usando DVC. Conforme mencionado anteriormente, ao usar DVC, não podemos aproveitar as vantagens dos recursos nativos de carregamento de dados do SageMaker. Além das penalidades de desempenho que podemos sofrer em grandes conjuntos de dados, também perdemos os recursos de rastreamento automático dos artefatos de saída. No entanto, graças ao rastreador e à API DVC Python, podemos compensar essas deficiências, recuperar essas informações em tempo de execução e armazená-las no componente de teste com pouco esforço. O valor agregado ao fazer isso é ter uma visão única dos artefatos de entrada e saída que pertencem a esse trabalho de processamento específico.

O script Python de pré-processamento completo está disponível no GitHub repo.

with Tracker.load() as tracker:
    tracker.log_parameters({"data_commit_hash": commit_hash})
    for file_type in file_types:
        path = dvc.api.get_url(
            f"{data_path}/{file_type}/california_{file_type}.csv",
            repo=dvc_repo_url,
            rev=dvc_branch
        )
        tracker.log_output(name=f"california_{file_type}",value=path)

O SageMaker nos dá a possibilidade de executar nosso script de processamento em imagens de contêiner gerenciadas pela AWS que são otimizadas para execução na infraestrutura da AWS. Se nosso script exigir dependências adicionais, podemos fornecer um requirements.txt arquivo. Quando iniciamos o trabalho de processamento, o SageMaker usa pip-install para instalar todas as bibliotecas que precisamos (por exemplo, bibliotecas relacionadas ao DVC). Caso você precise ter um controle mais rígido de todas as bibliotecas instaladas nos containers, você pode trazer seu próprio container no SageMaker, por exemplo para em processamento e formação.

Agora temos todos os ingredientes para executar nosso trabalho de processamento do SageMaker:

• Um script de processamento que pode processar vários argumentos (--train-test-split-ratio) e duas variáveis ​​ambientais (DVC_REPO_URL e DVC_BRANCH)
• A requiremets.txt lima
• Um repositório Git (no CodeCommit)
• Um experimento e teste do SageMaker

from sagemaker.processing import FrameworkProcessor, ProcessingInput
from sagemaker.sklearn.estimator import SKLearn

dvc_repo_url = "codecommit::{}://sagemaker-dvc-sample".format(region)
dvc_branch = my_first_trial.trial_name

script_processor = FrameworkProcessor(
    estimator_cls=SKLearn,
    framework_version='0.23-1',
    instance_count=1,
    instance_type='ml.m5.xlarge',
    env={
        "DVC_REPO_URL": dvc_repo_url,
        "DVC_BRANCH": dvc_branch,
        "USER": "sagemaker"
    },
    role=role
)

experiment_config={
    "ExperimentName": my_experiment.experiment_name,
    "TrialName": my_first_trial.trial_name
}

Em seguida, executamos o trabalho de processamento com o preprocessing-experiment.py roteiro, experiment_config, dvc_repo_url e dvc_branch definimos anteriormente.

%%time

script_processor.run(
    code='./source_dir/preprocessing-experiment.py',
    dependencies=['./source_dir/requirements.txt'],
    inputs=[ProcessingInput(source=s3_data_path, destination="/opt/ml/processing/input")],
    experiment_config=experiment_config,
    arguments=["--train-test-split-ratio", "0.2"]
)

O trabalho de processamento leva aproximadamente 5 minutos para ser concluído. Agora você pode visualizar os detalhes da avaliação do conjunto de dados de arquivo único.

A captura de tela a seguir mostra onde você pode encontrar as informações armazenadas no Studio. Observe os valores para dvc-trial-single-file in DVC_BRANCH, DVC_REPO_URL e data_commit_hash na parâmetros aba.

Observe também os detalhes de entrada e saída no Artefatos aba.

Crie um estimador e ajuste o modelo com versão de dados de arquivo único

Para usar a integração DVC dentro de um trabalho de treinamento do SageMaker, passamos um dvc_repo_url e dvc_branch como variáveis ​​ambientais quando você cria o objeto Estimador.

Treinamos no dvc-trial-single-file ramificar primeiro.

Ao extrair dados com DVC, usamos a seguinte estrutura de conjunto de dados:

dataset
    |-- train
    |   |-- california_train.csv
    |-- test
    |   |-- california_test.csv
    |-- validation
    |   |-- california_validation.csv

Agora criamos um estimador Scikit-learn usando o SDK Python do SageMaker. Isso nos permite especificar o seguinte:

• O caminho para o arquivo de origem do Python, que deve ser executado como ponto de entrada para o treinamento.
• A função do IAM que controla permissões para acessar dados do Amazon S3 e CodeCommit e executar funções do SageMaker.
• Uma lista de dicionários que definem as métricas usadas para avaliar os trabalhos de treinamento.
• O número e o tipo de instâncias de treinamento. Usamos uma instância ml.m5.large.
• Hiperparâmetros usados ​​para treinamento.
• Variáveis ​​de ambiente a serem usadas durante o trabalho de treinamento. Nós usamos DVC_REPO_URL, DVC_BRANCH e USER.

metric_definitions = [{'Name': 'median-AE', 'Regex': "AE-at-50th-percentile: ([0-9.]+).*$"}]

hyperparameters={ 
        "learning_rate" : 1,
        "depth": 6
    }
estimator = SKLearn(
    entry_point='train.py',
    source_dir='source_dir',
    role=role,
    metric_definitions=metric_definitions,
    hyperparameters=hyperparameters,
    instance_count=1,
    instance_type='ml.m5.large',
    framework_version='0.23-1',
    base_job_name='training-with-dvc-data',
    environment={
        "DVC_REPO_URL": dvc_repo_url,
        "DVC_BRANCH": dvc_branch,
        "USER": "sagemaker"
    }
)

experiment_config={
    "ExperimentName": my_experiment.experiment_name,
    "TrialName": my_first_trial.trial_name
}

Chamamos o método fit do Estimator com experiment_config que definimos anteriormente para iniciar o treinamento.

%%time
estimator.fit(experiment_config=experiment_config)

O trabalho de treinamento leva aproximadamente 5 minutos para ser concluído. Os logs mostram essas linhas, indicando os arquivos extraídos pelo DVC:

Running dvc pull command
A       train/california_train.csv
A       test/california_test.csv
A       validation/california_validation.csv
3 files added and 3 files fetched
Starting the training.
Found train files: ['/opt/ml/input/data/dataset/train/california_train.csv']
Found validation files: ['/opt/ml/input/data/dataset/train/california_train.csv']

Teste 2: Gere vários arquivos para treinamento e validação

Nós criamos um novo dvc-trial-multi-files teste e adicione-o ao atual DEMO-sagemaker-experiments-dvc experimentar.

second_trial_name = "dvc-trial-multi-files"
try:
    my_second_trial = Trial.load(trial_name=second_trial_name)
    print("existing trial loaded")
except Exception as ex:
    if "ResourceNotFound" in str(ex):
        my_second_trial = Trial.create(
            experiment_name=experiment_name,
            trial_name=second_trial_name,
        )
        print("new trial created")
    else:
        print(f"Unexpected {ex}=, {type(ex)}")
        print("Dont go forward!")
        raise

Diferentemente do primeiro script de processamento, agora criamos vários arquivos do conjunto de dados original para treinamento e validação e armazenamos os metadados DVC em uma ramificação diferente.

Você pode explorar o segundo script Python de pré-processamento em GitHub.

%%time

script_processor.run(
    code='./source_dir/preprocessing-experiment-multifiles.py',
    dependencies=['./source_dir/requirements.txt'],
    inputs=[ProcessingInput(source=s3_data_path, destination="/opt/ml/processing/input")],
    experiment_config=experiment_config,
    arguments=["--train-test-split-ratio", "0.1"]
)

O trabalho de processamento leva aproximadamente 5 minutos para ser concluído. Agora você pode visualizar os detalhes da avaliação do conjunto de dados de vários arquivos.

As capturas de tela a seguir mostram onde você pode encontrar as informações armazenadas no SageMaker Experiments no Componentes de teste seção na interface do Studio. Observe os valores para dvc-trial-multi-files in DVC_BRANCH, DVC_REPO_URL e data_commit_hash na parâmetros aba.

Você também pode revisar os detalhes de entrada e saída na página Artefatos aba.

Agora treinamos no dvc-trial-multi-files filial. Ao extrair dados com DVC, usamos a seguinte estrutura de conjunto de dados:

dataset
    |-- train
    |   |-- california_train_1.csv
    |   |-- california_train_2.csv
    |   |-- california_train_3.csv
    |   |-- california_train_4.csv
    |   |-- california_train_5.csv
    |-- test
    |   |-- california_test.csv
    |-- validation
    |   |-- california_validation_1.csv
    |   |-- california_validation_2.csv
    |   |-- california_validation_3.csv

Semelhante ao que fizemos antes, criamos um novo Estimador Scikit-learn com o nome de teste dvc-trial-multi-files e inicie o trabalho de treinamento.

%%time

estimator.fit(experiment_config=experiment_config)

O trabalho de treinamento leva aproximadamente 5 minutos para ser concluído. Na saída dos logs de trabalho de treinamento para o notebook, você pode ver essas linhas, indicando os arquivos extraídos pelo DVC:

Running dvc pull command
A       validation/california_validation_2.csv
A       validation/california_validation_1.csv
A       validation/california_validation_3.csv
A       train/california_train_4.csv
A       train/california_train_5.csv
A       train/california_train_2.csv
A       train/california_train_3.csv
A       train/california_train_1.csv
A       test/california_test.csv
9 files added and 9 files fetched
Starting the training.
Found train files: ['/opt/ml/input/data/dataset/train/california_train_2.csv', '/opt/ml/input/data/dataset/train/california_train_5.csv', '/opt/ml/input/data/dataset/train/california_train_4.csv', '/opt/ml/input/data/dataset/train/california_train_1.csv', '/opt/ml/input/data/dataset/train/california_train_3.csv']
Found validation files: ['/opt/ml/input/data/dataset/validation/california_validation_2.csv', '/opt/ml/input/data/dataset/validation/california_validation_1.csv', '/opt/ml/input/data/dataset/validation/california_validation_3.csv']

Hospede seu modelo no SageMaker

Depois de treinar seu modelo de ML, você poderá implantá-lo usando o SageMaker. Para implantar um endpoint persistente e em tempo real que faz uma previsão por vez, usamos Serviços de hospedagem em tempo real do SageMaker.

from sagemaker.serializers import CSVSerializer

predictor = estimator.deploy(1, "ml.t2.medium", serializer=CSVSerializer())

Primeiro, obtemos o conjunto de dados de teste mais recente localmente no notebook de desenvolvimento no Studio. Para este propósito, podemos usar dvc.api.read() para carregar os dados brutos armazenados no Amazon S3 pelo trabalho de processamento do SageMaker.

import io
import dvc.api

raw = dvc.api.read(
    "dataset/test/california_test.csv",
    repo=dvc_repo_url,
    rev=dvc_branch
)

Em seguida, preparamos os dados usando Pandas, carregamos um arquivo CSV de teste e chamamos predictor.predict para invocar o endpoint SageMaker criado anteriormente, com dados, e obter previsões.

test = pd.read_csv(io.StringIO(raw), sep=",", header=None)
X_test = test.iloc[:, 1:].values
y_test = test.iloc[:, 0:1].values

predicted = predictor.predict(X_test)
for i in range(len(predicted)-1):
    print(f"predicted: {predicted[i]}, actual: {y_test[i][0]}")

Exclua o ponto de extremidade

Você deve excluir endpoints quando eles não estiverem mais em uso, porque eles são cobrados pelo tempo de implantação (para obter mais informações, consulte Preços do Amazon SageMaker). Certifique-se de excluir o endpoint para evitar custos inesperados.

predictor.delete_endpoint()

limpar

Antes de remover todos os recursos criados, certifique-se de que todos os aplicativos sejam excluídos do data-scientist-dvc usuário, incluindo todos os aplicativos KernelGateway, bem como o aplicativo JupiterServer padrão.

Em seguida, você pode destruir a pilha do AWS CDK executando o seguinte comando:

cdk destroy

Se você usou um domínio existente, execute também os seguintes comandos:

# inject your DOMAIN_ID into the configuration file
sed -i 's/<your-sagemaker-studio-domain-id>/'"$DOMAIN_ID"'/' ../update-domain-no-custom-images.json
# update the sagemaker studio domain
aws --region ${REGION} sagemaker update-domain --cli-input-json file://../update-domain-no-custom-images.json

Conclusão

Nesta postagem, você percorreu um exemplo de como rastrear seus experimentos em código, dados, artefatos e métricas usando Experimentos SageMaker e trabalhos de processamento e treinamento do SageMaker em conjunto com DVC. Criamos uma imagem Docker contendo DVC, que era necessário para o Studio como notebook de desenvolvimento, e mostramos como você pode usar trabalhos de processamento e treinamento com DVC. Preparamos duas versões dos dados e usamos DVC para gerenciá-los com Git. Em seguida, você usou o SageMaker Experiments para rastrear o processamento e o treinamento com as duas versões dos dados para ter uma visão unificada de parâmetros, artefatos e métricas em um único painel. Por fim, você implantou o modelo em um endpoint do SageMaker e usou um conjunto de dados de teste da segunda versão do conjunto de dados para invocar o endpoint do SageMaker e obter previsões.

Na próxima etapa, você pode estender o notebook existente e introduzir sua própria estratégia de engenharia de recursos e usar DVC e SageMaker para executar seus experimentos. Vamos construir!

Para ler mais, consulte os seguintes recursos:

Sobre os autores

Paulo Di Francesco é arquiteto de soluções na AWS. Tem experiência na área de telecomunicações e engenharia de software. Ele é apaixonado por aprendizado de máquina e atualmente está se concentrando em usar sua experiência para ajudar os clientes a alcançar seus objetivos na AWS, principalmente em discussões sobre MLOps. Fora do trabalho, ele gosta de jogar futebol e ler.

Eitan Sela é um arquiteto de soluções especialista em aprendizado de máquina da Amazon Web Services. Ele trabalha com clientes da AWS para fornecer orientação e assistência técnica, ajudando-os a criar e operar soluções de machine learning na AWS. Em seu tempo livre, Eitan gosta de correr e ler os artigos mais recentes de aprendizado de máquina.