Utilisation du machine learning Amazon Aurora avec Aurora MySQL

En utilisant le machine learning Amazon Aurora avec votre cluster de bases de données Aurora MySQL, vous pouvez utiliser Amazon Bedrock, Amazon Comprehend, ou Amazon SageMaker AI, selon vos besoins. Ils prennent chacun en charge différents cas d’utilisation de machine learning.

Exigences pour l’utilisation du machine learning Aurora avec Aurora MySQL

Les services de machine learning AWS sont des services gérés que vous configurez et exécutez dans leurs propres environnements de production. Le machine learning Aurora prend en charge l’intégration avec Amazon Bedrock, Amazon Comprehend et SageMaker AI. Avant d’essayer de configurer votre cluster de bases de données Aurora MySQL pour utiliser le machine learning Aurora, assurez-vous de comprendre les exigences et prérequis suivants.

Disponibilité des régions et des versions

La disponibilité et la prise en charge des fonctions varient selon les versions spécifiques de chaque moteur de base de données Aurora, et selon les Régions AWS.

Fonctions prises en charge et limitations du machine learning Aurora avec Aurora MySQL

Lorsque vous utilisez Aurora MySQL avec le machine learning Aurora, les limitations suivantes s’appliquent :

Configuration de votre cluster de bases de données Aurora MySQL de façon à utiliser le machine learning Aurora

Dans les rubriques suivantes, vous pouvez trouver des procédures de configuration distinctes pour chacun de ces services de machine learning Aurora.

Configuration de votre cluster de bases de données Aurora MySQL pour utiliser Amazon Bedrock

Le machine learning Aurora s’appuie sur des rôles et des politiques AWS Identity and Access Management (IAM) pour permettre à votre cluster de bases de données Aurora MySQL d’accéder aux services Amazon Bedrock et de les utiliser. Les procédures suivantes créent une stratégie d’autorisation et un rôle IAM afin que votre cluster de bases de données puisse s’intégrer à Amazon Bedrock.

Créez ensuite le rôle IAM qui utilise la stratégie d’autorisation d’Amazon Bedrock.

Associez ensuite le rôle IAM d’Amazon Bedrock à votre cluster de bases de données.

Vous devez ajouter l’ARN de ce rôle IAM au paramètre aws_default_bedrock_role dans le groupe de paramètres du cluster de bases de données associé au cluster Aurora MySQL. Si votre cluster de bases de données Aurora MySQL n’utilise pas de groupe de paramètres de cluster de bases de données personnalisé, vous devez en créer un à utiliser avec votre cluster de bases de données Aurora MySQL pour terminer l’intégration. Pour plus d’informations, consultez Groupes de paramètres de cluster de bases de données pour les clusters de bases de données Amazon Aurora.

L’intégration IAM pour Amazon Bedrock est terminée. Poursuivez la configuration de votre cluster de bases de données Aurora MySQL pour qu’il fonctionne avec Amazon Bedrock en Autorisation d’accès aux utilisateurs de base de données pour le machine learning Aurora.

Configuration de votre cluster de bases de données Aurora MySQL pour utiliser Amazon Comprehend

Le machine learning Aurora s’appuie sur des rôles et des stratégies AWS Identity and Access Management pour permettre à votre cluster de bases de données Aurora MySQL d’accéder aux services Amazon Comprehend et de les utiliser. La procédure suivante crée automatiquement un rôle et une stratégie IAM pour votre cluster afin qu’il puisse utiliser Amazon Comprehend.

L’intégration IAM pour Amazon Comprehend est terminée. Continuez à configurer votre cluster de bases de données Aurora MySQL pour qu’il fonctionne avec Amazon Comprehend en accordant l’accès aux utilisateurs de base de données appropriés.

Configuration de votre cluster de bases de données Aurora MySQL pour utiliser SageMaker AI

La procédure suivante crée automatiquement un rôle et une stratégie IAM pour votre cluster de bases de données Aurora MySQL afin qu’il puisse utiliser SageMaker AI. Avant d’essayer de suivre cette procédure, assurez-vous que le point de terminaison SageMaker AI est disponible afin de pouvoir le saisir si nécessaire. En général, les scientifiques des données de votre équipe se chargent de produire un point de terminaison que vous pouvez utiliser à partir de votre cluster de bases de données Aurora MySQL. Vous pouvez trouver ces points de terminaison dans la console SageMaker AI. Dans le panneau de navigation, ouvrez Inference (Inférence), puis choisissez Endpoints (Points de terminaison). Dans l’image suivante, vous pouvez voir un exemple.

La configuration IAM est maintenant terminée. Continuez à configurer votre cluster de bases de données Aurora MySQL pour qu’il fonctionne avec SageMaker AI en accordant l’accès aux utilisateurs de base de données appropriés.

Si vous souhaitez utiliser vos modèles SageMaker AI à des fins de formation plutôt que d’utiliser des composants SageMaker AI prédéfinis, vous devez également ajouter le compartiment Amazon S3 à votre cluster de bases de données Aurora MySQL, comme indiqué dans Configuration de votre cluster de bases de données Aurora MySQL pour utiliser Amazon S3 pour SageMaker AI (facultatif) ci-dessous.

Configuration de votre cluster de bases de données Aurora MySQL pour utiliser Amazon S3 pour SageMaker AI (facultatif)

Pour utiliser SageMaker AI avec vos propres modèles plutôt que d’utiliser les composants prédéfinis fournis par SageMaker AI, vous devez configurer un compartiment Amazon S3 destiné au cluster de bases de données Aurora MySQL. Pour plus d’informations sur la création d’un compartiment Amazon S3, consultez Créer un compartiment dans le Guide de l’utilisateur Amazon Simple Storage Service.

Pour plus d’informations sur l’utilisation de compartiments Amazon S3 avec SageMaker AI, consultez Spécifier un compartiment S3 pour télécharger des jeux de données d’entraînement et stocker des données de sortie dans le Guide du développeur Amazon SageMaker AI. Pour en savoir plus sur l’utilisation de SageMaker AI, consultez Démarrer avec les instances de bloc-notes Amazon SageMaker AI dans le Guide du développeur Amazon SageMaker AI.

Autorisation d’accès aux utilisateurs de base de données pour le machine learning Aurora

Les utilisateurs de la base de données doivent être autorisés à invoquer ces fonctions de machine learning Aurora. La manière dont vous accordez l’autorisation dépend de la version de MySQL que vous utilisez pour votre cluster de bases de données Aurora MySQL, comme indiqué ci-dessous. La manière de procéder dépend de la version de MySQL utilisée par votre cluster de bases de données Aurora MySQL.

Le tableau suivant indique les rôles et les privilèges dont les utilisateurs de base de données ont besoin pour utiliser les fonctions de machine learning.

Autorisation d’accès aux fonctions Amazon Bedrock

Pour permettre aux utilisateurs de base de données d’accéder aux fonctions d’Amazon Bedrock, utilisez l’instruction SQL suivante :

GRANT AWS_BEDROCK_ACCESS TO user@domain-or-ip-address;

Les utilisateurs de base de données doivent également disposer d’autorisations EXECUTE pour les fonctions que vous créez pour travailler avec Amazon Bedrock :

GRANT EXECUTE ON FUNCTION database_name.function_name TO user@domain-or-ip-address;

Enfin, les rôles des utilisateurs de base de données doivent être définis sur AWS_BEDROCK_ACCESS :

SET ROLE AWS_BEDROCK_ACCESS;

Les fonctions Amazon Bedrock peuvent désormais être utilisées.

Autorisation d’accès aux fonctions Amazon Comprehend

Pour permettre aux utilisateurs de la base de données d’accéder aux fonctions d’Amazon Comprehend, utilisez l’instruction appropriée à votre version d’Aurora MySQL.

Les fonctions Amazon Comprehend peuvent désormais être utilisées. Pour obtenir des exemples d’utilisation, consultez Utiliser Amazon Comprehend avec votre cluster de bases de données Aurora MySQL.

Autorisation d’accès aux fonctions SageMaker AI

Pour permettre aux utilisateurs de base de données d’accéder aux fonctions de SageMaker AI, utilisez l’instruction appropriée à votre version d’Aurora MySQL.

Les utilisateurs de base de données doivent également disposer d’autorisations EXECUTE pour les fonctions que vous créez pour travailler avec SageMaker AI. Supposons que vous ayez créé deux fonctions, db1.anomoly_score et db2.company_forecasts, pour invoquer les services de votre point de terminaison SageMaker AI. Vous accordez des privilèges d’exécution comme indiqué dans l’exemple ci-dessous.

GRANT EXECUTE ON FUNCTION db1.anomaly_score TO user1@domain-or-ip-address1;
GRANT EXECUTE ON FUNCTION db2.company_forecasts TO user2@domain-or-ip-address2;

Les fonctions de SageMaker AI peuvent désormais être utilisées. Pour obtenir des exemples d’utilisation, consultez Utilisation de SageMaker AI avec votre cluster de bases de données Aurora MySQL.

Utilisation d’Amazon Bedrock avec votre cluster de bases de données Aurora MySQL

Pour utiliser Amazon Bedrock, vous devez créer une fonction définie par l’utilisateur (UDF) dans votre base de données Aurora MySQL qui invoque un modèle. Pour plus d’informations, consultez Modèles pris en charge dans Amazon Bedrock dans le Guide de l’utilisateur Amazon Bedrock.

Un UDF utilise la syntaxe suivante :

CREATE FUNCTION function_name (argument type)
        [DEFINER = user]
    RETURNS mysql_data_type
    [SQL SECURITY {DEFINER | INVOKER}]
    ALIAS AWS_BEDROCK_INVOKE_MODEL
    MODEL ID 'model_id'
    [CONTENT_TYPE 'content_type']
    [ACCEPT 'content_type']
    [TIMEOUT_MS timeout_in_milliseconds];

Par exemple, l’UDF suivant invoque le modèle Amazon Titan Text Express :

CREATE FUNCTION invoke_titan (request_body TEXT)
    RETURNS TEXT
    ALIAS AWS_BEDROCK_INVOKE_MODEL
    MODEL ID 'amazon.titan-text-express-v1'
    CONTENT_TYPE 'application/json'
    ACCEPT 'application/json';

Pour autoriser un utilisateur de base de données à utiliser cette fonction, utilisez la commande SQL suivante :

GRANT EXECUTE ON FUNCTION database_name.invoke_titan TO user@domain-or-ip-address;

L’utilisateur peut ensuite appeler invoke_titan comme n’importe quelle autre fonction, comme illustré dans l’exemple suivant. Assurez-vous de formater le corps de la demande conformément aux modèles de texte Amazon Titan.

CREATE TABLE prompts (request varchar(1024));
INSERT INTO prompts VALUES (
'{
    "inputText": "Generate synthetic data for daily product sales in various categories - include row number, product name, category, date of sale and price. Produce output in JSON format. Count records and ensure there are no more than 5.",
    "textGenerationConfig": {
        "maxTokenCount": 1024,
        "stopSequences": [],
        "temperature":0,
        "topP":1
    }
}');

SELECT invoke_titan(request) FROM prompts;

{"inputTextTokenCount":44,"results":[{"tokenCount":296,"outputText":"
```tabular-data-json
{
    "rows": [
        {
            "Row Number": "1",
            "Product Name": "T-Shirt",
            "Category": "Clothing",
            "Date of Sale": "2024-01-01",
            "Price": "$20"
        },
        {
            "Row Number": "2",
            "Product Name": "Jeans",
            "Category": "Clothing",
            "Date of Sale": "2024-01-02",
            "Price": "$30"
        },
        {
            "Row Number": "3",
            "Product Name": "Hat",
            "Category": "Accessories",
            "Date of Sale": "2024-01-03",
            "Price": "$15"
        },
        {
            "Row Number": "4",
            "Product Name": "Watch",
            "Category": "Accessories",
            "Date of Sale": "2024-01-04",
            "Price": "$40"
        },
        {
            "Row Number": "5",
            "Product Name": "Phone Case",
            "Category": "Accessories",
            "Date of Sale": "2024-01-05",
            "Price": "$25"
        }
    ]
}
```","completionReason":"FINISH"}]}

Pour les autres modèles que vous utilisez, veillez à appliquer le format approprié. Pour plus d’informations, consultez Paramètres d’inférence pour les modèles de fondation dans le Guide de l’utilisateur Amazon Bedrock.

Utiliser Amazon Comprehend avec votre cluster de bases de données Aurora MySQL

Pour Aurora MySQL, le machine learning Aurora fournit les deux fonctions intégrées suivantes pour travailler avec Amazon Comprehend et vos données texte. Vous fournissez le texte à analyser (input_data) et vous spécifiez la langue (language_code).

Pour les deux fonctions (aws_comprehend_detect_sentiment_confidence, aws_comprehend_detect_sentiment), max_batch_size utilise une valeur par défaut de 25 si aucune valeur n’est spécifiée. La taille de lot doit toujours être supérieure à 0. Le paramètre max_batch_size vous permet d’ajuster les performances des appels de fonction Amazon Comprehend. Une taille de lot importante est l’assurance de performances plus rapides pour une meilleure utilisation de la mémoire sur le cluster de bases de données Aurora MySQL. Pour plus d’informations, consultez Considérations sur les performances du machine learning Aurora avec Aurora MySQL.

Pour obtenir des informations sur les paramètres et retourner des types pour les fonctions de détection des sentiments dans Amazon Comprehend, consultez DetectSentiment

SELECT feedback AS 'Customer feedback',
    aws_comprehend_detect_sentiment(feedback, 'en') AS Sentiment,
    ROUND(aws_comprehend_detect_sentiment_confidence(feedback, 'en'), 6)
    AS Confidence FROM support
    ORDER BY Confidence DESC;
+----------------------------------------------------------+-----------+------------+
| Customer feedback                                        | Sentiment | Confidence |
+----------------------------------------------------------+-----------+------------+
| Thank you for the excellent customer support!            | POSITIVE  |   0.999771 |
| The latest version of this product stinks!               | NEGATIVE  |   0.999184 |
| Your support team is just awesome! I am blown away.      | POSITIVE  |   0.997774 |
| Your product is too complex, but your support is great.  | MIXED     |   0.957958 |
| Your support tech helped me in fifteen minutes.          | POSITIVE  |   0.949491 |
| My problem was never resolved!                           | NEGATIVE  |   0.920644 |
| When will the new version of this product be released?   | NEUTRAL   |   0.902706 |
| I cannot stand that chatbot.                             | NEGATIVE  |   0.895219 |
| Your support tech talked down to me.                     | NEGATIVE  |   0.868598 |
| It took me way too long to get a real person.            | NEGATIVE  |   0.481805 |
+----------------------------------------------------------+-----------+------------+
 10 rows in set (0.1898 sec)

SELECT AVG(CASE aws_comprehend_detect_sentiment(productTable.document, 'en')
  WHEN 'POSITIVE' THEN 1.0
  WHEN 'NEGATIVE' THEN -1.0
  ELSE 0.0 END) AS avg_sentiment, COUNT(*) AS total
FROM productTable
WHERE productTable.productCode = 1302 AND
    aws_comprehend_detect_sentiment_confidence(productTable.document, 'en') >= 0.80;

Utilisation de SageMaker AI avec votre cluster de bases de données Aurora MySQL

Pour utiliser les fonctionnalités de SageMaker AI depuis votre cluster de bases de données Aurora MySQL, vous devez créer des fonctions stockées qui intègrent vos appels au point de terminaison SageMaker AI et à ses fonctions d’inférence. Pour ce faire, vous utilisez CREATE FUNCTION de MySQL de la même manière que vous le faites pour les autres tâches de traitement sur votre cluster de bases de données Aurora MySQL.

Pour utiliser des modèles déployés dans SageMaker AI pour l’inférence, vous créez des fonctions définies par l’utilisateur à l’aide d’instructions Langage de définition de données (DDL) MySQL pour les fonctions stockées. Chaque fonction stockée représente le point de terminaison SageMaker AI hébergeant le modèle. Lorsque vous définissez une telle fonction, vous spécifiez les paramètres d’entrée dans le modèle, le point de terminaison SageMaker AI spécifique à invoquer et le type de retour. La fonction retourne l’inférence calculée par le point de terminaison SageMaker AI après avoir appliqué le modèle aux paramètres d’entrée.

Toutes les fonctions stockées de machine learning Aurora retournent des types numériques ou VARCHAR. Vous pouvez utiliser tous les types numériques à l’exception de BIT. Les autres types, tels que JSON, BLOB, TEXT et DATE ne sont pas autorisés.

L’exemple suivant illustre la syntaxe CREATE FUNCTION utilisée pour travailler avec SageMaker AI.

CREATE FUNCTION function_name (
     arg1 type1, 
     arg2 type2, ...)
     [DEFINER = user]
  RETURNS mysql_type
  [SQL SECURITY { DEFINER | INVOKER } ]
  ALIAS AWS_SAGEMAKER_INVOKE_ENDPOINT
  ENDPOINT NAME 'endpoint_name'
  [MAX_BATCH_SIZE max_batch_size];

Il s’agit d’une extension de l’instruction DDL CREATE FUNCTION normale. Dans l’instruction CREATE FUNCTION qui définit la fonction SageMaker AI, vous ne spécifiez pas un corps de la fonction. Au lieu de cela, vous spécifiez le mot-clé ALIAS à la place du corps de la fonction. Actuellement, le machine learning Aurora prend uniquement en charge aws_sagemaker_invoke_endpoint pour cette syntaxe étendue. Vous devez spécifier le paramètre endpoint_name. Un point de terminaison SageMaker AI peut disposer de caractéristiques différentes pour chaque modèle.

Le paramètre max_batch_size est facultatif. Par défaut, la taille maximale du lot est de 10 000. Vous pouvez utiliser ce paramètre dans votre fonction pour limiter le nombre maximum d’entrées traitées dans une demande par lot adressée à SageMaker AI. Le paramètre max_batch_size permet d’éviter une erreur causée par des entrées trop larges ou d’éviter à SageMaker AI de retourner une réponse plus rapidement. Ce paramètre affecte la taille d’un tampon interne utilisé pour le traitement des demandes SageMaker AI. Une valeur trop importante pour max_batch_size peut entraîner une surcharge de mémoire substantielle sur votre instance de base de données.

Nous recommandons de laisser le paramètre MANIFEST sur sa valeur par défaut de OFF. Bien que vous puissiez utiliser l’option MANIFEST ON, certaines fonctionnalités SageMaker AI ne peuvent pas directement utiliser le CSV exporté avec cette option. Le format de manifeste n’est pas compatible avec le format de manifeste prévu par SageMaker AI.

Vous créez une fonction stockée séparée pour chacun de vos modèles SageMaker AI. Ce mappage de fonctions vers des modèles est obligatoire, car un point de terminaison est associé à un modèle spécifique, et chaque modèle accepte différents paramètres. L’utilisation de types SQL pour les entrées de modèle et le type de sortie de modèle permet d’éviter les erreurs de conversion de types lors du transfert des données entre les services AWS. Vous pouvez contrôler qui peut appliquer le modèle. Vous pouvez également contrôler les caractéristiques d’exécution en spécifiant un paramètre représentant la taille de lot maximum.

Actuellement, toutes les fonctions de machine learning Aurora disposent de la propriété NOT DETERMINISTIC. Si vous ne spécifiez pas cette propriété de manière explicite, Aurora définit automatiquement NOT DETERMINISTIC. Cela s’explique, car le modèle SageMaker AI peut être modifié sans aucune notification à la base de données. Dans ce cas, les appels à une fonction de machine learning Aurora peuvent retourner différents résultats pour la même entrée au sein d’une seule transaction.

Vous ne pouvez pas utiliser les caractéristiques CONTAINS SQL, NO SQL, READS SQL DATA ou MODIFIES SQL DATA dans votre instruction CREATE FUNCTION.

Voici un exemple d’appel d’un point de terminaison SageMaker AI pour détecter des anomalies. Il existe un point de terminaison SageMaker AI random-cut-forest-model. Le modèle correspondant est déjà entraîné par l’algorithme random-cut-forest. Pour chaque entrée, le modèle retourne un score d’anomalie. Cet exemple illustre les points de données dont le score dépasse de 3 déviations standard (environ le 99,9e centile) le score moyen.

CREATE FUNCTION anomaly_score(value real) returns real
  alias aws_sagemaker_invoke_endpoint endpoint name 'random-cut-forest-model-demo';

set @score_cutoff = (select avg(anomaly_score(value)) + 3 * std(anomaly_score(value)) from nyc_taxi);

select *, anomaly_detection(value) score from nyc_taxi
  where anomaly_detection(value) > @score_cutoff;

Exigences du jeu de caractères pour les fonctions SageMaker AI qui retournent des chaînes

Nous recommandons de spécifier un jeu de caractères de utf8mb4 comme type de retour pour vos fonctions SageMaker AI qui retournent des valeurs de chaîne. Si cela n’est pas pratique, utilisez une chaîne suffisamment longue pour que le type de retour conserve une valeur représentée dans le jeu de caractères utf8mb4. L’exemple suivant illustre comment déclarer le jeu de caractères utf8mb4 pour votre fonction.

CREATE FUNCTION my_ml_func(...) RETURNS VARCHAR(5) CHARSET utf8mb4 ALIAS ...

Actuellement, chaque fonction SageMaker AI qui retourne une chaîne utilise le jeu de caractères utf8mb4 pour la valeur de retour. La valeur de retour utilise ce jeu de caractères même si votre fonction SageMaker AI déclare de manière implicite ou explicite un jeu de caractères différent pour son type de retour. Si votre fonction SageMaker AI déclare un jeu de caractères différent pour la valeur de retour, les données retournées peuvent être tronquées en mode silencieux si vous les stockez dans une colonne de tableau pas assez longue. Par exemple, une requête avec une clause DISTINCT crée un tableau temporaire. Ainsi, le résultat de la fonction SageMaker AI peut être tronqué en raison de la gestion interne des chaînes lors d’une requête.

Exportation des données vers Amazon S3 pour l’entraînement des modèles SageMaker AI (avancé)

Nous vous recommandons de commencer à utiliser le machine learning Aurora et SageMaker AI avec certains des algorithmes fournis, et de demander aux scientifiques des données de votre équipe de vous fournir les points de terminaison SageMaker AI que vous pouvez utiliser avec votre code SQL. Vous trouverez ci-dessous des informations minimales sur l’utilisation de votre propre compartiment Amazon S3 avec vos propres modèles SageMaker AI et votre cluster de bases de données Aurora MySQL.

Le machine learning comprend deux étapes principales : la formation et l’inférence. Pour entraîner des modèles SageMaker AI, vous exportez des données vers un compartiment Amazon S3. Le compartiment Amazon S3 est utilisé par une instance de bloc-note Jupyter SageMaker AI, afin de former votre modèle avant de le déployer. Vous pouvez utiliser l’instruction SELECT INTO OUTFILE S3 pour interroger les données d’un cluster de bases de données Aurora MySQL et les enregistrer directement dans des fichiers texte stockés dans un compartiment Amazon S3. Ensuite, l’instance de bloc-bote consomme les données du compartiment Amazon S3 dans le cadre de la formation.

Le machine learning Aurora étend la syntaxe SELECT INTO OUTFILE existante dans Aurora MySQL pour exporter les données au format CSV. Le fichier CSV généré peut être directement consommé par des modèles ayant besoin de ce format dans le cadre de la formation.

SELECT * INTO OUTFILE S3 's3_uri' [FORMAT {CSV|TEXT} [HEADER]] FROM table_name;

L’extension prend en charge le format CSV standard.

La syntaxe étendue et la grammaire de SELECT INTO sont désormais comme suit :

INTO OUTFILE S3 's3_uri'
[CHARACTER SET charset_name]
[FORMAT {CSV|TEXT} [HEADER]]
[{FIELDS | COLUMNS}
  [TERMINATED BY 'string']
  [[OPTIONALLY] ENCLOSED BY 'char']
  [ESCAPED BY 'char']
]
[LINES
  [STARTING BY 'string']
  [TERMINATED BY 'string']
]

Considérations sur les performances du machine learning Aurora avec Aurora MySQL

Les services Amazon Bedrock, Amazon Comprehend et SageMaker AI effectuent la majeure partie du travail lorsqu’ils sont invoqués par une fonction de machine learning Aurora. Cela signifie que vous pouvez adapter ces ressources selon vos besoins, de manière indépendante. Pour votre cluster de bases de données Aurora MySQL, vous pouvez rendre vos appels de fonctions aussi efficaces que possible. Vous trouverez ci-dessous quelques considérations relatives aux performances à prendre en compte lors de l’utilisation du machine learning Aurora.

Modèle et invite

Les performances obtenues avec Amazon Bedrock varient considérablement selon le modèle et l’invite utilisés. Choisissez le modèle et l’invite qui conviennent le mieux à votre cas d’utilisation.

Cache de requête

Le cache de requête MySQL Aurora ne fonctionne pas pour les fonctions de machine learning Aurora. Aurora MySQL ne stocke pas de résultats de requête dans le cache de requête pour aucune instruction SQL appelant des fonctions de machine learning Aurora.

Optimisation par lots pour les appels de fonction de machine learning Aurora

L’élément principal des performances de machine learning Aurora que vous pouvez influencer depuis votre cluster Aurora est le paramètre du mode par lots pour les appels vers les fonctions stockées de machine learning Aurora. Les fonctions de machine learning occasionnant généralement une surcharge conséquente, l’appel d’un service externe séparément pour chaque ligne est impraticable. Le machine learning Aurora peut réduire cette surcharge en combinant dans un seul lot les appels au service de machine learning Aurora externe pour de nombreuses lignes. Le machine learning Aurora reçoit les réponses pour toutes les lignes d’entrée, puis transmet les réponses, ligne par ligne, à la requête en cours d’exécution. Cette optimisation améliore le débit et la latence de vos requêtes Aurora sans en modifier les résultats.

Lorsque vous créez une fonction stockée Aurora connectée à un point de terminaison SageMaker AI, vous définissez le paramètre de taille de lot. Ce paramètre influence le nombre de ligne transféré pour chaque appel sous-jacent vers SageMaker AI. Pour les requêtes qui traitent un grand nombre de lignes, le nombre de ressources permettant d’exécuter un appel SageMaker AI séparé pour chaque ligne peut être substantiel. Plus l’ensemble de données traité par la procédure stockée est important, plus grande sera la taille de lot.

Pour savoir si l’optimisation du mode par lots peut être appliquée à une fonction SageMaker AI, vérifiez le plan de requête produit par l’instruction EXPLAIN PLAN. Dans ce cas, la colonne extra du plan d’exécution inclut Batched machine learning. L’exemple suivant illustre un appel vers une fonction SageMaker AI qui utilise un mode par lots.

mysql> CREATE FUNCTION anomaly_score(val real) returns real alias aws_sagemaker_invoke_endpoint endpoint name 'my-rcf-model-20191126';
Query OK, 0 rows affected (0.01 sec)

mysql> explain select timestamp, value, anomaly_score(value) from nyc_taxi;
+----+-------------+----------+------------+------+---------------+------+---------+------+------+----------+--------------------------+
| id | select_type | table    | partitions | type | possible_keys | key  | key_len | ref  | rows | filtered | Extra                    |
+----+-------------+----------+------------+------+---------------+------+---------+------+------+----------+--------------------------+
|  1 | SIMPLE      | nyc_taxi | NULL       | ALL  | NULL          | NULL | NULL    | NULL |   48 |   100.00 | Batched machine learning |
+----+-------------+----------+------------+------+---------------+------+---------+------+------+----------+--------------------------+
1 row in set, 1 warning (0.01 sec)

Lorsque vous appelez l’une des fonctions Amazon Comprehend intégrées, vous pouvez contrôler le taille de lot en spécifiant le paramètre max_batch_size facultatif. Ce paramètre limite le nombre maximum de valeurs input_text traitées dans chaque lot. En envoyant plusieurs objets à la fois, cela réduit le nombre d’allers-retours entre Aurora et Amazon Comprehend. Limiter la taille de lot s’avère utile dans les situations impliquant une requête avec une clause LIMIT. En utilisant une petite valeur pour max_batch_size, vous pouvez éviter d’appeler Amazon Comprehend plus de fois que vous n’avez de textes d’entrée.

L’optimisation par lots pour l’évaluation des fonctions de machine learning Aurora s’applique dans les cas suivants :

Surveillance du machine learning Aurora

Vous pouvez surveiller les opérations par lots de machine learning Aurora en interrogeant plusieurs variables globales, comme indiqué dans l’exemple ci-dessous.

show status like 'Aurora_ml%';

Vous pouvez réinitialiser ces variables d’état en utilisant une instruction FLUSH STATUS. Ainsi, tous les chiffres représentent des totaux, des moyennes, etc. depuis la dernière réinitialisation de la variable.

Pour obtenir des informations sur la surveillance des performances des opérations SageMaker AI appelées depuis des fonctions de machine learning Aurora, consultez Surveillance Amazon SageMaker AI.