Condividi tramite

Libreria client di Azure Analisi del testo per Python - versione 5.3.0

  • Articolo

Il servizio cognitivo di Azure per il linguaggio è un servizio basato sul cloud che fornisce funzionalità di elaborazione del linguaggio naturale (NLP) per la comprensione e l'analisi del testo e include le funzionalità principali seguenti:

  • Analisi del sentiment
  • Riconoscimento di entità denominate
  • Rilevamento lingua
  • Estrazione frasi chiave
  • Collegamento delle entità
  • Analisi multipla
  • Rilevamento delle informazioni personali
  • Analisi del testo per la sanità
  • Riconoscimento di entità denominato personalizzato
  • Classificazione del testo personalizzata
  • Riepilogo del testo estratto
  • Riepilogo del testo astrazione

Codice | sorgentePacchetto (PyPI) | Pacchetto (Conda) | Documentazione di | riferimento sulle APIDocumentazione | del prodottoCampioni

Introduzione

Prerequisiti

Creare una risorsa servizi cognitivi o servizio linguistico

Il servizio Language supporta sia l'accesso a più servizi che a servizio singolo. Creare una risorsa Servizi cognitivi se si prevede di accedere a più servizi cognitivi con un singolo endpoint/chiave. Solo per l'accesso al servizio lingua creare una risorsa del servizio lingua. È possibile creare la risorsa usando il portale di Azure o l'interfaccia della riga di comando di Azure seguendo la procedura descritta in questo documento.

L'interazione con il servizio tramite la libreria client inizia con un client . Per creare un oggetto client, è necessario il servizio Servizi cognitivi o Lingua per la risorsa e un credential oggetto endpoint che consente di accedere:

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)

Si noti che per alcune risorse di Servizi cognitivi l'endpoint potrebbe essere diverso dal frammento di codice precedente. Ad esempio, https://<region>.api.cognitive.microsoft.com/.

Installare il pacchetto

Installare la libreria client di Azure Analisi del testo per Python con 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))

Si noti che 5.2.X e versioni successive sono destinate alle API del servizio cognitivo di Azure per il linguaggio. Queste API includono le funzionalità di analisi del testo e elaborazione del linguaggio naturale disponibili nelle versioni precedenti della libreria client Analisi del testo. Inoltre, l'API del servizio è stata modificata dalla semantica al controllo delle versioni basate su data. Questa versione della libreria client viene predefinita per la versione dell'API supportata più recente, attualmente 2023-04-01.

Questa tabella mostra la relazione tra le versioni di SDK e le versioni API supportate del servizio

Versione dell'SDK Versione dell'API supportata del servizio
5.3.X - Versione stabile più recente 3.0, 3.1, 2022-05-01, 2023-04-01 (impostazione predefinita)
5.2.X 3.0, 3.1, 2022-05-01 (impostazione predefinita)
5.1.0 3.0, 3.1 (impostazione predefinita)
5.0.0 3.0

È possibile selezionare la versione dell'API passando l'argomento della parola chiave api_version nel client. Per le funzionalità più recenti del servizio linguistico, è consigliabile selezionare la versione dell'API beta più recente. Per gli scenari di produzione, è consigliata la versione stabile più recente. L'impostazione su una versione precedente può comportare una riduzione della compatibilità delle funzionalità.

Autenticare il client

Ottenere l'endpoint

È possibile trovare l'endpoint per la risorsa del servizio linguaggio usando il portale di Azure o l'interfaccia della riga di comando di Azure:

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

Ottenere la chiave API

È possibile ottenere la chiave API dalla risorsa servizi cognitivi o servizio linguistico nel portale di Azure. In alternativa, è possibile usare il frammento di interfaccia della riga di comando di Azure seguente per ottenere la chiave API della risorsa.

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

Creare un oggetto TextAnalyticsClient con una credenziale chiave API

Dopo aver ottenuto il valore per la chiave API, è possibile passarlo come stringa in un'istanza di AzureKeyCredential. Usare la chiave come parametro delle credenziali per autenticare il client:

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))

Creare un oggetto TextAnalyticsClient con una credenziale di Azure Active Directory

Per usare una credenziale token di Azure Active Directory (AAD), specificare un'istanza del tipo di credenziali desiderato ottenuto dalla libreria azure-identity . Si noti che gli endpoint a livello di area non supportano l'autenticazione AAD. Creare un nome di sottodominio personalizzato per la risorsa per usare questo tipo di autenticazione.

L'autenticazione con AAD richiede una configurazione iniziale:

Dopo la configurazione, è possibile scegliere il tipo di credenziali da azure.identity da usare. Ad esempio, DefaultAzureCredential può essere usato per autenticare il client:

Impostare i valori dell'ID client, dell'ID tenant e del segreto client dell'applicazione AAD come variabili di ambiente: AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET

Usare le credenziali del token restituite per autenticare il client:

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)

Concetti chiave

TextAnalyticsClient

La libreria client Analisi del testo fornisce un oggetto TextAnalyticsClient per eseguire l'analisi su di documenti. Fornisce sia operazioni sincrone che asincrone per accedere a un uso specifico dell'analisi del testo, ad esempio il rilevamento della lingua o l'estrazione di frasi chiave.

Input

Un documento è una singola unità da analizzare dai modelli predittivi nel servizio lingua. L'input per ogni operazione viene passato come elenco di documenti.

Ogni documento può essere passato come stringa nell'elenco, ad esempio.

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

oppure, se si vuole passare un documento id per elemento o languagecountry_hint/, può essere passato come elenco di DetectLanguageInput o TextDocumentInput o una rappresentazione simile a ct dell'oggetto:

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!"},
]

Vedere limitazioni del servizio per l'input, inclusi i limiti di lunghezza del documento, le dimensioni massime del batch e la codifica di testo supportata.

Valore restituito

Il valore restituito per un singolo documento può essere un oggetto risultato o errore. Un elenco eterogeneo contenente una raccolta di oggetti risultato ed errore viene restituito da ogni operazione. Questi risultati/errori sono corrispondenti all'indice con l'ordine dei documenti forniti.

Un risultato, ad esempio AnalysisSentimentResult, è il risultato di un'operazione di analisi del testo e contiene una stima o stime relative a un input del documento.

L'oggetto error , DocumentError, indica che il servizio ha avuto problemi durante l'elaborazione del documento e contiene il motivo per cui non è riuscito.

Gestione degli errori del documento

È possibile filtrare per un oggetto risultato o errore nell'elenco usando l'attributo is_error . Per un oggetto result questo è sempre False e per un DocumentError questo è True.

Ad esempio, per filtrare tutti gli errori di documenterrori, è possibile usare la comprensione dell'elenco:

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

È anche possibile usare l'attributo kind per filtrare tra i tipi di risultato:

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}")

operazioni Long-Running

Le operazioni a esecuzione prolungata sono operazioni che costituiscono una richiesta iniziale inviata al servizio per avviare un'operazione, seguita dal polling del servizio a intervalli per determinare se l'operazione è stata completata o non riuscita e, se ha avuto esito positivo, per ottenere il risultato.

I metodi che supportano l'analisi sanitaria, l'analisi del testo personalizzata o più analisi vengono modellate come operazioni a esecuzione prolungata. Il client espone un metodo che restituisce un begin_<method-name> oggetto poller. I chiamanti devono attendere il completamento dell'operazione chiamando result() l'oggetto poller restituito dal begin_<method-name> metodo . I frammenti di codice di esempio vengono forniti per illustrare l'uso di esempi di operazioni a esecuzione prolungata di seguito.

Esempio

La sezione seguente fornisce diversi frammenti di codice che illustrano alcune delle attività più comuni del servizio di linguaggio, tra cui:

Analizzare il sentiment

analyze_sentiment esamina il testo di input e determina se il sentiment è positivo, negativo, neutro o misto. La risposta include l'analisi del sentiment per frase e i punteggi di attendibilità.

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}")

La risposta restituita è un elenco eterogeneo di oggetti risultato ed errore: list[AnalyzeSentimentResult, DocumentError]

Per una descrizione concettuale dell'analisi del sentiment, vedere la documentazione del servizio. Per informazioni su come condurre un'analisi più granulare sulle opinioni relative ai singoli aspetti (ad esempio gli attributi di un prodotto o di un servizio) in un testo, vedere qui.

Riconoscere le entità

recognize_entities riconosce e categorie le entità nel testo di input come persone, luoghi, organizzazioni, data/ora, quantità, percentuali, valute e altro ancora.

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)
        )
    )

La risposta restituita è un elenco eterogeneo di oggetti risultato ed errore: list[RecognizeEntitiesResult, DocumentError]

Per una descrizione concettuale del riconoscimento delle entità denominate e dei tipi supportati, vedere la documentazione del servizio.

Riconoscere le entità collegate

recognize_linked_entities riconosce e disambigua l'identità di ogni entità trovata nel testo di input (ad esempio, determinare se un'occorrenza della parola Marte fa riferimento al pianeta o al dio romano della guerra). Le entità riconosciute sono associate agli URL a un knowledge base noto, ad esempio Wikipedia.

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

La risposta restituita è un elenco eterogeneo di oggetti risultato ed errore: list[RecognizeLinkedEntitiesResult, DocumentError]

Per una descrizione concettuale del collegamento delle entità e dei tipi supportati, vedere la documentazione del servizio.

Riconoscere le entità PII

recognize_pii_entities riconosce e classifica le entità informazioni personali (PII) nel testo di input, ad esempio numeri di previdenza sociale, informazioni sul conto corrente bancario, numeri di carta di credito e altro ancora.

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
        ))

La risposta restituita è un elenco eterogeneo di oggetti risultato ed errore: list[RecognizePiiEntitiesResult, DocumentError]

Per i tipi di entità piI supportati, vedere la documentazione del servizio.

Nota: il servizio Recognize PII Entities è disponibile nella versione 3.1 e successive dell'API.

Estrarre frasi chiave

extract_key_phrases determina i punti di discussione principali nel testo di input. Ad esempio, per il testo di input "Il cibo era delizioso e c'era personale meraviglioso", l'API restituisce: "cibo" e "personale meraviglioso".

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)
        ))

La risposta restituita è un elenco eterogeneo di oggetti risultato ed errore: list[ExtractKeyPhrasesResult, DocumentError]

Per una descrizione concettuale dell'estrazione di frasi chiave, vedere la documentazione del servizio.

Rilevare la lingua

detect_language determina la lingua del testo di input, incluso il punteggio di attendibilità della lingua stimata.

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
    ))

La risposta restituita è un elenco eterogeneo di oggetti risultato ed errore: list[DetectLanguageResult, DocumentError]

Fare riferimento alla documentazione del servizio per una descrizione concettuale del rilevamento della lingua e del supporto linguistico e regionale.

Analisi delle entità sanitarie

L'operazione a esecuzione prolungatabegin_analyze_healthcare_entities estrae le entità riconosciute all'interno del dominio sanitario e identifica le relazioni tra entità all'interno del documento di input e collegamenti a origini note di informazioni in diversi database noti, ad esempio UMLS, CHV, MSH e così via.

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: l'analisi delle entità sanitarie è disponibile solo con l'API versione 3.1 e successive.

Analisi multipla

L'operazione a esecuzione prolungatabegin_analyze_actions esegue più analisi su un set di documenti in una singola richiesta. Attualmente è supportato usando qualsiasi combinazione delle API language seguenti in una singola richiesta:

  • Riconoscimento delle entità
  • Riconoscimento delle entità PII
  • Riconoscimento di entità collegate
  • Estrazione frasi chiave
  • Analisi del sentiment
  • Riconoscimento di entità personalizzate (API versione 2022-05-01 e successive)
  • Classificazione con etichetta singola personalizzata (API versione 2022-05-01 e successive)
  • Classificazione multi etichetta personalizzata (API versione 2022-05-01 e successive)
  • Analisi delle entità del settore sanitario (API versione 2022-05-01 e successive)
  • Riepilogo estrativo (API versione 2023-04-01 e successive)
  • Riepilogo astratto (VERSIONE API 2023-04-01 e successive)
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("------------------------------------------")

La risposta restituita è un oggetto che incapsula più iterabili, ognuno dei quali rappresenta i risultati delle singole analisi.

Nota: l'analisi multipla è disponibile nella versione 3.1 e successive dell'API.

Configurazione facoltativa

Gli argomenti di parole chiave facoltativi possono essere passati al client e al livello di operazione. La documentazione di riferimento di azure-core descrive le configurazioni disponibili per tentativi, registrazione, protocolli di trasporto e altro ancora.

Risoluzione dei problemi

Generale

Il client Analisi del testo genererà eccezioni definite in Azure Core.

Registrazione

Questa libreria usa la libreria di registrazione standard per la registrazione. Le informazioni di base sulle sessioni HTTP (URL, intestazioni e così via) vengono registrate a livello di INFO.

La registrazione dettagliata a livello di debug, inclusi i corpi di richiesta-risposta e le intestazioni non modificate, può essere abilitata su un client con l'argomento parola chiave 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."])

Analogamente, logging_enable può abilitare la registrazione dettagliata per una singola operazione, anche quando non è abilitata per il client:

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

Passaggi successivi

Altro codice di esempio

Questi esempi di codice illustrano le operazioni di scenario comuni con la libreria client di Azure Analisi del testo.

Autenticare il client con una chiave API del servizio servizi cognitivi/linguaggio o una credenziale di token da azure-identity:

Scenari comuni

Scenari avanzati

Documentazione aggiuntiva

Per una documentazione più completa su Servizi cognitivi di Azure per la lingua, vedere la documentazione del servizio di linguaggio in docs.microsoft.com.

Contributo

In questo progetto sono benvenuti i contributi e i suggerimenti. Per la maggior parte dei contenuti è necessario sottoscrivere un contratto di licenza di collaborazione (CLA, Contributor License Agreement) che stabilisce che l'utente ha il diritto di concedere, e di fatto concede a Microsoft i diritti d'uso del suo contributo. Per informazioni dettagliate, visitare cla.microsoft.com.

Quando si invia una richiesta pull, un bot CLA determina automaticamente se è necessario specificare un contratto CLA e completare la richiesta pull in modo appropriato (ad esempio con un'etichetta e un commento). Seguire le istruzioni specificate dal bot. È sufficiente eseguire questa operazione una sola volta per tutti i repository che usano il contratto CLA Microsoft.

Questo progetto ha adottato il Codice di comportamento di Microsoft per l'open source. Per altre informazioni, vedere Code of Conduct FAQ (Domande frequenti sul Codice di comportamento Open Source di Microsoft) oppure contattare opencode@microsoft.com per eventuali altre domande o commenti.