Verwendung von Amazon Aurora Machine Learning mit Aurora MySQL

Wenn Sie Amazon Aurora Machine Learning mit Ihrem Aurora MySQL-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 Machine Learning.

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

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 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 stützt sich auf AWS Identity and Access Management (IAM-) Rollen und Richtlinien, damit Ihr Aurora MySQL-DB-Cluster 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 stützt sich auf AWS Identity and Access Management Rollen und Richtlinien, damit Ihr Aurora MySQL-DB-Cluster 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.

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

Das folgende Verfahren erstellt automatisch die IAM-Rolle und -Richtlinie für Ihren Aurora MySQL-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 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. Setzen Sie die Einrichtung Ihres Aurora MySQL-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 MySQL-DB-Cluster hinzufügen, wie im Einrichtung Ihres Aurora MySQL-DB-Clusters für die Verwendung von Amazon S3 for SageMaker AI (optional) Folgenden beschrieben.

Einrichtung Ihres Aurora MySQL-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 MySQL-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 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.

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 MySQL-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ü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 KI-Funktionen können jetzt verwendet werden. Anwendungsbeispiele finden Sie unter SageMaker KI mit Ihrem Aurora MySQL-DB-Cluster verwenden.

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.

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 MySQL-DB-Cluster verwenden

Um SageMaker KI-Funktionen aus Ihrem Aurora MySQL-DB-Cluster zu nutzen, müssen Sie gespeicherte Funktionen erstellen, die Ihre Aufrufe in den SageMaker KI-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 KI bereitgestellte Modelle für Inferenz zu verwenden, erstellen Sie benutzerdefinierte Funktionen mithilfe von MySQL 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 KI-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 die mit dieser Option exportierte CSV 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 von SQL-Typen für die Modelleingaben und den Modellausgabetyp trägt dazu bei, Typkonvertierungsfehler bei der Übertragung von Daten zwischen den AWS Diensten zu vermeiden. 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 MySQL-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 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 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 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 KI-Endpunkt verbunden ist, definieren Sie den Parameter für die Batchgröße. 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 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 SageMaker KI-Operationen, die von Aurora-Funktionen für maschinelles Lernen aufgerufen werden, finden Sie unter Amazon SageMaker AI überwachen.