View a markdown version of this page

Como usar o SageMaker AI XGBoost - SageMaker Inteligência Artificial da Amazon
Usar o XGBoost como uma frameworkUsar o XGBoost como um algoritmo integradoInput/Output interface para o algoritmo XGBoost

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á.

Como usar o SageMaker AI XGBoost

Com a SageMaker IA, você pode usar o XGBoost como um algoritmo ou estrutura embutida. Ao usar o XGBoost como framework, você tem maior flexibilidade e acesso a cenários mais avançados porque é possível personalizar seus próprios scripts de treinamento. As seções a seguir descrevem como usar o XGBoost com o SDK do SageMaker Python e a input/output interface do algoritmo XGBoost. Para obter informações sobre como usar o XGBoost na interface do usuário do Amazon SageMaker Studio Classic, consulte. SageMaker JumpStart modelos pré-treinados

Usar o XGBoost como uma framework

Use o XGBoost como um framework para executar scripts de treinamento personalizados que podem incorporar processamento de dados adicional aos trabalhos de treinamento. No exemplo de código a seguir, o SageMaker Python SDK fornece a API XGBoost como uma estrutura. Isso funciona de forma semelhante à forma como a SageMaker IA fornece outras APIs de estrutura TensorFlow, como MXNet e. PyTorch

import boto3
import sagemaker
from sagemaker.xgboost.estimator import XGBoost
from sagemaker.session import Session
from sagemaker.inputs import TrainingInput

# initialize hyperparameters
hyperparameters = {
        "max_depth":"5",
        "eta":"0.2",
        "gamma":"4",
        "min_child_weight":"6",
        "subsample":"0.7",
        "verbosity":"1",
        "objective":"reg:squarederror",
        "num_round":"50"}

# set an output path where the trained model will be saved
bucket = sagemaker.Session().default_bucket()
prefix = 'DEMO-xgboost-as-a-framework'
output_path = 's3://{}/{}/{}/output'.format(bucket, prefix, 'abalone-xgb-framework')

# construct a SageMaker AI XGBoost estimator
# specify the entry_point to your xgboost training script
estimator = XGBoost(entry_point = "your_xgboost_abalone_script.py", 
                    framework_version='1.7-1',
                    hyperparameters=hyperparameters,
                    role=sagemaker.get_execution_role(),
                    instance_count=1,
                    instance_type='ml.m5.2xlarge',
                    output_path=output_path)

# define the data type and paths to the training and validation datasets
content_type = "libsvm"
train_input = TrainingInput("s3://{}/{}/{}/".format(bucket, prefix, 'train'), content_type=content_type)
validation_input = TrainingInput("s3://{}/{}/{}/".format(bucket, prefix, 'validation'), content_type=content_type)

# execute the XGBoost training job
estimator.fit({'train': train_input, 'validation': validation_input})

Para ver um exemplo completo do uso do SageMaker AI XGBoost como estrutura, consulte Regressão com o Amazon AI XGBoost. SageMaker

Usar o XGBoost como um algoritmo integrado

Use o algoritmo integrado XGBoost para criar um contêiner de treinamento XGBoost como mostrado no exemplo de código a seguir. Você pode identificar automaticamente o URI de imagem do algoritmo integrado do XGBoost usando a SageMaker API AIimage_uris.retrieve. Se estiver usando o Amazon SageMaker Python SDK versão 1, use a API. get_image_uri Para garantir que a API image_uris.retrieve encontre o URI correto, consulte Parâmetros comuns para algoritmos integrados. Em seguida, consulte a lista completa em xgboost de URIs de imagens de algoritmos integrados e as regiões disponíveis.

Depois de especificar o URI da imagem do XGBoost, use o contêiner XGBoost para criar um estimador usando a SageMaker API AI Estimator e iniciar um trabalho de treinamento. Esse modo de algoritmo integrado XGBoost não incorpora seu próprio script de treinamento XGBoost e é executado diretamente nos conjuntos de dados de entrada.

Importante

Ao recuperar o URI da imagem do SageMaker AI XGBoost, não use :latest ou :1 para a tag do URI da imagem. Você deve especificar um deles Versões aceitas para escolher o contêiner SageMaker AI-managed XGBoost com a versão nativa do pacote XGBoost que você deseja usar. Para encontrar a versão do pacote migrada para os contêineres SageMaker AI XGBoost, consulte Docker Registry Paths and Example Code. Em seguida escolha a sua Região da AWS e navegue até a seção XGBoost (algoritmo).

import sagemaker
import boto3
from sagemaker import image_uris
from sagemaker.session import Session
from sagemaker.inputs import TrainingInput

# initialize hyperparameters
hyperparameters = {
        "max_depth":"5",
        "eta":"0.2",
        "gamma":"4",
        "min_child_weight":"6",
        "subsample":"0.7",
        "objective":"reg:squarederror",
        "num_round":"50"}

# set an output path where the trained model will be saved
bucket = sagemaker.Session().default_bucket()
prefix = 'DEMO-xgboost-as-a-built-in-algo'
output_path = 's3://{}/{}/{}/output'.format(bucket, prefix, 'abalone-xgb-built-in-algo')

# this line automatically looks for the XGBoost image URI and builds an XGBoost container.
# specify the repo_version depending on your preference.
xgboost_container = sagemaker.image_uris.retrieve("xgboost", region, "1.7-1")

# construct a SageMaker AI estimator that calls the xgboost-container
estimator = sagemaker.estimator.Estimator(image_uri=xgboost_container, 
                                          hyperparameters=hyperparameters,
                                          role=sagemaker.get_execution_role(),
                                          instance_count=1, 
                                          instance_type='ml.m5.2xlarge', 
                                          volume_size=5, # 5 GB 
                                          output_path=output_path)

# define the data type and paths to the training and validation datasets
content_type = "libsvm"
train_input = TrainingInput("s3://{}/{}/{}/".format(bucket, prefix, 'train'), content_type=content_type)
validation_input = TrainingInput("s3://{}/{}/{}/".format(bucket, prefix, 'validation'), content_type=content_type)

# execute the XGBoost training job
estimator.fit({'train': train_input, 'validation': validation_input})

Para obter mais informações sobre como configurar o XGBoost como algoritmo integrado, consulte os seguintes exemplos de caderno:

Input/Output interface para o algoritmo XGBoost

O aumento de gradiente trabalha em dados tabulares: as linhas representam as observações, uma coluna representa a variável de destino ou rótulo, e as demais colunas representam os atributos.

A implementação de SageMaker IA do XGBoost suporta os seguintes formatos de dados para treinamento e inferência:

  • text/libsvm (padrão)

  • text/csv

  • application/x-parquete

  • application/x-recordio-protobuf

nota

Há algumas considerações sobre as quais você deve estar ciente em relação às entradas de treinamento e inferência:

  • Para obter um melhor desempenho, recomendamos usar o XGBoost com o modo Arquivo, no qual seus dados do Amazon S3 são armazenados nos volumes da instância de treinamento.

  • Para treinamento com entrada colunar, o algoritmo pressupõe que a variável de destino (rótulo) está na primeira coluna. Para inferência, o algoritmo pressupõe que a entrada não tem a coluna de rótulo.

  • Para dados CSV, a entrada não deve ter um registro de cabeçalho.

  • Para treinamento do LIBSVM, o algoritmo pressupõe que as colunas subsequentes após a coluna do rótulo contêm os pares de valores de índice baseados em zero para os atributos. Portanto, cada linha tem o formato: <label> <index0>:<value0> <index1>:<value1>.

  • Para obter informações sobre os tipos de instância e o treinamento distribuído, consulte Recomendações de instâncias do EC2 para o algoritmo XGBoost.

Para o modo de entrada do treinamento CSV, a memória total disponível para o algoritmo deve ser capaz de conter o conjunto de dados de treinamento. A memória total disponível é calculada como Instance Count * the memory available in the InstanceType. Para o modo de entrada de treinamento libsvm, não é necessário, mas recomendado.

Para a versão 1.3-1 e posterior, o SageMaker AI XGBoost salva o modelo no formato binário interno do XGBoost, usando o. Booster.save_model As versões anteriores usam o módulo pickle do Python no modelo. serialize/deserialize

nota

Esteja atento às versões ao usar um modelo SageMaker AI XGBoost no XGBoost de código aberto. As versões 1.3-1 e posteriores usam o formato binário interno do XGBoost, enquanto as versões anteriores usam o módulo pickle do Python.

Para usar um modelo treinado com SageMaker AI XGBoost v1.3-1 ou posterior no XGBoost de código aberto

  • Use o seguinte código do Python:

    import xgboost as xgb

xgb_model = xgb.Booster()
xgb_model.load_model(model_file_path)
xgb_model.predict(dtest)
Para usar um modelo treinado com versões anteriores do SageMaker AI XGBoost no XGBoost de código aberto

  • Use o seguinte código do Python:

    import pickle as pkl 
import tarfile

t = tarfile.open('model.tar.gz', 'r:gz')
t.extractall()

model = pkl.load(open(model_file_path, 'rb'))

# prediction with test data
pred = model.predict(dtest)
Para diferenciar a importância dos pontos de dados rotulados, use Apoios de peso de instância

  • SageMaker O AI XGBoost permite que os clientes diferenciem a importância dos pontos de dados rotulados atribuindo a cada instância um valor de peso. Como text/libsvmentrada, os clientes podem atribuir valores de peso às instâncias de dados anexando-os após os rótulos. Por exemplo, .label:weight idx_0:val_0 idx_1:val_1... Para text/csventrada, os clientes precisam ativar a csv_weights bandeira nos parâmetros e anexar valores de peso na coluna após os rótulos. Por exemplo: label,weight,val_0,val_1,...).