Traduire et analyser du texte à l'aide de fonctions SQL avec Amazon Athena, Amazon Translate et Amazon Comprehend

Vous avez Service de stockage simple Amazon (Amazon S3) des seaux remplis de fichiers contenant des discussions client entrantes, des critiques de produits et des flux de médias sociaux, dans de nombreuses langues. Votre tâche consiste à identifier les produits dont les gens parlent, à déterminer s'ils expriment des pensées heureuses ou tristes, à traduire leurs commentaires dans un seul langage commun et à créer des copies des données pour vos analystes commerciaux avec ces nouvelles informations ajoutées à chaque enregistrement. En outre, vous devez supprimer toutes les informations personnelles identifiables (PII), telles que les noms, adresses et numéros de carte de crédit.

Vous savez déjà comment utiliser Amazone Athéna pour transformer des données dans Amazon S3 à l'aide de simples commandes SQL et des fonctions intégrées d'Athena. Désormais, vous pouvez également utiliser Athena pour traduire et analyser des champs de texte, grâce à Amazon Traduire, Amazon comprendreet la puissance des fonctions définies par l'utilisateur (UDF) Athena.

Athena est un service de requête interactif qui facilite l'analyse des données stockées dans Amazon S3 à l'aide de SQL. Amazon Comprehend est un service de traitement du langage naturel (NLP) qui facilite la découverte d'informations à partir de texte. Amazon Translate est un service de traduction automatique neuronale qui offre une traduction linguistique rapide, de haute qualité, abordable et personnalisable. Dans cet article, je vous montre comment vous pouvez désormais les utiliser ensemble pour effectuer les actions suivantes:

Détecter la langue dominante d'un champ de texte
Détecter le sentiment dominant exprimé: positif, négatif, ni l'un ni l'autre ou les deux
Détecter ou biffer des entités (telles que des articles, des lieux ou des quantités)
Détecter ou biffer les informations personnelles
Traduire du texte d'une langue à une autre

Cet article atteint les objectifs suivants:

Vous montrer comment configurer rapidement les fonctions d'analyse de texte dans votre propre compte AWS (c'est rapide et facile!)
Expliquez brièvement le fonctionnement des fonctions
Discuter des performances et des coûts
Fournir un didacticiel dans lequel nous effectuons des analyses de texte sur les critiques de produits Amazon
Décrivez toutes les fonctions disponibles

Nous incluons une liste de toutes les fonctions disponibles à la fin du message; le code suivant montre quelques exemples de requêtes et de résultats:

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

Installez l'UDF d'analyse de texte

Un Athena UDF utilise AWS Lambda pour implémenter la capacité de fonction. Je discute plus de détails plus tard dans cet article, mais vous n'avez pas besoin de comprendre le fonctionnement interne pour utiliser l'analyse de texte UDF, alors commençons.

Installez la fonction Lambda prédéfinie en procédant comme suit:

Accédez à la TextAnalyticsUDFHandlerTextAnalyticsUDFHandler application dans le Référentiel d'applications sans serveur AWS.
Dans le Les paramètres d'application section, conservez les paramètres à leurs valeurs par défaut.
Sélectionnez Je reconnais que cette application crée des rôles IAM personnalisés.
Selectionnez Déployer.

Et c'est tout! Vous avez maintenant une nouvelle fonction Lambda appelée textanalytics-udf. Vous êtes prêt à essayer des requêtes d'analyse de texte dans Athena.

Si vous préférez créer et déployer à partir du code source à la place, consultez les instructions à la fin du README du référentiel GitHub.

Exécutez votre première requête d'analyse de texte

Si vous êtes nouveau sur Athena, vous voudrez peut-être consulter le Pour commencer guider.

Au moment d'écrire ces lignes, la fonctionnalité Athena UDF est toujours en préversion. Pour l'activer, créez un groupe de travail Athena nommé AmazonAthenaPreviewFunctionality et exécutez toutes les requêtes UDF à partir de ce groupe de travail.

Entrez la requête suivante dans l'éditeur 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

Vous obtenez un simple POSITIVE résultat. Maintenant, réessayez, en faisant varier le texte d'entrée - essayez quelque chose de moins positif pour voir comment la valeur de sentiment renvoyée change.

Pour obtenir le sentiment ainsi que les scores de confiance pour chaque valeur de sentiment potentielle, utilisez plutôt la requête suivante:

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

Vous obtenez maintenant une chaîne JSON contenant le sentiment et tous les scores de sentiment:

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

Vous pouvez utiliser le fonctions d'extraction JSON intégrées à Athena sur ce résultat pour extraire les champs pour une analyse plus approfondie.

Comment fonctionne l'UDF

Pour plus d'informations sur le framework Athena UDF, voir Interroger avec des fonctions définies par l'utilisateur.

La classe Java TextAnalyticsUDFHandlerTextAnalyticsUDFHandler implémente notre gestionnaire de fonctions UDF Lambda. Chaque fonction d'analyse de texte a une méthode publique correspondante dans cette classe.

Athena appelle notre fonction UDF Lambda avec des lots d'enregistrements d'entrée. Le TextAnalyticsUDFHandler subdivise ces lots en lots plus petits de 25 lignes maximum pour tirer parti des API de lots multi-documents synchrones Amazon Comprehend là où ils sont disponibles (par exemple, pour détecter la langue, les entités et les sentiments). Lorsqu'aucune API multi-document synchrone n'est disponible (par exemple pour DetectPiiEntity ainsi que TranslateText), nous utilisons plutôt l'API à document unique.

API Amazon Comprehend quotas de service fournir des garde-corps pour limiter votre exposition aux coûts d'une utilisation élevée involontaire (nous en discuterons plus dans la section suivante). Par défaut, les API de lots multi-documents traitent jusqu'à 250 enregistrements par seconde et les API de document unique traitent jusqu'à 20 enregistrements par seconde. Nos UDF utilisent un recul exponentiel et réessaient de limiter le taux de demandes pour rester dans ces limites. Vous pouvez demander des augmentations du quota de transactions par seconde pour les API à l'aide du Modèle de demande de quota sur le Console de gestion AWS.

Amazon Comprehend et Amazon Translate appliquent chacun une longueur de chaîne d'entrée maximale de 5,000 8 octets utf-5,000. Les champs de texte de plus de 8 5,000 octets utf-5,000 sont tronqués à XNUMX XNUMX octets pour la détection de la langue et des sentiments, et répartis sur les limites de la phrase en plusieurs blocs de texte de moins de XNUMX XNUMX octets pour la traduction et la détection et la rédaction des entités ou des informations personnelles. Les résultats sont ensuite combinés.

Optimiser les coûts

Outre les coûts de requête Athena, l'UDF d'analyse de texte entraîne des coûts d'utilisation de Lambda, Amazon Comprehend et Amazon Translate. Le montant que vous payez est un facteur du nombre total d'enregistrements et de caractères que vous traitez avec l'UDF. Pour plus d'informations, consultez Tarification AWS Lambda, Tarification Amazon Comprehendet Tarification d'Amazon Translate.

Pour minimiser les coûts, je vous recommande d'éviter de traiter plusieurs fois les mêmes enregistrements. Au lieu de cela, matérialisez les résultats de la fonction UDF d'analyse de texte à l'aide de requêtes CREATE TABLE AS SELECT (CTAS) pour capturer les résultats dans une table distincte que vous pouvez ensuite interroger de manière rentable aussi souvent que nécessaire sans encourir de frais UDF supplémentaires. Traitez les nouveaux enregistrements de manière incrémentielle à l'aide des requêtes INSERT IGNORE INTO…SELECT pour analyser et enrichir uniquement les nouveaux enregistrements et les ajouter à la table cible.

Évitez d'appeler inutilement les fonctions d'analyse de texte sur des enregistrements que vous supprimerez par la suite. Écrivez vos requêtes pour filtrer l'ensemble de données en utilisant d'abord des tables temporaires, des vues ou des requêtes imbriquées, puis appliquez les fonctions d'analyse de texte aux enregistrements filtrés résultants.

Évaluez toujours le coût potentiel avant d'exécuter des requêtes d'analyse de texte sur des tables comportant un grand nombre d'enregistrements.

Dans cette section, nous fournissons deux exemples d'évaluation des coûts.

Exemple 1: analyser la langue et le sentiment des tweets

Supposons que vous ayez 10,000 enregistrements de tweet, avec une longueur moyenne de 100 caractères par tweet. Votre requête SQL détecte la langue et le sentiment dominants pour chaque tweet. Vous êtes dans votre deuxième année de service (l'offre gratuite ne s'applique plus). Les détails des coûts sont les suivants:

Taille de chaque tweet = 100 caractères
Nombre d'unités (100 caractères) par enregistrement (le minimum est de 3 unités) = 3
Unités totales: 10,000 3 (enregistrements) x 2 (unités par enregistrement) x 60,000 (demandes Amazon Comprehend par enregistrement) = XNUMX XNUMX
Prix par unité = 0.0001 USD
Coût total pour Amazon Comprehend = [nombre d'unités] x [coût par unité] = 60,000 0.0001 x 6.00 USD = XNUMX USD

Exemple 2: Traduire des tweets

Supposons que 2,000 de vos tweets ne soient pas dans votre langue locale, vous exécutez donc une deuxième requête SQL pour les traduire. Les détails des coûts sont les suivants:

Taille de chaque tweet = 100 caractères
Nombre total de caractères: 2,000 100 (enregistrements) * 1 (caractères par enregistrement) x 200,000 (demandes de traduction par enregistrement) = XNUMX XNUMX
Prix par caractère = 0.000015 USD
Coût total pour Amazon Translate = [nombre de caractères] x [coût par caractère] = 200,000 0.000015 x 3.00 USD = XNUMX USD

Analyser les informations issues des avis clients

Il est temps d'utiliser nos nouvelles requêtes d'analyse de texte.

Pour obtenir un didacticiel sur l'obtention d'informations exploitables à partir des avis clients, consultez Didacticiel: analyse des informations issues des avis clients avec Amazon Comprehend. Cet article propose une approche alternative au même défi: l'utilisation de requêtes SQL alimentées par Athena et Amazon Comprehend.

Le didacticiel dure environ 10 minutes et coûte jusqu'à 6 USD pour Amazon Comprehend. Il n'y a aucun coût si vous êtes éligible à l'offre gratuite.

Créer une nouvelle base de données dans Athena

Exécutez la requête suivante dans l'éditeur de requêtes Athena:

CREATE DATABASE IF NOT EXISTS comprehendresults;

Lors de la connexion de votre source de données, choisissez votre nouvelle base de données.

Créer une table source contenant des données d'avis client

Nous utilisons les Ensemble de données d'avis clients Amazon, commodément hébergé pour un accès public dans Amazon S3.

Exécutez la requête suivante dans l'éditeur de requêtes 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/'

Sous Tables, recherchez la nouvelle table amazon_reviews_parquet.
Dans le menu des options, choisissez Charger les partitions.

Aperçu du nouveau tableau, amazon_reviews_parquet.

Exécutez la requête suivante pour évaluer la durée moyenne de l'avis:

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

La longueur moyenne des avis est d'environ 365 caractères. Cela équivaut à 4 unités Amazon Comprehend par enregistrement (1 unité = 100 caractères).

Détectez la langue de chaque avis

Pour détecter la langue de chaque révision, exécutez la requête suivante dans l'éditeur de requêtes Athena. L'exécution prend un peu plus d'une minute et coûte 1 USD:

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

Cette requête crée une nouvelle table, amazon_reviews_with_language, avec une nouvelle colonne ajoutée: language. La clause LIMIT limite le nombre d'enregistrements à 5,000 XNUMX.

Le coût est calculé comme suit: 5,000 4 (enregistrements) x 1 (unités par enregistrement) x 0.0001 (demandes par enregistrement) x 2 USD (prix par unité Amazon Comprehend) = XNUMX USD.

Exécutez la requête suivante pour voir les codes de langue détectés, avec le nombre de critiques correspondant pour chaque langue:

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

Détectez les sentiments et les entités pour chaque avis

Pour détecter les sentiments, exécutez la requête suivante dans l'éditeur de requêtes Athena. Il utilise deux fonctions d'analyse de texte, prend environ 1 minute à exécuter et coûte 4 USD:

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

Cette requête crée une nouvelle table, amazon_reviews_with_text_analysis, avec deux colonnes supplémentaires ajoutées: sentiment ainsi que entities. La clause WHERE limite le jeu de résultats à la liste des langues prises en charge par la détection des sentiments et des entités Amazon Comprehend.

Le coût est calculé comme suit: 5,000 4 (enregistrements) x 2 (unités par enregistrement) x 0.0001 (demandes par enregistrement) x 4 USD (prix par unité Amazon Comprehend) = XNUMX USD.

Prévisualisez la nouvelle table et inspectez certaines des valeurs pour la nouvelle sentiment ainsi que entities Colonnes. Ils contiennent des chaînes JSON avec des structures et des champs imbriqués.

La capture d'écran suivante montre le sentiment détails de la colonne.

La capture d'écran suivante montre les détails de la colonne d'entités.

Ensuite, nous utilisons les fonctions JSON dans Athena pour préparer ces colonnes pour l'analyse.

Préparer le sentiment pour l'analyse

Exécutez la requête SQL suivante pour créer une nouvelle table contenant les scores de sentiment et de sentiment développés dans des colonnes distinctes:

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

Aperçu du nouveau sentiment_results_final table (voir la capture d'écran suivante). Le sentiment correspond-il généralement au texte de la review_body domaine? Comment est-il corrélé avec le star_rating? Si vous repérez des affectations de sentiment douteuses, vérifiez les scores de confiance pour voir si le sentiment a été attribué avec une confiance faible.

Préparer les entités pour l'analyse

Exécutez la requête SQL suivante pour créer une nouvelle table contenant les entités détectées non imbriquées dans des lignes séparées (sous-requête interne), avec chaque champ dans une colonne distincte (requête externe):

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

Aperçu du contenu du nouveau tableau, entities_results_final (voir la capture d'écran suivante).

Visualiser dans Amazon QuickSight (facultatif)

En option, vous pouvez visualiser vos résultats avec Amazon QuickSight. Pour obtenir des instructions, consultez Étape 5: Visualisation de la sortie Amazon Comprehend dans Amazon QuickSight.

Vous pouvez utiliser le nouveau type visuel de nuage de mots pour les entités, au lieu de l'arborescence. Dans le menu du graphique en nuage de mots, sélectionnez Masquer les «autres» catégories.

Vous disposez maintenant d'un tableau de bord avec des visualisations de sentiments et d'entités qui ressemble à la capture d'écran suivante.

Dépannage

Si votre requête échoue, vérifiez le Amazon Cloud Watch métriques et journaux générés par la fonction UDF Lambda.

Sur la console Lambda, recherchez le textanalytics-udf la fonction.
Selectionnez Le Monitoring.

Vous pouvez afficher les métriques CloudWatch indiquant la fréquence d'exécution de la fonction, sa durée d'exécution, sa fréquence d'échec, etc.

Selectionnez Afficher les journaux dans CloudWatch pour ouvrir les flux du journal des fonctions pour obtenir des informations de dépannage supplémentaires.

Pour plus d'informations sur l'affichage des métriques CloudWatch via Lambda, consultez Utilisation de la console Lambda.

Cas d'utilisation supplémentaires

Il existe de nombreux cas d'utilisation des fonctions d'analyse de texte SQL. En plus de l'exemple montré dans cet article, tenez compte des éléments suivants:

Simplifiez les pipelines ETL en utilisant des requêtes SQL incrémentielles pour enrichir les données textuelles avec des sentiments et des entités, comme le streaming de flux de médias sociaux ingérés par Firehose de données Amazon Kinesis
Utilisez les requêtes SQL pour explorer les sentiments et les entités dans vos textes de support client, e-mails et cas de support
Préparez des ensembles de données prêts pour la recherche en supprimant les informations personnelles à partir des interactions client ou patient
Standardiser de nombreuses langues dans une seule langue commune

Vous pouvez avoir des cas d'utilisation supplémentaires pour ces fonctions, ou des fonctionnalités supplémentaires que vous souhaitez voir ajoutées, telles que les suivantes:

Fonctions SQL pour appeler la reconnaissance d'entité personnalisée et les modèles de classification personnalisés dans Amazon Comprehend
Fonctions SQL pour la désidentification: étendre les fonctions de rédaction d'entités et d'informations personnelles pour remplacer les entités par des identificateurs uniques alternatifs

De plus, l'implémentation est open source, ce qui signifie que vous pouvez cloner le dépôt, modifier et étendre les fonctions comme bon vous semble et (espérons-le) nous envoyer des pull requests afin que nous puissions fusionner vos améliorations dans le projet et l'améliorer pour tout le monde.

Nettoyer

Une fois ce didacticiel terminé, vous souhaiterez peut-être nettoyer toutes les ressources AWS que vous ne souhaitez plus utiliser. Les ressources AWS actives peuvent continuer à entraîner des frais dans votre compte.

Dans Athena, exécutez la requête suivante pour supprimer la base de données et toutes les tables:
```
DROP DATABASE comprehendresults CASCADE
```

Dans AWS CloudFormation, supprimez la pile serverlessrepo-TextAnalyticsUDFHandler.
Annuler votre abonnement QuickSight.

Conclusion

Je vous ai montré comment installer l'exemple de fonction d'analyse de texte UDF Lambda pour Athena, afin que vous puissiez utiliser des requêtes SQL simples pour traduire du texte à l'aide d'Amazon Translate, générer des informations à partir de texte à l'aide d'Amazon Comprehend et biffer des informations sensibles. J'espère que vous trouverez cela utile et que vous partagerez des exemples de la façon dont vous pouvez l'utiliser pour simplifier vos architectures et mettre en œuvre de nouvelles fonctionnalités pour votre entreprise.

Veuillez partager vos réflexions avec nous dans la section commentaires, ou dans la section problèmes du projet GitHub référentiel.

Annexe: Référence des fonctions disponibles

Cette section résume les fonctions actuellement fournies. Le README Le fichier fournit des détails supplémentaires.

Détecter la langue

Cette fonction utilise Amazon Comprehend BatchDetectLanguedominante API pour identifier la langue dominante sur la base des 5,000 XNUMX premiers octets de texte d'entrée.

Le code suivant renvoie un code de langue, tel que fr pour le français ou en pour l'anglais:

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

Le code suivant renvoie un tableau au format JSON de codes de langue et les scores de confiance correspondants:

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

Détecter le sentiment

Cette fonction utilise Amazon Comprehend LotDetectSentiment API pour identifier le sentiment en fonction des 5,000 XNUMX premiers octets de texte d'entrée.

Le code suivant renvoie un sentiment comme POSITIF, NÉGATIF, NEUTRE ou MIXTE:

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

Le code suivant renvoie un objet au format JSON contenant les scores de sentiment et de confiance détectés pour chaque valeur de sentiment:

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

Détecter les entités

Cette fonction utilise Amazon Comprehend Détecter les entités API pour identifier les PII. Le texte d'entrée de plus de 5,000 XNUMX octets entraîne plusieurs appels d'API Amazon Comprehend.

Le code suivant renvoie un objet au format JSON contenant un tableau de types d'entités et valeurs:

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

Le code suivant renvoie un objet au format JSON contenant un tableau de types d'entités PII, avec leurs valeurs, scores et décalages de caractères:

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

Biffer les entités

Cette fonction remplace les valeurs d'entité pour les types d'entités spécifiés par "[ENTITY_TYPE]». Le texte d'entrée de plus de 5,000 XNUMX octets entraîne plusieurs appels d'API Amazon Comprehend. Voir le code suivant:

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

La commande renvoie une version expurgée sur la chaîne d'entrée. Spécifiez un ou plusieurs types d'entités à biffer en fournissant une liste d'éléments valides séparés par des virgules types dans le paramètre de chaîne types, ou ALL pour biffer tous les types.

Détecter les informations personnelles

Cette fonction utilise le Détecter les entités Pii API pour identifier les PII. Le texte d'entrée de plus de 5,000 XNUMX octets entraîne plusieurs appels d'API Amazon Comprehend.

Le code suivant renvoie un objet au format JSON contenant un tableau de Types d'entités PII et valeurs:

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

Le code suivant renvoie un objet au format JSON contenant un tableau de types d'entités PII, avec leurs scores et leurs décalages de caractères:

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

Réduire les informations personnelles

Cette fonction remplace les valeurs PII pour les types d'entités PII spécifiés par "[PII_ENTITY_TYPE]». Le texte d'entrée de plus de 5,000 XNUMX octets entraîne plusieurs appels d'API Amazon Comprehend. Voir le code suivant:

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

La fonction renvoie une version expurgée sur la chaîne d'entrée. Spécifiez un ou plusieurs Types d'entités PII à biffer en fournissant une liste de types valides séparés par des virgules dans le type paramètre de chaîne, ou ALL pour biffer tout type.

Traduire du texte

Cette fonction traduit le texte de la langue source vers la langue cible. Le texte d'entrée de plus de 5,000 XNUMX octets entraîne plusieurs appels d'API Amazon Translate. Voir le code suivant:

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

La fonction renvoie la chaîne traduite. Si vous le souhaitez, détectez automatiquement la langue source (utilisez auto comme code de langue, qui utilise Amazon Comprehend), et spécifiez éventuellement un terminologie personnalisée (sinon utilisez NULL en customTerminologyName).

À propos de l’auteur

Bob Strahan est un architecte de solutions principal au sein de l'équipe AWS Language AI Services.

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

Intelligence de données générative

Traduire et analyser du texte à l'aide des fonctions SQL avec Amazon Athena, Amazon Translate et Amazon Comprehend