Usar o machine learning do Amazon Aurora com o Aurora MySQL

Ao usar o machine learning do Amazon Aurora com o cluster de banco de dados do Aurora MySQL, é possível usar o Amazon Bedrock, o Amazon Comprehend, ou o Amazon SageMaker, dependendo das suas necessidades. Eles oferecem compatibilidade com casos de uso de machine learning diferentes.

Requisitos para usar o machine learning do Aurora com o Aurora MySQL

Os serviços do AWS Machine Learning são serviços gerenciados que são configurados e executados em seus próprios ambientes de produção. O machine learning do Aurora é compatível com a integração ao Amazon Bedrock, ao Amazon Comprehend e ao SageMaker. Antes de tentar configurar seu cluster de banco de dados Aurora MySQL para usar o machine learning do Aurora, entenda os requisitos e pré-requisitos a seguir.

Disponibilidade de região e versão

A disponibilidade e a compatibilidade de recursos variam entre versões específicas de cada mecanismo de banco de dados do Aurora e entre Regiões da AWS.

Recursos compatíveis e limitações do machine learning do Aurora com o MySQL

Ao usar o Aurora MySQL com o machine learning do Aurora, as seguintes limitações se aplicam:

Configurar o cluster de banco de dados do Aurora MySQL para usar machine learning do Aurora

Nos tópicos a seguir, você pode encontrar procedimentos de configuração separados para cada um desses serviços de machine learning do Aurora.

Configurar o cluster de banco de dados do Aurora MySQL para usar o Amazon Bedrock

O machine learning do Aurora Machine depende de políticas e perfis do AWS Identity and Access Management (IAM) para permitir que o cluster de banco de dados do Aurora MySQL acesse e use os serviços do Amazon Bedrock. Os procedimentos a seguir criam uma política e um perfil de permissão do IAM para que o cluster de banco de dados possa se integrar ao Amazon Bedrock.

Depois, crie o perfil do IAM que usa a política de permissão do Amazon Bedrock.

Depois, associe o perfil do IAM do Amazon Bedrock ao cluster de banco de dados.

É necessário adicionar o ARN desse perfil do IAM ao parâmetro aws_default_bedrock_role do grupo de parâmetros do cluster de banco de dados personalizado associado ao cluster de banco de dados do Aurora MySQL. Se seu cluster de banco de dados do Aurora MySQL não usa um grupo de parâmetros de cluster de banco de dados personalizado, será necessário criar um para ser usado com seu cluster de banco de dados do Aurora MySQL a fim de concluir a integração. Para ter mais informações, consulte Grupos de parâmetros do cluster de banco de dados para clusters de banco de dados do Amazon Aurora.

A integração do IAM com o Amazon Bedrock está concluída. Continue configurando o cluster de banco de dados do Aurora MySQL para trabalhar com o Amazon Bedrock de acordo com Conceder aos usuários de banco de dados acesso ao machine learning do Aurora.

Configurar o cluster de banco de dados do Aurora MySQL para usar o Amazon Comprehend

O Aurora Machine Learning depende de políticas e perfis do AWS Identity and Access Management para permitir que seu cluster de banco de dados do Aurora MySQL acesse e use os serviços do Amazon Comprehend. O procedimento a seguir cria automaticamente um perfil e uma política do IAM para seu cluster para que ele possa usar o Amazon Comprehend.

A integração do IAM com o Amazon Comprehend está concluída. Continue configurando seu cluster de banco de dados do Aurora MySQL para trabalhar com o Amazon Comprehend concedendo acesso aos usuários apropriados do banco de dados.

Configurar o cluster de banco de dados do Aurora MySQL para usar o SageMaker

O procedimento a seguir cria automaticamente o perfil e uma política do IAM para seu cluster de banco de dados do Aurora MySQL para que ele possa usar o SageMaker. Antes de tentar seguir esse procedimento, é necessário que o endpoint do SageMaker esteja disponível para poder inseri-lo quando necessário. Normalmente, os cientistas de dados de sua equipe trabalham para produzir um endpoint que você possa usá-lo em seu cluster de banco de dados do Aurora MySQL. Você pode encontrar esses endpoints no console do SageMaker. No painel de navegação, abra o menu Inference (Inferência) e selecione Endpoints. Na imagem a seguir, é fornecido um exemplo.

Agora a configuração do IAM está concluída. Continue configurando seu cluster de banco de dados do Aurora MySQL para trabalhar com o SageMaker concedendo acesso aos usuários apropriados do banco de dados.

Se você quiser usar seus modelos do SageMaker para treinamento em vez de usar componentes pré-criados do SageMaker, também precisará adicionar o bucket do Amazon S3 ao seu cluster de banco de dados do Aurora MySQL, conforme descrito no Configurar seu cluster de banco de dados do Aurora MySQL para usar o Amazon S3 para SageMaker (opcional) a seguir.

Configurar seu cluster de banco de dados do Aurora MySQL para usar o Amazon S3 para SageMaker (opcional)

Para usar o SageMaker com seus próprios modelos em vez de usar componentes pré-criados fornecidos pelo SageMaker, é necessário configurar um bucket do Amazon S3 para o cluster de banco de dados do Aurora MySQL usar. Para obter mais informações sobre como criar um bucket do Amazon S3, consulte Criação de um bucket, no Guia do usuário do Amazon Simple Storage Service.

Para obter mais informações sobre o uso de buckets do Amazon S3 com o SageMaker, consulte Specify an Amazon S3 Bucket to Upload Training Datasets and Store Output Data (Especificar um bucket do Amazon S3 para fazer upload de conjuntos de dados de treinamento e armazenar dados de saída) no Amazon SageMaker Developer Guide (Guia do desenvolvedor do Amazon SageMaker). Para saber mais sobre como trabalhar com o SageMaker, consulte Get Started with Amazon SageMaker Notebook Instances (Começar a usar instâncias de notebook do Amazon SageMaker) no Amazon SageMaker Developer Guide (Guia do desenvolvedor do Amazon SageMaker).

Conceder aos usuários de banco de dados acesso ao machine learning do Aurora

Os usuários do banco de dados devem receber permissão para invocar as funções de machine learning do Aurora. A forma como você concede a permissão depende da versão do MySQL que você usa para seu cluster de banco de dados do Aurora MySQL, conforme descrito a seguir. A forma como você faz isso depende da versão do MySQL que seu cluster de banco de dados do Aurora MySQL usa.

A tabela a seguir mostra os perfis e privilégios que os usuários do banco de dados precisam para trabalhar com funções de machine learning.

Conceder acesso às funções do Amazon Bedrock

Para conceder aos usuários do banco de dados acesso às funções do Amazon Bedrock, use a seguinte instrução SQL:

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

Os usuários do banco de dados também precisam receber permissões EXECUTE para as funções criadas para trabalhar com o Amazon Bedrock:

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

Por fim, os usuários do banco de dados devem ter seus perfis definidos como AWS_BEDROCK_ACCESS:

SET ROLE AWS_BEDROCK_ACCESS;

As funções do Amazon Bedrock já estão disponíveis para uso.

Conceder acesso às funções do Amazon Comprehend

Para conceder aos usuários do banco de dados acesso às funções do Amazon Comprehend, use a declaração apropriada para sua versão do Aurora MySQL.

As funções do Amazon Comprehend agora estão disponíveis para uso. Para obter exemplos de uso, consulte Usar o Amazon Comprehend com seu cluster de banco de dados do Aurora MySQL.

Conceder acesso às funções do SageMaker

Para conceder aos usuários do banco de dados acesso às funções do SageMaker, use a declaração apropriada para sua versão do Aurora MySQL.

Os usuários do banco de dados também precisam receber permissões EXECUTE para as funções criadas para trabalhar com o SageMaker. Suponha que você tenha criado duas funções, db1.anomoly_score e db2.company_forecasts, para invocar os serviços de seu endpoint do SageMaker. Você deve conceder privilégios de execução conforme mostrado no exemplo a seguir.

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;

As funções do SageMaker agora estão disponíveis para uso. Para obter exemplos de uso, consulte Usar o SageMaker com o cluster de banco de dados do Aurora MySQL.

Usar o Amazon Bedrock com o cluster de banco de dados do Aurora MySQL

Para usar o Amazon Bedrock, você cria uma função definida pelo usuário (UDF) no banco de dados do Aurora MySQL que invoca um modelo. Consulte mais informações em Supported models in Amazon Bedrock no Guia do usuário do Amazon Bedrock.

Uma UDF usa a seguinte sintaxe:

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

Por exemplo, a UDF a seguir invoca o modelo 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';

Para permitir que um usuário do banco de dados use essa função, use o seguinte comando do SQL:

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

Depois, o usuário pode chamar invoke_titan como qualquer outra função, conforme mostrado no exemplo a seguir. Formate o corpo da solicitação de acordo com os modelos de texto do 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"}]}

Para outros modelos que você usa, formate o corpo da solicitação de forma adequada para eles. Consulte mais informações em Inference parameters for foundation models no Guia do usuário do Amazon Bedrock.

Usar o Amazon Comprehend com seu cluster de banco de dados do Aurora MySQL

Para o Aurora MySQL, o machine learning do Aurora fornece as duas funções integradas a seguir para trabalhar com o Amazon Comprehend e seus dados de texto. Forneça o texto para analisar (input_data) e especifique o idioma (language_code).

Nas duas funções (aws_comprehend_detect_sentiment_confidence, aws_comprehend_detect_sentiment), o max_batch_size usa um valor padrão de 25 se nenhum for especificado. O tamanho do lote deve ser sempre maior que 0. Você pode usar max_batch_size para ajustar a performance das chamadas de função do Amazon Comprehend. Um lote grande troca performance mais alta por maior uso de memória no cluster de banco de dados do Aurora MySQL. Para obter mais informações, consulte Considerações de performance para usar o machine learning do Aurora com o Aurora MySQL.

Para obter mais informações sobre parâmetros e tipos de retorno para as funções de detecção de sentimentos no Amazon Comprehend, consulte 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;

Usar o SageMaker com o cluster de banco de dados do Aurora MySQL

Para usar a funcionalidade do SageMaker de seu cluster de banco de dados do Aurora MySQL, você precisa criar funções armazenadas que incorporem suas chamadas ao endpoint do SageMaker e seus recursos de inferência. Isso é feito usando CREATE FUNCTION do MySQL geralmente da mesma forma realizada para outras tarefas de processamento em seu cluster de banco de dados do Aurora MySQL.

Para usar modelos implantados no SageMaker para inferência, crie funções definidas pelo usuário usando as instruções da linguagem de definição de dados (DDL) do MySQL para funções armazenadas. Cada função armazenada representa o endpoint do SageMaker que hospeda o modelo. Ao definir tal função, especifique os parâmetros de entrada para o modelo, o endpoint do SageMaker específico a ser invocado e o tipo de retorno. A função retorna a inferência computada pelo endpoint do SageMaker após a aplicação do modelo com os parâmetros de entrada.

Todas as funções armazenadas de machine learning do Aurora retornam tipos numéricos ou VARCHAR. Você pode usar qualquer tipo numérico, exceto BIT. Outros tipos, como JSON, BLOB, TEXT e DATE, não são permitidos.

O exemplo a seguir mostra a sintaxe CREATE FUNCTION para trabalhar com o 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];

Essa é uma extensão da declaração DDL CREATE FUNCTION regular. Na instrução CREATE FUNCTION que define a função do SageMaker, não especifique um corpo de função. Em vez disso, especifique a palavra-chave ALIAS no lugar geralmente usado para o corpo da função. No momento, o machine learning do Aurora apenas oferece suporte a aws_sagemaker_invoke_endpoint para essa sintaxe estendida. Você deve especificar o parâmetro endpoint_name. Um endpoint do SageMaker pode ter características diferentes para cada modelo.

O parâmetro max_batch_size é opcional. Por padrão, o tamanho máximo do lote é 10 mil. Você pode usar esse parâmetro em sua função para restringir o número máximo de entradas processadas em uma solicitação em lote para o SageMaker. O parâmetro max_batch_size pode ajudar a evitar um erro causado por entradas muito grandes, ou para fazer o SageMaker retornar uma resposta com mais rapidez. O parâmetro afeta o tamanho de um buffer interno usado para processamento de solicitações do SageMaker. Especificar um valor muito grande para max_batch_size pode causar sobrecarga substancial de memória em sua instância de banco de dados.

Recomendamos manter a configuração MANIFEST em seu valor padrão de OFF. Embora seja possível usar a opção MANIFEST ON, alguns recursos do SageMaker não podem usar diretamente o CSV exportado com essa opção. O formato do manifesto não é compatível com o formato de manifesto esperado do SageMaker.

Crie uma função armazenada separada para cada um de seus modelos do SageMaker. Esse mapeamento de funções para modelos é necessário pois um endpoint está associado a um modelo específico e cada modelo aceita parâmetros diferentes. Uso de tipos de SQL para as entradas do modelo e o tipo de saída do modelo ajuda a evitar erros de conversão de tipos ao movimentar dados entre serviços da AWS. É possível controlar quem pode aplicar o modelo. Você também pode controlar as características do tempo de execução especificando um parâmetro que representa o tamanho máximo do lote.

No momento, as funções de machine learning do Aurora têm a propriedade NOT DETERMINISTIC. Se você não especificar essa propriedade explicitamente, o Aurora definirá NOT DETERMINISTIC automaticamente. Esse requisito se deve ao fato de ser possível alterar o modelo do SageMaker sem nenhuma notificação ao banco de dados. Se isso acontecer, as chamadas para uma função de machine learning do Aurora talvez retornem resultados diferentes para a mesma entrada em uma única transação.

Não é possível usar as características CONTAINS SQL, NO SQL, READS SQL DATA e MODIFIES SQL DATA na instrução CREATE FUNCTION.

Veja a seguir um exemplo de uso de invocação de um endpoint do SageMaker para detectar anomalias. Há um endpoint random-cut-forest-model do SageMaker. O modelo correspondente já foi treinado pelo algoritmo random-cut-forest. Para cada entrada, o modelo retorna uma pontuação de anomalia. Este exemplo mostra os pontos de dados cuja pontuação é maior do que 3 desvios padrão (aproximadamente o percentil 99,9) da pontuação média.

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 de conjunto de caracteres para funções do SageMaker que retornam strings

Recomenda-se especificar um conjunto de caracteres de utf8mb4 como tipo de retorno para as funções do SageMaker que retornam valores de string. Se isso não for prático, use um comprimento de string grande o suficiente para que o tipo de retorno mantenha um valor representado no conjunto de caracteres utf8mb4. A exemplo a seguir mostra como declarar o conjunto de caracteres utf8mb4 para a função.

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

Atualmente, cada função do SageMaker que retorna uma string usa o conjunto de caracteres utf8mb4 para o valor de retorno. O valor de retorno usa esse conjunto de caracteres mesmo que a sua função do SageMaker declare um conjunto de caracteres diferente para o tipo de retorno, de forma implícita ou explícita. Se a sua função de do SageMaker declarar um conjunto de caracteres diferente para o valor de retorno, os dados retornados poderão ser truncados silenciosamente se forem armazenados em uma coluna de tabela que não tenha o comprimento suficiente. Por exemplo, uma consulta com uma cláusula DISTINCT cria uma tabela temporária. Assim, o resultado da função do SageMaker poderá ser truncado devido à maneira como as strings são tratadas internamente durante uma consulta.

Exportar dados ao Amazon S3 para treinamento de modelos do SageMaker (avançado)

Recomendamos que você comece a usar o machine learning do Aurora e o SageMaker usando alguns dos algoritmos fornecidos e que os cientistas de dados de sua equipe forneçam os endpoints do SageMaker que você pode usar com seu código SQL. A seguir, você encontrará informações mínimas sobre como usar seu próprio bucket do Amazon S3 com seus próprios modelos do SageMaker e o cluster de banco de dados do Aurora MySQL.

O machine learning consiste em duas etapas principais: treinamento e inferência. Para treinar modelos do SageMaker, exporte os dados para um bucket do Amazon S3. O bucket do Amazon S3 é usado por uma instância de bloco de anotações Jupyter do SageMaker para treinar o modelo antes de ser implantado. Você pode usar a instrução SELECT INTO OUTFILE S3 para consultar dados de um cluster de banco de dados Aurora MySQL e salvá-los diretamente em arquivos de texto armazenados em um bucket do Amazon S3. Depois, a instância de bloco de anotações consumirá os dados do bucket do Amazon S3 para treinamento.

O machine learning do Aurora estende a sintaxe SELECT INTO OUTFILE existente no Aurora MySQL para exportar dados no formato CSV. O arquivo CSV gerado pode ser consumido diretamente por modelos que precisam desse formato para fins de treinamento.

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

A extensão oferece suporte ao formato CSV padrão.

A sintaxe estendida e a gramática de SELECT INTO agora tem a seguinte estrutura:

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

Considerações de performance para usar o machine learning do Aurora com o Aurora MySQL

Os serviços do Amazon Bedrock, do Amazon Comprehend e do SageMaker fazem a maior parte do trabalho quando invocados por uma função de machine learning do Aurora. Isso significa que você pode escalar esses recursos conforme necessário, de forma independente. Para seu cluster de banco de dados do Aurora MySQL, você pode tornar suas chamadas de função o mais eficientes possível. A seguir, você encontrará algumas considerações de performance a serem observadas ao trabalhar com o machine learning do Aurora.

Modelo e prompt

O desempenho ao usar o Amazon Bedrock depende muito do modelo e do prompt que você usa. Selecione um modelo e um prompt que sejam ideais para seu caso de uso.

Cache de consultas

O cache de consulta do Aurora MySQL não funciona para funções do machine learning do Aurora. O Aurora MySQL não armazena resultados de consultas no cache de consultas para nenhuma declaração de SQL que chame funções do machine learning do Aurora.

Otimização em lotes para chamadas de função do machine learning do Aurora

O principal aspecto de performance do machine learning do Aurora que pode ser influenciado no seu cluster do Aurora é a configuração do modo em lotes para chamadas às funções armazenadas do machine learning do Aurora. As funções de machine learning geralmente exigem sobrecarga substancial, o que torna impraticável chamar um serviço externo separadamente para cada linha. O machine learning do Aurora é capaz de minimizar essa sobrecarga, combinando as chamadas para o serviço de machine learning do Aurora externo para diversas linhas em um único lote. O machine learning do Aurora obtêm as respostas para todas as linhas de entrada e retorna essas respostas, uma linha por vez, à consulta durante a sua execução. Essa otimização melhora a taxa de transferência e a latência de suas consultas do Aurora, sem alterar os resultados.

Ao criar uma função armazenada do Aurora que está conectada a um endpoint do SageMaker, defina o parâmetro de tamanho do lote. Esse parâmetro influencia quantas linhas são transferidas ao SageMaker para cada chamada subjacente. Para consultas que processam grandes quantidades de linhas, a sobrecarga para realizar uma chamada do SageMaker separada para cada linha pode ser substancial. Quanto maior for o conjunto de dados processado pelo procedimento armazenado, maior poderá ser o tamanho do lote.

Se houver a possibilidade de aplicar a otimização do modo em lote a uma função do SageMaker, isso poderá ser determinado ao verificar o plano de consulta produzido pela instrução EXPLAIN PLAN. Nesse caso, a coluna extra no plano de execução inclui Batched machine learning. O exemplo a seguir mostra uma chamada para uma função do SageMaker que usa o modo em lote.

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)

Ao chamar uma das funções integradas do Amazon Comprehend, você pode controlar o tamanho do lote especificando o parâmetro max_batch_size opcional. Esse parâmetro restringe o número máximo de valores input_text processados em cada lote. Ao enviar vários itens por vez, ele reduz o número de percursos de ida e volta entre o Aurora e o Amazon Comprehend. Limitar o tamanho do lote é útil em situações, como uma consulta com uma cláusula LIMIT. Usando um valor pequeno para max_batch_size, é possível evitar a invocação do Amazon Comprehend mais vezes do que a quantidade de textos de entrada.

A otimização em lotes para avaliar funções do machine learning do Aurora é aplicável nos seguintes casos:

Monitorar o machine learning do Aurora

É possível monitorar as operações em lote de machine learning do Aurora consultando diversas variáveis globais, conforme mostrado no exemplo a seguir.

show status like 'Aurora_ml%';

É possível redefinir as variáveis de status usando uma declaração FLUSH STATUS. Assim, todas as quantidades representam totais, médias e assim por diante, desde a última vez em que a variável foi redefinida.

Para obter informações sobre como monitorar a performance das operações do SageMaker chamadas a partir de funções do machine learning do Aurora, consulte o tópico sobre como Monitorar o Amazon SageMaker.