Cloud Natural Language API pozwala wyodrębniać elementy z tekstu, przeprowadzać analizę nastawienia i składni oraz klasyfikować tekst na kategorie.
W tym module dowiesz się, jak korzystać z interfejsu Natural Language API do analizowania encji, nastawienia i składni.
Czego się nauczysz:
- Tworzenie żądania interfejsu Natural Language API i wywoływanie interfejsu API za pomocą narzędzia curl
- Wyodrębnia elementy i przeprowadza analizę nastawienia w tekście za pomocą interfejsu Natural Language API
- Przeprowadzanie analizy lingwistycznej tekstu za pomocą interfejsu Natural Language API
- Tworzenie żądania w interfejsie Natural Language API w innym języku
Potrzebnie będzie
Jak będziesz korzystać z tego samouczka?
Jak oceniasz korzystanie z Google Cloud Platform?
Konfiguracja środowiska we własnym tempie
Jeśli nie masz jeszcze konta Google (Gmail lub Google Apps), musisz je utworzyć. Zaloguj się w konsoli Google Cloud Platform (console.cloud.google.com) i utwórz nowy projekt:
Zapamiętaj identyfikator projektu, unikalną nazwę we wszystkich projektach Google Cloud (powyższa nazwa została już użyta i nie będzie działać). W ćwiczeniach nazywamy je później PROJECT_ID.
Aby móc używać zasobów Google Cloud, musisz najpierw włączyć płatności w Cloud Console.
Ćwiczenia z programowania nie powinny kosztować więcej niż kilka dolarów, ale mogą być większe, jeśli zdecydujesz się wykorzystać więcej zasobów lub pozostawisz to uruchomione (zobacz sekcję „Czyszczenie” na końcu tego dokumentu).
Nowi użytkownicy Google Cloud Platform mogą skorzystać z bezpłatnej wersji próbnej o wartości 300 USD.
Kliknij ikonę menu w lewym górnym rogu ekranu.
Wybierz w menu Interfejsy API i usługi i kliknij Panel.
Kliknij Włącz interfejsy API i usługi.
Następnie w polu wyszukiwania wpisz "language". Kliknij Google Cloud Natural Language API:
Kliknij Włącz, aby włączyć interfejs Cloud Natural Language API:
Zaczekaj kilka sekund, aż funkcja zostanie włączona. Po włączeniu tej funkcji zobaczysz to:
Google Cloud Shell to środowisko wiersza poleceń działające w chmurze. Ta maszyna wirtualna oparta na Debianie jest wyposażona we wszystkie potrzebne narzędzia dla programistów (gcloud, bq, git i inne) i oferuje trwały katalog domowy o pojemności 5 GB. Wykorzystamy Cloud Shell do utworzenia żądania do interfejsu Natural Language API.
Aby rozpocząć korzystanie z Cloud Shell, kliknij ikonę „Aktywuj” w Google Cloud Shell" 
w prawym górnym rogu paska nagłówka
Sesja Cloud Shell otworzy się w nowej ramce u dołu konsoli, zostanie również wyświetlony monit wiersza poleceń. Poczekaj na wyświetlenie monitu użytkownik@projekt:~$
Ponieważ do wysyłania żądań do interfejsu Natural Language API będziemy używać narzędzia curl, musimy więc wygenerować klucz interfejsu API, aby przekazać nasz adres URL żądania. Aby utworzyć klucz interfejsu API, otwórz w Cloud Console sekcję „Dane logowania” w sekcji „Interfejsy API” dla usługi:
Z menu wybierz Klucz interfejsu API:
Następnie skopiuj wygenerowany przed chwilą klucz. Klucz ten będzie potrzebny w dalszej części modułu.
Po utworzeniu klucza interfejsu API zapisz go w środowisku środowiskowym, aby nie trzeba było wstawiać wartości klucza interfejsu API w każdym żądaniu. Możesz to zrobić w Cloud Shell. Pamiętaj, aby zastąpić fragment <your_api_key> przed chwilą skopiowanym kluczem.
export API_KEY=<YOUR_API_KEY>Pierwsza stosowana przez nas metoda Natural Language API to analyzeEntities. Dzięki tej metodzie interfejs API może wyodrębniać elementy (takie jak osoby, miejsca i zdarzenia) z tekstu. Aby wypróbować analizę encji w interfejsie API, użyjemy tego zdania:
Joanne Rowling, która pisze pod imionami pióra J. K. Rowling i Robert Galbraith to brytyjski powieściopisarz i scenarzysta, który napisał serię serii o Harrym Potterze.
Żądanie interfejsu API Natural Language utworzymy w pliku request.json. W środowisku Cloud Shell utwórz plik request.json, używając kodu poniżej. Możesz utworzyć ten plik, korzystając z jednego z preferowanych edytorów wiersza poleceń (nano, vim, emacs) lub wbudowanego edytora Orion w Cloud Shell:
request.json
{
"document":{
"type":"PLAIN_TEXT",
"content":"Joanne Rowling, who writes under the pen names J. K. Rowling and Robert Galbraith, is a British novelist and screenwriter who wrote the Harry Potter fantasy series."
},
"encodingType":"UTF8"
}W żądaniu informujemy interfejs Natural Language API o tekście, który zostanie wysłany. Obsługiwane wartości typów to PLAIN_TEXT lub HTML. W treści przekazujemy tekst do interfejsu Natural Language API, który mamy przeanalizować. Natural Language API obsługuje też wysyłanie plików przechowywanych w Cloud Storage do przetwarzania tekstu. Jeśli chcesz wysłać plik z Cloud Storage, zastąpmy content ciągiem gcsContentUri i prześlemy mu wartość naszego identyfikatora tekstowego w Cloud Storage. encodingType informuje interfejs API, który typ kodowania ma zostać użyty podczas przetwarzania tekstu. Interfejs API użyje go do obliczenia miejsca w tekście poszczególnych elementów.
Możesz teraz przekazywać treść żądania wraz ze zmienną środowiskową klucza interfejsu API zapisaną wcześniej do interfejsu Natural Language API za pomocą tego polecenia curl (wszystko w jednym wierszu poleceń):
curl "https://language.googleapis.com/v1/documents:analyzeEntities?key=${API_KEY}" \
-s -X POST -H "Content-Type: application/json" --data-binary @request.jsonPoczątek odpowiedzi powinien wyglądać następująco:
{
"entities": [
{
"name": "Robert Galbraith",
"type": "PERSON",
"metadata": {
"mid": "/m/042xh",
"wikipedia_url": "https://en.wikipedia.org/wiki/J._K._Rowling"
},
"salience": 0.7980405,
"mentions": [
{
"text": {
"content": "Joanne Rowling",
"beginOffset": 0
},
"type": "PROPER"
},
{
"text": {
"content": "Rowling",
"beginOffset": 53
},
"type": "PROPER"
},
{
"text": {
"content": "novelist",
"beginOffset": 96
},
"type": "COMMON"
},
{
"text": {
"content": "Robert Galbraith",
"beginOffset": 65
},
"type": "PROPER"
}
]
},
...
]
}Każda jednostka w odpowiedzi otrzymuje element type, powiązany URL z Wikipedii (jeśli istnieje), salience oraz indeksy dotyczące miejsc w tekście, w których występuje. przy czym waga jest tu liczbą w zakresie od 0 do 1, która informuje o tym, jak istotna jest dana encja w odniesieniu do całego tekstu; Natural Language API może też rozpoznawać ten sam podmiot na różne sposoby. Spójrz na listę mentions w odpowiedzi: interfejs API jest w stanie określić, czy &Joanne Rowling", "Rowling", "novelist" & "Robert Galbriath" wskazują na to samo.
Oprócz wyodrębniania elementów interfejs Natural Language API umożliwia także analizę nastawienia w bloku tekstowym. Żądanie JSON będzie zawierać te same parametry co żądanie opisane powyżej, ale tym razem zmienimy tekst, by dodać coś o silniejszym odczuciu. Zamień swój plik request.json na ten plik. Możesz też zastąpić content poniżej własnym tekstem:
request.json
{
"document":{
"type":"PLAIN_TEXT",
"content":"Harry Potter is the best book. I think everyone should read it."
},
"encodingType": "UTF8"
}Następnie wyślemy żądanie do punktu końcowego analyzeSentiment interfejsu API:
curl "https://language.googleapis.com/v1/documents:analyzeSentiment?key=${API_KEY}" \
-s -X POST -H "Content-Type: application/json" --data-binary @request.json
Odpowiedź powinna wyglądać tak:
{
"documentSentiment": {
"magnitude": 0.8,
"score": 0.4
},
"language": "en",
"sentences": [
{
"text": {
"content": "Harry Potter is the best book.",
"beginOffset": 0
},
"sentiment": {
"magnitude": 0.7,
"score": 0.7
}
},
{
"text": {
"content": "I think everyone should read it.",
"beginOffset": 31
},
"sentiment": {
"magnitude": 0.1,
"score": 0.1
}
}
]
}Zauważ, że otrzymujemy 2 rodzaje wartości nastawienia: nastawienie dla całego dokumentu i wyrażenia podzielone na zdanie. Metoda nastawienia zwraca 2 wartości: score i magnitude. score to liczba od -1,0 do 1,0 oznaczająca dodatnią lub negatywną ocenę wyrażenia. magnitude to liczba od 0 do nieskończoności, która reprezentuje wagę wyrażenia zawartego w wyrażeniu, niezależnie od tego, czy jest ona dodatnia czy ujemna. Większe bloki tekstu z wyrażeniami o dużej wadze mają większe wartości. Pierwszy wynik jest dodatni (0,7), a drugi – neutralny (0,1).
Oprócz podania szczegółów na temat całego dokumentu tekstowego, który wysyłamy do NL API, może ono też rozbić odczucia podmiotów występujących w tekście. Wykorzystaj to zdanie jako przykład:
Bardzo podobało mi się sushi, ale obsługa była straszna
W takim przypadku uzyskanie wyniku nastawienia dla całego zdania, tak jak powyżej, może nie być aż tak przydatne. Jeśli opinia o restauracji ma setki opinii, chcemy się dowiedzieć, co podoba się użytkownikom, a co nie. Na szczęście interfejs NL API ma metodę, która pozwala uzyskać opinię każdego podmiotu w tekście – analyzeEntitySentiment. Aby je wypróbować, zaktualizuj żądanie.json, dodając do niego zdanie powyżej:
request.json
{
"document":{
"type":"PLAIN_TEXT",
"content":"I liked the sushi but the service was terrible."
},
"encodingType": "UTF8"
}Następnie wywołaj punkt końcowy analyzeEntitySentiment za pomocą tego polecenia curl:
curl "https://language.googleapis.com/v1/documents:analyzeEntitySentiment?key=${API_KEY}" \
-s -X POST -H "Content-Type: application/json" --data-binary @request.json
W odpowiedzi zwracamy 2 obiekty encji: jeden dla &sut;sushi" jeden dla &service." Oto pełna odpowiedź JSON:
{
"entities": [
{
"name": "sushi",
"type": "CONSUMER_GOOD",
"metadata": {},
"salience": 0.52716845,
"mentions": [
{
"text": {
"content": "sushi",
"beginOffset": 12
},
"type": "COMMON",
"sentiment": {
"magnitude": 0.9,
"score": 0.9
}
}
],
"sentiment": {
"magnitude": 0.9,
"score": 0.9
}
},
{
"name": "service",
"type": "OTHER",
"metadata": {},
"salience": 0.47283158,
"mentions": [
{
"text": {
"content": "service",
"beginOffset": 26
},
"type": "COMMON",
"sentiment": {
"magnitude": 0.9,
"score": -0.9
}
}
],
"sentiment": {
"magnitude": 0.9,
"score": -0.9
}
}
],
"language": "en"
}
Widzimy, że wynik dla „sushi"” wynosi 0,9, podczas gdy "service" wynik wynosi -0,9. Super! Możesz też zauważyć, że dla każdego elementu zwracane są 2 obiekty nastawienia. Gdy jedno z tych haseł zostanie wspomniane więcej niż raz, interfejs API zwróci inny wynik nastawienia i wielkości każdego z nich, razem z pełnym nastawieniem do elementu.
Przyglądając się teraz trzeciej metodzie interfejsu Natural Language API – adnotacji składni – przejdziemy do bardziej szczegółowej wersji językowej naszego tekstu. analyzeSyntax to metoda, która zawiera pełny zestaw informacji o semantycznych i składnikowych elementach tekstu. W przypadku każdego słowa w tekście interfejs API podpowie część mowy (rzeczownik, czasownik, przymiotnik itp.) oraz zostanie odnosząca się do innych słów w zdaniu (czy jest to czasownik główny? modyfikator?).
Spróbujmy w kilku prostych słowach. Nasze żądanie JSON będzie podobne do powyższego, ale zostanie dodany klucz funkcji. Informuje to interfejs API, że chcemy korzystać z adnotacji o składni. Zastąp ciąg request.json:
request.json
{
"document":{
"type":"PLAIN_TEXT",
"content": "Hermione often uses her quick wit, deft recall, and encyclopaedic knowledge to help Harry and Ron."
},
"encodingType": "UTF8"
}Następnie wywołaj metodę analyzeSyntax interfejsu API:
curl "https://language.googleapis.com/v1/documents:analyzeSyntax?key=${API_KEY}" \
-s -X POST -H "Content-Type: application/json" --data-binary @request.jsonW odpowiedzi na każdy token w zdaniu powinien być zwracany obiekt podobny do poniższego. W tym artykule zapoznamy się z odpowiedzią na słowo „&”;
{
"text": {
"content": "uses",
"beginOffset": 15
},
"partOfSpeech": {
"tag": "VERB",
"aspect": "ASPECT_UNKNOWN",
"case": "CASE_UNKNOWN",
"form": "FORM_UNKNOWN",
"gender": "GENDER_UNKNOWN",
"mood": "INDICATIVE",
"number": "SINGULAR",
"person": "THIRD",
"proper": "PROPER_UNKNOWN",
"reciprocity": "RECIPROCITY_UNKNOWN",
"tense": "PRESENT",
"voice": "VOICE_UNKNOWN"
},
"dependencyEdge": {
"headTokenIndex": 2,
"label": "ROOT"
},
"lemma": "use"
}Podzielmy odpowiedź. partOfSpeech zawiera szczegółowe informacje językowe o każdym słowie (wiele z nich jest nieznanych, ponieważ nie dotyczą angielskiego ani tego konkretnego słowa). tag jest częścią mowy, w tym przypadku czasownik. Pobieramy też szczegóły dotyczące czasu, modalności oraz liczby pojedynczej lub mnogiej. lemma to kanoniczna postać słowa (&"use"it&&tt;use"). Na przykład słowa bieg, bieg, bieg i bieg zawierają dowolną kategorię. Wartość lemmy jest przydatna do śledzenia wystąpień słowa w dużym tekście.
dependencyEdge obejmuje dane, których możesz użyć do utworzenia drzewa analizy zależności tekstu. Ten schemat pokazuje, jak słowa w zdaniu są ze sobą powiązane. Analiza zależności dla powyższego zdania wygląda tak:
headTokenIndex w naszej odpowiedzi to indeks tokena z łukiem wskazującym &"uses". Każdy token w zdaniu możemy traktować jako słowo w tablicy, a headTokenIndex z 2 oznacza &"uses" oznacza słowo "często,", które jest połączone z drzewem.
Natural Language API obsługuje również języki inne niż angielski (pełną listę znajdziesz tutaj). Wypróbuj następujące żądanie elementu w języku japońskim:
request.json
{
"document":{
"type":"PLAIN_TEXT",
"content":"日本のグーグルのオフィスは、東京の六本木ヒルズにあります"
},
"encodingType": "UTF8"
}Zauważyliśmy, że interfejs API nie jest w stanie określić, w jakim języku jest dany tekst. Następnie wyślemy go do punktu końcowego analyzeEntities:
curl "https://language.googleapis.com/v1/documents:analyzeEntities?key=${API_KEY}" \
-s -X POST -H "Content-Type: application/json" --data-binary @request.jsonOto 2 pierwszych elementów w odpowiedzi:
{
"entities": [
{
"name": "日本",
"type": "LOCATION",
"metadata": {
"mid": "/m/03_3d",
"wikipedia_url": "https://en.wikipedia.org/wiki/Japan"
},
"salience": 0.23854347,
"mentions": [
{
"text": {
"content": "日本",
"beginOffset": 0
},
"type": "PROPER"
}
]
},
{
"name": "グーグル",
"type": "ORGANIZATION",
"metadata": {
"mid": "/m/045c7b",
"wikipedia_url": "https://en.wikipedia.org/wiki/Google"
},
"salience": 0.21155767,
"mentions": [
{
"text": {
"content": "グーグル",
"beginOffset": 9
},
"type": "PROPER"
}
]
},
...
]
"language": "ja"
}Interfejs API wyodrębnia Japonię jako lokalizację, a Google jako organizację – oraz strony każdej z Wikipedii dotyczące każdej z nich.
Wiesz już, jak przeprowadzać analizy tekstu za pomocą interfejsu Cloud Natural Language API, wyodrębniając elementy, analizując nastawienie lub używając adnotacji do składni.
Omawiane zagadnienia
- Tworzenie żądania interfejsu Natural Language API i wywoływanie interfejsu API za pomocą narzędzia curl
- Wyodrębnia elementy i przeprowadza analizę nastawienia w tekście za pomocą interfejsu Natural Language API
- Przeprowadzenie analizy lingwistycznej tekstu w celu utworzenia drzewo analizy zależności
- Tworzenie żądania interfejsu Natural Language API w języku japońskim
Następne kroki
- Przeczytaj samouczki dotyczące interfejsu Natural Language API w dokumentacji.
- Wypróbuj interfejsy Vision API i Speech API.