O Amazon Redshift não permitirá mais a criação de UDFs do Python a partir do Patch 198. As UDFs do Python existentes continuarão a funcionar normalmente até 30 de junho de 2026. Para ter mais informações, consulte a [publicação de blog ](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). 

# Tutorial: Como construir modelos XGBoost
<a name="tutorial_xgboost"></a>

Neste tutorial, você cria um modelo com dados do Amazon S3 e executa consultas de previsão com o modelo usando o Amazon Redshift ML. O algoritmo XGBoost é uma implementação otimizada do algoritmo baseado em árvores com aumento de gradiente. O XGBoost lida com mais tipos de dados, relacionamentos e distribuições do que outros algoritmos de árvores com aumento de gradiente. Você pode usar o XGBoost para regressão, classificação binária, classificação multiclasse e problemas de classificação. Para obter mais informações sobre o algoritmo XGBoost, consulte [Algoritmo XGBoost](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost.html) no Guia do desenvolvedor do Amazon SageMaker AI.

A operação `CREATE MODEL` do Amazon Redshift ML com a opção `AUTO OFF` no momento aceita o XGBoost como `MODEL_TYPE`. Você pode fornecer informações relevantes, como o objetivo e os hiperparâmetros, como parte do `CREATE MODEL`, com base em seu caso de uso.

Neste tutorial, use o [conjunto de dados banknote authentication](https://archive.ics.uci.edu/ml/datasets/banknote+authentication) (autenticação de cédulas), que é um problema de classificação binária para prever se determinada cédula é genuína ou falsificada. 

## Exemplos de casos de uso
<a name="tutorial_xgboost_tasks"></a>

Você pode resolver outros problemas de classificação binária usando o Amazon Redshift ML, como prever se um paciente está saudável ou tem alguma doença. Você também pode prever se um e-mail é ou não spam.

**Tarefas**
+ Pré-requisitos
+ Etapa 1: Carregar dados do Amazon S3 para o Amazon Redshift
+ Etapa 2: Criar o modelo de machine learning
+ Etapa 3: Executar previsões com o modelo

## Pré-requisitos
<a name="tutorial_xgboost_prereqs"></a>

Para finalizar este tutorial, você deve concluir a [configuração administrativa](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html) do Amazon Redshift ML.

## Etapa 1: Carregar dados do Amazon S3 para o Amazon Redshift
<a name="tutorial_xgboost_step_load"></a>

Use o [editor de consultas v2 do Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) para executar as consultas a seguir.

A consulta a seguir cria duas tabelas, carrega os dados do Amazon S3 e divide os dados em um conjunto de treinamento e um conjunto de testes. Você usará o conjunto de treinamento para treinar seu modelo e criar a função de previsão. Em seguida, você testará a função de previsão no conjunto de testes.

```
--create training set table
CREATE TABLE banknoteauthentication_train(
    variance FLOAT,
    skewness FLOAT,
    curtosis FLOAT,
    entropy FLOAT,
    class INT
);

--Load into training table
COPY banknoteauthentication_train
FROM
    's3://redshiftbucket-ml-sagemaker/banknote_authentication/train_data/' IAM_ROLE default REGION 'us-west-2' IGNOREHEADER 1 CSV;

--create testing set table
CREATE TABLE banknoteauthentication_test(
    variance FLOAT,
    skewness FLOAT,
    curtosis FLOAT,
    entropy FLOAT,
    class INT
);

--Load data into testing table
COPY banknoteauthentication_test
FROM
    's3://redshiftbucket-ml-sagemaker/banknote_authentication/test_data/' 
    IAM_ROLE default 
    REGION 'us-west-2' 
    IGNOREHEADER 1 
    CSV;
```

## Etapa 2: Criar o modelo de machine learning
<a name="tutorial_xgboost_step_create_model"></a>

A consulta a seguir cria o modelo XGBoost no Amazon Redshift ML com base no conjunto de treinamento que você criou na etapa anterior. Substitua `amzn-s3-demo-bucket` por seu próprio `S3_BUCKET`, que armazenará os conjuntos de dados de entrada e outros artefatos do Redshift ML.

```
CREATE MODEL model_banknoteauthentication_xgboost_binary
FROM
    banknoteauthentication_train 
    TARGET class 
    FUNCTION func_model_banknoteauthentication_xgboost_binary 
    IAM_ROLE default 
    AUTO OFF 
    MODEL_TYPE xgboost 
    OBJECTIVE 'binary:logistic' 
    PREPROCESSORS 'none' 
    HYPERPARAMETERS DEFAULT
EXCEPT(NUM_ROUND '100') 
SETTINGS(S3_BUCKET 'amzn-s3-demo-bucket');
```

### Mostrar o status do modelo de treinamento (opcional)
<a name="tutorial_xgboost_show_status"></a>

Você pode usar o comando SHOW MODEL para saber quando o modelo está pronto.

Use a consulta a seguir para monitorar o andamento do treinamento do modelo.

```
SHOW MODEL model_banknoteauthentication_xgboost_binary;
```

Se o modelo for `READY`, a operação SHOW MODEL também fornecerá a métrica `train:error`, conforme mostrado no exemplo de saída a seguir. A métrica `train:error` é uma medida de precisão de seu modelo que mede até seis casas decimais. O valor 0 é o mais preciso e o 1 é o menos preciso.

```
+--------------------------+--------------------------------------------------+
|        Model Name        |   model_banknoteauthentication_xgboost_binary    |
+--------------------------+--------------------------------------------------+
| Schema Name              | public                                           |
| Owner                    | awsuser                                          |
| Creation Time            | Tue, 21.06.2022 19:07:35                         |
| Model State              | READY                                            |
| train:error              |                                         0.000000 |
| Estimated Cost           |                                         0.006197 |
|                          |                                                  |
| TRAINING DATA:           |                                                  |
| Query                    | SELECT *                                         |
|                          | FROM "BANKNOTEAUTHENTICATION_TRAIN"              |
| Target Column            | CLASS                                            |
|                          |                                                  |
| PARAMETERS:              |                                                  |
| Model Type               | xgboost                                          |
| Training Job Name        | redshiftml-20220621190735686935-xgboost          |
| Function Name            | func_model_banknoteauthentication_xgboost_binary |
| Function Parameters      | variance skewness curtosis entropy               |
| Function Parameter Types | float8 float8 float8 float8                      |
| IAM Role                 | default-aws-iam-role                             |
| S3 Bucket                | amzn-s3-demo-bucket                              |
| Max Runtime              |                                             5400 |
|                          |                                                  |
| HYPERPARAMETERS:         |                                                  |
| num_round                |                                              100 |
| objective                | binary:logistic                                  |
+--------------------------+--------------------------------------------------+
```

## Etapa 3: Executar previsões com o modelo
<a name="tutorial_xgboost_step_perform_predictions"></a>

### Conferir a precisão do modelo
<a name="tutorial_xgboost_check_accuracy"></a>

A consulta de previsão a seguir usa a função de previsão criada na etapa anterior para verificar a precisão do modelo. Execute essa consulta no conjunto de testes para verificar se o modelo não tem uma correspondência muito próxima do conjunto de treinamento. Essa correspondência próxima também é conhecida como sobreajuste, que pode levar o modelo a fazer previsões não confiáveis.

```
WITH predict_data AS (
    SELECT
        class AS label,
        func_model_banknoteauthentication_xgboost_binary (variance, skewness, curtosis, entropy) AS predicted,
        CASE
            WHEN label IS NULL THEN 0
            ELSE label
        END AS actual,
        CASE
            WHEN actual = predicted THEN 1 :: INT
            ELSE 0 :: INT
        END AS correct
    FROM
        banknoteauthentication_test
),
aggr_data AS (
    SELECT
        SUM(correct) AS num_correct,
        COUNT(*) AS total
    FROM
        predict_data
)
SELECT
    (num_correct :: FLOAT / total :: FLOAT) AS accuracy
FROM
    aggr_data;
```

### Prever a quantidade de cédulas originais e falsas
<a name="tutorial_xgboost_predict_amount"></a>

A consulta de previsão a seguir retorna a quantidade prevista de cédulas originais e falsas no conjunto de teste.

```
WITH predict_data AS (
    SELECT
        func_model_banknoteauthentication_xgboost_binary(variance, skewness, curtosis, entropy) AS predicted
    FROM
        banknoteauthentication_test
)
SELECT
    CASE
        WHEN predicted = '0' THEN 'Original banknote'
        WHEN predicted = '1' THEN 'Counterfeit banknote'
        ELSE 'NA'
    END AS banknote_authentication,
    COUNT(1) AS count
FROM
    predict_data
GROUP BY
    1;
```

### Encontrar a observação média de uma cédula original e uma falsificada
<a name="tutorial_xgboost_find_average_observation"></a>

A consulta de previsão a seguir retorna o valor médio de cada recurso para cédulas que são previstas como originais e falsificadas no conjunto de teste.

```
WITH predict_data AS (
    SELECT
        func_model_banknoteauthentication_xgboost_binary(variance, skewness, curtosis, entropy) AS predicted,
          variance,
          skewness,
          curtosis,
          entropy
    FROM
        banknoteauthentication_test
)
SELECT
    CASE
        WHEN predicted = '0' THEN 'Original banknote'
        WHEN predicted = '1' THEN 'Counterfeit banknote'
        ELSE 'NA'
    END AS banknote_authentication,
    TRUNC(AVG(variance), 2) AS avg_variance,
    TRUNC(AVG(skewness), 2) AS avg_skewness,
    TRUNC(AVG(curtosis), 2) AS avg_curtosis,
    TRUNC(AVG(entropy), 2) AS avg_entropy
FROM
    predict_data
GROUP BY
    1
ORDER BY
    2;
```

## Tópicos relacionados
<a name="tutorial_xgboost_related_topics"></a>

Para obter mais informações sobre o Amazon Redshift ML, consulte a seguinte documentação:
+ [Custos para usar o ML do Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)
+ [Operação CREATE MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MODEL.html)
+ [Função EXPLAIN\$1MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)

Para obter mais informações sobre machine learning, consulte a seguinte documentação:
+ [Visão geral do Machine Learning](https://docs.aws.amazon.com/redshift/latest/dg/machine_learning_overview.html)
+ [Machine Learning para iniciantes e especialistas](https://docs.aws.amazon.com/redshift/latest/dg/novice_expert.html)
+ [What Is Fairness and Model Explainability for Machine Learning Predictions? (O que é equidade e explicabilidade de modelo para previsões de machine learning?](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)