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/).
# Tutoriales de Amazon Redshift ML
Puede utilizar Amazon Redshift ML para entrenar modelos de machine learning mediante instrucciones SQL y, a continuación, invocar los modelos en consultas SQL para realizar predicciones. El machine learning en Amazon Redshift forma un modelo con un comando SQL. Amazon Redshift AI inicializa automáticamente un trabajo de entrenamiento en Amazon SageMaker AI y genera un modelo. Una vez creado el modelo, puede realizar predicciones en Amazon Redshift mediante la función de predicción del modelo.
Siga los pasos de estos tutoriales para obtener más información acerca de las características de Amazon Redshift ML:
+ [Tutorial: Creación de modelos de deserción de clientes](tutorial_customer_churn.md): en este tutorial, utilizará Amazon Redshift ML para crear un modelo de deserción de clientes con el comando CREATE MODEL y ejecutará consultas de predicción para situaciones de usuario. A continuación, implementará consultas mediante la función SQL que genera el comando CREATE MODEL.
+ [Tutorial: Creación de modelos de agrupación en clústeres k-means](tutorial_k-means_clustering.md): en este tutorial, utilizará Amazon Redshift ML para crear, entrenar e implementar un modelo de machine learning basado en el [algoritmo k-means](url-sm-dev;k-means.html).
+ [Tutorial: Creación de modelos de clasificación multiclase](tutorial_multi-class_classification.md): en este tutorial, utilizará Amazon Redshift ML para crear un modelo de machine learning que resuelva los problemas de clasificación multiclase. El algoritmo de clasificación multiclase clasifica los puntos de datos en una de tres o más clases. A continuación, implementará consultas mediante la función SQL que genera el comando CREATE MODEL.
+ [Tutorial: Creación de modelos XGBoost](tutorial_xgboost.md): 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.
+ [Tutorial: Creación de modelos de regresión](tutorial_regression.md): en este tutorial, utilizará Amazon Redshift ML para crear un modelo de regresión de machine learning y ejecutar consultas de predicción en el modelo. Los modelos de regresión le permiten predecir resultados numéricos, como el precio de una casa o cuántas personas utilizarán el servicio de alquiler de bicicletas de una ciudad.
+ [Tutorial: Creación de modelos de regresión con aprendizaje lineal](tutorial_linear_learner_regression.md): en este tutorial, creará un modelo de aprendizaje lineal con datos de Amazon S3 y ejecutará consultas de predicción con el modelo mediante Amazon Redshift ML. El algoritmo de aprendizaje lineal de SageMaker AI resuelve problemas de regresión o clasificación multiclase.
+ [Tutorial: Creación de modelos de clasificación multiclase con aprendizaje lineal](tutorial_linear_learner_multi-class_classification.md): en este tutorial, creará un modelo de aprendizaje lineal con datos de Amazon S3 y, a continuación, ejecutará consultas de predicción con el modelo mediante Amazon Redshift ML. El algoritmo de aprendizaje lineal de SageMaker AI resuelve problemas de regresión o clasificación.
# Tutorial: Creación de modelos de deserción de clientes
En este tutorial, utilizará Amazon Redshift ML para crear un modelo de deserción de clientes con el comando CREATE MODEL y ejecutará consultas de predicción para situaciones de usuario. A continuación, implementará consultas mediante la función SQL que genera el comando CREATE MODEL.
Se puede utilizar un comando sencillo CREATE MODEL para exportar datos de formación, formar un modelo, importar ese modelo y preparar una función de predicción de Amazon Redshift. Utilice la instrucción CREATE MODEL para especificar los datos de formación en forma de tabla o con la instrucción SELECT.
Este ejemplo utiliza información histórica para construir un modelo de machine learning sobre las bajas de clientes de un operador de telefonía móvil. En primer lugar, SageMaker AI entrena el modelo de machine learning y, a continuación, lo prueba utilizando la información de perfil de un cliente arbitrario. Una vez validado el modelo, Amazon SageMaker AI implementa el modelo y la función de predicción en Amazon Redshift. Puede usar la función de predicción para predecir si un cliente va a darse de baja o no.
## Ejemplos de casos de uso
Puede resolver otros problemas de clasificación binaria con Amazon Redshift ML, como predecir si un cliente potencial de ventas se cerrará o no. También puede predecir si una transacción financiera es fraudulenta 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
Para completar este tutorial, necesita los siguientes requisitos previos:
+ Debe configurar un clúster de Amazon Redshift para Amazon Redshift ML. Para ello, utilice la documentación relativa a la [Agrupación y ajuste de la configuración para la administración de Amazon Redshift ML](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html).
+ El clúster de Amazon Redshift que se utiliza para crear el modelo y el bucket de Amazon S3 que se utiliza para preparar los datos de entrenamiento y almacenar los artefactos del modelo deberán estar en la misma región de AWS.
+ Para descargar los comandos SQL y el conjunto de datos de muestra utilizados en esta documentación, realice una de las siguientes acciones:
+ Descargue los [comandos SQL](https://s3.amazonaws.com/redshift-downloads/redshift-ml/tutorial-scripts/redshift-ml-tutorial.sql), el [archivo de actividad del cliente](https://s3.amazonaws.com/redshift-downloads/redshift-ml/customer_activity/customer_activity.csv) y el [archivo de Abalone](https://s3.amazonaws.com/redshift-downloads/redshift-ml/abalone_xg/abalone.csv).
+ A través de la AWS CLI para Amazon S3, ejecute el siguiente comando. Puede utilizar su propia ruta de destino.
```
aws s3 cp s3://redshift-downloads/redshift-ml/tutorial-scripts/redshift-ml-tutorial.sql
aws s3 cp s3://redshift-downloads/redshift-ml/customer_activity/customer_activity.csv
aws s3 cp s3://redshift-downloads/redshift-ml/abalone_xgb/abalone_xgb.csv
```
## Paso 1: Cargar los datos desde Amazon S3 en Amazon Redshift
Use el [editor de consultas de Amazon Redshift v2](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) para editar y ejecutar consultas y visualizar los resultados.
Al ejecutar las consultas siguientes, se crea una tabla llamada `customer_activity` y se incorpora el conjunto de datos de ejemplo desde Amazon S3.
```
DROP TABLE IF EXISTS customer_activity;
CREATE TABLE customer_activity (
state varchar(2),
account_length int,
area_code int,
phone varchar(8),
intl_plan varchar(3),
vMail_plan varchar(3),
vMail_message int,
day_mins float,
day_calls int,
day_charge float,
total_charge float,
eve_mins float,
eve_calls int,
eve_charge float,
night_mins float,
night_calls int,
night_charge float,
intl_mins float,
intl_calls int,
intl_charge float,
cust_serv_calls int,
churn varchar(6),
record_date date
);
COPY customer_activity
FROM 's3://redshift-downloads/redshift-ml/customer_activity/'
REGION 'us-east-1' IAM_ROLE default
FORMAT AS CSV IGNOREHEADER 1;
```
## Paso 2: Crear el modelo de machine learning
La deserción es nuestro objetivo de entrada en este modelo. Todas las demás entradas del modelo son atributos que ayudan a crear una función para predecir la deserción.
En el siguiente ejemplo, se utiliza la operación CREATE MODEL para ofrecer un modelo que prediga si un cliente permanecerá activo. Para ello, se utilizan distintos datos, como edad del cliente, código postal, gasto y casos. En el siguiente ejemplo, reemplace amzn-s3-demo-bucket por el bucket de Amazon S3 propio.
```
CREATE MODEL customer_churn_auto_model
FROM
(
SELECT state,
account_length,
area_code,
total_charge/account_length AS average_daily_spend,
cust_serv_calls/account_length AS average_daily_cases,
churn
FROM customer_activity
WHERE record_date < '2020-01-01'
)
TARGET churn FUNCTION ml_fn_customer_churn_auto
IAM_ROLE default SETTINGS (
S3_BUCKET 'amzn-s3-demo-bucket'
);
```
La consulta SELECT del ejemplo anterior crea los datos de entrenamiento. La cláusula TARGET especifica cuál es la columna que corresponde a la etiqueta de machine learning que utiliza la operación CREATE MODEL para aprender a generar predicciones. La columna de destino “churn” (deserción) indica si el cliente todavía tiene una suscripción activa o si la ha suspendido. El campo S3\$1BUCKET es el nombre del bucket de Amazon S3 que ha creado anteriormente. El bucket de Amazon S3 se utiliza para compartir los datos y artefactos de entrenamiento entre Amazon Redshift y Amazon SageMaker AI. Las columnas restantes corresponden a las características que se utilizan para la predicción.
Para ver un resumen de la sintaxis y las características de un caso de uso básico del comando CREATE MODEL, consulte [CREATE MODEL simple](https://docs.aws.amazon.com/redshift/latest/dg/r_create_model_use_cases.html#r_simple_create_model).
### Añadir permisos para el cifrado del lado del servidor (opcional)
Amazon Redshift utiliza de forma predeterminada el Piloto automático de Amazon SageMaker AI para el entrenamiento. En concreto, Amazon Redshift exporta de forma segura los datos de entrenamiento al bucket de Amazon S3 que especifica el cliente. Si no se especifica un `KMS_KEY_ID`, los datos se cifran mediante el cifrado del servidor SSE-S3 de forma predeterminada.
Si cifra la entrada mediante el cifrado del lado del servidor con una clave administrada por AWS KMS (SSE-MMS), agregue los siguientes permisos:
```
{
"Effect": "Allow",
"Action": [
"kms:Encrypt"
"kms:Decrypt"
]
}
```
Para obtener más información acerca de los roles de Amazon SageMaker, consulte [Amazon SageMaker AI roles](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html) en la *Guía para desarrolladores de Amazon SageMaker AI*.
### Comprobar el estado del entrenamiento del modelo (opcional)
Puede utilizar el comando SHOW MODEL para saber cuándo está listo el modelo.
Utilice la siguiente operación para comprobar el estado del modelo.
```
SHOW MODEL customer_churn_auto_model;
```
A continuación se muestra un ejemplo de la salida de la operación anterior.
```
+--------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Key | Value |
+--------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Model Name | customer_churn_auto_model |
| Schema Name | public |
| Owner | awsuser |
| Creation Time | Tue, 14.06.2022 17:15:52 |
| Model State | TRAINING |
| | |
| TRAINING DATA: | |
| Query | SELECT STATE, ACCOUNT_LENGTH, AREA_CODE, TOTAL_CHARGE / ACCOUNT_LENGTH AS AVERAGE_DAILY_SPEND, CUST_SERV_CALLS / ACCOUNT_LENGTH AS AVERAGE_DAILY_CASES, CHURN |
| | FROM CUSTOMER_ACTIVITY |
| | WHERE RECORD_DATE < '2020-01-01' |
| Target Column | CHURN |
| | |
| PARAMETERS: | |
| Model Type | auto |
| Problem Type | |
| Objective | |
| AutoML Job Name | redshiftml-20220614171552640901 |
| Function Name | ml_fn_customer_churn_auto |
| Function Parameters | state account_length area_code average_daily_spend average_daily_cases |
| Function Parameter Types | varchar int4 int4 float8 int4 |
| IAM Role | default-aws-iam-role |
| S3 Bucket | amzn-s3-demo-bucket |
| Max Runtime | 5400 |
+--------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------+
```
Una vez finalizado el entrenamiento del modelo, la variable `model_state` se convierte en `Model is Ready` y la función de predicción pasa a estar disponible.
## Paso 3: Realizar predicciones con el modelo
Puede usar instrucciones SQL para ver las predicciones realizadas por el modelo de predicción. En este ejemplo, la función de predicción creada por la operación CREATE MODEL se denomina `ml_fn_customer_churn_auto`. Los argumentos de entrada para la función de predicción corresponden a los tipos de características, como varchar para `state` y entero para `account_length`. La salida de la función de predicción es del mismo tipo que la columna TARGET de la instrucción CREATE MODEL.
1. Ha entrenado el modelo con datos anteriores al 01/01/2020, por lo que ahora usa la función de predicción en el conjunto de pruebas. La siguiente consulta muestra las predicciones sobre si los clientes que se inscribieron después de 01-01-2020 se darán de baja o no.
```
SELECT
phone,
ml_fn_customer_churn_auto(
state,
account_length,
area_code,
total_charge / account_length,
cust_serv_calls / account_length
) AS active
FROM
customer_activity
WHERE
record_date > '2020-01-01';
```
1. El siguiente ejemplo utiliza la misma función de predicción para un caso de uso diferente. En este caso, Amazon Redshift predice la proporción de usuarios que se han dado de baja y los que no lo han hecho entre clientes de diferentes estados en los que la fecha de registro es posterior al 01-01-2020.
```
WITH predicted AS (
SELECT
state,
ml_fn_customer_churn_auto(
state,
account_length,
area_code,
total_charge / account_length,
cust_serv_calls / account_length
) :: varchar(6) AS active
FROM
customer_activity
WHERE
record_date > '2020-01-01'
)
SELECT
state,
SUM(
CASE
WHEN active = 'True.' THEN 1
ELSE 0
END
) AS churners,
SUM(
CASE
WHEN active = 'False.' THEN 1
ELSE 0
END
) AS nonchurners,
COUNT(*) AS total_per_state
FROM
predicted
GROUP BY
state
ORDER BY
state;
```
1. El siguiente ejemplo utiliza la función de predicción para el caso de uso consistente en predecir el porcentaje de clientes que se dan de baja en un estado. En este caso, Amazon Redshift predice el porcentaje de deserción con una fecha de registro posterior al 01/01/2020.
```
WITH predicted AS (
SELECT
state,
ml_fn_customer_churn_auto(
state,
account_length,
area_code,
total_charge / account_length,
cust_serv_calls / account_length
) :: varchar(6) AS active
FROM
customer_activity
WHERE
record_date > '2020-01-01'
)
SELECT
state,
CAST((CAST((SUM(
CASE
WHEN active = 'True.' THEN 1
ELSE 0
END
)) AS FLOAT) / CAST(COUNT(*) AS FLOAT)) AS DECIMAL (3, 2)) AS pct_churn,
COUNT(*) AS total_customers_per_state
FROM
predicted
GROUP BY
state
ORDER BY
3 DESC;
```
## Temas relacionados
Para obtener más información sobre Amazon Redshift ML, consulte la siguiente documentación:
+ [Costos de utilizar Amazon Redshift ML](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)
+ [Comando 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)
# Tutorial: Creación de modelos de agrupación en clústeres k-means
En este tutorial, utilizará Amazon Redshift ML para crear, entrenar e implementar un modelo de machine learning basado en el [algoritmo k-means](url-sm-dev;k-means.html). Este algoritmo resuelve problemas en clústeres en los que desea descubrir agrupaciones en los datos. K-means ayuda a agrupar datos que aún no se han etiquetado. Para obtener más información sobre la agrupación en clústeres k-means, consulte [Funcionamiento de la agrupación en clústeres de k-means](https://docs.aws.amazon.com/sagemaker/latest/dg/algo-kmeans-tech-notes.html) en la Guía para desarrolladores de Amazon SageMaker.
Utilizará una operación CREATE MODEL para crear un modelo k-means a partir de un clúster de Amazon Redshift. Se puede utilizar un comando CREATE MODEL para exportar datos de entrenamiento, entrenar un modelo, importar ese modelo y preparar una función de predicción de Amazon Redshift. Utilice la operación CREATE MODEL para especificar los datos de entrenamiento en forma de tabla o con la instrucción SELECT.
En este tutorial, utilizará k-means en el conjunto de datos de [Global Database of Events, Language, and Tone (GDELT)](https://aws.amazon.com/public-datasets/gdelt/), que monitoriza las noticias en todo el mundo y los datos que se almacenan segundo a segundo cada día. k-means agrupa eventos que tienen tonos, actores o ubicaciones similares. Los datos se almacenan a modo de varios archivos en Amazon Simple Storage Service en dos carpetas diferentes. Las carpetas son históricas (abarcan los años 1979-2013) y hay actualizaciones diarias a partir del año 2013. En este ejemplo, usamos el formato histórico y traemos datos de 1979.
## Ejemplos de casos de uso
Puede resolver otros problemas de agrupamiento en clústeres con Amazon Redshift ML, como el agrupamiento de clientes que tienen hábitos de visualización similares en un servicio de streaming. También puede usar Redshift ML para predecir la cantidad óptima de centros de envío para un servicio de entrega.
**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
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
1. Use el [editor de consultas de Amazon Redshift v2](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) para ejecutar la siguiente consulta. La consulta descarta la tabla `gdelt_data` en el esquema público si existe y crea una tabla con el mismo nombre en el esquema público.
```
DROP TABLE IF EXISTS gdelt_data CASCADE;
CREATE TABLE gdelt_data (
GlobalEventId bigint,
SqlDate bigint,
MonthYear bigint,
Year bigint,
FractionDate double precision,
Actor1Code varchar(256),
Actor1Name varchar(256),
Actor1CountryCode varchar(256),
Actor1KnownGroupCode varchar(256),
Actor1EthnicCode varchar(256),
Actor1Religion1Code varchar(256),
Actor1Religion2Code varchar(256),
Actor1Type1Code varchar(256),
Actor1Type2Code varchar(256),
Actor1Type3Code varchar(256),
Actor2Code varchar(256),
Actor2Name varchar(256),
Actor2CountryCode varchar(256),
Actor2KnownGroupCode varchar(256),
Actor2EthnicCode varchar(256),
Actor2Religion1Code varchar(256),
Actor2Religion2Code varchar(256),
Actor2Type1Code varchar(256),
Actor2Type2Code varchar(256),
Actor2Type3Code varchar(256),
IsRootEvent bigint,
EventCode bigint,
EventBaseCode bigint,
EventRootCode bigint,
QuadClass bigint,
GoldsteinScale double precision,
NumMentions bigint,
NumSources bigint,
NumArticles bigint,
AvgTone double precision,
Actor1Geo_Type bigint,
Actor1Geo_FullName varchar(256),
Actor1Geo_CountryCode varchar(256),
Actor1Geo_ADM1Code varchar(256),
Actor1Geo_Lat double precision,
Actor1Geo_Long double precision,
Actor1Geo_FeatureID bigint,
Actor2Geo_Type bigint,
Actor2Geo_FullName varchar(256),
Actor2Geo_CountryCode varchar(256),
Actor2Geo_ADM1Code varchar(256),
Actor2Geo_Lat double precision,
Actor2Geo_Long double precision,
Actor2Geo_FeatureID bigint,
ActionGeo_Type bigint,
ActionGeo_FullName varchar(256),
ActionGeo_CountryCode varchar(256),
ActionGeo_ADM1Code varchar(256),
ActionGeo_Lat double precision,
ActionGeo_Long double precision,
ActionGeo_FeatureID bigint,
DATEADDED bigint
);
```
1. La siguiente consulta carga los datos de muestra en la tabla `gdelt_data`.
```
COPY gdelt_data
FROM 's3://gdelt-open-data/events/1979.csv'
REGION 'us-east-1'
IAM_ROLE default
CSV
DELIMITER '\t';
```
### Examinar los datos de entrenamiento (opcional)
Para ver en qué datos se entrenará su modelo, utilice la siguiente consulta.
```
SELECT
AvgTone,
EventCode,
NumArticles,
Actor1Geo_Lat,
Actor1Geo_Long,
Actor2Geo_Lat,
Actor2Geo_Long
FROM
gdelt_data LIMIT 100;
```
## Paso 2: Crear el modelo de machine learning
El siguiente ejemplo utiliza el comando CREATE MODEL para crear un modelo que agrupa los datos en siete clústeres. El valor K es el número de clústeres en los que se dividen los puntos de datos. El modelo clasifica los puntos de datos en clústeres en los que los puntos de datos son más similares entre sí. A través de la agrupación en clústeres de los puntos de datos en grupos, el algoritmo k-means determina de forma iterativa el mejor centro del clúster. A continuación, el algoritmo asigna cada punto de datos al centro del clúster más cercano. Los miembros más cercanos al mismo centro del clúster pertenecen al mismo grupo. Los miembros de un grupo son lo más parecido posible a otros miembros del mismo grupo y lo más diferente posible de los miembros de otros grupos. El valor K es subjetivo y depende de los métodos que miden las similitudes entre los puntos de datos. Puede cambiar el valor K para suavizar los tamaños de los clústeres si están distribuidos de manera desigual.
En el siguiente ejemplo, reemplace amzn-s3-demo-bucket por el bucket de Amazon S3 propio.
```
CREATE MODEL news_data_clusters
FROM
(
SELECT
AvgTone,
EventCode,
NumArticles,
Actor1Geo_Lat,
Actor1Geo_Long,
Actor2Geo_Lat,
Actor2Geo_Long
FROM
gdelt_data
) FUNCTION news_monitoring_cluster
IAM_ROLE default
AUTO OFF
MODEL_TYPE KMEANS
PREPROCESSORS 'none'
HYPERPARAMETERS DEFAULT
EXCEPT
(K '7')
SETTINGS (S3_BUCKET 'amzn-s3-demo-bucket');
```
### Comprobar el estado del entrenamiento del modelo (opcional)
Puede utilizar el comando SHOW MODEL para saber cuándo está listo el modelo.
Para comprobar el estado del modelo, utilice la siguiente operación SHOW MODEL y determine si `Model State` es `Ready`.
```
SHOW MODEL NEWS_DATA_CLUSTERS;
```
Cuando el modelo esté listo, la salida de la operación anterior debería mostrar que `Model State` es `Ready`. A continuación se muestra un ejemplo de la salida de la operación SHOW MODEL.
```
+--------------------------+------------------------------------------------------------------------------------------------------+
| Model Name | news_data_clusters |
+--------------------------+------------------------------------------------------------------------------------------------------+
| Schema Name | public |
| Owner | awsuser |
| Creation Time | Fri, 17.06.2022 16:32:19 |
| Model State | READY |
| train:msd | 2973.822754 |
| train:progress | 100.000000 |
| train:throughput | 237114.875000 |
| Estimated Cost | 0.004983 |
| | |
| TRAINING DATA: | |
| Query | SELECT AVGTONE, EVENTCODE, NUMARTICLES, ACTOR1GEO_LAT, ACTOR1GEO_LONG, ACTOR2GEO_LAT, ACTOR2GEO_LONG |
| | FROM GDELT_DATA |
| | |
| PARAMETERS: | |
| Model Type | kmeans |
| Training Job Name | redshiftml-20220617163219978978-kmeans |
| Function Name | news_monitoring_cluster |
| Function Parameters | avgtone eventcode numarticles actor1geo_lat actor1geo_long actor2geo_lat actor2geo_long |
| Function Parameter Types | float8 int8 int8 float8 float8 float8 float8 |
| IAM Role | default-aws-iam-role |
| S3 Bucket | amzn-s3-demo-bucket |
| Max Runtime | 5400 |
| | |
| HYPERPARAMETERS: | |
| feature_dim | 7 |
| k | 7 |
+--------------------------+------------------------------------------------------------------------------------------------------+
```
## Paso 3: Realizar predicciones con el modelo
### Identificar los clústeres
Puede encontrar agrupaciones discretas identificadas en los datos por su modelo, también conocidas como clústeres. Un clúster es el conjunto de puntos de datos que está más cerca de su centro de clúster que de cualquier otro centro de clúster. Dado que el valor K representa el número de clústeres del modelo, también representa el número de centros de clúster. La siguiente consulta identifica los clústeres mostrando el clúster asociado a cada `globaleventid`.
```
SELECT
globaleventid,
news_monitoring_cluster (
AvgTone,
EventCode,
NumArticles,
Actor1Geo_Lat,
Actor1Geo_Long,
Actor2Geo_Lat,
Actor2Geo_Long
) AS cluster
FROM
gdelt_data;
```
### Comprobar la distribución de los datos
Puede comprobar la distribución de los datos entre los clústeres para ver si el valor K que eligió ha provocado que los datos se distribuyeran de manera uniforme. Utilice la siguiente consulta para determinar si los datos están distribuidos de manera uniforme en los clústeres.
```
SELECT
events_cluster,
COUNT(*) AS nbr_events
FROM
(
SELECT
globaleventid,
news_monitoring_cluster(
AvgTone,
EventCode,
NumArticles,
Actor1Geo_Lat,
Actor1Geo_Long,
Actor2Geo_Lat,
Actor2Geo_Long
) AS events_cluster
FROM
gdelt_data
)
GROUP BY
1;
```
Puede cambiar el valor K para suavizar los tamaños de los clústeres si no están distribuidos de manera uniforme.
### Determinar los centros de clúster
Un punto de datos está más cerca de su centro de clúster que de cualquier otro centro de clúster. Por lo tanto, encontrar los centros de clúster le ayuda a definir los clústeres.
Ejecute la siguiente consulta para determinar los centros de clúster en función del número de artículos por código de evento.
```
SELECT
news_monitoring_cluster (
AvgTone,
EventCode,
NumArticles,
Actor1Geo_Lat,
Actor1Geo_Long,
Actor2Geo_Lat,
Actor2Geo_Long
) AS events_cluster,
eventcode,
SUM(numArticles) AS numArticles
FROM
gdelt_data
GROUP BY
1,
2;
```
### Mostrar información sobre puntos de datos en un clúster
Utilice la siguiente consulta para devolver los datos de los puntos asignados al quinto clúster. Los artículos seleccionados deben tener dos actores.
```
SELECT
news_monitoring_cluster (
AvgTone,
EventCode,
NumArticles,
Actor1Geo_Lat,
Actor1Geo_Long,
Actor2Geo_Lat,
Actor2Geo_Long
) AS events_cluster,
eventcode,
actor1name,
actor2name,
SUM(numarticles) AS totalarticles
FROM
gdelt_data
WHERE
events_cluster = 5
AND actor1name <> ' '
AND actor2name <> ' '
GROUP BY
1,
2,
3,
4
ORDER BY
5 desc;
```
### Mostrar datos sobre eventos con actores del mismo código étnico
La siguiente consulta cuenta la cantidad de artículos escritos sobre eventos de tono positivo. La consulta también requiere que los dos actores tengan el mismo código étnico y devuelve a qué grupo está asignado cada evento.
```
SELECT
news_monitoring_cluster (
AvgTone,
EventCode,
NumArticles,
Actor1Geo_Lat,
Actor1Geo_Long,
Actor2Geo_Lat,
Actor2Geo_Long
) AS events_cluster,
SUM(numarticles) AS total_articles,
eventcode AS event_code,
Actor1EthnicCode AS ethnic_code
FROM
gdelt_data
WHERE
Actor1EthnicCode = Actor2EthnicCode
AND Actor1EthnicCode <> ' '
AND Actor2EthnicCode <> ' '
AND AvgTone > 0
GROUP BY
1,
3,
4
HAVING
(total_articles) > 4
ORDER BY
1,
2 ASC;
```
## Temas relacionados
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)
# Tutorial: Creación de modelos de clasificación multiclase
En este tutorial, utilizará Amazon Redshift ML para crear un modelo de machine learning que resuelva los problemas de clasificación multiclase. El algoritmo de clasificación multiclase clasifica los puntos de datos en una de tres o más clases. A continuación, implementará consultas mediante la función SQL que genera el comando CREATE MODEL.
Se puede utilizar un comando CREATE MODEL para exportar datos de entrenamiento, entrenar un modelo, importar ese modelo y preparar una función de predicción de Amazon Redshift. Utilice la operación CREATE MODEL para especificar los datos de entrenamiento en forma de tabla o con la instrucción SELECT.
Para seguir el tutorial, utilice el conjunto de datos público [E-Commerce Sales Forecast](https://www.kaggle.com/allunia/e-commerce-sales-forecast) (Previsión de ventas de comercio electrónico), que incluye datos de ventas de un minorista en línea del Reino Unido. El modelo que genere se dirigirá a los clientes más activos para un programa especial de fidelización de clientes. Con la clasificación multiclase, puede usar el modelo para predecir cuántos meses estará activo un cliente durante un período de 13 meses. La función de predicción designa a los clientes que se prevé que estarán activos durante 7 o más meses para la admisión al programa.
## Ejemplos de casos de uso
Puede resolver otros problemas de clasificación multiclase con Amazon Redshift ML, como predecir el producto más vendido de una línea de productos. También puede predecir qué fruta contiene una imagen, por ejemplo, seleccionar manzanas, peras o naranjas.
**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
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
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. Estas consultas cargan los datos de muestra en Amazon Redshift.
1. En la siguiente consulta, se crea una tabla llamada `ecommerce_sales`.
```
CREATE TABLE IF NOT EXISTS ecommerce_sales (
invoiceno VARCHAR(30),
stockcode VARCHAR(30),
description VARCHAR(60),
quantity DOUBLE PRECISION,
invoicedate VARCHAR(30),
unitprice DOUBLE PRECISION,
customerid BIGINT,
country VARCHAR(25)
);
```
1. La siguiente consulta copia los datos de muestra del [conjunto de datos E-Commerce Sales Forecast](https://www.kaggle.com/allunia/e-commerce-sales-forecast) (Previsión de ventas de comercio electrónico) en la tabla `ecommerce_sales`.
```
COPY ecommerce_sales
FROM
's3://redshift-ml-multiclass/ecommerce_data.txt'
IAM_ROLE default
DELIMITER '\t'
IGNOREHEADER 1
REGION 'us-east-1'
MAXERROR 100;
```
### Dividir los datos
Al crear un modelo en Amazon Redshift ML, SageMaker AI divide automáticamente los datos en conjuntos de entrenamiento y de prueba para que SageMaker AI pueda determinar la precisión del modelo. Al dividir manualmente los datos en este paso, podrá verificar la precisión del modelo asignando un conjunto de predicciones adicional.
Utilice la siguiente instrucción SQL para dividir los datos en tres conjuntos para el entrenamiento, la validación y la predicción.
```
--creates table with all data
CREATE TABLE ecommerce_sales_data AS (
SELECT
t1.stockcode,
t1.description,
t1.invoicedate,
t1.customerid,
t1.country,
t1.sales_amt,
CAST(RANDOM() * 100 AS INT) AS data_group_id
FROM
(
SELECT
stockcode,
description,
invoicedate,
customerid,
country,
SUM(quantity * unitprice) AS sales_amt
FROM
ecommerce_sales
GROUP BY
1,
2,
3,
4,
5
) t1
);
--creates training set
CREATE TABLE ecommerce_sales_training AS (
SELECT
a.customerid,
a.country,
a.stockcode,
a.description,
a.invoicedate,
a.sales_amt,
(b.nbr_months_active) AS nbr_months_active
FROM
ecommerce_sales_data a
INNER JOIN (
SELECT
customerid,
COUNT(
DISTINCT(
DATE_PART(y, CAST(invoicedate AS DATE)) || '-' || LPAD(
DATE_PART(mon, CAST(invoicedate AS DATE)),
2,
'00'
)
)
) AS nbr_months_active
FROM
ecommerce_sales_data
GROUP BY
1
) b ON a.customerid = b.customerid
WHERE
a.data_group_id < 80
);
--creates validation set
CREATE TABLE ecommerce_sales_validation AS (
SELECT
a.customerid,
a.country,
a.stockcode,
a.description,
a.invoicedate,
a.sales_amt,
(b.nbr_months_active) AS nbr_months_active
FROM
ecommerce_sales_data a
INNER JOIN (
SELECT
customerid,
COUNT(
DISTINCT(
DATE_PART(y, CAST(invoicedate AS DATE)) || '-' || LPAD(
DATE_PART(mon, CAST(invoicedate AS DATE)),
2,
'00'
)
)
) AS nbr_months_active
FROM
ecommerce_sales_data
GROUP BY
1
) b ON a.customerid = b.customerid
WHERE
a.data_group_id BETWEEN 80
AND 90
);
--creates prediction set
CREATE TABLE ecommerce_sales_prediction AS (
SELECT
customerid,
country,
stockcode,
description,
invoicedate,
sales_amt
FROM
ecommerce_sales_data
WHERE
data_group_id > 90);
```
## Paso 2: Crear el modelo de machine learning
En este paso, utilizará la instrucción CREATE MODEL para crear el modelo de machine learning mediante la clasificación multiclase.
La siguiente consulta crea el modelo de clasificación multiclase con el conjunto de entrenamiento mediante la operación CREATE MODEL. Reemplace amzn-s3-demo-bucket por el bucket de Amazon S3 propio.
```
CREATE MODEL ecommerce_customer_activity
FROM
(
SELECT
customerid,
country,
stockcode,
description,
invoicedate,
sales_amt,
nbr_months_active
FROM
ecommerce_sales_training
) TARGET nbr_months_active FUNCTION predict_customer_activity IAM_ROLE default PROBLEM_TYPE MULTICLASS_CLASSIFICATION SETTINGS (
S3_BUCKET 'amzn-s3-demo-bucket',
S3_GARBAGE_COLLECT OFF
);
```
En esta consulta, se especifica el tipo de problema como `Multiclass_Classification`. El objetivo que predice para el modelo es `nbr_months_active`. Cuando SageMaker AI termina de entrenar el modelo, crea la función `predict_customer_activity`, que utilizará para hacer predicciones en Amazon Redshift.
### Comprobar el estado del entrenamiento del modelo (opcional)
Puede utilizar el comando SHOW MODEL para saber cuándo está listo el modelo.
Utilice la siguiente consulta para devolver varias métricas del modelo, incluidos el estado y la precisión del modelo.
```
SHOW MODEL ecommerce_customer_activity;
```
Cuando el modelo esté listo, la salida de la operación anterior debería mostrar que `Model State` es `Ready`. A continuación se muestra un ejemplo de la salida de la operación SHOW MODEL.
```
+--------------------------+-----------------------------------------------------------------------------------------------+
| Model Name | ecommerce_customer_activity |
+--------------------------+-----------------------------------------------------------------------------------------------+
| Schema Name | public |
| Owner | awsuser |
| Creation Time | Fri, 17.06.2022 19:02:15 |
| Model State | READY |
| Training Job Status | MaxAutoMLJobRuntimeReached |
| validation:accuracy | 0.991280 |
| Estimated Cost | 7.897689 |
| | |
| TRAINING DATA: | |
| Query | SELECT CUSTOMERID, COUNTRY, STOCKCODE, DESCRIPTION, INVOICEDATE, SALES_AMT, NBR_MONTHS_ACTIVE |
| | FROM ECOMMERCE_SALES_TRAINING |
| Target Column | NBR_MONTHS_ACTIVE |
| | |
| PARAMETERS: | |
| Model Type | xgboost |
| Problem Type | MulticlassClassification |
| Objective | Accuracy |
| AutoML Job Name | redshiftml-20220617190215268770 |
| Function Name | predict_customer_activity |
| Function Parameters | customerid country stockcode description invoicedate sales_amt |
| Function Parameter Types | int8 varchar varchar varchar varchar float8 |
| IAM Role | default-aws-iam-role |
| S3 Bucket | amzn-s3-demo-bucket |
| Max Runtime | 5400 |
+--------------------------+-----------------------------------------------------------------------------------------------+
```
## Paso 3: Realizar predicciones con el modelo
La siguiente consulta muestra qué clientes califican para su programa de fidelización de clientes. Si el modelo predice que el cliente estará activo durante al menos siete meses, el modelo seleccionará al cliente para el programa de fidelización.
```
SELECT
customerid,
predict_customer_activity(
customerid,
country,
stockcode,
description,
invoicedate,
sales_amt
) AS predicted_months_active
FROM
ecommerce_sales_prediction
WHERE
predicted_months_active >= 7
GROUP BY
1,
2
LIMIT
10;
```
### Ejecutar consultas de predicción contra los datos de validación (opcional)
Ejecute las siguientes consultas de predicción con los datos de validación para comprobar el nivel de precisión del modelo.
```
SELECT
CAST(SUM(t1.match) AS decimal(7, 2)) AS predicted_matches,
CAST(SUM(t1.nonmatch) AS decimal(7, 2)) AS predicted_non_matches,
CAST(SUM(t1.match + t1.nonmatch) AS decimal(7, 2)) AS total_predictions,
predicted_matches / total_predictions AS pct_accuracy
FROM
(
SELECT
customerid,
country,
stockcode,
description,
invoicedate,
sales_amt,
nbr_months_active,
predict_customer_activity(
customerid,
country,
stockcode,
description,
invoicedate,
sales_amt
) AS predicted_months_active,
CASE
WHEN nbr_months_active = predicted_months_active THEN 1
ELSE 0
END AS match,
CASE
WHEN nbr_months_active <> predicted_months_active THEN 1
ELSE 0
END AS nonmatch
FROM
ecommerce_sales_validation
)t1;
```
### Prediga cuántos clientes no ingresan (opcional)
La siguiente consulta compara la cantidad de clientes que se prevé que estarán activos solo durante 5 o 6 meses. El modelo predice que estos clientes se quedarán fuera del programa de fidelización. A continuación, la consulta compara la cantidad que se quedan fuera del programa con el número que se prevé que cumpla los requisitos para el programa de fidelización. Esta consulta podría usarse para tomar una decisión sobre si reducir el umbral del programa de fidelización. También puede determinar si hay una cantidad significativa de clientes que se prevé que se quedarán fuera del programa por poco. A continuación, puede alentar a esos clientes a aumentar su actividad para poder entrar en el programa de fidelización.
```
SELECT
predict_customer_activity(
customerid,
country,
stockcode,
description,
invoicedate,
sales_amt
) AS predicted_months_active,
COUNT(customerid)
FROM
ecommerce_sales_prediction
WHERE
predicted_months_active BETWEEN 5 AND 6
GROUP BY
1
ORDER BY
1 ASC
LIMIT
10)
UNION
(SELECT
NULL AS predicted_months_active,
COUNT (customerid)
FROM
ecommerce_sales_prediction
WHERE
predict_customer_activity(
customerid,
country,
stockcode,
description,
invoicedate,
sales_amt
) >=7);
```
## Temas relacionados
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)
# Tutorial: Creación de modelos XGBoost
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
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
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
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
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)
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
### Comprobar la precisión del modelo
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
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
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
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)
# Tutorial: Creación de modelos de regresión
En este tutorial, utilizará Amazon Redshift ML para crear un modelo de regresión de machine learning y ejecutar consultas de predicción en el modelo. Los modelos de regresión le permiten predecir resultados numéricos, como el precio de una casa o cuántas personas utilizarán el servicio de alquiler de bicicletas de una ciudad. El comando CREATE MODEL se usa en Amazon Redshift con los datos de entrenamiento. A continuación, Amazon Redshift ML compila el modelo, importa el modelo entrenado a Redshift y prepara una función de predicción de SQL. Puede usar la función de predicción en consultas SQL en Amazon Redshift.
En este tutorial, utilizará Amazon Redshift ML para crear un modelo de regresión que prediga el número de personas que utilizan el servicio de bicicletas compartidas de la ciudad de Toronto a cualquier hora del día. Las entradas para el modelo incluyen días festivos y condiciones meteorológicas. Utilizará un modelo de regresión, porque quiere un resultado numérico para este problema.
Puede utilizar el comando CREATE MODEL para exportar datos de entrenamiento, entrenar un modelo y hacer que el modelo esté disponible en Amazon Redshift como una función SQL. Utilice la operación CREATE MODEL para especificar los datos de entrenamiento en forma de tabla o con la instrucción SELECT.
## Ejemplos de casos de uso
Puede resolver otros problemas de regresión con Amazon Redshift ML, como predecir el valor de por vida de un cliente. También puede usar Redshift ML para predecir el precio más rentable y los ingresos resultantes de un producto.
**Tareas**
+ Requisitos previos
+ Paso 1: Cargar los datos desde Amazon S3 en Amazon Redshift
+ Paso 2: Crear el modelo de machine learning
+ Paso 3: Validar el modelo
## Requisitos previos
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
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.
1. Debe crear tres tablas para cargar los tres conjuntos de datos públicos en Amazon Redshift. Los conjuntos de datos son los [datos del número de usuarios de bicicletas de Toronto](https://open.toronto.ca/dataset/bike-share-toronto-ridership-data/), los[datos meteorológicos históricos](https://climate.weather.gc.ca/historical_data/search_historic_data_e.html) y los [datos históricos de días festivos](https://github.com/uWaterloo/Datasets/blob/master/Holidays/holidays.csv). Ejecute la siguiente consulta en el editor de consultas de Amazon Redshift para crear las tablas denominadas `ridership`, `weather` y `holiday`.
```
CREATE TABLE IF NOT EXISTS ridership (
trip_id INT,
trip_duration_seconds INT,
trip_start_time timestamp,
trip_stop_time timestamp,
from_station_name VARCHAR(50),
to_station_name VARCHAR(50),
from_station_id SMALLINT,
to_station_id SMALLINT,
user_type VARCHAR(20)
);
CREATE TABLE IF NOT EXISTS weather (
longitude_x DECIMAL(5, 2),
latitude_y DECIMAL(5, 2),
station_name VARCHAR(20),
climate_id BIGINT,
datetime_utc TIMESTAMP,
weather_year SMALLINT,
weather_month SMALLINT,
weather_day SMALLINT,
time_utc VARCHAR(5),
temp_c DECIMAL(5, 2),
temp_flag VARCHAR(1),
dew_point_temp_c DECIMAL(5, 2),
dew_point_temp_flag VARCHAR(1),
rel_hum SMALLINT,
rel_hum_flag VARCHAR(1),
precip_amount_mm DECIMAL(5, 2),
precip_amount_flag VARCHAR(1),
wind_dir_10s_deg VARCHAR(10),
wind_dir_flag VARCHAR(1),
wind_spd_kmh VARCHAR(10),
wind_spd_flag VARCHAR(1),
visibility_km VARCHAR(10),
visibility_flag VARCHAR(1),
stn_press_kpa DECIMAL(5, 2),
stn_press_flag VARCHAR(1),
hmdx SMALLINT,
hmdx_flag VARCHAR(1),
wind_chill VARCHAR(10),
wind_chill_flag VARCHAR(1),
weather VARCHAR(10)
);
CREATE TABLE IF NOT EXISTS holiday (holiday_date DATE, description VARCHAR(100));
```
1. La siguiente consulta carga los datos de muestra en las tablas que ha creado en el paso anterior.
```
COPY ridership
FROM
's3://redshift-ml-bikesharing-data/bike-sharing-data/ridership/'
IAM_ROLE default
FORMAT CSV
IGNOREHEADER 1
DATEFORMAT 'auto'
TIMEFORMAT 'auto'
REGION 'us-west-2'
gzip;
COPY weather
FROM
's3://redshift-ml-bikesharing-data/bike-sharing-data/weather/'
IAM_ROLE default
FORMAT csv
IGNOREHEADER 1
DATEFORMAT 'auto'
TIMEFORMAT 'auto'
REGION 'us-west-2'
gzip;
COPY holiday
FROM
's3://redshift-ml-bikesharing-data/bike-sharing-data/holiday/'
IAM_ROLE default
FORMAT csv
IGNOREHEADER 1
DATEFORMAT 'auto'
TIMEFORMAT 'auto'
REGION 'us-west-2'
gzip;
```
1. La siguiente consulta realiza transformaciones en los conjuntos da datos `ridership` y `weather` para eliminar sesgos o anomalías. La eliminación de sesgos y anomalías mejora la precisión del modelo. La consulta simplifica las tablas mediante la creación de dos nuevas vistas denominadas `ridership_view` y `weather_view`.
```
CREATE
OR REPLACE VIEW ridership_view AS
SELECT
trip_time,
trip_count,
TO_CHAR(trip_time, 'hh24') :: INT trip_hour,
TO_CHAR(trip_time, 'dd') :: INT trip_day,
TO_CHAR(trip_time, 'mm') :: INT trip_month,
TO_CHAR(trip_time, 'yy') :: INT trip_year,
TO_CHAR(trip_time, 'q') :: INT trip_quarter,
TO_CHAR(trip_time, 'w') :: INT trip_month_week,
TO_CHAR(trip_time, 'd') :: INT trip_week_day
FROM
(
SELECT
CASE
WHEN TRUNC(r.trip_start_time) < '2017-07-01' :: DATE THEN CONVERT_TIMEZONE(
'US/Eastern',
DATE_TRUNC('hour', r.trip_start_time)
)
ELSE DATE_TRUNC('hour', r.trip_start_time)
END trip_time,
COUNT(1) trip_count
FROM
ridership r
WHERE
r.trip_duration_seconds BETWEEN 60
AND 60 * 60 * 24
GROUP BY
1
);
CREATE
OR REPLACE VIEW weather_view AS
SELECT
CONVERT_TIMEZONE(
'US/Eastern',
DATE_TRUNC('hour', datetime_utc)
) daytime,
ROUND(AVG(temp_c)) temp_c,
ROUND(AVG(precip_amount_mm)) precip_amount_mm
FROM
weather
GROUP BY
1;
```
1. La siguiente consulta crea una tabla que combina todos los atributos de entrada relevantes de `ridership_view` y `weather_view` en la tabla `trip_data`.
```
CREATE TABLE trip_data AS
SELECT
r.trip_time,
r.trip_count,
r.trip_hour,
r.trip_day,
r.trip_month,
r.trip_year,
r.trip_quarter,
r.trip_month_week,
r.trip_week_day,
w.temp_c,
w.precip_amount_mm,CASE
WHEN h.holiday_date IS NOT NULL THEN 1
WHEN TO_CHAR(r.trip_time, 'D') :: INT IN (1, 7) THEN 1
ELSE 0
END is_holiday,
ROW_NUMBER() OVER (
ORDER BY
RANDOM()
) serial_number
FROM
ridership_view r
JOIN weather_view w ON (r.trip_time = w.daytime)
LEFT OUTER JOIN holiday h ON (TRUNC(r.trip_time) = h.holiday_date);
```
### Ver los datos de muestra (opcional)
La siguiente consulta muestra las entradas de la tabla. Puede ejecutar esta operación para asegurarse de que la tabla se creó correctamente.
```
SELECT *
FROM trip_data
LIMIT 5;
```
A continuación se muestra un ejemplo de la salida de la operación anterior.
```
+---------------------+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
| trip_time | trip_count | trip_hour | trip_day | trip_month | trip_year | trip_quarter | trip_month_week | trip_week_day | temp_c | precip_amount_mm | is_holiday | serial_number |
+---------------------+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
| 2017-03-21 22:00:00 | 47 | 22 | 21 | 3 | 17 | 1 | 3 | 3 | 1 | 0 | 0 | 1 |
| 2018-05-04 01:00:00 | 19 | 1 | 4 | 5 | 18 | 2 | 1 | 6 | 12 | 0 | 0 | 3 |
| 2018-01-11 10:00:00 | 93 | 10 | 11 | 1 | 18 | 1 | 2 | 5 | 9 | 0 | 0 | 5 |
| 2017-10-28 04:00:00 | 20 | 4 | 28 | 10 | 17 | 4 | 4 | 7 | 11 | 0 | 1 | 7 |
| 2017-12-31 21:00:00 | 11 | 21 | 31 | 12 | 17 | 4 | 5 | 1 | -15 | 0 | 1 | 9 |
+---------------------+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
```
### Mostrar la correlación entre los atributos (opcional)
Determinar la correlación le ayuda a medir la fuerza de la asociación entre los atributos. El nivel de asociación puede ayudarle a determinar qué afecta a la salida objetivo. En este tutorial, la salida objetivo es `trip_count`.
La siguiente consulta crea o reemplaza el procedimiento `sp_correlation`. Se utiliza el procedimiento almacenado denominado `sp_correlation` para mostrar la correlación entre un atributo y otros atributos en una tabla de Amazon Redshift.
```
CREATE OR REPLACE PROCEDURE sp_correlation(source_schema_name in varchar(255), source_table_name in varchar(255), target_column_name in varchar(255), output_temp_table_name inout varchar(255)) AS $$
DECLARE
v_sql varchar(max);
v_generated_sql varchar(max);
v_source_schema_name varchar(255)=lower(source_schema_name);
v_source_table_name varchar(255)=lower(source_table_name);
v_target_column_name varchar(255)=lower(target_column_name);
BEGIN
EXECUTE 'DROP TABLE IF EXISTS ' || output_temp_table_name;
v_sql = '
SELECT
''CREATE temp table '|| output_temp_table_name||' AS SELECT ''|| outer_calculation||
'' FROM (SELECT COUNT(1) number_of_items, SUM('||v_target_column_name||') sum_target, SUM(POW('||v_target_column_name||',2)) sum_square_target, POW(SUM('||v_target_column_name||'),2) square_sum_target,''||
inner_calculation||
'' FROM (SELECT ''||
column_name||
'' FROM '||v_source_table_name||'))''
FROM
(
SELECT
DISTINCT
LISTAGG(outer_calculation,'','') OVER () outer_calculation
,LISTAGG(inner_calculation,'','') OVER () inner_calculation
,LISTAGG(column_name,'','') OVER () column_name
FROM
(
SELECT
CASE WHEN atttypid=16 THEN ''DECODE(''||column_name||'',true,1,0)'' ELSE column_name END column_name
,atttypid
,''CAST(DECODE(number_of_items * sum_square_''||rn||'' - square_sum_''||rn||'',0,null,(number_of_items*sum_target_''||rn||'' - sum_target * sum_''||rn||
'')/SQRT((number_of_items * sum_square_target - square_sum_target) * (number_of_items * sum_square_''||rn||
'' - square_sum_''||rn||''))) AS numeric(5,2)) ''||column_name outer_calculation
,''sum(''||column_name||'') sum_''||rn||'',''||
''SUM(trip_count*''||column_name||'') sum_target_''||rn||'',''||
''SUM(POW(''||column_name||'',2)) sum_square_''||rn||'',''||
''POW(SUM(''||column_name||''),2) square_sum_''||rn inner_calculation
FROM
(
SELECT
row_number() OVER (order by a.attnum) rn
,a.attname::VARCHAR column_name
,a.atttypid
FROM pg_namespace AS n
INNER JOIN pg_class AS c ON n.oid = c.relnamespace
INNER JOIN pg_attribute AS a ON c.oid = a.attrelid
WHERE a.attnum > 0
AND n.nspname = '''||v_source_schema_name||'''
AND c.relname = '''||v_source_table_name||'''
AND a.atttypid IN (16,20,21,23,700,701,1700)
)
)
)';
EXECUTE v_sql INTO v_generated_sql;
EXECUTE v_generated_sql;
END;
$$ LANGUAGE plpgsql;
```
La siguiente consulta muestra la correlación entre la columna objetivo, `trip_count`, y otros atributos numéricos de nuestro conjunto de datos.
```
call sp_correlation(
'public',
'trip_data',
'trip_count',
'tmp_corr_table'
);
SELECT
*
FROM
tmp_corr_table;
```
A continuación se muestra la salida de la operación `sp_correlation` anterior.
```
+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
| trip_count | trip_hour | trip_day | trip_month | trip_year | trip_quarter | trip_month_week | trip_week_day | temp_c | precip_amount_mm | is_holiday | serial_number |
+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
| 1 | 0.32 | 0.01 | 0.18 | 0.12 | 0.18 | 0 | 0.02 | 0.53 | -0.07 | -0.13 | 0 |
+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
```
## Paso 2: Crear el modelo de machine learning
1. La siguiente consulta divide los datos en un conjunto de entrenamiento y un conjunto de validación al designar el 80 % del conjunto de datos para el entrenamiento y el 20 % para la validación. El conjunto de entrenamiento es la entrada del modelo de ML para identificar el mejor algoritmo posible para el modelo. Una vez creado el modelo, se utiliza el conjunto de validación para validar la precisión del modelo.
```
CREATE TABLE training_data AS
SELECT
trip_count,
trip_hour,
trip_day,
trip_month,
trip_year,
trip_quarter,
trip_month_week,
trip_week_day,
temp_c,
precip_amount_mm,
is_holiday
FROM
trip_data
WHERE
serial_number > (
SELECT
COUNT(1) * 0.2
FROM
trip_data
);
CREATE TABLE validation_data AS
SELECT
trip_count,
trip_hour,
trip_day,
trip_month,
trip_year,
trip_quarter,
trip_month_week,
trip_week_day,
temp_c,
precip_amount_mm,
is_holiday,
trip_time
FROM
trip_data
WHERE
serial_number <= (
SELECT
COUNT(1) * 0.2
FROM
trip_data
);
```
1. La siguiente consulta crea un modelo de regresión para predecir el valor de `trip_count` para cualquier fecha y hora de entrada. En el siguiente ejemplo, reemplace amzn-s3-demo-bucket por el bucket de S3 propio.
```
CREATE MODEL predict_rental_count
FROM
training_data TARGET trip_count FUNCTION predict_rental_count
IAM_ROLE default
PROBLEM_TYPE regression
OBJECTIVE 'mse'
SETTINGS (
s3_bucket 'amzn-s3-demo-bucket',
s3_garbage_collect off,
max_runtime 5000
);
```
## Paso 3: Validar el modelo
1. Utilice la siguiente consulta para generar aspectos del modelo y buscar la métrica del error cuadrado medio raíz en la salida. El error cuadrado medio es una métrica de precisión típica para los problemas de regresión.
```
show model predict_rental_count;
```
1. Ejecute las siguientes consultas de predicción con los datos de validación para comparar el recuento de viajes previsto con el recuento de viajes real.
```
SELECT
trip_time,
actual_count,
predicted_count,
(actual_count - predicted_count) difference
FROM
(
SELECT
trip_time,
trip_count AS actual_count,
PREDICT_RENTAL_COUNT (
trip_hour,
trip_day,
trip_month,
trip_year,
trip_quarter,
trip_month_week,
trip_week_day,
temp_c,
precip_amount_mm,
is_holiday
) predicted_count
FROM
validation_data
)
LIMIT
5;
```
1. La siguiente consulta calcula el error cuadrado medio y el error cuadrado medio raíz basándose en los datos de validación. El error cuadrado medio y el error cuadrado medio raíz se utilizan para medir la distancia entre el destino numérico predicho y la respuesta numérica real. Un buen modelo tiene una puntuación baja en ambas métricas. La siguiente consulta devuelve el valor de ambas métricas.
```
SELECT
ROUND(
AVG(POWER((actual_count - predicted_count), 2)),
2
) mse,
ROUND(
SQRT(AVG(POWER((actual_count - predicted_count), 2))),
2
) rmse
FROM
(
SELECT
trip_time,
trip_count AS actual_count,
PREDICT_RENTAL_COUNT (
trip_hour,
trip_day,
trip_month,
trip_year,
trip_quarter,
trip_month_week,
trip_week_day,
temp_c,
precip_amount_mm,
is_holiday
) predicted_count
FROM
validation_data
);
```
1. La siguiente consulta calcula el porcentaje de error en el recuento de viajes para cada tiempo de viaje el 01/01/2017. La consulta ordena los tiempos de viaje desde el tiene el error porcentual más bajo hasta el tiempo con el error porcentual más alto.
```
SELECT
trip_time,
CAST(ABS(((actual_count - predicted_count) / actual_count)) * 100 AS DECIMAL (7,2)) AS pct_error
FROM
(
SELECT
trip_time,
trip_count AS actual_count,
PREDICT_RENTAL_COUNT (
trip_hour,
trip_day,
trip_month,
trip_year,
trip_quarter,
trip_month_week,
trip_week_day,
temp_c,
precip_amount_mm,
is_holiday
) predicted_count
FROM
validation_data
)
WHERE
trip_time LIKE '2017-01-01 %%:%%:%%'
ORDER BY
2 ASC;
```
## Temas relacionados
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)
# Tutorial: Creación de modelos de regresión con aprendizaje lineal
En este tutorial, creará un modelo de aprendizaje lineal con datos de Amazon S3 y ejecutará consultas de predicción con el modelo mediante Amazon Redshift ML. El algoritmo de aprendizaje lineal de SageMaker AI resuelve problemas de regresión o clasificación multiclase. Para obtener más información sobre los problemas de regresión y clasificación multiclase, consulte [Problem types for the machine learning paradigms](https://docs.aws.amazon.com/sagemaker/latest/dg/algorithms-choose.html#basic-machine-learning-paradigms) en la Guía para desarrolladores de Amazon SageMaker AI. En este tutorial, resolverá un problema de regresión. El algoritmo de aprendizaje lineal entrena muchos modelos en paralelo y determina automáticamente el modelo más optimizado. Utilice la operación CREATE MODEL en Amazon Redshift, que crea el modelo de aprendizaje lineal mediante SageMaker AI y envía una función de predicción a Amazon Redshift. Para obtener más información sobre el algoritmo de aprendizaje lineal, consulte [Algoritmo de aprendizaje lineal](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html) en la Guía para desarrolladores de Amazon SageMaker AI.
Se puede utilizar un comando CREATE MODEL para exportar datos de entrenamiento, entrenar un modelo, importar ese modelo y preparar una función de predicción de Amazon Redshift. Utilice la operación CREATE MODEL para especificar los datos de entrenamiento en forma de tabla o con la instrucción SELECT.
Los modelos de aprendizaje lineal optimizan los objetivos continuos o los objetivos discretos. Los objetivos continuos se utilizan para la regresión, mientras que las variables discretas se utilizan para la clasificación. Algunos métodos proporcionan una solución solo para objetivos continuos, como el método de regresión. El algoritmo de aprendizaje lineal proporciona un aumento de la velocidad comparado con las técnicas de optimización de hiperparámetros ingenua, como la técnica Naive Bayes. La técnica de optimización ingenua supone que cada variable de entrada es independiente. Para utilizar el algoritmo de aprendizaje lineal, debe proporcionar columnas que representan las dimensiones de las entradas y filas que representan las observaciones. Para obtener más información sobre el algoritmo de aprendizaje lineal, consulte [Algoritmo de aprendizaje lineal](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html) en la Guía para desarrolladores de Amazon SageMaker AI.
En este tutorial, vamos a crear un modelo de aprendizaje lineal que predice la edad del abulón. Utilice el comando CREATE MODEL en el [conjunto de datos del abulón](http://archive.ics.uci.edu/ml/datasets/Abalone) para determinar la relación entre las medidas físicas del abulón. Luego, utilice el modelo para determinar la edad del abulón.
## Ejemplos de casos de uso
Puede resolver otros problemas de regresión con el aprendizaje lineal y Amazon Redshift ML, como predecir el precio de una casa. También puede usar Redshift ML para predecir la cantidad de personas que usarán el servicio de alquiler de bicicletas de una ciudad.
**Tareas**
+ Requisitos previos
+ Paso 1: Cargar los datos desde Amazon S3 en Amazon Redshift
+ Paso 2: Crear el modelo de machine learning
+ Paso 3: Validar el modelo
## Requisitos previos
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
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. Estas consultas cargan los datos de muestra en Redshift y los dividen en un conjunto de entrenamiento y un conjunto de validación.
1. En la siguiente consulta, se crea la tabla `abalone_dataset`.
```
CREATE TABLE abalone_dataset (
id INT IDENTITY(1, 1),
Sex CHAR(1),
Length float,
Diameter float,
Height float,
Whole float,
Shucked float,
Viscera float,
Shell float,
Rings integer
);
```
1. La siguiente consulta copia los datos de muestra del [conjunto de datos de abulón](http://archive.ics.uci.edu/ml/datasets/Abalone) en Amazon S3 en la tabla `abalone_dataset` que creó anteriormente en Amazon Redshift.
```
COPY abalone_dataset
FROM
's3://redshift-ml-multiclass/abalone.csv' REGION 'us-east-1' IAM_ROLE default CSV IGNOREHEADER 1 NULL AS 'NULL';
```
1. Al dividir manualmente los datos, podrá verificar la precisión del modelo asignando un conjunto de predicciones adicional. La siguiente consulta divide los datos en dos conjuntos. La tabla `abalone_training` es para el entrenamiento y la tabla `abalone_validation`l es para validación.
```
CREATE TABLE abalone_training as
SELECT
*
FROM
abalone_dataset
WHERE
mod(id, 10) < 8;
CREATE TABLE abalone_validation as
SELECT
*
FROM
abalone_dataset
WHERE
mod(id, 10) >= 8;
```
## Paso 2: Crear el modelo de machine learning
En este paso, utilizará la instrucción CREATE MODEL para crear el modelo de machine learning con el algoritmo de aprendizaje lineal.
La siguiente consulta crea el modelo de aprendizaje lineal con la operación CREATE MODEL mediante el bucket de S3. Reemplace amzn-s3-demo-bucket por el bucket de S3 propio.
```
CREATE MODEL model_abalone_ring_prediction
FROM
(
SELECT
Sex,
Length,
Diameter,
Height,
Whole,
Shucked,
Viscera,
Shell,
Rings AS target_label
FROM
abalone_training
) TARGET target_label FUNCTION f_abalone_ring_prediction IAM_ROLE default MODEL_TYPE LINEAR_LEARNER PROBLEM_TYPE REGRESSION OBJECTIVE 'MSE' SETTINGS (
S3_BUCKET 'amzn-s3-demo-bucket',
MAX_RUNTIME 15000
);
```
### Comprobar el estado del entrenamiento del modelo (opcional)
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_abalone_ring_prediction;
```
Cuando el modelo esté listo, la salida de la operación anterior tendrá un aspecto semejante al del siguiente ejemplo. Tenga en cuenta que la salida proporciona la métrica `validation:mse`, que es el error cuadrado medio. Utilice el error cuadrado medio para validar la precisión del modelo en el paso siguiente.
```
+--------------------------+----------------------------------------------------------------------------------------------------+
| Model Name | model_abalone_ring_prediction |
+--------------------------+----------------------------------------------------------------------------------------------------+
| Schema Name | public |
| Owner | awsuser |
| Creation Time | Thu, 30.06.2022 18:00:10 |
| Model State | READY |
| validation:mse | 4.168633 |
| Estimated Cost | 4.291608 |
| | |
| TRAINING DATA: | |
| Query | SELECT SEX , LENGTH , DIAMETER , HEIGHT , WHOLE , SHUCKED , VISCERA , SHELL, RINGS AS TARGET_LABEL |
| | FROM ABALONE_TRAINING |
| Target Column | TARGET_LABEL |
| | |
| PARAMETERS: | |
| Model Type | linear_learner |
| Problem Type | Regression |
| Objective | MSE |
| AutoML Job Name | redshiftml-20220630180010947843 |
| Function Name | f_abalone_ring_prediction |
| Function Parameters | sex length diameter height whole shucked viscera shell |
| Function Parameter Types | bpchar float8 float8 float8 float8 float8 float8 float8 |
| IAM Role | default-aws-iam-role |
| S3 Bucket | amzn-s3-demo-bucket |
| Max Runtime | 15000 |
+--------------------------+----------------------------------------------------------------------------------------------------+
```
## Paso 3: Validar el modelo
1. La siguiente consulta de predicción valida la precisión del modelo en el conjunto de datos `abalone_validation`calculando el error cuadrado medio y el error cuadrado medio raíz.
```
SELECT
ROUND(AVG(POWER((tgt_label - predicted), 2)), 2) mse,
ROUND(SQRT(AVG(POWER((tgt_label - predicted), 2))), 2) rmse
FROM
(
SELECT
Sex,
Length,
Diameter,
Height,
Whole,
Shucked,
Viscera,
Shell,
Rings AS tgt_label,
f_abalone_ring_prediction(
Sex,
Length,
Diameter,
Height,
Whole,
Shucked,
Viscera,
Shell
) AS predicted,
CASE
WHEN tgt_label = predicted then 1
ELSE 0
END AS match,
CASE
WHEN tgt_label <> predicted then 1
ELSE 0
END AS nonmatch
FROM
abalone_validation
) t1;
```
La salida de la consulta anterior tendrá un aspecto semejante al de este ejemplo. El valor de la métrica del error cuadrado medio debe ser similar al valor de la métrica `validation:mse` que se muestra en la salida de la operación SHOW MODEL.
```
+-----+--------------------+
| mse | rmse |
+-----+--------------------+
| 5.1 | 2.2600000000000002 |
+-----+--------------------+
```
1. Utilice la siguiente consulta para ejecutar la operación EXPLAIN\$1MODEL en la función de predicción. La operación devolverá un informe de explicabilidad del modelo. Para obtener más información sobre la operación EXPLAIN\$1MODEL, consulte [Función EXPLAIN\$1MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html) en la Guía para desarrolladores de bases de datos de Amazon Redshift.
```
SELECT
EXPLAIN_MODEL ('model_abalone_ring_prediction');
```
La siguiente información es un ejemplo del informe de explicabilidad del modelo generado por la operación EXPLAIN\$1MODEL anterior. Los valores de cada una de las entradas son valores de Shapley. Los valores de Shapley representan el efecto que tiene cada entrada en la predicción de su modelo, donde las entradas de mayor valor tienen más impacto en la predicción. En este ejemplo, las entradas de mayor valor tienen más impacto en la predicción de la edad del abulón.
```
{
"explanations": {
"kernel_shap": {
"label0": {
"expected_value" :10.290688514709473,
"global_shap_values": {
"diameter" :0.6856910187882492,
"height" :0.4415323937124035,
"length" :0.21507476107609084,
"sex" :0.448611774505744,
"shell" :1.70426496893776,
"shucked" :2.1181392924386994,
"viscera" :0.342220754059912,
"whole" :0.6711906974084011
}
}
}
},
"version" :"1.0"
};
```
1. Utilice la siguiente consulta para calcular el porcentaje de predicciones correctas que el modelo hace sobre los abulones que aún no están maduros. Los abulones inmaduros tienen 10 anillos o menos, y una predicción correcta es precisa dentro de un anillo del número real de anillos.
```
SELECT
TRUNC(
SUM(
CASE
WHEN ROUND(
f_abalone_ring_prediction(
Sex,
Length,
Diameter,
Height,
Whole,
Shucked,
Viscera,
Shell
),
0
) BETWEEN Rings - 1
AND Rings + 1 THEN 1
ELSE 0
END
) / CAST(COUNT(SHELL) AS FLOAT),
4
) AS prediction_pct
FROM
abalone_validation
WHERE
Rings <= 10;
```
## Temas relacionados
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)
# Tutorial: Creación de modelos de clasificación multiclase con aprendizaje lineal
En este tutorial, creará un modelo de aprendizaje lineal con datos de Amazon S3 y, a continuación, ejecutará consultas de predicción con el modelo mediante Amazon Redshift ML. El algoritmo de aprendizaje lineal de SageMaker AI resuelve problemas de regresión o clasificación. Para obtener más información sobre los problemas de regresión y clasificación multiclase, consulte [Problem types for the machine learning paradigms](https://docs.aws.amazon.com/sagemaker/latest/dg/algorithms-choose.html#basic-machine-learning-paradigms) en la Guía para desarrolladores de Amazon SageMaker AI. En este tutorial, solucionará un problema de clasificación multiclase. El algoritmo de aprendizaje lineal entrena muchos modelos en paralelo y determina automáticamente el modelo más optimizado. Utilice la operación CREATE MODEL en Amazon Redshift, que crea el modelo de aprendizaje lineal mediante SageMaker AI y envía la función de predicción a Amazon Redshift. Para obtener más información sobre el algoritmo de aprendizaje lineal, consulte [Algoritmo de aprendizaje lineal](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html) en la Guía para desarrolladores de Amazon SageMaker AI.
Se puede utilizar un comando CREATE MODEL para exportar datos de entrenamiento, entrenar un modelo, importar ese modelo y preparar una función de predicción de Amazon Redshift. Utilice la operación CREATE MODEL para especificar los datos de entrenamiento en forma de tabla o con la instrucción SELECT.
Los modelos de aprendizaje lineal optimizan los objetivos continuos o los objetivos discretos. Los objetivos continuos se utilizan para la regresión, mientras que las variables discretas se utilizan para la clasificación. Algunos métodos proporcionan una solución solo para objetivos continuos, como un método de regresión. El algoritmo de aprendizaje lineal proporciona un aumento de la velocidad comparado con las técnicas de optimización de hiperparámetros ingenua, como la técnica Naive Bayes. La técnica de optimización ingenua supone que cada variable de entrada es independiente. El algoritmo de aprendizaje lineal entrena muchos modelos en paralelo y selecciona el modelo más optimizado. Un algoritmo similar es XGBoost, que combina estimaciones de un conjunto de modelos más simples y más débiles para hacer predicciones. Para obtener más información sobre XGBoost, consulte [Algoritmo XGBoost](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost.html) en la Guía para desarrolladores de Amazon SageMaker AI.
Para utilizar el algoritmo de aprendizaje lineal, debe proporcionar columnas que representan las dimensiones de las entradas y filas que representan las observaciones. Para obtener más información sobre el algoritmo de aprendizaje lineal, consulte [Algoritmo de aprendizaje lineal](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html) en la Guía para desarrolladores de Amazon SageMaker AI.
En este tutorial, creará un modelo de aprendizaje lineal que predice los tipos de cubiertas para un área determinada. Utilice el comando CREATE MODEL en el [conjunto de datos Covertype](https://archive.ics.uci.edu/ml/datasets/covertype) de UCI Machine Learning Repository. A continuación, utilice la función de predicción creada por el comando para determinar los tipos de cubierta en un área natural. Un tipo de cubierta forestal suele ser un tipo de árbol. Las entradas que utilizará Redshift ML para crear el modelo incluyen el tipo de suelo, la distancia a las carreteras y la designación de áreas naturales. Para obtener más información sobre el conjunto de datos, consulte el [conjunto de datos Covertype](https://archive.ics.uci.edu/ml/datasets/covertype) de UCI Machine Learning Repository.
## Ejemplos de casos de uso
Puede resolver otros problemas de clasificación multiclase con el aprendizaje lineal con Amazon Redshift ML, como predecir la especie de una planta a partir de una imagen. También puede predecir la cantidad de un producto que comprará un cliente.
**Tareas**
+ Requisitos previos
+ Paso 1: Cargar los datos desde Amazon S3 en Amazon Redshift
+ Paso 2: Crear el modelo de machine learning
+ Paso 3: Validar el modelo
## Requisitos previos
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
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. Estas consultas cargan los datos de muestra en Redshift y los dividen en un conjunto de entrenamiento y un conjunto de validación.
1. En la siguiente consulta, se crea la tabla `covertype_data`.
```
CREATE TABLE public.covertype_data (
elevation bigint ENCODE az64,
aspect bigint ENCODE az64,
slope bigint ENCODE az64,
horizontal_distance_to_hydrology bigint ENCODE az64,
vertical_distance_to_hydrology bigint ENCODE az64,
horizontal_distance_to_roadways bigint ENCODE az64,
hillshade_9am bigint ENCODE az64,
hillshade_noon bigint ENCODE az64,
hillshade_3pm bigint ENCODE az64,
horizontal_distance_to_fire_points bigint ENCODE az64,
wilderness_area1 bigint ENCODE az64,
wilderness_area2 bigint ENCODE az64,
wilderness_area3 bigint ENCODE az64,
wilderness_area4 bigint ENCODE az64,
soil_type1 bigint ENCODE az64,
soil_type2 bigint ENCODE az64,
soil_type3 bigint ENCODE az64,
soil_type4 bigint ENCODE az64,
soil_type5 bigint ENCODE az64,
soil_type6 bigint ENCODE az64,
soil_type7 bigint ENCODE az64,
soil_type8 bigint ENCODE az64,
soil_type9 bigint ENCODE az64,
soil_type10 bigint ENCODE az64,
soil_type11 bigint ENCODE az64,
soil_type12 bigint ENCODE az64,
soil_type13 bigint ENCODE az64,
soil_type14 bigint ENCODE az64,
soil_type15 bigint ENCODE az64,
soil_type16 bigint ENCODE az64,
soil_type17 bigint ENCODE az64,
soil_type18 bigint ENCODE az64,
soil_type19 bigint ENCODE az64,
soil_type20 bigint ENCODE az64,
soil_type21 bigint ENCODE az64,
soil_type22 bigint ENCODE az64,
soil_type23 bigint ENCODE az64,
soil_type24 bigint ENCODE az64,
soil_type25 bigint ENCODE az64,
soil_type26 bigint ENCODE az64,
soil_type27 bigint ENCODE az64,
soil_type28 bigint ENCODE az64,
soil_type29 bigint ENCODE az64,
soil_type30 bigint ENCODE az64,
soil_type31 bigint ENCODE az64,
soil_type32 bigint ENCODE az64,
soil_type33 bigint ENCODE az64,
soil_type34 bigint ENCODE az64,
soil_type35 bigint ENCODE az64,
soil_type36 bigint ENCODE az64,
soil_type37 bigint ENCODE az64,
soil_type38 bigint ENCODE az64,
soil_type39 bigint ENCODE az64,
soil_type40 bigint ENCODE az64,
cover_type bigint ENCODE az64
) DISTSTYLE AUTO;
```
1. La siguiente consulta copia los datos de muestra del [conjunto de datos Covertype](https://archive.ics.uci.edu/ml/datasets/covertype) en Amazon S3 en la tabla `covertype_data` que creó anteriormente en Amazon Redshift.
```
COPY public.covertype_data
FROM
's3://redshift-ml-multiclass/covtype.data.gz' IAM_ROLE DEFAULT gzip DELIMITER ',' REGION 'us-east-1';
```
1. Al dividir manualmente los datos, podrá verificar la precisión del modelo asignando un conjunto de pruebas adicional. La siguiente consulta divide los datos en tres conjuntos. La tabla `covertype_training` es para el entrenamiento, la tabla `covertype_validation` es para la validación y la tabla `covertype_test` es para probar su modelo. Utilizará el conjunto de entrenamiento para entrenar el modelo y el conjunto de validación para validar el desarrollo del modelo. A continuación, utilizará el conjunto de pruebas para probar el rendimiento del modelo y comprobar si el modelo está sobreajustado o insuficientemente ajustado en el conjunto de datos.
```
CREATE TABLE public.covertype_data_prep AS
SELECT
a.*,
CAST (random() * 100 AS int) AS data_group_id
FROM
public.covertype_data a;
--training dataset
CREATE TABLE public.covertype_training as
SELECT
*
FROM
public.covertype_data_prep
WHERE
data_group_id < 80;
--validation dataset
CREATE TABLE public.covertype_validation AS
SELECT
*
FROM
public.covertype_data_prep
WHERE
data_group_id BETWEEN 80
AND 89;
--test dataset
CREATE TABLE public.covertype_test AS
SELECT
*
FROM
public.covertype_data_prep
WHERE
data_group_id > 89;
```
## Paso 2: Crear el modelo de machine learning
En este paso, utilizará la instrucción CREATE MODEL para crear el modelo de machine learning con el algoritmo de aprendizaje lineal.
La siguiente consulta crea el modelo de aprendizaje lineal con la operación CREATE MODEL mediante el bucket de S3. Reemplace amzn-s3-demo-bucket por el bucket de S3 propio.
```
CREATE MODEL forest_cover_type_model
FROM
(
SELECT
Elevation,
Aspect,
Slope,
Horizontal_distance_to_hydrology,
Vertical_distance_to_hydrology,
Horizontal_distance_to_roadways,
HIllshade_9am,
Hillshade_noon,
Hillshade_3pm,
Horizontal_Distance_To_Fire_Points,
Wilderness_Area1,
Wilderness_Area2,
Wilderness_Area3,
Wilderness_Area4,
soil_type1,
Soil_Type2,
Soil_Type3,
Soil_Type4,
Soil_Type5,
Soil_Type6,
Soil_Type7,
Soil_Type8,
Soil_Type9,
Soil_Type10,
Soil_Type11,
Soil_Type12,
Soil_Type13,
Soil_Type14,
Soil_Type15,
Soil_Type16,
Soil_Type17,
Soil_Type18,
Soil_Type19,
Soil_Type20,
Soil_Type21,
Soil_Type22,
Soil_Type23,
Soil_Type24,
Soil_Type25,
Soil_Type26,
Soil_Type27,
Soil_Type28,
Soil_Type29,
Soil_Type30,
Soil_Type31,
Soil_Type32,
Soil_Type33,
Soil_Type34,
Soil_Type36,
Soil_Type37,
Soil_Type38,
Soil_Type39,
Soil_Type40,
Cover_type
from
public.covertype_training
) TARGET cover_type FUNCTION predict_cover_type IAM_ROLE default MODEL_TYPE LINEAR_LEARNER PROBLEM_TYPE MULTICLASS_CLASSIFICATION OBJECTIVE 'Accuracy' SETTINGS (
S3_BUCKET 'amzn-s3-demo-bucket',
S3_GARBAGE_COLLECT OFF,
MAX_RUNTIME 15000
);
```
### Comprobar el estado del entrenamiento del modelo (opcional)
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 forest_cover_type_model;
```
Cuando el modelo esté listo, la salida de la operación anterior tendrá un aspecto semejante al del siguiente ejemplo. Tenga en cuenta que en la salida se proporciona la métrica `validation:multiclass_accuracy`, que puede ver en el lado derecho del siguiente ejemplo. La precisión multiclase mide el porcentaje de puntos de datos que el modelo clasifica correctamente. Utilizará la precisión multiclase para validar la precisión del modelo en el siguiente paso.
```
+--------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Key | Value |
+--------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Model Name | forest_cover_type_model |
| Schema Name | public |
| Owner | awsuser |
| Creation Time | Tue, 12.07.2022 20:24:32 |
| Model State | READY |
| validation:multiclass_accuracy | 0.724952 |
| Estimated Cost | 5.341750 |
| | |
| TRAINING DATA: | |
| Query | SELECT ELEVATION, ASPECT, SLOPE, HORIZONTAL_DISTANCE_TO_HYDROLOGY, VERTICAL_DISTANCE_TO_HYDROLOGY, HORIZONTAL_DISTANCE_TO_ROADWAYS, HILLSHADE_9AM, HILLSHADE_NOON, HILLSHADE_3PM , HORIZONTAL_DISTANCE_TO_FIRE_POINTS, WILDERNESS_AREA1, WILDERNESS_AREA2, WILDERNESS_AREA3, WILDERNESS_AREA4, SOIL_TYPE1, SOIL_TYPE2, SOIL_TYPE3, SOIL_TYPE4, SOIL_TYPE5, SOIL_TYPE6, SOIL_TYPE7, SOIL_TYPE8, SOIL_TYPE9, SOIL_TYPE10 , SOIL_TYPE11, SOIL_TYPE12 , SOIL_TYPE13 , SOIL_TYPE14, SOIL_TYPE15, SOIL_TYPE16, SOIL_TYPE17, SOIL_TYPE18, SOIL_TYPE19, SOIL_TYPE20, SOIL_TYPE21, SOIL_TYPE22, SOIL_TYPE23, SOIL_TYPE24, SOIL_TYPE25, SOIL_TYPE26, SOIL_TYPE27, SOIL_TYPE28, SOIL_TYPE29, SOIL_TYPE30, SOIL_TYPE31, SOIL_TYPE32, SOIL_TYPE33, SOIL_TYPE34, SOIL_TYPE36, SOIL_TYPE37, SOIL_TYPE38, SOIL_TYPE39, SOIL_TYPE40, COVER_TYPE |
| | FROM PUBLIC.COVERTYPE_TRAINING |
| Target Column | COVER_TYPE |
| | |
| PARAMETERS: | |
| Model Type | linear_learner |
| Problem Type | MulticlassClassification |
| Objective | Accuracy |
| AutoML Job Name | redshiftml-20220712202432187659 |
| Function Name | predict_cover_type |
| Function Parameters | elevation aspect slope horizontal_distance_to_hydrology vertical_distance_to_hydrology horizontal_distance_to_roadways hillshade_9am hillshade_noon hillshade_3pm horizontal_distance_to_fire_points wilderness_area1 wilderness_area2 wilderness_area3 wilderness_area4 soil_type1 soil_type2 soil_type3 soil_type4 soil_type5 soil_type6 soil_type7 soil_type8 soil_type9 soil_type10 soil_type11 soil_type12 soil_type13 soil_type14 soil_type15 soil_type16 soil_type17 soil_type18 soil_type19 soil_type20 soil_type21 soil_type22 soil_type23 soil_type24 soil_type25 soil_type26 soil_type27 soil_type28 soil_type29 soil_type30 soil_type31 soil_type32 soil_type33 soil_type34 soil_type36 soil_type37 soil_type38 soil_type39 soil_type40 |
| Function Parameter Types | int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 |
| IAM Role | default-aws-iam-role |
| S3 Bucket | amzn-s3-demo-bucket |
| Max Runtime | 15000 |
+--------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
```
## Paso 3: Validar el modelo
1. La siguiente consulta de predicción valida la precisión del modelo en el conjunto de datos `covertype_validation` calculando la precisión multiclase. La precisión multiclase es el porcentaje de las predicciones del modelo que son correctas.
```
SELECT
CAST(sum(t1.match) AS decimal(7, 2)) AS predicted_matches,
CAST(sum(t1.nonmatch) AS decimal(7, 2)) AS predicted_non_matches,
CAST(sum(t1.match + t1.nonmatch) AS decimal(7, 2)) AS total_predictions,
predicted_matches / total_predictions AS pct_accuracy
FROM
(
SELECT
Elevation,
Aspect,
Slope,
Horizontal_distance_to_hydrology,
Vertical_distance_to_hydrology,
Horizontal_distance_to_roadways,
HIllshade_9am,
Hillshade_noon,
Hillshade_3pm,
Horizontal_Distance_To_Fire_Points,
Wilderness_Area1,
Wilderness_Area2,
Wilderness_Area3,
Wilderness_Area4,
soil_type1,
Soil_Type2,
Soil_Type3,
Soil_Type4,
Soil_Type5,
Soil_Type6,
Soil_Type7,
Soil_Type8,
Soil_Type9,
Soil_Type10,
Soil_Type11,
Soil_Type12,
Soil_Type13,
Soil_Type14,
Soil_Type15,
Soil_Type16,
Soil_Type17,
Soil_Type18,
Soil_Type19,
Soil_Type20,
Soil_Type21,
Soil_Type22,
Soil_Type23,
Soil_Type24,
Soil_Type25,
Soil_Type26,
Soil_Type27,
Soil_Type28,
Soil_Type29,
Soil_Type30,
Soil_Type31,
Soil_Type32,
Soil_Type33,
Soil_Type34,
Soil_Type36,
Soil_Type37,
Soil_Type38,
Soil_Type39,
Soil_Type40,
Cover_type AS actual_cover_type,
predict_cover_type(
Elevation,
Aspect,
Slope,
Horizontal_distance_to_hydrology,
Vertical_distance_to_hydrology,
Horizontal_distance_to_roadways,
HIllshade_9am,
Hillshade_noon,
Hillshade_3pm,
Horizontal_Distance_To_Fire_Points,
Wilderness_Area1,
Wilderness_Area2,
Wilderness_Area3,
Wilderness_Area4,
soil_type1,
Soil_Type2,
Soil_Type3,
Soil_Type4,
Soil_Type5,
Soil_Type6,
Soil_Type7,
Soil_Type8,
Soil_Type9,
Soil_Type10,
Soil_Type11,
Soil_Type12,
Soil_Type13,
Soil_Type14,
Soil_Type15,
Soil_Type16,
Soil_Type17,
Soil_Type18,
Soil_Type19,
Soil_Type20,
Soil_Type21,
Soil_Type22,
Soil_Type23,
Soil_Type24,
Soil_Type25,
Soil_Type26,
Soil_Type27,
Soil_Type28,
Soil_Type29,
Soil_Type30,
Soil_Type31,
Soil_Type32,
Soil_Type33,
Soil_Type34,
Soil_Type36,
Soil_Type37,
Soil_Type38,
Soil_Type39,
Soil_Type40
) AS predicted_cover_type,
CASE
WHEN actual_cover_type = predicted_cover_type THEN 1
ELSE 0
END AS match,
CASE
WHEN actual_cover_type <> predicted_cover_type THEN 1
ELSE 0
END AS nonmatch
FROM
public.covertype_validation
) t1;
```
La salida de la consulta anterior tendrá un aspecto semejante al de este ejemplo. El valor de la métrica de precisión multiclase debe ser similar al valor de la métrica `validation:multiclass_accuracy` que se muestra en la salida de la operación SHOW MODEL.
```
+-------------------+-----------------------+-------------------+--------------+
| predicted_matches | predicted_non_matches | total_predictions | pct_accuracy |
+-------------------+-----------------------+-------------------+--------------+
| 41211 | 16324 | 57535 | 0.71627704 |
+-------------------+-----------------------+-------------------+--------------+
```
1. La siguiente consulta predice el tipo de cubierta más común para `wilderness_area2`. Este conjunto de datos incluye cuatro áreas naturales y siete tipos de cubiertas. Un área natural puede tener varios tipos de cubiertas.
```
SELECT t1. predicted_cover_type, COUNT(*)
FROM
(
SELECT
Elevation,
Aspect,
Slope,
Horizontal_distance_to_hydrology,
Vertical_distance_to_hydrology,
Horizontal_distance_to_roadways,
HIllshade_9am,
Hillshade_noon,
Hillshade_3pm ,
Horizontal_Distance_To_Fire_Points,
Wilderness_Area1,
Wilderness_Area2,
Wilderness_Area3,
Wilderness_Area4,
soil_type1,
Soil_Type2,
Soil_Type3,
Soil_Type4,
Soil_Type5,
Soil_Type6,
Soil_Type7,
Soil_Type8,
Soil_Type9,
Soil_Type10 ,
Soil_Type11,
Soil_Type12 ,
Soil_Type13 ,
Soil_Type14,
Soil_Type15,
Soil_Type16,
Soil_Type17,
Soil_Type18,
Soil_Type19,
Soil_Type20,
Soil_Type21,
Soil_Type22,
Soil_Type23,
Soil_Type24,
Soil_Type25,
Soil_Type26,
Soil_Type27,
Soil_Type28,
Soil_Type29,
Soil_Type30,
Soil_Type31,
Soil_Type32,
Soil_Type33,
Soil_Type34,
Soil_Type36,
Soil_Type37,
Soil_Type38,
Soil_Type39,
Soil_Type40,
predict_cover_type( Elevation,
Aspect,
Slope,
Horizontal_distance_to_hydrology,
Vertical_distance_to_hydrology,
Horizontal_distance_to_roadways,
HIllshade_9am,
Hillshade_noon,
Hillshade_3pm ,
Horizontal_Distance_To_Fire_Points,
Wilderness_Area1,
Wilderness_Area2,
Wilderness_Area3,
Wilderness_Area4,
soil_type1,
Soil_Type2,
Soil_Type3,
Soil_Type4,
Soil_Type5,
Soil_Type6,
Soil_Type7,
Soil_Type8,
Soil_Type9,
Soil_Type10,
Soil_Type11,
Soil_Type12,
Soil_Type13,
Soil_Type14,
Soil_Type15,
Soil_Type16,
Soil_Type17,
Soil_Type18,
Soil_Type19,
Soil_Type20,
Soil_Type21,
Soil_Type22,
Soil_Type23,
Soil_Type24,
Soil_Type25,
Soil_Type26,
Soil_Type27,
Soil_Type28,
Soil_Type29,
Soil_Type30,
Soil_Type31,
Soil_Type32,
Soil_Type33,
Soil_Type34,
Soil_Type36,
Soil_Type37,
Soil_Type38,
Soil_Type39,
Soil_Type40) AS predicted_cover_type
FROM public.covertype_test
WHERE wilderness_area2 = 1)
t1
GROUP BY 1;
```
La salida de la operación anterior tendrá un aspecto semejante al del siguiente ejemplo. Esta salida significa que el modelo predijo que la mayor parte de la cubierta es de tipo 1, y que hay alguna cubierta de los tipos 2 y 7.
```
+----------------------+-------+
| predicted_cover_type | count |
+----------------------+-------+
| 2 | 564 |
| 7 | 97 |
| 1 | 2309 |
+----------------------+-------+
```
1. La siguiente consulta muestra el tipo de cubierta más común en una sola área natural. La consulta muestra la cantidad de ese tipo de cubierta y el área natural del tipo de cubierta.
```
SELECT t1. predicted_cover_type, COUNT(*), wilderness_area
FROM
(
SELECT
Elevation,
Aspect,
Slope,
Horizontal_distance_to_hydrology,
Vertical_distance_to_hydrology,
Horizontal_distance_to_roadways,
HIllshade_9am,
Hillshade_noon,
Hillshade_3pm ,
Horizontal_Distance_To_Fire_Points,
Wilderness_Area1,
Wilderness_Area2,
Wilderness_Area3,
Wilderness_Area4,
soil_type1,
Soil_Type2,
Soil_Type3,
Soil_Type4,
Soil_Type5,
Soil_Type6,
Soil_Type7,
Soil_Type8,
Soil_Type9,
Soil_Type10 ,
Soil_Type11,
Soil_Type12 ,
Soil_Type13 ,
Soil_Type14,
Soil_Type15,
Soil_Type16,
Soil_Type17,
Soil_Type18,
Soil_Type19,
Soil_Type20,
Soil_Type21,
Soil_Type22,
Soil_Type23,
Soil_Type24,
Soil_Type25,
Soil_Type26,
Soil_Type27,
Soil_Type28,
Soil_Type29,
Soil_Type30,
Soil_Type31,
Soil_Type32,
Soil_Type33,
Soil_Type34,
Soil_Type36,
Soil_Type37,
Soil_Type38,
Soil_Type39,
Soil_Type40,
predict_cover_type( Elevation,
Aspect,
Slope,
Horizontal_distance_to_hydrology,
Vertical_distance_to_hydrology,
Horizontal_distance_to_roadways,
HIllshade_9am,
Hillshade_noon,
Hillshade_3pm ,
Horizontal_Distance_To_Fire_Points,
Wilderness_Area1,
Wilderness_Area2,
Wilderness_Area3,
Wilderness_Area4,
soil_type1,
Soil_Type2,
Soil_Type3,
Soil_Type4,
Soil_Type5,
Soil_Type6,
Soil_Type7,
Soil_Type8,
Soil_Type9,
Soil_Type10,
Soil_Type11,
Soil_Type12,
Soil_Type13,
Soil_Type14,
Soil_Type15,
Soil_Type16,
Soil_Type17,
Soil_Type18,
Soil_Type19,
Soil_Type20,
Soil_Type21,
Soil_Type22,
Soil_Type23,
Soil_Type24,
Soil_Type25,
Soil_Type26,
Soil_Type27,
Soil_Type28,
Soil_Type29,
Soil_Type30,
Soil_Type31,
Soil_Type32,
Soil_Type33,
Soil_Type34,
Soil_Type36,
Soil_Type37,
Soil_Type38,
Soil_Type39,
Soil_Type40) AS predicted_cover_type,
CASE WHEN Wilderness_Area1 = 1 THEN 1
WHEN Wilderness_Area2 = 1 THEN 2
WHEN Wilderness_Area3 = 1 THEN 3
WHEN Wilderness_Area4 = 1 THEN 4
ELSE 0
END AS wilderness_area
FROM public.covertype_test)
t1
GROUP BY 1, 3
ORDER BY 2 DESC
LIMIT 1;
```
La salida de la operación anterior tendrá un aspecto semejante al del siguiente ejemplo.
```
+----------------------+-------+-----------------+
| predicted_cover_type | count | wilderness_area |
+----------------------+-------+-----------------+
| 2 | 15738 | 1 |
+----------------------+-------+-----------------+
```
## Temas relacionados
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 en las predicciones de machine learning?](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)