Verwendung von Amazon Aurora Machine Learning mit Aurora PostgreSQL

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

Aurora Machine Learning wird nur in bestimmten AWS-Regionen und für bestimmte Versionen von Aurora PostgreSQL unterstützt. Bevor Sie versuchen, Aurora Machine Learning einzurichten, überprüfen Sie die Verfügbarkeit Ihrer Aurora-PostgreSQL-Version und Ihrer Region. Details hierzu finden Sie unter Aurora Machine Learning mit Aurora PostgreSQL.

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

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 Comprehend und Amazon SageMaker Bedrock. Bevor Sie versuchen, Ihren DB-Cluster von Aurora PostgreSQL für die Verwendung von Aurora Machine Learning einzurichten, stellen Sie sicher, dass Sie die folgenden Anforderungen und Voraussetzungen verstehen.

• Die Amazon Comprehend- und Amazon Bedrock-Services müssen im selben System AWS-Region wie Ihr Aurora PostgreSQL-DB-Cluster ausgeführt werden. SageMaker Sie können Amazon Comprehend- SageMaker oder Amazon Bedrock-Services nicht von einem Aurora PostgreSQL-DB-Cluster in einer anderen Region aus verwenden.

• Wenn sich Ihr Aurora PostgreSQL-DB-Cluster in einer anderen Virtual Public Cloud (VPC) befindet, die auf dem Amazon VPC-Service basiert, als Ihr Amazon Comprehend und Ihre SageMaker Services, muss die Sicherheitsgruppe der VPC ausgehende Verbindungen zum Aurora-Zielservice für maschinelles Lernen zulassen. Weitere Informationen finden Sie unter Aktivieren der Netzwerkkommunikation von Amazon Aurora MySQL zu anderen AWS-Services.

• Denn die Komponenten des maschinellen Lernens SageMaker, die Sie für Inferenzen verwenden möchten, müssen eingerichtet und einsatzbereit sein. Während des Konfigurationsprozesses für Ihren Aurora PostgreSQL-DB-Cluster muss der Amazon-Ressourcenname (ARN) des SageMaker Endpunkts verfügbar sein. Die Datenwissenschaftler in Ihrem Team sind wahrscheinlich am besten in der Lage, die Modelle vorzubereiten und die anderen Aufgaben dieser Art SageMaker zu erledigen. Informationen zu den ersten Schritten mit Amazon SageMaker finden Sie unter Erste Schritte mit Amazon SageMaker. Weitere Informationen zu Rückschlüssen und Endpunkten finden Sie unter Echtzeit-Inferenz.

• Für Amazon Bedrock müssen Sie die Modell-ID der Bedrock-Modelle, die Sie für Inferenzen verwenden möchten, während des Konfigurationsprozesses Ihres Aurora PostgreSQL-DB-Clusters zur Verfügung haben. Die Datenwissenschaftler in Ihrem Team sind wahrscheinlich am besten in der Lage, mit Bedrock zusammenzuarbeiten, um zu entscheiden, welche Modelle verwendet werden sollen, sie bei Bedarf zu verfeinern und andere solche Aufgaben zu erledigen. Informationen zu den ersten Schritten mit Amazon Bedrock finden Sie unter So richten Sie Bedrock ein.

• Amazon-Bedrock-Benutzer müssen den Zugriff auf Modelle anfordern, bevor sie verwendet werden können. Wenn Sie zusätzliche Modelle für die Text-, Chat- und Bildgenerierung hinzufügen möchten, müssen Sie den Zugriff auf Modelle in Amazon Bedrock anfordern. Weitere Informationen finden Sie unter Modellzugriff.

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

Aurora Machine Learning unterstützt jeden SageMaker Endpunkt, der das CSV-Format (Comma-Separated Value) lesen und schreiben kann, und zwar mit einem ContentType Wert von. text/csv Die integrierten SageMaker Algorithmen, die dieses Format derzeit akzeptieren, sind die folgenden.

• Lineares Lernen

• Random Cut Forest

• XGBoost

  Weitere Informationen zu diesen Algorithmen finden Sie unter Choose an Algorithm im Amazon SageMaker Developer Guide.

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

• Die benutzerdefinierten Funktionen (UDFs) bieten eine native Möglichkeit, mit Amazon Bedrock zu interagieren. Die UDFs haben keine spezifischen Anforderungen an Anfragen oder Antworten, sodass sie jedes Modell verwenden können.

• Sie können UDFs verwenden, um jeden gewünschten Workflow zu erstellen. Sie können beispielsweise Basis-Primitive kombinieren, pg_cron um beispielsweise eine Abfrage auszuführen, Daten abzurufen, Schlussfolgerungen zu generieren und in Tabellen zu schreiben, um Abfragen direkt zu bearbeiten.

• UDFs unterstützen keine gestapelten oder parallel Aufrufe.

• Die Aurora Machine Learning Learning-Erweiterung unterstützt keine Vektorschnittstellen. Als Teil der Erweiterung ist eine Funktion verfügbar, mit der die Einbettungen der Modellantwort in dem float8[] Format ausgegeben werden können, in dem diese Einbettungen in Aurora gespeichert werden. Weitere Informationen zur Verwendung von finden Sie unter. float8[] Verwenden von Amazon Bedrock mit Ihrem Aurora PostgreSQL-DB-Cluster

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

Damit Aurora Machine Learning mit Ihrem Aurora PostgreSQL-DB-Cluster funktioniert, müssen Sie für jeden der Dienste, die Sie verwenden möchten, eine AWS Identity and Access Management (IAM-) Rolle erstellen. Die IAM-Rolle ermöglicht es Ihrem DB-Cluster von Aurora PostgreSQL, den Aurora-Dienst für Machine Learning im Namen des Clusters zu verwenden. Sie müssen auch die Aurora-Erweiterung für Machine Learning installieren. In den folgenden Themen finden Sie Einrichtungsverfahren für jeden dieser Aurora-Dienste für Machine Learning.

Themen

• Aurora PostgreSQL für die Verwendung von Amazon Bedrock einrichten
• Einrichten von Aurora PostgreSQL für die Verwendung von Amazon Comprehend
• Aurora PostgreSQL für die Nutzung von Amazon einrichten SageMaker
  • Aurora PostgreSQL für die Verwendung von Amazon S3 einrichten SageMaker (Fortgeschritten)
• Installieren der Aurora-Erweiterung für Machine Learning

Aurora PostgreSQL für die Verwendung von Amazon Bedrock einrichten

Im folgenden Verfahren erstellen Sie zunächst die IAM-Rolle und -Richtlinie, die Ihrem Aurora PostgreSQL die Erlaubnis geben, Amazon Bedrock im Namen des Clusters zu verwenden. Anschließend fügen Sie die Richtlinie einer IAM-Rolle hinzu, die Ihr Aurora PostgreSQL-DB-Cluster für die Zusammenarbeit mit Amazon Bedrock verwendet. Der Einfachheit halber verwendet dieses Verfahren die, um alle Aufgaben AWS Management Console zu erledigen.

So richten Sie Ihren Aurora PostgreSQL-DB-Cluster für die Verwendung von Amazon Bedrock ein

1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die IAM-Konsole unter https://console.aws.amazon.com/iam/.

2. Öffnen Sie die IAM-Konsole unter https://console.aws.amazon.com/iam/.

3. Wählen Sie im Konsolenmenü (IAM) die Option Richtlinien AWS Identity and Access Management (unter Zugriffsverwaltung) aus.

   1. Wählen Sie Richtlinie erstellen aus. Wählen Sie auf der Visual Editor-Seite Service aus und geben Sie dann Bedrock in das Feld Service auswählen ein. Erweitern Sie die Lesezugriffsebene. Wählen Sie InvokeModelaus den Amazon Bedrock-Leseeinstellungen.

   2. Wählen Sie das Foundation/Provisioned-Modell aus, dem Sie über die Richtlinie Lesezugriff gewähren möchten.

      

4. Wählen Sie Next: Tags (Weiter: Tags) aus und definieren Sie Tags (dies ist optional). Wählen Sie Weiter: Prüfen aus. Geben Sie einen Namen und eine Beschreibung für die Richtlinie ein, wie in der Abbildung gezeigt.

   

5. Wählen Sie Richtlinie erstellen aus. Die Konsole zeigt eine Warnung an, wenn die Richtlinie gespeichert wurde. Sie finden sie in der Liste der Richtlinien.

6. Wählen Sie in der IAM-Konsole die Option Roles (Rollen) (unter „Access management“ (Zugriffsverwaltung)) aus.

7. Wählen Sie Rolle erstellen aus.

8. Wählen Sie auf der Seite Vertrauenswürdige Entität auswählen die AWS Service-Kachel und dann RDS aus, um den Selektor zu öffnen.

9. Wählen Sie RDS – Add Role to Database (RDS – Rolle zu Datenbank hinzufügen) aus.

   

10. Wählen Sie Weiter aus. Suchen Sie auf der Seite „Add permissions“ (Berechtigungen hinzufügen) nach der im vorherigen Schritt erstellten Richtlinie und wählen Sie sie aus den aufgelisteten Richtlinien aus. Wählen Sie Weiter aus.

11. Next: Review (Weiter: Überprüfung). Geben Sie einen Namen und eine Beschreibung für die IAM-Rolle ein.

12. Öffnen Sie die Amazon-RDS-Konsole unter https://console.aws.amazon.com/rds/.

13. Navigieren Sie zu dem AWS-Region Ort, an dem sich Ihr Aurora PostgreSQL-DB-Cluster befindet.

14. Wählen Sie im Navigationsbereich Datenbanken und dann den Aurora PostgreSQL-DB-Cluster aus, den Sie mit Bedrock verwenden möchten.

15. Wählen Sie die Registerkarte Connectivity & security (Konnektivität und Sicherheit) aus und scrollen Sie zum Abschnitt Manage IAM roles (IAM-Rollen verwalten) auf der Seite. Wählen Sie in der Auswahl Add IAM roles to this cluster (Diesem Cluster IAM-Rollen hinzufügen) die Rolle aus, die Sie in den vorherigen Schritten erstellt haben. Wählen Sie in der Funktionsauswahl Bedrock und dann Rolle hinzufügen aus.

Die Rolle ist (mit ihrer Richtlinie) dem DB-Cluster von Aurora PostgreSQL zugeordnet. Wenn der Vorgang abgeschlossen ist, wird die Rolle in der Liste „Current IAM roles for this cluster“ (Aktuelle IAM-Rollen für diesen Cluster) angezeigt, wie in der folgenden Abbildung dargestellt.

Das IAM-Setup für Amazon Bedrock ist abgeschlossen. Fahren Sie mit der Einrichtung von Aurora PostgreSQL für Aurora Machine Learning fort, indem Sie die Erweiterung wie unter Installieren der Aurora-Erweiterung für Machine Learning beschrieben installieren.

Einrichten von Aurora PostgreSQL für die Verwendung von Amazon Comprehend

Im folgenden Verfahren erstellen Sie zunächst die IAM-Rolle und -Richtlinie, die Aurora PostgreSQL die Berechtigung erteilt, Amazon Comprehend im Namen des Clusters zu verwenden. Anschließend fügen Sie die Richtlinie einer IAM-Rolle an, die Ihr DB-Cluster von Aurora PostgreSQL für die Arbeit mit Amazon Comprehend verwendet. Der Einfachheit halber nutzt dieses Verfahren die AWS Management Console , um alle Aufgaben abzuschließen.

So richten Sie Ihren DB-Cluster von Aurora PostgreSQL zur Verwendung von Amazon Comprehend ein

1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die IAM-Konsole unter https://console.aws.amazon.com/iam/.

2. Öffnen Sie die IAM-Konsole unter https://console.aws.amazon.com/iam/.

3. Wählen Sie im Konsolenmenü (IAM) die Option Richtlinien AWS Identity and Access Management (unter Zugriffsverwaltung) aus.

   

4. Wählen Sie Richtlinie erstellen aus. Wählen Sie auf der Seite „Visual editor“ (Visueller Editor) die Option Service (Service) aus und geben Sie dann im Feld „Select a service“ (Service auswählen) Comprehend ein. Erweitern Sie die Lesezugriffsebene. Wählen Sie BatchDetectSentimentund DetectSentimentaus den Amazon Comprehend Leseeinstellungen.

5. Wählen Sie Next: Tags (Weiter: Tags) aus und definieren Sie Tags (dies ist optional). Wählen Sie Weiter: Prüfen aus. Geben Sie einen Namen und eine Beschreibung für die Richtlinie ein, wie in der Abbildung gezeigt.

   

6. Wählen Sie Richtlinie erstellen aus. Die Konsole zeigt eine Warnung an, wenn die Richtlinie gespeichert wurde. Sie finden sie in der Liste der Richtlinien.

7. Wählen Sie in der IAM-Konsole die Option Roles (Rollen) (unter „Access management“ (Zugriffsverwaltung)) aus.

8. Wählen Sie Rolle erstellen aus.

9. Wählen Sie auf der Seite Vertrauenswürdige Entität auswählen die AWS Service-Kachel und dann RDS aus, um den Selektor zu öffnen.

10. Wählen Sie RDS – Add Role to Database (RDS – Rolle zu Datenbank hinzufügen) aus.

    

11. Wählen Sie Weiter aus. Suchen Sie auf der Seite „Add permissions“ (Berechtigungen hinzufügen) nach der im vorherigen Schritt erstellten Richtlinie und wählen Sie sie aus den aufgelisteten Richtlinien aus. Wählen Sie Next (Weiter) aus.

12. Next: Review (Weiter: Überprüfung). Geben Sie einen Namen und eine Beschreibung für die IAM-Rolle ein.

13. Öffnen Sie die Amazon-RDS-Konsole unter https://console.aws.amazon.com/rds/.

14. Navigieren Sie zu dem AWS-Region Ort, an dem sich Ihr Aurora PostgreSQL-DB-Cluster befindet.

15. Wählen Sie im Navigationsbereich Databases (Datenbanken) und dann den DB-Cluster von Aurora PostgreSQL aus, den Sie mit Amazon Comprehend verwenden möchten.

16. Wählen Sie die Registerkarte Connectivity & security (Konnektivität und Sicherheit) aus und scrollen Sie zum Abschnitt Manage IAM roles (IAM-Rollen verwalten) auf der Seite. Wählen Sie in der Auswahl Add IAM roles to this cluster (Diesem Cluster IAM-Rollen hinzufügen) die Rolle aus, die Sie in den vorherigen Schritten erstellt haben. Wählen Sie in der Funktionsauswahl die Option Comprehend und dann Add role aus.

Die Rolle ist (mit ihrer Richtlinie) dem DB-Cluster von Aurora PostgreSQL zugeordnet. Wenn der Vorgang abgeschlossen ist, wird die Rolle in der Liste „Current IAM roles for this cluster“ (Aktuelle IAM-Rollen für diesen Cluster) angezeigt, wie in der folgenden Abbildung dargestellt.

Die IAM-Einrichtung für Amazon Comprehend ist abgeschlossen. Fahren Sie mit der Einrichtung von Aurora PostgreSQL für Aurora Machine Learning fort, indem Sie die Erweiterung wie unter Installieren der Aurora-Erweiterung für Machine Learning beschrieben installieren.

Aurora PostgreSQL für die Nutzung von Amazon einrichten SageMaker

Bevor Sie die IAM-Richtlinie und -Rolle für Ihren Aurora PostgreSQL-DB-Cluster erstellen können, müssen Sie Ihr SageMaker Modell-Setup und Ihren Endpunkt verfügbar haben.

So richten Sie Ihren Aurora PostgreSQL-DB-Cluster zur Verwendung ein SageMaker

1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die IAM-Konsole unter https://console.aws.amazon.com/iam/.

2. Wählen Sie im Konsolenmenü (IAM) die Option Richtlinien AWS Identity and Access Management (unter Zugriffsverwaltung) und wählen Sie dann Richtlinie erstellen aus. Wählen Sie im Visual Editor SageMakerden Service aus. Öffnen Sie für Aktionen den Auswahlbereich Lesen (unter Zugriffsebene) und wählen Sie InvokeEndpoint. Daraufhin wird ein Warnsymbol angezeigt.

3. Öffnen Sie die Ressourcenauswahl und wählen Sie unter Endpunktressourcen-ARN angeben für die InvokeEndpoint Aktion den Link ARN hinzufügen, um den Zugriff einzuschränken.

4. Geben Sie Ihre SageMaker Ressourcen und den Namen Ihres Endpunkts ein. AWS-Region Ihr AWS Konto ist vorausgefüllt.

   

5. Wählen Sie zum Speichern Add (Hinzufügen) aus. Wählen Sie Next: Tags (Weiter: Tags) und Next: Review (Weiter: Überprüfen) aus, um zur letzten Seite des Richtlinienerstellungsprozesses zu gelangen.

6. Geben Sie einen Namen und eine Beschreibung für die Richtlinie ein und wählen Sie dann Create policy (Richtlinie erstellen) aus. Die Richtlinie wird erstellt und der Liste „Policies“ (Richtlinien) hinzugefügt. Dabei wird in der Konsole eine Warnung angezeigt.

7. Wählen Sie in der IAM-Konsole Roles (Rollen) aus.

8. Wählen Sie Rolle erstellen aus.

9. Wählen Sie auf der Seite Vertrauenswürdige Entität auswählen die AWS Dienstkachel und dann RDS aus, um den Selektor zu öffnen.

10. Wählen Sie RDS – Add Role to Database (RDS – Rolle zu Datenbank hinzufügen) aus.

11. Wählen Sie Weiter aus. Suchen Sie auf der Seite „Add permissions“ (Berechtigungen hinzufügen) nach der im vorherigen Schritt erstellten Richtlinie und wählen Sie sie aus den aufgelisteten Richtlinien aus. Wählen Sie Next (Weiter) aus.

12. Next: Review (Weiter: Überprüfung). Geben Sie einen Namen und eine Beschreibung für die IAM-Rolle ein.

13. Öffnen Sie die Amazon-RDS-Konsole unter https://console.aws.amazon.com/rds/.

14. Navigieren Sie zu dem AWS-Region Ort, an dem sich Ihr Aurora PostgreSQL-DB-Cluster befindet.

15. Wählen Sie im Navigationsbereich Datenbanken und dann den Aurora PostgreSQL-DB-Cluster aus, mit dem Sie es verwenden möchten. SageMaker

16. Wählen Sie die Registerkarte Connectivity & security (Konnektivität und Sicherheit) aus und scrollen Sie zum Abschnitt Manage IAM roles (IAM-Rollen verwalten) auf der Seite. Wählen Sie in der Auswahl Add IAM roles to this cluster (Diesem Cluster IAM-Rollen hinzufügen) die Rolle aus, die Sie in den vorherigen Schritten erstellt haben. Wählen Sie in der Funktionsauswahl die Option und SageMaker anschließend Rolle hinzufügen aus.

Die Rolle ist (mit ihrer Richtlinie) dem DB-Cluster von Aurora PostgreSQL zugeordnet. Wenn der Vorgang abgeschlossen ist, wird die Rolle in der Liste „Current IAM roles for this cluster“ (Aktuelle IAM-Rollen für diesen Cluster) angezeigt.

Das IAM-Setup für SageMaker ist abgeschlossen. Fahren Sie mit der Einrichtung von Aurora PostgreSQL für Aurora Machine Learning fort, indem Sie die Erweiterung wie unter Installieren der Aurora-Erweiterung für Machine Learning beschrieben installieren.

Aurora PostgreSQL für die Verwendung von Amazon S3 einrichten SageMaker (Fortgeschritten)

Für die Verwendung SageMaker mit Ihren eigenen Modellen, anstatt die von bereitgestellten vorgefertigten Komponenten zu verwenden SageMaker, müssen Sie einen Amazon Simple Storage Service (Amazon S3) -Bucket einrichten, den der Aurora PostgreSQL-DB-Cluster verwenden kann. Dies ist ein Thema für Fortgeschrittene und wird in diesem Benutzerhandbuch für Amazon Aurora nicht vollständig dokumentiert. Der allgemeine Prozess ist derselbe wie bei der Integration der Unterstützung für SageMaker, und zwar wie folgt.

1. Erstellen Sie die IAM-Richtlinie und -Rolle für Amazon S3.

2. Fügen Sie die IAM-Rolle und den Amazon-S3-Import oder -Export als Funktion auf der Registerkarte „Connectivity & security“ (Konnektivität und Sicherheit) Ihres DB-Clusters von Aurora PostgreSQL hinzu.

3. Fügen Sie den ARN der Rolle der benutzerdefinierten DB-Cluster-Parametergruppe für jeden Aurora-DB-Cluster hinzu.

Grundlegende Informationen zur Nutzung finden Sie unter Exportieren von Daten nach Amazon S3 für SageMaker Modelltraining (Fortgeschritten).

Installieren der Aurora-Erweiterung für Machine Learning

Die Aurora-Erweiterungen aws_ml 1.0 für maschinelles Lernen bieten zwei Funktionen, mit denen Sie Amazon Comprehend SageMaker Comprehend-Dienste aufrufen können, sowie aws_ml 2.0 zwei zusätzliche Funktionen, mit denen Sie Amazon Bedrock-Dienste aufrufen können. Durch die Installation dieser Erweiterungen auf Ihrem Aurora PostgreSQL-DB-Cluster wird auch eine Administratorrolle für die Funktion erstellt.

Anmerkung

Die Verwendung dieser Funktionen hängt davon ab, ob die IAM-Einrichtung für den Aurora-Service für maschinelles Lernen (Amazon Comprehend SageMaker, Amazon Bedrock) abgeschlossen ist, wie unter beschrieben. Einrichten Ihres DB-Clusters von Aurora PostgreSQL zur Verwendung von Aurora Machine Learning

• aws_comprehend.detect_sentiment – Sie verwenden diese Funktion, um Stimmungsanalysen auf Text anzuwenden, der in der Datenbank Ihres DB-Clusters von Aurora PostgreSQL gespeichert ist.

• aws_sagemaker.invoke_endpoint — Sie verwenden diese Funktion in Ihrem SQL-Code, um von Ihrem Cluster aus mit dem Endpunkt zu kommunizieren. SageMaker

• aws_bedrock.invoke_model — Sie verwenden diese Funktion in Ihrem SQL-Code, um mit den Bedrock-Modellen aus Ihrem Cluster zu kommunizieren. Die Antwort dieser Funktion erfolgt im Format eines TEXTS. Wenn also ein Modell im Format eines JSON-Hauptteils antwortet, wird die Ausgabe dieser Funktion im Format einer Zeichenfolge an den Endbenutzer weitergeleitet.

• aws_bedrock.invoke_model_get_embeddings — Sie verwenden diese Funktion in Ihrem SQL-Code, um Bedrock-Modelle aufzurufen, die Ausgabeeinbettungen innerhalb einer JSON-Antwort zurückgeben. Dies kann genutzt werden, wenn Sie die direkt mit dem JSON-Key verknüpften Einbettungen extrahieren möchten, um die Antwort mit selbstverwalteten Workflows zu optimieren.

So richten Sie die Aurora-Erweiterung für Machine Learning in Ihrem DB-Cluster von Aurora PostgreSQL ein

• Verwenden Sie psql, um eine Verbindung mit der Writer-Instance Ihres DB-Clusters von Aurora PostgreSQL herzustellen. Stellen Sie eine Verbindung mit der entsprechenden Datenbank her, in der die aws_ml-Erweiterung installiert werden soll.

  psql --host=cluster-instance-1.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=labdb

labdb=> CREATE EXTENSION IF NOT EXISTS aws_ml CASCADE;
NOTICE:  installing required extension "aws_commons"
CREATE EXTENSION
labdb=> 

Durch die Installation der aws_ml Erweiterungen werden auch die aws_ml Administratorrolle und zwei neue Schemas wie folgt erstellt.

• aws_comprehend – Schema für den Amazon-Comprehend-Service und die Quelle der detect_sentiment-Funktion (aws_comprehend.detect_sentiment).

• aws_sagemaker— Schema für den SageMaker Dienst und die Quelle der invoke_endpoint Funktion (aws_sagemaker.invoke_endpoint).

• aws_bedrock— Schema für den Amazon Bedrock-Service und Quelle der invoke_model(aws_bedrock.invoke_model) invoke_model_get_embeddings(aws_bedrock.invoke_model_get_embeddings) Funktionen.

Der rds_superuser-Rolle wird die administrative aws_ml-Rolle zugewiesen und wird damit zum OWNER dieser beiden Aurora-Schemata für Machine Learning. Damit andere Datenbankbenutzer auf die Aurora-Funktionen für Machine Learning zugreifen können, muss der rds_superuser EXECUTE-Berechtigungen für die Aurora-Funktionen für Machine Learning erteilen. Standardmäßig werden EXECUTE-Berechtigungen von PUBLIC für die Funktionen in den beiden Aurora-Schemata für Machine Learning widerrufen.

In einer Datenbankkonfiguration mit mehreren Mandanten können Sie verhindern, dass Mandanten auf Aurora-Funktionen für Machine Learning zugreifen, indem Sie REVOKE USAGE für das spezifische Aurora-Schema für Machine Learning verwenden, das Sie schützen möchten.

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

Für Aurora PostgreSQL bietet Aurora Machine Learning die folgende Amazon Bedrock-Funktion für die Arbeit mit Ihren Textdaten. Diese Funktion ist erst verfügbar, nachdem Sie die aws_ml 2.0-Erweiterung installiert und alle Einrichtungsverfahren abgeschlossen haben. Weitere Informationen finden Sie unter Einrichten Ihres DB-Clusters von Aurora PostgreSQL zur Verwendung von Aurora Machine Learning.

aws_bedrock.invoke_model

Diese Funktion verwendet in JSON formatierten Text als Eingabe und verarbeitet ihn für eine Vielzahl von Modellen, die auf Amazon Bedrock gehostet werden, und ruft die JSON-Textantwort vom Modell zurück. Diese Antwort kann Text, Bild oder Einbettungen enthalten. Eine Zusammenfassung der Dokumentation der Funktion lautet wie folgt.

aws_bedrock.invoke_model(
   IN model_id      varchar,
   IN content_type  text,
   IN accept_type   text,
   IN model_input   text,
   OUT model_output varchar)

Die Ein- und Ausgaben dieser Funktion sind wie folgt.

• model_id— Kennung des Modells.

• content_type— Der Typ der Anfrage an das Bedrock-Modell.

• accept_type— Die Art der Antwort, die von Bedrocks Modell zu erwarten ist. Normalerweise application/JSON für die meisten Modelle.

• model_input— Eingabeaufforderungen; ein bestimmter Satz von Eingaben für das Modell in dem von content_type angegebenen Format. Weitere Informationen zum Anforderungsformat/zur Struktur, die das Modell akzeptiert, finden Sie unter Inferenzparameter für Fundamentmodelle.

• model_output— Die Ausgabe des Bedrock-Modells als Text.

Das folgende Beispiel zeigt, wie mit invoke_model ein Anthropic Claude 2-Modell für Bedrock aufgerufen wird.

Beispiel: Eine einfache Abfrage mit Amazon Bedrock-Funktionen

SELECT aws_bedrock.invoke_model (
    model_id    := 'anthropic.claude-v2',
    content_type:= 'application/json',
    accept_type := 'application/json',
    model_input := '{"prompt": "\n\nHuman: You are a helpful assistant that answers questions directly and only using the information provided in the context below.\nDescribe the answer 
    in detail.\n\nContext: %s \n\nQuestion: %s \n\nAssistant:","max_tokens_to_sample":4096,"temperature":0.5,"top_k":250,"top_p":0.5,"stop_sequences":[]}'
);

aws_bedrock.invoke_model_get_embeddings

Die Modellausgabe kann in einigen Fällen auf Vektoreinbettungen verweisen. Da die Antwort je nach Modell unterschiedlich ist, kann eine weitere Funktion namens invoke_model_get_embeddings genutzt werden, die genau wie invoke_model funktioniert, aber die Einbettungen durch Angabe des entsprechenden JSON-Schlüssels ausgibt.

aws_bedrock.invoke_model_get_embeddings(
   IN model_id      varchar,
   IN content_type  text,
   IN json_key      text,
   IN model_input   text,
   OUT model_output float8[])

Die Ein- und Ausgaben dieser Funktion sind wie folgt.

• model_id— Bezeichner des Modells.

• content_type— Der Typ der Anfrage an das Bedrock-Modell. Hier ist accept_type auf den Standardwert gesetzt. application/json

• model_input— Eingabeaufforderungen; ein bestimmter Satz von Eingaben für das Modell in dem von content_type angegebenen Format. Weitere Informationen zum Anforderungsformat/zur Struktur, die das Modell akzeptiert, finden Sie unter Inferenzparameter für Fundamentmodelle.

• json_key— Verweis auf das Feld, aus dem die Einbettung extrahiert werden soll. Dies kann variieren, wenn sich das Einbettungsmodell ändert.

• model_output— Die Ausgabe des Bedrock-Modells als Array von Einbettungen mit 16-Bit-Dezimalzahlen.

Das folgende Beispiel zeigt, wie eine Einbettung mit dem Modell Titan Embeddings G1 — Text Embedding für den Ausdruck PostgreSQL I/O monitoring views generiert wird.

Beispiel: Eine einfache Abfrage mit Amazon Bedrock-Funktionen

SELECT aws_bedrock.invoke_model_get_embeddings(
   model_id      := 'amazon.titan-embed-text-v1',
   content_type  := 'application/json',
   json_key      := 'embedding',
   model_input   := '{ "inputText": "PostgreSQL I/O monitoring views"}') AS embedding;

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

Für Aurora PostgreSQL bietet Aurora Machine Learning die folgende Amazon-Comprehend-Funktion für die Arbeit mit Ihren Textdaten. Diese Funktion ist erst verfügbar, nachdem Sie die aws_ml-Erweiterung installiert und alle Einrichtungsvorgänge abgeschlossen haben. Weitere Informationen finden Sie unter Einrichten Ihres DB-Clusters von Aurora PostgreSQL zur Verwendung von Aurora Machine Learning.

aws_comprehend.detect_sentiment

Diese Funktion nimmt Text als Eingabe und wertet aus, ob der Text eine positive, negative, neutrale oder gemischte emotionale Haltung hat. Sie gibt diese Stimmung zusammen mit einem Wahrscheinlichkeitsgrad für ihre Bewertung aus. Eine Zusammenfassung der Dokumentation der Funktion lautet wie folgt.

aws_comprehend.detect_sentiment(
   IN input_text varchar,      
   IN language_code varchar,  
   IN max_rows_per_batch int, 
   OUT sentiment varchar, 
   OUT confidence real)

Die Ein- und Ausgaben dieser Funktion sind wie folgt.

• input_text – Der Text zur Bewertung und Zuordnung der Stimmung (negativ, positiv, neutral, gemischt).

• language_code – Die Sprache des identifizierten input_text unter Verwendung der aus zwei Buchstaben bestehenden ISO-639-1-Kennung mit regionalem Untertag (nach Bedarf) bzw. dem aus drei Buchstaben bestehenden ISO-639-2-Code. Zum Beispiel ist en der Code für Englisch, zh der Code für vereinfachtes Chinesisch. Weitere Informationen finden Sie unter Unterstützte Sprachen im Amazon-Comprehend-Entwicklerhandbuch.

• max_rows_per_batch – Die maximale Anzahl von Zeilen pro Batch für die Verarbeitung im Batch-Modus. Weitere Informationen finden Sie unter Grundlagen zum Batch-Modus und zu den Aurora-Funktionen für Machine Learning.

• sentiment – Die Stimmung des Eingabetexts, die als POSITIV, NEGATIV, NEUTRAL oder GEMISCHT identifiziert wird.

• confidence – Der Grad der Wahrscheinlichkeit für die Genauigkeit der angegebenen sentiment. Die Werte können zwischen 0,0 und 1,0 liegen.

Nachstehend finden Sie Beispiele zur Verwendung dieser Funktion.

Beispiel: Eine einfache Abfrage mit Amazon-Comprehend-Funktionen

Hier ist ein Beispiel für eine einfache Abfrage, die diese Funktion aufruft, um die Kundenzufriedenheit mit Ihrem Support-Team zu bewerten. Angenommen, Sie haben eine Datenbanktabelle (support), in der Kundenfeedback nach jeder Supportanfrage gespeichert wird. Diese Beispielabfrage wendet die aws_comprehend.detect_sentiment-Funktion auf den Text in der feedback-Spalte der Tabelle an und gibt die Stimmung und den Wahrscheinlichkeitsgrad für diese Stimmung aus. Diese Abfrage gibt Ergebnisse außerdem in absteigender Reihenfolge aus.

SELECT feedback, s.sentiment,s.confidence 
    FROM support,aws_comprehend.detect_sentiment(feedback, 'en') s 
    ORDER BY s.confidence DESC;
 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)

Damit vermieden wird, dass Sie für die Stimmungserkennung mehr als einmal pro Tabellenzeile belastet werden, können Sie die Ergebnisse materialisieren. Tun Sie dies in den relevanten Zeilen. Beispielsweise werden die Notizen des Klinikers aktualisiert, sodass nur Personen auf Französisch (fr) die Stimmungserkennungsfunktion verwenden.

UPDATE clinician_notes
SET sentiment = (aws_comprehend.detect_sentiment (french_notes, 'fr')).sentiment,
    confidence = (aws_comprehend.detect_sentiment (french_notes, 'fr')).confidence
WHERE
    clinician_notes.french_notes IS NOT NULL AND
    LENGTH(TRIM(clinician_notes.french_notes)) > 0 AND
    clinician_notes.sentiment IS NULL;

Weitere Informationen zur Optimierung Ihrer Funktionsaufrufe finden Sie unter Leistungsaspekte zur Verwendung von Aurora Machine Learning mit Aurora PostgreSQL.

Verwendung SageMaker mit Ihrem Aurora PostgreSQL-DB-Cluster

Nachdem Sie Ihre SageMaker Umgebung eingerichtet und wie unter beschrieben in Aurora PostgreSQL integriert habenAurora PostgreSQL für die Nutzung von Amazon einrichten SageMaker , können Sie mithilfe der Funktion Operationen aufrufen. aws_sagemaker.invoke_endpoint Die aws_sagemaker.invoke_endpoint-Funktion stellt nur eine Verbindung mit einem Modellendpunkt in derselben AWS-Region her. Wenn Ihre Datenbank-Instance über mehrere Replikate verfügt, stellen Sie AWS-Regionen sicher, dass Sie jedes Modell einrichten und für jedes SageMaker Modell bereitstellen. AWS-Region

Aufrufe von aws_sagemaker.invoke_endpoint werden mithilfe der IAM-Rolle authentifiziert, die Sie eingerichtet haben, um Ihren Aurora PostgreSQL-DB-Cluster mit dem SageMaker Service und dem Endpunkt zu verknüpfen, den Sie während des Einrichtungsvorgangs angegeben haben. SageMaker Modellendpunkte sind auf ein einzelnes Konto beschränkt und nicht öffentlich. Die endpoint_name URL enthält nicht die Konto-ID. SageMaker bestimmt die Konto-ID anhand des Authentifizierungstoken, das von der SageMaker IAM-Rolle der Datenbankinstanz bereitgestellt wird.

aws_sagemaker.invoke_endpoint

Diese Funktion verwendet den SageMaker Endpunkt als Eingabe und die Anzahl der Zeilen, die als Batch verarbeitet werden sollen. Sie verwendet auch die verschiedenen Parameter, die vom SageMaker Modellendpunkt erwartet werden, als Eingabe. Die Referenzdokumentation dieser Funktion lautet wie folgt.

aws_sagemaker.invoke_endpoint(
  IN endpoint_name varchar,   
  IN max_rows_per_batch int,
  VARIADIC model_input "any",
  OUT model_output varchar  
  )

Die Ein- und Ausgaben dieser Funktion sind wie folgt.

• endpoint_name— Eine Endpunkt-URL, die AWS-Region—unabhängig ist.

• max_rows_per_batch – Die maximale Anzahl von Zeilen pro Batch für die Verarbeitung im Batch-Modus. Weitere Informationen finden Sie unter Grundlagen zum Batch-Modus und zu den Aurora-Funktionen für Machine Learning.

• model_input – Ein oder mehrere Eingabeparameter für das Modell. Dabei kann es sich um jeden Datentyp handeln, den das SageMaker Modell benötigt. Mit PostgreSQL können Sie bis zu 100 Eingabeparameter für eine Funktion angeben. Array-Datentypen müssen eindimensional sein, können aber so viele Elemente enthalten, wie vom SageMaker Modell erwartet werden. Die Anzahl der Eingaben in ein SageMaker Modell ist nur durch die Nachrichtengrößenbeschränkung von SageMaker 6 MB begrenzt.

• model_output— Die Ausgabe des SageMaker Modells als Text.

Erstellen einer benutzerdefinierten Funktion zum Aufrufen eines Modells SageMaker

Erstellen Sie eine separate benutzerdefinierte Funktion, die aws_sagemaker.invoke_endpoint für jedes Ihrer Modelle aufgerufen wird. SageMaker Ihre benutzerdefinierte Funktion stellt den SageMaker Endpunkt dar, auf dem das Modell gehostet wird. Die aws_sagemaker.invoke_endpoint-Funktion wird innerhalb der benutzerdefinierten Funktion ausgeführt. Benutzerdefinierte Funktionen bieten viele Vorteile:

• Sie können Ihrem SageMaker Modell einen eigenen Namen geben, anstatt nur alle Ihre SageMaker Modelle aufzurufenaws_sagemaker.invoke_endpoint.

• Sie können die Modellendpunkt-URL an nur einer Stelle im SQL-Anwendungscode angeben.

• Sie können EXECUTE-Berechtigungen für jede Aurora-Funktion für Machine Learning unabhängig steuern.

• Sie können die Modellein- und Ausgabetypen mit SQL-Typen deklarieren. SQL erzwingt die Anzahl und den Typ der an Ihr SageMaker Modell übergebenen Argumente und führt bei Bedarf eine Typkonvertierung durch. Die Verwendung von SQL-Typen führt auch SQL NULL zu dem entsprechenden Standardwert, der von Ihrem SageMaker Modell erwartet wird.

• Sie können die maximale Stapelgröße reduzieren, wenn Sie die ersten paar Zeilen etwas schneller zurückgeben möchten.

Um eine benutzerdefinierte Funktion anzugeben, verwenden Sie die SQL Data Definition Language (DDL)-Anweisung CREATE FUNCTION. Beim Definieren der Funktion geben Sie Folgendes an:

• Die Eingabeparameter für das Modell.

• Der spezifische SageMaker Endpunkt, der aufgerufen werden soll.

• Den Rückgabetyp.

Die benutzerdefinierte Funktion gibt die vom SageMaker Endpunkt berechnete Inferenz zurück, nachdem das Modell mit den Eingabeparametern ausgeführt wurde. Im folgenden Beispiel wird eine benutzerdefinierte Funktion für ein SageMaker Modell mit zwei Eingabeparametern erstellt.

CREATE FUNCTION classify_event (IN arg1 INT, IN arg2 DATE, OUT category INT)
AS $$
    SELECT aws_sagemaker.invoke_endpoint (
        'sagemaker_model_endpoint_name', NULL,
        arg1, arg2                        -- model inputs are separate arguments
        )::INT                            -- cast the output to INT
$$ LANGUAGE SQL PARALLEL SAFE COST 5000;

Beachten Sie Folgendes:

• Die aws_sagemaker.invoke_endpoint-Funktionseingabe kann ein oder mehrere Parameter eines beliebigen Datentyps sein.

• In diesem Beispiel wird ein INT-Ausgabetyp verwendet. Wenn Sie die Ausgabe von einem varchar-Typ in einen anderen Typ umwandeln, muss sie in einen von PostgreSQL eingebauten skalaren Typ wie INTEGER, REAL, FLOAT oder NUMERIC umgewandelt werden. Weitere Informationen zu diesen Typen finden Sie unter Datentypen in der PostgreSQL-Dokumentation.

• Geben Sie PARALLEL SAFE an, um die parallele Abfrageausführung zu aktivieren. Weitere Informationen finden Sie unter Verbessern von Antwortzeiten durch parallele Abfrageverarbeitung.

• Geben Sie COST 5000 an, um die Kosten für die Ausführung der Funktion zu schätzen. Verwenden Sie eine positive Zahl, welche die geschätzten Ausführungskosten für die Funktion in -Einheiten angib cpu_operator_cost.

Übergabe eines Arrays als Eingabe an ein Modell SageMaker

Die aws_sagemaker.invoke_endpoint-Funktion kann bis zu 100 Eingabeparameter haben, was die Grenze für PostgreSQL-Funktionen ist. Wenn das SageMaker Modell mehr als 100 Parameter desselben Typs benötigt, übergeben Sie die Modellparameter als Array.

Das folgende Beispiel definiert eine Funktion, die ein Array als Eingabe an das SageMaker Regressionsmodell übergibt. Die Ausgabe wird in einen REAL-Wert umgewandelt.

CREATE FUNCTION regression_model (params REAL[], OUT estimate REAL)
AS $$
    SELECT aws_sagemaker.invoke_endpoint (
      'sagemaker_model_endpoint_name',
      NULL,
      params                            
      )::REAL
$$ LANGUAGE SQL PARALLEL SAFE COST 5000;

Angabe der Batchgröße beim Aufrufen eines Modells SageMaker

Im folgenden Beispiel wird eine benutzerdefinierte Funktion für ein SageMaker Modell erstellt, die den Standardwert für die Batchgröße auf NULL setzt. Mit der Funktion können Sie auch eine andere Stapelgröße angeben, wenn Sie sie aufrufen.

CREATE FUNCTION classify_event (
    IN event_type INT, IN event_day DATE, IN amount REAL, -- model inputs
    max_rows_per_batch INT DEFAULT NULL,  -- optional batch size limit
    OUT category INT)                     -- model output
AS $$
    SELECT aws_sagemaker.invoke_endpoint (
        'sagemaker_model_endpoint_name', max_rows_per_batch,
        event_type, event_day, COALESCE(amount, 0.0)
        )::INT              -- casts output to type INT
$$ LANGUAGE SQL PARALLEL SAFE COST 5000;

Beachten Sie Folgendes:

• Verwenden Sie den optionalen max_rows_per_batch-Parameter, um die Anzahl der Zeilen für einen Stapelmodus-Funktionsaufruf zu steuern. Wenn Sie den Wert NULL verwenden, wählt der Abfrageoptimierer automatisch die maximale Stapelgröße aus. Weitere Informationen finden Sie unter Grundlagen zum Batch-Modus und zu den Aurora-Funktionen für Machine Learning.

• Standardmäßig wird die Übergabe von NULL als Parameterwert vor der Übergabe an in eine leere Zeichenfolge übersetzt. SageMaker Für dieses Beispiel haben die Eingaben unterschiedliche Typen.

• Wenn Sie über eine Nicht-Texteingabe oder eine Texteingabe verfügen, die standardmäßig auf einen anderen Wert als eine leere Zeichenfolge gesetzt werden muss, verwenden Sie die COALESCE-Anweisung. Verwenden Sie COALESCE, um NULL in den gewünschten Nullersetzungswert im Aufruf von aws_sagemaker.invoke_endpoint zu übersetzen. Für den amount-Parameter in diesem Beispiel wird ein NULL-Wert in 0,0 konvertiert.

Aufrufen eines SageMaker Modells mit mehreren Ausgaben

Im folgenden Beispiel wird eine benutzerdefinierte Funktion für ein SageMaker Modell erstellt, das mehrere Ausgaben zurückgibt. Ihre Funktion muss die Ausgabe der aws_sagemaker.invoke_endpoint-Funktion in einen entsprechenden Datentyp umwandeln. Beispielsweise können Sie den integrierten PostgreSQL-Punkttyp für (x,y)-Paare oder einen benutzerdefinierten zusammengesetzten Typ verwenden.

Diese benutzerdefinierte Funktion gibt Werte aus einem Modell zurück, das mehrere Ausgaben zurückgibt, indem ein zusammengesetzter Typ für die Ausgaben verwendet wird.

CREATE TYPE company_forecasts AS ( 
    six_month_estimated_return real,
    one_year_bankruptcy_probability float);
CREATE FUNCTION analyze_company (
    IN free_cash_flow NUMERIC(18, 6),
    IN debt NUMERIC(18,6),
    IN max_rows_per_batch INT DEFAULT NULL,
    OUT prediction company_forecasts) 
AS $$
    SELECT (aws_sagemaker.invoke_endpoint('endpt_name',
       max_rows_per_batch,free_cash_flow, debt))::company_forecasts;                                                                                                                  
$$ LANGUAGE SQL PARALLEL SAFE COST 5000;

Verwenden Sie für den zusammengesetzten Typ Felder in der gleichen Reihenfolge wie sie in der Modellausgabe angezeigt werden und wandeln Sie die Ausgabe von aws_sagemaker.invoke_endpoint in den zusammengesetzten Typ um. Der Aufrufer kann die einzelnen Felder entweder nach Namen oder mit der PostgreSQL-".*"-Notation extrahieren.

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

Wir empfehlen Ihnen, sich mit Aurora Machine Learning vertraut zu machen und SageMaker die bereitgestellten Algorithmen und Beispiele zu verwenden, anstatt zu versuchen, Ihre eigenen Modelle zu trainieren. Weitere Informationen finden Sie unter Erste Schritte mit Amazon SageMaker

Um SageMaker Modelle zu trainieren, exportieren Sie Daten in einen Amazon S3 S3-Bucket. Der Amazon S3 S3-Bucket wird verwendet SageMaker, um Ihr Modell vor der Bereitstellung zu trainieren. Sie können Daten aus einem Aurora PostgreSQL-DB-Cluster abfragen und direkt in Textdateien speichern, die in einem Amazon S3-Bucket gespeichert sind. SageMaker Nutzt dann die Daten aus dem Amazon S3 S3-Bucket für das Training. Weitere Informationen zum SageMaker Modelltraining finden Sie unter Modeltraining mit Amazon SageMaker.

Anmerkung

Wenn Sie einen Amazon S3 S3-Bucket für SageMaker Modelltraining oder Batch-Scoring erstellen, verwenden Sie sagemaker den Namen des Amazon S3 S3-Buckets. Weitere Informationen finden Sie unter Spezifizieren eines Amazon S3 S3-Buckets zum Hochladen von Trainingsdatensätzen und Speichern von Ausgabedaten im Amazon SageMaker Developer Guide.

Weitere Informationen zum Exportieren der Daten finden Sie unter Exportieren von Daten aus einem/einer Aurora PostgreSQL-DB-Cluster zu Amazon S3.

Leistungsaspekte zur Verwendung von Aurora Machine Learning mit Aurora PostgreSQL

Amazon Comprehend und die SageMaker Dienste erledigen die meiste 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 PostgreSQL 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 und Aurora PostgreSQL beachten sollten.

Themen

• Grundlagen zum Batch-Modus und zu den Aurora-Funktionen für Machine Learning
• Verbessern von Antwortzeiten durch parallele Abfrageverarbeitung
• Verwenden von materialisierten Ansichten und materialisierten Spalten

Grundlagen zum Batch-Modus und zu den Aurora-Funktionen für Machine Learning

Normalerweise führt PostgreSQL Funktionen zeilenweise aus. Aurora Machine Learning kann diesen Overhead reduzieren, indem die Aufrufe an den externen Aurora-Service für Machine Learning für viele Zeilen in Batches mit einem Ansatz kombiniert werden, der als Ausführung im Batch-Modus bezeichnet wird. Im Batch-Modus empfängt Aurora Machine Learning die Antworten für einen Batch von Eingabezeilen und sendet dann die Antworten eine Zeile nach der anderen an die laufende Abfrage zurück. Diese Optimierung verbessert den Durchsatz Ihrer Aurora-Abfragen, ohne den PostgreSQL-Abfrageoptimierer zu beschränken.

Aurora verwendet automatisch den Stapelmodus, wenn die Funktion aus der SELECT-Liste, einer WHERE-Klausel oder einer HAVING-Klausel referenziert wird. Beachten Sie, dass einfache CASE-Ausdrücke der obersten Ebene für die Ausführung im Stapelmodus geeignet sind. Gesuchte CASE-Ausdrücke der obersten Ebene sind auch für die Ausführung im Stapelmodus berechtigt, vorausgesetzt, die erste WHEN-Klausel ist ein einfaches Prädikat mit einem Stapelmodus-Funktionsaufruf.

Ihre benutzerdefinierte Funktion muss eine LANGUAGE SQL-Funktion sein und sollte PARALLEL SAFE und COST 5000 angeben.

Funktionsmigration von der SELECT-Anweisung zur FROM-Klausel

Normalerweise wird eine aws_ml-Funktion, die für die Ausführung im Stapelmodus berechtigt ist, automatisch von Aurora in die FROM-Klausel migriert.

Die Migration berechtigter Funktionen im Stapelmodus in die FROM-Klausel kann manuell auf Abfrageebene untersucht werden. Dazu verwenden Sie EXPLAIN-Anweisungen (und ANALYZE und VERBOSE) und finden unter jedem im Stapelmodus die "Stapelverarbeitungs"-Informatione Function Scan. Sie können EXPLAIN (mit VERBOSE) auch verwenden, ohne die Abfrage auszuführen. Sie beobachten dann, ob die Aufrufe der Funktion als Function Scan unter einem eingebetteten Loop-Join erscheinen, der nicht in der ursprünglichen Anweisung angegeben wurde.

Im folgenden Beispiel zeigt der eingebettete Loop-Join-Operator im Plan, dass Aurora die anomaly_score-Funktion migriert hat. Sie migrierte diese Funktion von der SELECT-Liste in die FROM-Klausel, wo sie für die Ausführung im Stapelmodus berechtigt ist.

EXPLAIN (VERBOSE, COSTS false) 
SELECT anomaly_score(ts.R.description) from ts.R;
                         QUERY PLAN                          
-------------------------------------------------------------
 Nested Loop
   Output: anomaly_score((r.description)::text)
   ->  Seq Scan on ts.r
         Output: r.id, r.description, r.score
   ->  Function Scan on public.anomaly_score
         Output: anomaly_score.anomaly_score
         Function Call: anomaly_score((r.description)::text)

Um die Ausführung im Stapelmodus zu deaktivieren, setzen Sie den apg_enable_function_migration-Parameter auf false. Dies verhindert die Migration von aws_ml-Funktionen von der SELECT in die FROM-Klausel. Nachfolgend wird gezeigt, wie Sie dies tun.

SET apg_enable_function_migration = false;

Der apg_enable_function_migration-Parameter ist ein GUC-Parameter (Grand Unified Configuration), der von der Aurora PostgreSQL apg_plan_mgmt-Erweiterung für die Abfrageplanverwaltung erkannt wird. Um die Funktionsmigration in einer Sitzung zu deaktivieren, speichern Sie den resultierenden Plan mithilfe der Abfrageplanverwaltung als approved-Plan. Zur Laufzeit erzwingt die Abfrageplanverwaltung den approved-Plan mit seiner apg_enable_function_migration-Einstellung. Diese Erzwingung erfolgt unabhängig von der Einstellung des apg_enable_function_migration-GUC-Parameters. Weitere Informationen finden Sie unter Verwalten von Abfrageausführungsplänen für Aurora PostgreSQL.

Verwenden des max_rows_per_batch-Parameters

Sowohl die aws_comprehend.detect_sentiment- als auch die aws_sagemaker.invoke_endpoint-Funktion verfügen über einen max_rows_per_batch-Parameter. Dieser Parameter gibt die Anzahl der Zeilen an, die an den Aurora-Service für Machine Learning gesendet werden können. Je größer der von Ihrer Funktion verarbeitete Datensatz ist, umso größer kann die Batch-Größe gewählt werden.

Funktionen im Batch-Modus verbessern die Effizienz, indem sie Batches von Zeilen erstellen, welche die Kosten der Aurora Machine Learning-Funktionsaufrufe über eine große Anzahl von Zeilen verteilen. Wenn jedoch eine SELECT-Anweisung aufgrund einer LIMIT-Klausel früh beendet wird, kann der Stapel über mehr Zeilen konstruiert werden, als die Abfrage verwendet. Dieser Ansatz kann zu zusätzlichen Gebühren für Ihr Konto führen. AWS Um die Vorteile der Ausführung im Stapelmodus zu nutzen, aber das Erstellen zu großer Stapel zu vermeiden, verwenden Sie einen kleineren Wert für den max_rows_per_batch-Parameter in Ihren Funktionsaufrufen.

Wenn Sie eine EXPLAIN (VERBOSE, ANALYZE) einer Abfrage ausführen, welche die Ausführung im Stapelmodus verwendet, sehen Sie einen FunctionScan-Operator, der unterhalb eines eingebetteten Loop-Joins ist. Die Anzahl der von EXPLAIN gemeldeten Schleifen entspricht der Angabe, wie oft eine Zeile vom FunctionScan-Operator abgerufen wurde. Wenn eine Anweisung eine LIMIT-Klausel verwendet, ist die Anzahl der Abrufe konsistent. Um die Größe des Stapels zu optimieren, setzen Sie den max_rows_per_batch-Parameter auf diesen Wert. Wenn jedoch die Funktion im Stapelmodus in einem Prädikat in der WHERE-Klausel oder HAVING-Klausel referenziert wird, können Sie die Anzahl der Abrufe wahrscheinlich nicht im Voraus kennen. Verwenden Sie in diesem Fall die Schleifen als Richtlinie und experimentieren Sie mit max_rows_per_batch, um eine Einstellung zu finden, welche die Leistung optimiert.

Überprüfen der Ausführung im Stapelmodus

Um festzustellen, ob eine Funktion im Batch-Modus ausgeführt wurde, verwenden Sie EXPLAIN ANALYZE. Wenn die Ausführung im Stapelmodus verwendet wurde, enthält der Abfrageplan die Informationen in einem Abschnitt "Stapelverarbeitung".

EXPLAIN ANALYZE SELECT user-defined-function();
 Batch Processing: num batches=1 avg/min/max batch size=3333.000/3333.000/3333.000
                                avg/min/max batch call time=146.273/146.273/146.273

In diesem Beispiel gab es 1 Stapel, der 3.333 Zeilen enthielt, deren Verarbeitung 146,273 ms dauerte. Der Abschnitt "Stapelverarbeitung" zeigt Folgendes:

• Wie viele Stapel es für diese Scan-Operation der Funktion gab

• Die durchschnittliche, minimale und maximale Stapelgröße

• Die durchschnittliche, minimale und maximale Stapel-Ausführungszeit

In der Regel ist der letzte Stapel kleiner als der Rest, was häufig zu einer minimalen Stapelgröße führt, die viel kleiner als der Durchschnitt ist.

Um die ersten Zeilen schneller zurückzugeben, setzen Sie den max_rows_per_batch-Parameter auf einen kleineren Wert.

Um die Anzahl der Aufrufe im Stapelmodus an den ML-Service zu reduzieren, wenn Sie ein LIMIT in Ihrer benutzerdefinierten Funktion verwenden, setzen Sie den max_rows_per_batch-Parameter auf einen kleineren Wert.

Verbessern von Antwortzeiten durch parallele Abfrageverarbeitung

Damit Sie möglichst schnell Ergebnisse aus einer großen Anzahl von Zeilen erhalten, können Sie die parallele Abfrageverarbeitung mit der Verarbeitung im Batch-Modus kombinieren. Sie können die parallele Abfrageverarbeitung für SELECT-, CREATE TABLE AS SELECT- und CREATE MATERIALIZED VIEW-Anweisungen verwenden.

Anmerkung

PostgreSQL unterstützt noch keine parallele Abfrage für DML-Anweisungen (Data Manipulation Language).

Die parallele Abfrageverarbeitung erfolgt sowohl innerhalb der Datenbank als auch innerhalb des ML-Services. Die Anzahl der Kerne in der Instance-Klasse der Datenbank begrenzt den Parallelitätsgrad, der während der Abfrageausführung verwendet werden kann. Der Datenbankserver kann einen Ausführungsplan für parallele Abfragen erstellen, der die Aufgabe unter einer Gruppe von parallelen Workern partitioniert. Dann kann jeder dieser Worker Stapelanforderungen erstellen, die Zehntausende von Zeilen enthalten (oder so viele, wie es von jedem Service erlaubt ist).

Die gebündelten Anfragen von allen parallel Workern werden an den SageMaker Endpunkt gesendet. Der Grad der Parallelität, den der Endpunkt unterstützen kann, hängt von der Anzahl und Art der Instances ab, die ihn unterstützen. Für K Grade der Parallelität benötigen Sie eine Datenbank-Instance-Klasse mit mindestens K Kernen. Außerdem müssen Sie den SageMaker Endpunkt für Ihr Modell so konfigurieren, dass er über K Anfangsinstanzen einer ausreichend leistungsstarken Instanzklasse verfügt.

Zur Nutzung der parallelen Abfrageverarbeitung können Sie den parallel_workers-Speicherparameter der Tabelle festlegen, welche die Daten enthält, die Sie übergeben möchten. Sie setzen parallel_workers auf eine Funktion im Stapelmodus wie aws_comprehend.detect_sentiment. Wenn der Optimierer einen parallelen Abfrageplan wählt, können die AWS ML-Dienste sowohl im Batch als auch parallel aufgerufen werden.

Sie können die folgenden Parameter mit der aws_comprehend.detect_sentiment-Funktion verwenden, um einen Plan mit 4-Wege-Parallelität zu erhalten. Wenn Sie einen der beiden folgenden Parameter ändern, müssen Sie die Datenbank-Instance neu starten, damit die Änderungen wirksam werden.

-- SET max_worker_processes to 8;  -- default value is 8
-- SET max_parallel_workers to 8;  -- not greater than max_worker_processes
SET max_parallel_workers_per_gather to 4;  -- not greater than max_parallel_workers

-- You can set the parallel_workers storage parameter on the table that the data
-- for the Aurora machine learning function is coming from in order to manually override the degree of
-- parallelism that would otherwise be chosen by the query optimizer
--
ALTER TABLE yourTable SET (parallel_workers = 4);

-- Example query to exploit both batch-mode execution and parallel query
EXPLAIN (verbose, analyze, buffers, hashes) 
SELECT aws_comprehend.detect_sentiment(description, 'en')).*
FROM yourTable
WHERE id < 100;

Weitere Informationen zum Steuern paralleler Abfragen finden Sie unter Parallele Pläne in der PostgreSQL-Dokumentation.

Verwenden von materialisierten Ansichten und materialisierten Spalten

Wenn Sie einen AWS Service wie SageMaker Amazon Comprehend aus Ihrer Datenbank aufrufen, wird Ihr Konto gemäß der Preispolitik dieses Dienstes belastet. Um die Gebühren für Ihr Konto zu minimieren, können Sie das Ergebnis des Aufrufs des AWS Service in einer materialisierten Spalte materialisieren, sodass der AWS Service nicht mehr als einmal pro Eingabezeile aufgerufen wird. Wenn gewünscht, können Sie eine materializedAt-Zeitstempelspalte hinzufügen, um die Zeit aufzuzeichnen, zu der die Spalten materialisiert wurden.

Die Latenz einer gewöhnlichen einzeiligen INSERT-Anweisung ist in der Regel viel geringer als die Latenz beim Aufrufen einer Funktion im Stapelmodus. Daher können Sie möglicherweise die Latenzanforderungen Ihrer Anwendung nicht erfüllen, wenn Sie die Funktion im Stapelmodus für jede einzeilige INSERT aufrufen, die Ihre Anwendung ausführt. Um das Ergebnis des Aufrufs eines AWS Dienstes in einer materialisierten Spalte zu materialisieren, müssen Hochleistungsanwendungen in der Regel die materialisierten Spalten auffüllen. Dazu geben sie regelmäßig eine UPDATE-Anweisung aus, die gleichzeitig für einen großen Stapel von Zeilen ausgeführt wird.

UPDATE führt eine Sperre auf Zeilenebene durch, die sich auf eine laufende Anwendung auswirken kann. Sie müssen also möglicherweise SELECT ... FOR UPDATE SKIP LOCKED oder MATERIALIZED VIEW verwenden.

Analyseabfragen, die mit einer großen Anzahl von Zeilen in Echtzeit arbeiten, können die Materialisierung im Batch-Modus mit der Echtzeitverarbeitung kombinieren. Dazu fügen diese Abfragen eine UNION ALL der vormaterialisierten Ergebnisse mit einer Abfrage über die Zeilen zusammen, die noch keine materialisierten Ergebnisse haben. In einigen Fällen wird eine solche UNION ALL an mehreren Stellen benötigt oder die Abfrage wird von einer Drittanbieteranwendung generiert. Wenn ja, können Sie eine VIEW erstellen, um die UNION ALL-Operation zu kapseln, damit dieses Detail nicht für den Rest der SQL-Anwendung verfügbar gemacht wird.

Sie können eine materialisierte Ansicht verwenden, um die Ergebnisse einer beliebigen SELECT-Anweisung rechtzeitig zu einem Snapshot zu materialisieren. Sie können sie auch verwenden, um die materialisierte Ansicht jederzeit in der Zukunft zu aktualisieren. Derzeit unterstützt PostgreSQL keine inkrementelle Aktualisierung, so dass jedes Mal, wenn die materialisierte Ansicht aktualisiert wird, die materialisierte Ansicht vollständig neu berechnet wird.

Sie können materialisierte Ansichten mit der CONCURRENTLY-Option aktualisieren, die den Inhalt der materialisierten Ansicht aktualisiert, ohne eine exklusive Sperre durchzuführen. Dadurch kann eine SQL-Anwendung aus der materialisierten Ansicht lesen, während sie aktualisiert wird.

Überwachung von Aurora Machine Learning

Sie können die aws_ml-Funktionen überwachen, indem Sie den track_functions-Parameter in Ihrer benutzerdefinierten DB-Cluster-Parametergruppe auf all festlegen. Standardmäßig ist dieser Parameter auf pl eingestellt, was bedeutet, dass nur „procedure-language“-Funktionen verfolgt werden. Wenn Sie diese Einstellung in all ändern, werden auch die aws_ml-Funktionen verfolgt. Weitere Informationen finden Sie unter Laufzeitstatistik in der PostgreSQL-Dokumentation.

Informationen zur Überwachung der Leistung von SageMaker Vorgängen, die von Aurora-Funktionen für maschinelles Lernen aufgerufen werden, finden Sie unter Monitor Amazon SageMaker im Amazon SageMaker Developer Guide.

Wenn track_functions auf all festgelegt ist, können Sie die pg_stat_user_functions-Ansicht abfragen, um Statistiken über die Funktionen zu erhalten, die Sie definieren und zum Aufrufen von Aurora-Services für Machine Learning verwenden. Die Ansicht gibt die Anzahl der calls, total_time und self_time für jede Funktion an.

Wenn Sie die Statistiken für die aws_sagemaker.invoke_endpoint- und aws_comprehend.detect_sentiment-Funktionen anzeigen möchten, können Sie die Ergebnisse mit der folgenden Abfrage nach Schemanamen filtern.

SELECT * FROM pg_stat_user_functions 
    WHERE schemaname 
    LIKE 'aws_%';

Gehen Sie wie folgt vor, um die Statistiken zu löschen.

SELECT pg_stat_reset();

Sie können die Namen Ihrer SQL-Funktionen, die die aws_sagemaker.invoke_endpoint-Funktion aufrufen, abrufen, indem Sie den pg_proc-Systemkatalog von PostgreSQL abfragen. Dieser Katalog speichert Informationen zu Funktionen, Prozeduren und mehr. Weitere Informationen finden Sie unter pg_proc in der PostgreSQL-Dokumentation. Das folgende Beispiel veranschaulicht das Abfragen der Tabelle, um die Namen von Funktionen (proname) zu erhalten, deren Quelle (prosrc) den Text invoke_endpoint enthält.

SELECT proname FROM pg_proc WHERE prosrc LIKE '%invoke_endpoint%';