Verwenden von Amazon Aurora Machine Learning mit Aurora Postgre SQL

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

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

Anforderungen für die Verwendung von Aurora Machine Learning mit Aurora Postgre SQL

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

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

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

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

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

Damit Aurora Machine Learning mit Ihrem Aurora SQL Postgre-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 Aurora SQL Postgre-DB-Cluster, den Aurora-Service für maschinelles Lernen 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.

Aurora Postgre SQL für die Verwendung von Amazon Bedrock einrichten

Im folgenden Verfahren erstellen Sie zunächst die IAM Rolle und die Richtlinie, die Ihrem Aurora Postgre die SQL Erlaubnis geben, Amazon Bedrock im Namen des Clusters zu verwenden. Anschließend fügen Sie die Richtlinie einer IAM Rolle hinzu, die Ihr Aurora SQL Postgre-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.

Die Rolle (mit ihrer Richtlinie) ist dem Aurora SQL Postgre-DB-Cluster zugeordnet. Wenn der Vorgang abgeschlossen ist, wird die Rolle in der Liste Aktuelle IAM Rollen für diesen Cluster aufgeführt, wie im Folgenden dargestellt.

Die IAM Einrichtung für Amazon Bedrock ist abgeschlossen. Richten Sie Aurora Postgre weiter für SQL die Arbeit mit Aurora Machine Learning ein, indem Sie die Erweiterung installieren, wie unter beschrieben Installieren der Aurora-Erweiterung für Machine Learning

Aurora Postgre für die Verwendung von Amazon SQL Comprehend einrichten

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

Die Rolle (mit ihrer Richtlinie) ist dem Aurora SQL Postgre-DB-Cluster zugeordnet. Wenn der Vorgang abgeschlossen ist, wird die Rolle in der Liste Aktuelle IAM Rollen für diesen Cluster aufgeführt, wie im Folgenden dargestellt.

Die IAM Einrichtung für Amazon Comprehend ist abgeschlossen. Richten Sie Aurora Postgre weiter für SQL die Arbeit mit Aurora Machine Learning ein, indem Sie die Erweiterung installieren, wie unter beschrieben Installieren der Aurora-Erweiterung für Machine Learning

Aurora Postgre für die Nutzung SQL von Amazon SageMaker AI einrichten

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

Die Rolle (mit ihrer Richtlinie) ist dem Aurora SQL Postgre-DB-Cluster zugeordnet. Wenn der Vorgang abgeschlossen ist, wird die Rolle in der Liste Aktuelle IAM Rollen für diesen Cluster aufgeführt.

Das IAM Setup für SageMaker KI ist abgeschlossen. Richten Sie Aurora Postgre weiter für SQL die Arbeit mit Aurora Machine Learning ein, indem Sie die Erweiterung installieren, wie unter beschriebenInstallieren der Aurora-Erweiterung für Machine Learning.

Einrichtung von Aurora Postgre für SQL die Verwendung von Amazon S3 für SageMaker KI (Fortgeschritten)

Um SageMaker KI mit Ihren eigenen Modellen zu verwenden, anstatt die von SageMaker AI bereitgestellten vorgefertigten Komponenten zu verwenden, müssen Sie einen Amazon Simple Storage Service (Amazon S3) -Bucket einrichten, den der Aurora SQL Postgre-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 SageMaker KI-Unterstützung, und zwar wie folgt.

Grundlegende Informationen zur Nutzung finden Sie unter Exportieren von Daten nach Amazon S3 für das SageMaker KI-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 AI-Services, aufrufen können, und aws_ml 2.0 bieten zwei zusätzliche Funktionen, mit denen Sie Amazon Bedrock-Dienste aufrufen können. Durch die Installation dieser Erweiterungen auf Ihrem Aurora SQL Postgre-DB-Cluster wird auch eine Administratorrolle für die Funktion erstellt.

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 drei neue Schemas wie folgt erstellt.

Der rds_superuser Rolle wird die aws_ml administrative Rolle zugewiesen und besteht aus diesen drei Aurora-Schemas für maschinelles Lernen. OWNER 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 Postgre-DB-Cluster SQL

Für Aurora Postgre SQL 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 Einrichtung Ihres Aurora SQL Postgre-DB-Clusters für die Nutzung von Aurora Machine Learning.

Die Ein- und Ausgaben dieser Funktion sind wie folgt.

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

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":[]}'
);

Die Ein- und Ausgaben dieser Funktion sind wie folgt.

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

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 Aurora SQL Postgre-DB-Cluster

Für Aurora Postgre SQL bietet Aurora Machine Learning die folgende Amazon Comprehend 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 Einrichtung Ihres Aurora SQL Postgre-DB-Clusters für die Nutzung von Aurora Machine Learning.

Die Ein- und Ausgaben dieser Funktion sind wie folgt.

Nachstehend finden Sie Beispiele zur Verwendung dieser Funktion.

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 Überlegungen zur Leistung bei der Verwendung von Aurora Machine Learning mit Aurora Postgre SQL.

SageMaker KI mit Ihrem Aurora SQL Postgre-DB-Cluster verwenden

Nachdem Sie Ihre SageMaker KI-Umgebung eingerichtet und SQL wie unter beschrieben in Aurora Postgre integriert habenAurora Postgre für die Nutzung SQL von Amazon SageMaker AI einrichten , können Sie mithilfe der aws_sagemaker.invoke_endpoint Funktion Operationen aufrufen. 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 SageMaker KI-Modell einrichten und für alle bereitstellen. AWS-Region

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

Die Ein- und Ausgaben dieser Funktion sind wie folgt.

Erstellen einer benutzerdefinierten Funktion zum Aufrufen eines KI-Modells SageMaker

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

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

Die benutzerdefinierte Funktion gibt die vom SageMaker KI-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 KI-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:

Übergabe eines Arrays als Eingabe an ein SageMaker KI-Modell

Die aws_sagemaker.invoke_endpoint Funktion kann bis zu 100 Eingabeparameter haben. Dies ist die Grenze für SQL Postgre-Funktionen. Wenn das SageMaker KI-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 KI-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 KI-Modells SageMaker

Im folgenden Beispiel wird eine benutzerdefinierte Funktion für ein SageMaker KI-Modell erstellt, die die Batchgröße standardmäßig auf festlegt. NULL 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:

Aufrufen eines SageMaker KI-Modells mit mehreren Ausgaben

Das folgende Beispiel erstellt eine benutzerdefinierte Funktion für ein SageMaker KI-Modell, das mehrere Ausgaben zurückgibt. Ihre Funktion muss die Ausgabe der aws_sagemaker.invoke_endpoint-Funktion in einen entsprechenden Datentyp umwandeln. Sie könnten beispielsweise den integrierten SQL Postgre-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 Postgre-Notation SQL „.*“ extrahieren.

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

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

Um SageMaker KI-Modelle zu trainieren, exportieren Sie Daten in einen Amazon S3 S3-Bucket. Der Amazon S3 S3-Bucket wird von SageMaker KI verwendet, um Ihr Modell vor der Bereitstellung zu trainieren. Sie können Daten aus einem Aurora SQL Postgre-DB-Cluster abfragen und sie direkt in Textdateien speichern, die in einem Amazon S3 S3-Bucket gespeichert sind. Dann SageMaker verwendet KI die Daten aus dem Amazon S3 S3-Bucket für das Training. Weitere Informationen zum Training von SageMaker KI-Modellen finden Sie unter Trainieren eines Modells mit Amazon SageMaker AI.

Weitere Informationen zum Exportieren der Daten finden Sie unter Exportieren von Daten aus einem Aurora SQL Postgre-DB-Cluster RDS S3.

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

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

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

Normalerweise SQL führt Postgre 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 SQL Postgre-Abfrageoptimierer einzuschrä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 Klausel FROM

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 geeigneter Batchmodus-Funktionen zur FROM Klausel kann manuell auf Abfrageebene geprüft werden. Dazu verwenden Sie die EXPLAIN Anweisungen (und undVERBOSE) ANALYZE und finden die Informationen zur „Batch-Verarbeitung“ unter jedem Batch-ModusFunction Scan. Sie können EXPLAIN (withVERBOSE) 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. Es hat diese Funktion aus der SELECT Liste in die FROM Klausel migriert, wo sie für die Ausführung im Batch-Modus geeignet 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. Dadurch wird die Migration von aws_ml Funktionen von der zur Klausel SELECT verhindert. FROM Nachfolgend wird gezeigt, wie Sie dies tun.

SET apg_enable_function_migration = false;

Der apg_enable_function_migration Parameter ist ein Grand Unified Configuration (GUC) -Parameter, der von der Aurora SQL apg_plan_mgmt Postgre-Erweiterung für die Verwaltung von Abfrageplänen 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 Durchsetzung erfolgt unabhängig von der apg_enable_function_migration GUC Parametereinstellung. Weitere Informationen finden Sie unter Verwaltung von Abfrageausführungsplänen für Aurora Postgre SQL.

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 AWS Konto führen. 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:

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.

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 aller parallel Worker werden an den SageMaker KI-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 KI-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 zur Steuerung parallel Abfragen finden Sie unter Parallele Pläne in der SQL Postgre-Dokumentation.

Verwenden von materialisierten Ansichten und materialisierten Spalten

Wenn Sie einen AWS Service wie SageMaker AI oder 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 Dienstes 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. Falls ja, können Sie eine erstellen, um den UNION ALL Vorgang VIEW zu kapseln, sodass dieses Detail nicht für den Rest der Anwendung sichtbar ist. SQL

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 Postgre SQL keine inkrementelle Aktualisierung, sodass 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. Auf diese Weise kann eine SQL Anwendung während der Aktualisierung aus der materialisierten Ansicht lesen.

Ü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 Runtime Statistics in der Postgre-Dokumentation. SQL

Informationen zur Überwachung der Leistung der SageMaker KI-Operationen, die über Aurora-Funktionen für maschinelles Lernen aufgerufen werden, finden Sie unter Monitor Amazon SageMaker AI im Amazon SageMaker AI 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 SQL pg_proc Postgre-Systemkatalog abfragen. Dieser Katalog speichert Informationen zu Funktionen, Prozeduren und mehr. Weitere Informationen finden Sie unter pg_proc in der Postgre-Dokumentation. SQL 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%';