Amazon Redshift dejará de admitir la creación de nuevas UDF de Python a partir del parche 198. Las UDF de Python existentes seguirán funcionando hasta el 30 de junio de 2026. Para obtener más información, consulte la [publicación del blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). 

# Tutorial: Creación de modelos XGBoost
<a name="tutorial_xgboost"></a>

En este tutorial, creará un modelo con datos de Amazon S3 y ejecutará consultas de predicción con el modelo mediante Amazon Redshift ML. El algoritmo XGBoost es una implementación optimizada del algoritmo de árboles aumentados. XGBoost maneja más tipos de datos, relaciones y distribuciones que otros algoritmos de árboles aumentados. Puede usar XGBoost para problemas de regresión, de clasificación binaria, clasificación multiclase) y de ranking. Para obtener más información sobre el algoritmo XGBoost, consulte [Algoritmo XGBoost](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost.html) en la Guía para desarrolladores de Amazon SageMaker AI.

Actualmente,la operación `CREATE MODEL` de Amazon Redshift ML con la opción `AUTO OFF` es compatible con XGBoost como `MODEL_TYPE`. Puede proporcionar información relevante, como el objetivo y los hiperparámetros, como parte de `CREATE MODEL`, en función del caso de uso.

En este tutorial, se utiliza el [conjunto de datos de autenticación de billetes](https://archive.ics.uci.edu/ml/datasets/banknote+authentication), que es un problema de clasificación binaria para predecir si un billete determinado es auténtico o falso. 

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

Puede resolver otros problemas de clasificación binaria con Amazon Redshift ML, como predecir si un paciente está sano o tiene una enfermedad. También puede predecir si un correo electrónico es spam o no.

**Tareas**
+ Requisitos previos
+ Paso 1: Cargar los datos desde Amazon S3 en Amazon Redshift
+ Paso 2: Crear el modelo de machine learning
+ Paso 3: Realizar predicciones con el modelo

## Requisitos previos
<a name="tutorial_xgboost_prereqs"></a>

Para completar este tutorial, debe realizar el procedimiento de [configuración administrativa](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html) de Amazon Redshift ML.

## Paso 1: Cargar los datos desde Amazon S3 en Amazon Redshift
<a name="tutorial_xgboost_step_load"></a>

Use el [editor de consultas de Amazon Redshift v2](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) para ejecutar las siguientes consultas.

La siguiente consulta crea dos tablas, carga los datos de Amazon S3 y divide los datos en un conjunto de entrenamiento y un conjunto de pruebas. Utilizará el conjunto de entrenamiento para entrenar su modelo y crear la función de predicción. A continuación, probará la función de predicción en el conjunto de pruebas.

```
--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;
```

## Paso 2: Crear el modelo de machine learning
<a name="tutorial_xgboost_step_create_model"></a>

La siguiente consulta crea el modelo XGBoost en Amazon Redshift ML a partir del conjunto de entrenamiento que creó en el paso anterior. Reemplace `amzn-s3-demo-bucket` con su propio `S3_BUCKET`, que almacenará sus conjuntos de datos de entrada y otros artefactos de 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');
```

### Comprobar el estado del entrenamiento del modelo (opcional)
<a name="tutorial_xgboost_show_status"></a>

Puede utilizar el comando SHOW MODEL para saber cuándo está listo el modelo.

Utilice la siguiente consulta para supervisar el estado del entrenamiento del modelo.

```
SHOW MODEL model_banknoteauthentication_xgboost_binary;
```

Si el modelo es `READY`, la operación SHOW MODEL también proporciona la métrica `train:error`, como se muestra en el siguiente ejemplo de la salida. La métrica `train:error` es una medida de precisión de su modelo que mide hasta seis decimales. Un valor de 0 es más preciso y un valor de 1 es 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                                  |
+--------------------------+--------------------------------------------------+
```

## Paso 3: Realizar predicciones con el modelo
<a name="tutorial_xgboost_step_perform_predictions"></a>

### Comprobar la precisión del modelo
<a name="tutorial_xgboost_check_accuracy"></a>

La siguiente consulta de predicción utiliza la función de predicción creada en el paso anterior para comprobar la precisión del modelo. Ejecute esta consulta en el conjunto de pruebas para asegurarse de que el modelo no se corresponde demasiado con el conjunto de entrenamiento. Esta estrecha correspondencia también se conoce como sobreajuste, y el sobreajuste podría hacer que el modelo hiciera predicciones poco fiables.

```
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;
```

### Predecir la cantidad de billetes auténticos y falsos
<a name="tutorial_xgboost_predict_amount"></a>

La siguiente consulta de predicción devuelve la cantidad prevista de billetes auténticos y falsos en el conjunto de pruebas.

```
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 la observación promedio de un billete auténtico y uno falso
<a name="tutorial_xgboost_find_average_observation"></a>

La siguiente consulta de predicción devuelve el valor promedio de cada característica para los billetes que se predice que son auténticos y falsos en el conjunto de prueba.

```
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;
```

## Temas relacionados
<a name="tutorial_xgboost_related_topics"></a>

Para obtener más información sobre Amazon Redshift ML, consulte la siguiente documentación:
+ [Costes de utilizar Amazon Redshift ML](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)
+ [Operación CREATE MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MODEL.html)
+ [Función EXPLAIN\$1MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)

Para obtener más información sobre machine learning, consulte la siguiente documentación:
+ [Información general sobre machine learning](https://docs.aws.amazon.com/redshift/latest/dg/machine_learning_overview.html)
+ [Machine learning para principiantes y expertos](https://docs.aws.amazon.com/redshift/latest/dg/novice_expert.html)
+ [Qué es la equidad y la explicabilidad del modelo para las predicciones de machine learning?](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)