Exemples de cas d'utilisation Prérequis É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 Rubriques en relation

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 SageMaker , entraînez votre modèle d'apprentissage automatique, puis testez-le à l'aide des informations de profil d'un client arbitraire. Une fois le modèle validé, Amazon SageMaker 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

Prérequis
É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

Prérequis

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.
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, le fichier d'activité client et le fichier Abalone.
- À 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 </target/path>
aws s3 cp s3://redshift-downloads/redshift-ml/customer_activity/customer_activity.csv </target/path>
aws s3 cp s3://redshift-downloads/redshift-ml/abalone_xgb/abalone_xgb.csv </target/path>
```

Étape 1 : charger les données d'Amazon S3 dans Amazon Redshift

Utilisez l'éditeur de requête v2 Amazon Redshift 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 DOC-EXAMPLE-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 'DOC-EXAMPLE-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_BUCKET 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 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.

Ajouter des autorisations pour le chiffrement côté serveur (facultatif)

Amazon Redshift utilise par défaut Amazon SageMaker 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 SageMaker rôles Amazon, consultez la section relative aux SageMaker rôles Amazon dans le manuel Amazon SageMaker 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         |                                                                        DOC-EXAMPLE-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.

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

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;

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 :

Pour plus d'informations sur le machine learning, consultez la documentation suivante :

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Tutoriels pour Amazon Redshift ML

Tutoriel : Création de modèles d'inférence à distance