O blog da AWS

Personalização e reutilização de modelos gerados pelo Amazon SageMaker Autopilot

Por Simon Zamarin, Piali Das e Qingwei Li

 

O Amazon SageMaker Autopilot treina e ajusta automaticamente os melhores modelos de aprendizado de máquina (ML) para problemas de classificação ou regressão e ao mesmo tempo permite que você mantenha controle total e visibilidade. Isto não só permite que analistas de dados, desenvolvedores e cientistas de dados treinem, ajustem e implantem modelos com pouco ou nenhum código, mas você pode também revisar um notebook gerado que descreve todas as etapas que o Autopilot considerou para gerar o modelo. Em alguns casos, você também pode querer personalizar pipelines gerados pelo Autopilot com seus próprios componentes personalizados.

Esta publicação mostra como criar e usar modelos com o Autopilot em alguns cliques e, em seguida, descreve como adaptar o código gerado pelo SageMaker Autopilot com seus próprios seletores de recursos e transformadores personalizados para adicionar recursos de domínios específicos. Também usamos a capacidade de executar um ensaio completo do Autopilot, no qual o Autopilot gera apenas código para pré-processadores de dados, algoritmos e configurações de parâmetros de algoritmo. Isso pode ser feito simplesmente escolhendo a opção de executar um piloto para criar um notebook com definições candidatas.

 

 

Personalizando o Autopilot

Personalizar modelos do Autopilot é, na maioria dos casos, não necessário. O Autopilot cria modelos de alta qualidade que podem ser implantados sem a necessidade de personalização. O Autopilot executa automaticamente a análise exploratória dos seus dados e decide quais recursos podem produzir os melhores resultados. Como tal, apresenta uma baixa barreira de entrada ao ML para uma ampla gama de usuários, desde analistas de dados a desenvolvedores, que desejam adicionar recursos de AI/ML ao seu projeto.

No entanto, usuários mais avançados podem aproveitar a abordagem transparente do AutoPilot para AutoML para reduzir drasticamente o trabalho pesado indiferenciado prevalente em projetos de ML. Por exemplo, você pode querer que o Autopilot use transformações de recursos personalizados que sua empresa utiliza, ou técnicas de imputação personalizadas que funcionam melhor no contexto de seus dados. Você pode pré-processar seus dados antes de trazê-lo para o SageMaker Autopilot, mas isso envolveria sair do Autopilot e manter um pipeline de pré-processamento separado. Como alternativa, você pode usar o pipeline de processamento de dados do Autopilot para direcionar o Autopilot para usar suas transformações e imputações personalizadas. A vantagem dessa abordagem é que você pode se concentrar na coleta de dados e permitir que o Autopilot faça o trabalho pesado de aplicar as transformações e imputações de recursos desejadas e, em seguida, encontrar e implantar o melhor modelo.

 

Preparando seus dados e o Autopilot job

Vamos começar criando um experimento no Autopilot usando o conjunto de dados Tipos de Cobertura de Florestas.

  1. Faça o download do conjunto de dados e faça o upload para o Amazon Simple Storage Service (Amazon S3).

Certifique-se de criar seu usuário do Amazon SageMaker Studio na mesma região que o bucket do S3.

2. Abra o SageMaker Studio.

3. Crie um job, fornecendo as seguintes informações:

a. Nome do experimento

b. Localização do conjunto de dados de treinamento

c. Bucket S3 para salvar dados de saída do Autopilot

d. Tipo de problema de ML

Seu job do Autopilot está pronto para ser executado. Em vez de executar um experimento completo, optamos por permitir que o Autopilot ofereça um notebook com definições candidatas.

 

 

Inspecionando os pipelines gerados pelo Autopilot

O SageMaker Autopilot automatiza as principais tarefas em um pipeline de ML. Ele explora centenas de modelos compostos por diferentes recursos, algoritmos e hiperparâmetros para encontrar o que melhor se adapta aos seus dados. Ele também fornece os 250 melhores modelos para que você possa ver como foi a performance de cada modelo candidato e escolher o melhor para implantar. Exploramos isso em mais profundidade na seção final desta publicação.

Quando o experimento estiver concluído, você pode inspecionar os pipelines candidatos gerados. Candidato refere-se à combinação de etapas de pré-processamento de dados e seleção de algoritmos usados para treinar os 250 modelos. O notebook de geração de candidatos contém código Python usado pelo Autopilot para gerar esses candidatos.

  1. Escolha Abrir notebook de geração de candidatos.
  2. Abra o seu notebook.
  3. Escolha Importar para importar o notebook para o seu espaço de trabalho.
  4. Quando solicitado, escolha Python 3 (Data Science) como o kernel.
  5. Dentro do notebook, execute todas as células na Configuração do SageMaker

 

 

Isso copia o código de preparação de dados gerado pelo Autopilot em seu espaço de trabalho.

No seu diretório raiz do SageMaker Studio, agora você deve ver uma pasta com o nome do seu experimento de piloto Autopilot. O nome da pasta deve ser <Your Experiment Name>–artifacts. Esse diretório contém dois subdiretórios: generated_module e sagemaker_automl. O diretório generated_module contém os artefatos de processamento de dados gerados pelo Autopilot.

Até agora, o job do Autopilot analisou o conjunto de dados e gerou pipelines ML candidatos que contêm um conjunto de transformadores de recursos e um algoritmo ML. Navegue pela pasta generated_module até o diretório candidate_data_processors, que contém 12 arquivos:

  • dpp0.py—dpp9.py — Candidatos de processamento de dados gerados pelo Autopilot
  • trainer.py — Script que executa os candidatos ao processamento de dados
  • sagemaker_serve.py — Script para executar o pipeline de pré-processamento durante a inferência

 

 

Se você examinar qualquer um dos arquivos dpp*.py, você pode observar que o código gerado pelo Autopilot que cria pipelines sckit-learn , os quais você pode facilmente estender com suas próprias transformações. Você pode fazer isso modificando diretamente os arquivos dpp*.py existentes ou estendendo os pipelines depois que eles são instanciados no arquivo trainer.py, no qual você define um transformador que pode ser chamado dentro dos arquivos dpp*.py existentes. A segunda abordagem é recomendada porque é mais sustentável e permite que você estenda todos os pipelines de processamento propostos de uma só vez em vez de modificar cada um individualmente.

 

Usando transformadores específicos

Você pode querer chamar um transformador específico do sckit-learn ou usar um implementado no pacote de código aberto sagemaker-scikit-learn-extension. Este último fornece uma série de estimadores e transformadores compatíveis com scikit-learning que você pode usar. Por exemplo, ele implementa o codificador Weight of Evidence (WoE), uma codificação frequentemente usada para características categóricas no contexto da classificação binária.

Para usar transformadores adicionais, primeiro estenda as instruções de importação no arquivo trainer.py . Para o nosso caso de uso, adicionamos o seguinte código:

from sklearn.pipeline import FeatureUnion, Pipeline

from sklearn.ensemble import RandomForestClassifier

from sklearn.feature_selection import selectFromModel

from sagemaker_sklearn_extension.preprocessing import RobustStandardScaler

Se, ao modificar trainer.py, você encontrar erros ao executar a célula do notebook contendo automl_interactive_runner.fit_data_transformers (...), você pode obter informações de depuração do Amazon CloudWatch no grupo de logs /AWS/SageMaker/TrainingJobs.

Implementação de transformadores personalizados

Voltando ao caso de uso do tipo de cobertura florestal, temos recursos para a distância vertical e horizontal à hidrologia. Queremos estender isso com uma transformação de recurso adicional que calcula a distância da linha reta à hidrologia. Podemos fazer isso adicionando um arquivo adicional no diretório candidate_data_processors onde definimos nossa transformação personalizada. Consulte o seguinte código:

# additional_features.py

import numpy as np

from sklearn.base import BaseEstimator, TransformerMixin




class HydrologyDistance (BaseEstimator, TransformerMixin):




def __init__ (self, feature_index):

self._feature_index=feature_index




def fit (self, X, y = None):

return self




def transform (self, X, y = None):

X = X.copy() .astype(np.float32)

a, b = np.split (X [:, self._feature_index], 2, axis=1)

return np.hypot (a, b).reshape (-1,1)

Dentro do arquivo trainer.py , importamos o módulo additional_features e adicionamos nosso transformador HydrologyDistance como um pipeline paralelo aos gerados existentes.

Além do nosso transformador de recursos adicionais, também adicionamos um seletor de recursos ao nosso pipeline para selecionar apenas os recursos com a maior importância, conforme determinado no RandomForestClassifier:

def update_feature_transformer (header, feature_transformer):

“" "Personalize o transformador de recursos. Devoluções padrão




cabeçalho: SageMaker_SKLEARN_Extension.Externals.Header

Objeto da classe Header, usado para mapear os nomes das colunas para o índice apropriado




feature_transformer: obj

transformador aplicado às características




Devoluções

—

feature_transformer: obj

transformador atualizado a ser aplicado às características

“"”




features_to_transform = header.as_feature_indices (

[

'Horizontal_Distance_To_Hydrology',

'Vertical_Distance_To_Hydrology'

]

)




# novo pipeline com transformações personalizadas

additional_pipeline = Pipeline ([(“distance”, HydrologyDistance (features_to_transform)),

(“ScaleDistance”, RobustStandardScaler ())

])

# combinar com o pipeline gerado pelo Autopilot

combined_transformer = FeatureUnion ([(“additional”, additional_pipeline),

(“existente”, feature_transformer)]

)

# executar a seleção de recursos no pipeline combinado

feature_selector=SelectFromModel (RandomForestClassifier (n_estimators = 10))




feature_transformer = Pipeline ([(“feature_engineering”, combined_transformer),

(“feature_selection”, feature_selector)]

)

return feature_transformerfrom additional_features import *

 

Executando inferências

Em seguida, precisamos copiar nosso arquivo additional_features.py para o diretório do modelo para torná-lo disponível no momento da inferência. Uma função serialize_code é fornecida especificamente para isso. Modifique a função de acordo com o código de exemplo a seguir para se certificar de que ela está incluída no artefato do modelo. A linha de código que requer modificação é realçada.

def serialize_code (dest_dir, processor_file):

“" "Copia o código necessário para inferência no diretório de destino

Por padrão, sagemaker_serve.py e o arquivo do módulo do processador são copiados.

Para serializar qualquer arquivo .py adicional para transformações personalizadas, adicione-o a

lista files_to_serialize.




dest_dir: str

destino onde os arquivos python serão serializados




“"”

files_to_serialize = [

os.path.join (os.path.dirname (__file__), 'sagemaker_serve.py'),

processor_file]




# Inclua o código personalizado do transformador no diretório do modelo

files_to_serialize.append (os.path.join (os.path.dirname (__file__), 'additional_features.py'))




os.makedirs (dest_dir, exist_OK=true)

for source in files_to_serialize:

shutil.copy (source, os.path.join (dest_dir, os.path.basename (source)))

Finalmente precisamos modificar a função model_fn em sagemaker_serve.py para copiar o arquivo additional_features.py para o diretório de trabalho atual para que o pipeline scikit-learn possa importar o arquivo no momento da inferência:

import shutil # verifique se isto é importado para que o arquivo possa ser copiado

def model_fn (model_dir):

“" "Carrega o modelo.




O servidor do modelo SageMaker Scikit-Learn carrega o modelo invocando este método.




Parâmetros

—

model_dir: str

o diretório onde os arquivos de modelo residem




Devoluções

—

: AutomlTransformer

objeto do modelo de-serializado que pode ser usado para servir o modelo




“"”




shutil.copyfile (os.path.join (model_dir, 'additional_features.py'), 'additional_features.py')




return load (filename=os.path.join (model_dir, 'model.joblib')

 

Quando terminar todas essas etapas, você pode retornar ao notebook de definição candidato e executar as células restantes. As transformações adicionais definidas são aplicadas em todos os candidatos do pipeline de processamento de dados selecionados e também são incluídas no pipeline de inferência.

 

Implantando o melhor modelo

À medida que o Autopilot executa os pipelines candidatos, ele itera mais de 250 combinações de pipelines de processamento, tipos de algoritmos e hiperparâmetros de modelo. Quando o processo estiver concluído, você pode navegar até a seção final do notebook (Seleção de Modelo e Implantação) e visualizar uma tabela de classificação dos modelos Autopilot gerados. A execução das células de notebook restantes implanta automaticamente o modelo que produziu os melhores resultados e o expõe como um endpoint REST API.

 

 

Conclusões

Nesta publicação, demonstramos como personalizar um pipeline de treinamento e inferência do Autopilot com seu próprio código de engenharia de recursos. Primeiro deixamos o Autopilot gerar definições candidatas sem executar o treinamento real e o ajuste de hiperparâmetros. Em seguida, implementamos transformadores personalizados que representam engenharia de recursos personalizados que queremos trazer para o Autopilot. Para obter mais informações sobre o Autopilot, consulte Amazon SageMaker Autopilot.

 

Este artigo foi traduzido do Blog da AWS em Inglês.

 

Sobre os Autores

Simon Zamarin é um arquiteto de soluções de AI/ML cujo foco principal é ajudar os clientes a extrair valor de seus ativos de dados. Em seu tempo livre, Simon gosta de passar tempo com a família, ler ficção científica e trabalhar em vários projetos de casa DIY(Faça você mesmo).

 

 

 

 

Qingwei Li é especialista em aprendizado de máquina na Amazon Web Services. Ele recebeu seu Ph.D. em Pesquisa de Operações depois que ele quebrou a conta de bolsa de pesquisa de seu conselheiro e não conseguiu entregar o Prêmio Nobel que ele prometeu. Atualmente, ele ajuda os clientes do setor de serviços financeiros e seguros a criar soluções de machine learning na AWS. Em seu tempo livre, ele gosta de ler e ensinar.

 

 

 

Piali Das é engenheiro sênior de software na equipe do AWS SageMaker Autopilot. Ela já contribuiu para a construção de Algoritmos SageMaker. Ela gosta de programação científica em geral e desenvolveu um interesse em aprendizado de máquina e sistemas distribuídos.

 

 

 

Revisor

Tiago Simão é Arquiteto de Soluções na AWS Brasil.