Requisitos para usar o machine learning do Aurora Pré-requisitos Disponibilidade de região e versão Habilitar o machine learning do Aurora Recursos compatíveis e limitações Configurar o cluster do Aurora para o machine learning do Aurora Usar o Amazon Comprehend com seu cluster de banco de dados do Aurora MySQL Usar o SageMaker com o cluster de banco de dados do Aurora MySQL Considerações sobre a performance Monitoramento

Usar o machine learning do Amazon Aurora com o Aurora MySQL

Ao usar o machine learning do Amazon Aurora com seu cluster de banco de dados Aurora MySQL, você pode usar o Amazon Comprehend ou o Amazon SageMaker ou ambos, dependendo de suas necessidades. O Amazon Comprehend e o SageMaker oferecem compatibilidade com diferentes casos de uso de machine learning da forma a seguir.

Amazon Comprehend: O Amazon Comprehend é um serviço gerenciado de processamento de linguagem natural (PLN) utilizado para extrair insights de documentos. Com o Amazon Comprehend, você pode deduzir sentimentos com base no conteúdo dos documentos, analisando entidades, frases-chave, linguagem e outros recursos. Para saber mais, consulte What is Amazon Comprehend? (O que é o Amazon Comprehend?) no Amazon Comprehend Developer Guide (Guia do desenvolvedor do Amazon Comprehend).
SageMaker: Amazon SageMaker é um serviço de Machine Learning totalmente gerenciado. Cientistas de dados e desenvolvedores usam o Amazon SageMaker para criar, treinar e testar modelos de machine learning para uma série de tarefas de inferência, como detecção de fraudes e recomendação de produtos. Quando um modelo de machine learning está pronto para uso na produção, ele pode ser implantado no ambiente hospedado do Amazon SageMaker. Para obter informações, consulte What Is Amazon SageMaker? (O que é Amazon SageMaker) no Amazon SageMaker Developer Guide (Guia do desenvolvedor do Amazon SageMaker).

Usar o Amazon Comprehend com seu cluster de banco de dados Aurora exige menos configuração preliminar do que usar o SageMaker. Se você é novo no AWS Machine Learning e no machine learning do Aurora, recomendamos que comece explorando o Amazon Comprehend.

O machine learning do Aurora é compatível somente com determinadas Regiões da AWS e versões específicas do Aurora MySQL. Antes de tentar configurar o machine learning do Aurora, confira a disponibilidade de sua versão do Aurora MySQL e sua região. Para obter mais detalhes, consulte Machine learning do Aurora com o MySQL.

Tópicos

Requisitos para usar o machine learning do Aurora com o Aurora MySQL
Pré-requisitos para o Machine learning do Aurora
Disponibilidade de região e versão
Habilitar o machine learning do Aurora
Recursos compatíveis e limitações do machine learning do Aurora com o MySQL
Configurar o cluster de banco de dados do Aurora MySQL para usar machine learning do Aurora
Usar o Amazon Comprehend com seu cluster de banco de dados do Aurora MySQL
Usar o SageMaker com o cluster de banco de dados do Aurora MySQL
Considerações de performance para usar o machine learning do Aurora com o Aurora MySQL
Monitorar o machine learning do Aurora

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 com o Amazon Comprehend e o 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.

Pré-requisitos para o Machine learning do Aurora

Você pode fazer upgrade de um cluster do Aurora que executa uma versão inferior do Aurora MySQL para uma versão superior para usar o machine learning do Aurora com esse cluster. Para obter mais informações, consulte Atualizações do mecanismo de banco de dados Amazon Aurora MySQL.

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. Para obter mais informações sobre a disponibilidade de versões e regiões com o Aurora MySQL e o machine learning do Aurora, consulte Machine learning do Aurora com o MySQL.

Habilitar o machine learning do Aurora

Habilitar os recursos de ML envolve as seguintes etapas:

Os serviços Amazon Comprehend e SageMaker devem estar em execução na mesma Região da AWS que seu cluster de banco de dados Aurora MySQL. Você não pode usar os serviços Amazon Comprehend e SageMaker de um cluster de banco de dados Aurora MySQL em uma região diferente.
Se o seu cluster de banco de dados Aurora MySQL estiver em uma nuvem pública virtual (VPC) baseada no serviço Amazon VPC diferente dos serviços Amazon Comprehend e SageMaker, o grupo de segurança da VPC precisará permitir conexões de saída com o serviço de machine learning do Aurora de destino. Para obter mais informações, consulte Permitir a comunicação de rede do Amazon Aurora MySQL com outros produtos da AWS.
Seu cluster de banco de dados Aurora MySQL precisa usar um grupo de parâmetros de cluster de banco de dados personalizado. Ao final do processo de configuração de cada serviço de machine learning do Aurora que você deseja usar, adicione o nome do recurso da Amazon (ARN) do perfil do IAM associado que foi criado para o serviço. Recomendamos criar um grupo de parâmetros de cluster de banco de dados personalizado para seu Aurora MySQL com antecedência e configurar seu cluster de banco de dados Aurora MySQL para usá-lo de forma que esteja pronto para ser modificado no final do processo de configuração.
Para o SageMaker, os componentes de machine learning que você deseja usar para inferências devem estar configurados e prontos para uso. Durante o processo de configuração do cluster de banco de dados do Aurora MySQL, é necessário ter o nome do recurso da Amazon (ARN) do endpoint do SageMaker disponível. Os cientistas de dados de sua equipe provavelmente estão mais aptos a trabalhar com o SageMaker para preparar os modelos e realizar outras tarefas desse tipo. Para começar a usar o Amazon SageMaker, consulte Comece a usar o Amazon SageMaker. Para obter mais informações sobre inferências e endpoints, consulte Real-time Inference.
Para usar o SageMaker com seus próprios dados de treinamento, você precisa configurar um bucket do Amazon Simple Storage Service (Amazon S3) como parte da configuração do Aurora MySQL para machine learning do Aurora. Para fazer isso, siga o mesmo processo geral de configuração da integração com o SageMaker. Para obter um resumo desse processo de configuração opcional, consulte Configurar seu cluster de banco de dados do Aurora MySQL para usar o Amazon S3 para SageMaker (opcional).
Para bancos de dados globais do Aurora, configure os serviços de machine learning do Aurora que deseja usar em todas as Regiões da AWS que compõem seu banco de dados global do Aurora. Por exemplo, se quiser usar o machine learning do Aurora com o SageMaker para seu banco de dados global do Aurora, faça o seguinte para cada cluster de banco de dados Aurora MySQL em cada Região da AWS.
- Configure os serviços do Amazon SageMaker com os mesmos modelos de treinamento e endpoints do SageMaker. Eles também devem usar os mesmos nomes.
- Crie os perfis do IAM conforme detalhado em Configurar o cluster de banco de dados do Aurora MySQL para usar machine learning do Aurora.
- Adicione o ARN do perfil do IAM ao grupo de parâmetros do cluster de banco de dados personalizado para cada cluster de banco de dados Aurora MySQL em cada Região da AWS.
Essas tarefas exigem que o machine learning do Aurora esteja disponível para sua versão do Aurora MySQL em todas as Regiões da AWS que compõem seu banco de dados global do Aurora.

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, existem as limitações a seguir.

Formatos de algoritmo compatíveis do SageMaker: o Aurora MySQL é compatível com qualquer endpoint do SageMaker que leia e grave no formato de valores separados por vírgula (CSV), por meio um ContentType de text/csv. Atualmente, esse formato é aceito pelos algoritmos integrados do SageMaker a seguir.
- Aprendizagem linear
- Random Cut Forest
- XGBoost
Para saber mais sobre esses algoritmos, consulte Choose an Algorithm (Selecionar um algoritmo) no Amazon SageMaker Developer Guide (Guia do desenvolvedor do Amazon SageMaker).
Limitações da função armazenada do Aurora MySQL: as funções de machine learning do Aurora não são compatíveis com o formato de log binário (binlog). Isso afeta a integração do machine learning do Aurora da forma a seguir.
- Não há suporte para funções armazenadas que chamam tabelas com colunas sempre geradas. Isso se aplica a qualquer função armazenada do Aurora MySQL. Para saber mais sobre esse tipo de coluna, consulte CREATE TABLE and Generated Columns (CREATE TABLE e colunas geradas) na documentação do MySQL.
- A configuração --binlog-format=STATEMENT lança uma exceção para chamadas a funções do machine learning do Aurora. As funções do machine learning do Aurora não determinísticas e funções armazenadas não determinísticas não são compatíveis com o formato de binlog.
Para obter informações sobre esse formato binlog, consulte Binary Logging Formats (Formatos de registro em log binários) na documentação do MySQL.

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

Conforme mencionado em Usar o machine learning do Amazon Aurora com o Aurora MySQL, o Amazon Comprehend e o SageMaker oferecem compatibilidade com diferentes casos de uso de machine learning. Nos tópicos a seguir, você pode encontrar procedimentos de configuração separados para cada um desses serviços de machine learning do Aurora.

Tópicos

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.

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

Faça login no AWS Management Console e abra o console do Amazon RDS em https://console.aws.amazon.com/rds/.
Selecione Databases (Bancos de dados) no menu de navegação do Amazon RDS e o cluster de banco de dados do Aurora MySQL que deseja conectar aos serviços do Amazon Comprehend.
Escolha a guia Connectivity & security (Conectividade e segurança).
Role a página para a seção Manage IAM roles (Gerenciar perfis do IAM) e, depois, Select a service to connect to this cluster (Selecionar um serviço para se conectar a esse cluster). Selecione Amazon Comprehend no seletor e, depois, Connect service (Conectar serviço).
A caixa de diálogo Connect cluster to Amazon Comprehend (Conectar cluster ao Amazon Comprehend) não exige nenhuma informação adicional. No entanto, você pode ver uma mensagem notificando que a integração entre o Aurora e o Amazon Comprehend está atualmente em visualização prévia. Não deixe de ler a mensagem antes de continuar. Você pode selecionar Cancel (Cancelar) se preferir não continuar.
Selecione Connect service (Conectar serviço) para concluir o processo de integração.

O Aurora cria o perfil do IAM. Ele também cria a política que permite que o Aurora MySQL use os serviços do Amazon Comprehend e anexa a política ao perfil. Quando o processo for concluído, você poderá encontrar o perfil na lista Current IAM roles for this cluster (Perfis atuais do IAM para esse cluster), conforme mostrado na imagem a seguir.

Você precisa adicionar o ARN desse perfil do IAM ao parâmetro aws_default_comprehend_role de seu 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 obter mais informações, consulte Trabalhar com grupos de parâmetros de cluster de banco de dados.

Depois de criar seu grupo de parâmetros de cluster de banco de dados personalizado e associá-lo ao seu cluster de banco de dados do Aurora MySQL, você poderá continuar seguindo estas etapas.

Se o cluster usa um grupo de parâmetros de cluster de banco de dados personalizado, faça o seguinte.
1. No console do Amazon RDS, abra a guia Configuration (Configuração) de seu cluster de banco de dados do Aurora MySQL.
2. Localize o grupo de parâmetros de cluster de banco de dados configurado para seu cluster e clique no link para abrir o grupo de parâmetros de cluster de banco de dados personalizado. Escolha Edit parameters.
3. Encontre o parâmetro aws_default_comprehend_role em seu grupo de parâmetros de cluster de banco de dados personalizado.
4. No campo Value (Valor), insira o ARN do perfil do IAM.
5. Selecione Save changes (Salvar alterações) para salvar a configuração. Na imagem a seguir, é fornecido um exemplo.
Reinicialize a instância primária de seu cluster de banco de dados do Aurora MySQL para que essa configuração de parâmetro entre em vigor.

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.

Imagem mostrando o SageMaker selecionado para o cluster de banco de dados do Aurora MySQL.

Como configurar o cluster de banco de dados do Aurora MySQL para usar o SageMaker

Faça login no AWS Management Console e abra o console do Amazon RDS em https://console.aws.amazon.com/rds/.
Selecione Databases (Bancos de dados) no menu de navegação do Amazon RDS e, depois, o cluster de banco de dados do Aurora MySQL que deseja conectar aos serviços do SageMaker.
Escolha a guia Connectivity & security (Conectividade e segurança).
Role a página para a seção Manage IAM roles (Gerenciar perfis do IAM) e, depois, Select a service to connect to this cluster (Selecionar um serviço para se conectar a esse cluster). Selecione SageMaker no seletor.
Escolha Connect service (Conectar serviço).
Na caixa de diálogo Connect cluster to SageMaker (Conectar cluster ao SageMaker), insira o nome do recurso da Amazon (ARN) do endpoint do SageMaker.
O Aurora cria o perfil do IAM. Ele também cria a política que permite que o Aurora MySQL use os serviços do SageMaker e anexa a política ao perfil. Quando o processo for concluído, você poderá encontrar o perfil na lista Current IAM roles for this cluster (Perfis atuais do IAM para esse cluster).
Abra o console do IAM em https://console.aws.amazon.com/iam/.
Selecione Roles (Perfis) na seção Access management (Gerenciamento de acesso) do menu de navegação do AWS Identity and Access Management.
Encontre o perfil dentre os listados. Seu nome usa o padrão a seguir.
```
rds-sagemaker-your-cluster-name-role-auto-generated-digits
```
Abra a página de resumo da função e localize o ARN. Anote o ARN ou copie-o usando o widget de cópia.
Abra o console do Amazon RDS em https://console.aws.amazon.com/rds/.
Selecione o cluster de banco de dados do Aurora MySQL e, depois, a guia Configuration (Configuração).
Localize o grupo de parâmetros de cluster de banco de dados e, depois, clique no link para abrir o grupo de parâmetros de cluster de banco de dados personalizado. Encontre o parâmetro aws_default_sagemaker_role e insira o ARN do perfil do IAM no campo Value (Valor) e salve a configuração.
Reinicialize a instância primária de seu cluster de banco de dados do Aurora MySQL para que essa configuração de parâmetro entre em vigor.

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 Simple Storage Service (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.

Como configurar o cluster de banco de dados do Aurora MySQL para usar um bucket do Amazon S3 para SageMaker

Faça login no AWS Management Console e abra o console do Amazon RDS em https://console.aws.amazon.com/rds/.
Selecione Databases (Bancos de dados) no menu de navegação do Amazon RDS e, depois, o cluster de banco de dados do Aurora MySQL que deseja conectar aos serviços do SageMaker.
Escolha a guia Connectivity & security (Conectividade e segurança).
Role a página para a seção Manage IAM roles (Gerenciar perfis do IAM) e, depois, Select a service to connect to this cluster (Selecionar um serviço para se conectar a esse cluster). Selecione Amazon S3 no seletor.
Escolha Connect service (Conectar serviço).
Na caixa de diálogo Connect cluster to Amazon S3 (Conectar o cluster ao Amazon S3), insira o nome do recurso da Amazon (ARN) do bucket do Amazon S3, como mostrado na imagem a seguir.
Selecione Connect service (Conectar serviço) para concluir o processo.

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

O machine learning do Aurora inclui funções integradas para trabalhar com o Amazon Comprehend e o SageMaker. Os usuários do banco de dados devem ter permissão para invocar essas funções incorporadas. 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.

Para o Aurora MySQL 3 (compatível com o MySQL 8.0), os usuários do banco de dados devem receber a função de banco de dados apropriada. Para obter mais informações sobre funções de banco de dados do MySQL 3, consulte Using Roles (Usar funções) no MySQL 8.0 Reference Manual (Manual de referência do MySQL 8.0).
Para o Aurora MySQL 2 (compatível com o MySQL 5.7), os usuários do banco de dados recebem privilégios. Para obter mais informações, consulte Access Control and Account Management (Controle de acesso e gerenciamento de contas) no MySQL 5.7 Reference Manual (Manual de referência do MySQL 5.7).

Na tabela a seguir, você pode encontrar a função ou o privilégio de que os usuários do banco de dados precisam para trabalhar com as funções do Amazon Comprehend e do SageMaker.

Aurora MySQL 3 (MySQL 8.0) (função)	Aurora MySQL 2 (MySQL 5.7) (privilégio)
AWS_COMPREHEND_ACCESS	INVOCAR COMPREHEND
AWS_SAGEMAKER_ACCESS	INVOCAR SAGEMAKER

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 instrução apropriada para sua versão do Aurora MySQL.

Aurora MySQL versão 3 (compatível com o MySQL 8.0)


GRANT AWS_COMPREHEND_ACCESS TO user@domain-or-ip-address

Aurora MySQL versão 2 (compatível com o MySQL 5.7)


GRANT INVOKE COMPREHEND ON *.* TO user@domain-or-ip-address

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 instrução apropriada para sua versão do Aurora MySQL.

Aurora MySQL versão 3 (compatível com o MySQL 8.0)


GRANT AWS_SAGEMAKER_ACCESS TO user@domain-or-ip-address

Aurora MySQL versão 2 (compatível com o MySQL 5.7)


GRANT INVOKE SAGEMAKER ON *.* 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 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 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 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).

aws_comprehend_detect_sentiment

Essa função identifica uma postura emocional positiva, negativa, neutra ou mista no texto. A documentação de referência dessa função é a seguinte.


aws_comprehend_detect_sentiment(
  input_text,
  language_code
  [,max_batch_size]
)

Para saber mais, consulte Sentiment (Sentimento) no Amazon Comprehend Developer Guide (Guia do desenvolvedor do Amazon Comprehend).

aws_comprehend_detect_sentiment_confidence

Essa função mede o nível de confiança do sentimento detectado em determinado texto. Ele retorna um valor (tipo, double) que indica a confiança do sentimento atribuído pela função aws_comprehend_detect_sentiment ao texto. A confiança é uma métrica estatística entre 0 e 1. Quanto maior for o nível de confiança, mais peso você poderá atribuir ao resultado. Veja um resumo da documentação da função.


aws_comprehend_detect_sentiment_confidence(
  input_text,
  language_code
  [,max_batch_size]
)

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 rápida 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

exemplo Exemplo: uma consulta simples utilizando as funções do Amazon Comprehend

Veja um exemplo de uma consulta simples que invoca essas duas funções para ver o nível de satisfação de clientes com sua equipe de atendimento. Suponha que você tenha uma tabela de banco de dados (support) que armazene o feedback do cliente após cada solicitação de ajuda. Esta consulta de exemplo aplica as duas funções incorporadas ao texto na coluna feedback da tabela e gera os resultados. Os valores de confiança retornados pela função são duplos entre 0.0 e 1.0. Para obter uma saída mais legível, esta consulta arredonda os resultados para 6 pontos decimais. Para facilitar as comparações, ela também classifica primeiro os resultados em ordem decrescente, começando pelo resultado com o maior grau de confiança.


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)

exemplo Exemplo: determinar o sentimento médio para um texto acima de um nível de confiança específico

Uma típica consulta do Amazon Comprehend procura linhas em que o sentimento é um valor especificado, com um nível de confiança superior a um número especificado. Por exemplo, a consulta a seguir mostra como você pode determinar o sentimento médio de documentos em seu banco de dados. A consulta considera somente documentos em que a confiança da avaliação é superior a 80%.


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. Em outras palavras, crie funções definidas pelo usuário usando as instruções de linguagem de definição de dados (DDL) familiares do MySQL para funções armazenadas.

Para usar modelos implantados no SageMaker para inferência, crie funções definidas pelo usuário usando as instruções de linguagem de definição de dados (DDL) MySQL familiares 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.

No exemplo a seguir, você pode encontrar o padrão de sintaxe doCREATE 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 instruçã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.

nota

Para obter mais informações sobreCREATE FUNCTION, consulte CREATE PROCEDURE and CREATE FUNCTION Statements (Instruções CREATE PROCEDURE e CREATE FUNCTION) no MySQL 8.0 Reference Manual (Manual de referência do MySQL 8.0).

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.

O formato TEXT é igual ao formato de exportação do MySQL existente. Esse é o formato padrão.
O formato CSV é um formato recém-apresentado que segue a especificação em RFC-4180.
Se você especificar a palavra-chave opcional HEADER, o arquivo de saída conterá uma linha de cabeçalho. Os rótulos na linha de cabeçalho correspondem aos nomes de coluna da instrução SELECT.
Você ainda pode usar as palavras-chave CSV e HEADER como identificadores.

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 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.

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 instruçã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:

Chamadas de funções dentro da lista de seleção ou da cláusula WHERE de instruções SELECT. Há algumas exceções, conforme descrito a seguir.
Chamadas de funções na lista VALUES de instruções INSERT e REPLACE.

Funções do SageMaker nos valores SET em instruções UPDATE.


INSERT INTO MY_TABLE (col1, col2, col3) VALUES
  (ML_FUNC(1), ML_FUNC(2), ML_FUNC(3)),
  (ML_FUNC(4), ML_FUNC(5), ML_FUNC(6));
UPDATE MY_TABLE SET col1 = ML_FUNC(col2), SET col3 = ML_FUNC(col4) WHERE ...;

Monitorar o machine learning do Aurora

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


show status like 'Aurora_ml%';

É possível redefinir as variáveis de status usando uma instruçã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.

Aurora_ml_logical_response_cnt: A contagem agregada de respostas que o Aurora MySQL recebe dos serviços de machine learning do Aurora entre todas as consultas executadas por usuários da instância de banco de dados.
Aurora_ml_actual_request_cnt: A contagem agregada de solicitações que o Aurora MySQL recebe dos serviços de machine learning do Aurora entre todas as consultas executadas por usuários da instância de banco de dados.
Aurora_ml_actual_response_cnt: A contagem agregada de respostas que o Aurora MySQL recebe dos serviços de machine learning do Aurora entre todas as consultas executadas por usuários da instância de banco de dados.
Aurora_ml_cache_hit_cnt: A contagem agregada de acertos do cache interno que o Aurora MySQL recebe dos serviços de machine learning do Aurora entre todas as consultas executadas por usuários da instância de banco de dados.
Aurora_ml_single_request_cnt: A contagem agregada de funções do machine learning do Aurora que são avaliadas pelo modo que não seja em lote entre todas as consultas executadas por usuários da instância de banco de dados.

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.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Publicar logs do Aurora MySQL no CloudWatch Logs

Modo de laboratório do Aurora MySQL