Utilisation de l'apprentissage automatique d'Amazon Aurora avec Aurora My SQL

En utilisant l'apprentissage automatique Amazon Aurora avec votre cluster Aurora My SQL DB, vous pouvez utiliser Amazon Bedrock, Amazon Comprehend ou SageMaker Amazon AI, selon vos besoins. Ils prennent chacun en charge différents cas d'utilisation de l'apprentissage automatique.

Conditions requises pour utiliser l'apprentissage automatique Aurora avec Aurora My SQL

AWS les services d'apprentissage automatique sont des services gérés qui sont configurés et exécutés dans leurs propres environnements de production. L'apprentissage automatique Aurora prend en charge l'intégration avec Amazon Bedrock, Amazon Comprehend et AI. SageMaker Avant d'essayer de configurer votre cluster Aurora My SQL DB pour utiliser l'apprentissage automatique Aurora, assurez-vous de bien comprendre les exigences et les 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.

Fonctionnalités prises en charge et limites de l'apprentissage automatique Aurora avec Aurora My SQL

Lorsque vous utilisez Aurora My SQL avec l'apprentissage automatique Aurora, les limites suivantes s'appliquent :

Configuration de votre cluster Aurora My SQL DB pour utiliser l'apprentissage automatique 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 Aurora My SQL DB pour utiliser Amazon Bedrock

L'apprentissage automatique Aurora repose sur AWS Identity and Access Management (IAM) des rôles et des politiques pour permettre à votre cluster Aurora My SQL DB d'accéder aux services Amazon Bedrock et de les utiliser. Les procédures suivantes créent une politique d'IAMautorisation et un rôle afin que votre cluster de base de données puisse s'intégrer à Amazon Bedrock.

Ensuite, vous créez le IAM rôle qui utilise la politique d'autorisation d'Amazon Bedrock.

Ensuite, vous associez le IAM rôle Amazon Bedrock à votre cluster de base de données.

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

L'IAMintégration pour Amazon Bedrock est terminée. Continuez à configurer votre cluster Aurora My SQL DB pour qu'il fonctionne avec Amazon Bedrock enAutorisation d'accès aux utilisateurs de base de données pour le machine learning Aurora.

Configuration de votre cluster Aurora My SQL DB pour utiliser Amazon Comprehend

L'apprentissage automatique Aurora repose sur AWS Identity and Access Management des rôles et des politiques pour permettre à votre cluster Aurora My SQL DB d'accéder aux services Amazon Comprehend et de les utiliser. La procédure suivante crée automatiquement un IAM rôle et une politique pour votre cluster afin qu'il puisse utiliser Amazon Comprehend.

L'IAMintégration pour Amazon Comprehend est terminée. Poursuivez la configuration de votre cluster Aurora My SQL DB 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 Aurora My SQL DB pour utiliser l' SageMaker IA

La procédure suivante crée automatiquement le IAM rôle et la politique de votre cluster Aurora My SQL DB afin qu'il puisse utiliser l' SageMaker IA. Avant d'essayer de suivre cette procédure, assurez-vous que le point de terminaison SageMaker AI est disponible afin de pouvoir le saisir en cas de besoin. Généralement, les data scientists de votre équipe se chargent de produire un point de terminaison que vous pouvez utiliser à partir de votre cluster Aurora My SQL DB. Vous pouvez trouver de tels points de terminaison dans la console SageMaker AI. Dans le volet de navigation, ouvrez Inference (Inférence), puis choisissez Endpoints (Points de terminaison). Dans l'image suivante, vous pouvez voir un exemple.

La IAM configuration est maintenant terminée. Poursuivez la configuration de votre cluster Aurora My SQL DB pour qu'il fonctionne avec l' SageMaker IA en accordant l'accès aux utilisateurs de base de données appropriés.

Si vous souhaitez utiliser vos modèles d' SageMaker IA pour la formation plutôt que d'utiliser des composants d' SageMaker IA prédéfinis, vous devez également ajouter le compartiment Amazon S3 à votre cluster Aurora My SQL DB, comme Configuration de votre cluster Aurora My SQL DB pour utiliser Amazon S3 for SageMaker AI (facultatif) indiqué ci-dessous.

Configuration de votre cluster Aurora My SQL DB pour utiliser Amazon S3 for SageMaker AI (facultatif)

Pour utiliser l' SageMaker IA avec vos propres modèles plutôt que d'utiliser les composants prédéfinis fournis par l' SageMaker IA, vous devez configurer un compartiment Amazon S3 pour le cluster Aurora My SQL DB à utiliser. Pour plus d'informations sur la création d'un compartiment Amazon S3, veuillez consulter Créer un compartiment dans le Guide de l'utilisateur Amazon Simple Storage Service.

Pour plus d'informations sur l'utilisation des compartiments Amazon S3 avec l' SageMaker IA, consultez Spécifier un compartiment Amazon S3 pour télécharger des ensembles de données de formation et stocker les données de sortie dans le manuel Amazon SageMaker AI Developer Guide. Pour en savoir plus sur l'utilisation de l' SageMaker IA, consultez Get Started with Amazon SageMaker AI Notebook Instances dans le manuel 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 les fonctions d'apprentissage automatique d'Aurora. La manière dont vous accordez l'autorisation dépend de la version de My SQL que vous utilisez pour votre cluster Aurora My SQL DB, comme indiqué ci-dessous. La manière de procéder dépend de la version de My SQL utilisée par votre cluster Aurora My SQL DB.

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 d'apprentissage automatique.

Octroi de l'accès aux fonctions d'Amazon Bedrock

Pour permettre aux utilisateurs de la base de données d'accéder aux fonctions d'Amazon Bedrock, utilisez l'SQLinstruction suivante :

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

Les utilisateurs de la base de données doivent également EXECUTE être autorisés à accéder aux 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 de manière à AWS_BEDROCK_ACCESS :

SET ROLE AWS_BEDROCK_ACCESS;

Les fonctions Amazon Bedrock sont désormais disponibles.

Autorisation d'accès aux fonctions Amazon Comprehend

Pour permettre aux utilisateurs de la base de données d'accéder aux fonctions 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 Utilisation d'Amazon Comprehend avec votre cluster Aurora My DB SQL.

Octroi de l'accès aux fonctions de SageMaker l'IA

Pour permettre aux utilisateurs de la base de données d'accéder aux fonctions d' SageMaker intelligence artificielle, utilisez l'instruction appropriée à votre SQL version d'Aurora My.

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

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 l' SageMaker IA peuvent désormais être utilisées. Pour obtenir des exemples d'utilisation, consultez Utilisation de l' SageMaker IA avec votre cluster Aurora My SQL DB.

Utilisation d'Amazon Bedrock avec votre cluster Aurora My SQL DB

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

A 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, ce qui suit UDF 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 SQL commande suivante :

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

L'utilisateur peut alors appeler invoke_titan comme n'importe quelle autre fonction, comme indiqué 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 à mettre en forme le corps de la demande de manière appropriée. Pour plus d'informations, consultez la section Paramètres d'inférence pour les modèles de base dans le guide de l'utilisateur d'Amazon Bedrock.

Utilisation d'Amazon Comprehend avec votre cluster Aurora My DB SQL

Pour Aurora MySQL, l'apprentissage automatique 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 permet d'obtenir des performances plus rapides pour une utilisation plus importante de la mémoire sur le cluster Aurora My SQL DB. Pour de plus amples informations, veuillez consulter Considérations relatives aux performances liées à l'utilisation de l'apprentissage automatique Aurora avec Aurora My SQL.

Pour plus d'informations sur les paramètres et les types de retours 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 l' SageMaker IA avec votre cluster Aurora My SQL DB

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

Pour utiliser des modèles déployés dans l' SageMaker IA à des fins d'inférence, vous devez créer des fonctions définies par l'utilisateur à l'aide des instructions My SQL data definition language (DDL) 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 du modèle, le point de terminaison SageMaker AI spécifique à invoquer et le type de retour. La fonction renvoie l'inférence calculée par le point de terminaison de l' SageMaker IA 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 montre la CREATE FUNCTION syntaxe permettant de travailler avec l' SageMaker IA.

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 la CREATE FUNCTION DDL déclaration régulière. Dans l'CREATE FUNCTIONinstruction qui définit la fonction SageMaker AI, vous ne spécifiez pas de corps de 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 d' SageMaker IA peut avoir des 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 groupée adressée à l' SageMaker IA. Le max_batch_size paramètre peut aider à éviter une erreur causée par des entrées trop importantes ou à faire en sorte que l' SageMaker IA renvoie une réponse plus rapidement. Ce paramètre affecte la taille d'une mémoire tampon interne utilisée pour le traitement des demandes d' SageMaker IA. 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 MANIFEST ON cette option, certaines fonctionnalités de l' SageMaker IA ne peuvent pas utiliser directement les fonctionnalités CSV exportées avec cette option. Le format du manifeste n'est pas compatible avec le format du manifeste attendu par SageMaker AI.

Vous créez une fonction stockée distincte pour chacun de vos modèles d' SageMaker IA. 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 SQL de types pour les entrées du modèle et le type de sortie du modèle permet d'éviter les erreurs de conversion de type lors du transfert de données entre les AWS services. 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. Cette exigence est due au fait que le modèle d' SageMaker IA 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'utilisation de l'appel d'un point de terminaison d' SageMaker IA pour détecter des anomalies. Il existe un point de terminaison SageMaker basé sur l'IArandom-cut-forest-model. Le modèle correspondant est déjà formé 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;

Jeu de caractères requis pour les fonctions d' SageMaker IA renvoyant des chaînes

Nous vous recommandons de spécifier un jeu de caractères utf8mb4 comme type de retour pour vos fonctions d' SageMaker IA qui renvoient 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 renvoie 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 implicitement ou explicitement 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 renvoyées peuvent être tronquées silencieusement si vous les stockez dans une colonne de table trop courte. 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 façon dont les chaînes sont traitées en interne lors d'une requête.

Exportation de données vers Amazon S3 pour la formation de modèles d' SageMaker IA (niveau avancé)

Nous vous recommandons de vous familiariser avec l'apprentissage automatique et l' SageMaker IA Aurora en utilisant certains des algorithmes fournis, et de demander aux data scientists de votre équipe de vous fournir les points de terminaison d' SageMaker IA que vous pouvez utiliser avec votre SQL code. Vous trouverez ci-dessous des informations minimales sur l'utilisation de votre propre compartiment Amazon S3 avec vos propres modèles d' SageMaker IA et votre cluster Aurora My SQL DB.

Le machine learning comprend deux étapes principales : la formation et l'inférence. Pour entraîner des modèles d' SageMaker IA, vous exportez des données vers un compartiment Amazon S3. Le compartiment Amazon S3 est utilisé par une instance de bloc-notes Jupyter SageMaker AI pour entraîner votre modèle avant son déploiement. Vous pouvez utiliser SELECT INTO OUTFILE S3 cette instruction pour interroger les données d'un cluster Aurora My SQL DB 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.

L'apprentissage automatique Aurora étend la SELECT INTO OUTFILE syntaxe existante dans Aurora My SQL pour exporter les données au CSV format. Le CSV fichier généré peut être directement utilisé par les modèles qui ont besoin de ce format à des fins de formation.

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

L'extension prend en charge le CSV format 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 relatives aux performances liées à l'utilisation de l'apprentissage automatique Aurora avec Aurora My SQL

Les services Amazon Bedrock, Amazon Comprehend SageMaker et AI effectuent l'essentiel du travail lorsqu'ils sont invoqués par une fonction d'apprentissage automatique Aurora. Cela signifie que vous pouvez adapter ces ressources selon vos besoins, de manière indépendante. Pour votre cluster Aurora My SQL DB, vous pouvez rendre vos appels de fonction 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 lors de l'utilisation d'Amazon Bedrock dépendent fortement du modèle et de l'invite que vous utilisez. Choisissez un modèle et une invite adaptés à votre cas d'utilisation.

Cache de requête

Le cache de SQL requêtes Aurora My ne fonctionne pas pour les fonctions d'apprentissage automatique d'Aurora. Aurora My SQL ne stocke pas les résultats des requêtes dans le cache des requêtes pour les SQL instructions qui appellent les fonctions d'apprentissage automatique d'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 du lot. Ce paramètre influence le nombre de lignes transférées pour chaque appel sous-jacent à l' SageMaker IA. Pour les requêtes qui traitent un grand nombre de lignes, la charge nécessaire pour effectuer un appel d' SageMaker IA distinct pour chaque ligne peut être importante. Plus l'ensemble de données traité par la procédure stockée est important, plus grande sera la taille de lot.

Si l'optimisation du mode batch peut être appliquée à une fonction d' SageMaker IA, vous pouvez le savoir en vérifiant le plan de requête produit par l'EXPLAIN PLANinstruction. Dans ce cas, la colonne extra du plan d'exécution inclut Batched machine learning. L'exemple suivant montre un appel à une fonction d' SageMaker IA qui utilise le mode batch.

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 d'apprentissage automatique Aurora en interrogeant plusieurs variables globales, comme illustré dans l'exemple suivant.

show status like 'Aurora_ml%';

Vous pouvez réinitialiser ces variables de statut 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 plus d'informations sur la surveillance des performances des opérations d' SageMaker IA appelées par les fonctions d'apprentissage automatique Aurora, consultez la section Surveiller Amazon SageMaker AI.