Traduza e analise texto usando funções SQL com Amazon Athena, Amazon Translate e Amazon Comprehend

Você tem Serviço de armazenamento simples da Amazon (Amazon S3) baldes cheios de arquivos contendo bate-papos de clientes, análises de produtos e feeds de mídia social, em muitos idiomas. Sua tarefa é identificar os produtos sobre os quais as pessoas estão falando, determinar se eles estão expressando pensamentos felizes ou tristes, traduzir seus comentários em uma única linguagem comum e criar cópias dos dados para seus analistas de negócios com essas novas informações adicionadas ao cada registro. Além disso, você precisa remover todas as informações de identificação pessoal (PII), como nomes, endereços e números de cartão de crédito.

Você já sabe como usar Amazona atena para transformar dados no Amazon S3 usando comandos SQL simples e as funções integradas no Athena. Agora você também pode usar o Athena para traduzir e analisar campos de texto, graças ao Amazon Tradutor, Amazon Comprehende o poder das Funções Definidas pelo Usuário (UDFs) do Athena.

Athena é um serviço de consulta interativo que facilita a análise de dados armazenados no Amazon S3 usando SQL. O Amazon Comprehend é um serviço de Processamento de Linguagem Natural (PNL) que facilita a descoberta de insights de texto. Amazon Translate é um serviço de tradução automática neural que oferece tradução de idiomas rápida, de alta qualidade, acessível e personalizável. Nesta postagem, mostro como agora você pode usá-los juntos para realizar as seguintes ações:

Detecta o idioma dominante de um campo de texto
Detecte o sentimento predominante expresso - positivo, negativo, nenhum ou ambos
Detectar ou editar entidades (como itens, lugares ou quantidades)
Detectar ou editar PII
Traduzir texto de um idioma para outro

Esta postagem atinge os seguintes objetivos:

Mostre como configurar rapidamente as funções de análise de texto em sua própria conta da AWS (é rápido e fácil!)
Explique resumidamente como as funções funcionam
Discutir desempenho e custo
Fornece um tutorial onde fazemos algumas análises de texto sobre análises de produtos da Amazon
Descreva todas as funções disponíveis

Incluímos uma lista de todas as funções disponíveis no final da postagem; o código a seguir mostra alguns exemplos de consultas e resultados:

USING FUNCTION detect_sentiment(text_col VARCHAR, lang VARCHAR) RETURNS VARCHAR TYPE LAMBDA_INVOKE WITH (lambda_name = 'textanalytics-udf') SELECT detect_sentiment('I am very happy', 'en') as sentiment sentiment POSITIVE USING FUNCTION detect_pii_entities(text_col VARCHAR, lang VARCHAR) RETURNS VARCHAR TYPE LAMBDA_INVOKE WITH (lambda_name = 'textanalytics-udf') SELECT detect_pii_entities('I am Bob, I live in Herndon VA, and I love cars', 'en') as pii pii [["NAME","Bob"],["ADDRESS","Herndon VA"]] USING FUNCTION redact_pii_entities(text_col VARCHAR, lang VARCHAR, type VARCHAR) RETURNS VARCHAR TYPE LAMBDA_INVOKE WITH (lambda_name = 'textanalytics-udf') SELECT redact_pii_entities('I am Bob, I live in Herndon VA, and I love cars', 'en', 'NAME,ADDRESS') as pii_redacted pii_redacted I am [NAME], I live in [ADDRESS], and I love cars USING FUNCTION translate_text(text_col VARCHAR, sourcelang VARCHAR, targetlang VARCHAR, terminologyname VARCHAR) RETURNS VARCHAR TYPE LAMBDA_INVOKE WITH (lambda_name = 'textanalytics-udf') SELECT translate_text('It is a beautiful day in the neighborhood', 'auto', 'fr', NULL) as translated_text translated_text C'est une belle journée dans le quartier

Instale o UDF de análise de texto

Um Athena UDF usa AWS Lambda para implementar a capacidade da função. Discutirei mais detalhes posteriormente neste post, mas você não precisa entender o funcionamento interno para usar a UDF de analítica de texto, então vamos começar.

Instale a função Lambda pré-construída com as seguintes etapas:

Navegue até a TextAnalyticsUDFHandler aplicação no Repositório de aplicativos sem servidor da AWS.
No As configurações do aplicativo seção, mantenha as configurações em seus padrões.
Selecionar Eu reconheço que este aplicativo cria papéis IAM personalizados.
Escolha Implantação.

E é isso! Agora você tem uma nova função Lambda chamada textanalytics-udf. Você está pronto para experimentar algumas consultas de análise de texto no Athena.

Se você preferir construir e implantar a partir do código-fonte, consulte as instruções no final do README do repositório GitHub.

Execute sua primeira consulta de análise de texto

Se você é novo em Atenas, pode querer revisar o Iniciando guia.

No momento em que este livro foi escrito, o recurso Athena UDF ainda estava em pré-visualização. Para habilitá-lo, crie um grupo de trabalho Athena chamado AmazonAthenaPreviewFunctionality e execute todas as consultas UDF desse grupo de trabalho.

Insira a seguinte consulta no editor SQL:

USING FUNCTION detect_sentiment(text_col VARCHAR, lang VARCHAR) RETURNS VARCHAR TYPE LAMBDA_INVOKE WITH (lambda_name = 'textanalytics-udf') SELECT detect_sentiment('I am very happy', 'en') as sentiment

Você consegue um simples POSITIVE resultado. Agora tente novamente, variando o texto de entrada - tente algo menos positivo para ver como o valor de sentimento retornado muda.

Para obter o sentimento junto com as pontuações de confiança para cada valor potencial de sentimento, use a seguinte consulta:

USING FUNCTION detect_sentiment_all(text_col VARCHAR, lang VARCHAR) RETURNS VARCHAR TYPE LAMBDA_INVOKE WITH (lambda_name = 'textanalytics-udf') SELECT detect_sentiment_all('I am very happy', 'en') as sentiment

Agora você obtém uma string JSON contendo o sentimento e todas as pontuações de sentimento:

{"sentiment":"POSITIVE","sentimentScore":{"positive":0.999519,"negative":7.407639E-5,"neutral":2.7478999E-4,"mixed":1.3210243E-4}}

Você pode usar o funções de extração JSON integradas em Atenas sobre este resultado para extrair os campos para uma análise posterior.

Como funciona o UDF

Para obter mais informações sobre a estrutura Athena UDF, consulte Consultando com funções definidas pelo usuário.

A classe Java TextAnalyticsUDFHandler implementa nosso manipulador de função UDF Lambda. Cada função de analítica de texto tem um método público correspondente nesta classe.

Athena invoca nossa função UDF Lambda com lotes de registros de entrada. O TextAnalyticsUDFHandler subdivide esses lotes em lotes menores de até 25 linhas para aproveitar as vantagens das APIs de lote de vários documentos síncronos do Amazon Comprehend, onde estão disponíveis (por exemplo, para detectar linguagem, entidades e sentimento). Quando não há API de vários documentos síncrona disponível (como para DetectPiiEntity e TranslateText), usamos a API de documento único.

API Amazon Comprehend cotas de serviço fornecer grades de proteção para limitar sua exposição a custos de alto uso não intencional (discutiremos isso mais na seção seguinte). Por padrão, as APIs em lote de vários documentos processam até 250 registros por segundo e as APIs de documento único processam até 20 registros por segundo. Nossas UDFs usam recuo exponencial e tentam novamente controlar a taxa de solicitação para permanecer dentro desses limites. Você pode solicitar aumentos na cota de transações por segundo para APIs usando o Modelo de solicitação de cota na Console de gerenciamento da AWS.

Amazon Comprehend e Amazon Translate impõem um comprimento máximo de string de entrada de 5,000 bytes utf-8. Os campos de texto com mais de 5,000 bytes utf-8 são truncados para 5,000 bytes para detecção de linguagem e sentimento e divididos nos limites da frase em vários blocos de texto de menos de 5,000 bytes para tradução e entidade ou detecção e redação de PII. Os resultados são então combinados.

Otimizando custo

Além dos custos de consulta do Athena, o UDF de analítica de texto incorre em custos de uso do Lambda, Amazon Comprehend e Amazon Translate. O valor que você paga é um fator do número total de registros e caracteres que você processa com o UDF. Para mais informações, veja Preços do AWS Lambda, Preços do Amazon Comprehend e Preços do Amazon Translate.

Para minimizar os custos, recomendo que você evite processar os mesmos registros várias vezes. Em vez disso, materialize os resultados da UDF de análise de texto usando consultas CREATE TABLE AS SELECT (CTAS) para capturar os resultados em uma tabela separada que você pode consultar de maneira econômica sempre que necessário, sem incorrer em cobranças adicionais de UDF. Processe registros recém-chegados de forma incremental usando consultas INSERT IGNORE INTO…SELECT para analisar e enriquecer apenas os novos registros e adicioná-los à tabela de destino.

Evite chamar as funções de analítica de texto desnecessariamente em registros que você descartará posteriormente. Escreva suas consultas para filtrar o conjunto de dados primeiro usando tabelas temporárias, visualizações ou consultas aninhadas e, em seguida, aplique as funções de analítica de texto aos registros filtrados resultantes.

Sempre avalie o custo potencial antes de executar consultas de análise de texto em tabelas com grande número de registros variados.

Nesta seção, fornecemos dois exemplos de avaliações de custos.

Exemplo 1: Analise a linguagem e o sentimento dos tweets

Vamos supor que você tenha 10,000 registros de tweet, com comprimento médio de 100 caracteres por tweet. Sua consulta SQL detecta a linguagem dominante e o sentimento de cada tweet. Você está no segundo ano de serviço (o nível gratuito não se aplica mais). Os detalhes de custo são os seguintes:

Tamanho de cada tweet = 100 caracteres
Número de unidades (100 caracteres) por registro (mínimo é 3 unidades) = 3
Total de unidades: 10,000 (registros) x 3 (unidades por registro) x 2 (solicitações do Amazon Comprehend por registro) = 60,000
Preço por unidade = $ 0.0001
Custo total para Amazon Comprehend = [número de unidades] x [custo por unidade] = 60,000 x $ 0.0001 = $ 6.00

Exemplo 2: traduzir tweets

Vamos supor que 2,000 de seus tweets não estejam em seu idioma local, então você executa uma segunda consulta SQL para traduzi-los. Os detalhes de custo são os seguintes:

Tamanho de cada tweet = 100 caracteres
Total de caracteres: 2,000 (registros) * 100 (caracteres por registro) x 1 (solicitações de tradução por registro) = 200,000
Preço por personagem = $ 0.000015
Custo total para Amazon Translate = [número de caracteres] x [custo por caractere] = 200,000 x $ 0.000015 = $ 3.00

Analise insights de comentários de clientes

É hora de colocar nossas novas consultas de análise de texto em uso.

Para obter um tutorial sobre como obter insights acionáveis de avaliações de clientes, consulte Tutorial: Analisando Insights de Avaliações de Clientes com o Amazon Comprehend. Esta postagem fornece uma abordagem alternativa para o mesmo desafio: usar consultas SQL com tecnologia Athena e Amazon Comprehend.

O tutorial leva aproximadamente 10 minutos para ser concluído e custa até $ 6 para o Amazon Comprehend - não há custo se você estiver qualificado para o nível gratuito.

Crie um novo banco de dados em Athena

Execute a seguinte consulta no editor de consultas Athena:

CREATE DATABASE IF NOT EXISTS comprehendresults;

Ao conectar sua fonte de dados, escolha seu novo banco de dados.

Crie uma tabela de origem contendo dados de avaliação do cliente

Usamos o Conjunto de dados de críticas do cliente Amazon, convenientemente hospedado para acesso público no Amazon S3.

Execute a seguinte consulta no editor de consultas Athena:

CREATE EXTERNAL TABLE amazon_reviews_parquet( marketplace string, customer_id string, review_id string, product_id string, product_parent string, product_title string, star_rating int, helpful_votes int, total_votes int, vine string, verified_purchase string, review_headline string, review_body string, review_date bigint, year int)
PARTITIONED BY (product_category string)
ROW FORMAT SERDE 'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe' STORED AS INPUTFORMAT 'org.apache.hadoop.hive.ql.io.parquet.MapredParquetInputFormat' OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat'
LOCATION 's3://amazon-reviews-pds/parquet/'

Debaixo Tabelas, encontre a nova tabela amazon_reviews_parquet.
No menu de opções, escolha Carregar partições.

Visualize a nova tabela, amazon_reviews_parquet.

Execute a seguinte consulta para avaliar a duração média da revisão:

SELECT AVG(LENGTH(review_body)) AS average_review_length FROM amazon_reviews_parquet

A duração média da revisão é de cerca de 365 caracteres. Isso equivale a 4 unidades do Amazon Comprehend por registro (1 unidade = 100 caracteres).

Detecte o idioma de cada revisão

Para detectar o idioma de cada revisão, execute a seguinte consulta no editor de consultas Athena - leva pouco mais de 1 minuto para ser executada e custa US $ 2:

CREATE TABLE amazon_reviews_with_language WITH (format='parquet') AS
USING FUNCTION detect_dominant_language(col1 VARCHAR) RETURNS VARCHAR TYPE LAMBDA_INVOKE WITH (lambda_name = 'textanalytics-udf')
SELECT *, detect_dominant_language(review_body) AS language
FROM amazon_reviews_parquet
LIMIT 5000

Esta consulta cria uma nova tabela, amazon_reviews_with_language, com uma nova coluna adicionada: language. A cláusula LIMIT limita o número de registros a 5,000.

O custo é calculado como: 5,000 (registros) x 4 (unidades por registro) x 1 (solicitações por registro) x $ 0.0001 (preço por unidade do Amazon Comprehend) = $ 2.

Execute a seguinte consulta para ver os códigos de idioma detectados, com a contagem correspondente de revisões para cada idioma:

SELECT language, count(*) AS count FROM amazon_reviews_with_language GROUP BY language ORDER BY count DESC

Detecte sentimentos e entidades para cada revisão

Para detectar o sentimento, execute a seguinte consulta no editor de consulta Athena - ele usa duas funções de análise de texto, leva cerca de 1 minuto para ser executado e custa US $ 4:

CREATE TABLE amazon_reviews_with_text_analysis WITH (format='parquet') AS
USING FUNCTION detect_sentiment_all(col1 VARCHAR, lang VARCHAR) RETURNS VARCHAR TYPE LAMBDA_INVOKE WITH (lambda_name = 'textanalytics-udf'), FUNCTION detect_entities_all(col1 VARCHAR, lang VARCHAR) RETURNS VARCHAR TYPE LAMBDA_INVOKE WITH (lambda_name = 'textanalytics-udf')
SELECT *, detect_sentiment_all(review_body, language) AS sentiment, detect_entities_all(review_body, language) AS entities
FROM amazon_reviews_with_language
WHERE language IN ('ar', 'hi', 'ko', 'zh-TW', 'ja', 'zh', 'de', 'pt', 'en', 'it', 'fr', 'es')

Esta consulta cria uma nova tabela, amazon_reviews_with_text_analysis, com duas colunas adicionais adicionadas: sentiment e entities. A cláusula WHERE restringe o conjunto de resultados à lista de idiomas suportados pelo sentimento do Amazon Comprehend e detecção de entidade.

O custo é calculado como: 5,000 (registros) x 4 (unidades por registro) x 2 (solicitações por registro) x $ 0.0001 (preço por unidade do Amazon Comprehend) = $ 4.

Visualize a nova tabela e inspecione alguns dos valores para a nova sentiment e entities colunas. Eles contêm strings JSON com estruturas e campos aninhados.

A captura de tela a seguir mostra o sentiment detalhes da coluna.

A captura de tela a seguir mostra os detalhes da coluna de entidades.

Em seguida, usamos as funções JSON no Athena para preparar essas colunas para análise.

Prepare o sentimento para análise

Execute a seguinte consulta SQL para criar uma nova tabela contendo pontuações de sentimento e sentimentos expandidos em colunas separadas:

CREATE TABLE sentiment_results_final WITH (format='parquet') AS
SELECT review_date, year, product_title, star_rating, language, CAST(JSON_EXTRACT(sentiment,'$.sentiment') AS VARCHAR) AS sentiment, CAST(JSON_EXTRACT(sentiment,'$.sentimentScore.positive') AS DOUBLE ) AS positive_score, CAST(JSON_EXTRACT(sentiment,'$.sentimentScore.negative') AS DOUBLE ) AS negative_score, CAST(JSON_EXTRACT(sentiment,'$.sentimentScore.neutral') AS DOUBLE ) AS neutral_score, CAST(JSON_EXTRACT(sentiment,'$.sentimentScore.mixed') AS DOUBLE ) AS mixed_score, review_headline, review_body
FROM amazon_reviews_with_text_analysis

Visualize o novo sentiment_results_final tabela (veja a imagem a seguir). O sentimento geralmente se alinha com o texto do review_body campo? Como isso se correlaciona com o star_rating? Se você detectar qualquer atribuição de sentimento duvidoso, verifique as pontuações de confiança para ver se o sentimento foi atribuído com uma confiança baixa.

Prepare entidades para análise

Execute a seguinte consulta SQL para criar uma nova tabela contendo entidades detectadas não aninhadas em linhas separadas (subconsulta interna), com cada campo em uma coluna separada (consulta externa):

CREATE TABLE entities_results_final WITH (format='parquet') AS
SELECT review_date, year, product_title, star_rating, language, CAST(JSON_EXTRACT(entity_element, '$.text') AS VARCHAR ) AS entity, CAST(JSON_EXTRACT(entity_element, '$.type') AS VARCHAR ) AS category, CAST(JSON_EXTRACT(entity_element, '$.score') AS DOUBLE ) AS score, CAST(JSON_EXTRACT(entity_element, '$.beginOffset') AS INTEGER ) AS beginoffset, CAST(JSON_EXTRACT(entity_element, '$.endOffset') AS INTEGER ) AS endoffset, review_headline, review_body
FROM
( SELECT * FROM ( SELECT *, CAST(JSON_PARSE(entities) AS ARRAY(json)) AS entities_array FROM amazon_reviews_with_text_analysis ) CROSS JOIN UNNEST(entities_array) AS t(entity_element)
)

Visualize o conteúdo da nova tabela, entities_results_final (veja a imagem a seguir).

Visualize no Amazon QuickSight (opcional)

Como etapa opcional, você pode visualizar seus resultados com AmazonQuickSight. Para obter instruções, consulte Etapa 5: Visualizando o Amazon Comprehend Output no Amazon QuickSight.

Você pode usar o novo tipo visual de nuvem de palavras para entidades, em vez de mapa de árvore. No menu do gráfico de nuvem de palavras, selecione Ocultar “outras” categorias.

Agora você tem um painel com visualizações de sentimento e entidades que se parecem com a captura de tela a seguir.

guia de solução de problemas

Se sua consulta falhar, verifique o Amazon CloudWatch métricas e logs gerados pela função UDF Lambda.

No console do Lambda, encontre o textanalytics-udf função.
Escolha do Paciente.

Você pode visualizar as métricas do CloudWatch mostrando quantas vezes a função foi executada, por quanto tempo ela foi executada, com que frequência falhou e muito mais.

Escolha Ver registros no CloudWatch para abrir os fluxos de registro de função para insights adicionais de solução de problemas.

Para obter mais informações sobre como visualizar as métricas CloudWatch via Lambda, consulte Usando o console Lambda.

Casos de uso adicionais

Existem muitos casos de uso para funções analíticas de texto SQL. Além do exemplo mostrado nesta postagem, considere o seguinte:

Simplifique os pipelines de ETL usando consultas SQL incrementais para enriquecer os dados de texto com sentimentos e entidades, como streaming de fluxos de mídia social ingeridos por Mangueira de incêndio de dados do Amazon Kinesis
Use consultas SQL para explorar sentimentos e entidades em seus textos de suporte ao cliente, e-mails e casos de suporte
Prepare conjuntos de dados prontos para pesquisa, redigindo PII de interações com clientes ou pacientes
Padronizar muitos idiomas para um único idioma comum

Você pode ter casos de uso adicionais para essas funções ou recursos adicionais que deseja ver adicionados, como o seguinte:

Funções SQL para chamar o reconhecimento de entidade personalizada e modelos de classificação personalizados no Amazon Comprehend
Funções SQL para desidentificação - estendendo as funções de edição de PII e entidade para substituir entidades por identificadores exclusivos alternativos

Além disso, a implementação é de código aberto, o que significa que você pode clonar o repo, modificar e estender as funções conforme achar necessário e (com sorte) nos enviar solicitações de pull para que possamos incorporar suas melhorias de volta ao projeto e torná-lo melhor para todo o mundo.

Limpando

Depois de concluir este tutorial, você pode querer limpar todos os recursos da AWS que não deseja mais usar. Os recursos ativos da AWS podem continuar gerando cobranças em sua conta.

No Athena, execute a seguinte consulta para eliminar o banco de dados e todas as tabelas:
```
DROP DATABASE comprehendresults CASCADE
```

No AWS CloudFormation, exclua a pilha serverlessrepo-TextAnalyticsUDFHandler.
Cancelar sua assinatura QuickSight.

Conclusão

Mostrei como instalar a função UDF Lambda de análise de texto de amostra para Athena, para que você possa usar consultas SQL simples para traduzir texto usando o Amazon Translate, gerar insights de texto usando o Amazon Comprehend e editar informações confidenciais. Espero que você ache isso útil e compartilhe exemplos de como você pode usá-lo para simplificar suas arquiteturas e implementar novos recursos para o seu negócio.

Por favor, compartilhe suas idéias conosco na seção de comentários, ou na seção de questões do projeto Repositório GitHub.

Apêndice: Referência de função disponível

Esta seção resume as funções fornecidas atualmente. O README arquivo fornece detalhes adicionais.

detectar idioma

Esta função usa o Amazon Comprehend BatchDetectDominantLanguage API para identificar o idioma dominante com base nos primeiros 5,000 bytes de texto de entrada.

O código a seguir retorna um código de idioma, como fr para francês ou en para inglês:

USING FUNCTION detect_dominant_language(text_col VARCHAR) RETURNS VARCHAR TYPE LAMBDA_INVOKE WITH (lambda_name = 'textanalytics-udf') SELECT detect_dominant_language('il fait beau à Orlando') as language

O código a seguir retorna uma matriz formatada em JSON de códigos de idioma e pontuações de confiança correspondentes:

USING FUNCTION detect_dominant_language_all(text_col VARCHAR) RETURNS VARCHAR TYPE LAMBDA_INVOKE WITH (lambda_name = 'textanalytics-udf') SELECT detect_dominant_language_all('il fait beau à Orlando') as language_all

Detectar sentimento

Esta função usa o Amazon Comprehend Sentimento de detecção de lote API para identificar o sentimento com base nos primeiros 5,000 bytes do texto de entrada.

O código a seguir retorna um sentimento como POSITIVO, NEGATIVO, NEUTRO ou MISTO:

USING FUNCTION detect_sentiment(text_col VARCHAR, lang VARCHAR) RETURNS VARCHAR TYPE LAMBDA_INVOKE WITH (lambda_name = 'textanalytics-udf') SELECT detect_sentiment('Joe is very happy', 'en') as sentiment

O código a seguir retorna um objeto formatado em JSON contendo pontuações de sentimento e confiança detectadas para cada valor de sentimento:

USING FUNCTION detect_sentiment_all(text_col VARCHAR, lang VARCHAR) RETURNS VARCHAR TYPE LAMBDA_INVOKE WITH (lambda_name = 'textanalytics-udf') SELECT detect_sentiment_all('Joe is very happy', 'en') as sentiment_all

Detectar entidades

Esta função usa o Amazon Comprehend Detectar entidades API para identificar PII. Texto de entrada com mais de 5,000 bytes resulta em várias chamadas de API do Amazon Comprehend.

O código a seguir retorna um objeto formatado JSON contendo uma matriz de tipos de entidade e valores:

USING FUNCTION detect_entities(text_col VARCHAR, lang VARCHAR) RETURNS VARCHAR TYPE LAMBDA_INVOKE WITH (lambda_name = 'textanalytics-udf') SELECT detect_entities('His name is Joe, he lives in Richmond VA, he bought an Amazon Echo Show on January 5th, and he loves it', 'en') as entities

O código a seguir retorna um objeto formatado em JSON contendo uma matriz de tipos de entidade PII, com seus valores, pontuações e deslocamentos de caracteres:

USING FUNCTION detect_entities_all(text_col VARCHAR, lang VARCHAR) RETURNS VARCHAR TYPE LAMBDA_INVOKE WITH (lambda_name = 'textanalytics-udf') SELECT detect_entities_all('His name is Joe, he lives in Richmond VA, he bought an Amazon Echo Show on January 5th, and he loves it', 'en') as entities_all

Redigir entidades

Esta função substitui valores de entidade para os tipos de entidade especificados por “[ENTITY_TYPE]”. Texto de entrada com mais de 5,000 bytes resulta em várias chamadas de API do Amazon Comprehend. Veja o seguinte código:

USING FUNCTION redact_entities(text_col VARCHAR, lang VARCHAR, types VARCHAR) RETURNS VARCHAR TYPE LAMBDA_INVOKE WITH (lambda_name = 'textanalytics-udf') SELECT redact_entities('His name is Joe, he lives in Richmond VA, he bought an Amazon Echo Show on January 5th, and he loves it', 'en', 'ALL') as entities_redacted

O comando retorna uma versão redigida na string de entrada. Especifique um ou mais tipos de entidade para editar, fornecendo uma lista separada por vírgulas de types no parâmetro de string de tipos, ou ALL para editar todos os tipos.

Detectar PII

Esta função usa o Detectar PiiEntities API para identificar PII. Texto de entrada com mais de 5,000 bytes resulta em várias chamadas de API do Amazon Comprehend.

O código a seguir retorna um objeto formatado JSON contendo uma matriz de Tipos de entidade PII e valores:

USING FUNCTION detect_pii_entities(text_col VARCHAR, lang VARCHAR) RETURNS VARCHAR TYPE LAMBDA_INVOKE WITH (lambda_name = 'textanalytics-udf') SELECT detect_pii_entities('His name is Joe, his username is joe123 and he lives in Richmond VA', 'en') as pii

O código a seguir retorna um objeto formatado em JSON contendo uma matriz de tipos de entidade PII, com suas pontuações e deslocamentos de caracteres:

USING FUNCTION detect_pii_entities_all(text_col VARCHAR, lang VARCHAR) RETURNS VARCHAR TYPE LAMBDA_INVOKE WITH (lambda_name = 'textanalytics-udf') SELECT detect_pii_entities_all('His name is Joe, his username is joe123 and he lives in Richmond VA', 'en') as pii_all

Redigir PII

Esta função substitui os valores PII dos tipos de entidade PII especificados por “[PII_ENTITY_TYPE]”. Texto de entrada com mais de 5,000 bytes resulta em várias chamadas de API do Amazon Comprehend. Veja o seguinte código:

USING FUNCTION redact_pii_entities(text_col VARCHAR, lang VARCHAR, types VARCHAR) RETURNS VARCHAR TYPE LAMBDA_INVOKE WITH (lambda_name = 'textanalytics-udf') SELECT redact_pii_entities('His name is Joe, his username is joe123 and he lives in Richmond VA', 'en', 'ALL') as pii_redacted

A função retorna uma versão editada na string de entrada. Especifique um ou mais Tipos de entidade PII para editar, fornecendo uma lista separada por vírgulas de tipos válidos no type parâmetro de string, ou ALL para editar todos os tipos.

Traduzir texto

Esta função traduz o texto do idioma de origem para o idioma de destino. Texto de entrada com mais de 5,000 bytes resulta em várias chamadas de API do Amazon Translate. Veja o seguinte código:

USING FUNCTION translate_text(text_col VARCHAR, sourcelang VARCHAR, targetlang VARCHAR, customterminologyname VARCHAR) RETURNS VARCHAR TYPE LAMBDA_INVOKE WITH (lambda_name = 'textanalytics-udf') SELECT translate_text('It is a beautiful day in the neighborhood', 'auto', 'fr', NULL) as translated_text

A função retorna a string traduzida. Opcionalmente, detecte automaticamente o idioma de origem (use auto como o código do idioma, que usa Amazon Comprehend) e, opcionalmente, especifique um terminologia customizada (caso contrário, use NULL para customTerminologyName).

Sobre o autor

Bob Strahan é arquiteto de soluções principais na equipe AWS Language AI Services.

Fonte: https://aws.amazon.com/blogs/machine-learning/translate-and-analyze-text-using-sql-functions-with-amazon-athena-amazon-translate-and-amazon-comprehend/

Inteligência de dados generativa