Organize sua jornada de machine learning com o Amazon SageMaker Experiments e o Amazon SageMaker Pipelines

O processo de construção de um modelo de aprendizado de máquina (ML) é iterativo até que você encontre o modelo candidato com bom desempenho e pronto para ser implantado. À medida que os cientistas de dados percorrem esse processo, eles precisam de um método confiável para rastrear facilmente os experimentos para entender como cada versão do modelo foi construída e como foi executada.

Amazon Sage Maker permite que as equipes aproveitem uma ampla variedade de recursos para preparar, construir, treinar, implantar e monitorar rapidamente modelos de ML. Pipelines Amazon SageMaker fornece um processo repetível para iterar por meio de atividades de construção de modelo e é integrado com Experimentos Amazon SageMaker. Por padrão, cada pipeline do SageMaker é associado a um experimento e cada execução desse pipeline é rastreada como um teste nesse experimento. Em seguida, suas iterações são rastreadas automaticamente sem etapas adicionais.

Nesta postagem, analisamos mais de perto a motivação por trás de um processo automatizado para rastrear experimentos com Experimentos e os recursos nativos integrados ao Pipelines.

Por que é importante manter seus experimentos organizados?

Vamos dar um passo atrás por um momento e tentar entender por que é importante ter experimentos organizados para aprendizado de máquina. Quando os cientistas de dados abordam um novo problema de ML, eles precisam responder a muitas perguntas diferentes, desde a disponibilidade de dados até como medirão o desempenho do modelo.

No início, o processo é cheio de incertezas e altamente iterativo. Como resultado, essa fase de experimentação pode produzir vários modelos, cada um criado a partir de suas próprias entradas (conjuntos de dados, scripts de treinamento e hiperparâmetros) e produzindo suas próprias saídas (artefatos de modelo e métricas de avaliação). O desafio, então, é acompanhar todas essas entradas e saídas de cada iteração.

Os cientistas de dados normalmente treinam muitas versões de modelos diferentes até encontrarem a combinação de transformação de dados, algoritmo e hiperparâmetros que resulta na versão de melhor desempenho de um modelo. Cada uma dessas combinações únicas é um único experimento. Com um registro rastreável das entradas, algoritmos e hiperparâmetros que foram usados ​​por esse teste, a equipe de ciência de dados pode achar fácil reproduzir suas etapas.

Ter um processo automatizado para rastrear experimentos melhora a capacidade de reproduzir, bem como implantar versões de modelos específicos com bom desempenho. A integração nativa do Pipelines com o Experiments facilita o rastreamento e o gerenciamento automáticos de experimentos em execuções de pipeline.

Benefícios das Experiências do SageMaker

O SageMaker Experiments permite que os cientistas de dados organizem, rastreiem, comparem e avaliem suas iterações de treinamento.

Vamos começar com uma visão geral do que você pode fazer com as Experiências:

• Organizar experimentos - Os experimentos estruturam a experimentação com uma entidade de nível superior chamada experimentar que contém um conjunto de ensaios. Cada tentativa contém um conjunto de etapas chamado componentes de teste. Cada componente de teste é uma combinação de conjuntos de dados, algoritmos e parâmetros. Você pode imaginar experimentos como a pasta de nível superior para organizar suas hipóteses, seus ensaios como subpastas para cada execução de teste de grupo e seus componentes de avaliação como seus arquivos para cada instância de uma execução de teste.
• Acompanhar experimentos - Experimentos permite que cientistas de dados rastreiem experimentos. Ele oferece a possibilidade de atribuir automaticamente trabalhos do SageMaker a um teste por meio de configurações simples e por meio dos SDKs de rastreamento.
• Comparar e avaliar experimentos - A integração de Experimentos com Estúdio Amazon SageMaker facilita a produção de visualizações de dados e a comparação de diferentes testes. Você também pode acessar os dados de avaliação por meio do SDK do Python para gerar sua própria visualização usando suas bibliotecas de plotagem preferidas.

Para saber mais sobre APIs e SDKs de experimentos, recomendamos a seguinte documentação: CriarExperiência e O Amazon SageMaker experimenta o SDK do Python.

Se você quiser mergulhar mais fundo, recomendamos olhar para o Amazon-sagemaker-examples/sagemaker-experiments Repositório GitHub para mais exemplos.

Integração entre pipelines e experimentos

Os pipelines de construção de modelo que fazem parte do Pipelines são desenvolvidos especificamente para ML e permitem que você orquestre suas tarefas de construção de modelo usando uma ferramenta de pipeline que inclui integrações nativas com outros recursos do SageMaker, bem como a flexibilidade de estender seu pipeline com etapas executadas fora do SageMaker . Cada etapa define uma ação que o pipeline executa. As dependências entre as etapas são definidas por um gráfico acíclico direto (DAG) criado usando o Pipelines Python SDK. Você pode criar um pipeline do SageMaker programaticamente por meio do mesmo SDK. Após a implantação de um pipeline, você pode, opcionalmente, visualizar seu fluxo de trabalho no Studio.

Os pipelines se integram automaticamente com os Experiments criando automaticamente um experimento e uma avaliação para cada execução. Os pipelines criam automaticamente um experimento e um teste para cada execução do pipeline antes de executar as etapas, a menos que uma ou ambas as entradas sejam especificadas. Ao executar o trabalho do SageMaker do pipeline, o pipeline associa o teste ao experimento e associa ao teste todos os componentes de teste criados pelo trabalho. Especificar seu próprio experimento ou teste programaticamente permite que você ajuste como organizar seus experimentos.

O fluxo de trabalho que apresentamos neste exemplo consiste em uma série de etapas: uma etapa de pré-processamento para dividir nosso conjunto de dados de entrada em conjuntos de dados de treinamento, teste e validação; uma etapa de ajuste para ajustar nossos hiperparâmetros e iniciar trabalhos de treinamento para treinar um modelo usando o Algoritmo integrado XGBoost; e, finalmente, uma etapa de modelo para criar um modelo do SageMaker a partir do artefato de modelo mais bem treinado. Pipelines também oferece vários suportes nativos tipos de passos fora do que é discutido neste post. Também ilustramos como você pode acompanhar seu fluxo de trabalho de pipeline e gerar métricas e gráficos de comparação. Além disso, mostramos como associar o novo teste gerado a um experimento existente que pode ter sido criado antes da definição do pipeline.

Código SageMaker Pipelines

Você pode revisar e baixar o notebook do Repositório GitHub associado a esta postagem. Analisamos o código específico do Pipelines para entendê-lo melhor.

Pipelines permite passar parâmetros em tempo de execução. Aqui definimos os tipos e contagens de instâncias de processamento e treinamento em tempo de execução com padrões predefinidos:

base_job_prefix = "pipeline-experiment-sample"
model_package_group_name = "pipeline-experiment-model-package"

processing_instance_count = ParameterInteger(
  name="ProcessingInstanceCount", default_value=1
)

training_instance_count = ParameterInteger(
  name="TrainingInstanceCount", default_value=1
)

processing_instance_type = ParameterString(
  name="ProcessingInstanceType", default_value="ml.m5.xlarge"
)
training_instance_type = ParameterString(
  name="TrainingInstanceType", default_value="ml.m5.xlarge"
)

Em seguida, configuramos um script de processamento que baixa e divide o conjunto de dados de entrada em partes de treinamento, teste e validação. Nós usamos SKLearnProcessor para executar esta etapa de pré-processamento. Para isso, definimos um objeto processador com o tipo de instância e a contagem necessária para executar o trabalho de processamento.

Pipelines nos permite obter versionamento de dados de forma programática usando variáveis ​​específicas de execução como ExecutionVariables.PIPELINE_EXECUTION_ID, que é o ID exclusivo de uma execução de pipeline. Podemos, por exemplo, criar uma chave única para armazenar os conjuntos de dados de saída em Serviço de armazenamento simples da Amazon (Amazon S3) que os vincula a uma execução de pipeline específica. Para obter a lista completa de variáveis, consulte Variáveis ​​de Execução.

framework_version = "0.23-1"

sklearn_processor = SKLearnProcessor(
    framework_version=framework_version,
    instance_type=processing_instance_type,
    instance_count=processing_instance_count,
    base_job_name="sklearn-ca-housing",
    role=role,
)

process_step = ProcessingStep(
    name="ca-housing-preprocessing",
    processor=sklearn_processor,
    outputs=[
        ProcessingOutput(
            output_name="train",
            source="/opt/ml/processing/train",
            destination=Join(
                on="/",
                values=[
                    "s3://{}".format(bucket),
                    prefix,
                    ExecutionVariables.PIPELINE_EXECUTION_ID,
                    "train",
                ],
            ),
        ),
        ProcessingOutput(
            output_name="validation",
            source="/opt/ml/processing/validation",
            destination=Join(
                on="/",
                values=[
                    "s3://{}".format(bucket),
                    prefix,
                    ExecutionVariables.PIPELINE_EXECUTION_ID,
                    "validation",
                ],
            )
        ),
        ProcessingOutput(
            output_name="test",
            source="/opt/ml/processing/test",
            destination=Join(
                on="/",
                values=[
                    "s3://{}".format(bucket),
                    prefix,
                    ExecutionVariables.PIPELINE_EXECUTION_ID,
                    "test",
                ],
            )
        ),
    ],
    code="california-housing-preprocessing.py",
)

Em seguida, passamos a criar um objeto estimador para treinar um modelo XGBoost. Definimos alguns hiperparâmetros estáticos que são comumente usados ​​com o XGBoost:

model_path = f"s3://{default_bucket}/{base_job_prefix}/ca-housing-experiment-pipeline"

image_uri = sagemaker.image_uris.retrieve(
    framework="xgboost",
    region=region,
    version="1.2-2",
    py_version="py3",
    instance_type=training_instance_type,
)

xgb_train = Estimator(
    image_uri=image_uri,
    instance_type=training_instance_type,
    instance_count=training_instance_count,
    output_path=model_path,
    base_job_name=f"{base_job_prefix}/ca-housing-train",
    sagemaker_session=sagemaker_session,
    role=role,
)

xgb_train.set_hyperparameters(
    eval_metric="rmse",
    objective="reg:squarederror",  # Define the object metric for the training job
    num_round=50,
    max_depth=5,
    eta=0.2,
    gamma=4,
    min_child_weight=6,
    subsample=0.7
)

Fazemos o ajuste de hiperparâmetros dos modelos que criamos usando um ContinuousParameter alcance para lambda. Escolher uma métrica para ser a métrica objetiva informa ao sintonizador (a instância que executa os trabalhos de ajuste de hiperparâmetros) que você avaliará o trabalho de treinamento com base nessa métrica específica. O sintonizador retorna a melhor combinação com base no melhor valor para essa métrica objetiva, ou seja, a melhor combinação que minimiza o melhor erro quadrático médio (RMSE).

objective_metric_name = "validation:rmse"

hyperparameter_ranges = {
    "lambda": ContinuousParameter(0.01, 10, scaling_type="Logarithmic")
}

tuner = HyperparameterTuner(estimator,
                            objective_metric_name,
                            hyperparameter_ranges,
                            objective_type=objective_type,
                            strategy="Bayesian",
                            max_jobs=10,
                            max_parallel_jobs=3)

tune_step = TuningStep(
    name="HPTuning",
    tuner=tuner_log,
    inputs={
        "train": TrainingInput(
            s3_data=process_step.properties.ProcessingOutputConfig.Outputs[
                "train"
            ].S3Output.S3Uri,
            content_type="text/csv",
        ),
        "validation": TrainingInput(
            s3_data=process_step.properties.ProcessingOutputConfig.Outputs[
                "validation"
            ].S3Output.S3Uri,
            content_type="text/csv",
        ),
    } 
)

A etapa de ajuste executa várias tentativas com o objetivo de determinar o melhor modelo entre as faixas de parâmetros testadas. Com o método get_top_model_s3_uri, classificamos as 50 versões com melhor desempenho do URI S3 do artefato de modelo e extraímos apenas a versão com melhor desempenho (especificamos k=0 para o melhor) para criar um modelo SageMaker.

model_bucket_key = f"{default_bucket}/{base_job_prefix}/ca-housing-experiment-pipeline"
model_candidate = Model(
    image_uri=image_uri,
    model_data=tune_step.get_top_model_s3_uri(top_k=0, s3_bucket=model_bucket_key),
    sagemaker_session=sagemaker_session,
    role=role,
    predictor_cls=XGBoostPredictor,
)

create_model_step = CreateModelStep(
    name="CreateTopModel",
    model=model_candidate,
    inputs=sagemaker.inputs.CreateModelInput(instance_type="ml.m4.large"),
)

Quando o pipeline é executado, ele cria componentes de avaliação para cada trabalho de ajuste de hiperparâmetro e cada trabalho do SageMaker criado pelas etapas do pipeline.

Você pode configurar ainda mais a integração de pipelines com Experiments criando um PipelineExperimentConfig objeto e passá-lo para o objeto pipeline. Os dois parâmetros definem o nome do experimento que será criado e o teste que fará referência a toda a execução do pipeline.

Se você quiser associar uma execução de pipeline a um experimento existente, poderá passar seu nome e o Pipelines associará o novo teste a ele. Você pode impedir a criação de um experimento e uma avaliação para um pipeline executado definindo pipeline_experiment_config para None.

#Pipeline experiment config
ca_housing_experiment_config = PipelineExperimentConfig(
    experiment_name,
    Join(
        on="-",
        values=[
            "pipeline-execution",
            ExecutionVariables.PIPELINE_EXECUTION_ID
        ],
    )
)

Passamos os tipos de instância e contagens como parâmetros e encadeamos as etapas anteriores na ordem a seguir. O fluxo de trabalho do pipeline é definido implicitamente pelas saídas de uma etapa sendo as entradas de outra etapa.

pipeline_name = f"CAHousingExperimentsPipeline"

pipeline = Pipeline(
    name=pipeline_name,
    pipeline_experiment_config=ca_housing_experiment_config,
    parameters=[
        processing_instance_count,
        processing_instance_type,
        training_instance_count,
        training_instance_type
    ],
    steps=[process_step,tune_step,create_model_step],
)

O pipeline completo agora está criado e pronto para ser usado. Adicionamos uma função de execução ao pipeline e o iniciamos. A partir daqui, podemos ir para o console do SageMaker Studio Pipelines e acompanhar visualmente cada etapa. Você também pode acessar os logs vinculados do console para depurar um pipeline.

pipeline.upsert(role_arn=sagemaker.get_execution_role())
execution = pipeline.start()

A captura de tela anterior mostra em verde um pipeline executado com êxito. Obtemos as métricas de um teste de uma execução do pipeline com o seguinte código:

# SM Pipeline injects the Execution ID into trial component names
execution_id = execution.describe()['PipelineExecutionArn'].split('/')[-1]
source_arn_filter = Filter(
    name="TrialComponentName", operator=Operator.CONTAINS, value=execution_id
)

source_type_filter = Filter(
    name="Source.SourceType", operator=Operator.EQUALS, value="SageMakerTrainingJob"
)

search_expression = SearchExpression(
    filters=[source_arn_filter, source_type_filter]
)

trial_component_analytics = ExperimentAnalytics(
    sagemaker_session=sagemaker_session,
    experiment_name=experiment_name,
    search_expression=search_expression.to_boto()
)

analytic_table = trial_component_analytics.dataframe()
analytic_table.head()

Compare as métricas para cada componente de avaliação

Você pode plotar os resultados do ajuste de hiperparâmetros no Studio ou por meio de outras bibliotecas de plotagem do Python. Mostramos as duas maneiras de fazer isso.

Explore as métricas de treinamento e avaliação no Studio

O Studio fornece uma interface de usuário interativa onde você pode gerar plotagens interativas. Os passos são os seguintes:

1. Escolha Experimentos e testes do Recursos do SageMaker ícone na barra lateral esquerda.
2. Escolha seu experimento para abri-lo.
3. Escolha (clique com o botão direito do mouse) a avaliação de interesse.
4. Escolha Abrir na lista de componentes de teste.
5. Press Shift para selecionar os componentes de avaliação que representam os trabalhos de treinamento.
6. Escolha Adicionar gráfico.
7. Escolha Novo gráfico e personalize-o para traçar as métricas coletadas que você deseja analisar. Para nosso caso de uso, escolha o seguinte:
   1. Escolha Tipo de dados¸ selecionar Estatísticas resumidas.
   2. Escolha tipo de gráfico¸ selecionar Gráfico de dispersão.
   3. Escolha Eixo X, escolha lambda.
   4. Escolha Eixo Y, escolha validation:rmse_last.

O novo gráfico aparece na parte inferior da janela, rotulado como '8'.

Você pode incluir mais ou menos trabalhos de treinamento pressionando Shift e escolhendo o ícone do olho para uma experiência mais interativa.

Análise com experiências do SageMaker

Quando a execução do pipeline estiver concluída, podemos visualizar rapidamente como as diferentes variações do modelo se comparam em termos das métricas coletadas durante o treinamento. Anteriormente, exportamos todas as métricas de teste para um Pandas DataFrame utilização ExperimentAnalytics. Podemos reproduzir o gráfico obtido no Studio usando a biblioteca Matplotlib.

analytic_table.plot.scatter("lambda", "validation:rmse - Last", grid=True)

Conclusão

A integração nativa entre o SageMaker Pipelines e o SageMaker Experiments permite que os cientistas de dados organizem, rastreiem e visualizem experimentos automaticamente durante as atividades de desenvolvimento do modelo. Você pode criar experimentos para organizar todo o seu trabalho de desenvolvimento de modelo, como o seguinte:

• Um caso de uso de negócios que você está abordando, como criar um experimento para prever a perda de clientes
• Um experimento de propriedade da equipe de ciência de dados em relação à análise de marketing, por exemplo
• Um projeto específico de ciência de dados e ML

Neste post, mergulhamos no Pipelines para mostrar como você pode usá-lo em conjunto com os Experiments para organizar um fluxo de trabalho de ponta a ponta totalmente automatizado.

Como próxima etapa, você pode usar esses três recursos do SageMaker – Studio, Experiments e Pipelines – para seu próximo projeto de ML.

Leituras sugeridas

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.

Mário Bourgoin é arquiteto de soluções de parceiro sênior da AWS, especialista em IA/ML e líder de tecnologia global para MLOps. Ele trabalha com clientes e parceiros corporativos que implementam soluções de IA na nuvem. Ele tem mais de 30 anos de experiência em aprendizado de máquina e IA em startups e empresas, começando com a criação de um dos primeiros sistemas comerciais de aprendizado de máquina para big data. Mario passa seu tempo livre brincando com seus três Tervurens belgas, cozinhando o jantar para sua família e aprendendo sobre matemática e cosmologia.

Ganapathi Krishnamoorthi é arquiteto de soluções de ML sênior na AWS. A Ganapathi fornece orientação prescritiva para clientes iniciantes e corporativos, ajudando-os a projetar e implantar aplicativos em nuvem em escala. Ele é especializado em aprendizado de máquina e está focado em ajudar os clientes a aproveitar a IA/ML para seus resultados de negócios. Quando não está no trabalho, ele gosta de explorar o ar livre e ouvir música.

Valerie Soundhakith é arquiteto de soluções da AWS, trabalhando no setor de jogos e com parceiros que implantam soluções de IA. Ela pretende construir sua carreira em torno da Visão Computacional. Durante seu tempo livre, Valerie o gasta para viajar, descobrir novos lugares para comer e mudar o interior de sua casa.