Amazon Redshift ne prendra plus en charge la création de nouveaux Python à UDFs partir du patch 198. UDFs Le Python existant continuera de fonctionner jusqu'au 30 juin 2026. Pour plus d’informations, consultez le [ billet de blog ](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Tutoriels pour Amazon Redshift ML
Vous pouvez utiliser Amazon Redshift ML pour entraîner des modèles de machine learning en utilisant des instructions SQL et les invoquer dans des requêtes SQL pour la prédiction. Le machine learning dans Amazon Redshift entraîne un modèle avec une instruction SQL. Amazon Redshift lance automatiquement une tâche de formation dans Amazon SageMaker AI et génère un modèle. Une fois qu'un modèle est créé, vous pouvez effectuer des prédictions dans Amazon Redshift à l'aide de la fonction de prédiction du modèle.
Suivez les étapes décrites dans ces tutoriels pour en savoir plus sur les fonctionnalités Amazon Redshift ML :
+ [Tutoriel : Création de modèles de désabonnement des clients](tutorial_customer_churn.md) : dans ce tutoriel, vous utilisez Amazon Redshift ML pour créer un modèle de désabonnement des clients à l’aide de la commande CREATE MODEL et vous exécutez des requêtes de prédiction pour les scénarios utilisateur. Ensuite, vous implémentez des requêtes à l’aide de la fonction SQL générée par la commande CREATE MODEL.
+ [Tutoriel : Création de modèles de clustering en k-moyennes](tutorial_k-means_clustering.md) : dans ce tutoriel, vous utilisez Amazon Redshift ML pour créer, entraîner et déployer un modèle de machine learning basé sur l’[algorithme des k-moyennes](url-sm-dev;k-means.html).
+ [Tutoriel : Création de modèles de classification multiclasse](tutorial_multi-class_classification.md) : dans ce tutoriel, vous utilisez Amazon Redshift ML pour créer un modèle de machine learning capable de résoudre des problèmes de classification multiclasse. L’algorithme de classification multiclasse classe les points de données entre trois classes ou plus. Ensuite, vous implémentez des requêtes à l’aide de la fonction SQL générée par la commande CREATE MODEL.
+ [Tutoriel : Création de XGBoost modèles](tutorial_xgboost.md) : dans ce tutoriel, vous créez un modèle avec des données d’Amazon S3 et vous exécutez des requêtes de prédiction avec ce modèle à l’aide d’Amazon Redshift ML. L' XGBoost algorithme est une implémentation optimisée de l'algorithme des arbres amplifiés par le gradient.
+ [Tutoriel : Création de modèles de régression](tutorial_regression.md) : dans ce tutoriel, vous utilisez Amazon Redshift ML pour créer un modèle de régression de machine learning et exécuter des requêtes de prédiction sur le modèle. Les modèles de régression vous permettent de prédire des résultats numériques, tels que le prix d’une maison ou le nombre de personnes qui utiliseront le service de location de vélos d’une ville.
+ [Tutoriel : Création de modèles de régression avec apprentissage linéaire](tutorial_linear_learner_regression.md) : dans ce tutoriel, vous créez un modèle d’apprentissage linéaire avec des données d’Amazon S3 et vous exécutez des requêtes de prédiction avec ce modèle à l’aide d’Amazon Redshift ML. L'algorithme d'apprentissage linéaire basé sur l' SageMaker IA résout les problèmes de régression ou de classification multi-classes.
+ [Tutoriel : Création de modèles de classification multiclasse avec apprentissage linéaire](tutorial_linear_learner_multi-class_classification.md) : dans ce tutoriel, vous créez un modèle d’apprentissage linéaire avec des données d’Amazon S3, puis vous exécutez des requêtes de prédiction avec le modèle en utilisant Amazon Redshift ML. L'algorithme d'apprentissage linéaire basé sur l' SageMaker IA résout les problèmes de régression ou de classification.
# Tutoriel : Création de modèles de désabonnement des clients
Dans ce tutoriel, vous utilisez Amazon Redshift ML pour créer un modèle de désabonnement des clients à l'aide de la commande CREATE MODEL et vous exécutez des requêtes de prédiction pour les scénarios utilisateur. Ensuite, vous implémentez des requêtes à l'aide de la fonction SQL générée par la commande CREATE MODEL.
Vous pouvez utiliser une simple instruction CREATE MODEL pour exporter des données d'entraînement, entraîner un modèle, importer le modèle et préparer une fonction de prédiction Amazon Redshift. Utilisez l'instruction CREATE MODEL pour spécifier les données d'entraînement sous forme de table ou d'instruction SELECT.
Cet exemple utilise des informations d'historique pour créer un modèle de machine learning du taux de désabonnement des clients d'un opérateur mobile. Tout d'abord, l' SageMaker IA entraîne votre modèle d'apprentissage automatique, puis teste votre modèle en utilisant les informations de profil d'un client arbitraire. Une fois le modèle validé, Amazon SageMaker AI déploie le modèle et la fonction de prédiction sur Amazon Redshift. Vous pouvez utiliser la fonction de prédiction pour prédire si un client va se désabonner ou non.
## Exemples de cas d’utilisation
Vous pouvez résoudre d'autres problèmes de classification binaire à l'aide d'Amazon Redshift ML, par exemple pour prédire si une vente sera conclue ou non. Vous pouvez également prédire si une transaction financière est frauduleuse ou non.
**Tâches**
+ Conditions préalables
+ Étape 1 : charger les données d'Amazon S3 dans Amazon Redshift
+ Étape 2 : Créer le modèle de machine learning
+ Étape 3 : Effectuer des prédictions avec le modèle
## Conditions préalables
Pour effectuer ce tutoriel, vous devez avoir rempli les conditions suivantes :
+ Vous devez configurer un cluster Amazon Redshift pour Amazon Redshift ML. Pour cela, utilisez la documentation [Configuration du cluster et de la mise en place pour l'administration Amazon Redshift ML](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html).
+ Le cluster Amazon Redshift que vous utilisez pour créer le modèle et le compartiment Amazon S3 que vous utilisez pour fournir les données d'entraînement et stocker les artefacts de modèle doivent être dans la même région AWS .
+ Pour télécharger les commandes SQL et l'exemple de jeu de données utilisés dans cette documentation, effectuez l'une des opérations suivantes :
+ Télécharger les [instructions SQL](https://s3.amazonaws.com/redshift-downloads/redshift-ml/tutorial-scripts/redshift-ml-tutorial.sql), le [fichier d'activité client](https://s3.amazonaws.com/redshift-downloads/redshift-ml/customer_activity/customer_activity.csv) et le [fichier Abalone](https://s3.amazonaws.com/redshift-downloads/redshift-ml/abalone_xg/abalone.csv).
+ À l'aide AWS CLI de for Amazon S3, exécutez la commande suivante. Vous pouvez utiliser votre propre chemin d’accès.
```
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
```
## Étape 1 : charger les données d'Amazon S3 dans Amazon Redshift
Utilisez l'[éditeur de requête v2 Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) pour modifier et exécuter des requêtes, et visualiser les résultats.
L'exécution des requêtes suivantes crée une table nommée `customer_activity` et ingère l'exemple de jeu de données d'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;
```
## Étape 2 : créer le modèle de machine learning
Le taux de désabonnement est notre entrée cible dans ce modèle. Toutes les autres entrées du modèle sont des attributs qui aident à créer une fonction permettant de prédire le taux de désabonnement.
L'exemple suivant utilise l'opération CREATE MODEL pour fournir un modèle qui prédit si un client sera actif, à l'aide d'entrées telles que l'âge, le code postal, les dépenses et les dossiers du client. Dans l’exemple suivant, remplacez amzn-s3-demo-bucket par votre propre compartiment Amazon S3.
```
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 requête SELECT de l'exemple précédent crée les données d'entraînement. La clause TARGET spécifie quelle colonne correspond à l'étiquette de machine learning que l'opération CREATE MODEL utilise pour apprendre à effectuer des prédictions. La colonne cible « churn » (désabonnement) indique si le client a toujours un abonnement actif ou s'il a suspendu l'adhésion. Le champ S3\$1BUCKET correspond au nom du compartiment Amazon S3 que vous avez créé précédemment. Le compartiment Amazon S3 est utilisé pour partager des données d'entraînement et des artefacts entre Amazon Redshift et Amazon SageMaker AI. Les colonnes restantes correspondent aux entités qui sont utilisées pour la prédiction.
Pour un résumé de la syntaxe et des entités d'un cas d'utilisation élémentaire de la commande CREATE MODEL, consultez [CREATE MODEL simple](https://docs.aws.amazon.com/redshift/latest/dg/r_create_model_use_cases.html#r_simple_create_model).
### Ajouter des autorisations pour le chiffrement côté serveur (facultatif)
Amazon Redshift utilise par défaut Amazon SageMaker AI Autopilot pour la formation. En particulier, Amazon Redshift exporte en toute sécurité les données d'entraînement dans le compartiment Amazon S3 spécifié par le client. Si vous ne spécifiez pas de `KMS_KEY_ID`, les données sont chiffrées par défaut à l'aide du chiffrement côté serveur SSE-S3.
Lorsque vous chiffrez vos entrées à l'aide d'un chiffrement côté serveur avec une clé AWS KMS gérée (SSE-MMS), ajoutez les autorisations suivantes :
```
{
"Effect": "Allow",
"Action": [
"kms:Encrypt"
"kms:Decrypt"
]
}
```
Pour plus d'informations sur les rôles Amazon SageMaker AI, consultez la section relative aux [rôles Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html) dans le manuel *Amazon SageMaker AI Developer Guide*.
### Vérifier l’état de l’entraînement du modèle (facultatif)
Vous pouvez utiliser la commande SHOW MODEL pour savoir quand votre modèle sera prêt.
Utilisez l'opération suivante pour vérifier l'état du modèle.
```
SHOW MODEL customer_churn_auto_model;
```
Voici un exemple de la sortie de l'opération précédente.
```
+--------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------+
| 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 |
+--------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------+
```
Lorsque l'entraînement du modèle est terminé, la variable `model_state` devient `Model is Ready`, et la fonction de prédiction devient disponible.
## Étape 3 : effectuer des prédictions avec le modèle
Vous pouvez utiliser des instructions SQL pour afficher les prédictions effectuées par le modèle de prédiction. Dans cet exemple, la fonction de prédiction créée par l'opération CREATE MODEL est nommée `ml_fn_customer_churn_auto`. Les arguments en entrée de la fonction de prédiction correspondent aux types d'entités, tels que varchar pour `state` et integer pour `account_length`. La sortie de la fonction de prédiction est du même type que celle de la colonne TARGET de l'instruction CREATE MODEL.
1. Vous avez entraîné le modèle sur des données datant d'avant le 01/01/2020. Vous utilisez donc maintenant la fonction de prédiction sur le jeu de test. La requête suivante affiche les prédictions indiquant si les clients qui se sont inscrits après le 01/01/2020 vont se désabonner ou non.
```
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. L'exemple suivant utilise la même fonction de prédiction pour un autre cas d'utilisation. Dans ce cas, Amazon Redshift prédit la proportion de clients qui se désabonnent et de ceux qui ne se désabonnent pas parmi les clients de différents états avec une date d'enregistrement ultérieure à 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. L'exemple suivant utilise la fonction de prédiction pour le cas d'utilisation de la prédiction du pourcentage de clients qui se désabonnent dans un état. Dans ce cas, Amazon Redshift prédit le pourcentage de désabonnement quand la date d'enregistrement est ultérieure au 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;
```
## Rubriques en relation
Pour plus d'informations sur Amazon Redshift ML, consultez la documentation suivante :
+ [Coûts d'utilisation d'Amazon Redshift ML](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)
+ [Commande CREATE MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MODEL.html)
+ [Fonction EXPLAIN\$1MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)
Pour plus d'informations sur le machine learning, consultez la documentation suivante :
+ [Présentation du machine learning](https://docs.aws.amazon.com/redshift/latest/dg/machine_learning_overview.html)
+ [Machine learning pour les novices et les experts](https://docs.aws.amazon.com/redshift/latest/dg/novice_expert.html)
+ [En quoi consistent l'équité et l'explicabilité des modèles pour les prédictions de machine learning ?](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)
# Tutoriel : Création de modèles de clustering en k-moyennes
Dans ce tutoriel, vous utilisez Amazon Redshift ML pour créer, entraîner et déployer un modèle de machine learning basé sur l'[algorithme des k-moyennes](url-sm-dev;k-means.html). Cet algorithme résout les problèmes de mise en cluster lorsque vous souhaitez découvrir des regroupements dans les données. Les k-moyennes permettent de regrouper les données qui n'ont pas encore été étiquetées. Pour en savoir plus sur le clustering K-means, consultez [How K-means Clustering Works dans](https://docs.aws.amazon.com/sagemaker/latest/dg/algo-kmeans-tech-notes.html) le manuel Amazon SageMaker AI Developer Guide.
Vous allez utiliser une opération CREATE MODEL pour créer un modèle de k-moyennes à partir d'un cluster Amazon Redshift. Vous pouvez utiliser une commande CREATE MODEL pour exporter des données d'entraînement, entraîner un modèle, importer le modèle et préparer une fonction de prédiction Amazon Redshift. Utilisez l'opération CREATE MODEL pour spécifier les données d'entraînement sous la forme d'une table ou d'une instruction SELECT.
Dans ce tutoriel, vous utilisez l'algorithme des k-moyennes sur le jeu de données [GDELT (Global Database of Events, Language, and Tone)](https://aws.amazon.com/public-datasets/gdelt/), qui suit l'actualité mondiale, et les données sont stockées pour chaque seconde de chaque jour. L'algorithme des k-moyennes regroupera les événements qui ont un ton, des acteurs ou des lieux similaires. Les données sont stockées sous forme de fichiers multiples sur Amazon Simple Storage Service, dans deux dossiers différents. Le dossier d'historique qui couvre les années 1979 à 2013, et le dossier des mises à jour quotidiennes, qui couvre les années à partir de 2013. Dans le cadre de cet exemple, nous utilisons le format historique et nous intégrons les données de 1979.
## Exemples de cas d’utilisation
Vous pouvez résoudre d'autres problèmes de clustering avec Amazon Redshift ML, tels que le regroupement des clients ayant des habitudes de visionnage similaires sur un service de streaming. Vous pouvez également utiliser Redshift ML pour prédire le nombre optimal de centres d'expédition pour un service de livraison.
**Tâches**
+ Conditions préalables
+ Étape 1 : charger les données d'Amazon S3 dans Amazon Redshift
+ Étape 2 : Créer le modèle de machine learning
+ Étape 3 : Effectuer des prédictions avec le modèle
## Conditions préalables
Pour effectuer ce tutoriel, vous devez suivre la procédure [Configuration administrative](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html) pour Amazon Redshift ML.
## Étape 1 : charger les données d'Amazon S3 dans Amazon Redshift
1. Utilisez l'[éditeur de requête v2 Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) pour exécuter la requête suivante. La requête supprime la table `gdelt_data` dans le schéma public si elle existe et crée une table du même nom dans le schéma public.
```
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 requête suivante charge les données d'exemple dans la table `gdelt_data`.
```
COPY gdelt_data
FROM 's3://gdelt-open-data/events/1979.csv'
REGION 'us-east-1'
IAM_ROLE default
CSV
DELIMITER '\t';
```
### Examiner les données d'entraînement (facultatif)
Pour voir sur quelles données votre modèle sera entraîné, utilisez la requête suivante.
```
SELECT
AvgTone,
EventCode,
NumArticles,
Actor1Geo_Lat,
Actor1Geo_Long,
Actor2Geo_Lat,
Actor2Geo_Long
FROM
gdelt_data LIMIT 100;
```
## Étape 2 : Créer le modèle de machine learning
L'exemple suivant utilise la commande CREATE MODEL pour créer un modèle qui regroupe les données en sept clusters. La valeur K correspond au nombre de clusters utilisés pour diviser vos points de données. Le modèle classe vos points de données en clusters dans lesquels les points de données sont plus similaires les uns aux autres. En partitionnant les points de données en groupes, l'algorithme des k-moyennes détermine de manière itérative le meilleur centre de cluster. L'algorithme attribue ensuite chaque point de données au centre de cluster le plus proche. Les membres les plus proches du même centre de cluster appartiennent au même groupe. Les membres d’un groupe sont aussi semblables que possible des autres membres du même groupe et aussi différents que possible des membres des autres groupes. La valeur K est subjective et dépend des méthodes qui mesurent les similitudes entre les points de données. Vous pouvez modifier la valeur K pour mieux égaliser les tailles des clusters si ces derniers sont distribués de manière inégale.
Dans l’exemple suivant, remplacez amzn-s3-demo-bucket par votre propre compartiment Amazon S3.
```
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');
```
### Vérifier l’état de l’entraînement du modèle (facultatif)
Vous pouvez utiliser la commande SHOW MODEL pour savoir quand votre modèle est prêt.
Pour vérifier l'état du modèle, utilisez l'opération SHOW MODEL suivante et recherchez si `Model State` a pour valeur `Ready`.
```
SHOW MODEL NEWS_DATA_CLUSTERS;
```
Lorsque le modèle est prêt, la sortie de l'opération précédente doit indiquer que `Model State` a pour valeur `Ready`. Voici un exemple de la sortie de l'opération 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 |
+--------------------------+------------------------------------------------------------------------------------------------------+
```
## Étape 3 : Effectuer des prédictions avec le modèle
### Identifier les clusters
Vous pouvez trouver des regroupements discrets identifiés dans les données par votre modèle, également appelés clusters. Un cluster est l'ensemble des points de données qui sont plus proches de son centre de cluster que de tout autre centre de cluster. Puisque la valeur K représente le nombre de clusters dans le modèle, elle représente également le nombre de centres de cluster. La requête suivante identifie les clusters en montrant le cluster associé à chaque `globaleventid`.
```
SELECT
globaleventid,
news_monitoring_cluster (
AvgTone,
EventCode,
NumArticles,
Actor1Geo_Lat,
Actor1Geo_Long,
Actor2Geo_Lat,
Actor2Geo_Long
) AS cluster
FROM
gdelt_data;
```
### Vérifier la distribution des données
Vous pouvez vérifier la distribution des données entre les clusters pour voir si la valeur K que vous avez choisie donne lieu à une distribution assez uniforme des données. Utilisez la requête suivante pour déterminer si les données sont distribuées uniformément entre vos clusters.
```
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;
```
Notez que vous pouvez modifier la valeur K pour mieux égaliser les tailles des clusters si ces derniers sont distribués de manière inégale.
### Déterminer les centres de cluster
Un point de données est plus proche de son centre de cluster que de tout autre centre de cluster. Ainsi, la recherche des centres de cluster vous aide à définir les clusters.
Exécutez la requête suivante pour déterminer les centres des clusters en fonction du nombre d'articles par code d'événement.
```
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;
```
### Afficher des informations sur les points de données d'un cluster
Utilisez la requête suivante pour renvoyer les données des points affectés au cinquième cluster. Les articles sélectionnés doivent avoir deux acteurs.
```
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;
```
### Afficher des données sur les événements avec des acteurs du même code ethnique
La requête suivante comptabilise le nombre d'articles écrits sur des événements avec un ton positif. La requête exige également que les deux acteurs aient le même code ethnique et elle renvoie le cluster auquel chaque événement est affecté.
```
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;
```
## Rubriques en relation
Pour plus d’informations sur Amazon Redshift ML, consultez la documentation suivante :
+ [Coûts d'utilisation d'Amazon Redshift ML](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)
+ [Opération CREATE MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MODEL.html)
+ [Fonction EXPLAIN\$1MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)
Pour plus d’informations sur le machine learning, consultez la documentation suivante :
+ [Présentation du machine learning](https://docs.aws.amazon.com/redshift/latest/dg/machine_learning_overview.html)
+ [Machine learning pour les novices et les experts](https://docs.aws.amazon.com/redshift/latest/dg/novice_expert.html)
+ [En quoi consistent l'équité et l'explicabilité des modèles pour les prédictions de machine learning ?](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)
# Tutoriel : Création de modèles de classification multiclasse
Dans ce tutoriel, vous utilisez Amazon Redshift ML pour créer un modèle de machine learning capable de résoudre des problèmes de classification multiclasse. L'algorithme de classification multiclasse classe les points de données entre trois classes ou plus. Ensuite, vous implémentez des requêtes à l'aide de la fonction SQL générée par la commande CREATE MODEL.
Vous pouvez utiliser une commande CREATE MODEL pour exporter des données d'entraînement, entraîner un modèle, importer le modèle et préparer une fonction de prédiction Amazon Redshift. Utilisez l'opération CREATE MODEL pour spécifier les données d'entraînement sous la forme d'une table ou d'une instruction SELECT.
Pour suivre ce tutoriel, vous utilisez le jeu de données public [E-Commerce Sales Forecast](https://www.kaggle.com/allunia/e-commerce-sales-forecast), qui inclut les données de vente d'un détaillant britannique en ligne. Le modèle que vous générez ciblera les clients les plus actifs en vue de les admettre à un programme de fidélité spécial pour la clientèle. Avec la classification multiclasse, vous pouvez utiliser ce modèle pour prédire le nombre de mois pendant lesquels un client sera actif sur une période de 13 mois. La fonction de prédiction désigne les clients qui devraient être actifs pendant 7 mois ou plus afin de les admettre au programme.
## Exemples de cas d’utilisation
Vous pouvez résoudre d'autres problèmes de classification multiclasse avec Amazon Redshift ML, tels que la prédiction du produit le plus vendu d'une gamme de produits. Vous pouvez également prédire les fruits qu'une image contient, en sélectionnant par exemple des pommes, des poires ou des oranges.
**Tâches**
+ Conditions préalables
+ Étape 1 : charger les données d'Amazon S3 dans Amazon Redshift
+ Étape 2 : Créer le modèle de machine learning
+ Étape 3 : Effectuer des prédictions avec le modèle
## Conditions préalables
Pour effectuer ce tutoriel, vous devez suivre la procédure [Configuration administrative](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html) pour Amazon Redshift ML.
## Étape 1 : charger les données d'Amazon S3 dans Amazon Redshift
Utilisez l'[éditeur de requête v2 Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) pour exécuter les requêtes suivantes. Ces requêtes chargent les données d'exemple dans Amazon Redshift.
1. La requête suivante crée une table nommée `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 requête suivante copie les données d'exemple à partir du [jeu de données E-Commerce Sales Forecast](https://www.kaggle.com/allunia/e-commerce-sales-forecast) dans la table `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;
```
### Diviser les données
Lorsque vous créez un modèle dans Amazon Redshift ML, l' SageMaker IA divise automatiquement vos données en ensembles d'entraînement et de test, afin que l' SageMaker IA puisse déterminer la précision du modèle. En divisant manuellement les données dans cette étape, vous serez en mesure de vérifier la précision du modèle en allouant un jeu de prédiction supplémentaire.
Utilisez l'instruction SQL suivante pour diviser les données en trois jeux à des fins d'entraînement, de validation et de prédiction.
```
--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);
```
## Étape 2 : Créer le modèle de machine learning
Dans cette étape, vous utilisez l'instruction CREATE MODEL pour créer votre modèle de machine learning à l'aide de la classification multiclasse.
La requête suivante crée le modèle de classification multiclasse avec le jeu d'entraînement à l'aide de l'opération CREATE MODEL. Remplacez amzn-s3-demo-bucket par votre propre compartiment Amazon S3.
```
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
);
```
Dans cette requête, vous spécifiez le type de problème `Multiclass_Classification`. La cible que vous prédisez pour le modèle est `nbr_months_active`. Lorsque l' SageMaker IA a fini d'entraîner le modèle, elle crée la fonction`predict_customer_activity`, que vous utiliserez pour faire des prédictions dans Amazon Redshift.
### Afficher l’état de l’entraînement du modèle (facultatif)
Vous pouvez utiliser la commande SHOW MODEL pour savoir quand votre modèle sera prêt.
Utilisez la requête suivante pour renvoyer diverses métriques du modèle, y compris l'état et la précision du modèle.
```
SHOW MODEL ecommerce_customer_activity;
```
Lorsque le modèle est prêt, la sortie de l’opération précédente doit indiquer que `Model State` a pour valeur `Ready`. Voici un exemple de la sortie de l'opération 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 |
+--------------------------+-----------------------------------------------------------------------------------------------+
```
## Étape 3 : Effectuer des prédictions avec le modèle
La requête suivante montre quels clients peuvent bénéficier de votre programme de fidélité client. Si le modèle prédit que le client sera actif pendant au moins 7 mois, il sélectionne le client pour le programme de fidélité.
```
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;
```
### Exécuter des requêtes de prédiction sur les données de validation (facultatif)
Exécutez les requêtes de prédiction suivantes par rapport aux données de validation pour voir le niveau de précision du modèle.
```
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;
```
### Prédire le nombre de clients qui manquent une entrée (facultatif)
La requête suivante compare le nombre de clients qui ne devraient être actifs que 5 ou 6 mois. Le modèle prédit que ces clients ne bénéficieront pas du programme de fidélité. La requête compare ensuite le nombre de clients qui manquent de peu le programme au nombre de clients prédits comme admissibles au programme de fidélité. Cette requête pourrait être utilisée pour prendre une décision éclairée quant au fait d'abaisser ou non le seuil d'admission au programme de fidélité. Vous pouvez également déterminer s'il y a un nombre important de clients qui devraient manquer de peu l'admission au programme. Vous pourriez alors encourager ces clients à augmenter leur activité pour devenir membres du programme de fidélité.
```
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);
```
## Rubriques en relation
Pour plus d'informations sur Amazon Redshift ML, consultez la documentation suivante :
+ [Coûts d'utilisation d'Amazon Redshift ML](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)
+ [Opération CREATE MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MODEL.html)
+ [Fonction EXPLAIN\$1MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)
Pour plus d'informations sur le machine learning, consultez la documentation suivante :
+ [Présentation du machine learning](https://docs.aws.amazon.com/redshift/latest/dg/machine_learning_overview.html)
+ [Machine learning pour les novices et les experts](https://docs.aws.amazon.com/redshift/latest/dg/novice_expert.html)
+ [En quoi consistent l’équité et l’explicabilité des modèles pour les prédictions de machine learning?](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)
# Tutoriel : Création de XGBoost modèles
Dans ce tutoriel, vous créez un modèle avec des données d'Amazon S3 et vous exécutez des requêtes de prédiction avec ce modèle à l'aide d'Amazon Redshift ML. L' XGBoost algorithme est une implémentation optimisée de l'algorithme des arbres amplifiés par le gradient. XGBoost gère plus de types de données, de relations et de distributions que les autres algorithmes d'arbres augmentés par gradient. Vous pouvez l'utiliser XGBoost pour les problèmes de régression, de classification binaire, de classification multiclasse et de classement. Pour plus d'informations sur l' XGBoostalgorithme, consultez l'[XGBoostalgorithme](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost.html) dans le manuel Amazon SageMaker AI Developer Guide.
L'`CREATE MODEL`opération Amazon Redshift ML avec `AUTO OFF` cette option est actuellement prise en charge en XGBoost tant que. `MODEL_TYPE` Vous pouvez fournir des informations pertinentes telles que l'objectif et les hyperparamètres dans le cadre de la commande `CREATE MODEL`, en fonction de votre cas d'utilisation.
Dans ce tutoriel, vous utilisez le jeu de données [banknote authentication Data Set](https://archive.ics.uci.edu/ml/datasets/banknote+authentication), qui est un problème de classification binaire visant à prédire si un billet de banque donné est authentique ou contrefait.
## Exemples de cas d’utilisation
Vous pouvez résoudre d'autres problèmes de classification binaire à l'aide d'Amazon Redshift ML, comme par exemple prédire si un patient est en bonne santé ou malade. Vous pouvez également prédire si un e-mail est un courrier indésirable ou non.
**Tâches**
+ Conditions préalables
+ Étape 1 : charger les données d'Amazon S3 dans Amazon Redshift
+ Étape 2 : Créer le modèle de machine learning
+ Étape 3 : Effectuer des prédictions avec le modèle
## Conditions préalables
Pour effectuer ce tutoriel, vous devez suivre la procédure [Configuration administrative](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html) pour Amazon Redshift ML.
## Étape 1 : charger les données d'Amazon S3 dans Amazon Redshift
Utilisez l'[éditeur de requête v2 Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) pour exécuter les requêtes suivantes.
La requête suivante crée deux tables, charge les données depuis Amazon S3 et divise les données en un jeu d'entraînement et un jeu de test. Vous allez utiliser le jeu d'entraînement pour entraîner votre modèle et créer la fonction de prédiction. Ensuite, vous testerez la fonction de prédiction sur le jeu de test.
```
--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;
```
## Étape 2 : Créer le modèle de machine learning
La requête suivante crée le XGBoost modèle dans Amazon Redshift ML à partir du kit d'apprentissage que vous avez créé à l'étape précédente. Remplacez `amzn-s3-demo-bucket` par votre propre `S3_BUCKET`, qui stockera vos jeux de données en entrée et d'autres artefacts 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');
```
### Afficher l'état de l'entraînement du modèle (facultatif)
Vous pouvez utiliser la commande SHOW MODEL pour savoir quand votre modèle sera prêt.
Utilisez la requête suivante pour surveiller la progression de l'entraînement du modèle.
```
SHOW MODEL model_banknoteauthentication_xgboost_binary;
```
Si le modèle est `READY`, l'opération SHOW MODEL fournit également la métrique `train:error`, comme illustré dans l'exemple suivant de la sortie. La métrique `train:error` est une mesure de la précision de votre modèle qui présente jusqu'à six décimales. Une valeur de 0 est la plus précise et une valeur de 1 est la moins précise.
```
+--------------------------+--------------------------------------------------+
| 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 |
+--------------------------+--------------------------------------------------+
```
## Étape 3 : Effectuer des prédictions avec le modèle
### Vérifier la précision du modèle
La requête de prédiction suivante utilise la fonction de prédiction créée à l'étape précédente pour vérifier la précision de votre modèle. Exécutez cette requête sur le jeu de test pour vous assurer que le modèle ne correspond pas trop au jeu d'entraînement. Cette correspondance étroite porte également le nom de surajustement, et un surajustement peut amener le modèle à effectuer des prédictions non 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;
```
### Prédire la quantité de billets de banque authentiques et contrefaits
La requête de prédiction suivante renvoie la quantité prédite de billets authentiques et contrefaits dans le jeu de test.
```
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;
```
### Trouver l'observation moyenne pour un billet de banque authentique et un faux billet
La requête de prédiction suivante renvoie la valeur moyenne de chaque entité pour les billets qui sont prédits comme authentiques ou contrefaits dans le jeu de test.
```
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;
```
## Rubriques en relation
Pour plus d'informations sur Amazon Redshift ML, consultez la documentation suivante :
+ [Coûts d'utilisation d'Amazon Redshift ML](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)
+ [Opération CREATE MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MODEL.html)
+ [Fonction EXPLAIN\$1MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)
Pour plus d'informations sur le machine learning, consultez la documentation suivante :
+ [Présentation du machine learning](https://docs.aws.amazon.com/redshift/latest/dg/machine_learning_overview.html)
+ [Machine learning pour les novices et les experts](https://docs.aws.amazon.com/redshift/latest/dg/novice_expert.html)
+ [En quoi consistent l'équité et l'explicabilité des modèles pour les prédictions de machine learning ?](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)
# Tutoriel : Création de modèles de régression
Dans ce tutoriel, vous utilisez Amazon Redshift ML pour créer un modèle de régression de machine learning et exécuter des requêtes de prédiction sur le modèle. Les modèles de régression vous permettent de prédire des résultats numériques, tels que le prix d'une maison ou le nombre de personnes qui utiliseront le service de location de vélos d'une ville. Vous utilisez la commande CREATE MODEL dans Amazon Redshift avec vos données d'entraînement. Ensuite, Amazon Redshift ML compile le modèle, importe le modèle entraîné dans Redshift et prépare une fonction de prédiction SQL. Vous pouvez utiliser la fonction de prédiction dans les requêtes SQL dans Amazon Redshift.
Dans ce tutoriel, vous allez utiliser Amazon Redshift ML pour créer un modèle de régression qui prédira le nombre de personnes qui utilisent le service de vélos en libre-service de la ville de Toronto à une heure donnée de la journée. Les entrées du modèle incluent les jours fériés et les conditions météorologiques. Vous allez utiliser un modèle de régression, car vous souhaitez obtenir un résultat numérique pour ce problème.
Vous pouvez utiliser la commande CREATE MODEL pour exporter des données d'entraînement, entraîner un modèle et mettre ce modèle à disposition dans Amazon Redshift en tant que fonction SQL. Utilisez l'opération CREATE MODEL pour spécifier les données d'entraînement sous la forme d'une table ou d'une instruction SELECT.
## Exemples de cas d’utilisation
Vous pouvez résoudre d'autres problèmes de régression avec Amazon Redshift ML, tels que la prédiction de la valeur à vie d'un client. Vous pouvez également utiliser Redshift ML pour prédire le prix le plus rentable et le chiffre d'affaires qui en résulte pour un produit.
**Tâches**
+ Conditions préalables
+ Étape 1 : charger les données d'Amazon S3 dans Amazon Redshift
+ Étape 2 : Créer le modèle de machine learning
+ Étape 3 : valider le modèle
## Conditions préalables
Pour effectuer ce tutoriel, vous devez suivre la procédure [Configuration administrative](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html) pour Amazon Redshift ML.
## Étape 1 : charger les données d'Amazon S3 dans Amazon Redshift
Utilisez l'[éditeur de requête v2 Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) pour exécuter les requêtes suivantes.
1. Vous devez créer trois tables pour charger les trois jeux de données publics dans Amazon Redshift. Les jeux de données sont [Bike Share Toronto Ridership Data](https://open.toronto.ca/dataset/bike-share-toronto-ridership-data/), [Données climatiques historiques](https://climate.weather.gc.ca/historical_data/search_historic_data_e.html) et [Données historiques des jours fériés](https://github.com/uWaterloo/Datasets/blob/master/Holidays/holidays.csv). Exécutez la requête suivante dans l'éditeur de requête Amazon Redshift pour créer des tables nommées `ridership`, `weather` et `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 requête suivante charge les données d'exemple dans les tables que vous avez créées à l'étape précédente.
```
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 requête suivante effectue des transformations sur les jeux de données `ridership` et `weather` pour éliminer les biais ou les anomalies. La suppression des biais et des anomalies améliore la précision du modèle. La requête simplifie les tables en créant deux nouvelles vues appelées `ridership_view` et `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 requête suivante crée une table qui combine tous les attributs d'entrée pertinents de `ridership_view` et `weather_view` dans la table `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);
```
### Afficher les données d'exemple (facultatif)
La requête suivante montre les entrées de la table. Vous pouvez exécuter cette opération pour vous assurer que la table a été créée correctement.
```
SELECT *
FROM trip_data
LIMIT 5;
```
Voici un exemple de la sortie de l’opération précédente.
```
+---------------------+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
| 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 |
+---------------------+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
```
### Montrer la corrélation entre les attributs (facultatif)
La détermination de la corrélation vous aide à mesurer la force de l'association entre les attributs. Le niveau d'association peut vous aider à déterminer ce qui affecte votre résultat cible. Dans ce tutoriel, le résultat cible est `trip_count`.
La requête suivante crée ou remplace la procédure `sp_correlation`. Vous utilisez la procédure stockée appelée `sp_correlation` pour montrer la corrélation entre un attribut et d'autres attributs d'une table dans 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 requête suivante montre la corrélation entre la colonne cible, `trip_count`, et d'autres attributs numériques de notre jeu de données.
```
call sp_correlation(
'public',
'trip_data',
'trip_count',
'tmp_corr_table'
);
SELECT
*
FROM
tmp_corr_table;
```
Voici un exemple de la sortie de l'opération `sp_correlation` précédente.
```
+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
| 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 |
+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
```
## Étape 2 : Créer le modèle de machine learning
1. La requête suivante divise vos données en un jeu d'entraînement et un jeu de validation en désignant 80 % du jeu de données pour l'entraînement et 20 % pour la validation. Le jeu d'entraînement est l'entrée du modèle ML utilisée pour identifier le meilleur algorithme possible pour le modèle. Une fois le modèle créé, vous utilisez le jeu de validation pour valider la précision du modèle.
```
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 requête suivante crée un modèle de régression pour prédire la valeur `trip_count` pour n'importe quelles date et heure d'entrée. Dans l’exemple suivant, remplacez amzn-s3-demo-bucket par votre propre compartiment S3.
```
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
);
```
## Étape 3 : valider le modèle
1. Utilisez la requête suivante pour générer des aspects du modèle et recherchez la métrique d'écart quadratique moyen dans la sortie. L'écart quadratique moyen est une métrique de précision standard des problèmes de régression.
```
show model predict_rental_count;
```
1. Exécutez les requêtes de prédiction suivantes par rapport aux données de validation pour comparer le nombre prédit de trajets au nombre réel de trajets.
```
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 requête suivante calcule l'écart quadratique moyen et l'écart-type en fonction de vos données de validation. Vous utilisez l'écart quadratique moyen et l'écart-type pour mesurer la distance entre la cible numérique prédite et la réponse numérique réelle. Un bon modèle présente un faible score pour les deux métriques. La requête suivante renvoie la valeur des deux métriques.
```
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 requête suivante calcule le pourcentage d'erreur dans le nombre de trajets pour chaque heure de trajet le 01/01/2017. La requête ordonne les heures de trajet de l'heure avec le pourcentage d'erreur le plus bas jusqu'à l'heure avec le pourcentage d'erreur le plus haut.
```
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;
```
## Rubriques en relation
Pour plus d'informations sur Amazon Redshift ML, consultez la documentation suivante :
+ [Coûts d'utilisation d'Amazon Redshift ML](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)
+ [Opération CREATE MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MODEL.html)
+ [Fonction EXPLAIN\$1MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)
Pour plus d'informations sur le machine learning, consultez la documentation suivante :
+ [Présentation du machine learning](https://docs.aws.amazon.com/redshift/latest/dg/machine_learning_overview.html)
+ [Machine learning pour les novices et les experts](https://docs.aws.amazon.com/redshift/latest/dg/novice_expert.html)
+ [En quoi consistent l'équité et l'explicabilité des modèles pour les prédictions de machine learning ?](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)
# Tutoriel : Création de modèles de régression avec apprentissage linéaire
Dans ce tutoriel, vous créez un modèle d'apprentissage linéaire avec des données d'Amazon S3 et vous exécutez des requêtes de prédiction avec ce modèle à l'aide d'Amazon Redshift ML. L'algorithme d'apprentissage linéaire basé sur l' SageMaker IA résout les problèmes de régression ou de classification multi-classes. Pour en savoir plus sur les problèmes de régression et de classification multiclasse, consultez la section [Types de problèmes liés aux paradigmes d'apprentissage automatique](https://docs.aws.amazon.com/sagemaker/latest/dg/algorithms-choose.html#basic-machine-learning-paradigms) dans le manuel Amazon SageMaker AI Developer Guide. Dans ce tutoriel, vous résolvez un problème de régression. L'algorithme d'apprentissage linéaire entraîne de nombreux modèles en parallèle et détermine automatiquement le modèle le plus optimisé. Vous utilisez l'opération CREATE MODEL dans Amazon Redshift, qui crée votre modèle d'apprenant linéaire à l'aide de l' SageMaker IA et envoie une fonction de prédiction à Amazon Redshift. Pour plus d'informations sur l'algorithme d'apprentissage linéaire, consultez Algorithme d'[apprentissage linéaire dans le manuel](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html) Amazon SageMaker AI Developer Guide.
Vous pouvez utiliser une commande CREATE MODEL pour exporter des données d’entraînement, entraîner un modèle, importer le modèle et préparer une fonction de prédiction Amazon Redshift. Utilisez l'opération CREATE MODEL pour spécifier les données d'entraînement sous la forme d'une table ou d'une instruction SELECT.
Les modèles d'apprentissage linéaire optimisent les objectifs continus ou discrets. Les objectifs continus sont utilisés pour la régression, tandis que les variables discrètes sont utilisées pour la classification. Certaines méthodes fournissent une solution pour les seuls objectifs continus, comme la méthode de régression. L'algorithme d'apprentissage linéaire fournit une hausse de la vitesse par rapport aux techniques naïves d'optimisation des hyperparamètres, telles que la technique naïve bayésienne. Une technique naïve d'optimisation suppose que chaque variable d'entrée est indépendante. Pour utiliser l'algorithme d'apprentissage linéaire, vous devez fournir des colonnes représentant les dimensions des entrées et des lignes représentant les observations. Pour plus d'informations sur l'algorithme d'apprentissage linéaire, consultez l'algorithme d'[apprentissage linéaire dans le manuel](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html) Amazon SageMaker AI Developer Guide.
Dans ce tutoriel, vous créez un modèle d'apprentissage linéaire qui prédit l'âge des ormeaux. Vous utilisez la commande CREATE MODEL dans le jeu de données [Abalone Data Set](http://archive.ics.uci.edu/ml/datasets/Abalone) pour déterminer la relation entre les mesures physiques d'un ormeau. Ensuite, vous utilisez ce modèle pour déterminer l'âge des ormeaux.
## Exemples de cas d’utilisation
Vous pouvez résoudre d'autres problèmes de régression avec l'apprentissage linéaire et Amazon Redshift ML, tels que la prédiction du prix d'une maison. Vous pouvez également utiliser Redshift ML pour prédire le nombre de personnes qui utiliseront le service de location de vélos d'une ville.
**Tâches**
+ Conditions préalables
+ Étape 1 : charger les données d'Amazon S3 dans Amazon Redshift
+ Étape 2 : Créer le modèle de machine learning
+ Étape 3 : valider le modèle
## Conditions préalables
Pour effectuer ce tutoriel, vous devez suivre la procédure [Configuration administrative](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html) pour Amazon Redshift ML.
## Étape 1 : charger les données d'Amazon S3 dans Amazon Redshift
Utilisez l'[éditeur de requête v2 Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) pour exécuter les requêtes suivantes. Ces requêtes chargent les données d'exemple dans Redshift et divisent les données en un jeu d'entraînement et un jeu de validation.
1. La requête suivante crée la table `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 requête suivante copie les données d'exemple à partir du jeu de données [Abalone Data Set](http://archive.ics.uci.edu/ml/datasets/Abalone) dans Amazon S3, dans la table `abalone_dataset` que vous avez créée précédemment dans 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. En divisant manuellement les données, vous serez en mesure de vérifier la précision du modèle en allouant un jeu de prédiction supplémentaire. La requête suivante divise les données en deux ensembles. La table `abalone_training` est destinée à l'entraînement et la table `abalone_validation` à la validation.
```
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;
```
## Étape 2 : Créer le modèle de machine learning
Dans cette étape, vous utilisez l'instruction CREATE MODEL pour créer votre modèle de machine learning avec l'algorithme d'apprentissage linéaire.
La requête suivante crée le modèle d’apprentissage linéaire avec l’opération CREATE MODEL à l’aide de votre compartiment S3. Remplacez amzn-s3-demo-bucket par votre propre compartiment S3.
```
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
);
```
### Afficher l’état de l’entraînement du modèle (facultatif)
Vous pouvez utiliser la commande SHOW MODEL pour savoir quand votre modèle sera prêt.
Utilisez la requête suivante pour surveiller la progression de l'entraînement du modèle.
```
SHOW MODEL model_abalone_ring_prediction;
```
Lorsque le modèle est prêt, la sortie de l'opération précédente doit ressembler à celle présentée dans l'exemple suivant. Notez que la sortie fournit la métrique `validation:mse`, qui est l'écart quadratique moyen. Vous utiliserez l'écart quadratique moyen pour valider la précision du modèle à l'étape suivante.
```
+--------------------------+----------------------------------------------------------------------------------------------------+
| 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 |
+--------------------------+----------------------------------------------------------------------------------------------------+
```
## Étape 3 : valider le modèle
1. La requête de prédiction suivante valide la précision du modèle sur le jeu de données `abalone_validation` en calculant l'écart quadratique moyen et l'écart-type.
```
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 sortie de la requête précédente doit ressembler à celle de l'exemple suivant. La valeur de la métrique d'écart quadratique moyen doit être similaire à la métrique `validation:mse` affichée par la sortie de l'opération SHOW MODEL.
```
+-----+--------------------+
| mse | rmse |
+-----+--------------------+
| 5.1 | 2.2600000000000002 |
+-----+--------------------+
```
1. Utilisez la requête suivante pour exécuter l'opération EXPLAIN\$1MODEL sur votre fonction de prédiction. Cette opération renvoie un rapport d'explicabilité du modèle. Pour plus d'informations sur l'opération EXPLAIN\$1MODEL, consultez [Fonction EXPLAIN\$1MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html) dans le Guide du développeur de base de données Amazon Redshift.
```
SELECT
EXPLAIN_MODEL ('model_abalone_ring_prediction');
```
Les informations suivantes sont un exemple du rapport d'explicabilité de modèle produit par l'opération EXPLAIN\$1MODEL précédente. Les valeurs de chacune des entrées sont des valeurs de Shapley. Les valeurs de Shapley représentent l'effet de chaque entrée sur la prédiction de votre modèle, les entrées de valeur supérieure ayant plus d'impact sur la prédiction. Dans cet exemple, les entrées à valeurs élevées ont plus d'impact sur la prédiction de l'âge des ormeaux.
```
{
"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. Utilisez la requête suivante pour calculer le pourcentage de prédictions correctes que le modèle effectue à propos des ormeaux qui ne sont pas encore matures. Les ormeaux encore immatures ont 10 anneaux ou moins, et une prédiction correcte est précise à moins d'un anneau du nombre réel d'anneaux.
```
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;
```
## Rubriques en relation
Pour plus d'informations sur Amazon Redshift ML, consultez la documentation suivante :
+ [Coûts d'utilisation d'Amazon Redshift ML](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)
+ [Opération CREATE MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MODEL.html)
+ [Fonction EXPLAIN\$1MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)
Pour plus d'informations sur le machine learning, consultez la documentation suivante :
+ [Présentation du machine learning](https://docs.aws.amazon.com/redshift/latest/dg/machine_learning_overview.html)
+ [Machine learning pour les novices et les experts](https://docs.aws.amazon.com/redshift/latest/dg/novice_expert.html)
+ [En quoi consistent l'équité et l'explicabilité des modèles pour les prédictions de machine learning ?](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)
# Tutoriel : Création de modèles de classification multiclasse avec apprentissage linéaire
Dans ce tutoriel, vous créez un modèle d'apprentissage linéaire avec des données d'Amazon S3, puis vous exécutez des requêtes de prédiction avec le modèle en utilisant Amazon Redshift ML. L'algorithme d'apprentissage linéaire basé sur l' SageMaker IA résout les problèmes de régression ou de classification. Pour en savoir plus sur les problèmes de régression et de classification multiclasse, consultez la section [Types de problèmes liés aux paradigmes d'apprentissage automatique](https://docs.aws.amazon.com/sagemaker/latest/dg/algorithms-choose.html#basic-machine-learning-paradigms) dans le manuel Amazon SageMaker AI Developer Guide. Dans ce tutoriel, vous résolvez un problème de classification multiclasse. L’algorithme d’apprentissage linéaire entraîne de nombreux modèles en parallèle et détermine automatiquement le modèle le plus optimisé. Vous utilisez l'opération CREATE MODEL dans Amazon Redshift, qui crée votre modèle d'apprenant linéaire à l'aide de l' SageMaker IA et envoie la fonction de prédiction à Amazon Redshift. Pour plus d'informations sur l'algorithme d'apprentissage linéaire, consultez l'algorithme d'[apprentissage linéaire dans le manuel](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html) Amazon SageMaker AI Developer Guide.
Vous pouvez utiliser une commande CREATE MODEL pour exporter des données d’entraînement, entraîner un modèle, importer le modèle et préparer une fonction de prédiction Amazon Redshift. Utilisez l'opération CREATE MODEL pour spécifier les données d'entraînement sous la forme d'une table ou d'une instruction SELECT.
Les modèles d'apprentissage linéaire optimisent les objectifs continus ou discrets. Les objectifs continus sont utilisés pour la régression, tandis que les variables discrètes sont utilisées pour la classification. Certaines méthodes fournissent une solution pour les seuls objectifs continus, comme une méthode de régression. L'algorithme d'apprentissage linéaire fournit une hausse de la vitesse par rapport aux techniques naïves d'optimisation des hyperparamètres, telles que la technique naïve bayésienne. Une technique naïve d'optimisation suppose que chaque variable d'entrée est indépendante. L'algorithme d'apprentissage linéaire entraîne de nombreux modèles en parallèle et sélectionne le modèle le plus optimisé. Un algorithme similaire combine XGBoost les estimations d'un ensemble de modèles plus simples et plus faibles pour faire des prédictions. Pour en savoir plus XGBoost, consultez [XGBoost l'algorithme](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost.html) dans le manuel Amazon SageMaker AI Developer Guide.
Pour utiliser l’algorithme d’apprentissage linéaire, vous devez fournir des colonnes représentant les dimensions des entrées et des lignes représentant les observations. Pour plus d'informations sur l'algorithme d'apprentissage linéaire, consultez l'algorithme d'[apprentissage linéaire dans le manuel](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html) Amazon SageMaker AI Developer Guide.
Dans ce tutoriel, vous créez un modèle d'apprentissage linéaire qui prédit les types de couverture pour une zone donnée. Vous utilisez la commande CREATE MODEL sur le jeu de données [Covertype Data Set](https://archive.ics.uci.edu/ml/datasets/covertype) sur le site Machine Learning Repository de l'UCI. Ensuite, vous utilisez la fonction de prédiction créée par la commande pour déterminer les types de couverture dans une aire de nature sauvage. Un type de couverture forestière est généralement un type d'arbre. Les entrées que Redshift ML utilisera pour créer le modèle incluent le type de sol, la distance aux routes et la désignation des aires de nature sauvage. Pour plus d'informations sur le jeu de données, consultez [Covertype Data Set](https://archive.ics.uci.edu/ml/datasets/covertype) sur le site Machine Learning Repository de l'UCI.
## Exemples de cas d’utilisation
Vous pouvez résoudre d'autres problèmes de classification multiclasse avec apprentissage linéaire à l'aide d'Amazon Redshift ML, tels que la prédiction de l'espèce d'une plante à partir d'une image. Vous pouvez également prédire la quantité d'un produit qu'un client achètera.
**Tâches**
+ Conditions préalables
+ Étape 1 : charger les données d'Amazon S3 dans Amazon Redshift
+ Étape 2 : Créer le modèle de machine learning
+ Étape 3 : valider le modèle
## Conditions préalables
Pour effectuer ce tutoriel, vous devez suivre la procédure [Configuration administrative](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html) pour Amazon Redshift ML.
## Étape 1 : charger les données d'Amazon S3 dans Amazon Redshift
Utilisez l'[éditeur de requête v2 Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) pour exécuter les requêtes suivantes. Ces requêtes chargent les données d'exemple dans Redshift et divisent les données en un jeu d'entraînement et un jeu de validation.
1. La requête suivante crée la table `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 requête suivante copie les données d'exemple à partir du jeu de données [Covertype Data Set](https://archive.ics.uci.edu/ml/datasets/covertype) dans Amazon S3, dans la table `covertype_data` que vous avez créée précédemment dans Amazon Redshift.
```
COPY public.covertype_data
FROM
's3://redshift-ml-multiclass/covtype.data.gz' IAM_ROLE DEFAULT gzip DELIMITER ',' REGION 'us-east-1';
```
1. En divisant manuellement les données, vous serez en mesure de vérifier la précision du modèle en allouant un jeu de test supplémentaire. La requête suivante divise les données en trois ensembles. La table `covertype_training` est destinée à l'entraînement, la table `covertype_validation` à la validation, et la table `covertype_test` au test du modèle. Vous utiliserez le jeu d'entraînement pour entraîner votre modèle et le jeu de validation pour valider le développement du modèle. Ensuite, vous utilisez le jeu de test pour tester les performances du modèle et voir si le modèle présente un surajustement ou un sous-ajustement du jeu de données.
```
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;
```
## Étape 2 : Créer le modèle de machine learning
Dans cette étape, vous utilisez l'instruction CREATE MODEL pour créer votre modèle de machine learning avec l'algorithme d'apprentissage linéaire.
La requête suivante crée le modèle d’apprentissage linéaire avec l’opération CREATE MODEL à l’aide de votre compartiment S3. Remplacez amzn-s3-demo-bucket par votre propre compartiment S3.
```
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
);
```
### Afficher l’état de l’entraînement du modèle (facultatif)
Vous pouvez utiliser la commande SHOW MODEL pour savoir quand votre modèle sera prêt.
Utilisez la requête suivante pour surveiller la progression de l'entraînement du modèle.
```
SHOW MODEL forest_cover_type_model;
```
Lorsque le modèle est prêt, la sortie de l'opération précédente doit ressembler à celle présentée dans l'exemple suivant. Notez que la sortie fournit la métrique `validation:multiclass_accuracy`, que vous pouvez voir sur le côté droit de l'exemple suivant. La précision multiclasse mesure le pourcentage des points de données correctement classés par le modèle. Vous utiliserez la précision multiclasse pour valider la précision du modèle à l'étape suivante.
```
+--------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| 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 |
+--------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
```
## Étape 3 : valider le modèle
1. La requête de prédiction suivante valide la précision du modèle sur le jeu de données `covertype_validation` en calculant la précision multiclasse. La précision multiclasse correspond au pourcentage des prédictions du modèle qui sont correctes.
```
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 sortie de la requête précédente doit ressembler à celle de l'exemple suivant. La valeur de la métrique de précision multiclasse doit être similaire à la métrique `validation:multiclass_accuracy` affichée par la sortie de l'opération SHOW MODEL.
```
+-------------------+-----------------------+-------------------+--------------+
| predicted_matches | predicted_non_matches | total_predictions | pct_accuracy |
+-------------------+-----------------------+-------------------+--------------+
| 41211 | 16324 | 57535 | 0.71627704 |
+-------------------+-----------------------+-------------------+--------------+
```
1. La requête suivante prédit le type de couverture le plus courant pour `wilderness_area2`. Ce jeu de données comprend quatre aires de nature sauvage et sept types de couverture. Une aire de nature sauvage peut avoir plusieurs types de couverture.
```
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 sortie de l'opération précédente doit ressembler à celle de l'exemple suivant. Cette sortie signifie que le modèle a prédit que la majeure partie de la couverture correspond au type de couverture 1, et qu'une partie de la couverture présente les types de couverture 2 et 7.
```
+----------------------+-------+
| predicted_cover_type | count |
+----------------------+-------+
| 2 | 564 |
| 7 | 97 |
| 1 | 2309 |
+----------------------+-------+
```
1. La requête suivante montre le type de couverture le plus courant dans une aire de nature sauvage individuelle. La requête affiche la quantité de ce type de couverture et l'aire de nature sauvage de ce type de couverture.
```
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 sortie de l'opération précédente doit ressembler à celle de l'exemple suivant.
```
+----------------------+-------+-----------------+
| predicted_cover_type | count | wilderness_area |
+----------------------+-------+-----------------+
| 2 | 15738 | 1 |
+----------------------+-------+-----------------+
```
## Rubriques en relation
Pour plus d'informations sur Amazon Redshift ML, consultez la documentation suivante :
+ [Coûts d'utilisation d'Amazon Redshift ML](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)
+ [Opération CREATE MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MODEL.html)
+ [Fonction EXPLAIN\$1MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)
Pour plus d'informations sur le machine learning, consultez la documentation suivante :
+ [Présentation du machine learning](https://docs.aws.amazon.com/redshift/latest/dg/machine_learning_overview.html)
+ [Machine learning pour les novices et les experts](https://docs.aws.amazon.com/redshift/latest/dg/novice_expert.html)
+ [En quoi consistent l’équité et l’explicabilité des modèles pour les prédictions de machine learning?](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)