1. Übersicht
Mit der Natural Language API können Sie Informationen aus unstrukturiertem Text extrahieren, indem Sie Machine Learning von Google nutzen. In dieser Anleitung konzentrieren Sie sich auf die Verwendung der Python-Clientbibliothek.
Lerninhalte
- Umgebung einrichten
- Sentimentanalyse durchführen
- Entitätsanalyse durchführen
- Syntaxanalyse durchführen
- Inhaltsklassifizierung durchführen
- Text moderieren
Voraussetzungen
Umfrage
Wie werden Sie diese Anleitung verwenden?
Wie würden Sie Ihre Erfahrung mit Python bewerten?
Wie würden Sie Ihre Erfahrungen mit Google Cloud-Diensten bewerten?
2. Einrichtung und Anforderungen
Umgebung zum selbstbestimmten Lernen einrichten
- Melden Sie sich in der Google Cloud Console an und erstellen Sie ein neues Projekt oder verwenden Sie ein vorhandenes. Wenn Sie noch kein Gmail- oder Google Workspace-Konto haben, müssen Sie eines erstellen.
- Der Projektname ist der Anzeigename für die Teilnehmer dieses Projekts. Es handelt sich um einen String, der nicht von Google APIs verwendet wird. Sie können sie jederzeit aktualisieren.
- Die Projekt-ID ist für alle Google Cloud-Projekte eindeutig und unveränderlich (kann nach dem Festlegen nicht mehr geändert werden). In der Cloud Console wird automatisch ein eindeutiger String generiert. Normalerweise ist es nicht wichtig, wie dieser String aussieht. In den meisten Codelabs müssen Sie auf Ihre Projekt-ID verweisen (in der Regel als
PROJECT_IDangegeben). Wenn Ihnen die generierte ID nicht gefällt, können Sie eine andere zufällige ID generieren. Alternativ können Sie es mit einem eigenen Namen versuchen und sehen, ob er verfügbar ist. Sie kann nach diesem Schritt nicht mehr geändert werden und bleibt für die Dauer des Projekts bestehen. - Zur Information: Es gibt einen dritten Wert, die Projektnummer, die von einigen APIs verwendet wird. Weitere Informationen zu diesen drei Werten
- Als Nächstes müssen Sie die Abrechnung in der Cloud Console aktivieren, um Cloud-Ressourcen/-APIs zu verwenden. Die Durchführung dieses Codelabs kostet wenig oder gar nichts. Wenn Sie Ressourcen herunterfahren möchten, um Kosten zu vermeiden, die über diese Anleitung hinausgehen, können Sie die erstellten Ressourcen oder das Projekt löschen. Neue Google Cloud-Nutzer können am kostenlosen Testzeitraum mit einem Guthaben von 300$ teilnehmen.
Cloud Shell starten
Während Sie Google Cloud von Ihrem Laptop aus per Fernzugriff nutzen können, wird in diesem Codelab Cloud Shell verwendet, eine Befehlszeilenumgebung, die in der Cloud ausgeführt wird.
Cloud Shell aktivieren
- Klicken Sie in der Cloud Console auf Cloud Shell aktivieren
.
Wenn Sie die Cloud Shell zum ersten Mal starten, wird ein Fenster mit einer Beschreibung eingeblendet. Klicken Sie in diesem Fall einfach auf Weiter.
Das Herstellen der Verbindung mit der Cloud Shell sollte nur wenige Augenblicke dauern.
Auf dieser virtuellen Maschine sind alle erforderlichen Entwicklungstools installiert. Sie bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und läuft in Google Cloud, was die Netzwerkleistung und Authentifizierung erheblich verbessert. Die meisten, wenn nicht sogar alle Aufgaben in diesem Codelab können mit einem Browser erledigt werden.
Sobald die Verbindung mit der Cloud Shell hergestellt ist, sehen Sie, dass Sie authentifiziert sind und für das Projekt Ihre Projekt-ID eingestellt ist.
- Führen Sie in der Cloud Shell den folgenden Befehl aus, um zu prüfen, ob Sie authentifiziert sind:
gcloud auth list
Befehlsausgabe
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
- Führen Sie den folgenden Befehl in Cloud Shell aus, um zu bestätigen, dass der gcloud-Befehl Ihr Projekt kennt:
gcloud config list project
Befehlsausgabe
[core] project = <PROJECT_ID>
Ist dies nicht der Fall, können Sie die Einstellung mit diesem Befehl vornehmen:
gcloud config set project <PROJECT_ID>
Befehlsausgabe
Updated property [core/project].
3. Umgebung einrichten
Bevor Sie die Natural Language API verwenden können, müssen Sie die API aktivieren. Führen Sie dazu den folgenden Befehl in Cloud Shell aus:
gcloud services enable language.googleapis.com
Auf dem Bildschirm sollte Folgendes zu sehen sein:
Operation "operations/..." finished successfully.
Jetzt können Sie die Natural Language API verwenden.
Wechseln Sie zu Ihrem Basisverzeichnis:
cd ~
Erstellen Sie eine virtuelle Python-Umgebung, um die Abhängigkeiten zu isolieren:
virtualenv venv-language
Aktivieren Sie die virtuelle Umgebung:
source venv-language/bin/activate
Installieren Sie IPython, Pandas und die Natural Language API-Clientbibliothek:
pip install ipython pandas tabulate google-cloud-language
Auf dem Bildschirm sollte Folgendes zu sehen sein:
... Installing collected packages: ... pandas ... ipython ... google-cloud-language Successfully installed ... google-cloud-language-2.11.0 ...
Jetzt können Sie die Natural Language API-Clientbibliothek verwenden.
In den nächsten Schritten verwenden Sie einen interaktiven Python-Interpreter namens IPython, den Sie im vorherigen Schritt installiert haben. Starten Sie eine Sitzung, indem Sie ipython in Cloud Shell ausführen:
ipython
Auf dem Bildschirm sollte Folgendes zu sehen sein:
Python 3.9.2 (default, Feb 28 2021, 17:03:44) Type 'copyright', 'credits' or 'license' for more information IPython 8.15.0 -- An enhanced Interactive Python. Type '?' for help. In [1]:
4. Sentimentanalyse
Bei der Sentimentanalyse wird der angegebene Text untersucht und die vorherrschenden emotionalen Meinungen im Text werden ermittelt. Insbesondere wird festgestellt, ob die geäußerten Meinungen auf Satz- und Dokumentebene positiv, negativ oder neutral sind. Dies geschieht mit der analyze_sentiment-Methode, die eine AnalyzeSentimentResponse zurückgibt.
Kopieren Sie den folgenden Code in Ihre IPython-Sitzung:
from google.cloud import language
def analyze_text_sentiment(text: str) -> language.AnalyzeSentimentResponse:
client = language.LanguageServiceClient()
document = language.Document(
content=text,
type_=language.Document.Type.PLAIN_TEXT,
)
return client.analyze_sentiment(document=document)
def show_text_sentiment(response: language.AnalyzeSentimentResponse):
import pandas as pd
columns = ["score", "sentence"]
data = [(s.sentiment.score, s.text.content) for s in response.sentences]
df_sentence = pd.DataFrame(columns=columns, data=data)
sentiment = response.document_sentiment
columns = ["score", "magnitude", "language"]
data = [(sentiment.score, sentiment.magnitude, response.language)]
df_document = pd.DataFrame(columns=columns, data=data)
format_args = dict(index=False, tablefmt="presto", floatfmt="+.1f")
print(f"At sentence level:\n{df_sentence.to_markdown(**format_args)}")
print()
print(f"At document level:\n{df_document.to_markdown(**format_args)}")
So führen Sie eine Analyse durch:
# Input
text = """
Python is a very readable language, which makes it easy to understand and maintain code.
It's simple, very flexible, easy to learn, and suitable for a wide variety of tasks.
One disadvantage is its speed: it's not as fast as some other programming languages.
"""
# Send a request to the API
analyze_sentiment_response = analyze_text_sentiment(text)
# Show the results
show_text_sentiment(analyze_sentiment_response)
Die Ausgabe sollte in etwa so aussehen:
At sentence level:
score | sentence
---------+------------------------------------------------------------------------------------------
+0.8 | Python is a very readable language, which makes it easy to understand and maintain code.
+0.9 | It's simple, very flexible, easy to learn, and suitable for a wide variety of tasks.
-0.4 | One disadvantage is its speed: it's not as fast as some other programming languages.
At document level:
score | magnitude | language
---------+-------------+------------
+0.4 | +2.2 | en
Nehmen Sie sich einen Moment Zeit, um Ihre eigenen Sätze zu testen.
Zusammenfassung
In diesem Schritt haben Sie eine Sentimentanalyse für einen Textstring durchgeführt.
5. Entitätsanalyse
Die Entitätsanalyse untersucht den angegebenen Text auf bekannte Entitäten (Eigennamen wie Personen des öffentlichen Lebens, Sehenswürdigkeiten usw.) und gibt Informationen zu diesen Entitäten zurück. Dies geschieht mit der analyze_entities-Methode, die eine AnalyzeEntitiesResponse zurückgibt.
Kopieren Sie den folgenden Code in Ihre IPython-Sitzung:
from google.cloud import language
def analyze_text_entities(text: str) -> language.AnalyzeEntitiesResponse:
client = language.LanguageServiceClient()
document = language.Document(
content=text,
type_=language.Document.Type.PLAIN_TEXT,
)
return client.analyze_entities(document=document)
def show_text_entities(response: language.AnalyzeEntitiesResponse):
import pandas as pd
columns = ("name", "type", "salience", "mid", "wikipedia_url")
data = (
(
entity.name,
entity.type_.name,
entity.salience,
entity.metadata.get("mid", ""),
entity.metadata.get("wikipedia_url", ""),
)
for entity in response.entities
)
df = pd.DataFrame(columns=columns, data=data)
print(df.to_markdown(index=False, tablefmt="presto", floatfmt=".0%"))
So führen Sie eine Analyse durch:
# Input
text = """Guido van Rossum is best known as the creator of Python,
which he named after the Monty Python comedy troupe.
He was born in Haarlem, Netherlands.
"""
# Send a request to the API
analyze_entities_response = analyze_text_entities(text)
# Show the results
show_text_entities(analyze_entities_response)
Die Ausgabe sollte in etwa so aussehen:
name | type | salience | mid | wikipedia_url ------------------+--------------+------------+-----------+------------------------------------------------------------- Guido van Rossum | PERSON | 50% | /m/01h05c | https://en.wikipedia.org/wiki/Guido_van_Rossum Python | ORGANIZATION | 38% | /m/05z1_ | https://en.wikipedia.org/wiki/Python_(programming_language) creator | PERSON | 5% | | Monty Python | PERSON | 3% | /m/04sd0 | https://en.wikipedia.org/wiki/Monty_Python comedy troupe | PERSON | 2% | | Haarlem | LOCATION | 1% | /m/0h095 | https://en.wikipedia.org/wiki/Haarlem Netherlands | LOCATION | 1% | /m/059j2 | https://en.wikipedia.org/wiki/Netherlands
Nehmen Sie sich einen Moment Zeit, um Ihre eigenen Sätze zu testen, in denen andere Rechtssubjekte erwähnt werden.
Zusammenfassung
In diesem Schritt haben Sie eine Entitätsanalyse durchgeführt.
6. Syntaxanalyse
Bei der Syntaxanalyse werden linguistische Informationen extrahiert. Dazu wird der angegebene Text in eine Reihe von Sätzen und Tokens (in der Regel auf Grundlage von Wortgrenzen) unterteilt und eine weitere Analyse dieser Tokens durchgeführt. Dies geschieht mit der analyze_syntax-Methode, die eine AnalyzeSyntaxResponse zurückgibt.
Kopieren Sie den folgenden Code in Ihre IPython-Sitzung:
from typing import Optional
from google.cloud import language
def analyze_text_syntax(text: str) -> language.AnalyzeSyntaxResponse:
client = language.LanguageServiceClient()
document = language.Document(
content=text,
type_=language.Document.Type.PLAIN_TEXT,
)
return client.analyze_syntax(document=document)
def get_token_info(token: Optional[language.Token]) -> list[str]:
parts = [
"tag",
"aspect",
"case",
"form",
"gender",
"mood",
"number",
"person",
"proper",
"reciprocity",
"tense",
"voice",
]
if not token:
return ["token", "lemma"] + parts
text = token.text.content
lemma = token.lemma if token.lemma != token.text.content else ""
info = [text, lemma]
for part in parts:
pos = token.part_of_speech
info.append(getattr(pos, part).name if part in pos else "")
return info
def show_text_syntax(response: language.AnalyzeSyntaxResponse):
import pandas as pd
tokens = len(response.tokens)
sentences = len(response.sentences)
columns = get_token_info(None)
data = (get_token_info(token) for token in response.tokens)
df = pd.DataFrame(columns=columns, data=data)
# Remove empty columns
empty_columns = [col for col in df if df[col].eq("").all()]
df.drop(empty_columns, axis=1, inplace=True)
print(f"Analyzed {tokens} token(s) from {sentences} sentence(s):")
print(df.to_markdown(index=False, tablefmt="presto"))
So führen Sie eine Analyse durch:
# Input
text = """Guido van Rossum is best known as the creator of Python.
He was born in Haarlem, Netherlands.
"""
# Send a request to the API
analyze_syntax_response = analyze_text_syntax(text)
# Show the results
show_text_syntax(analyze_syntax_response)
Die Ausgabe sollte in etwa so aussehen:
Analyzed 20 token(s) from 2 sentence(s): token | lemma | tag | case | gender | mood | number | person | proper | tense | voice -------------+---------+-------+------------+-----------+------------+----------+----------+----------+---------+--------- Guido | | NOUN | | | | SINGULAR | | PROPER | | van | | NOUN | | | | SINGULAR | | PROPER | | Rossum | | NOUN | | | | SINGULAR | | PROPER | | is | be | VERB | | | INDICATIVE | SINGULAR | THIRD | | PRESENT | best | well | ADV | | | | | | | | known | know | VERB | | | | | | | PAST | as | | ADP | | | | | | | | the | | DET | | | | | | | | creator | | NOUN | | | | SINGULAR | | | | of | | ADP | | | | | | | | Python | | NOUN | | | | SINGULAR | | PROPER | | . | | PUNCT | | | | | | | | He | | PRON | NOMINATIVE | MASCULINE | | SINGULAR | THIRD | | | was | be | VERB | | | INDICATIVE | SINGULAR | THIRD | | PAST | born | bear | VERB | | | | | | | PAST | PASSIVE in | | ADP | | | | | | | | Haarlem | | NOUN | | | | SINGULAR | | PROPER | | , | | PUNCT | | | | | | | | Netherlands | | NOUN | | | | SINGULAR | | PROPER | | . | | PUNCT | | | | | | | |
Nehmen Sie sich einen Moment Zeit, um Ihre eigenen Sätze mit anderen syntaktischen Strukturen zu testen.
Wenn Sie sich die Antwortstatistiken genauer ansehen, finden Sie auch die Beziehungen zwischen den Tokens. Hier ist eine visuelle Interpretation der vollständigen Syntaxanalyse für dieses Beispiel, ein Screenshot aus der Online-Natural Language-Demo:
Zusammenfassung
In diesem Schritt haben Sie eine Syntaxanalyse durchgeführt.
7. Inhaltsklassifizierung
Bei der Inhaltsklassifizierung wird ein Dokument analysiert und eine Liste der Inhaltskategorien zurückgegeben, die für den im Dokument gefundenen Text gelten. Dies geschieht mit der Methode classify_text, die eine ClassifyTextResponse zurückgibt.
Kopieren Sie den folgenden Code in Ihre IPython-Sitzung:
from google.cloud import language
def classify_text(text: str) -> language.ClassifyTextResponse:
client = language.LanguageServiceClient()
document = language.Document(
content=text,
type_=language.Document.Type.PLAIN_TEXT,
)
return client.classify_text(document=document)
def show_text_classification(text: str, response: language.ClassifyTextResponse):
import pandas as pd
columns = ["category", "confidence"]
data = ((category.name, category.confidence) for category in response.categories)
df = pd.DataFrame(columns=columns, data=data)
print(f"Text analyzed:\n{text}")
print(df.to_markdown(index=False, tablefmt="presto", floatfmt=".0%"))
So führen Sie eine Analyse durch:
# Input
text = """Python is an interpreted, high-level, general-purpose programming language.
Created by Guido van Rossum and first released in 1991, Python's design philosophy
emphasizes code readability with its notable use of significant whitespace.
"""
# Send a request to the API
classify_text_response = classify_text(text)
# Show the results
show_text_classification(text, classify_text_response)
Die Ausgabe sollte in etwa so aussehen:
Text analyzed: Python is an interpreted, high-level, general-purpose programming language. Created by Guido van Rossum and first released in 1991, Python's design philosophy emphasizes code readability with its notable use of significant whitespace. category | confidence --------------------------------------+-------------- /Computers & Electronics/Programming | 99% /Science/Computer Science | 99%
Nehmen Sie sich einen Moment Zeit, um Ihre eigenen Sätze zu anderen Kategorien zu testen. Sie müssen einen Textblock (Dokument) mit mindestens 20 Tokens (Wörtern und Satzzeichen) angeben.
Zusammenfassung
In diesem Schritt haben Sie die Inhaltsklassifizierung durchgeführt.
8. Text moderation
Die Textmoderation basiert auf dem neuesten PaLM 2-Foundation Model von Google und erkennt eine Vielzahl schädlicher Inhalte, darunter Hassrede, Mobbing und sexuelle Belästigung. Dies geschieht mit der Methode moderate_text, die eine ModerateTextResponse zurückgibt.
Kopieren Sie den folgenden Code in Ihre IPython-Sitzung:
from google.cloud import language
def moderate_text(text: str) -> language.ModerateTextResponse:
client = language.LanguageServiceClient()
document = language.Document(
content=text,
type_=language.Document.Type.PLAIN_TEXT,
)
return client.moderate_text(document=document)
def show_text_moderation(text: str, response: language.ModerateTextResponse):
import pandas as pd
def confidence(category: language.ClassificationCategory) -> float:
return category.confidence
columns = ["category", "confidence"]
categories = sorted(response.moderation_categories, key=confidence, reverse=True)
data = ((category.name, category.confidence) for category in categories)
df = pd.DataFrame(columns=columns, data=data)
print(f"Text analyzed:\n{text}")
print(df.to_markdown(index=False, tablefmt="presto", floatfmt=".0%"))
So führen Sie eine Analyse durch:
# Input
text = """I have to read Ulysses by James Joyce.
I'm a little over halfway through and I hate it.
What a pile of garbage!
"""
# Send a request to the API
response = moderate_text(text)
# Show the results
show_text_moderation(text, response)
Die Ausgabe sollte in etwa so aussehen:
Text analyzed: I have to read Ulysses by James Joyce. I'm a little over halfway through and I hate it. What a pile of garbage! category | confidence -----------------------+-------------- Toxic | 67% Insult | 58% Profanity | 53% Violent | 48% Illicit Drugs | 29% Religion & Belief | 27% Politics | 22% Death, Harm & Tragedy | 21% Finance | 18% Derogatory | 14% Firearms & Weapons | 11% Health | 10% Legal | 10% War & Conflict | 7% Public Safety | 5% Sexual | 4%
Nehmen Sie sich einen Moment Zeit, um Ihre eigenen Sätze zu testen.
Zusammenfassung
In diesem Schritt haben Sie die Textmoderation durchgeführt.
9. Glückwunsch!
Sie haben gelernt, wie Sie die Natural Language API mit Python verwenden.
Bereinigen
So bereinigen Sie Ihre Entwicklungsumgebung über Cloud Shell:
- Wenn Sie sich noch in Ihrer IPython-Sitzung befinden, kehren Sie zur Shell zurück:
exit - Beenden Sie die Verwendung der virtuellen Python-Umgebung:
deactivate - Löschen Sie den Ordner für die virtuelle Umgebung:
cd ~ ; rm -rf ./venv-language
So löschen Sie Ihr Google Cloud-Projekt über Cloud Shell:
- Rufen Sie Ihre aktuelle Projekt-ID ab:
PROJECT_ID=$(gcloud config get-value core/project) - Prüfen Sie, ob dies das Projekt ist, das Sie löschen möchten:
echo $PROJECT_ID - Projekt löschen:
gcloud projects delete $PROJECT_ID
Weitere Informationen
- Demo im Browser testen: https://cloud.google.com/natural-language#natural-language-api-demo
- Dokumentation zu Natural Language: https://cloud.google.com/natural-language/docs
- Python in Google Cloud: https://cloud.google.com/python
- Cloud-Clientbibliotheken für Python: https://github.com/googleapis/google-cloud-python
Lizenz
Dieser Text ist mit einer Creative Commons Attribution 2.0 Generic License lizenziert.