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
<a name="xgboost-how-to-use"></a>

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](studio-jumpstart.md)

**Topics**
+ [Usar o XGBoost como uma framework](#xgboost-how-to-framework)
+ [Usar o XGBoost como um algoritmo integrado](#xgboost-how-to-built-in)
+ [Input/Output interface para o algoritmo XGBoost](#InputOutput-XGBoost)

## Usar o XGBoost como uma framework
<a name="xgboost-how-to-framework"></a>

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](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/xgboost_abalone/xgboost_abalone_dist_script_mode.html) o Amazon AI XGBoost. SageMaker 

## Usar o XGBoost como um algoritmo integrado
<a name="xgboost-how-to-built-in"></a>

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 AI`image_uris.retrieve`. Se estiver usando o [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) 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](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html). 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](xgboost.md#xgboost-supported-versions) 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](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths.html) 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:
+ [Managed Spot Training for XGBoost](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/xgboost_abalone/xgboost_managed_spot_training.html)
+ [Regressão com Amazon SageMaker AI XGBoost (entrada Parquet)](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/xgboost_abalone/xgboost_parquet_input_training.html)

## Input/Output interface para o algoritmo XGBoost
<a name="InputOutput-XGBoost"></a>

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](xgboost.md#Instance-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/libsvm*entrada, 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/csv*entrada, 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,...`).