Tekst vertalen en analyseren met behulp van SQL-functies met Amazon Athena, Amazon Translate en Amazon Comprehend

U heeft Amazon eenvoudige opslagservice (Amazon S3) emmers vol bestanden met inkomende chats van klanten, productrecensies en feeds voor sociale media, in vele talen. Het is uw taak om de producten te identificeren waar mensen het over hebben, te bepalen of ze gelukkige of droevige gedachten uiten, hun opmerkingen in één gemeenschappelijke taal te vertalen en kopieën van de gegevens te maken voor uw bedrijfsanalisten met deze nieuwe informatie toegevoegd aan elk record. Bovendien moet u alle persoonlijk identificeerbare informatie (PII) verwijderen, zoals namen, adressen en creditcardnummers.

Je weet al hoe je het moet gebruiken Amazone Athene om gegevens in Amazon S3 te transformeren met behulp van eenvoudige SQL-opdrachten en de ingebouwde functies in Athena. Nu kunt u Athena ook gebruiken om tekstvelden te vertalen en te analyseren, dankzij Amazon Vertalen, Amazon begrijpt het, en de kracht van Athena User Defined Functions (UDF's).

Athena is een interactieve zoekservice waarmee u eenvoudig gegevens kunt analyseren die zijn opgeslagen in Amazon S3 met behulp van SQL. Amazon Comprehend is een Natural Language Processing (NLP) -service waarmee je gemakkelijk inzichten uit tekst kunt halen. Amazon Translate is een neurale automatische vertaalservice die snelle, hoogwaardige, betaalbare en aanpasbare taalvertalingen levert. In dit bericht laat ik je zien hoe je ze nu samen kunt gebruiken om de volgende acties uit te voeren:

Detecteer de dominante taal van een tekstveld
Detecteer het heersende sentiment: positief, negatief, geen van beide of beide
Entiteiten detecteren of redigeren (zoals items, plaatsen of hoeveelheden)
Detecteer of redigeer PII
Vertaal tekst van de ene taal naar de andere

Met dit bericht worden de volgende doelen bereikt:

Laat zien hoe u snel de tekstanalyse-functies instelt in uw eigen AWS-account (het is snel en eenvoudig!)
Leg kort uit hoe de functies werken
Bespreek prestaties en kosten
Geef een zelfstudie waarin we wat tekstanalyses uitvoeren op Amazon-productrecensies
Beschrijf alle beschikbare functies

We voegen een lijst met alle beschikbare functies toe aan het einde van het bericht; de volgende code toont enkele voorbeeldquery's en resultaten:

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

Installeer de tekstanalyse-UDF

Een Athena UDF gebruikt AWS Lambda om de functiecapaciteit te implementeren. Ik bespreek later in dit bericht meer details, maar je hoeft de innerlijke werking niet te begrijpen om de UDF voor tekstanalyse te gebruiken, dus laten we aan de slag gaan.

Installeer de voorgebouwde Lambda-functie met de volgende stappen:

Navigeer naar de TextAnalyticsUDFHandler toepassing in de AWS serverloze toepassingsrepository.
In de Applicatie-instellingen sectie, laat de instellingen op hun standaardwaarden staan.
kies Ik erken dat deze app aangepaste IAM-rollen maakt.
Kies Implementeren.

En dat is het! Nu heb je een nieuwe Lambda-functie genaamd textanalytics-udf U bent klaar om enkele tekstanalysequery's in Athena te proberen.

Als u liever vanaf de broncode bouwt en implementeert, raadpleegt u de instructies aan het einde van het GitHub-opslagplaats README.

Voer uw eerste tekstanalysequery uit

Als u nieuw bent bij Athena, wilt u misschien het Ermee beginnen gids.

Op het moment van schrijven is de Athena UDF-functie nog in preview. Om het in te schakelen, maakt u een Athena-werkgroep met de naam AmazonAthenaPreviewFunctionality en voer alle UDF-query's van die werkgroep uit.

Voer de volgende vraag in de SQL-editor in:

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

Je krijgt een simpel POSITIVE resultaat. Probeer het nu opnieuw, variërend van de invoertekst - probeer iets minder positiefs om te zien hoe de geretourneerde sentimentwaarde verandert.

Gebruik in plaats daarvan de volgende query om het sentiment samen met de vertrouwensscores voor elke potentiële sentimentwaarde te krijgen:

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

Nu krijg je een JSON-string met het sentiment en alle sentimentscores:

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

U kunt gebruik maken van de ingebouwde JSON-extractiefuncties in Athena op dit resultaat om de velden te extraheren voor verdere analyse.

Hoe de UDF werkt

Zie voor meer informatie over het Athena UDF-framework Query's uitvoeren met door de gebruiker gedefinieerde functies.

De Java-klasse TextAnalyticsUDFHandler implementeert onze UDF Lambda-functiehandler. Elke tekstanalysefunctie heeft een overeenkomstige openbare methode in deze klasse.

Athena roept onze UDF Lambda-functie op met batches van invoerrecords. De TextAnalyticsUDFHandler verdeelt deze batches in kleinere batches van maximaal 25 rijen om te profiteren van de synchrone multi-document batch-API's van Amazon Comprehend waar ze beschikbaar zijn (bijvoorbeeld voor het detecteren van taal, entiteiten en sentiment). Als er geen synchrone multi-document API beschikbaar is (zoals voor DetectPiiEntity en TranslateText), gebruiken we in plaats daarvan de API voor één document.

Amazon begrijpt API servicequota zorg voor vangrails om uw blootstelling aan kosten door onbedoeld intensief gebruik te beperken (we bespreken dit meer in de volgende sectie). Standaard verwerken de batch-API's voor meerdere documenten tot 250 records per seconde en verwerken de API's voor één document tot 20 records per seconde. Onze UDF's gebruiken exponentiële back-off en proberen opnieuw om de verzoeksnelheid te vertragen om binnen deze limieten te blijven. U kunt een verhoging van het aantal transacties per seconde voor API's aanvragen met behulp van de Sjabloon voor quotumaanvraag op de AWS-beheerconsole.

Amazon Comprehend en Amazon Translate dwingen elk een maximale invoertekenreeks af van 5,000 utf-8 bytes. Tekstvelden die langer zijn dan 5,000 utf-8 bytes worden afgekapt tot 5,000 bytes voor taal- en sentimentdetectie, en op zinsgrenzen gesplitst in meerdere tekstblokken van minder dan 5,000 bytes voor vertaling en entiteits- of PII-detectie en redactie. De resultaten worden vervolgens gecombineerd.

Kosten optimaliseren

Naast de kosten voor Athena-zoekopdrachten, brengt de tekstanalyse-UDF gebruikskosten met zich mee van Lambda en Amazon Comprehend en Amazon Translate. Het bedrag dat u betaalt, is een factor van het totale aantal records en tekens dat u met de UDF verwerkt. Zie voor meer informatie AWS Lambda-prijzen, Amazon begrijpt prijzen en Amazon Translate-prijzen.

Om de kosten zo laag mogelijk te houden, raad ik aan om dezelfde records niet meerdere keren te verwerken. Realiseer in plaats daarvan de resultaten van de tekstanalyse-UDF door CREATE TABLE AS SELECT (CTAS)-query's te gebruiken om de resultaten vast te leggen in een aparte tabel die u vervolgens zo vaak als nodig kunt opvragen zonder extra UDF-kosten. Verwerk nieuw binnengekomen records stapsgewijs met behulp van INSERT IGNORE INTO...SELECT-query's om alleen de nieuwe records te analyseren en te verrijken en toe te voegen aan de doeltabel.

Voorkom dat u de tekstanalyse-functies onnodig aanroept op records die u later weggooit. Schrijf uw query's om de gegevensset eerst te filteren met behulp van tijdelijke tabellen, weergaven of geneste query's, en pas vervolgens de tekstanalysefuncties toe op de resulterende gefilterde records.

Beoordeel altijd de potentiële kosten voordat u tekstanalysequery's uitvoert op tabellen met een verschillend groot aantal records.

In deze sectie geven we twee voorbeelden van kostenramingen.

Voorbeeld 1: analyseer de taal en het sentiment van tweets

Laten we aannemen dat je 10,000 tweetrecords hebt, met een gemiddelde lengte van 100 tekens per tweet. Uw SQL-query detecteert de dominante taal en het sentiment voor elke tweet. Je zit in je tweede dienstjaar (de gratis laag is niet langer van toepassing). De kostengegevens zijn als volgt:

Grootte van elke tweet = 100 tekens
Aantal eenheden (100 tekens) per record (minimum is 3 eenheden) = 3
Totaal aantal eenheden: 10,000 (records) x 3 (eenheden per record) x 2 (Amazon Comprehend-verzoeken per record) = 60,000
Prijs per stuk = $ 0.0001
Totale kosten voor Amazon Comprehend = [aantal eenheden] x [kosten per eenheid] = 60,000 x $ 0.0001 = $ 6.00

Voorbeeld 2: tweets vertalen

Laten we aannemen dat 2,000 van uw tweets niet in uw lokale taal zijn, dus voert u een tweede SQL-query uit om ze te vertalen. De kostengegevens zijn als volgt:

Grootte van elke tweet = 100 tekens
Totaal aantal tekens: 2,000 (records) * 100 (tekens per record) x 1 (vertaalverzoeken per record) = 200,000
Prijs per teken = $ 0.000015
Totale kosten voor Amazon Translate = [aantal tekens] x [kosten per teken] = 200,000 x $ 0.000015 = $ 3.00

Analyseer inzichten uit klantrecensies

Het is tijd om onze nieuwe tekstanalysequery's te gebruiken.

Zie voor een tutorial over het verkrijgen van bruikbare inzichten uit klantrecensies Zelfstudie: inzichten uit klantrecensies analyseren met Amazon Comprehend Dit bericht biedt een alternatieve benadering van dezelfde uitdaging: het gebruik van SQL-query's mogelijk gemaakt door Athena en Amazon Comprehend.

De zelfstudie duurt ongeveer 10 minuten en kost tot $ 6 voor Amazon Comprehend. Er zijn geen kosten als je in aanmerking komt voor de gratis laag.

Maak een nieuwe database aan in Athena

Voer de volgende query uit in de Athena-queryeditor:

CREATE DATABASE IF NOT EXISTS comprehendresults;

Kies uw nieuwe database wanneer u uw gegevensbron aansluit.

Maak een brontabel met klantrecensiegegevens

We maken gebruik van de Amazon Klantrecensies Dataset, handig gehost voor openbare toegang in Amazon S3.

Voer de volgende query uit in de Athena-queryeditor:

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

Onder Tafels, zoek de nieuwe tabel amazon cialis_parquet.
Kies in het optiemenu Laad partities.

Bekijk een voorbeeld van de nieuwe tafel, amazon_reviews_parquet.

Voer de volgende query uit om de gemiddelde beoordelingsduur te bepalen:

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

De gemiddelde lengte van een recensie is ongeveer 365 tekens. Dit komt overeen met 4 Amazon Comprehend-eenheden per record (1 eenheid = 100 tekens).

Detecteer de taal voor elke recensie

Om de taal van elke recensie te achterhalen, voert u de volgende zoekopdracht uit in de Athena-zoekopdrachteditor - het duurt iets meer dan 1 minuut en kost $ 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

Deze query maakt een nieuwe tabel aan, amazon_reviews_with_language, met een nieuwe kolom toegevoegd: language De LIMIT-clausule beperkt het aantal records tot 5,000.

De kosten worden berekend als: 5,000 (records) x 4 (eenheden per record) x 1 (verzoeken per record) x $ 0.0001 (Amazon Comprehend-prijs per eenheid) = $ 2.

Voer de volgende zoekopdracht uit om de gedetecteerde taalcodes te zien, met het overeenkomstige aantal beoordelingen voor elke taal:

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

Detecteer sentiment en entiteiten voor elke recensie

Om sentiment te detecteren, voert u de volgende query uit in de Athena-queryeditor - deze gebruikt twee tekstanalysefuncties, duurt ongeveer 1 minuut en kost $ 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')

Deze query maakt een nieuwe tabel aan, amazon_reviews_with_text_analysis, met twee extra kolommen toegevoegd: sentiment en entities De WHERE-clausule beperkt de resultatenset tot de lijst met talen die worden ondersteund door Amazon Comprehend-sentiment en entiteitsdetectie.

De kosten worden berekend als: 5,000 (records) x 4 (eenheden per record) x 2 (verzoeken per record) x $ 0.0001 (Amazon Comprehend-prijs per eenheid) = $ 4.

Bekijk een voorbeeld van de nieuwe tabel en inspecteer enkele van de waarden voor de nieuwe sentiment en entities kolommen. Ze bevatten JSON-strings met geneste structuren en velden.

De volgende schermafbeelding toont de sentiment kolomdetails.

De volgende schermafbeelding toont de details van de entiteitenkolom.

Vervolgens gebruiken we de JSON-functies in Athena om deze kolommen voor analyse voor te bereiden.

Bereid sentiment voor op analyse

Voer de volgende SQL-query uit om een nieuwe tabel te maken met sentiment- en sentimentscores, uitgebreid in afzonderlijke kolommen:

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

Bekijk een voorbeeld van het nieuwe sentiment_results_final tabel (zie de volgende schermafbeelding). Komt het sentiment over het algemeen overeen met de tekst van het review_body veld? Hoe verhoudt het zich tot de star_rating Als u dubieuze sentimenttoewijzingen ziet, controleer dan de betrouwbaarheidsscores om te zien of het sentiment met een laag vertrouwen is toegewezen.

Bereid entiteiten voor op analyse

Voer de volgende SQL-query uit om een nieuwe tabel te maken met gedetecteerde entiteiten die niet zijn genest in afzonderlijke rijen (binnenste subquery), met elk veld in een aparte kolom (buitenste query):

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

Bekijk een voorbeeld van de inhoud van de nieuwe tabel, entities_results_final (zie de volgende schermafbeelding).

Visualiseer in Amazon QuickSight (optioneel)

Als optionele stap kunt u uw resultaten visualiseren met Amazon QuickSight. Voor instructies, zie Stap 5: Amazon Comprehend-uitvoer visualiseren in Amazon QuickSight.

U kunt het nieuwe visuele type woordwolk gebruiken voor entiteiten, in plaats van een boomstructuur. Selecteer in het word cloud-diagrammenu Verberg "andere" categorieën.

Je hebt nu een dashboard met visualisaties van sentiment en entiteiten dat lijkt op de volgende schermafbeelding.

Probleem oplossen

Als uw vraag mislukt, vinkt u het Amazon Cloud Watch metrische gegevens en logboeken die zijn gegenereerd door de UDF Lambda-functie.

Zoek op de Lambda-console het textanalytics-udf functie.
Kies Monitoren.

U kunt de CloudWatch-statistieken bekijken die laten zien hoe vaak de functie is uitgevoerd, hoe lang deze is uitgevoerd, hoe vaak deze is mislukt en meer.

Kies Bekijk logboeken in CloudWatch om de functielogboekstromen te openen voor meer inzicht in probleemoplossing.

Zie voor meer informatie over het bekijken van CloudWatch-statistieken via Lambda Met behulp van de Lambda-console.

Extra gebruiksscenario's

Er zijn veel use-cases voor SQL-tekstanalysefuncties. Houd naast het voorbeeld in dit bericht rekening met het volgende:

Vereenvoudig ETL-pijplijnen door incrementele SQL-query's te gebruiken om tekstgegevens te verrijken met sentiment en entiteiten, zoals het streamen van socialemediastreams die worden opgenomen door Amazon Kinesis-gegevens Firehose
Gebruik SQL-query's om sentiment en entiteiten in uw klantondersteuningsteksten, e-mails en ondersteuningsaanvragen te onderzoeken
Bereid onderzoeksklare datasets voor door PII uit klant- of patiëntinteracties te redigeren
Standaardiseer veel talen naar één gemeenschappelijke taal

Mogelijk hebt u aanvullende gebruiksscenario's voor deze functies, of extra mogelijkheden die u toegevoegd wilt zien, zoals de volgende:

SQL-functies om aangepaste entiteitsherkenning en aangepaste classificatiemodellen aan te roepen in Amazon Comprehend
SQL-functies voor de-identificatie - uitbreiding van de entiteit- en PII-redactiefuncties om entiteiten te vervangen door alternatieve unieke identifiers

Bovendien is de implementatie open source, wat betekent dat u de opslagplaats kunt klonen, de functies naar eigen inzicht kunt wijzigen en uitbreiden en (hopelijk) ons pull-verzoeken kunt sturen zodat we uw verbeteringen weer in het project kunnen samenvoegen en het beter kunt maken voor iedereen.

Schoonmaken

Nadat u deze zelfstudie heeft voltooid, wilt u misschien alle AWS-bronnen opschonen die u niet langer wilt gebruiken. Actieve AWS-resources kunnen kosten blijven maken in uw account.

Voer in Athena de volgende query uit om de database en alle tabellen te verwijderen:
```
DROP DATABASE comprehendresults CASCADE
```

Verwijder in AWS CloudFormation de stapel serverlessrepo-TextAnalyticsUDFHandler.
Zeg uw QuickSight-abonnement op.

Conclusie

Ik heb je laten zien hoe je de voorbeeldtekstanalyse UDF Lambda-functie voor Athena installeert, zodat je eenvoudige SQL-query's kunt gebruiken om tekst te vertalen met Amazon Translate, inzichten kunt genereren uit tekst met Amazon Comprehend en gevoelige informatie kunt redigeren. Ik hoop dat u dit nuttig vindt en voorbeelden deelt van hoe u het kunt gebruiken om uw architecturen te vereenvoudigen en nieuwe mogelijkheden voor uw bedrijf te implementeren.

Deel uw mening met ons in de commentarensectie of in de kwestiessectie van de projecten GitHub-repository.

Bijlage: Beschikbare functieverwijzing

Dit gedeelte geeft een overzicht van de functies die momenteel beschikbaar zijn. De README bestand biedt aanvullende details.

taal herkennen

Deze functie maakt gebruik van het Amazon Comprehend BatchDetectDominantTaal API om de dominante taal te identificeren op basis van de eerste 5,000 bytes aan invoertekst.

De volgende code retourneert een taalcode, zoals fr voor Frans of en voor Engels:

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

De volgende code retourneert een JSON-geformatteerde array van taalcodes en bijbehorende betrouwbaarheidsscores:

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

Detecteer sentiment

Deze functie maakt gebruik van het Amazon Comprehend BatchDetectSentiment API om het sentiment te identificeren op basis van de eerste 5,000 bytes aan invoertekst.

De volgende code retourneert een gevoel als POSITIEF, NEGATIEF, NEUTRAAL of GEMENGD:

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

De volgende code retourneert een object in JSON-indeling met gedetecteerde sentiment- en vertrouwensscores voor elke sentimentwaarde:

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

Detecteer entiteiten

Deze functie maakt gebruik van het Amazon Comprehend DetectEntiteiten API om PII te identificeren. Invoer van tekst die langer is dan 5,000 bytes resulteert in meerdere Amazon Comprehend API-aanroepen.

De volgende code retourneert een JSON-geformatteerd object met een array van entiteitstypen en waarden:

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

De volgende code retourneert een object in JSON-indeling dat een array van PII-entiteitstypen bevat, met hun waarden, scores en tekenoffsets:

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

Entiteiten redigeren

Deze functie vervangt entiteitswaarden voor de opgegeven entiteitstypen door “[ENTITY_TYPE] Invoer van tekst langer dan 5,000 bytes resulteert in meerdere Amazon Comprehend API-aanroepen. Zie de volgende code:

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

De opdracht retourneert een geredigeerde versie van de invoertekenreeks. Specificeer een of meer entiteitstypen redigeren door een door komma's gescheiden lijst met valid types in de parameter types string, of ALL om alle typen te redigeren.

Detecteer PII

Deze functie gebruikt de DetectPiiEntiteiten API om PII te identificeren. Invoer van tekst die langer is dan 5,000 bytes resulteert in meerdere Amazon Comprehend API-aanroepen.

De volgende code retourneert een JSON-geformatteerd object met een array van PII-entiteitstypen en waarden:

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

De volgende code retourneert een object in JSON-indeling dat een array van PII-entiteitstypen bevat, met hun scores en tekenoffsets:

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

PII redigeren

Deze functie vervangt de PII-waarden voor de opgegeven PII-entiteitstypen door '[PII_ENTITY_TYPE] Invoer van tekst langer dan 5,000 bytes resulteert in meerdere Amazon Comprehend API-aanroepen. Zie de volgende code:

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

De functie retourneert een geredigeerde versie van de invoertekenreeks. Specificeer een of meer PII-entiteitstypen redigeren door een door komma's gescheiden lijst van geldige typen in het type tekenreeksparameter, of ALL om alle typen te redigeren.

Tekst vertalen

Deze functie vertaalt tekst van de brontaal naar de doeltaal. Invoer van tekst die langer is dan 5,000 bytes resulteert in meerdere Amazon Translate API-aanroepen. Zie de volgende code:

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

De functie retourneert de vertaalde string. Detecteer optioneel de brontaal automatisch (gebruik auto als de taalcode, die Amazon Comprehend gebruikt), en specificeer optioneel een aangepaste terminologie (gebruik anders NULL For customTerminologyName).

Over de auteur

Bob Strahan is een Principal Solutions Architect in het AWS Language AI Services-team.

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

Generatieve data-intelligentie

Vertaal en analyseer tekst met behulp van SQL-functies met Amazon Athena, Amazon Translate en Amazon Comprehend