Partilhar via

Biblioteca de cliente 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 na cloud que fornece funcionalidades de Processamento de Linguagem Natural (NLP) para compreender e analisar texto e inclui as seguintes funcionalidades principais:

  • Análise de Sentimentos
  • Reconhecimento de Entidades Nomeadas
  • Deteção de Idioma
  • Extração de Expressões-Chave
  • Ligar à Entidade
  • Múltiplas Análises
  • Deteção de Informações Pessoais (PII)
  • Análise de Texto para a Saúde
  • Reconhecimento de Entidades Nomeadas Personalizadas
  • Classificação de Texto Personalizado
  • Resumo de Texto Extrativo
  • Resumo de Texto Abstrativo

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

Introdução

Pré-requisitos

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

O serviço Idioma suporta o acesso de vários serviços e de serviço único. Crie um recurso dos Serviços Cognitivos se planear aceder a múltiplos serviços cognitivos num único ponto final/chave. Apenas para acesso ao Serviço de idiomas, crie um recurso do Serviço de idiomas. Pode criar o recurso com o Portal do Azure ou a CLI do Azure ao seguir os passos neste documento.

A interação com o serviço através da biblioteca de cliente começa com um cliente . Para criar um objeto de cliente, precisará do serviço endpoint Serviços Cognitivos ou Idioma para o recurso e de um credential que lhe permita aceder:

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)

Tenha em atenção que, para alguns recursos dos Serviços Cognitivos, o ponto final poderá ter um aspeto diferente do fragmento de código acima. Por exemplo, https://<region>.api.cognitive.microsoft.com/.

Instalar o pacote

Instale a biblioteca de cliente 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))

Tenha em atenção que 5.2.X e mais recentes visam as APIs de Idioma do Serviço Cognitivo do Azure. Estas APIs incluem a análise de texto e as funcionalidades de processamento de linguagem natural encontradas nas versões anteriores do Análise de Texto biblioteca de cliente. Além disso, a API de serviço mudou de semântica para controlo de versões baseada em datas. Esta versão da biblioteca de cliente é predefinida para a versão mais recente da API suportada, que atualmente é 2023-04-01.

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

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

A versão da API pode ser selecionada ao transmitir o argumento api_version palavra-chave para o cliente. Para obter as funcionalidades mais recentes do Serviço de idiomas, considere selecionar a versão mais recente da API beta. Para cenários de produção, é recomendada a versão estável mais recente. Definir para uma versão mais antiga pode resultar numa compatibilidade de funcionalidades reduzida.

Autenticar o cliente

Obter o ponto final

Pode encontrar o ponto final do recurso do Serviço de idiomas com 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

Pode obter a chave de API a partir dos Serviços Cognitivos ou do recurso do serviço Idioma no portal do Azure. Em alternativa, pode utilizar o fragmento 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

Assim que tiver o valor da chave de API, pode passá-lo como uma cadeia numa instância do AzureKeyCredential. Utilize 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 utilizar uma credencial de token do Azure Active Directory (AAD), forneça uma instância do tipo de credencial pretendido obtido a partir da biblioteca de identidades do azure . Tenha em atenção que os pontos finais regionais não suportam a autenticação do AAD. Crie um nome de subdomínio personalizado para o recurso para utilizar este tipo de autenticação.

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

Após a configuração, pode escolher o tipo de credencial a partir de azure.identity a utilizar. Por exemplo, DefaultAzureCredential pode ser utilizado para autenticar o cliente:

Defina os valores do ID de cliente, do ID do inquilino e do segredo do cliente da aplicação do AAD como variáveis de ambiente: AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET

Utilize a credencial do token devolvido 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)

Conceitos-chave

TextAnalyticsClient

A biblioteca de cliente Análise de Texto fornece um TextAnalyticsClient para fazer de documentos. Fornece operações síncronas e assíncronas para aceder a uma utilização específica da análise de texto, como a deteção de idioma ou a extração de expressões-chave.

Entrada

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

Cada documento pode ser transmitido como uma cadeia 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 pretender transmitir um documento id por item ou languagecountry_hint/, estes podem ser transmitidos como uma lista de DetectLanguageInput ou TextDocumentInput ou uma representação tipo dict 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!"},
]

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

Devolver Valor

O valor devolvido de um único documento pode ser um objeto de resultado ou erro. É devolvida uma lista heterogénea que contém uma coleção de objetos de resultado e erro de cada operação. Estes resultados/erros correspondem à ordem dos documentos fornecidos.

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

O objeto de erroDocumentError indica que o serviço teve problemas ao processar o documento e contém o motivo pelo qual não teve êxito.

Processamento de Erros do Documento

Pode filtrar por um objeto de resultado ou erro na lista com o is_error atributo . Para um objeto de resultado, isto é sempre False e para um DocumentError isto é True.

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

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

Também pode utilizar o kind atributo para filtrar entre tipos de resultados:

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 de Long-Running

As operações de execução prolongada são operações que consistem num pedido inicial enviado ao serviço para iniciar uma operação, seguidas de consulta 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.

Os métodos que suportam a análise de cuidados de saúde, a análise de texto personalizado 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 devolve um objeto poller. Os autores da chamada devem aguardar que a operação seja concluída ao chamar result() o objeto poller devolvido do begin_<method-name> método . Os fragmentos de código de exemplo são fornecidos para ilustrar a utilização de operações de execução prolongada abaixo.

Exemplos

A secção seguinte fornece vários fragmentos de código que abrangem algumas das tarefas mais comuns do Serviço de idiomas, incluindo:

Analisar Sentimentos

analyze_sentiment analisa o texto de entrada e determina se o sentimento é positivo, negativo, neutro ou misto. A resposta inclui análise de sentimentos por frase e classificaçõ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 devolvida é uma lista heterogénea de objetos de resultado e erro: list[AnalyzeSentimentResult, DocumentError]

Veja a documentação do serviço para uma discussão conceptual sobre a análise de sentimentos. Para ver como realizar análises mais granulares sobre as opiniões relacionadas com aspetos individuais (como atributos de um produto ou serviço) num texto, veja aqui.

Reconhecer Entidades

recognize_entities reconhece e categorias de entidades no texto de entrada como pessoas, locais, organizações, data/hora, quantidades, percentagens, 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 devolvida é uma lista heterogénea de objetos de resultado e erro: list[RecognizeEntitiesResult, DocumentError]

Veja a documentação do serviço para obter um debate conceptual sobre o reconhecimento de entidades nomeadas e os tipos suportados.

Reconhecer Entidades Ligadas

recognize_linked_entities reconhece e desambigua a identidade de cada entidade encontrada no seu texto de entrada (por exemplo, determinar se uma ocorrência da palavra Marte se refere ao planeta ou ao deus romano da guerra). As entidades reconhecidas estão associadas a URLs a uma base de dados de conhecimento conhecida, 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 devolvida é uma lista heterogénea de objetos de resultado e erro: list[RecognizeLinkedEntitiesResult, DocumentError]

Veja a documentação do serviço para obter um debate conceptual sobre a ligação de entidades e os tipos suportados.

Reconhecer Entidades PII

recognize_pii_entities reconhece e categoriza entidades de Informações Pessoais (PII) no texto de entrada, como Números da Segurança Social, informações da conta bancária, números de cartões 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 devolvida é uma lista heterogénea de objetos de resultado e erro: list[RecognizePiiEntitiesResult, DocumentError]

Veja a documentação do serviço para obter os tipos de entidades PII suportados.

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

Extrair Expressões-Chave

extract_key_phrases determina os principais pontos de discussão no texto de entrada. Por exemplo, para o texto de entrada "A comida estava deliciosa e havia uma equipa maravilhosa", a API devolve: "comida" e "pessoal maravilhoso".

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 devolvida é uma lista heterogénea de objetos de resultado e erro: list[ExtractKeyPhrasesResult, DocumentError]

Veja a documentação do serviço para um debate conceptual sobre a extração de expressões-chave.

Detetar Idioma

detect_language determina o idioma do texto de entrada, incluindo a classificaçã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 devolvida é uma lista heterogénea de objetos de resultado e erro: list[DetectLanguageResult, DocumentError]

Veja a documentação do serviço para obter um debate conceptual sobre a deteção de idiomas e o suporte regional e de idioma.

Análise de Entidades de Cuidados de Saúde

A operação de execução prolongadabegin_analyze_healthcare_entities extrai entidades reconhecidas no domínio de cuidados de saúde e identifica relações entre entidades no documento de entrada e ligações para origens de informações conhecidas em várias bases de dados conhecidas, 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
]

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

Múltiplas Análises

A operação de execução prolongada begin_analyze_actions efetua múltiplas análises através de um conjunto de documentos num único pedido. Atualmente, é suportado através de qualquer combinação das seguintes APIs de Idioma num único pedido:

  • Reconhecimento de Entidades
  • Reconhecimento de Entidades PII
  • Reconhecimento de Entidades Ligadas
  • Extração de Expressões-Chave
  • Análise de Sentimentos
  • Reconhecimento de Entidades Personalizadas (versão da API 2022-05-01 e mais recente)
  • Classificação personalizada de etiqueta única (versão da API 2022-05-01 e mais recente)
  • Classificação de Várias Etiquetas Personalizada (versão da API 2022-05-01 e mais recente)
  • Análise de Entidades de Cuidados de Saúde (versão da API 2022-05-01 e mais recente)
  • Resumo Extrativo (versão da API 2023-04-01 e mais recente)
  • Resumo Abstrativo (versão da API 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 devolvida é um objeto que encapsula vários iteráveis, cada um representando resultados de análises individuais.

Nota: estão disponíveis múltiplas análises na versão da API v3.1 e mais recente.

Configuração opcional

Os argumentos de palavra-chave opcionais podem ser transmitidos ao nível do cliente e por operação. A documentação de referência azure-core descreve as configurações disponíveis para repetições, registo, protocolos de transporte e muito mais.

Resolução de problemas

Geral

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

Registo

Esta biblioteca utiliza a biblioteca de registos padrão para registo. As informações básicas sobre sessões HTTP (URLs, cabeçalhos, etc.) são registadas ao nível da INFORMAÇÃO.

O registo ao nível de DEBUG detalhado, incluindo os corpos de pedido/resposta e os cabeçalhos não retotados, pode ser ativado num cliente com o logging_enable argumento de palavra-chave:

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 ativar o registo detalhado para uma única operação, mesmo quando não está ativado para o cliente:

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

Passos seguintes

Mais código de exemplo

Estes exemplos de código mostram operações de cenários comuns com a biblioteca de cliente do Azure Análise de Texto.

Autenticar o cliente com uma chave de API dos Serviços Cognitivos/Serviço de idioma ou uma credencial de token do azure-identity:

Cenários comuns

Cenários avançados

Documentação adicional

Para obter documentação mais extensa sobre o Serviço Cognitivo do Azure para idiomas, veja a documentação do Serviço de Linguagem sobre docs.microsoft.com.

Contribuir

Agradecemos todas as contribuições e sugestões para este projeto. A maioria das contribuições requerem que celebre um Contrato de Licença de Contribuição (CLA) no qual se declare que tem o direito de conceder e que, na verdade, concede-nos os direitos para utilizar a sua contribuição. Para obter detalhes, visite cla.microsoft.com.

Quando submete um pedido Pull, um bot do CLA determina automaticamente se tem de fornecer um CLA e decorar o PR de forma adequada (por exemplo, etiqueta, comentário). Só tem de seguir as instruções fornecidas pelo bot. Apenas terá de fazer isto uma vez em todos os repositórios com o nosso CLA.

Este projeto adotou o Microsoft Open Source Code of Conduct (Código de Conduta do Microsoft Open Source). Para obter mais informações, consulte as FAQ do Código de Conduta ou contacte opencode@microsoft.com com quaisquer perguntas ou comentários adicionais.