Share via

Biblioteca de clientes do Azure Análise de Texto para Python – versão 5.3.0

  • Artigo

O Serviço Cognitivo do Azure para Linguagem é um serviço baseado em nuvem que fornece recursos de NLP (Processamento de Linguagem Natural) para entender e analisar texto e inclui os seguintes recursos de main:

  • Análise de Sentimento
  • Reconhecimento de Entidade Nomeada
  • Detecção de Idioma
  • Extração de Frases-Chave
  • Vinculação de Identidade
  • Análise múltipla
  • Detecção de PII (Informações de Identificação Pessoal)
  • Análise de Texto para integridade
  • Reconhecimento de Entidade Nomeada personalizado
  • Classificação de texto personalizada
  • Resumo de texto extrativo
  • Resumo de texto abstrativo

Código-fonte | Pacote (PyPI) | Pacote (Conda) | Documentação | de referência da APIDocumentação do produto | Amostras

Introdução

Pré-requisitos

Criar um recurso dos Serviços Cognitivos ou do Serviço de Linguagem

O serviço de Linguagem dá suporte ao acesso de vários serviços e de serviço único. Crie um recurso dos Serviços Cognitivos se você planeja acessar vários serviços cognitivos em um só ponto de extremidade/chave. Somente para acesso ao serviço de linguagem, crie um recurso de serviço de linguagem. Você pode criar o recurso usando o Portal do Azure ou a CLI do Azure seguindo as etapas neste documento.

A interação com o serviço usando a biblioteca de clientes começa com um cliente . Para criar um objeto cliente, você precisará dos Serviços Cognitivos ou do serviço endpoint de Linguagem para seu recurso e um credential que permita que você acesse:

from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient

credential = AzureKeyCredential("<api_key>")
text_analytics_client = TextAnalyticsClient(endpoint="https://<resource-name>.cognitiveservices.azure.com/", credential=credential)

Observe que, para alguns recursos dos Serviços Cognitivos, o ponto de extremidade pode parecer diferente do snippet de código acima. Por exemplo, https://<region>.api.cognitive.microsoft.com/.

Instalar o pacote

Instale a biblioteca de clientes do Azure Análise de Texto para Python com pip:

pip install azure-ai-textanalytics

import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient
endpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]
key = os.environ["AZURE_LANGUAGE_KEY"]

text_analytics_client = TextAnalyticsClient(endpoint, AzureKeyCredential(key))

Observe que 5.2.X e mais recentes são direcionados ao Serviço Cognitivo do Azure para APIs de Linguagem. Essas APIs incluem a análise de texto e os recursos de processamento de idioma natural encontrados nas versões anteriores do Análise de Texto biblioteca de clientes. Além disso, a API de serviço foi alterada de controle de versão semântico para baseado em data. Essa versão da biblioteca de clientes usa como padrão a versão mais recente da API com suporte, que atualmente é 2023-04-01.

Esta tabela mostra a relação entre as versões do SDK e as versões de API com suporte do serviço

Versão do SDK Versão da API do serviço com suporte
5.3.X – Versão estável mais recente 3.0, 3.1, 2022-05-01, 2023-04-01 (padrão)
5.2.X 3.0, 3.1, 2022-05-01 (padrão)
5.1.0 3.0, 3.1 (padrão)
5.0.0 3.0

A versão da API pode ser selecionada passando o argumento api_version palavra-chave para o cliente. Para os recursos mais recentes do serviço de linguagem, considere selecionar a versão mais recente da API beta. Para cenários de produção, a versão estável mais recente é recomendada. A configuração para uma versão mais antiga pode resultar em redução da compatibilidade de recursos.

Autenticar o cliente

Obter o ponto de extremidade

Você pode encontrar o ponto de extremidade para o recurso de serviço de linguagem usando o Portal do Azure ou a CLI do Azure:

# Get the endpoint for the Language service resource
az cognitiveservices account show --name "resource-name" --resource-group "resource-group-name" --query "properties.endpoint"

Obter a chave de API

Você pode obter a chave de API dos Serviços Cognitivos ou do recurso de serviço de linguagem no Portal do Azure. Como alternativa, você pode usar o snippet da CLI do Azure abaixo para obter a chave de API do recurso.

az cognitiveservices account keys list --name "resource-name" --resource-group "resource-group-name"

Criar um TextAnalyticsClient com uma credencial de chave de API

Depois de ter o valor da chave de API, você poderá passá-la como uma cadeia de caracteres para uma instância de AzureKeyCredential. Use a chave como o parâmetro de credencial para autenticar o cliente:

import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient
endpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]
key = os.environ["AZURE_LANGUAGE_KEY"]

text_analytics_client = TextAnalyticsClient(endpoint, AzureKeyCredential(key))

Criar um TextAnalyticsClient com uma credencial do Azure Active Directory

Para usar uma credencial de token do AAD (Azure Active Directory), forneça uma instância do tipo de credencial desejado obtido da biblioteca azure-identity . Observe que os pontos de extremidade regionais não dão suporte à autenticação do AAD. Crie um nome de subdomínio personalizado para o recurso para usar esse tipo de autenticação.

A autenticação com o AAD requer alguma configuração inicial:

Após a instalação, você pode escolher qual tipo de credencial de azure.identity usar. Por exemplo, DefaultAzureCredential pode ser usado para autenticar o cliente:

Defina os valores da ID do cliente, da ID do locatário e do segredo do cliente do aplicativo AAD como variáveis de ambiente: AZURE_CLIENT_ID, AZURE_TENANT_ID AZURE_CLIENT_SECRET

Use a credencial de token retornada para autenticar o cliente:

import os
from azure.ai.textanalytics import TextAnalyticsClient
from azure.identity import DefaultAzureCredential

endpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]
credential = DefaultAzureCredential()

text_analytics_client = TextAnalyticsClient(endpoint, credential=credential)

Principais conceitos

TextAnalyticsClient

A biblioteca de clientes do Análise de Texto fornece um TextAnalyticsClient para fazer análises em de documentos. Ele fornece operações síncronas e assíncronas para acessar um uso específico da análise de texto, como detecção de idioma ou extração de frases-chave.

Entrada

Um documento é uma única unidade a ser analisada pelos modelos preditivos no serviço de Linguagem. A entrada para cada operação é passada como uma lista de documentos.

Cada documento pode ser passado como uma cadeia de caracteres na lista, por exemplo,

documents = ["I hated the movie. It was so slow!", "The movie made it into my top ten favorites. What a great movie!"]

ou, se você quiser passar um documento id por item ou languagecountry_hint/, eles poderão ser passados como uma lista de DetectLanguageInput ou TextDocumentInput ou uma representação semelhante a um ditado do objeto:

documents = [
    {"id": "1", "language": "en", "text": "I hated the movie. It was so slow!"},
    {"id": "2", "language": "en", "text": "The movie made it into my top ten favorites. What a great movie!"},
]

Confira limitações de serviço para a entrada, incluindo limites de comprimento do documento, tamanho máximo do lote e codificação de texto com suporte.

Valor Retornado

O valor retornado de um único documento pode ser um resultado ou um objeto de erro. Uma lista heterogênea que contém uma coleção de objetos result e error é retornada de cada operação. Esses resultados/erros correspondem ao índice com a ordem dos documentos fornecidos.

Um resultado, como AnalyzeSentimentResult, é o resultado de uma operação de análise de texto e contém uma previsão ou previsões sobre uma entrada de documento.

O objeto de erro, DocumentError, indica que o serviço teve problemas para processar o documento e contém o motivo pelo qual ele não teve êxito.

Tratamento de erros de documento

Você pode filtrar um resultado ou um objeto de erro na lista usando o is_error atributo . Para um objeto de resultado, isso é sempre False e para um DocumentError este é True.

Por exemplo, para filtrar todos os DocumentErrors, você pode usar a compreensão da lista:

response = text_analytics_client.analyze_sentiment(documents)
successful_responses = [doc for doc in response if not doc.is_error]

Você também pode usar o kind atributo para filtrar entre tipos de resultado:

poller = text_analytics_client.begin_analyze_actions(documents, actions)
response = poller.result()
for result in response:
    if result.kind == "SentimentAnalysis":
        print(f"Sentiment is {result.sentiment}")
    elif result.kind == "KeyPhraseExtraction":
        print(f"Key phrases: {result.key_phrases}")
    elif result.is_error is True:
        print(f"Document error: {result.code}, {result.message}")

Operações do Long-Running

Operações de execução longa são operações que consistem em uma solicitação inicial enviada ao serviço para iniciar uma operação, seguidas pela sondagem do serviço em intervalos para determinar se a operação foi concluída ou falhou e, se foi bem-sucedida, para obter o resultado.

Métodos que dão suporte à análise de serviços de saúde, análise de texto personalizada ou várias análises são modelados como operações de execução prolongada. O cliente expõe um begin_<method-name> método que retorna um objeto poller. Os chamadores devem aguardar a conclusão da operação chamando result() o objeto poller retornado do begin_<method-name> método . Snippets de código de exemplo são fornecidos para ilustrar o uso de operações de longa execução abaixo.

Exemplos

A seção a seguir fornece vários snippets de código que abrangem algumas das tarefas mais comuns do Serviço de Linguagem, incluindo:

Analisar Sentimento

analyze_sentiment examina seu texto de entrada e determina se seu sentimento é positivo, negativo, neutro ou misto. Sua resposta inclui análise de sentimento por frase e pontuações de confiança.

import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient

endpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]
key = os.environ["AZURE_LANGUAGE_KEY"]

text_analytics_client = TextAnalyticsClient(endpoint=endpoint, credential=AzureKeyCredential(key))

documents = [
    """I had the best day of my life. I decided to go sky-diving and it made me appreciate my whole life so much more.
    I developed a deep-connection with my instructor as well, and I feel as if I've made a life-long friend in her.""",
    """This was a waste of my time. All of the views on this drop are extremely boring, all I saw was grass. 0/10 would
    not recommend to any divers, even first timers.""",
    """This was pretty good! The sights were ok, and I had fun with my instructors! Can't complain too much about my experience""",
    """I only have one word for my experience: WOW!!! I can't believe I have had such a wonderful skydiving company right
    in my backyard this whole time! I will definitely be a repeat customer, and I want to take my grandmother skydiving too,
    I know she'll love it!"""
]


result = text_analytics_client.analyze_sentiment(documents, show_opinion_mining=True)
docs = [doc for doc in result if not doc.is_error]

print("Let's visualize the sentiment of each of these documents")
for idx, doc in enumerate(docs):
    print(f"Document text: {documents[idx]}")
    print(f"Overall sentiment: {doc.sentiment}")

A resposta retornada é uma lista heterogênea de objetos de resultado e erro: list[AnalyzeSentimentResult, DocumentError]

Consulte a documentação do serviço para obter uma discussão conceitual sobre análise de sentimento. Para ver como conduzir uma análise mais granular nas opiniões relacionadas a aspectos individuais (como atributos de um produto ou serviço) em um texto, consulte aqui.

Reconhecer entidades

recognize_entities reconhece e categoria entidades em seu texto de entrada como pessoas, locais, organizações, data/hora, quantidades, percentuais, moedas e muito mais.

import os
import typing
from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient

endpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]
key = os.environ["AZURE_LANGUAGE_KEY"]

text_analytics_client = TextAnalyticsClient(endpoint=endpoint, credential=AzureKeyCredential(key))
reviews = [
    """I work for Foo Company, and we hired Contoso for our annual founding ceremony. The food
    was amazing and we all can't say enough good words about the quality and the level of service.""",
    """We at the Foo Company re-hired Contoso after all of our past successes with the company.
    Though the food was still great, I feel there has been a quality drop since their last time
    catering for us. Is anyone else running into the same problem?""",
    """Bar Company is over the moon about the service we received from Contoso, the best sliders ever!!!!"""
]

result = text_analytics_client.recognize_entities(reviews)
result = [review for review in result if not review.is_error]
organization_to_reviews: typing.Dict[str, typing.List[str]] = {}

for idx, review in enumerate(result):
    for entity in review.entities:
        print(f"Entity '{entity.text}' has category '{entity.category}'")
        if entity.category == 'Organization':
            organization_to_reviews.setdefault(entity.text, [])
            organization_to_reviews[entity.text].append(reviews[idx])

for organization, reviews in organization_to_reviews.items():
    print(
        "\n\nOrganization '{}' has left us the following review(s): {}".format(
            organization, "\n\n".join(reviews)
        )
    )

A resposta retornada é uma lista heterogênea de objetos de resultado e erro: list[RecognizeEntitiesResult, DocumentError]

Consulte a documentação do serviço para obter uma discussão conceitual sobre o reconhecimento de entidade nomeada e os tipos com suporte.

Reconhecer entidades vinculadas

recognize_linked_entities reconhece e desambigua a identidade de cada entidade encontrada em seu texto de entrada (por exemplo, determinar se uma ocorrência da palavra Marte se refere ao planeta ou ao deus romano da guerra). Entidades reconhecidas são associadas a URLs a um base de dados de conhecimento conhecido, como a Wikipédia.

import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient

endpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]
key = os.environ["AZURE_LANGUAGE_KEY"]

text_analytics_client = TextAnalyticsClient(endpoint=endpoint, credential=AzureKeyCredential(key))
documents = [
    """
    Microsoft was founded by Bill Gates with some friends he met at Harvard. One of his friends,
    Steve Ballmer, eventually became CEO after Bill Gates as well. Steve Ballmer eventually stepped
    down as CEO of Microsoft, and was succeeded by Satya Nadella.
    Microsoft originally moved its headquarters to Bellevue, Washington in January 1979, but is now
    headquartered in Redmond.
    """
]

result = text_analytics_client.recognize_linked_entities(documents)
docs = [doc for doc in result if not doc.is_error]

print(
    "Let's map each entity to it's Wikipedia article. I also want to see how many times each "
    "entity is mentioned in a document\n\n"
)
entity_to_url = {}
for doc in docs:
    for entity in doc.entities:
        print("Entity '{}' has been mentioned '{}' time(s)".format(
            entity.name, len(entity.matches)
        ))
        if entity.data_source == "Wikipedia":
            entity_to_url[entity.name] = entity.url

A resposta retornada é uma lista heterogênea de objetos de resultado e erro: list[RecognizeLinkedEntitiesResult, DocumentError]

Consulte a documentação do serviço para obter uma discussão conceitual sobre vinculação de entidade e tipos com suporte.

Reconhecer entidades PII

recognize_pii_entities reconhece e categoriza entidades de PII (Informações de Identificação Pessoal) em seu texto de entrada, como Números da Previdência Social, informações de conta bancária, números de cartão de crédito e muito mais.

import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient

endpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]
key = os.environ["AZURE_LANGUAGE_KEY"]

text_analytics_client = TextAnalyticsClient(
    endpoint=endpoint, credential=AzureKeyCredential(key)
)
documents = [
    """Parker Doe has repaid all of their loans as of 2020-04-25.
    Their SSN is 859-98-0987. To contact them, use their phone number
    555-555-5555. They are originally from Brazil and have Brazilian CPF number 998.214.865-68"""
]

result = text_analytics_client.recognize_pii_entities(documents)
docs = [doc for doc in result if not doc.is_error]

print(
    "Let's compare the original document with the documents after redaction. "
    "I also want to comb through all of the entities that got redacted"
)
for idx, doc in enumerate(docs):
    print(f"Document text: {documents[idx]}")
    print(f"Redacted document text: {doc.redacted_text}")
    for entity in doc.entities:
        print("...Entity '{}' with category '{}' got redacted".format(
            entity.text, entity.category
        ))

A resposta retornada é uma lista heterogênea de objetos de resultado e erro: list[RecognizePiiEntitiesResult, DocumentError]

Consulte a documentação do serviço para obter tipos de entidade PII com suporte.

Observação: o serviço Reconhecer Entidades de PII está disponível na versão v3.1 e mais recente da API.

Extrair frases-chave

extract_key_phrases determina os pontos de discussão main em seu texto de entrada. Por exemplo, para o texto de entrada "A comida estava deliciosa e havia uma equipe maravilhosa", a API retorna: "comida" e "equipe maravilhosa".

import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient

endpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]
key = os.environ["AZURE_LANGUAGE_KEY"]

text_analytics_client = TextAnalyticsClient(endpoint=endpoint, credential=AzureKeyCredential(key))
articles = [
    """
    Washington, D.C. Autumn in DC is a uniquely beautiful season. The leaves fall from the trees
    in a city chock-full of forests, leaving yellow leaves on the ground and a clearer view of the
    blue sky above...
    """,
    """
    Redmond, WA. In the past few days, Microsoft has decided to further postpone the start date of
    its United States workers, due to the pandemic that rages with no end in sight...
    """,
    """
    Redmond, WA. Employees at Microsoft can be excited about the new coffee shop that will open on campus
    once workers no longer have to work remotely...
    """
]

result = text_analytics_client.extract_key_phrases(articles)
for idx, doc in enumerate(result):
    if not doc.is_error:
        print("Key phrases in article #{}: {}".format(
            idx + 1,
            ", ".join(doc.key_phrases)
        ))

A resposta retornada é uma lista heterogênea de objetos de resultado e erro: list[ExtractKeyPhrasesResult, DocumentError]

Consulte a documentação do serviço para obter uma discussão conceitual sobre a extração de frases-chave.

Detectar o idioma

detect_language determina o idioma de seu texto de entrada, incluindo a pontuação de confiança do idioma previsto.

import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient

endpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]
key = os.environ["AZURE_LANGUAGE_KEY"]

text_analytics_client = TextAnalyticsClient(endpoint=endpoint, credential=AzureKeyCredential(key))
documents = [
    """
    The concierge Paulette was extremely helpful. Sadly when we arrived the elevator was broken, but with Paulette's help we barely noticed this inconvenience.
    She arranged for our baggage to be brought up to our room with no extra charge and gave us a free meal to refurbish all of the calories we lost from
    walking up the stairs :). Can't say enough good things about my experience!
    """,
    """
    最近由于工作压力太大，我们决定去富酒店度假。那儿的温泉实在太舒服了，我跟我丈夫都完全恢复了工作前的青春精神！加油！
    """
]

result = text_analytics_client.detect_language(documents)
reviewed_docs = [doc for doc in result if not doc.is_error]

print("Let's see what language each review is in!")

for idx, doc in enumerate(reviewed_docs):
    print("Review #{} is in '{}', which has ISO639-1 name '{}'\n".format(
        idx, doc.primary_language.name, doc.primary_language.iso6391_name
    ))

A resposta retornada é uma lista heterogênea de objetos de resultado e erro: list[DetectLanguageResult, DocumentError]

Consulte a documentação do serviço para obter uma discussão conceitual sobre detecção de idioma e idioma e suporte regional.

Análise de entidades de saúde

A operação de execução longa begin_analyze_healthcare_entities extrai entidades reconhecidas dentro do domínio de saúde e identifica relações entre entidades dentro do documento de entrada e links para fontes de informações conhecidas em vários bancos de dados conhecidos, como UMLS, CHV, MSH etc.

import os
import typing
from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient, HealthcareEntityRelation

endpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]
key = os.environ["AZURE_LANGUAGE_KEY"]

text_analytics_client = TextAnalyticsClient(
    endpoint=endpoint,
    credential=AzureKeyCredential(key),
)

documents = [
    """
    Patient needs to take 100 mg of ibuprofen, and 3 mg of potassium. Also needs to take
    10 mg of Zocor.
    """,
    """
    Patient needs to take 50 mg of ibuprofen, and 2 mg of Coumadin.
    """
]

poller = text_analytics_client.begin_analyze_healthcare_entities(documents)
result = poller.result()

docs = [doc for doc in result if not doc.is_error]

print("Let's first visualize the outputted healthcare result:")
for doc in docs:
    for entity in doc.entities:
        print(f"Entity: {entity.text}")
        print(f"...Normalized Text: {entity.normalized_text}")
        print(f"...Category: {entity.category}")
        print(f"...Subcategory: {entity.subcategory}")
        print(f"...Offset: {entity.offset}")
        print(f"...Confidence score: {entity.confidence_score}")
        if entity.data_sources is not None:
            print("...Data Sources:")
            for data_source in entity.data_sources:
                print(f"......Entity ID: {data_source.entity_id}")
                print(f"......Name: {data_source.name}")
        if entity.assertion is not None:
            print("...Assertion:")
            print(f"......Conditionality: {entity.assertion.conditionality}")
            print(f"......Certainty: {entity.assertion.certainty}")
            print(f"......Association: {entity.assertion.association}")
    for relation in doc.entity_relations:
        print(f"Relation of type: {relation.relation_type} has the following roles")
        for role in relation.roles:
            print(f"...Role '{role.name}' with entity '{role.entity.text}'")
    print("------------------------------------------")

print("Now, let's get all of medication dosage relations from the documents")
dosage_of_medication_relations = [
    entity_relation
    for doc in docs
    for entity_relation in doc.entity_relations if entity_relation.relation_type == HealthcareEntityRelation.DOSAGE_OF_MEDICATION
]

Observação: a Análise de Entidades de Saúde só está disponível com a versão da API v3.1 e mais recente.

Análise múltipla

A operação de execuçãolonga begin_analyze_actions executa várias análises em um conjunto de documentos em uma única solicitação. Atualmente, há suporte para ele usando qualquer combinação das seguintes APIs de Linguagem em uma única solicitação:

  • Reconhecimento de entidades
  • Reconhecimento de entidades PII
  • Reconhecimento de Entidade Vinculada
  • Extração de Frases-Chave
  • Análise de Sentimento
  • Reconhecimento de Entidade Personalizada (API versão 2022-05-01 e mais recente)
  • Classificação personalizada de rótulo único (versão 2022-05-01 e mais recente)
  • Classificação personalizada de vários rótulos (versão 2022-05-01 e mais recente)
  • Análise de Entidades de Saúde (API versão 2022-05-01 e mais recente)
  • Resumo Extrativo (versão da API 2023-04-01 e mais recente)
  • Resumo Abstrativo (API versão 2023-04-01 e mais recente)
import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import (
    TextAnalyticsClient,
    RecognizeEntitiesAction,
    RecognizeLinkedEntitiesAction,
    RecognizePiiEntitiesAction,
    ExtractKeyPhrasesAction,
    AnalyzeSentimentAction,
)

endpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]
key = os.environ["AZURE_LANGUAGE_KEY"]

text_analytics_client = TextAnalyticsClient(
    endpoint=endpoint,
    credential=AzureKeyCredential(key),
)

documents = [
    'We went to Contoso Steakhouse located at midtown NYC last week for a dinner party, and we adore the spot! '
    'They provide marvelous food and they have a great menu. The chief cook happens to be the owner (I think his name is John Doe) '
    'and he is super nice, coming out of the kitchen and greeted us all.'
    ,

    'We enjoyed very much dining in the place! '
    'The Sirloin steak I ordered was tender and juicy, and the place was impeccably clean. You can even pre-order from their '
    'online menu at www.contososteakhouse.com, call 312-555-0176 or send email to order@contososteakhouse.com! '
    'The only complaint I have is the food didn\'t come fast enough. Overall I highly recommend it!'
]

poller = text_analytics_client.begin_analyze_actions(
    documents,
    display_name="Sample Text Analysis",
    actions=[
        RecognizeEntitiesAction(),
        RecognizePiiEntitiesAction(),
        ExtractKeyPhrasesAction(),
        RecognizeLinkedEntitiesAction(),
        AnalyzeSentimentAction(),
    ],
)

document_results = poller.result()
for doc, action_results in zip(documents, document_results):
    print(f"\nDocument text: {doc}")
    for result in action_results:
        if result.kind == "EntityRecognition":
            print("...Results of Recognize Entities Action:")
            for entity in result.entities:
                print(f"......Entity: {entity.text}")
                print(f".........Category: {entity.category}")
                print(f".........Confidence Score: {entity.confidence_score}")
                print(f".........Offset: {entity.offset}")

        elif result.kind == "PiiEntityRecognition":
            print("...Results of Recognize PII Entities action:")
            for pii_entity in result.entities:
                print(f"......Entity: {pii_entity.text}")
                print(f".........Category: {pii_entity.category}")
                print(f".........Confidence Score: {pii_entity.confidence_score}")

        elif result.kind == "KeyPhraseExtraction":
            print("...Results of Extract Key Phrases action:")
            print(f"......Key Phrases: {result.key_phrases}")

        elif result.kind == "EntityLinking":
            print("...Results of Recognize Linked Entities action:")
            for linked_entity in result.entities:
                print(f"......Entity name: {linked_entity.name}")
                print(f".........Data source: {linked_entity.data_source}")
                print(f".........Data source language: {linked_entity.language}")
                print(
                    f".........Data source entity ID: {linked_entity.data_source_entity_id}"
                )
                print(f".........Data source URL: {linked_entity.url}")
                print(".........Document matches:")
                for match in linked_entity.matches:
                    print(f"............Match text: {match.text}")
                    print(f"............Confidence Score: {match.confidence_score}")
                    print(f"............Offset: {match.offset}")
                    print(f"............Length: {match.length}")

        elif result.kind == "SentimentAnalysis":
            print("...Results of Analyze Sentiment action:")
            print(f"......Overall sentiment: {result.sentiment}")
            print(
                f"......Scores: positive={result.confidence_scores.positive}; \
                neutral={result.confidence_scores.neutral}; \
                negative={result.confidence_scores.negative} \n"
            )

        elif result.is_error is True:
            print(
                f"...Is an error with code '{result.error.code}' and message '{result.error.message}'"
            )

    print("------------------------------------------")

A resposta retornada é um objeto que encapsula vários iteráveis, cada um representando resultados de análises individuais.

Observação: várias análises estão disponíveis na versão da API v3.1 e mais recente.

Configuração opcional

Argumentos opcionais de palavra-chave podem ser passados no nível do cliente e por operação. A documentação de referência do azure-core descreve as configurações disponíveis para repetições, registro em log, protocolos de transporte e muito mais.

Solução de problemas

Geral

O cliente Análise de Texto gerará exceções definidas no Azure Core.

Log

Essa biblioteca usa a biblioteca de log padrão para registro em log. Informações básicas sobre sessões HTTP (URLs, cabeçalhos etc.) são registradas no nível INFO.

O log detalhado no nível de DEBUG, incluindo corpos de solicitação/resposta e cabeçalhos não redigidos, pode ser habilitado em um cliente com o argumento de palavra-chave logging_enable:

import sys
import logging
from azure.identity import DefaultAzureCredential
from azure.ai.textanalytics import TextAnalyticsClient

# Create a logger for the 'azure' SDK
logger = logging.getLogger('azure')
logger.setLevel(logging.DEBUG)

# Configure a console output
handler = logging.StreamHandler(stream=sys.stdout)
logger.addHandler(handler)

endpoint = "https://<resource-name>.cognitiveservices.azure.com/"
credential = DefaultAzureCredential()

# This client will log detailed information about its HTTP sessions, at DEBUG level
text_analytics_client = TextAnalyticsClient(endpoint, credential, logging_enable=True)
result = text_analytics_client.analyze_sentiment(["I did not like the restaurant. The food was too spicy."])

Da mesma forma, logging_enable pode habilitar o log detalhado para uma operação individual, mesmo quando ela não está habilitada para o cliente:

result = text_analytics_client.analyze_sentiment(documents, logging_enable=True)

Próximas etapas

Mais códigos de exemplo

Esses exemplos de código mostram operações de cenário comuns com a biblioteca de clientes Análise de Texto do Azure.

Autentique o cliente com uma chave de API de serviço de Linguagem/Serviços Cognitivos ou uma credencial de token do azure-identity:

Cenários comuns

Cenários avançados

Documentação adicional

Para obter uma documentação mais abrangente sobre o Serviço Cognitivo do Azure para Linguagem, consulte a documentação do Serviço de Linguagem sobre docs.microsoft.com.

Contribuição

Este projeto aceita contribuições e sugestões. A maioria das contribuições exige que você concorde com um CLA (Contrato de Licença do Colaborador) declarando que você tem o direito de nos conceder, e de fato concede, os direitos de usar sua contribuição. Para obter detalhes, visite cla.microsoft.com.

Quando você envia uma solicitação de pull, um bot do CLA determina automaticamente se você precisa fornecer um CLA e preencher a PR corretamente (por exemplo, rótulo, comentário). Basta seguir as instruções fornecidas pelo bot. Você só precisará fazer isso uma vez em todos os repositórios que usam nosso CLA.

Este projeto adotou o Código de Conduta de Software Livre da Microsoft. Para obter mais informações, confira as Perguntas frequentes sobre o Código de Conduta ou contate opencode@microsoft.com para enviar outras perguntas ou comentários.