Verwenden von Amazon Aurora Machine Learning mit Aurora My SQL

Wenn Sie Amazon Aurora Machine Learning mit Ihrem Aurora My SQL DB-Cluster verwenden, können Sie je nach Bedarf Amazon Bedrock, Amazon Comprehend oder Amazon SageMaker AI verwenden. Sie unterstützen jeweils unterschiedliche Anwendungsfälle für maschinelles Lernen.

Voraussetzungen für die Verwendung von Aurora Machine Learning mit Aurora My SQL

AWS Dienste für maschinelles Lernen sind verwaltete Dienste, die in ihren eigenen Produktionsumgebungen eingerichtet und ausgeführt werden. Aurora Machine Learning unterstützt die Integration mit Amazon Bedrock, Amazon Comprehend und KI. SageMaker Bevor Sie versuchen, Ihren Aurora My SQL DB-Cluster für die Nutzung von Aurora Machine Learning einzurichten, stellen Sie sicher, dass Sie die folgenden Anforderungen und Voraussetzungen verstehen.

Verfügbarkeit von Regionen und Versionen

Die Verfügbarkeit von Funktionen und der Support variieren zwischen bestimmten Versionen der einzelnen Aurora-Datenbank-Engines und in allen AWS-Regionen.

Unterstützte Funktionen und Einschränkungen von Aurora Machine Learning mit Aurora My SQL

Bei der Verwendung von Aurora My SQL mit Aurora Machine Learning gelten die folgenden Einschränkungen:

Einrichtung Ihres Aurora My SQL DB-Clusters für die Nutzung von Aurora Machine Learning

In den folgenden Themen finden Sie separate Einrichtungsverfahren für jeden dieser Aurora-Dienste für Machine Learning.

Einrichtung Ihres Aurora My SQL DB-Clusters für die Verwendung von Amazon Bedrock

Aurora Machine Learning stützt sich auf AWS Identity and Access Management (IAM) Rollen und Richtlinien, damit Ihr Aurora My SQL DB-Cluster auf die Amazon Bedrock-Services zugreifen und diese nutzen kann. Mit den folgenden Verfahren werden eine IAM Berechtigungsrichtlinie und eine Rolle erstellt, sodass Ihr DB-Cluster in Amazon Bedrock integriert werden kann.

Als Nächstes erstellen Sie die IAM Rolle, die die Amazon Bedrock-Berechtigungsrichtlinie verwendet.

Als Nächstes verknüpfen Sie die Amazon IAM Bedrock-Rolle mit Ihrem DB-Cluster.

Sie müssen diese IAM Rolle dem Parameter ARN der benutzerdefinierten aws_default_bedrock_role DB-Cluster-Parametergruppe hinzufügen, die mit Ihrem Aurora My SQL DB-Cluster verknüpft ist. Wenn Ihr Aurora My SQL DB-Cluster keine benutzerdefinierte DB-Cluster-Parametergruppe verwendet, müssen Sie eine für Ihren Aurora My SQL DB-Cluster erstellen, um die Integration abzuschließen. Weitere Informationen finden Sie unter DB-Cluster-Parametergruppen für Amazon Aurora Aurora-DB-Cluster.

Die IAM Integration für Amazon Bedrock ist abgeschlossen. Fahren Sie mit der Einrichtung Ihres Aurora My SQL DB-Clusters für die Zusammenarbeit mit Amazon Bedrock by Erteilen des Zugriffs auf Aurora Machine Learning für Datenbankbenutzer fort.

Einrichtung Ihres Aurora My SQL DB-Clusters für die Verwendung von Amazon Comprehend

Aurora Machine Learning stützt sich auf AWS Identity and Access Management Rollen und Richtlinien, damit Ihr Aurora My SQL DB-Cluster auf die Amazon Comprehend-Services zugreifen und diese nutzen kann. Das folgende Verfahren erstellt automatisch eine IAM Rolle und Richtlinie für Ihren Cluster, sodass dieser Amazon Comprehend verwenden kann.

Die IAM Integration für Amazon Comprehend ist abgeschlossen. Setzen Sie die Einrichtung Ihres Aurora My SQL DB-Clusters für die Zusammenarbeit mit Amazon Comprehend fort, indem Sie den entsprechenden Datenbankbenutzern Zugriff gewähren.

Einrichtung Ihres Aurora My SQL DB-Clusters für die Verwendung von SageMaker KI

Das folgende Verfahren erstellt automatisch die IAM Rolle und die Richtlinie für Ihren Aurora My SQL DB-Cluster, sodass dieser SageMaker KI verwenden kann. Bevor Sie versuchen, dieses Verfahren zu befolgen, stellen Sie sicher, dass Sie den SageMaker KI-Endpunkt verfügbar haben, damit Sie ihn bei Bedarf eingeben können. In der Regel erledigen Datenwissenschaftler in Ihrem Team die Arbeit, um einen Endpunkt zu erstellen, den Sie von Ihrem Aurora My SQL DB-Cluster aus verwenden können. Sie finden solche Endpunkte in der SageMaker AI-Konsole. Öffnen Sie im Navigationsbereich das Menü Inference (Inferenz) und wählen Sie Endpoints (Endpunkte) aus. Die folgende Abbildung zeigt ein Beispiel.

Die IAM Einrichtung ist jetzt abgeschlossen. Setzen Sie die Einrichtung Ihres Aurora My SQL DB-Clusters für die Zusammenarbeit mit SageMaker KI fort, indem Sie den entsprechenden Datenbankbenutzern Zugriff gewähren.

Wenn Sie Ihre SageMaker KI-Modelle für Schulungen verwenden möchten, anstatt vorgefertigte SageMaker KI-Komponenten zu verwenden, müssen Sie auch den Amazon S3 S3-Bucket zu Ihrem Aurora My SQL DB-Cluster hinzufügen, wie im Einrichtung Ihres Aurora My SQL DB-Clusters für die Verwendung von Amazon S3 for SageMaker AI (optional) Folgenden beschrieben.

Einrichtung Ihres Aurora My SQL DB-Clusters für die Verwendung von Amazon S3 for SageMaker AI (optional)

Um SageMaker KI mit Ihren eigenen Modellen zu verwenden, anstatt die von SageMaker AI bereitgestellten vorgefertigten Komponenten zu verwenden, müssen Sie einen Amazon S3 S3-Bucket einrichten, den der Aurora My SQL DB-Cluster verwenden kann. Weitere Informationen zum Erstellen eines Amazon-S3-Buckets finden Sie unter Erstellen von Buckets im Handbuch für Amazon Simple Storage Service.

Weitere Informationen zur Verwendung von Amazon S3 S3-Buckets mit SageMaker KI finden Sie unter Spezifizieren eines Amazon S3 S3-Buckets zum Hochladen von Trainingsdatensätzen und Speichern von Ausgabedaten im Amazon SageMaker AI Developer Guide. Weitere Informationen zur Arbeit mit SageMaker KI finden Sie unter Erste Schritte mit Amazon SageMaker AI Notebook Instances im Amazon SageMaker AI Developer Guide.

Erteilen des Zugriffs auf Aurora Machine Learning für Datenbankbenutzer

Datenbankbenutzern muss die Erlaubnis erteilt werden, Aurora-Funktionen für maschinelles Lernen aufzurufen. Wie Sie die Genehmigung erteilen, hängt von der Version von My abSQL, die Sie für Ihren Aurora My SQL DB-Cluster verwenden, wie im Folgenden beschrieben. Wie Sie das tun, hängt von der Version von My abSQL, die Ihr Aurora My SQL DB-Cluster verwendet.

Die folgende Tabelle zeigt die Rollen und Rechte, die Datenbankbenutzer benötigen, um mit Funktionen für maschinelles Lernen zu arbeiten.

Zugriff auf Amazon Bedrock-Funktionen gewähren

Verwenden Sie die folgende SQL Anweisung, um Datenbankbenutzern Zugriff auf Amazon Bedrock-Funktionen zu gewähren:

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

Datenbankbenutzern müssen auch EXECUTE Berechtigungen für die Funktionen erteilt werden, die Sie für die Arbeit mit Amazon Bedrock erstellen:

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

Schließlich müssen die Rollen der Datenbankbenutzer wie folgt festgelegt seinAWS_BEDROCK_ACCESS:

SET ROLE AWS_BEDROCK_ACCESS;

Die Funktionen von Amazon Bedrock können jetzt verwendet werden.

Erteilen des Zugriffs auf Amazon-Comprehend-Funktionen

Um Datenbankbenutzern Zugriff auf die Funktionen von Amazon Comprehend zu gewähren, verwenden Sie die entsprechende Anweisung für Ihre Aurora SQL My-Version.

Die Amazon-Comprehend-Funktionen sind jetzt verfügbar. Anwendungsbeispiele finden Sie unter Verwenden von Amazon Comprehend mit Ihrem Aurora My SQL DB-Cluster.

Zugriff auf SageMaker KI-Funktionen gewähren

Um Datenbankbenutzern Zugriff auf SageMaker KI-Funktionen zu gewähren, verwenden Sie die entsprechende Anweisung für Ihre Aurora SQL My-Version.

Datenbankbenutzern müssen außerdem EXECUTE Berechtigungen für die Funktionen erteilt werden, die Sie für die Arbeit mit SageMaker KI erstellen. Angenommen, Sie haben zwei Funktionen erstellt, db1.anomoly_score unddb2.company_forecasts, um die Dienste Ihres SageMaker KI-Endpunkts aufzurufen. Sie gewähren Ausführungsrechte, wie im folgenden Beispiel gezeigt.

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;

Die SageMaker KI-Funktionen können jetzt verwendet werden. Anwendungsbeispiele finden Sie unter SageMaker KI mit Ihrem Aurora My SQL DB-Cluster verwenden.

Amazon Bedrock mit Ihrem Aurora My SQL DB-Cluster verwenden

Um Amazon Bedrock zu verwenden, erstellen Sie eine benutzerdefinierte Funktion (UDF) in Ihrer Aurora SQL My-Datenbank, die ein Modell aufruft. Weitere Informationen finden Sie unter Unterstützte Modelle in Amazon Bedrock im Amazon Bedrock-Benutzerhandbuch.

A UDF verwendet die folgende Syntax:

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

Im Folgenden wird beispielsweise das Amazon Titan Text Express-Modell UDF aufgerufen:

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

Verwenden Sie den folgenden SQL Befehl, um einem DB-Benutzer die Verwendung dieser Funktion zu ermöglichen:

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

Dann kann der Benutzer invoke_titan wie jede andere Funktion aufrufen, wie im folgenden Beispiel gezeigt. Achten Sie darauf, den Text der Anfrage gemäß den Textmodellen von Amazon Titan zu formatieren.

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"}]}

Achten Sie bei anderen Modellen, die Sie verwenden, darauf, den Anfragetext entsprechend zu formatieren. Weitere Informationen finden Sie unter Inferenzparameter für Fundamentmodelle im Amazon Bedrock-Benutzerhandbuch.

Verwenden von Amazon Comprehend mit Ihrem Aurora My SQL DB-Cluster

Für Aurora My SQL bietet Aurora Machine Learning die folgenden beiden integrierten Funktionen für die Arbeit mit Amazon Comprehend und Ihren Textdaten. Sie geben den zu analysierenden Text (input_data) und die Sprache (language_code) an.

In beiden Funktionen (aws_comprehend_detect_sentiment_confidence, aws_comprehend_detect_sentiment) verwendet max_batch_size den Standardwert 25, wenn kein Wert angegeben ist. Die Batch-Größe sollte immer größer als 0 sein. Sie können max_batch_size zur Optimierung der Leistung der Amazon-Comprehend-Funktionsaufrufe verwenden. Bei einer großen Batchgröße wird eine schnellere Leistung gegen eine höhere Speicherauslastung auf dem Aurora My SQL DB-Cluster eingetauscht. Weitere Informationen finden Sie unter Überlegungen zur Leistung bei der Verwendung von Aurora Machine Learning mit Aurora My SQL.

Weitere Informationen zu Parametern und Rückgabetypen für die Stimmungserkennungsfunktionen in Amazon Comprehend finden Sie unter 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;

SageMaker KI mit Ihrem Aurora My SQL DB-Cluster verwenden

Um SageMaker KI-Funktionen von Ihrem Aurora My SQL DB-Cluster aus nutzen zu können, müssen Sie gespeicherte Funktionen erstellen, die Ihre Aufrufe in den SageMaker KI-Endpunkt und seine Inferenzfunktionen einbetten. Sie tun dies, indem Sie SQL My's CREATE FUNCTION im Allgemeinen auf die gleiche Weise verwenden, wie Sie es für andere Verarbeitungsaufgaben in Ihrem Aurora My SQL DB-Cluster tun.

Um in SageMaker KI bereitgestellte Modelle für Inferenz zu verwenden, erstellen Sie benutzerdefinierte Funktionen mithilfe von My SQL Data Definition Language (DDL) -Anweisungen für gespeicherte Funktionen. Jede gespeicherte Funktion stellt den SageMaker KI-Endpunkt dar, der das Modell hostet. Wenn Sie eine solche Funktion definieren, geben Sie die Eingabeparameter für das Modell, den spezifischen SageMaker AI-Endpunkt, der aufgerufen werden soll, und den Rückgabetyp an. Die Funktion gibt die vom SageMaker KI-Endpunkt berechnete Inferenz zurück, nachdem das Modell auf die Eingabeparameter angewendet wurde.

Alle gespeicherten Aurora Machine Learning-Funktionen geben numerische Typen oder zurüc VARCHAR. Sie können alle numerischen Typen außer verwende BIT. Andere Typen wie etwa JSON, BLOB, TEXT oder DATE sind nicht zulässig.

Das folgende Beispiel zeigt die CREATE FUNCTION Syntax für die Arbeit mit SageMaker KI.

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

Dies ist eine Erweiterung der regulären CREATE FUNCTION DDL Anweisung. In der CREATE FUNCTION Anweisung, die die SageMaker AI-Funktion definiert, geben Sie keinen Funktionskörper an. Stattdessen geben Sie das Schlüsselwort ALIAS dort an, wo normalerweise der Funktionstext steht. Derzeit unterstützt Aurora Machine Learning nur aws_sagemaker_invoke_endpoint für diese erweiterte Syntax. Sie müssen den Parameter endpoint_name angeben. Ein SageMaker KI-Endpunkt kann für jedes Modell unterschiedliche Eigenschaften aufweisen.

Der Parameter max_batch_size ist optional. Standardmäßig beträgt die maximale Stapelgröße 10 000. Sie können diesen Parameter in Ihrer Funktion verwenden, um die maximale Anzahl von Eingaben zu beschränken, die in einer Batch-Anfrage an SageMaker KI verarbeitet werden. Der max_batch_size Parameter kann dazu beitragen, Fehler zu vermeiden, die durch zu große Eingaben verursacht werden, oder SageMaker KI dazu zu bringen, schneller eine Antwort zurückzugeben. Dieser Parameter wirkt sich auf die Größe eines internen Puffers aus, der für die Verarbeitung von SageMaker KI-Anfragen verwendet wird. Die Angabe eines zu großen Werts für max_batch_size kann zu erheblicher Speicherüberlastung auf Ihrer DB-Instance führen.

Wir empfehlen Ihnen, für die Einstellung MANIFEST den Standardwert OFF zu belassen. Sie können die MANIFEST ON Option zwar verwenden, aber einige SageMaker KI-Funktionen können den mit dieser Option CSV exportierten Inhalt nicht direkt verwenden. Das Manifestformat ist nicht mit dem erwarteten Manifestformat von SageMaker AI kompatibel.

Sie erstellen für jedes Ihrer SageMaker KI-Modelle eine separate gespeicherte Funktion. Dieses Mapping von Funktionen zu Modellen ist erforderlich, da ein Endpunkt mit einem spezifischen Modell verbunden ist und jedes Modell unterschiedliche Parameter akzeptiert. Die Verwendung SQL von Typen für die Modelleingaben und den Modellausgabetyp trägt dazu bei, Fehler bei der Typkonvertierung zu vermeiden, wenn Daten zwischen den AWS Diensten hin- und hergeschickt werden. Sie können steuern, wer das Modell anwenden kann. Sie können auch die Laufzeiteigenschaften steuern, indem Sie einen Parameter angeben, der für die maximale Stapelgröße steht.

Derzeit haben alle Aurora Machine Learning-Funktionen die NOT DETERMINISTIC-Eigenschaft. Wenn Sie diese Eigenschaft nicht explizit angeben, richtet Aurora NOT DETERMINISTIC automatisch ein. Diese Anforderung ist darauf zurückzuführen, dass das SageMaker KI-Modell ohne Benachrichtigung an die Datenbank geändert werden kann. Wenn dies geschieht, führen Aufrufe an eine Aurora Machine Learning-Funktion möglicherweise zu unterschiedlichen Ergebnissen für gleiche Eingaben innerhalb einer einzigen Transaktion.

Sie können die Merkmale CONTAINS SQL, NO SQL, READS SQL DATA oder MODIFIES SQL DATA in Ihrer CREATE FUNCTION-Anweisung nicht verwenden.

Im Folgenden finden Sie ein Beispiel für die Verwendung des Aufrufs eines SageMaker KI-Endpunkts zur Erkennung von Anomalien. Es gibt einen KI-Endpunkt SageMaker . random-cut-forest-model Das entsprechende Modell wurde bereits durch den random-cut-forest-Algorithmus trainiert. Für jede Eingabe gibt das Modell einen Anomaliewert aus. Dieses Beispiel zeigt die Datenpunkte, deren Wert über 3 Standardabweichungen (etwa das 99,9-te Perzentil) vom Durchschnittsergebnis liegt.

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;

Zeichensatzanforderung für SageMaker KI-Funktionen, die Zeichenketten zurückgeben

Wir empfehlen, einen Zeichensatz von utf8mb4 als Rückgabetyp für Ihre SageMaker KI-Funktionen anzugeben, die Zeichenkettenwerte zurückgeben. Wenn dies nicht sinnvoll ist, verwenden Sie eine ausreichende Zeichenfolgenlänge, damit der Rückgabetyp einen im utf8mb4-Zeichensatz ausgedrückten Wert aufnehmen kann. Das folgende Beispiel illustriert die Angabe des utf8mb4-Zeichensatzes für Ihre Funktion.

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

Derzeit verwendet jede SageMaker AI-Funktion, die eine Zeichenfolge zurückgibt, den Zeichensatz utf8mb4 als Rückgabewert. Der Rückgabewert verwendet diesen Zeichensatz, auch wenn Ihre SageMaker AI-Funktion implizit oder explizit einen anderen Zeichensatz für ihren Rückgabetyp deklariert. Wenn Ihre SageMaker AI-Funktion einen anderen Zeichensatz für den Rückgabewert deklariert, werden die zurückgegebenen Daten möglicherweise stillschweigend gekürzt, wenn Sie sie in einer Tabellenspalte speichern, die nicht lang genug ist. Beispielsweise erstellt eine Abfrage mit einer DISTINCT-Klausel eine temporäre Tabelle. Daher kann das Ergebnis der SageMaker AI-Funktion aufgrund der Art und Weise, wie Zeichenketten während einer Abfrage intern behandelt werden, gekürzt werden.

Exportieren von Daten nach Amazon S3 für das SageMaker KI-Modelltraining (Fortgeschritten)

Wir empfehlen Ihnen, mit Aurora Machine Learning und SageMaker KI zu beginnen, indem Sie einige der bereitgestellten Algorithmen verwenden und dass die Datenwissenschaftler in Ihrem Team Ihnen die SageMaker KI-Endpunkte zur Verfügung stellen, die Sie mit Ihrem SQL Code verwenden können. Im Folgenden finden Sie minimale Informationen zur Verwendung Ihres eigenen Amazon S3 S3-Buckets mit Ihren eigenen SageMaker KI-Modellen und Ihrem Aurora My SQL DB-Cluster.

Machine Learning besteht aus zwei Hauptschritten: Training und Inferenz. Um SageMaker KI-Modelle zu trainieren, exportieren Sie Daten in einen Amazon S3 S3-Bucket. Der Amazon S3 S3-Bucket wird von einer Jupyter SageMaker AI-Notebook-Instance verwendet, um Ihr Modell vor der Bereitstellung zu trainieren. Sie können die SELECT INTO OUTFILE S3 Anweisung verwenden, um Daten aus einem Aurora My SQL DB-Cluster abzufragen und sie direkt in Textdateien zu speichern, die in einem Amazon S3 S3-Bucket gespeichert sind. Anschließend verwendet die Notebook-Instance die Daten aus dem Amazon S3-Bucket für das Training.

Aurora Machine Learning erweitert die bestehende SELECT INTO OUTFILE Syntax in Aurora MySQL, um Daten in CSV ein Format zu exportieren. Die generierte CSV Datei kann direkt von Modellen verwendet werden, die dieses Format für Trainingszwecke benötigen.

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

Die Erweiterung unterstützt das CSV Standardformat.

Die erweiterte Syntax und Grammatik von SELECT INTO sind jetzt wie folgt.

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

Überlegungen zur Leistung bei der Verwendung von Aurora Machine Learning mit Aurora My SQL

Die Dienste Amazon Bedrock, Amazon Comprehend und SageMaker KI erledigen den Großteil der Arbeit, wenn sie von einer Aurora-Funktion für maschinelles Lernen aufgerufen werden. Das bedeutet, dass Sie diese Ressourcen nach Bedarf unabhängig voneinander skalieren können. Für Ihren Aurora My SQL DB-Cluster können Sie Ihre Funktionsaufrufen so effizient wie möglich gestalten. Im Folgenden finden Sie einige Leistungsaspekte, die Sie bei der Arbeit mit Aurora Machine Learning beachten sollten.

Modell und Aufforderung

Die Leistung bei der Verwendung von Amazon Bedrock hängt stark vom Modell und der verwendeten Eingabeaufforderung ab. Wählen Sie ein Modell und eine Aufforderung, die für Ihren Anwendungsfall optimal sind.

Abfrage-Cache

Der Aurora My SQL Query Cache funktioniert nicht für Aurora-Funktionen für maschinelles Lernen. Aurora My speichert SQL keine Abfrageergebnisse im Abfrage-Cache für SQL Anweisungen, die Aurora-Funktionen für maschinelles Lernen aufrufen.

Batch-Optimierung für Aurora-Machine-Learning-Funktionsaufrufe

Der wichtigste Aurora Machine Learning-Performanceaspekt, den Sie von Ihrem Aurora-Cluster aus beeinflussen können, ist die Batch-Moduseinstellung für Aufrufe der gespeicherten Aurora-Machine-Learning-Funktion. Machine-Learning-Funktionen erfordern in der Regel einen erheblichen Overhead, was es unpraktisch macht, einen externen Service für jede Zeile separat aufzurufen. Aurora Machine Learning kann diesen Overhead minimieren, indem die Aufrufe des externen Aurora-Machine-Learning-Services für viele Zeilen in einem einzigen Batch zusammengefasst werden. Aurora Machine Learning empfängt die Antworten für alle Eingabezeilen und liefert die Antworten Zeile für Zeile an die Abfrage, während sie ausgeführt wird. Diese Optimierung verbessert den Durchsatz und die Latenz für Ihre Aurora-Abfragen ohne Änderungen bei den Ergebnissen.

Wenn Sie eine gespeicherte Aurora-Funktion erstellen, die mit einem SageMaker KI-Endpunkt verbunden ist, definieren Sie den Batchgröße-Parameter. Dieser Parameter beeinflusst, wie viele Zeilen für jeden zugrunde liegenden Aufruf an SageMaker AI übertragen werden. Bei Abfragen, die eine große Anzahl von Zeilen verarbeiten, kann der Aufwand, für jede Zeile einen separaten SageMaker KI-Aufruf zu tätigen, erheblich sein. Je größer der von der gespeicherten Prozedur verarbeitete Datensatz ist, umso größer kann die Stapelgröße gewählt werden.

Ob die Optimierung im Batchmodus auf eine SageMaker AI-Funktion angewendet werden kann, können Sie anhand des durch die EXPLAIN PLAN Anweisung erstellten Abfrageplans feststellen. In diesem Fall enthält die extra-Spalte in dem Ausführungsplan Batched machine learning. Das folgende Beispiel zeigt einen Aufruf einer SageMaker AI-Funktion, die den Batch-Modus verwendet.

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)

Wenn Sie eine der integrierten Amazon Comprehend-Funktionen aufrufen, können Sie die Stapelgröße steuern, indem Sie den optionalen max_batch_size-Parameter angeben. Dieser Parameter schränkt die maximale Anzahl der in jedem Stapel verarbeiteten input_text-Werte ein. Wenn mehrere Elemente gleichzeitig gesendet werden, reduziert dies die Anzahl der Wiederholungen zwischen Aurora und Amazon Comprehend. Die Begrenzung der Stapelgröße ist in verschiedenen Situationen sinnvoll, etwa bei einer Abfrage mit einer LIMIT-Klausel. Durch die Verwendung eines kleineren Wertes für max_batch_size vermeiden Sie, dass Amazon Comprehend häufiger aufgerufen wird als Eingabetexte vorhanden sind.

Die Batchoptimierung für die Evaluierung von Aurora-Machine-Learning-Funktionen gilt in den folgenden Fällen:

Überwachung von Aurora Machine Learning

Sie können die Batchoperationen für maschinelles Lernen in Aurora überwachen, indem Sie mehrere globale Variablen abfragen, wie im folgenden Beispiel gezeigt.

show status like 'Aurora_ml%';

Sie können die Statusvariablen mit einer FLUSH STATUS-Anweisung zurücksetzen. So stehen alle Zahlen für Gesamtwerte, Durchschnittswerte usw. seit der letzten Zurücksetzung der Variablen.

Informationen zur Überwachung der Leistung der SageMaker KI-Operationen, die von Aurora-Funktionen für maschinelles Lernen aufgerufen werden, finden Sie unter Amazon SageMaker AI überwachen.