1. Descripción general
La API de Natural Language te permite extraer información de texto no estructurado con el aprendizaje automático de Google. En este instructivo, te enfocarás en el uso de la biblioteca cliente de Python.
Qué aprenderás
- Cómo configurar tu entorno
- Cómo realizar un análisis de opiniones
- Cómo realizar un análisis de entidades
- Cómo realizar un análisis sintáctico
- Cómo realizar una clasificación de contenido
- Cómo moderar un texto
Requisitos
Encuesta
¿Cómo usarás este instructivo?
¿Cómo calificarías tu experiencia en Python?
¿Cómo calificarías tu experiencia con los servicios de Google Cloud?
2. Configuración y requisitos
Configuración del entorno de autoaprendizaje
- Accede a Google Cloud Console y crea un proyecto nuevo o reutiliza uno existente. Si aún no tienes una cuenta de Gmail o de Google Workspace, debes crear una.
- El Nombre del proyecto es el nombre visible de los participantes de este proyecto. Es una cadena de caracteres que no se utiliza en las APIs de Google. Puedes actualizarla cuando quieras.
- El ID del proyecto es único en todos los proyectos de Google Cloud y es inmutable (no se puede cambiar después de configurarlo). La consola de Cloud genera automáticamente una cadena única. Por lo general, no importa cuál sea. En la mayoría de los codelabs, deberás hacer referencia al ID de tu proyecto (suele identificarse como
PROJECT_ID
). Si no te gusta el ID que se generó, podrías generar otro aleatorio. También puedes probar uno propio y ver si está disponible. No se puede cambiar después de este paso y se usa el mismo durante todo el proyecto. - Recuerda que hay un tercer valor, un número de proyecto, que usan algunas APIs. Obtén más información sobre estos tres valores en la documentación.
- A continuación, deberás habilitar la facturación en la consola de Cloud para usar las APIs o los recursos de Cloud. Ejecutar este codelab no costará mucho, tal vez nada. Para cerrar recursos y evitar que se generen cobros más allá de este instructivo, puedes borrar los recursos que creaste o borrar el proyecto. Los usuarios nuevos de Google Cloud son aptos para participar en el programa Prueba gratuita de $300.
Inicia Cloud Shell
Si bien Google Cloud se puede operar de manera remota desde tu laptop, en este codelab usarás Cloud Shell, un entorno de línea de comandos que se ejecuta en la nube.
Activar Cloud Shell
- En la consola de Cloud, haz clic en Activar Cloud Shell.
Si es la primera vez que inicias Cloud Shell, verás una pantalla intermedia que describe en qué consiste. Si apareció una pantalla intermedia, haz clic en Continuar.
El aprovisionamiento y la conexión a Cloud Shell solo tomará unos minutos.
Esta máquina virtual está cargada con todas las herramientas de desarrollo necesarias. Ofrece un directorio principal persistente de 5 GB y se ejecuta en Google Cloud, lo que mejora considerablemente el rendimiento de la red y la autenticación. Gran parte de tu trabajo en este codelab, si no todo, se puede hacer con un navegador.
Una vez que te conectes a Cloud Shell, deberías ver que estás autenticado y que el proyecto está configurado con tu ID del proyecto.
- En Cloud Shell, ejecuta el siguiente comando para confirmar que tienes la autenticación:
gcloud auth list
Resultado del comando
Credentialed Accounts ACTIVE ACCOUNT * <my_account>@<my_domain.com> To set the active account, run: $ gcloud config set account `ACCOUNT`
- Ejecuta el siguiente comando en Cloud Shell para confirmar que el comando de gcloud conoce tu proyecto:
gcloud config list project
Resultado del comando
[core] project = <PROJECT_ID>
De lo contrario, puedes configurarlo con el siguiente comando:
gcloud config set project <PROJECT_ID>
Resultado del comando
Updated property [core/project].
3. Configuración del entorno
Antes de comenzar a usar la API de Natural Language, ejecuta el siguiente comando en Cloud Shell para habilitarla:
gcloud services enable language.googleapis.com
Debería ver algo como esto:
Operation "operations/..." finished successfully.
Ahora, puedes usar la API de Natural Language.
Navega a tu directorio principal:
cd ~
Crea un entorno virtual de Python para aislar las dependencias:
virtualenv venv-language
Activa el entorno virtual:
source venv-language/bin/activate
Instala IPython, Pandas y la biblioteca cliente de la API de Natural Language:
pip install ipython pandas tabulate google-cloud-language
Debería ver algo como esto:
... Installing collected packages: ... pandas ... ipython ... google-cloud-language Successfully installed ... google-cloud-language-2.11.0 ...
Ahora, está todo listo para usar la biblioteca cliente de la API de Natural Language.
En los siguientes pasos, usarás un intérprete de Python interactivo llamado IPython, que instalaste en el paso anterior. Para iniciar una sesión, ejecuta ipython
en Cloud Shell:
ipython
Debería ver algo como esto:
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. Análisis de opiniones
El análisis de opiniones inspecciona el texto dado e identifica las opiniones emocionales predominantes en él, especialmente para determinar las opiniones expresadas como positivas, negativas o neutras, tanto a nivel de la oración como del documento. Se realiza con el método analyze_sentiment
, que muestra un AnalyzeSentimentResponse
.
Copia el siguiente código en tu sesión de 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)}")
Realiza un análisis:
# 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)
Deberías ver un resultado como el siguiente:
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
Tómate un momento para probar tus propias oraciones.
Resumen
En este paso, pudiste realizar un análisis de opiniones en una cadena de texto.
5. Análisis de entidades
El análisis de entidades inspecciona el texto dado en busca de entidades conocidas (nombres propios como figuras públicas, puntos de referencia, etc.) y muestra información sobre esas entidades. Se realiza con el método analyze_entities
, que muestra un AnalyzeEntitiesResponse
.
Copia el siguiente código en tu sesión de 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%"))
Realiza un análisis:
# 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)
Deberías ver un resultado como el siguiente:
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
Tómate un momento para probar tus propias oraciones en las que mencionen a otras entidades.
Resumen
En este paso, pudiste realizar un análisis de entidades.
6. Análisis sintáctico
El análisis sintáctico extrae información lingüística mediante la división del texto dado en una serie de oraciones y tokens (generalmente basados en límites de palabras) para proporcionar un análisis más detallado sobre esos tokens. Se realiza con el método analyze_syntax
, que muestra un AnalyzeSyntaxResponse
.
Copia el siguiente código en tu sesión de 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"))
Realiza un análisis:
# 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)
Deberías ver un resultado como el siguiente:
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 | | | | | | | |
Tómate un momento para probar tus propias oraciones con otras estructuras sintácticas.
Si profundizas en las estadísticas de las respuestas, también encontrarás las relaciones entre los tokens. Esta es una interpretación visual que muestra el análisis sintáctico completo para este ejemplo, una captura de pantalla de la demostración en línea de Natural Language:
Resumen
En este paso, pudiste realizar el análisis sintáctico.
7. Clasificación de contenido
La clasificación de contenido analiza un documento y devuelve una lista de categorías de contenido que se aplican al texto del documento. Se realiza con el método classify_text
, que muestra un ClassifyTextResponse
.
Copia el siguiente código en tu sesión de 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%"))
Realiza un análisis:
# 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)
Deberías ver un resultado como el siguiente:
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%
Tómate un momento para probar tus propias oraciones relacionadas con otras categorías. Ten en cuenta que debes proporcionar un bloque de texto (documento) con al menos veinte tokens (palabras y signos de puntuación).
Resumen
En este paso, pudiste realizar una clasificación de contenido.
8. Moderación de texto
Con la tecnología del modelo de base PaLM 2 más reciente de Google, la moderación de textos identifica una amplia variedad de contenido dañino, como la incitación al odio o a la violencia, el bullying y el acoso sexual. Se realiza con el método moderate_text
, que muestra un ModerateTextResponse
.
Copia el siguiente código en tu sesión de 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%"))
Realiza un análisis:
# 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)
Deberías ver un resultado como el siguiente:
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%
Tómate un momento para probar tus propias oraciones.
Resumen
En este paso, pudiste realizar una moderación de texto.
9. ¡Felicitaciones!
Aprendiste a usar la API de Natural Language con Python.
Limpia
Para limpiar tu entorno de desarrollo, desde Cloud Shell, haz lo siguiente:
- Si aún estás en la sesión de IPython, vuelve a la shell:
exit
- Deja de usar el entorno virtual de Python:
deactivate
- Borra tu carpeta de entorno virtual:
cd ~ ; rm -rf ./venv-language
Para borrar tu proyecto de Google Cloud de Cloud Shell, haz lo siguiente:
- Recupera el ID de tu proyecto actual:
PROJECT_ID=$(gcloud config get-value core/project)
- Asegúrate de que este sea el proyecto que quieres borrar:
echo $PROJECT_ID
- Borrar el proyecto:
gcloud projects delete $PROJECT_ID
Más información
- Prueba la demostración en tu navegador: https://cloud.google.com/natural-language#natural-language-api-demo
- Documentación de Natural Language: https://cloud.google.com/natural-language/docs
- Python en Google Cloud: https://cloud.google.com/python
- Bibliotecas cliente de Cloud para Python: https://github.com/googleapis/google-cloud-python
Licencia
Este trabajo cuenta con una licencia Atribución 2.0 Genérica de Creative Commons.