1. Présentation
L'API Natural Language vous permet d'extraire des informations d'un texte non structuré à l'aide du machine learning de Google. Dans ce tutoriel, vous allez vous concentrer sur l'utilisation de sa bibliothèque cliente Python.
Points abordés
- Configurer votre environnement
- Effectuer une analyse des sentiments
- Effectuer une analyse des entités
- Comment effectuer une analyse syntaxique
- Classification de contenu
- Modérer du texte
Prérequis
Enquête
Comment allez-vous utiliser ce tutoriel ?
Quel est votre niveau d'expérience avec Python ?
Comment évalueriez-vous votre expérience des services Google Cloud ?
<ph type="x-smartling-placeholder">2. Préparation
Configuration de l'environnement au rythme de chacun
- Connectez-vous à la console Google Cloud, puis créez un projet ou réutilisez un projet existant. (Si vous ne possédez pas encore de compte Gmail ou Google Workspace, vous devez en créer un.)
- Le nom du projet est le nom à afficher pour les participants au projet. Il s'agit d'une chaîne de caractères non utilisée par les API Google. Vous pourrez toujours le modifier.
- L'ID du projet est unique parmi tous les projets Google Cloud et non modifiable une fois défini. La console Cloud génère automatiquement une chaîne unique (en général, vous n'y accordez d'importance particulière). Dans la plupart des ateliers de programmation, vous devrez indiquer l'ID de votre projet (généralement identifié par
PROJECT_ID). Si l'ID généré ne vous convient pas, vous pouvez en générer un autre de manière aléatoire. Vous pouvez également en spécifier un et voir s'il est disponible. Après cette étape, l'ID n'est plus modifiable et restera donc le même pour toute la durée du projet. - Pour information, il existe une troisième valeur (le numéro de projet) que certaines API utilisent. Pour en savoir plus sur ces trois valeurs, consultez la documentation.
- Vous devez ensuite activer la facturation dans la console Cloud pour utiliser les ressources/API Cloud. L'exécution de cet atelier de programmation est très peu coûteuse, voire sans frais. Pour désactiver les ressources et éviter ainsi que des frais ne vous soient facturés après ce tutoriel, vous pouvez supprimer le projet ou les ressources que vous avez créées. Les nouveaux utilisateurs de Google Cloud peuvent participer au programme d'essai sans frais pour bénéficier d'un crédit de 300 $.
Démarrer Cloud Shell
Bien que Google Cloud puisse être utilisé à distance depuis votre ordinateur portable, vous allez utiliser Cloud Shell dans cet atelier de programmation, un environnement de ligne de commande exécuté dans le cloud.
Activer Cloud Shell
- Dans Cloud Console, cliquez sur Activer Cloud Shell
.
Si vous démarrez Cloud Shell pour la première fois, un écran intermédiaire vous explique de quoi il s'agit. Si un écran intermédiaire s'est affiché, cliquez sur Continuer.
Le provisionnement et la connexion à Cloud Shell ne devraient pas prendre plus de quelques minutes.
Cette machine virtuelle contient tous les outils de développement nécessaires. Elle comprend un répertoire d'accueil persistant de 5 Go et s'exécute dans Google Cloud, ce qui améliore considérablement les performances du réseau et l'authentification. Une grande partie, voire la totalité, de votre travail dans cet atelier de programmation peut être effectué dans un navigateur.
Une fois connecté à Cloud Shell, vous êtes authentifié et le projet est défini sur votre ID de projet.
- Exécutez la commande suivante dans Cloud Shell pour vérifier que vous êtes authentifié :
gcloud auth list
Résultat de la commande
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
- Exécutez la commande suivante dans Cloud Shell pour vérifier que la commande gcloud connaît votre projet:
gcloud config list project
Résultat de la commande
[core] project = <PROJECT_ID>
Si vous obtenez un résultat différent, exécutez cette commande :
gcloud config set project <PROJECT_ID>
Résultat de la commande
Updated property [core/project].
3. Cofiguration de l'environnement
Avant de pouvoir utiliser l'API Natural Language, vous devez l'activer en exécutant la commande suivante dans Cloud Shell:
gcloud services enable language.googleapis.com
L'écran qui s'affiche devrait ressembler à ce qui suit :
Operation "operations/..." finished successfully.
Vous pouvez maintenant utiliser l'API Natural Language.
Accédez à votre répertoire d'accueil:
cd ~
Créez un environnement virtuel Python pour isoler les dépendances:
virtualenv venv-language
Activez l'environnement virtuel :
source venv-language/bin/activate
Installez IPython, Pandas et la bibliothèque cliente de l'API Natural Language:
pip install ipython pandas tabulate google-cloud-language
L'écran qui s'affiche devrait ressembler à ce qui suit :
... Installing collected packages: ... pandas ... ipython ... google-cloud-language Successfully installed ... google-cloud-language-2.11.0 ...
Vous êtes maintenant prêt à utiliser la bibliothèque cliente de l'API Natural Language.
Dans les étapes suivantes, vous allez utiliser un interpréteur Python interactif appelé IPython, que vous avez installé à l'étape précédente. Démarrez une session en exécutant ipython dans Cloud Shell:
ipython
L'écran qui s'affiche devrait ressembler à ce qui suit :
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. Analyse des sentiments
L'analyse des sentiments examine le texte donné et identifie les opinions émotionnelles dominantes dans celui-ci, en particulier pour déterminer si les sentiments exprimés sont positifs, négatifs ou neutres, à la fois au niveau de la phrase et au niveau du document. Pour ce faire, utilisez la méthode analyze_sentiment qui renvoie un AnalyzeSentimentResponse.
Copiez le code suivant dans votre session IPython:
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)}")
Effectuez une analyse:
# 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)
Un résultat semblable aux lignes suivantes doit s'afficher:
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
Prenez un moment pour tester vos propres phrases.
Résumé
Au cours de cette étape, vous avez pu effectuer une analyse des sentiments sur une chaîne de texte.
5. Analyse des entités
L'analyse des entités inspecte le texte donné à la recherche d'entités connues (des noms propres tels que des personnages publics, des points de repère, etc.) et renvoie des informations sur ces entités. Pour ce faire, utilisez la méthode analyze_entities qui renvoie un AnalyzeEntitiesResponse.
Copiez le code suivant dans votre session IPython:
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%"))
Effectuez une analyse:
# 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)
Un résultat semblable aux lignes suivantes doit s'afficher:
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
Prenez un moment pour tester vos propres phrases mentionnant d'autres entités.
Résumé
Au cours de cette étape, vous avez pu effectuer une analyse des entités.
6. Analyse syntaxique
L'analyse syntaxique extrait les informations linguistiques en divisant le texte donné en une série de phrases et de jetons (généralement basés sur des limites de mots), en fournissant une analyse plus approfondie de ces jetons. Pour ce faire, utilisez la méthode analyze_syntax qui renvoie un AnalyzeSyntaxResponse.
Copiez le code suivant dans votre session IPython:
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"))
Effectuez une analyse:
# 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)
Un résultat semblable aux lignes suivantes doit s'afficher:
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 | | | | | | | |
Prenez un moment pour tester vos propres phrases avec d'autres structures syntaxiques.
Si vous examinez plus en détail les insights sur les réponses, vous trouverez également les relations entre les jetons. Voici une interprétation visuelle montrant l'analyse syntaxique complète de cet exemple. Il s'agit d'une capture d'écran de la démonstration en ligne Natural Language:
Résumé
Au cours de cette étape, vous avez pu effectuer une analyse syntaxique !
7. Classification de contenu
La classification de contenu analyse un document et renvoie une liste de catégories de contenu qui s'appliquent au texte présent dans le document. Pour ce faire, utilisez la méthode classify_text qui renvoie un ClassifyTextResponse.
Copiez le code suivant dans votre session IPython:
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%"))
Effectuez une analyse:
# 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)
Un résultat semblable aux lignes suivantes doit s'afficher:
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%
Prenez un moment pour tester vos propres phrases sur d'autres catégories. Notez que vous devez fournir un bloc de texte (document) contenant au moins vingt jetons (mots et signes de ponctuation).
Résumé
Au cours de cette étape, vous avez pu classer des contenus.
8. Modération de texte
Basée sur le dernier modèle de fondation PaLM 2 de Google, la modération de texte identifie un large éventail de contenus nuisibles, y compris l'incitation à la haine, l'intimidation et le harcèlement sexuel. Pour ce faire, utilisez la méthode moderate_text qui renvoie un ModerateTextResponse.
Copiez le code suivant dans votre session IPython:
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%"))
Effectuez une analyse:
# 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)
Un résultat semblable aux lignes suivantes doit s'afficher:
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%
Prenez un moment pour tester vos propres phrases.
Résumé
Au cours de cette étape, vous avez réussi à modérer le texte.
9. Félicitations !
Vous avez appris à utiliser l'API Natural Language avec Python.
Effectuer un nettoyage
Pour nettoyer votre environnement de développement à partir de Cloud Shell:
- Si vous êtes toujours dans votre session IPython, revenez au shell:
exit - Cessez d'utiliser l'environnement virtuel Python:
deactivate - Supprimez le dossier d'environnement virtuel:
cd ~ ; rm -rf ./venv-language.
Pour supprimer votre projet Google Cloud à partir de Cloud Shell, procédez comme suit:
- Récupérez l'ID de votre projet actuel:
PROJECT_ID=$(gcloud config get-value core/project) - Assurez-vous qu'il s'agit bien du projet que vous souhaitez supprimer:
echo $PROJECT_ID - Supprimez le projet:
gcloud projects delete $PROJECT_ID
En savoir plus
- Testez la démonstration dans votre navigateur: https://cloud.google.com/natural-language#natural-language-api-demo
- Documentation sur Natural Language: https://cloud.google.com/natural-language/docs
- Python sur Google Cloud: https://cloud.google.com/python
- Bibliothèques clientes Cloud pour Python: https://github.com/googleapis/google-cloud-python
Licence
Ce document est publié sous une licence Creative Commons Attribution 2.0 Generic.