Utilizzo di machine learning di Amazon Aurora con Aurora MySQL

Utilizzando l'apprendimento automatico di Amazon Aurora con il tuo cluster Aurora MySQL DB, puoi usare Amazon Bedrock, Amazon Comprehend o Amazon, a seconda delle tue esigenze. SageMaker Ciascuno di essi supporta diversi casi d'uso dell'apprendimento automatico.

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

AWS i servizi di apprendimento automatico sono servizi gestiti che vengono configurati ed eseguiti nei propri ambienti di produzione. L'apprendimento automatico Aurora supporta l'integrazione con Amazon Bedrock, Amazon Comprehend e. SageMaker 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 si utilizza Aurora MySQL con Aurora Machine Learning, 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 Aurora MySQL DB per utilizzare Amazon Bedrock

L'apprendimento automatico di Aurora si basa su ruoli e policy AWS Identity and Access Management (IAM) per consentire al cluster Aurora MySQL DB di accedere e utilizzare i servizi Amazon Bedrock. Le seguenti procedure creano una politica e un ruolo di autorizzazione IAM in modo che il cluster DB possa integrarsi con Amazon Bedrock.

Successivamente crei il ruolo IAM che utilizza la policy di autorizzazione di Amazon Bedrock.

Successivamente associ il ruolo IAM di Amazon Bedrock al tuo cluster DB.

È necessario aggiungere l'ARN di questo ruolo IAM al aws_default_bedrock_role parametro del gruppo di parametri del cluster DB personalizzato associato al cluster Aurora MySQL DB. 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 Utilizzo di gruppi di parametri di cluster di database.

L'integrazione IAM per Amazon Bedrock è completa. Continua a configurare il cluster Aurora MySQL DB per utilizzarlo con Amazon Bedrock by. Concessione agli utenti del database dell'accesso a machine learning di Aurora

Configurazione del cluster database Aurora MySQL per utilizzare Amazon Comprehend

L'apprendimento automatico Aurora si basa su AWS Identity and Access Management ruoli e policy per consentire al cluster Aurora MySQL DB 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 Aurora MySQL DB da utilizzare SageMaker

La procedura seguente crea automaticamente il ruolo e la policy IAM per il cluster Aurora MySQL DB in modo che possa essere utilizzato. SageMaker Prima di provare a seguire questa procedura, assicurati di avere l' SageMaker endpoint 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. È possibile trovare tali endpoint nella SageMaker console. Nel riquadro di navigazione, apri il menu Inferenza e scegli Endpoint. Nell'immagine seguente, è disponibile un esempio.

La configurazione IAM è ora completata. Continua a configurare il cluster Aurora MySQL DB con cui lavorare concedendo l'accesso agli utenti del database SageMaker appropriati.

Se desideri utilizzare i tuoi SageMaker modelli per la formazione anziché utilizzare SageMaker componenti predefiniti, devi anche aggiungere il bucket Amazon S3 al tuo cluster Aurora MySQL DB, come indicato di seguito. Configurazione del cluster Aurora MySQL DB per l'utilizzo di Amazon S3 (opzionale) SageMaker

Configurazione del cluster Aurora MySQL DB per l'utilizzo di Amazon S3 (opzionale) SageMaker

Per utilizzarlo SageMaker con i tuoi modelli anziché utilizzare i componenti predefiniti forniti da SageMaker, devi configurare un bucket Amazon S3 per l'utilizzo del cluster Aurora MySQL DB. 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 dei bucket Amazon S3 con SageMaker, consulta Specificare un bucket Amazon S3 per caricare set di dati di formazione e archiviare i dati di output nella Amazon Developer Guide. SageMaker Per ulteriori informazioni su come lavorare con SageMaker, consulta la sezione Get Started with Amazon SageMaker Notebook Instances nella Amazon SageMaker Developer Guide.

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

Agli utenti del database deve essere concessa l'autorizzazione per richiamare le funzioni di machine learning di Aurora. 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.

La tabella seguente mostra i ruoli e i privilegi necessari agli utenti del database per lavorare con le funzioni di machine learning.

Concessione dell'accesso alle funzioni di Amazon Bedrock

Per consentire agli utenti del database di accedere alle funzioni di Amazon Bedrock, utilizza la seguente istruzione SQL:

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

Agli utenti del database devono inoltre essere concesse EXECUTE le autorizzazioni per le funzioni che crei per lavorare con Amazon Bedrock:

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

Infine, gli utenti del database devono avere i ruoli 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 SageMaker

Per consentire agli utenti del database di accedere alle SageMaker funzioni, usa l'istruzione appropriata per la tua versione di Aurora MySQL.

Agli utenti del database devono inoltre essere concesse EXECUTE le autorizzazioni per le funzioni create con cui lavorare. SageMaker Supponiamo di aver creato due funzioni db1.anomoly_score e di richiamare db2.company_forecasts i servizi del tuo endpoint. SageMaker Concedete i privilegi di esecuzione come illustrato nell'esempio seguente.

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 SageMaker funzioni sono ora disponibili per l'uso. Per esempi di utilizzo, consultare Utilizzo SageMaker con il cluster Aurora MySQL DB.

Utilizzo di Amazon Bedrock con il cluster Aurora MySQL DB

Per utilizzare Amazon Bedrock, crei una funzione definita dall'utente (UDF) nel database Aurora MySQL che richiama un modello. Per ulteriori informazioni, consulta la sezione Modelli supportati in Amazon Bedrock nella Amazon Bedrock User Guide.

Un UDF utilizza la seguente sintassi:

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 richiama 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 DB di utilizzare questa funzione, usa il 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 i parametri di inferenza per i modelli di base nella Amazon Bedrock User Guide.

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 ulteriori informazioni sui parametri e sui tipi di rendimento per le funzioni di rilevamento del sentiment in Amazon Comprehend, consulta 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 SageMaker con il cluster Aurora MySQL DB

Per utilizzare SageMaker le funzionalità del cluster Aurora MySQL DB, è necessario creare funzioni archiviate che incorporino le chiamate all'endpoint e le sue funzionalità di inferenza. SageMaker 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 distribuiti SageMaker per l'inferenza, si creano funzioni definite dall'utente utilizzando istruzioni DDL (Data Definition Language) MySQL per le funzioni archiviate. Ogni funzione memorizzata rappresenta l'endpoint che ospita il modello. SageMaker Quando si definisce una funzione di questo tipo, si specificano i parametri di input per il modello, l' SageMaker endpoint specifico da richiamare e il tipo restituito. La funzione restituisce l'inferenza calcolata dall' SageMaker endpoint dopo aver applicato il modello ai 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.

L'esempio seguente mostra la CREATE FUNCTION sintassi con cui lavorare. SageMaker

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. Nell'CREATE FUNCTIONistruzione che definisce la SageMaker funzione, non si specifica 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 SageMaker endpoint può avere caratteristiche diverse per ogni modello.

Il parametro max_batch_size è facoltativo. Per impostazione predefinita, la dimensione batch massima è 10.000. È possibile utilizzare questo parametro nella funzione per limitare a il numero massimo di input elaborati in una richiesta in batch a. SageMaker Il max_batch_size parametro può aiutare a evitare un errore causato da input troppo grandi o a SageMaker restituire una risposta più rapidamente. Questo parametro influisce sulla dimensione di un buffer interno utilizzato per l'elaborazione delle SageMaker richieste. 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'MANIFEST ONopzione, alcune SageMaker funzionalità non possono utilizzare direttamente il file CSV esportato con questa opzione. Il formato manifesto non è compatibile con il formato manifesto previsto da. SageMaker

Crei una funzione memorizzata separata per ciascuno dei tuoi SageMaker modelli. Questa mappatura delle funzioni sui modelli è necessaria perché un endpoint è associato a un modello specifico e ciascun modello accetta parametri diversi. L'utilizzo dei tipi SQL per gli input del modello e il tipo di output del modello consente di evitare errori di conversione dei tipi durante lo scambio di dati tra i AWS servizi. È 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 SageMaker modello 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 utilizzo dell'invocazione di un SageMaker endpoint per rilevare anomalie. C'è un endpoint. SageMaker random-cut-forest-model 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 SageMaker le funzioni che restituiscono stringhe

Si consiglia di specificare un set di caratteri utf8mb4 come tipo restituito per le SageMaker funzioni che restituiscono valori di 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 SageMaker funzione 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 SageMaker funzione dichiara un set di caratteri diverso per il tipo restituito in modo implicito o esplicito. Se la SageMaker funzione dichiara un set di caratteri diverso per il valore restituito, i dati restituiti potrebbero essere troncati automaticamente se li memorizzi in una colonna della tabella che non è sufficientemente lunga. Ad esempio, una query con una clausola DISTINCT crea una tabella temporanea. Pertanto, il risultato della SageMaker funzione potrebbe essere troncato a causa del modo in cui le stringhe vengono gestite internamente durante una query.

Esportazione di dati su Amazon S3 SageMaker per la formazione dei modelli (Advanced)

Ti consigliamo di iniziare con l'apprendimento automatico di Aurora e SageMaker di utilizzare alcuni degli algoritmi forniti e che i data scientist del tuo team ti forniscano gli SageMaker endpoint che puoi utilizzare con il tuo codice SQL. Di seguito, puoi trovare informazioni minime sull'utilizzo del tuo bucket Amazon S3 con i tuoi SageMaker modelli e il tuo cluster Aurora MySQL DB.

La funzione machine learning comprende due fasi principali: training e inferenza. Per addestrare SageMaker i modelli, esporti i dati in un bucket Amazon S3. Il bucket Amazon S3 viene utilizzato da un'istanza di SageMaker notebook Jupyter per addestrare il modello prima della distribuzione. 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

Amazon Bedrock, Amazon Comprehend SageMaker e i servizi svolgono la maggior parte del lavoro quando vengono richiamati da una funzione di machine learning 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

Le prestazioni quando si utilizza Amazon Bedrock dipendono in larga misura dal modello e dal prompt utilizzati. 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 si crea una funzione memorizzata Aurora connessa a un SageMaker endpoint, si definisce il parametro della dimensione del batch. Questo parametro influenza il numero di righe trasferite per ogni chiamata sottostante a. SageMaker Per le query che elaborano un numero elevato di righe, il sovraccarico necessario per effettuare una SageMaker chiamata separata per ogni riga può essere notevole. Maggiore è il set di dati elaborato dalla stored procedure, maggiore è la dimensione del batch.

Se l'ottimizzazione in modalità batch può essere applicata a una SageMaker funzione, è possibile verificarlo controllando il piano di interrogazione prodotto dall'EXPLAIN PLANistruzione. In questo caso, la colonna extra nel piano di esecuzione include Batched machine learning. L'esempio seguente mostra una chiamata a una SageMaker funzione 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

È possibile monitorare le operazioni batch di machine learning di Aurora interrogando 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 SageMaker operazioni richiamate dalle funzioni di machine learning di Aurora, consulta Monitor Amazon. SageMaker