Verwendung von Amazon Aurora Machine Learning mit Aurora MySQL

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

Voraussetzungen für die Verwendung von Aurora Machine Learning mit Aurora MySQL

AWS Machine Learning Services sind verwaltete Services, die in ihren eigenen Produktionsumgebungen eingerichtet und ausgeführt werden. Aurora Machine Learning unterstützt die Integration in Amazon Bedrock, Amazon Comprehend, und SageMaker AI. Bevor Sie versuchen, Ihren DB-Cluster von Aurora MySQL für die Verwendung 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 MySQL

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

Einrichten Ihres DB-Clusters von Aurora MySQL zur Verwendung von Aurora Machine Learning

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

Einrichten Ihres DB-Clusters von Aurora MySQL zur Verwendung von Amazon Bedrock

Aurora Machine Learning basiert auf Rollen und Richtlinien von AWS Identity and Access Management, damit Ihr DB-Cluster von Aurora MySQL auf die Amazon-Bedrock-Services zugreifen und diese nutzen kann. Die folgenden Verfahren erstellen eine IAM-Berechtigungsrichtlinie und -rolle, 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 ordnen Sie Ihrem DB-Cluster die Amazon-Bedrock-IAM-Rolle zu.

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

Die IAM-Integration für Amazon Bedrock ist abgeschlossen. Fahren Sie mit der Einrichtung Ihres DB-Clusters von Aurora MySQL für den Einsatz von Amazon Bedrock durch Erteilen des Zugriffs auf Aurora Machine Learning für Datenbankbenutzer fort.

Einrichten Ihres DB-Clusters von Aurora MySQL zur Verwendung von Amazon Comprehend

Aurora Machine Learning basiert auf Rollen und Richtlinien von AWS Identity and Access Management, damit Ihr DB-Cluster von Aurora MySQL auf die Amazon-Comprehend-Services zugreifen und diese nutzen kann. Mit dem folgenden Verfahren werden automatisch eine IAM-Rolle und -Richtlinie für Ihren Cluster erstellt, sodass dieser Amazon Comprehend verwenden kann.

Die IAM-Integration für Amazon Comprehend ist abgeschlossen. Fahren Sie mit der Einrichtung Ihres DB-Clusters von Aurora MySQL zur Zusammenarbeit mit Amazon Comprehend fort, indem Sie den entsprechenden Datenbankbenutzern Zugriff gewähren.

Einrichten Ihres DB-Clusters von Aurora MySQL zur Verwendung von SageMaker AI

Mit dem folgenden Verfahren werden automatisch eine IAM-Rolle und -Richtlinie für Ihren DB-Cluster von Aurora MySQL erstellt, sodass dieser SageMaker AI verwenden kann. Bevor Sie versuchen, dieses Verfahren auszuführen, stellen Sie sicher, dass der SageMaker AI-Endpunkt verfügbar ist, damit Sie ihn bei Bedarf eingeben können. In der Regel ist es Aufgabe der Datenwissenschaftler in Ihrem Team, einen Endpunkt zu erstellen, den Sie von Ihrem DB-Cluster von Aurora MySQL 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 damit abgeschlossen. Fahren Sie mit der Einrichtung Ihres DB-Clusters von Aurora MySQL zur Zusammenarbeit mit SageMaker AI fort, indem Sie den entsprechenden Datenbankbenutzern Zugriff gewähren.

Wenn Sie Ihre SageMaker AI-Modelle für das Training verwenden möchten, anstatt vordefinierte SageMaker AI-Komponenten zu nutzen, müssen Sie Ihrem DB-Cluster von Aurora MySQL auch den Amazon-S3-Bucket hinzufügen, wie im folgenden Abschnitt Einrichten Ihres DB-Clusters von Aurora MySQL zur Verwendung von Amazon S3 für SageMaker AI (optional) beschrieben.

Einrichten Ihres DB-Clusters von Aurora MySQL zur Verwendung von Amazon S3 für SageMaker AI (optional)

Wenn Sie SageMaker AI mit Ihren eigenen Modellen verwenden möchten, anstatt die von SageMaker AI bereitgestellten vordefinierten Komponenten zu verwenden, müssen Sie einen Amazon-S3-Bucket für den DB-Cluster von Aurora MySQL einrichten. 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-Buckets mit SageMaker AI finden Sie unter Angeben eines Amazon-S3-Buckets zum Hochladen von Trainingsdatensätzen und Speichern von Ausgabedaten im Entwicklerhandbuch für Amazon SageMaker AI. Weitere Informationen zum Arbeiten mit SageMaker AI finden Sie unter Erste Schritte mit Notebook-Instances von Amazon SageMaker AI im Entwicklerhandbuch für Amazon SageMaker AI.

Erteilen des Zugriffs auf Aurora Machine Learning für Datenbankbenutzer

Datenbankbenutzern muss die Berechtigung zum Aufrufen von Aurora-Machine-Learning-Funktionen erteilt werden. Wie Sie Berechtigungen erteilen, hängt von der MySQL-Version ab, die Sie für Ihren DB-Cluster von Aurora MySQL verwenden, wie im Folgenden beschrieben. Wie Sie diesen Vorgang ausführen, hängt von der MySQL-Version ab, die Ihr DB-Cluster von Aurora MySQL verwendet.

Die folgende Tabelle zeigt die Rollen und Berechtigungen, die Datenbankbenutzer benötigen, um mit Funktionen für Machine Learning zu arbeiten.

Erteilen des Zugriffs auf Amazon-Bedrock-Funktionen

Wenn Sie Datenbankbenutzern Zugriff auf Amazon-Bedrock-Funktionen erteilen möchten, verwenden Sie die folgende SQL-Anweisung:

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

Datenbankbenutzern müssen außerdem 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 auf AWS_BEDROCK_ACCESS festgelegt sein:

SET ROLE AWS_BEDROCK_ACCESS;

Die Amazon-Bedrock-Funktionen sind jetzt verfügbar.

Erteilen des Zugriffs auf Amazon-Comprehend-Funktionen

Wenn Sie Datenbankbenutzern Zugriff auf Amazon-Comprehend-Funktionen erteilen möchten, verwenden Sie die entsprechende Anweisung für Ihre Aurora-MySQL-Version.

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

Erteilen des Zugriffs auf SageMaker AI-Funktionen

Wenn Sie Datenbankbenutzern Zugriff auf SageMaker AI-Funktionen erteilen möchten, verwenden Sie die entsprechende Anweisung für Ihre Aurora-MySQL-Version.

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

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 AI-Funktionen sind jetzt verfügbar. Anwendungsbeispiele finden Sie unter Verwenden von SageMaker AI mit Ihrem DB-Cluster von Aurora MySQL.

Verwenden von Amazon Bedrock mit Ihrem DB-Cluster von Aurora MySQL

Um Amazon Bedrock zu verwenden, erstellen Sie eine benutzerdefinierte Funktion (UDF) in Ihrer Aurora-MySQL-Datenbank, die ein Modell aufruft. Weitere Informationen finden Sie unter Was ist Amazon Bedrock? im Amazon Bedrock-Benutzerhandbuch.

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

Die folgende UDF ruft beispielsweise das Modell „Amazon Titan Text Express“ auf:

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 Anforderung 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 Anforderungstext entsprechend zu formatieren. Weitere Informationen finden Sie unter Inferenzparameter für Fundamentmodelle im Amazon Bedrock-Benutzerhandbuch.

Verwenden von Amazon Comprehend mit Ihrem DB-Cluster von Aurora MySQL

Für Aurora MySQL bietet Aurora Machine Learning die folgenden zwei 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. Große Stapel bieten schnellere Leistung bei gleichzeitig höherer Speichernutzung auf dem DB-Cluster von Aurora MySQL. Weitere Informationen finden Sie unter Leistungsaspekte zur Verwendung von Aurora Machine Learning mit Aurora MySQL.

Informationen zu den 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;

Verwenden von SageMaker AI mit Ihrem DB-Cluster von Aurora MySQL

Damit Sie die SageMaker AI-Funktionalität von Ihrem DB-Cluster von Aurora MySQL aus verwenden können, müssen Sie gespeicherte Funktionen erstellen, die Ihre Aufrufe an den SageMaker AI-Endpunkt und seine Inferenzfunktionen einbetten. Verwenden Sie dazu CREATE FUNCTION von MySQL im Prinzip auf die gleiche Weise wie für andere Verarbeitungsaufgaben auf Ihrem DB-Cluster von Aurora MySQL.

Um in SageMaker AI bereitgestellte Modelle für die Inferenz zu verwenden, erstellen Sie benutzerdefinierte Funktionen mithilfe von MySQL-Datendefinitionssprachenanweisungen (DDL) für gespeicherte Funktionen. Jede gespeicherte Funktion stelle den SageMaker AI-Endpunkt das, der das Modell hostet. Wenn Sie eine solche Funktion definieren, geben Sie die Eingabeparameter für das Modell, den spezifischen aufzurufenden SageMaker AI-Endpunkt und den Rückgabetyp an. Die Funktion gibt die vom SageMaker AI-Endpunkt nach dem Anwenden des Modells auf den Eingabeparametern berechnete Inferenz an.

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 Syntax CREATE FUNCTION für das Arbeiten mit 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];

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 Funktionstext 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 AI-Endpunkt kann verschiedene Eigenschaften für jedes Modell haben.

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 der in einer Stapelanfrage an SageMaker AI verarbeiteten Eingaben zu beschränken. Der max_batch_size-Parameter kann dabei helfen, Fehler durch zu große Eingaben zu vermeiden oder unterstützen, dass SageMaker AI schneller eine Antwort zurückgibt. Dieser Parameter wirkt sich auf die Größe eines internen Puffers für die Verarbeitung von SageMaker AI-Anfragen aus. 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. Obwohl Sie die MANIFEST ON-Option verwenden können, können einige SageMaker AI-Funktionen die mit dieser Option exportierte CSV-Datei nicht direkt verwenden. Das Manifestformat ist nicht mit dem erweiterten Manifestformat von SageMaker AI kompatibel.

Sie erstellen eine separate gespeicherte Funktion für jedes Ihrer SageMaker AI-Modelle. 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 von SQL-Typen für die Modelleingaben und den Modellausgabetyp hilft bei der Vermeidung von Konvertierungsfehlern, bei denen Daten zwischen den AWS-Services hin- und herübertragen 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. Dies ist erforderlich, weil das SageMaker AI-Modell ohne Benachrichtigung der 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.

Nachfolgend sehen Sie ein Beispiel für den Aufruf eines SageMaker AI-Endpunkts zum Erkennen von Anomalien. Es gibt einen SageMaker AI-Endpunkt 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;

Zeichensatzanforderungen für SageMaker AI-Funktionen, die Zeichenfolgen zurückgeben

Wir empfehlen die Angabe eines Zeichensatzes von utf8mb4 als Rückgabetyp für Ihre SageMaker AI-Funktionen, die Zeichenfolgenwerte 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 für den Rückgabewert. Der Rückgabewert verwendet diesen Zeichensatz auch dann, wenn Ihre SageMaker AI-Funktion implizit oder explizit für ihren Rückgabetyp einen anderen Zeichensatz angibt. Wenn Ihre SageMaker AI-Funktion einen anderen Zeichensatz für den Rückgabewert angibt, können die zurückgegebenen Daten leicht gekürzt sein, 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 durch die Art und Weise, in der Zeichenfolgen bei einer Abfrage intern behandelt werden, gekürzt werden.

Export von Daten nach Amazon S3 für das SageMaker AI-Modelltraining (erweitert)

Wir empfehlen Ihnen, mit Aurora Machine Learning und SageMaker AI zu beginnen, indem Sie einige der bereitgestellten Algorithmen verwenden. Die Datenwissenschaftler in Ihrem Team sollten Ihnen die SageMaker AI-Endpunkte bereitstellen, die Sie mit Ihrem SQL-Code verwenden können. Im Folgenden finden Sie minimale Informationen zur Verwendung Ihres eigenen Amazon-S3-Buckets mit Ihren eigenen SageMaker AI-Modellen und Ihrem DB-Cluster von Aurora MySQL.

Machine Learning besteht aus zwei Hauptschritten: Training und Inferenz. Für das Training von SageMaker AI-Modellen exportieren Sie Daten in einen Amazon S3-Bucket. Der Amazon S3-Bucket wird von einer Jupyter SageMaker AI-Notebook-Instance für das Training Ihres Modells vor seiner Bereitstellung verwendet. Sie können die Anweisung SELECT INTO OUTFILE S3 verwenden, um Daten aus einem Aurora MySQL-DB-Cluster abzufragen und sie direkt in Textdateien in einem Amazon S3-Bucket zu speichern. 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 zum Export von Daten im CSV-Format. 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 Standard-CSV-Format.

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

Leistungsaspekte zur Verwendung von Aurora Machine Learning mit Aurora MySQL

Die Dienste Amazon Bedrock, Amazon Comprehend und SageMaker AI erledigen den größten Teil der Arbeit, wenn sie von einer Aurora-Funktion für Machine Learning aufgerufen werden. Das bedeutet, dass Sie diese Ressourcen nach Bedarf unabhängig voneinander skalieren können. Für Ihren DB-Cluster von Aurora MySQL können Sie Ihre Funktionsaufrufe 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 Prompt

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

Abfrage-Cache

Der Abfrage-Cache von Aurora MySQL funktioniert nicht für Aurora-Funktionen für Machine Learning. Aurora MySQL speichert keine Abfrageergebnisse im Abfrage-Cache für SQL-Anweisungen, die Aurora-Funktionen für Machine Learning 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 AI-Endpunkt verbunden ist, legen Sie den Parameter für die Stapelgröße fest. Dieser Parameter legt fest, wie viele Zeilen für jeden zugrunde liegenden Aufruf an SageMaker AI übertragen werden. Bei Abfragen, die sehr viele Zeilen verarbeiten, kann der Overhead für separate SageMaker AI-Aufrufe für jede Zeile 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 Stapelmodusoptimierung für eine SageMaker AI-Funktion verwendet werden kann, erkennen Sie, wenn Sie den von der EXPLAIN PLAN-Anweisung erstellten Abfrageplan prüfen. In diesem Fall enthält die extra-Spalte in dem Ausführungsplan Batched machine learning. Das folgende Beispiel zeigt einen Aufruf an eine SageMaker AI-Funktion im Stapelmodus.

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 Batchoperationen von Aurora Machine Learning ü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 von Aurora Machine Learning-Funktionen aufgerufenen SageMaker AI-Vorgänge finden Sie unter Überwachung von Amazon SageMaker AI.