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 : valider le modèle Rubriques en relation

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

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 : valider le modèle

Prérequis

Pour effectuer ce tutoriel, vous devez suivre la procédure Configuration administrative 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 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.

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

La requête suivante copie les données d'exemple à partir du jeu de données Abalone Data Set 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';
```
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

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 |
+-----+--------------------+

Utilisez la requête suivante pour exécuter l'opération EXPLAIN_MODEL 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_MODEL, consultez Fonction EXPLAIN_MODEL 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_MODEL 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" 
};
```

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 :

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

Tutoriel : Création de modèles de régression

Tutoriel : Création de modèles de classification multiclasse avec apprentissage linéaire