Utilizzo di machine learning di Amazon Aurora con Aurora MySQL

L’utilizzo del machine learning di Amazon Aurora con il cluster di database Aurora MySQL, consente di utilizzare Amazon Bedrock, Amazon Comprehend o Amazon SageMaker AI, a seconda delle esigenze. Ciascuno di essi supporta casi d’uso di machine learning diversi.

Requisiti per l'utilizzo di machine learning di Aurora con Aurora MySQL

I servizi di machine learning di AWS sono servizi gestiti che vengono impostati ed eseguiti negli ambienti di produzione. Il machine learning di Aurora supporta l’integrazione con Amazon Bedrock, Amazon Comprehend e SageMaker AI. Prima di provare a configurare il cluster database Aurora MySQL per utilizzare il machine learning di Aurora, occorre accertarsi di aver compreso i requisiti e prerequisiti riportati di seguito.

Disponibilità di regioni e versioni

La disponibilità e il supporto della funzionalità varia tra le versioni specifiche di ciascun motore di database Aurora e tra Regioni AWS.

Funzionalità supportate e limitazioni del machine learning di Aurora con Aurora MySQL

Quando utilizzi Aurora MySQL con il machine learning di Aurora, si applicano le seguenti limitazioni:

Configurazione del cluster database Aurora per utilizzare machine learning di Aurora

Nei seguenti argomenti sono illustrate le procedure di configurazione separate per ciascuno di questi servizi di machine learning di Aurora.

Configurazione del cluster di database Aurora MySQL per utilizzare Amazon Bedrock

Il machine learning di Aurora si basa su policy e ruoli (IAM) AWS Identity and Access Management per consentire al cluster di database Aurora MySQL di accedere ai servizi Amazon Bedrock e utilizzarli. Le seguenti procedure creano un ruolo e una policy di autorizzazione IAM per consentire al cluster di database di integrarsi con Amazon Bedrock.

A questo punto, crea il ruolo IAM che utilizza la policy di autorizzazione di Amazon Bedrock.

Associa quindi il ruolo IAM Amazon Bedrock al cluster di database.

È necessario impostare l’ARN di questo ruolo IAM sul parametro aws_default_bedrock_role del parametro del cluster di database personalizzato associato al cluster di database Aurora MySQL. Se il cluster database Aurora MySQL non utilizza un gruppo di parametri cluster database personalizzato, è necessario crearne uno da utilizzare con il cluster database Aurora MySQL per completare l'integrazione. Per ulteriori informazioni, consulta Gruppi di parametri del cluster di database per i cluster di database Amazon Aurora.

L’integrazione con IAM per Amazon Bedrock è stata completata. Continua a configurare il cluster di database Aurora MySQL in modo che funzioni con Amazon Bedrock in base ai Concessione agli utenti del database dell'accesso a machine learning di Aurora.

Configurazione del cluster database Aurora MySQL per utilizzare Amazon Comprehend

Machine learning di Aurora si basa su ruoli e policy AWS Identity and Access Management per consentire al cluster database Aurora MySQL di accedere e utilizzare i servizi Amazon Comprehend. La seguente procedura crea automaticamente un ruolo e una policy IAM per il cluster in modo che possa utilizzare Amazon Comprehend.

L'integrazione con IAM per Amazon Comprehend è stata completata. Continua a configurare il cluster database Aurora MySQL per funzionare con Amazon Comprehend concedendo l'accesso agli utenti del database appropriati.

Configurazione del cluster di database Aurora MySQL per utilizzare SageMaker AI

La seguente procedura crea automaticamente la policy e il ruolo IAM per il cluster di database Aurora MySQL in modo da poter utilizzare SageMaker AI. Prima di provare a seguire questa procedura, occorre assicurarsi che l’endpoint SageMaker AI sia disponibile, in modo da poterlo inserire quando necessario. In genere, i data scientist del team eseguono il lavoro per produrre un endpoint che è possibile utilizzare dal cluster database Aurora MySQL. Tali endpoint sono disponibili nella console SageMaker AI. Nel riquadro di navigazione, apri il menu Inferenza e scegli Endpoint. Nell'immagine seguente, è disponibile un esempio.

La configurazione di IAM è ora completata. Continua a configurare il cluster di database Aurora MySQL in modo che funzioni con SageMaker AI concedendo l’accesso agli utenti del database appropriati.

Se per l’addestramento desideri utilizzare i tuoi modelli SageMaker AI anziché i componenti predefiniti di SageMaker AI, devi aggiungere al cluster di database Aurora MySQL anche il bucket Amazon S3, come descritto nella sezione Configurazione del cluster di database Aurora MySQL per utilizzare Amazon S3 for SageMaker AI (facoltativo) di seguito.

Configurazione del cluster di database Aurora MySQL per utilizzare Amazon S3 for SageMaker AI (facoltativo)

Per utilizzare SageMaker AI con i tuoi modelli anziché utilizzare i componenti predefiniti forniti da SageMaker AI, devi configurare un bucket Amazon S3 per il cluster di database Aurora MySQL da utilizzare. Per ulteriori informazioni sulla creazione di un bucket Amazon S3, consultaCreazione di un bucketnellaGuida all'utente di Amazon Simple Storage Service.

Per ulteriori informazioni sull’utilizzo di bucket Amazon S3 con SageMaker AI, consulta Specify an Amazon S3 Bucket to Upload Training Datasets and Store Output Data nella Guida per gli sviluppatori di Amazon SageMaker AI. Per ulteriori informazioni su come utilizzare SageMaker AI, consulta Get Started with Amazon SageMaker AI Notebook Instances nella Guida per gli sviluppatori di Amazon SageMaker AI.

Concessione agli utenti del database dell'accesso a machine learning di Aurora

Per invocare le funzioni di machine learning di Aurora, gli utenti del database devono disporre dell’autorizzazione appropriata. Il modo in cui l'autorizzazione viene concessa dipende dalla versione di MySQL utilizzata per il cluster database Aurora MySQL, come descritto di seguito. L'operazione utilizzata dipende dalla versione di MySQL utilizzata dal cluster database Aurora MySQL.

Nella tabella seguente sono raffigurati i ruoli e i privilegi necessari agli utenti del database per utilizzare le funzioni di machine learning.

Concessione dell’accesso alle funzioni di Amazon Bedrock

Per fornire agli utenti del database l’accesso alle funzioni di Amazon Bedrock, utilizza la seguente istruzione SQL:

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

Per utilizzare Amazon Bedrock, gli utenti del database devono inoltre disporre di autorizzazioni EXECUTE per le funzioni che hai creato.

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

Infine, i ruoli degli utenti del database devono essere impostati su AWS_BEDROCK_ACCESS:

SET ROLE AWS_BEDROCK_ACCESS;

Le funzioni di Amazon Bedrock sono ora disponibili per l’uso.

Concessione dell'accesso alle funzioni Amazon Comprehend

Per fornire agli utenti del database l'accesso alle funzioni di Amazon Comprehend, utilizza l'istruzione appropriata per la versione di Aurora MySQL.

Le funzioni di Amazon Comprehend sono ora disponibili per l'uso. Per esempi di utilizzo, consultare Utilizzo di Amazon Comprehend con il cluster database Aurora MySQL.

Concessione dell’accesso alle funzioni di SageMaker AI

Per fornire agli utenti del database l’accesso alle funzioni di SageMaker AI, utilizza l’istruzione appropriata per la versione di Aurora MySQL.

Per utilizzare SageMaker AI, gli utenti del database devono inoltre disporre di autorizzazioni EXECUTE per le funzioni che hai creato. Supponi di aver creato due funzioni, db1.anomoly_score e db2.company_forecasts, per invocare i servizi del tuo endpoint SageMaker AI. Concedi i privilegi di esecuzione come illustrato nel seguente esempio.

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;

Le funzioni di SageMaker AI sono ora disponibili per l’uso. Per esempi di utilizzo, consultare Utilizzo di SageMaker AI con il cluster di database Aurora MySQL.

Utilizzo di Amazon Bedrock con il cluster di database Aurora MySQL

Per utilizzare Amazon Bedrock, crea nel database Aurora MySQL una funzione definita dall’utente (UDF) che invochi un modello. Per ulteriori informazioni, consulta Modelli supportati in Amazon Bedrock nella Guida per l’utente di Amazon Bedrock.

Le UDF utilizzano la sintassi seguente:

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

Ad esempio, la seguente UDF invoca il modello Amazon Titan Text Express:

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

Per consentire a un utente del database di utilizzare questa funzione, ricorri al seguente comando SQL:

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

Quindi l’utente può chiamare invoke_titan come qualsiasi altra funzione, come mostrato nell’esempio seguente. Assicurati di formattare il corpo della richiesta in base ai modelli di testo di Amazon Titan.

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

Per gli altri modelli che utilizzi, assicurati di formattare il corpo della richiesta in modo appropriato. Per ulteriori informazioni, consulta Parametri di inferenza per modelli di fondazione nella Guida per l’utente di Amazon Bedrock.

Utilizzo di Amazon Comprehend con il cluster database Aurora MySQL

Per Aurora MySQL, il machine learning di Aurora fornisce le due funzioni integrate seguenti per l'utilizzo con Amazon Comprehend e i dati di testo. Viene fornito il testo da analizzare (input_data) e specificata la lingua (language_code).

In entrambe le funzioni (aws_comprehend_detect_sentiment_confidence, aws_comprehend_detect_sentiment) il parametro max_batch_size utilizza un valore predefinito pari a 25, se uno non è stato specificato. La dimensione del batch deve essere sempre maggiore di zero. max_batch_size può essere utilizzato per ottimizzare le prestazioni delle chiamate di funzione Amazon Comprehend. Un batch di grandi dimensioni ha prestazioni più veloci con un maggiore utilizzo della memoria nel cluster database Aurora MySQL. Per ulteriori informazioni, consulta Considerazioni sulle prestazioni per l'utilizzo del machine learning di Aurora con Aurora MySQL.

Per informazioni sui parametri e sui tipi restituiti per le funzioni di rilevamento del sentiment in Amazon Comprehend, consultare 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;

Utilizzo di SageMaker AI con il cluster di database Aurora MySQL

Per utilizzare la funzionalità SageMaker AI dal cluster di database Aurora MySQL, è necessario creare funzioni archiviate che incorporano le chiamate all’endpoint SageMaker AI e alle relative funzionalità di inferenza. Per eseguire questa operazione, si utilizza CREATE FUNCTION di MySQL esattamente come in altre attività di elaborazione sul cluster database Aurora MySQL.

Per utilizzare i modelli implementati in SageMaker AI per l’inferenza, è necessario creare funzioni definite dall’utente utilizzando le dichiarazioni Data Definition Language (DDL) MySQL per le funzioni archiviate. Ogni funzione archiviata rappresenta l’endpoint SageMaker AI che ospita il modello. Quando definisci tale funzione, indichi i parametri di input per il modello, lo specifico endpoint SageMaker AI da invocare e il tipo restituito. La funzione restituisce l’inferenza calcolata dall’endpoint SageMaker AI dopo l’applicazione del modello sui parametri di input.

Tutte le funzioni archiviate Aurora Machine Learning restituiscono tipi numerici o VARCHAR. È possibile utilizzare qualsiasi tipo numerico tranne BIT. Altri tipi, ad esempio JSON, BLOB, TEXT e DATE non sono consentiti.

Nell’esempio seguente viene mostrata la sintassi CREATE FUNCTION per utilizzare SageMaker AI.

CREATE FUNCTION function_name (
     arg1 type1, 
     arg2 type2, ...)
     [DEFINER = user]
  RETURNS mysql_type
  [SQL SECURITY { DEFINER | INVOKER } ]
  ALIAS AWS_SAGEMAKER_INVOKE_ENDPOINT
  ENDPOINT NAME 'endpoint_name'
  [MAX_BATCH_SIZE max_batch_size];

Questa è un'estensione della normale istruzione DDL CREATE FUNCTION. Nella dichiarazione CREATE FUNCTION che definisce la funzione di SageMaker AI, non specificare un corpo della funzione. Specifica invece la parola chiave ALIAS al posto del corpo della funzione. Attualmente, Aurora Machine Learning supporta solo aws_sagemaker_invoke_endpoint per questa sintassi estesa. È necessario specificare il parametro endpoint_name. Un endpoint SageMaker AI può avere caratteristiche diverse per ciascun modello.

Il parametro max_batch_size è facoltativo. Per impostazione predefinita, la dimensione batch massima è 10.000. Questo parametro può essere utilizzato nella funzione per limitare il numero massimo di input elaborati in una richiesta batch a SageMaker AI. Il parametro max_batch_size può contribuire a evitare un errore causato da input troppo grandi o a velocizzare la risposta di SageMaker AI. Questo parametro influisce sulla dimensione di un buffer interno utilizzato per l’elaborazione della richiesta SageMaker AI. Se specifichi un valore troppo grande per max_batch_size, è possibile che si verifichi un notevole sovraccarico di memoria nell'istanza database.

Ti consigliamo di lasciare l'impostazione MANIFEST sul valore predefinito OFF. Sebbene sia possibile utilizzare l’opzione MANIFEST ON, alcune funzionalità di SageMaker AI non possono utilizzare direttamente il CSV esportato con questa opzione. Il formato manifest non è compatibile con il formato manifest previsto da SageMaker AI.

Crea una funzione archiviata separata per ciascuno dei tuoi modelli SageMaker AI. Questa mappatura delle funzioni sui modelli è necessaria perché un endpoint è associato a un modello specifico e ciascun modello accetta parametri diversi. L'uso dei tipi SQL per gli input del modello e il tipo di output del modello consente di evitare errori di conversione dei tipi che passano i dati avanti e indietro tra i servizi AWS. È possibile controllare chi può applicare il modello. È inoltre possibile controllare le caratteristiche di runtime specificando un parametro che rappresenta la dimensione massima del batch.

Attualmente tutte le funzioni Aurora Machine Learning hanno la proprietà NOT DETERMINISTIC. Se non specifichi la proprietà esplicitamente, Aurora imposta NOT DETERMINISTIC automaticamente. Questo requisito è dovuto al fatto che il modello SageMaker AI può essere modificato senza alcuna notifica al database. In tal caso, le chiamate a una funzione Aurora Machine Learning potrebbero restituire risultati diversi per lo stesso input all'interno di una singola transazione.

Non puoi usare le caratteristiche CONTAINS SQL, NO SQL, READS SQL DATA o MODIFIES SQL DATA nell'istruzione CREATE FUNCTION.

Di seguito è riportato un esempio di come invocare un endpoint SageMaker AI per rilevare eventuali anomalie. È presente un endpoint random-cut-forest-model di SageMaker AI. Il modello corrispondente è già stato addestrato dall'algoritmo random-cut-forest. Per ogni input, il modello restituisce un punteggio di anomalia. Questo esempio mostra i punti dati il cui punteggio è maggiore di 3 deviazioni standard (circa il 99,9 percentile) dal punteggio medio.

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;

Requisito del set di caratteri per le funzioni di SageMaker AI che restituiscono stringhe

È consigliabile specificare un set di caratteri utf8mb4 come tipo restituito per le funzioni SageMaker AI che restituiscono valori stringa. Se non è pratico, utilizza una lunghezza della stringa sufficiente per il tipo restituito per contenere un valore rappresentato nel set di caratteri utf8mb4. L'esempio seguente mostra come dichiarare il set di caratteri utf8mb4 per la tua funzione.

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

Attualmente, ogni funzione di SageMaker AI che restituisce una stringa utilizza il set di caratteri utf8mb4 per il valore restituito. Il valore restituito utilizza questo set di caratteri anche se la funzione di SageMaker AI dichiara un set di caratteri diverso per il tipo restituito in modo implicito o esplicito. Se la funzione di SageMaker AI dichiara un set di caratteri diverso per il valore restituito, i dati restituiti archiviati in una colonna della tabella non abbastanza lunga potrebbero essere troncati senza alcun avviso. Ad esempio, una query con una clausola DISTINCT crea una tabella temporanea. Pertanto, il risultato della funzione SageMaker AI potrebbe essere troncato a causa del modo in cui le stringhe vengono gestite internamente durante la query.

Esportazione dei dati in Amazon S3 per l’addestramento dei modelli SageMaker AI (avanzato)

Ti consigliamo di iniziare a utilizzare il machine learning di Aurora e SageMaker AI partendo da alcuni degli algoritmi forniti e dagli endpoint SageMaker AI forniti dai data scientist del tuo team che puoi utilizzare con il tuo codice SQL. Di seguito, sono disponibili le informazioni minime relative all’utilizzo del bucket Amazon S3 con i tuoi modelli SageMaker AI e il cluster di database Aurora MySQL.

La funzione machine learning comprende due fasi principali: training e inferenza. Per eseguire l’addestramento dei modelli SageMaker AI, esporta i dati in un bucket Amazon S3. Il bucket Amazon S3 viene utilizzato da un’istanza notebook Jupyter SageMaker AI per eseguire l’addestramento del modello prima della relativa implementazione. Puoi usare l'istruzione SELECT INTO OUTFILE S3 per eseguire una query sui dati da un cluster di database Aurora MySQL e salvarlo direttamente nei file di testo archiviati in un bucket Simple Storage Service (Amazon S3). Quindi, l'istanza notebook utilizza i dati dal bucket Simple Storage Service (Amazon S3) per il training.

Aurora Machine Learning estende la sintassi SELECT INTO OUTFILE esistente in Aurora MySQL per esportare i dati in formato CSV. Il file CSV generato può essere utilizzato direttamente dai modelli che necessitano di questo formato per il training.

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

L'estensione supporta il formato CSV standard.

La sintassi estesa e la grammatica di SELECT INTO ora sono le seguenti:

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

Considerazioni sulle prestazioni per l'utilizzo del machine learning di Aurora con Aurora MySQL

I servizi Amazon Bedrock, Amazon Comprehend e SageMaker AI svolgono la maggior parte del lavoro quando vengono invocati da una funzione di machine learning di Aurora. Ciò significa che è possibile dimensionare tali risorse in base alle esigenze, in modo indipendente. Per il cluster database Aurora MySQL, è possibile rendere le chiamate di funzione il più efficienti possibile. Di seguito sono riportate alcune considerazioni sulle prestazioni da tenere presenti quando si utilizza machine learning di Aurora.

Modello e prompt

Quando utilizzi Amazon Bedrock, le prestazioni dipendono in larga misura dal modello e dal prompt in uso. Scegli un modello e un prompt ottimali per il tuo caso d’uso.

Cache delle query

La cache delle query di Aurora MySQL non funziona per le funzioni di machine learning di Aurora. Aurora MySQL non archivia i risultati della query nella cache delle query per le istruzioni SQL che richiamano le funzioni di machine learning di Aurora.

Ottimizzazione batch per le chiamate di funzione Aurora Machine Learning

L'aspetto principale delle prestazioni Aurora Machine Learning che è possibile applicare dal cluster Aurora è l'impostazione della modalità batch per le chiamate alle funzioni archiviate Aurora Machine Learning. Le funzioni di machine learning in genere richiedono un sovraccarico considerevole, rendendo impossibile chiamare separatamente un servizio esterno per ogni riga. Il machine learning di Aurora può ridurre al minimo questo sovraccarico combinando le chiamate al servizio di machine learning Aurora esterno per molte righe in un singolo batch. Il machine learning di Aurora riceve le risposte per un batch di righe di input e quindi restituisce le risposte alla query in esecuzione una riga alla volta. Questa ottimizzazione migliora la velocità effettiva e la latenza delle query Aurora senza modificare i risultati.

Quando crei una funzione Aurora archiviata connessa a un endpoint SageMaker AI, definisci il parametro della dimensione del batch. Questo parametro influisce sul numero di righe trasferite per ogni chiamata sottostante a SageMaker AI. In caso di query che elaborano un numero elevato di righe, il sovraccarico legato all’esecuzione di una chiamata SageMaker AI separata per ogni riga può essere sostanziale. Maggiore è il set di dati elaborato dalla stored procedure, maggiore è la dimensione del batch.

È possibile verificare se l’ottimizzazione della modalità batch è applicabile a una funzione di SageMaker AI controllando il piano di query prodotto dall’istruzione EXPLAIN PLAN. In questo caso, la colonna extra nel piano di esecuzione include Batched machine learning. Nell’esempio seguente viene mostrata una chiamata a una funzione SageMaker AI che utilizza la modalità batch.

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)

Quando si chiama una delle funzioni Amazon Comprehend integrate, è possibile controllare la dimensione del batch specificando il parametro facoltativo max_batch_size che limita il numero massimo di valori input_text elaborati in ogni batch. L'invio di più elementi contemporaneamente riduce il numero di passaggi tra Aurora e Amazon Comprehend. Limitare la dimensione del batch è utile in situazioni come le query con una clausola LIMIT. Utilizzando un valore basso per max_batch_size, puoi evitare di invocare Amazon Comprehend più volte di quanti sono i testi di input.

L'ottimizzazione batch per la valutazione delle funzioni Aurora Machine Learning si applica nei seguenti casi:

Monitoraggio del machine learning di Aurora

Per monitorare le operazioni batch di machine learning di Aurora, puoi eseguire query su diverse variabili globali, come illustrato nell’esempio seguente.

show status like 'Aurora_ml%';

Lo stato di queste variabili può essere ripristinato utilizzando un'istruzione FLUSH STATUS. Pertanto, tutte le cifre rappresentano i totali, le medie e così via, dall'ultima volta che la variabile è stata ripristinata.

Per informazioni sul monitoraggio delle prestazioni delle operazioni SageMaker AI chiamate dalle funzioni di machine learning di Aurora, consulta Monitor Amazon SageMaker AI.