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.
# Machine learning
Le machine learning d’Amazon Redshift (Amazon Redshift ML) est un service robuste, basé sur le cloud, qui facilite l’utilisation de la technologie de machine learning par les analystes et les scientifiques des données de tous niveaux de compétence. Amazon Redshift ML utilise un modèle pour générer des résultats. Vous pouvez utiliser les modèles des manières suivantes :
+ Vous pouvez fournir les données que vous souhaitez pour entraîner un modèle et les métadonnées associées aux données en entrée à Amazon Redshift. Amazon Redshift ML crée ensuite des modèles dans Amazon SageMaker AI qui capturent des modèles dans les données d'entrée. En utilisant vos propres données pour le modèle, vous pouvez utiliser Amazon Redshift ML pour identifier les tendances des données, telles que la prévision du taux de désabonnement, la valeur du cycle de vie du client ou la prévision des revenus. Vous pouvez utiliser ces modèles pour générer des prédictions pour de nouvelles données entrées sans encourir de coûts supplémentaires.
+ Vous pouvez utiliser l’un des modèles de fondation (FM) fournis par Amazon Bedrock, tels que Claude ou Amazon Titan. À l'aide d'Amazon Bedrock, vous pouvez associer la puissance de grands modèles linguistiques (LLMs) à vos données d'analyse dans Amazon Redshift en quelques étapes. En utilisant un grand modèle de langage (LLM) externe, vous pouvez utiliser Amazon Redshift pour effectuer le traitement du langage naturel (NLP) sur vos données. Vous pouvez utiliser le traitement du langage naturel pour des applications telles que la génération de texte, l’analyse des sentiments ou la traduction. Pour plus d’informations sur l’utilisation d’Amazon Bedrock avec Amazon Redshift, consultez [Intégrations d’Amazon Redshift ML à Amazon Bedrock](machine-learning-br.md).
**Note**
**Refus d'utiliser vos données pour améliorer le service**
Si vous utilisez des modèles Amazon Bedrock, nous vous encourageons à lire les AWS politiques relatives à la manière dont le service Amazon Bedrock gère vos données. Vous devez déterminer si vous devez utiliser une politique de désinscription pour empêcher le service d’utiliser vos données pour améliorer le modèle ou le service, si Amazon Bedrock implémente une telle fonctionnalité à l’avenir. Pour vous assurer que le service n'utilise pas vos données à de telles fins, utilisez la politique générale de AWS désinscription.
Pour plus d’informations, consultez les ressources suivantes :
[Politiques de désabonnement aux services d'IA](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_ai-opt-out.html)
[Amazon Bedrock FAQs](https://aws.amazon.com/bedrock/faqs/)
**Note**
LLMs peut générer des informations inexactes ou incomplètes. Nous vous recommandons de vérifier les informations LLMs produites pour vous assurer qu'elles sont exactes et complètes.
**Comment Amazon Redshift ML fonctionne avec Amazon AI SageMaker **
Amazon Redshift fonctionne avec Amazon SageMaker AI Autopilot pour obtenir automatiquement le meilleur modèle et rendre la fonction de prédiction disponible dans Amazon Redshift.
Le schéma suivant illustre le fonctionnement d'Amazon Redshift ML.
![\[Flux de travail pour Amazon Redshift ML intégré à Amazon SageMaker AI Autopilot.\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/images/machine_learning_overview.png)
De manière générale, procédez comme suit :
1. Amazon Redshift exporte les données d'entraînement vers Amazon S3.
1. Amazon SageMaker AI Autopilot prétraite les données d'entraînement. Le *prétraitement* remplit des fonctions importantes, telles que l'imputation des valeurs manquantes. Il reconnaît que certaines colonnes sont catégoriques (comme le code postal), les formate correctement pour l'entraînement, et effectue de nombreuses autres tâches. Choisir les meilleurs préprocesseurs à appliquer à l'ensemble de données d'entraînement est un problème en soi, et Amazon SageMaker AI Autopilot automatise sa solution.
1. Amazon SageMaker AI Autopilot trouve l'algorithme et les hyperparamètres de l'algorithme qui fournissent au modèle les prédictions les plus précises.
1. Amazon Redshift enregistre la fonction de prédiction en tant que fonction SQL dans votre cluster Amazon Redshift.
1. Lorsque vous exécutez des instructions CREATE MODEL, Amazon Redshift utilise Amazon SageMaker AI pour la formation. Par conséquent, il y a un coût associé pour l'entraînement de votre modèle. Il s'agit d'une rubrique distincte pour Amazon SageMaker AI dans votre AWS facture. Vous payez également les frais de stockage de vos données d'entraînement dans Amazon S3. L'inférence qui utilise des modèles créés avec CREATE MODEL pouvant être compilés et exécutés sur votre cluster Redshift ne sera pas facturée. L'utilisation d'Amazon Redshift ML n'entraîne pas de frais supplémentaires pour Amazon Redshift.
**Topics**
+ [Présentation du machine learning](machine_learning_overview.md)
+ [Le machine learning pour les novices et les experts](novice_expert.md)
+ [Coûts d’utilisation d’Amazon Redshift ML](cost.md)
+ [Premiers pas avec Amazon Redshift ML](getting-started-machine-learning.md)
+ [Tutoriels pour Amazon Redshift ML](tutorials_for_amazon_redshift_ml.md)
+ [Intégrations d’Amazon Redshift ML à Amazon Bedrock](machine-learning-br.md)
# Présentation du machine learning
Avec Amazon Redshift, vous pouvez tirer parti des fonctionnalités de machine learning pour obtenir des informations précieuses à partir de vos données. Cette présentation du Machine Learning (ML) vous montre comment explorer, visualiser et préparer vos données pour l’entraînement des modèles et le déploiement du machine learning. Les sections suivantes vous guideront tout au long du processus d’utilisation d’Amazon Redshift ML pour exploiter le potentiel de vos données grâce au machine learning.
En utilisant Amazon Redshift ML, vous pouvez 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.
Pour vous aider à apprendre à utiliser Amazon Redshift ML, vous pouvez regarder la vidéo suivante.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/pJF2kYGtO4A)
Pour plus d’informations sur les conditions préalables à la configuration de votre cluster Redshift ou groupe de travail sans serveur, les autorisations et les droits de propriété pour utiliser Amazon Redshift ML, consultez les rubriques suivantes. Ces sections décrivent également le fonctionnement de l'entraînement et des prédictions simples dans Amazon Redshift ML.
## Comment le machine learning peut résoudre un problème
Un modèle de machine learning génère des prédictions en trouvant des modèles dans vos données d'entraînement et en appliquant ensuite ces modèles à de nouvelles données. Dans le machine learning, vous entraînez ces modèles en apprenant les schémas qui expliquent le mieux vos données. Ensuite, vous utilisez les modèles pour élaborer des prédictions (également appelées inférences) sur de nouvelles données. Le machine learning est typiquement un processus itératif où vous pouvez continuer à améliorer la précision des prédictions en changeant les paramètres et en améliorant vos données de formation. Si les données changent, il faut réentraîner de nouveaux modèles avec le nouveau jeu de données.
Pour répondre à divers objectifs métier, il existe différentes approches fondamentales en matière de machine learning.
### Apprentissage supervisé dans Amazon Redshift ML
Amazon Redshift prend en charge l'apprentissage supervisé, qui est l'approche la plus courante en matière d'analytique avancée d'entreprise. L'apprentissage supervisé est l'approche privilégiée du machine learning lorsque vous disposez d'un jeu de données établi et que vous comprenez comment des données d'entrée spécifiques prédisent divers résultats métier. Ces résultats sont parfois appelés étiquettes. En particulier, votre jeu de données est une table avec des attributs qui comprennent des caractéristiques (entrées) et des cibles (sorties). Par exemple, supposons que vous ayez une table qui fournit l'âge et le code postal des clients anciens et actuels. Supposons que vous ayez également un champ « active » (actif) qui est défini sur true pour les clients actuels et sur false pour les clients qui ont suspendu leur adhésion. L'objectif du machine learning supervisé est de repérer les modèles d'âge et de code postal menant à la perte de clients, tels que représentés par les clients dont les cibles ont la valeur « False ». Vous pouvez utiliser ce modèle pour prédire les clients susceptibles de se désabonner, par exemple en suspendant leur adhésion, et éventuellement offrir des incitatifs de rétention.
Amazon Redshift prend en charge l'apprentissage supervisé qui inclut la régression, la classification binaire et la classification multiclasse. La régression fait référence au problème de la prédiction de valeurs continues, telles que les dépenses totales des clients. La classification binaire fait référence au problème de la prédiction de l'un des deux résultats, comme la prédiction de la résiliation ou non d'un client. La classification multiclasse fait référence au problème de la prédiction d'un résultat parmi plusieurs, comme la prédiction de l'article qui pourrait intéresser un client. Les analystes et les scientifiques des données peuvent l'utiliser pour effectuer un apprentissage supervisé afin de s'attaquer à des problèmes allant de la prédiction à la personnalisation, en passant par la prédiction du taux de désabonnement des clients. Vous pouvez également utiliser l'apprentissage supervisé pour les problèmes tels que la prédiction des ventes qui seront conclues, la prédiction des revenus, la détection de fraude et la prédiction de la valeur de la durée de vie des clients.
### Apprentissage non supervisé dans Amazon Redshift ML
L'apprentissage non supervisé utilise des algorithmes de machine learning pour analyser et regrouper des données de formation non étiquetées. Les algorithmes découvrent des modèles ou des regroupements cachés. L'objectif est de modéliser la structure ou la distribution sous-jacente dans les données pour en savoir plus sur les données.
Amazon Redshift prend en charge l'algorithme de mise en cluster K-Means pour résoudre un problème d'apprentissage non supervisé. Cet algorithme résout les problèmes de mise en cluster lorsque vous souhaitez découvrir des regroupements dans les données. L'algorithme K-Means tente de trouver des regroupements discrets dans les données. Les données non classifiées sont regroupées et partitionnées en fonction de leurs similitudes et de leurs différences. Grâce au regroupement, l'algorithme K-Means détermine de manière itérative les meilleurs centroïdes et affecte chaque membre au centroïde le plus proche. Les membres les plus proches du même centroïde 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. Par exemple, l'algorithme de mise en cluster K-Means peut être utilisé pour classer les villes touchées par une pandémie ou en fonction de la popularité des produits de consommation.
Lorsque vous utilisez l'algorithme K-Means, vous spécifiez une entrée `k` qui indique le nombre de clusters à trouver dans les données. La sortie de cet algorithme est un ensemble de centroïdes k. Chaque point de données appartient à l'un des clusters k les plus proches. Chaque cluster est décrit par son centroïde. Le centroïde peut être considéré comme la moyenne multidimensionnelle du cluster. L'algorithme K-Means compare les distances pour voir à quel point les clusters sont différents les uns des autres. Une distance plus grande indique généralement une plus grande différence entre les clusters.
Le prétraitement des données est important pour K-Means, car il garantit que les fonctions du modèle restent à la même échelle et produisent des résultats fiables. Amazon Redshift prend en charge certains préprocesseurs K-Means pour l'instruction CREATE MODEL, tels que StandardScaler, et. MinMax NumericPassthrough Si vous ne souhaitez appliquer aucun prétraitement pour K-means, choisissez-le NumericPassthrough explicitement en tant que transformateur. Pour plus d'informations sur les paramètres K-Means, consultez [CREATE MODEL avec les paramètres K-MEANS](r_create_model_use_cases.md#r_k-means-create-model-parameters).
Pour vous aider à apprendre à effectuer une formation non supervisée avec le clustering K-Means, vous pouvez regarder la vidéo suivante.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/TFKgl5d0U_0)
## Termes et concepts pour Amazon Redshift ML
Les termes suivants sont utilisés pour décrire certains concepts d'Amazon Redshift ML :
+ Le *machine learning* dans Amazon Redshift entraîne un modèle avec une instruction SQL. Amazon Redshift ML et Amazon SageMaker AI gèrent toutes les conversions de données, les autorisations, l'utilisation des ressources et la découverte du modèle approprié.
+ L'*entraînement* est la phase où Amazon Redshift crée un modèle de machine learning en exécutant un sous-jeu spécifié de données dans le modèle. Amazon Redshift lance automatiquement une tâche de formation dans Amazon SageMaker AI et génère un modèle.
+ La *prédiction* (également appelée *inférence*) est l'utilisation du modèle dans les requêtes SQL Amazon Redshift pour prédire les résultats. Au moment de l'inférence, Amazon Redshift utilise une fonction de prédiction basée sur un modèle dans le cadre d'une requête plus vaste pour produire des prédictions. Les prédictions sont calculées localement, au niveau du cluster Redshift, offrant ainsi un débit élevé, une faible latence et aucuns frais.
+ Avec *Bring your own model (BYOM)*, vous pouvez utiliser un modèle formé en dehors d'Amazon Redshift avec Amazon AI pour effectuer des inférences dans la base de données localement dans SageMaker Amazon Redshift. Amazon Redshift ML prend en charge l'utilisation de BYOM dans l'inférence locale.
+ L'*inférence locale* est utilisée lorsque les modèles sont préentraînés dans Amazon SageMaker AI, compilés par Amazon SageMaker AI Neo et localisés dans Amazon Redshift ML. Pour importer des modèles pris en charge pour l'inférence locale dans Amazon Redshift, utilisez l'instruction CREATE MODEL. Amazon Redshift importe les modèles d'IA préentraînés en appelant Amazon SageMaker SageMaker AI Neo. Vous y compilez le modèle et importez le modèle compilé dans Amazon Redshift. Utilisez l'inférence locale pour accélérer la vitesse et réduire les coûts.
+ *L'inférence à distance* est utilisée lorsqu'Amazon Redshift invoque un modèle de point de terminaison déployé dans l'IA. SageMaker L'inférence à distance offre la flexibilité d'invoquer tous les types de modèles personnalisés et de modèles d'apprentissage profond, tels que les TensorFlow modèles que vous avez créés et déployés dans Amazon SageMaker AI.
Les éléments suivants sont également importants :
+ *Amazon SageMaker AI* est un service d'apprentissage automatique entièrement géré. Avec Amazon SageMaker AI, les data scientists et les développeurs peuvent facilement créer, former et déployer directement des modèles dans un environnement hébergé prêt pour la production. Pour plus d'informations sur Amazon SageMaker AI, consultez la section [Qu'est-ce qu'Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/whatis.html) dans le manuel *Amazon SageMaker AI Developer Guide*.
+ *Amazon SageMaker AI Autopilot* est un ensemble de fonctionnalités qui entraîne et règle automatiquement les meilleurs modèles d'apprentissage automatique pour la classification ou la régression, en fonction de vos données. Vous conservez le plein contrôle et une visibilité totale. Amazon SageMaker AI Autopilot prend en charge les données d'entrée au format tabulaire. Amazon SageMaker AI Autopilot assure le nettoyage et le prétraitement automatiques des données, la sélection automatique d'algorithmes pour la régression linéaire, la classification binaire et la classification multiclasse. Il prend également en charge l'optimisation automatique des hyperparamètres (HPO), l'entraînement distribué, ainsi que les instances automatiques et la sélection de la taille des clusters. Pour plus d'informations sur Amazon SageMaker AI Autopilot, consultez [Automatiser le développement de modèles avec Amazon SageMaker AI Autopilot dans](https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-automate-model-development.html) le manuel *Amazon SageMaker * AI Developer Guide.
+ *Amazon Bedrock* est un service entièrement géré qui propose un choix de modèles de base très performants (FMs) proposés par des sociétés d'IA de premier plan telles que AI21 Labs, Anthropic, Cohere, Meta, Mistral AI, Stability AI et Amazon via une seule API, ainsi qu'un large éventail de fonctionnalités nécessaires pour créer des applications d'IA génératives.
# Le machine learning pour les novices et les experts
Avec Amazon Redshift, vous pouvez tirer parti des fonctionnalités du machine learning (ML) pour obtenir des informations à partir de vos données, que vous soyez novice ou expert en machine learning. Le machine learning est une fonctionnalité d’Amazon Redshift qui vous permet de créer, d’entraîner et de déployer des modèles de machine learning à l’aide de commandes SQL, sans avoir besoin d’une expertise approfondie en machine learning ou d’une ingénierie de données complexe.
Les sections suivantes vous guident tout au long du processus d’utilisation du machine learning, afin de vous permettre d’exploiter tout le potentiel de vos données avec Amazon Redshift.
Amazon Redshift ML vous permet d'entraîner des modèles avec une seule instruction SQL CREATE MODEL. L'instruction CREATE MODEL crée un modèle qu'Amazon Redshift utilise pour générer des prédictions basées sur un modèle avec des constructions SQL familières.
Amazon Redshift ML est particulièrement utile lorsque vous n'avez aucune expertise en matière d'apprentissage automatique, d'outils, de langages, d'algorithmes et. APIs Avec Amazon Redshift ML, vous n'avez pas à effectuer les opérations lourdes et indifférenciées nécessaires à l'intégration d'un service externe de machine learning. Amazon Redshift vous fait gagner du temps pour formater et déplacer les données, gérer les contrôles d'autorisation ou créer des intégrations, des flux de travail et des scripts personnalisés. Vous pouvez facilement utiliser les algorithmes de machine learning les plus populaires et simplifier les besoins en entraînement qui nécessitent une itération fréquente de l'entraînement à la prédiction. Amazon Redshift détermine automatiquement le meilleur algorithme et affine le meilleur modèle correspondant à votre problème. Vous pouvez faire des prédictions à partir du cluster Amazon Redshift sans avoir à déplacer les données en dehors d'Amazon Redshift ni à vous interfacer avec un autre service et à payer pour celui-ci.
Amazon Redshift ML soutient les analystes de données et les scientifiques des données dans l'utilisation du machine learning. Il permet également aux experts du machine learning d'utiliser leurs connaissances pour guider l'instruction CREATE MODEL afin d'utiliser uniquement les aspects qu'ils spécifient. En procédant ainsi, vous pouvez accélérer le temps dont CREATE MODEL a besoin pour trouver le meilleur candidat et/ou améliorer la précision du modèle.
L'instruction CREATE MODEL offre une certaine souplesse dans la façon dont vous pouvez spécifier les paramètres de la tâche d'entraînement. Cette flexibilité permet aux utilisateurs novices ou experts en machine learning de choisir leurs préprocesseurs, algorithmes, types de problèmes ou hyperparamètres préférés. Par exemple, un utilisateur intéressé par le taux de désabonnement peut spécifier dans l'instruction CREATE MODEL que le type de problème est une classification binaire qui fonctionne bien pour le taux de désabonnement. Ensuite, l'instruction CREATE MODEL réduit sa recherche du meilleur modèle à ceux de type classification binaire. Même si l'utilisateur choisit le type de problème, il existe encore de nombreuses options à utiliser avec l'instruction CREATE MODEL. Par exemple, la fonction CREATE MODEL détermine et applique les meilleures transformations de prétraitement et sélectionne les meilleurs réglages d'hyperparamètres.
Amazon Redshift ML facilite la formation en trouvant automatiquement le meilleur modèle à l'aide d'Amazon SageMaker AI Autopilot. Dans les coulisses, Amazon SageMaker AI Autopilot entraîne et règle automatiquement le meilleur modèle d'apprentissage automatique en fonction des données que vous avez fournies. Amazon SageMaker AI Neo compile ensuite le modèle d'entraînement et le rend disponible à des fins de prédiction dans votre cluster Redshift. Lorsque vous exécutez une requête d'inférence basée sur le machine learning à l'aide d'un modèle entraîné, la requête peut utiliser toutes les capacités de traitement massivement parallèle d'Amazon Redshift. En même temps, la requête peut utiliser une prédiction basée sur le machine learning.
+ Si vous *débutez avec le machine learning* et que vous avez une connaissance générale des différents aspects de celui-ci, tels que les préprocesseurs, les algorithmes et les hyperparamètres, utilisez l'instruction CREATE MODEL uniquement pour les aspects que vous spécifiez. Vous pouvez alors réduire le temps dont CREATE MODEL a besoin pour trouver le meilleur candidat ou améliorer la précision du modèle. En outre, vous pouvez augmenter la valeur opérationnelle des prédictions en introduisant des connaissances supplémentaires du domaine telles que le type de problème ou l'objectif. Par exemple, dans un scénario de désabonnement client, si le résultat « le client n'est pas actif » est rare, l'objectif F1 est souvent préféré à l'objectif Précision. Étant donné que les modèles à haute précision peuvent prédire « le client est actif » tout le temps, il en résulte une haute précision, mais peu de valeur opérationnelle. Pour plus d'informations sur les objectifs F1, consultez [Auto MLJob Objective](https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_AutoMLJobObjective.html) dans le *manuel Amazon SageMaker AI API Reference*.
Pour plus d'informations sur les options de base de l'instruction CREATE MODEL, consultez [CREATE MODEL simple](r_create_model_use_cases.md#r_simple_create_model).
+ Si vous êtes un *pratiquant avancé du machine learning*, vous pouvez spécifier le type de problème et les préprocesseurs pour certaines fonctions (mais pas toutes). Ensuite, le modèle CREATE suit vos suggestions sur les aspects spécifiés. Dans le même temps, CREATE MODEL détecte les meilleurs préprocesseurs pour les fonctions restantes et les meilleurs hyperparamètres. Pour plus d'informations sur la façon de limiter un ou plusieurs aspects du pipeline d'entraînement, consultez [CREATE MODEL avec guide de l’utilisateur](r_create_model_use_cases.md#r_user_guidance_create_model).
+ Si vous êtes *expert en machine learning*, vous pouvez prendre le contrôle total de l'entraînement et du réglage des hyperparamètres. L'instruction CREATE MODEL ne cherche pas à déterminer les préprocesseurs, algorithmes et hyperparamètres optimaux, car c'est vous qui faites tous les choix. Pour plus d'informations sur l'utilisation de l'instruction CREATE MODEL avec AUTO OFF, consultez [CRÉEZ des XGBoost modèles avec AUTO OFF](r_create_model_use_cases.md#r_auto_off_create_model).
+ En tant qu'*ingénieur de données*, vous pouvez utiliser un XGBoost modèle préentraîné dans Amazon SageMaker AI et l'importer dans Amazon Redshift pour une inférence locale. Avec Bring your own model (BYOM), vous pouvez utiliser un modèle formé en dehors d'Amazon Redshift avec Amazon AI pour effectuer des inférences dans la base de données localement dans SageMaker Amazon Redshift. Amazon Redshift ML prend en charge l'utilisation de BYOM en inférence locale ou distante.
Pour plus d'informations sur l'utilisation de l'instruction CREATE MODEL pour une inférence locale ou distante, consultez [Modèle BYOM (Bring Your Own Model) : inférence locale](r_create_model_use_cases.md#r_byom_create_model).
Si vous utilisez Amazon Redshift ML, vous pouvez choisir l'une des options suivantes pour entraîner et déployer votre modèle.
+ Types de problèmes, voir [CREATE MODEL avec guide de l’utilisateur](r_create_model_use_cases.md#r_user_guidance_create_model).
+ Objectifs, voir [CREATE MODEL avec guide de l’utilisateur](r_create_model_use_cases.md#r_user_guidance_create_model) ou [CRÉEZ des XGBoost modèles avec AUTO OFF](r_create_model_use_cases.md#r_auto_off_create_model).
+ Types de modèles, voir[CRÉEZ des XGBoost modèles avec AUTO OFF](r_create_model_use_cases.md#r_auto_off_create_model).
+ Préprocesseurs, voir [CREATE MODEL avec guide de l’utilisateur](r_create_model_use_cases.md#r_user_guidance_create_model).
+ Hyperparamètres, voir [CRÉEZ des XGBoost modèles avec AUTO OFF](r_create_model_use_cases.md#r_auto_off_create_model).
+ BYOM (Bring Your Own Model), voir [Modèle BYOM (Bring Your Own Model) : inférence locale](r_create_model_use_cases.md#r_byom_create_model).
# Coûts d’utilisation d’Amazon Redshift ML
Avec Amazon Redshift, vous pouvez tirer parti des fonctionnalités de machine learning pour obtenir des informations à partir de vos données sans avoir besoin d’une expertise approfondie en ingénierie des données ou en machine learning. Les sections suivantes décrivent les coûts associés à l’utilisation d’Amazon Redshift ML, afin de vous aider à planifier et à optimiser vos dépenses tout en tirant parti de cette puissante intégration du machine learning.
## Coûts liés à l'utilisation d'Amazon Redshift ML avec l'IA SageMaker
Amazon Redshift ML for SageMaker AI utilise les ressources de votre cluster existantes à des fins de prévision afin que vous puissiez éviter des frais supplémentaires liés à Amazon Redshift. Il n'y a pas de frais supplémentaires Amazon Redshift pour la création ou l'utilisation d'un modèle. La prédiction se produit localement dans votre cluster Redshift. Vous n'avez donc pas à payer de frais supplémentaires à moins que vous n'ayez besoin de redimensionner votre cluster. Amazon Redshift ML utilise Amazon SageMaker AI pour entraîner votre modèle, ce qui entraîne un coût supplémentaire.
Il n'y a pas de frais supplémentaires pour les fonctions de prédiction qui s'exécutent au sein de votre cluster Amazon Redshift. L'instruction CREATE MODEL utilise Amazon SageMaker AI et entraîne un coût supplémentaire. Le coût augmente avec le nombre de cellules dans vos données d'entraînement. Le nombre de cellules est le produit du nombre d'enregistrements (dans la requête d'entraînement ou dans la table) multiplié par le nombre de colonnes. Par exemple, lorsqu'une requête SELECT de l'instruction CREATE MODEL crée 10 000 enregistrements et 5 colonnes, le nombre de cellules qu'elle crée est de 50 000.
Dans certains cas, les données d'entraînement produites par la requête SELECT de CREATE MODEL dépassent la limite MAX\$1CELLS que vous avez indiquée (ou la limite par défaut de 1 million si vous n'en avez pas spécifiée). Dans ces cas, CREATE MODEL choisit au hasard la limite MAX\$1CELLS (c'est-à-dire le nombre d'enregistrements « colonnes » du jeu de données d'entraînement). CREATE MODEL effectue ensuite un entraînement à l'aide de ces tuples choisis au hasard. L'échantillonnage aléatoire garantit que le jeu de données d'entraînement réduit n'aura aucun biais. Ainsi, en définissant la limite MAX\$1CELLS, vous pouvez contrôler vos coûts d'entraînement.
Lorsque vous utilisez l'instruction de commande CREATE MODEL, vous pouvez utiliser les options MAX\$1CELLS et MAX\$1RUNTIME pour contrôler les coûts, le temps et la précision potentielle du modèle.
MAX\$1RUNTIME indique la durée maximale que l'entraînement peut prendre dans l' SageMaker IA lorsque l'option AUTO ON ou OFF est utilisée. Les tâches d'entraînement se terminent souvent plus tôt que MAX\$1RUNTIME, en fonction de la taille du jeu de données. Après l'entraînement d'un modèle, Amazon Redshift effectue une tâche supplémentaire en arrière-plan pour compiler et installer vos modèles dans votre cluster. Ainsi, l'exécution de CREATE MODEL peut prendre plus de temps que MAX\$1RUNTIME. Cependant, MAX\$1RUNTIME limite la quantité de calcul et le temps utilisés par l' SageMaker IA pour entraîner votre modèle. Vous pouvez vérifier l'état de votre modèle à tout moment en utilisant la commande SHOW MODEL.
Lorsque vous exécutez CREATE MODEL avec AUTO ON, Amazon Redshift ML utilise le pilote automatique SageMaker AI pour explorer automatiquement et intelligemment différents modèles (ou candidats) afin de trouver le meilleur. MAX\$1RUNTIME limite la durée et le nombre de calculs effectués. Si la valeur MAX\$1RUNTIME est trop basse, il se peut qu'il n'y ait pas assez de temps pour explorer ne serait-ce qu'un seul candidat. Si l'erreur « Autopilot candidate has no models (Le candidat Autopilot n'a pas de modèles) » s'affiche, réexécutez l'instruction CREATE MODEL avec une valeur MAX\$1RUNTIME plus élevée. Pour plus d'informations sur ce paramètre, consultez [MaxAutoMLJobRuntimeInSeconds](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AutoMLJobCompletionCriteria.html)le manuel *Amazon SageMaker AI API Reference*.
Lorsque vous exécutez CREATE MODEL avec AUTO OFF, MAX\$1RUNTIME correspond à une limite de durée d'exécution de la tâche d'entraînement dans SageMaker l'IA. Les tâches d'entraînement se terminent souvent plus tôt, en fonction de la taille du jeu de données et des autres paramètres utilisés, tels que num\$1rounds dans MODEL\$1TYPE XGBOOST.
Vous pouvez également contrôler les coûts ou réduire le temps d'entraînement en spécifiant une valeur MAX\$1CELLS plus petite lorsque vous exécutez CREATE MODEL. Une *cellule* est une entrée dans la base de données. Chaque ligne correspond à autant de cellules qu'il y a de colonnes, qui peuvent être de largeur fixe ou variable. MAX\$1CELLS limite le nombre de cellules, et donc le nombre d'exemples d'entraînement utilisés pour entraîner votre modèle. Par défaut, MAX\$1CELLS est défini à 1 million de cellules. La réduction de MAX\$1CELLS réduit le nombre de lignes issues du résultat de la requête SELECT dans CREATE MODEL qu'Amazon Redshift exporte et envoie SageMaker à AI pour entraîner un modèle. La réduction de MAX\$1CELLS permet donc de réduire la taille du jeu de données utilisé pour entraîner les modèles, que ce soit avec AUTO ON ou AUTO OFF. Cette approche permet de réduire les coûts et le temps d'entraînement des modèles. Pour consulter les informations relatives à la formation et aux délais de facturation d'une tâche de formation spécifique, choisissez **Training jobs** in Amazon SageMaker AI.
L'augmentation de MAX\$1RUNTIME et de MAX\$1CELLS améliore souvent la qualité des modèles en permettant à l' SageMaker IA d'explorer davantage de candidats. Ainsi, l' SageMaker IA peut prendre plus de temps pour former chaque candidat et utiliser davantage de données pour former de meilleurs modèles. Si vous souhaitez une itération ou une exploration plus rapide de votre jeu de données, utilisez des valeurs MAX\$1RUNTIME et MAX\$1CELLS plus basses. Si vous souhaitez améliorer la précision des modèles, utilisez des valeurs MAX\$1RUNTIME et MAX\$1CELLS plus élevées.
Pour plus d'informations sur les coûts associés aux différents nombres de cellules et sur les détails de l'offre gratuite, consultez la [tarification Amazon Redshift](https://aws.amazon.com/redshift/pricing).
## Coûts d’utilisation d’Amazon Redshift ML avec Amazon Bedrock
L’utilisation d’Amazon Redshift ML avec Amazon Bedrock entraîne des coûts supplémentaires. Pour plus d’informations, consultez [Tarification d’Amazon Bedrock](https://aws.amazon.com/bedrock/pricing/).
# Premiers pas avec Amazon Redshift ML
Amazon Redshift ML permet aux utilisateurs de SQL de créer, d'entraîner et de déployer facilement des modèles de machine learning à l'aide d'instructions SQL familières. Avec Amazon Redshift ML, vous pouvez utiliser les données de votre cluster Redshift pour entraîner des modèles avec Amazon AI. SageMaker Ensuite, les modèles sont localisés et les prédictions peuvent être faites dans une base de données Amazon Redshift. Amazon Redshift ML prend actuellement en charge les algorithmes d'apprentissage automatique suivants : XGBoost (AUTO ON et OFF), perceptron multicouche (AUTO ON), K-Means (AUTO OFF) et Linear Learner.
**Topics**
+ [Cluster et configuration de la mise en place pour l'administration Amazon Redshift ML](#admin-setup)
+ [Utilisation de l'explicabilité du modèle avec Amazon Redshift ML](#clarify)
+ [Métriques de probabilité Amazon Redshift ML](#probability_metrics)
## Cluster et configuration de la mise en place pour l'administration Amazon Redshift ML
Avant de travailler avec Amazon Redshift ML, terminez la configuration du cluster et configurez les autorisations pour utiliser Amazon Redshift ML.
### Configuration du cluster pour l’utilisation d’Amazon Redshift ML
Avant de travailler avec Amazon Redshift ML, vous devez remplir les conditions préalables suivantes.
En tant qu’administrateur Amazon Redshift, effectuez la configuration unique suivante pour utiliser les clusters alloués par Amazon Redshift. Pour utiliser Amazon Redshift ML avec Amazon Redshift sans serveur, consultez [Premiers pas avec Amazon Redshift sans serveur](https://docs.aws.amazon.com/redshift/latest/gsg/new-user-serverless.html).
Pour effectuer une configuration de cluster unique pour Amazon Redshift ML
1. Créez un cluster Redshift à l'aide du AWS Management Console ou du AWS Command Line Interface ()AWS CLI. Assurez-vous d'associer la politique Gestion des identités et des accès AWS (IAM) lors de la création du cluster. Pour plus d'informations sur les autorisations requises pour utiliser Amazon Redshift ML avec Amazon SageMaker AI, consultez [Autorisations requises pour utiliser Amazon Redshift machine](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-identity-based.html#iam-permission-ml?) learning (ML)
1. Créez le rôle IAM requis pour utiliser le machine learning Amazon Redshift de l'une des manières suivantes :
+ Pour utiliser l' SageMaker IA avec Amazon Redshift ML, créez un rôle IAM avec des `AmazonS3FullAccess` politiques. `AmazonSageMakerFullAccess` Si vous envisagez également de créer des modèles de prévisions, associez également la politique `AmazonForecastFullAccess` à votre rôle.
+ Pour utiliser Amazon Bedrock avec Amazon Redshift ML, créez un rôle IAM avec les stratégies `AmazonS3FullAccess` et `AmazonBedrockFullAccess`.
+ Nous vous recommandons de créer un rôle IAM via la console Amazon Redshift avec la politique `AmazonRedshiftAllCommandsFullAccess` disposant des autorisations nécessaires pour exécuter des commandes SQL, telles que CREATE MODEL. Amazon Redshift utilise un mécanisme transparent basé sur une API pour créer des rôles IAM par programme en votre nom. Compte AWS Amazon Redshift associe automatiquement les politiques AWS gérées existantes au rôle IAM. Cette approche signifie que vous pouvez rester dans la console Amazon Redshift et que vous n'avez pas besoin de passer à la console IAM pour créer des rôles. Pour plus d'informations, consultez [Création d'un rôle IAM par défaut pour Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/default-iam-role.html).
Lorsqu'un rôle IAM est créé comme rôle par défaut pour votre cluster, incluez `redshift` dans le nom de la ressource ou utilisez une balise spécifique à RedShift pour étiqueter ces ressources.
Pour utiliser les modèles de fondation Amazon Bedrock, ajoutez la section suivante :
```
// Required section if you use Bedrock models.
{
"Effect": "Allow",
"Action": "bedrock:InvokeModel",
"Resource": [
"arn:aws:bedrock:::foundation-model/*"
]
}
```
+ Si vous souhaitez créer un rôle IAM avec une politique plus restrictive, vous pouvez utiliser celle qui suit. Vous pouvez également modifier cette politique afin de répondre à vos besoins.
Le compartiment Amazon S3 `redshift-downloads/redshift-ml/` est l'emplacement où sont stockées les exemples de données utilisés pour les autres étapes et exemples. Vous pouvez le supprimer si vous n'avez pas besoin de charger des données à partir d'Amazon S3. Ou alors, remplacez-le par d'autres compartiments Amazon S3 que vous utilisez pour charger des données dans Amazon Redshift.
Les valeurs *`your-account-id`*, *`your-role`* et `amzn-s3-demo-bucket` sont celles que vous spécifiez dans le cadre de votre instruction CREATE MODEL.
(Facultatif) Utilisez la section AWS KMS clés de l'exemple de politique si vous spécifiez une AWS KMS clé lors de l'utilisation d'Amazon Redshift ML. La valeur *`your-kms-key`* est la clé que vous utilisez dans le cadre de votre instruction CREATE MODEL.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudwatch:PutMetricData",
"ecr:BatchCheckLayerAvailability",
"ecr:BatchGetImage",
"ecr:GetAuthorizationToken",
"ecr:GetDownloadUrlForLayer",
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:DescribeLogStreams",
"logs:PutLogEvents",
"sagemaker:*Job*",
"sagemaker:AddTags",
"sagemaker:CreateModel",
"sagemaker:CreateEndpoint",
"sagemaker:CreateEndpointConfig",
"sagemaker:DeleteEndpoint",
"sagemaker:DeleteEndpointConfig",
"sagemaker:DeleteModel"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"iam:PassRole",
"s3:AbortMultipartUpload",
"s3:GetObject",
"s3:DeleteObject",
"s3:PutObject"
],
"Resource": [
"arn:aws:iam::111122223333:role/",
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::redshift-downloads/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:GetBucketLocation",
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::redshift-downloads"
]
},
{
"Effect": "Allow",
"Action": [
"kms:CreateGrant",
"kms:Decrypt",
"kms:DescribeKey",
"kms:Encrypt",
"kms:GenerateDataKey*"
],
"Resource": [
"arn:aws:kms:us-east-1:111122223333:key/"
]
}
]
}
```
------
1. Pour permettre à Amazon Redshift et à SageMaker AI d'assumer le rôle d'interaction avec d'autres services, ajoutez la politique de confiance suivante au rôle IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"redshift.amazonaws.com",
"sagemaker.amazonaws.com",
"forecast.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. (Facultatif) Créez un compartiment Amazon S3 et une AWS KMS clé. Ils sont destinés à Amazon Redshift pour stocker les données de formation envoyées à Amazon SageMaker AI et recevoir le modèle entraîné depuis Amazon SageMaker AI.
1. (Facultatif) Créez différentes combinaisons de rôles IAM et de compartiments Amazon S3 pour contrôler l'accès à différents groupes d'utilisateurs.
1. Lorsque vous activez le routage VPC amélioré, le trafic entre Redshift ML et votre compartiment S3 passe par votre VPC privé. Pour plus d'informations sur le routage VPC, consultez [Routage VPC amélioré dans Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/enhanced-vpc-routing.html).
Pour plus d'informations sur les autorisations requises pour spécifier un VPC privé pour votre tâche de réglage des hyperparamètres, consultez [Autorisations requises pour utiliser Amazon Redshift ML avec Amazon AI](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-identity-based.html). SageMaker
**Note**
Les appels d'inférence effectués vers des modèles d' SageMaker IA distants ne passent pas par votre VPC.
Pour plus d'informations sur la manière d'utiliser l'instruction CREATE MODEL pour commencer à créer des modèles pour différents cas d'utilisation, consultez [CREATE MODEL](r_CREATE_MODEL.md).
### Gestion des autorisations et de la propriété
Tout comme pour d'autres objets de base de données, tels que des tables ou des fonctions, Amazon Redshift lie la création et l'utilisation de modèles ML pour accéder aux mécanismes de contrôle. Il existe des autorisations distinctes pour la création d'un modèle exécutant des fonctions de prédiction.
Les exemples suivants illustrent comment Amazon Redshift gère le contrôle d'accès en utilisant deux groupes d'utilisateurs, `retention_analyst_grp` (créateur du modèle) et `marketing_analyst_grp` (utilisateur du modèle). L'analyste de rétention crée des modèles de machine learning que d'autres groupes d'utilisateurs peuvent utiliser grâce aux autorisations acquises.
Un super-utilisateur peut accorder l'autorisation GRANT USER ou GROUP pour créer des modèles de machine learning à l'aide de l'instruction suivante.
```
GRANT CREATE MODEL TO GROUP retention_analyst_grp;
```
Les utilisateurs ou groupes disposant de cette autorisation peuvent créer un modèle dans n'importe quel schéma du cluster si un utilisateur dispose de l'autorisation CREATE habituelle sur le SCHEMA. Le modèle de machine learning fait partie de la hiérarchie du schéma de la même manière que les tables, les vues, les procédures et les fonctions définies par l'utilisateur.
En supposant qu'un schéma `demo_ml` existe déjà, accordez l'autorisation aux deux groupes d'utilisateurs sur le schéma comme suit.
```
GRANT CREATE, USAGE ON SCHEMA demo_ml TO GROUP retention_analyst_grp;
```
```
GRANT USAGE ON SCHEMA demo_ml TO GROUP marketing_analyst_grp;
```
Vous pouvez permettre à d'autres utilisateurs d'utiliser votre fonction d'inférence du machine learning en leur accordant l'autorisation EXECUTE. L'exemple suivant utilise l'autorisation EXECUTE pour accorder au groupe marketing\$1analyst\$1grp l'autorisation d'utiliser le modèle.
```
GRANT EXECUTE ON MODEL demo_ml.customer_churn_auto_model TO GROUP marketing_analyst_grp;
```
Utilisez l'instruction REVOKE avec CREATE MODEL et EXECUTE pour révoquer ces autorisations auprès d'utilisateurs ou de groupes. Pour plus d'informations sur les instructions de contrôle d'autorisations, consultez [GRANT](r_GRANT.md) et [REVOKE](r_REVOKE.md).
## Utilisation de l'explicabilité du modèle avec Amazon Redshift ML
Avec l'explicabilité du modèle dans Amazon Redshift ML, vous utilisez des valeurs d'importance des fonctions pour aider à comprendre comment chaque attribut de vos données d'entraînement contribue au résultat prédit.
L'explicabilité du modèle aide à améliorer vos modèles de machine learning (ML) en expliquant les prédictions réalisées par vos modèles. L'explicabilité du modèle vous explique comment les modèles réalisent des prédictions à l'aide d'une approche d'attribution de fonctions.
Amazon Redshift ML intègre l'explicabilité du modèle pour fournir une fonctionnalité d'explication du modèle aux utilisateurs Amazon Redshift ML. Pour plus d'informations sur l'explicabilité des modèles, consultez [Qu'est-ce que l'équité et l'explicabilité des modèles pour les prédictions du Machine Learning ?](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html) dans le manuel *Amazon SageMaker AI Developer Guide*.
L'explicabilité du modèle surveille également les inférences produites par les modèles en production, pour la dérive dans l'attribution de fonctions. Elle fournit également les outils nécessaires pour générer des rapports de gouvernance de modèles destinés aux équipes responsables des risques et de la conformité, et aux organismes de réglementation externes.
Lorsque vous spécifiez l'option AUTO ON ou AUTO OFF lorsque vous utilisez l'instruction CREATE MODEL, une fois la tâche d'entraînement du modèle terminée, l' SageMaker IA crée la sortie d'explication. Vous pouvez utiliser la fonction EXPLAIN\$1MODEL pour interroger le rapport d'explicabilité au format JSON. Pour plus d’informations, consultez [Solutions de machine learning](ml-function.md).
## Métriques de probabilité Amazon Redshift ML
Dans les problèmes d'apprentissage supervisé, les étiquettes de classe sont le résultat de prédictions utilisant les données d'entrée. Par exemple, si vous utilisez un modèle pour prédire si un client se réabonnera à un service de streaming, les étiquettes possibles sont probable et peu probable. Redshift ML offre la possibilité d'utiliser des métriques de probabilité, qui attribuent une probabilité à chaque étiquette pour indiquer sa probabilité. Cela vous permet de prendre des décisions plus éclairées en fonction des résultats prévus. Dans Amazon Redshift ML, des métriques de probabilité sont disponibles lors de la création de modèles AUTO ON présentant un type de problème de classification binaire ou de classification multi-classes. Si vous omettez le paramètre AUTO ON, Redshift ML suppose que le modèle doit disposer de la fonction AUTO ON.
### Créer le modèle
Lors de la création d'un modèle, Amazon Redshift détecte automatiquement le type de modèle et le type de problème. S'il s'agit d'un problème de classification, Redshift crée automatiquement une deuxième fonction d'inférence que vous pouvez utiliser pour générer des probabilités relatives à chaque étiquette. Le nom de cette deuxième fonction d'inférence est le nom de la fonction d'inférence que vous avez spécifié, suivi de la chaîne `_probabilities`. Par exemple, si vous nommez votre fonction d'inférence `customer_churn_predict`, le nom de la deuxième fonction d'inférence est `customer_churn_predict_probabilities`. Vous pouvez ensuite interroger cette fonction pour obtenir les probabilités de chaque étiquette.
```
CREATE MODEL customer_churn_model
FROM customer_activity
PROBLEM_TYPE BINARY_CLASSIFICATION
TARGET churn
FUNCTION customer_churn_predict
IAM_ROLE {default}
AUTO ON
SETTINGS ( S3_BUCKET 'amzn-s3-demo-bucket'
```
### Obtenir des probabilités
Une fois que la fonction de probabilité est prête, l'exécution de la commande renvoie un [type SUPER](https://docs.aws.amazon.com/redshift/latest/dg/r_SUPER_type.html) qui contient des tableaux des probabilités renvoyées et leurs étiquettes associées. Par exemple, le résultat `"probabilities" : [0.7, 0.3], "labels" : ["False.", "True."]` signifie que l'étiquette False a une probabilité de 0,7 et que l'étiquette True a une probabilité de 0,3.
```
SELECT customer_churn_predict_probabilities(Account_length, Area_code,
VMail_message, Day_mins, Day_calls, Day_charge,Eve_mins, Eve_calls,
Eve_charge, Night_mins, Night_calls, Night_charge,Intl_mins, Intl_calls,
Intl_charge, Cust_serv_calls)
FROM customer_activity;
customer_churn_predict_probabilities
--------------------
{"probabilities" : [0.7, 0.3], "labels" : ["False.", "True."]}
{"probabilities" : [0.8, 0.2], "labels" : ["False.", "True."]}
{"probabilities" : [0.75, 0.25], "labels" : ["True.", "False"]}
```
Les tableaux de probabilités et d'étiquettes sont toujours triés en fonction de leurs probabilités par ordre décroissant. Vous pouvez écrire une requête pour renvoyer uniquement l'étiquette prédite présentant la probabilité la plus élevée en désimbriquant les résultats renvoyés par SUPER par la fonction de probabilité.
```
SELECT prediction.labels[0], prediction.probabilities[0]
FROM (SELECT customer_churn_predict_probabilities(Account_length, Area_code,
VMail_message, Day_mins, Day_calls, Day_charge,Eve_mins, Eve_calls,
Eve_charge, Night_mins, Night_calls, Night_charge,Intl_mins, Intl_calls,
Intl_charge, Cust_serv_calls) AS prediction
FROM customer_activity);
labels | probabilities
-----------+--------------
"False." | 0.7
"False." | 0.8
"True." | 0.75
```
Pour simplifier les requêtes, vous pouvez stocker les résultats de la fonction de prédiction dans une table.
```
CREATE TABLE churn_auto_predict_probabilities AS
(SELECT customer_churn_predict_probabilities(Account_length, Area_code,
VMail_message, Day_mins, Day_calls, Day_charge,Eve_mins, Eve_calls,
Eve_charge, Night_mins, Night_calls, Night_charge,Intl_mins,
Intl_calls, Intl_charge, Cust_serv_calls) AS prediction
FROM customer_activity);
```
Vous pouvez interroger la table contenant les résultats pour renvoyer uniquement les prédictions dont la probabilité est supérieure à 0,7.
```
SELECT prediction.labels[0], prediction.probabilities[0]
FROM churn_auto_predict_probabilities
WHERE prediction.probabilities[0] > 0.7;
labels | probabilities
-----------+--------------
"False." | 0.8
"True." | 0.75
```
En utilisant la notation d'index, vous pouvez obtenir la probabilité d'une étiquette spécifique. L'exemple suivant renvoie les probabilités de toutes les étiquettes `True.`.
```
SELECT label, index, p.prediction.probabilities[index]
FROM churn_auto_predict_probabilities p, p.prediction.labels AS label AT index
WHERE label='True.';
label | index | probabilities
---------+-------+---------------
"True." | 0 | 0.3
"True." | 0 | 0.2
"True." | 0 | 0.75
```
L'exemple suivant renvoie toutes les lignes portant une étiquette `True` avec une probabilité supérieure à 0,7, ce qui indique que le client est susceptible de se désister.
```
SELECT prediction.labels[0], prediction.probabilities[0]
FROM churn_auto_predict_probabilities
WHERE prediction.probabilities[0] > 0.7 AND prediction.labels[0] = "True.";
labels | probabilities
-----------+--------------
"True." | 0.75
```
# 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)
# Intégrations d’Amazon Redshift ML à Amazon Bedrock
Cette section décrit comment utiliser l’intégration Amazon Redshift ML avec Amazon Bedrock. Grâce à cette fonctionnalité, vous pouvez invoquer un modèle Amazon Bedrock à l’aide de SQL, et vous pouvez utiliser vos données issues d’un entrepôt de données Amazon Redshift pour créer des applications d’IA génératives telles que la génération de texte, l’analyse des sentiments ou la traduction.
**Topics**
+ [Création ou mise à jour d’un rôle IAM pour l’intégration d’Amazon Redshift ML à Amazon Bedrock](#machine-learning-br-iam)
+ [Création d’un modèle externe pour l’intégration d’Amazon Redshift ML à Amazon Bedrock](#machine-learning-br-create)
+ [Utilisation d’un modèle externe pour l’intégration d’Amazon Redshift ML à Amazon Bedrock](#machine-learning-br-use)
+ [Ingénierie de requête pour l’intégration d’Amazon Redshift ML à Amazon Bedrock](#machine-learning-br-prompt)
## Création ou mise à jour d’un rôle IAM pour l’intégration d’Amazon Redshift ML à Amazon Bedrock
Cette section explique comment créer un rôle IAM à utiliser avec l’intégration d’Amazon Redshift ML à Amazon Bedrock.
Ajoutez la politique suivante au rôle IAM que vous utilisez dans le cadre de l’intégration d’Amazon Redshift ML à Amazon Bedrock :
+ `AmazonBedrockFullAccess`
Pour permettre à Amazon Redshift d’assumer un rôle afin d’interagir avec d’autres services, ajoutez la politique de confiance suivante au rôle IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"redshift.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Si le cluster ou l’espace de noms se trouve dans un VPC, suivez les instructions figurant dans [Cluster et configuration de la mise en place pour l'administration Amazon Redshift ML](getting-started-machine-learning.md#admin-setup).
Si vous avez besoin d’une politique plus restrictive, vous pouvez en créer une qui inclut uniquement les autorisations Amazon Bedrock spécifiées dans les pages suivantes :
+ [Cluster et configuration de la mise en place pour l'administration Amazon Redshift ML](getting-started-machine-learning.md#admin-setup)
+ [Autorisations requises pour utiliser le machine learning (ML) Amazon Redshift)](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-identity-based.html#iam-permission-ml?)
Pour plus d’informations sur la création d’un rôle IAM, consultez [Création de rôles IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create.html) dans le *Guide de l’utilisateur Gestion des identités et des accès AWS *.
## Création d’un modèle externe pour l’intégration d’Amazon Redshift ML à Amazon Bedrock
Cette section explique comment créer un modèle externe à utiliser comme interface pour Amazon Bedrock au sein de votre entrepôt de données Amazon Redshift.
Pour appeler un modèle Amazon Bedrock depuis Amazon Redshift, vous devez d’abord exécuter la commande `CREATE EXTERNAL MODEL`. Cette commande crée un objet modèle externe dans la base de données et une fonction utilisateur associée que vous utilisez pour générer du contenu textuel avec Amazon Bedrock.
L’exemple de code suivant montre une commande `CREATE EXTERNAL MODEL` de base :
```
CREATE EXTERNAL MODEL llm_claude
FUNCTION llm_claude_func
IAM_ROLE ''
MODEL_TYPE BEDROCK
SETTINGS (
MODEL_ID 'anthropic.claude-v2:1',
PROMPT 'Summarize the following text:');
```
La commande `CREATE EXTERNAL MODEL` dispose d’une interface unifiée et cohérente avec Amazon Bedrock for tous les modèles de fondation (FM) prenant en charge les messages. Il s’agit de l’option par défaut lorsque vous utilisez la commande `CREATE EXTERNAL MODEL` ou lorsque vous spécifiez explicitement le type de demande pour qu’elle soit `UNIFIED`. Pour plus d’informations, consultez la [Documentation de l’API Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html) dans la *Documentation de l’API Amazon Bedrock*.
Si un modèle de fondation ne prend pas en charge les messages, vous devez définir le paramètre `request_type` sur `RAW`, comme le montre l’exemple suivant. Lorsque vous définissez `request_type` sur `RAW`, vous devez créer la demande envoyée à Amazon Bedrock lorsque vous utilisez la fonction d’inférence en fonction du modèle de fondation sélectionné. Assurez-vous d’activer l’accès au modèle Titan Text G1 — Express dans Amazon Bedrock avant d’exécuter l’exemple suivant.
```
CREATE EXTERNAL MODEL titan_raw
FUNCTION func_titan_raw
IAM_ROLE ''
MODEL_TYPE BEDROCK
SETTINGS (
MODEL_ID 'amazon.titan-text-express-v1',
REQUEST_TYPE RAW,
RESPONSE_TYPE SUPER);
```
Si vous avez besoin de plus d’informations sur une demande d’entrée, telles que le nombre total de jetons, vous pouvez demander à ce que le `RESPONSE_TYPE` soit `super` lorsque vous créez le modèle.
```
CREATE EXTERNAL MODEL patient_recommendations_v2
FUNCTION patient_recommendations_func_v2
IAM_ROLE ''
MODEL_TYPE BEDROCK
SETTINGS (
MODEL_ID 'anthropic.claude-v2',
PROMPT 'Generate personalized diet plan for following patient:',
RESPONSE_TYPE SUPER);
```
Le paramètre `PROMPT` de la commande `CREATE EXTERNAL MODEL` est une invite statique. Si vous avez besoin d’une invite dynamique pour votre application, vous devez la spécifier lorsque vous utilisez la fonction d’inférence. Pour en savoir plus, consultez [Ingénierie de requête pour l’intégration d’Amazon Redshift ML à Amazon Bedrock](#machine-learning-br-prompt).
Pour plus d’informations sur l’instruction `CREATE EXTERNAL MODEL` et ses paramètres, consultez [CREATE EXTERNAL MODEL](r_create_external_model.md).
## Utilisation d’un modèle externe pour l’intégration d’Amazon Redshift ML à Amazon Bedrock
Cette section explique comment invoquer un modèle externe pour générer du texte en réponse aux invites fournies. Pour invoquer un modèle externe, utilisez la fonction d’inférence que vous créez avec `CREATE EXTERNAL MODEL`.
**Topics**
+ [Inférence avec des modèles de type de requête `UNIFIED`](#machine-learning-br-use-unified)
+ [Inférence avec des modèles de type de requête `RAW`](#machine-learning-br-use-raw)
+ [Fonctions d’inférence en tant que fonctions principale uniquement](#machine-learning-br-use-leader)
+ [Notes d’utilisation de la fonction d’inférence](#machine-learning-br-use-usage)
### Inférence avec des modèles de type de requête `UNIFIED`
La fonction d’inférence pour les modèles avec type de requête `UNIFIED` possède les trois paramètres suivants qui sont transmis à la fonction dans l’ordre :
+ **Texte de saisie** (obligatoire) : ce paramètre spécifie le texte d’entrée qu’Amazon Redshift transmet à Amazon Bedrock.
+ **Configuration d’inférence** et **Champs de requête de modèle supplémentaires** (facultatif) : Amazon Redshift transmet ces paramètres aux paramètres correspondants pour l’API du modèle Converse.
L’exemple de code suivant montre comment utiliser une fonction d’inférence de type `UNIFIED` :
```
SELECT llm_claude_func(input_text, object('temperature', 0.7, 'maxtokens', 500))
FROM some_data;
```
### Inférence avec des modèles de type de requête `RAW`
La fonction d’inférence pour les modèles avec type de demande `RAW` ne comporte qu’un seul paramètre de type de données `SUPER`. La syntaxe de ce paramètre dépend du modèle Amazon Bedrock utilisé.
L’exemple de code suivant montre comment utiliser une fonction d’inférence de type `RAW` :
```
SELECT llm_titan_func(
object(
"inputText", "Summarize the following text: " | input_text,
"textGenerationConfig", object("temperature", 0.5, "maxTokenCount", 500)
)
)
FROM some_data;
```
### Fonctions d’inférence en tant que fonctions principale uniquement
Les fonctions d’inférence pour les modèles Amazon Bedrock peuvent être exécutées en tant que fonctions du nœud principal uniquement lorsque la requête qui les utilise ne fait référence à aucune table. Cela peut être utile si vous souhaitez poser rapidement une question à un grand modèle de langage.
L’exemple de code suivant montre comment utiliser une fonction d’inférence principal uniquement :
```
SELECT general_titan_llm_func('Summarize the benefits of LLM on data analytics in 100 words');
```
### Notes d’utilisation de la fonction d’inférence
Notez les points suivants lorsque vous utilisez des fonctions d’inférence avec l’intégration d’Amazon Redshift ML à Amazon Bedrock :
+ Les noms des paramètres de tous les modèles Amazon Bedrock sont sensibles à la casse. Si vos paramètres ne correspondent pas à ceux requis par le modèle, Amazon Bedrock risque de les ignorer discrètement.
+ Le débit des requêtes d’inférence est limité par les quotas d’exécution des différents modèles proposés par Amazon Bedrock dans différentes régions. Pour de plus amples informations, consultez [Quotas pour Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/quotas.html) dans le *Guide de l’utilisateur Amazon Bedrock*.
+ Si vous avez besoin d’un débit garanti et constant, pensez à obtenir un débit alloué pour le modèle dont vous avez besoin auprès d’Amazon Bedrock. Pour plus d’informations, consultez la section [Augmenter la capacité d’invocation des modèles avec le débit alloué dans Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/prov-throughput.html) dans le *Guide de l’utilisateur Amazon Bedrock*.
+ Les requêtes d’inférence contenant de grandes quantités de données peuvent faire l’objet d’exceptions de limitation. Cela est dû aux quotas d’exécution limités pour Amazon Bedrock. Amazon Redshift réessaie plusieurs fois les requêtes, mais celles-ci peuvent toujours être limitées car le débit des modèles non alloués peut être variable.
+ Si vous rencontrez des exceptions de limitation provenant d’Amazon Bedrock, par exemple « `Too many requests, please wait before trying again.` », même avec de petites quantités de données, vérifiez les quotas dans la section **Service Quotas** de votre compte Amazon Bedrock. Vérifiez que le quota appliqué au niveau du compte est au moins identique à la valeur de quota AWS par défaut pour les **InvokeModel**demandes pour le modèle que vous utilisez.
## Ingénierie de requête pour l’intégration d’Amazon Redshift ML à Amazon Bedrock
Cette section explique comment utiliser les invites statiques avec un modèle externe.
Pour utiliser des préfixes statiques et des invites de préfixe pour votre modèle externe, fournissez-les à l’aide des paramètres `PROMPT` et `SUFFIX` de l’instruction `CREATE EXTERNAL MODEL`. Ces instructions sont ajoutées à chaque requête à l’aide du modèle externe.
L’exemple suivant montre comment ajouter des invites de préfixe et de suffixe à un modèle externe :
```
CREATE EXTERNAL MODEL llm_claude
FUNCTION llm_claude_func
IAM_ROLE ''
MODEL_TYPE BEDROCK
SETTINGS (
MODEL_ID 'anthropic.claude-v2:1',
PROMPT 'Summarize the following text:',
SUFFIX 'Respond in an analytic tone');
```
Pour utiliser des invites dynamiques, vous pouvez les fournir lorsque vous utilisez la fonction d’inférence en les concaténant dans l’entrée de la fonction. L’exemple suivant montre comment utiliser des invites dynamiques avec une fonction inférence :
```
SELECT llm_claude_func('Summarize the following review:' | input_text | 'The review should have formal tone.')
FROM some_data
```