Previsão de rotatividade usando algoritmos tabulares integrados do Amazon SageMaker LightGBM, CatBoost, TabTransformer e AutoGluon-Tabular

Amazon Sage Maker oferece um conjunto de algoritmos integrados, modelos pré-treinados e modelos de solução pré-criados para ajudar cientistas de dados e profissionais de machine learning (ML) a começar a treinar e implantar modelos de ML rapidamente. Esses algoritmos e modelos podem ser usados ​​para aprendizado supervisionado e não supervisionado. Eles podem processar vários tipos de dados de entrada, incluindo tabular, imagem e texto.

A rotatividade de clientes é um problema enfrentado por uma ampla gama de empresas, de telecomunicações a bancos, onde os clientes normalmente são perdidos para os concorrentes. É do interesse de uma empresa reter os clientes existentes em vez de adquirir novos clientes, porque geralmente custa muito mais atrair novos clientes. As operadoras de telefonia móvel têm registros históricos em que os clientes continuaram usando o serviço ou acabaram saindo. Podemos usar essas informações históricas do churn de uma operadora móvel para treinar um modelo de ML. Depois de treinar esse modelo, podemos passar as informações de perfil de um cliente arbitrário (as mesmas informações de perfil que usamos para treinar o modelo) para o modelo e fazer com que ele preveja se esse cliente vai sair ou não.

Neste post, treinamos e implantamos quatro algoritmos SageMaker lançados recentemente— LightGBM, CatBoost, TabTransformer e AutoGluon-Tabular — em um conjunto de dados de previsão de rotatividade. Nós usamos Ajuste automático de modelos do SageMaker (uma ferramenta para otimização de hiperparâmetros) para encontrar os melhores hiperparâmetros para cada modelo e comparar seu desempenho em um conjunto de dados de teste de validação para selecionar o ideal.

Você também pode usar essa solução como um modelo para pesquisar uma coleção de algoritmos tabulares de última geração e usar a otimização de hiperparâmetros para encontrar o melhor modelo geral. Você pode substituir facilmente o conjunto de dados de exemplo pelo seu próprio para resolver problemas reais de negócios nos quais está interessado. exemplo de notebook Jupyter.

Benefícios dos algoritmos integrados do SageMaker

Ao selecionar um algoritmo para seu tipo específico de problema e dados, usar um algoritmo integrado do SageMaker é a opção mais fácil, pois isso traz os seguintes benefícios principais:

• Codificação baixa – Os algoritmos integrados requerem pouca codificação para iniciar a execução de experimentos. As únicas entradas que você precisa fornecer são os dados, hiperparâmetros e recursos de computação. Isso permite que você execute experimentos mais rapidamente, com menos sobrecarga para rastrear resultados e alterações de código.
• Implementações de algoritmos eficientes e escaláveis – Os algoritmos integrados vêm com paralelização em várias instâncias de computação e suporte a GPU pronto para uso para todos os algoritmos aplicáveis. Se você tiver muitos dados para treinar seu modelo, a maioria dos algoritmos integrados pode ser dimensionada facilmente para atender à demanda. Mesmo se você já tiver um modelo pré-treinado, ainda pode ser mais fácil usar seu corolário no SageMaker e inserir os hiperparâmetros que você já conhece, em vez de portá-lo e escrever um script de treinamento você mesmo.
• Transparência – Você é o proprietário dos artefatos de modelo resultantes. Você pode pegar esse modelo e implantá-lo no SageMaker para vários padrões de inferência diferentes (confira todos os tipos de implantação disponíveis) e dimensionamento e gerenciamento fáceis de endpoints, ou você pode implantá-lo onde mais precisar.

Visualização e pré-processamento de dados

Primeiro, reunimos nosso conjunto de dados de rotatividade de clientes. É um conjunto de dados relativamente pequeno com 5,000 registros, onde cada registro usa 21 atributos para descrever o perfil de um cliente de uma operadora móvel desconhecida dos EUA. Os atributos variam desde o estado dos EUA em que o cliente reside, até o número de chamadas feitas para o atendimento ao cliente e o custo cobrado pelas chamadas diurnas. Estamos tentando prever se o cliente vai sair ou não, o que é um problema de classificação binária. Veja a seguir um subconjunto desses recursos, com o rótulo como a última coluna.

A seguir estão alguns insights para cada coluna, especificamente as estatísticas resumidas e o histograma dos recursos selecionados.

Em seguida, pré-processamos os dados, dividimos em conjuntos de treinamento, validação e teste e carregamos os dados para Serviço de armazenamento simples da Amazon (Amazônia S3).

Ajuste automático do modelo de algoritmos tabulares

Os hiperparâmetros controlam como nossos algoritmos subjacentes operam e influenciam o desempenho do modelo. Esses hiperparâmetros podem ser o número de camadas, taxa de aprendizado, taxa de decaimento de peso e abandono para modelos baseados em rede neural ou o número de folhas, iterações e profundidade máxima da árvore para modelos de conjunto de árvores. Para selecionar o melhor modelo, aplicamos o ajuste de modelo automático do SageMaker a cada um dos quatro algoritmos tabulares treinados do SageMaker. Você só precisa selecionar os hiperparâmetros a serem ajustados e um intervalo para cada parâmetro a ser explorado. Para obter mais informações sobre o ajuste automático do modelo, consulte Amazon SageMaker Ajuste automático de modelo: usando aprendizado de máquina para aprendizado de máquina or Ajuste automático do modelo do Amazon SageMaker: otimização escalável sem gradiente.

Vamos ver como isso funciona na prática.

Light GBM

Começamos executando o ajuste automático de modelos com o LightGBM e adaptamos esse processo aos outros algoritmos. Como está explicado no post Modelos e algoritmos do Amazon SageMaker JumpStart agora disponíveis via API, os seguintes artefatos são necessários para treinar um algoritmo pré-criado por meio do SDK do SageMaker:

• Sua imagem de contêiner específica do framework, contendo todas as dependências necessárias para treinamento e inferência
• Os scripts de treinamento e inferência para o modelo ou algoritmo selecionado

Primeiro recuperamos esses artefatos, que dependem da model_id (lightgbm-classification-model neste caso) e versão:

from sagemaker import image_uris, model_uris, script_uris
train_model_id, train_model_version, train_scope = "lightgbm-classification-model", "*", "training"
training_instance_type = "ml.m5.4xlarge"

# Retrieve the docker image
train_image_uri = image_uris.retrieve(region=None,
                                      framework=None,
                                      model_id=train_model_id,
                                      model_version=train_model_version,
                                      image_scope=train_scope,
                                      instance_type=training_instance_type,
                                      )                                      
# Retrieve the training script
train_source_uri = script_uris.retrieve(model_id=train_model_id,
                                        model_version=train_model_version,
                                        script_scope=train_scope
                                        )
# Retrieve the pre-trained model tarball (in the case of tabular modeling, it is a dummy file)
train_model_uri = model_uris.retrieve(model_id=train_model_id,
                                      model_version=train_model_version,
                                      model_scope=train_scope)

Em seguida, obtemos os hiperparâmetros padrão para LightGBM, definimos alguns deles para valores fixos selecionados, como número de rodadas de reforço e métrica de avaliação nos dados de validação, e definimos os intervalos de valores que queremos pesquisar para outros. Usamos os parâmetros do SageMaker ContinuousParameter e IntegerParameter por esta:

from sagemaker import hyperparameters
from sagemaker.tuner import ContinuousParameter, IntegerParameter, HyperparameterTuner

# Retrieve the default hyper-parameters for fine-tuning the model
hyperparameters = hyperparameters.retrieve_default(model_id=train_model_id,
                                                   model_version=train_model_version
                                                   )
# [Optional] Override default hyperparameters with custom values
hyperparameters["num_boost_round"] = "500"
hyperparameters["metric"] = "auc"

# Define search ranges for other hyperparameters
hyperparameter_ranges_lgb = {
    "learning_rate": ContinuousParameter(1e-4, 1, scaling_type="Logarithmic"),
    "num_boost_round": IntegerParameter(2, 30),
    "num_leaves": IntegerParameter(10, 50),
    "feature_fraction": ContinuousParameter(0, 1),
    "bagging_fraction": ContinuousParameter(0, 1),
    "bagging_freq": IntegerParameter(1, 10),
    "max_depth": IntegerParameter(5, 30),
    "min_data_in_leaf": IntegerParameter(5, 50),
}

Por fim, criamos um Avaliador do SageMaker, alimente-o em um Sintonizador de Hiperarâmetroe inicie o trabalho de ajuste de hiperparâmetro com tuner.fit():

from sagemaker.estimator import Estimator
from sagemaker.tuner import HyperParameterTuner

# Create SageMaker Estimator instance
tabular_estimator = Estimator(
    role=aws_role,
    image_uri=train_image_uri,
    source_dir=train_source_uri,
    model_uri=train_model_uri,
    entry_point="transfer_learning.py",
    instance_count=1,
    instance_type=training_instance_type,
    max_run=360000,
    hyperparameters=hyperparameters,
)

tuner = HyperparameterTuner(
            tabular_estimator,
            "auc",
            hyperparameter_ranges_lgb,
            [{"Name": "auc", "Regex": "auc: ([0-9.]+)"}],
            max_jobs=10,
            max_parallel_jobs=5,
            objective_type="Maximize",
            base_tuning_job_name="some_name",
        )

tuner.fit({"training": training_dataset_s3_path}, logs=True)

A max_jobs O parâmetro define quantos jobs totais serão executados no job de ajuste de modelo automático e max_parallel_jobs define quantos trabalhos de treinamento simultâneos devem ser iniciados. Também definimos o objetivo de “Maximize” a AUC do modelo (área sob a curva). Para mergulhar mais fundo nos parâmetros disponíveis expostos por HyperParameterTuner, referir-se HiperparâmetroTuner.

Confira o caderno de amostra para ver como procedemos para implantar e avaliar esse modelo no conjunto de teste.

Cat Boost

O processo para ajuste de hiperparâmetros no algoritmo CatBoost é o mesmo de antes, embora precisemos recuperar artefatos de modelo sob o ID catboost-classification-model e altere a seleção de intervalo de hiperparâmetros:

from sagemaker import hyperparameters

# Retrieve the default hyper-parameters for fine-tuning the model
hyperparameters = hyperparameters.retrieve_default(
    model_id=train_model_id, model_version=train_model_version
)
# [Optional] Override default hyperparameters with custom values
hyperparameters["iterations"] = "500"
hyperparameters["eval_metric"] = "AUC"

# Define search ranges for other hyperparameters
hyperparameter_ranges_cat = {
    "learning_rate": ContinuousParameter(0.00001, 0.1, scaling_type="Logarithmic"),
    "iterations": IntegerParameter(50, 1000),
    "depth": IntegerParameter(1, 10),
    "l2_leaf_reg": IntegerParameter(1, 10),
    "random_strength": ContinuousParameter(0.01, 10, scaling_type="Logarithmic"),
}

TabTransformador

O processo para ajuste de hiperparâmetros no modelo TabTransformer é o mesmo de antes, embora precisemos recuperar artefatos de modelo sob o ID pytorch-tabtransformerclassification-model e altere a seleção de intervalo de hiperparâmetros.

Também mudamos o treinamento instance_type para ml.p3.2xlarge. TabTransformer é um modelo recentemente derivado da pesquisa da Amazon, que traz o poder do aprendizado profundo para dados tabulares usando modelos Transformer. Para treinar esse modelo de maneira eficiente, precisamos de uma instância apoiada por GPU. Para mais informações, consulte Trazendo o poder do aprendizado profundo para dados em tabelas.

from sagemaker import hyperparameters
from sagemaker.tuner import CategoricalParameter

# Retrieve the default hyper-parameters for fine-tuning the model
hyperparameters = hyperparameters.retrieve_default(
    model_id=train_model_id, model_version=train_model_version
)
# [Optional] Override default hyperparameters with custom values
hyperparameters["n_epochs"] = 40  # The same hyperparameter is named as "iterations" for CatBoost
hyperparameters["patience"] = 10

# Define search ranges for other hyperparameters
hyperparameter_ranges_tab = {
    "learning_rate": ContinuousParameter(0.001, 0.01, scaling_type="Auto"),
    "batch_size": CategoricalParameter([64, 128, 256, 512]),
    "attn_dropout": ContinuousParameter(0.0, 0.8, scaling_type="Auto"),
    "mlp_dropout": ContinuousParameter(0.0, 0.8, scaling_type="Auto"),
    "input_dim": CategoricalParameter(["16", "32", "64", "128", "256"]),
    "frac_shared_embed": ContinuousParameter(0.0, 0.5, scaling_type="Auto"),
}

AutoGluon-Tabular

No caso do AutoGluon, não executamos o ajuste de hiperparâmetros. Isso ocorre por design, porque o AutoGluon se concentra em agrupar vários modelos com opções sensatas de hiperparâmetros e empilhá-los em várias camadas. Isso acaba sendo mais eficiente do que treinar um modelo com a seleção perfeita de hiperparâmetros e também é computacionalmente mais barato. Para detalhes, confira AutoGluon-Tabular: AutoML robusto e preciso para dados estruturados.

Por isso, trocamos o model_id para autogluon-classification-ensemble, e apenas corrija o hiperparâmetro da métrica de avaliação para nossa pontuação AUC desejada:

from sagemaker import hyperparameters

# Retrieve the default hyper-parameters for fine-tuning the model
hyperparameters = hyperparameters.retrieve_default(
    model_id=train_model_id, model_version=train_model_version
)

hyperparameters["eval_metric"] = "roc_auc"

Em vez de ligar tuner.fit(), nós chamamos estimator.fit() para iniciar um único trabalho de treinamento.

Benchmarking dos modelos treinados

Depois de implantar todos os quatro modelos, enviamos o conjunto de teste completo para cada endpoint para previsão e calculamos as métricas de precisão, F1 e AUC para cada (consulte o código no caderno de amostra). Apresentamos os resultados na tabela a seguir, com um aviso importante: os resultados e o desempenho relativo entre esses modelos dependerão do conjunto de dados usado para treinamento. Esses resultados são representativos, e mesmo que a tendência de certos algoritmos para um melhor desempenho seja baseada em fatores relevantes (por exemplo, o AutoGluon agrupa inteligentemente as previsões dos modelos LightGBM e CatBoost nos bastidores), o equilíbrio no desempenho pode mudar, dado um distribuição de dados.

Conclusão

Neste post, treinamos quatro algoritmos integrados diferentes do SageMaker para resolver o problema de previsão de perda de clientes com baixo esforço de codificação. Usamos o ajuste automático de modelos do SageMaker para encontrar os melhores hiperparâmetros para treinar esses algoritmos e comparamos seu desempenho em um conjunto de dados de previsão de rotatividade selecionado. Você pode usar o relacionado caderno de amostra como um modelo, substituindo o conjunto de dados pelo seu próprio para resolver o problema baseado em dados tabular desejado.

Certifique-se de experimentar esses algoritmos no SageMaker e confira exemplos de notebooks sobre como usar outros algoritmos integrados disponíveis em GitHub.

Sobre os autores

Dr.Xin Huang é um cientista aplicado para algoritmos integrados Amazon SageMaker JumpStart e Amazon SageMaker. Ele se concentra no desenvolvimento de algoritmos de aprendizado de máquina escaláveis. Seus interesses de pesquisa estão na área de processamento de linguagem natural, aprendizado profundo explicável em dados tabulares e análise robusta de agrupamento não paramétrico de espaço-tempo. Ele publicou muitos artigos em conferências ACL, ICDM, KDD e Royal Statistical Society: Series A journal.

João moura é arquiteto de soluções especialista em IA/ML na Amazon Web Services. Ele se concentra principalmente em casos de uso de PNL e em ajudar os clientes a otimizar o treinamento e a implantação de modelos de Deep Learning. Ele também é um defensor ativo de soluções de ML de baixo código e hardware especializado em ML.