1. Visão geral
A API Natural Language permite extrair informações de textos não estruturados usando o machine learning do Google. Neste tutorial, você vai se concentrar no uso da biblioteca de cliente Python.
O que você vai aprender
- Como configurar seu ambiente
- Como fazer uma análise de sentimentos
- Como fazer uma análise de entidades
- Como fazer uma análise sintática
- Como fazer a classificação de conteúdo
- Como fazer a moderação de texto
O que é necessário
- um projeto do Google Cloud;
- Use um navegador, como o Chrome ou o Firefox.
- Familiaridade com o Python
Pesquisa
Como você vai usar este tutorial?
Como você classificaria sua experiência com Python?
Como você classificaria sua experiência com os serviços do Google Cloud?
2. Configuração e requisitos
Configuração de ambiente autoguiada
- Faça login no Console do Google Cloud e crie um novo projeto ou reutilize um existente. Crie uma conta do Gmail ou do Google Workspace, se ainda não tiver uma.
- O Nome do projeto é o nome de exibição para os participantes do projeto. É uma string de caracteres não usada pelas APIs do Google e pode ser atualizada quando você quiser.
- O ID do projeto precisa ser exclusivo em todos os projetos do Google Cloud e não pode ser mudado após a definição. O console do Cloud gera automaticamente uma string exclusiva. Em geral, não importa o que seja. Na maioria dos codelabs, é necessário fazer referência ao ID do projeto, normalmente identificado como
PROJECT_ID. Se você não gostar do ID gerado, crie outro aleatório. Se preferir, teste o seu e confira se ele está disponível. Ele não pode ser mudado após essa etapa e permanece durante o projeto. - Para sua informação, há um terceiro valor, um Número do projeto, que algumas APIs usam. Saiba mais sobre esses três valores na documentação.
- Em seguida, ative o faturamento no console do Cloud para usar os recursos/APIs do Cloud. A execução deste codelab não vai ser muito cara, se tiver algum custo. Para encerrar os recursos e evitar cobranças além deste tutorial, exclua os recursos criados ou exclua o projeto. Novos usuários do Google Cloud estão qualificados para o programa de US$ 300 de avaliação sem custos.
Inicie o Cloud Shell
Embora o Google Cloud possa ser operado remotamente do seu laptop, neste codelab usaremos o Cloud Shell, um ambiente de linha de comando executado no Cloud.
Ativar o Cloud Shell
- No Console do Cloud, clique em Ativar o Cloud Shell
.
Se esta for a primeira vez que você inicia o Cloud Shell, uma tela intermediária vai aparecer com a descrição dele. Se isso acontecer, clique em Continuar.
Leva apenas alguns instantes para provisionar e se conectar ao Cloud Shell.
Essa máquina virtual contém todas as ferramentas de desenvolvimento necessárias. Ela oferece um diretório principal persistente de 5 GB, além de ser executada no Google Cloud. Isso aprimora o desempenho e a autenticação da rede. Neste codelab, quase todo o trabalho pode ser feito com um navegador.
Depois de se conectar ao Cloud Shell, você vai ver que sua conta já está autenticada e que o projeto está configurado com o ID do seu projeto.
- Execute o seguinte comando no Cloud Shell para confirmar se a conta está autenticada:
gcloud auth list
Resposta ao comando
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
- Execute o comando a seguir no Cloud Shell para confirmar se o comando gcloud sabe sobre seu projeto:
gcloud config list project
Resposta ao comando
[core] project = <PROJECT_ID>
Se o projeto não estiver configurado, configure-o usando este comando:
gcloud config set project <PROJECT_ID>
Resposta ao comando
Updated property [core/project].
3. configuração do ambiente
Antes de começar a usar a API Natural Language, execute o seguinte comando no Cloud Shell para ativar a API:
gcloud services enable language.googleapis.com
Você verá algo como:
Operation "operations/..." finished successfully.
Agora você pode usar a API Natural Language.
Navegue até o diretório principal:
cd ~
Crie um ambiente virtual do Python para isolar as dependências:
virtualenv venv-language
Ative o ambiente virtual:
source venv-language/bin/activate
Instale o IPython, o Pandas e a biblioteca de cliente da API Natural Language:
pip install ipython pandas tabulate google-cloud-language
Você verá algo como:
... Installing collected packages: ... pandas ... ipython ... google-cloud-language Successfully installed ... google-cloud-language-2.11.0 ...
Agora você já pode usar a biblioteca de cliente da API Natural Language.
Nas próximas etapas, você vai usar um interpretador interativo chamado IPython, que foi instalado na etapa anterior. Inicie uma sessão executando ipython no Cloud Shell:
ipython
Você verá algo como:
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álise de sentimento
A análise de sentimento inspeciona o texto fornecido e identifica as opiniões emocionais predominantes nele, principalmente para determinar se os sentimentos expressos são positivos, negativos ou neutros, tanto no nível da frase quanto do documento. Isso é feito com o método analyze_sentiment, que retorna um AnalyzeSentimentResponse.
Copie o seguinte código na sua sessão do 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)}")
Faça uma análise:
# 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)
O resultado será semelhante a este:
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
Teste suas próprias frases.
Resumo
Nesta etapa, você fez uma análise de sentimento em uma string de texto.
5. Análise de entidades
A análise de entidade inspeciona o texto fornecido em busca de entidades conhecidas (substantivos próprios, como figuras públicas, pontos de referência etc.) e retorna informações sobre elas. Isso é feito com o método analyze_entities, que retorna um AnalyzeEntitiesResponse.
Copie o seguinte código na sua sessão do 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%"))
Faça uma análise:
# 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)
O resultado será semelhante a este:
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
Teste suas próprias frases mencionando outras entidades.
Resumo
Nesta etapa, você fez uma análise de entidades.
6. Análise sintática
A análise de sintaxe extrai informações linguísticas, dividindo o texto fornecido em uma série de frases e tokens (geralmente com base em limites de palavras) e apresentando uma análise mais detalhada desses tokens. Isso é feito com o método analyze_syntax, que retorna um AnalyzeSyntaxResponse.
Copie o seguinte código na sua sessão do 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"))
Faça uma análise:
# 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)
O resultado será semelhante a este:
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 | | | | | | | |
Teste suas próprias frases com outras estruturas sintáticas.
Se você se aprofundar nos insights de resposta, também vai encontrar as relações entre os tokens. Confira uma interpretação visual que mostra a análise sintática completa deste exemplo, uma captura de tela da demonstração da Natural Language on-line:
Resumo
Nesta etapa, você conseguiu fazer uma análise de sintaxe.
7. Classificação de conteúdo
A classificação de conteúdo analisa um documento e retorna uma lista de categorias de conteúdo que se aplicam ao texto encontrado no documento. Isso é feito com o método classify_text, que retorna um ClassifyTextResponse.
Copie o seguinte código na sua sessão do 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%"))
Faça uma análise:
# 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)
O resultado será semelhante a este:
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%
Teste suas próprias frases relacionadas a outras categorias. É necessário fornecer um bloco de texto (documento) com pelo menos 20 tokens (palavras e sinais de pontuação).
Resumo
Nesta etapa, você conseguiu fazer a classificação de conteúdo.
8. Moderação de texto
Desenvolvida com o mais recente modelo de fundação PaLM 2 do Google, a moderação de texto identifica uma ampla variedade de conteúdo nocivo, incluindo discurso de ódio, bullying e assédio sexual. Isso é feito com o método moderate_text, que retorna um ModerateTextResponse.
Copie o seguinte código na sua sessão do 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%"))
Faça uma análise:
# 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)
O resultado será semelhante a este:
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%
Teste suas próprias frases.
Resumo
Nesta etapa, você conseguiu fazer a moderação de texto.
9. Parabéns!
Você aprendeu a usar a API Natural Language com Python.
Limpar
Para limpar o ambiente de desenvolvimento, no Cloud Shell:
- Se você ainda estiver na sessão do IPython, volte ao shell:
exit - Pare de usar o ambiente virtual do Python:
deactivate - Exclua a pasta do ambiente virtual:
cd ~ ; rm -rf ./venv-language
Para excluir seu projeto do Google Cloud, no Cloud Shell:
- Recupere o ID do projeto atual:
PROJECT_ID=$(gcloud config get-value core/project) - Confirme se este é o projeto que você quer excluir:
echo $PROJECT_ID - Excluir o projeto:
gcloud projects delete $PROJECT_ID
Saiba mais
- Teste a demonstração no navegador: https://cloud.google.com/natural-language#natural-language-api-demo
- Documentação da linguagem natural: https://cloud.google.com/natural-language/docs
- Python no Google Cloud: https://cloud.google.com/python
- Bibliotecas de cliente do Cloud para Python: https://github.com/googleapis/google-cloud-python
Licença
Este conteúdo está sob a licença Atribuição 2.0 Genérica da Creative Commons.