Azure Textanalys-klientbibliotek för Python – version 5.3.0

  • Artikel

Azure Cognitive Service for Language är en molnbaserad tjänst som tillhandahåller NLP-funktioner (Natural Language Processing) för att förstå och analysera text och innehåller följande huvudfunktioner:

  • Attitydanalys
  • Igenkänning av namngiven enhet
  • Språkidentifiering
  • Extrahering av nyckelfraser
  • Entity Linking
  • Flera analyser
  • Identifiering av personligt identifierbar information (PII)
  • Textanalys för hälso- och sjukvården
  • Igenkänning av anpassad namngiven entitet
  • Klassificering av anpassad text
  • Sammanfattning av extraherad text
  • Sammanfattning av abstrakt text

| KällkodPaket (PyPI) | Paket (Conda) | API-referensdokumentation | Produktdokumentation | Prover

Komma igång

Förutsättningar

Skapa en Cognitive Services- eller Språktjänstresurs

Språktjänsten stöder både åtkomst med flera tjänster och en enda tjänst. Skapa en Cognitive Services-resurs om du planerar att komma åt flera kognitiva tjänster under en enda slutpunkt/nyckel. Skapa en språktjänstresurs för endast åtkomst till språktjänsten. Du kan skapa resursen med hjälp av Azure-portalen eller Azure CLI genom att följa stegen i det här dokumentet.

Interaktionen med tjänsten med hjälp av klientbiblioteket börjar med en . Om du vill skapa ett klientobjekt behöver du Cognitive Services- eller Language-tjänsten endpoint till resursen och en credential som gör att du kan komma åt:

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)

Observera att slutpunkten för vissa Cognitive Services-resurser kan se annorlunda ut än kodfragmentet ovan. Till exempel https://<region>.api.cognitive.microsoft.com/.

Installera paketet

Installera Azure Textanalys-klientbiblioteket för Python med 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))

Observera att 5.2.X och senare är inriktade på Azure Cognitive Service för språk-API:er. Dessa API:er innehåller textanalys och bearbetningsfunktioner för naturligt språk som finns i de tidigare versionerna av Textanalys-klientbiblioteket. Dessutom har tjänst-API:et ändrats från semantisk till datumbaserad versionshantering. Den här versionen av klientbiblioteket har som standard den senaste API-versionen som stöds, som för närvarande är 2023-04-01.

Den här tabellen visar relationen mellan SDK-versioner och API-versioner som stöds av tjänsten

SDK-version API-version av tjänsten som stöds
5.3.X – Senaste stabila versionen 3.0, 3.1, 2022-05-01, 2023-04-01 (standard)
5.2.X 3.0, 3.1, 2022-05-01 (standard)
5.1.0 3.0, 3.1 (standard)
5.0.0 3.0

DU kan välja API-version genom att skicka nyckelordsargumentet api_version till klienten. För de senaste funktionerna i Language Service kan du välja den senaste beta-API-versionen. För produktionsscenarier rekommenderas den senaste stabila versionen. Om du anger en äldre version kan funktionskompatibiliteten minska.

Autentisera klienten

Hämta slutpunkten

Du hittar slutpunkten för språktjänstresursen med hjälp av Azure-portalen eller Azure CLI:

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

Hämta API-nyckeln

Du kan hämta API-nyckeln från Cognitive Services- eller Language Service-resursen i Azure-portalen. Du kan också använda Azure CLI-kodfragmentet nedan för att hämta API-nyckeln för din resurs.

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

Skapa en TextAnalyticsClient med en API-nyckelautentiseringsuppgift

När du har värdet för API-nyckeln kan du skicka den som en sträng till en instans av AzureKeyCredential. Använd nyckeln som parameter för autentiseringsuppgifter för att autentisera klienten:

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

Skapa en TextAnalyticsClient med en Azure Active Directory-autentiseringsuppgift

Om du vill använda en AAD-tokenautentisering (Azure Active Directory) anger du en instans av önskad typ av autentiseringsuppgifter som hämtats från biblioteket azure-identity . Observera att regionala slutpunkter inte stöder AAD-autentisering. Skapa ett anpassat underdomännamn för resursen för att kunna använda den här typen av autentisering.

Autentisering med AAD kräver viss inledande konfiguration:

Efter installationen kan du välja vilken typ av autentiseringsuppgifter från azure.identity som ska användas. Till exempel kan DefaultAzureCredential användas för att autentisera klienten:

Ange värdena för klient-ID, klient-ID och klienthemlighet för AAD-programmet som miljövariabler: AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET

Använd den returnerade tokenautentiseringsuppgiften för att autentisera klienten:

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)

Viktiga begrepp

TextAnalyticsClient

Klientbiblioteket Textanalys innehåller en TextAnalyticsClient för analys av med dokument. Den innehåller både synkrona och asynkrona åtgärder för att få åtkomst till en specifik användning av textanalys, till exempel språkidentifiering eller extrahering av nyckelfraser.

Indata

Ett dokument är en enda enhet som ska analyseras av prediktiva modeller i språktjänsten. Indata för varje åtgärd skickas som en lista över dokument.

Varje dokument kan skickas som en sträng i listan, t.ex.

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

eller, om du vill skicka ett dokument id per objekt eller languagecountry_hint/, kan de skickas som en lista över DetectLanguageInput eller TextDocumentInput eller en dict-liknande representation av objektet:

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

Se tjänstbegränsningar för indata, inklusive dokumentlängdsgränser, maximal batchstorlek och textkodning som stöds.

Returvärde

Returvärdet för ett enskilt dokument kan vara ett resultat- eller felobjekt. En heterogen lista som innehåller en samling resultat- och felobjekt returneras från varje åtgärd. Dessa resultat/fel är indexmatchade med ordningen på de angivna dokumenten.

Ett resultat, till exempel AnalyzeSentimentResult, är resultatet av en textanalysåtgärd och innehåller en förutsägelse eller förutsägelser om ett dokumentindata.

FelobjektetDocumentError anger att tjänsten hade problem med att bearbeta dokumentet och innehåller orsaken till att det misslyckades.

Dokumentfelhantering

Du kan filtrera efter ett resultat- eller felobjekt i listan med hjälp av attributet is_error . För ett resultatobjekt är detta alltid False och för en DocumentError är Truedetta .

Om du till exempel vill filtrera bort alla DocumentErrors kan du använda listförståelse:

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

Du kan också använda attributet kind för att filtrera mellan resultattyper:

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

Long-Running åtgärder

Långvariga åtgärder är åtgärder som består av en första begäran som skickas till tjänsten för att starta en åtgärd, följt av avsökning av tjänsten med jämna mellanrum för att avgöra om åtgärden har slutförts eller misslyckats, och om den har lyckats för att få resultatet.

Metoder som stöder hälso- och sjukvårdsanalys, anpassad textanalys eller flera analyser modelleras som långvariga åtgärder. Klienten exponerar en begin_<method-name> metod som returnerar ett pollerobjekt. Anropare bör vänta tills åtgärden har slutförts genom att anropa result() det pollerobjekt som returneras från begin_<method-name> metoden . Exempelkodfragment tillhandahålls för att illustrera med hjälp av långvariga åtgärder nedan.

Exempel

Följande avsnitt innehåller flera kodfragment som täcker några av de vanligaste uppgifterna för språktjänsten, inklusive:

Analysera sentiment

analyze_sentiment tittar på indatatexten och avgör om dess sentiment är positivt, negativt, neutralt eller blandat. Svaret innehåller attitydanalys per mening och förtroendepoäng.

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

Det returnerade svaret är en heterogen lista över resultat- och felobjekt: list[AnalyzeSentimentResult, DocumentError]

I tjänstdokumentationen finns en konceptuell diskussion om attitydanalys. Information om hur du utför mer detaljerad analys av åsikter som rör enskilda aspekter (till exempel attribut för en produkt eller tjänst) i en text finns här.

Identifiera entiteter

recognize_entities identifierar och kategorier entiteter i indatatexten som personer, platser, organisationer, datum/tid, kvantiteter, procenttal, valutor med mera.

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

Det returnerade svaret är en heterogen lista över resultat- och felobjekt: list[RecognizeEntitiesResult, DocumentError]

Se tjänstdokumentationen för en konceptuell beskrivning av namngiven entitetsigenkänning och typer som stöds.

Identifiera länkade entiteter

recognize_linked_entities känner igen och förtydligar identiteten för varje entitet som finns i dess indatatext (till exempel att avgöra om en förekomst av ordet Mars refererar till planeten eller till den romerska krigsguden). Identifierade entiteter är associerade med URL:er till en välkänd kunskapsbas, till exempel 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

Det returnerade svaret är en heterogen lista över resultat- och felobjekt: list[RecognizeLinkedEntitiesResult, DocumentError]

Se tjänstdokumentationen för en konceptuell diskussion om entitetslänkning och typer som stöds.

Identifiera PII-entiteter

recognize_pii_entities identifierar och kategoriserar PII-entiteter (Personligt identifierbar information) i indatatexten, till exempel personnummer, bankkontoinformation, kreditkortsnummer med mera.

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

Det returnerade svaret är en heterogen lista över resultat- och felobjekt: list[RecognizePiiEntitiesResult, DocumentError]

Se tjänstdokumentationen för pii-entitetstyper som stöds.

Obs! Tjänsten Identifiera PII-entiteter är tillgänglig i API-version v3.1 och senare.

Extrahera nyckelfraser

extract_key_phrases avgör de viktigaste diskussionspunkterna i inmatningstexten. Till exempel för indatatexten "Maten var utsökt och det fanns underbar personal" returnerar API:et: "mat" och "underbar personal".

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

Det returnerade svaret är en heterogen lista över resultat- och felobjekt: list[ExtractKeyPhrasesResult, DocumentError]

Se tjänstdokumentationen för en konceptuell diskussion om extrahering av nyckelfraser.

Identifiera språk

detect_language avgör språket i indatatexten, inklusive konfidenspoängen för det förutsagda språket.

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

Det returnerade svaret är en heterogen lista över resultat- och felobjekt: list[DetectLanguageResult, DocumentError]

Se tjänstdokumentationen för en konceptuell diskussion om språkidentifiering och språk och regional support.

Analys av hälso- och sjukvårdsentiteter

Tidskrävande åtgärdbegin_analyze_healthcare_entities extraherar entiteter som identifieras i sjukvårdsdomänen och identifierar relationer mellan entiteter i indatadokumentet och länkar till kända informationskällor i olika välkända databaser, till exempel UMLS, CHV, MSH osv.

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
]

Obs! Analys av hälso- och sjukvårdsentiteter är endast tillgängligt med API-version v3.1 och senare.

Flera analyser

Långvariga åtgärderbegin_analyze_actions utför flera analyser över en uppsättning dokument i en enda begäran. För närvarande stöds det med valfri kombination av följande språk-API:er i en enda begäran:

  • Entitetsigenkänning
  • Igenkänning av PII-entiteter
  • Igenkänning av länkad entitet
  • Extrahering av nyckelfraser
  • Attitydanalys
  • Anpassad entitetsigenkänning (API-version 2022-05-01 och senare)
  • Anpassad klassificering med en etikett (API-version 2022-05-01 och senare)
  • Anpassad klassificering av flera etiketter (API-version 2022-05-01 och senare)
  • Analys av sjukvårdsentiteter (API-version 2022-05-01 och senare)
  • Extraheringssammanfattning (API-version 2023-04-01 och senare)
  • Abstrakt sammanfattning (API-version 2023-04-01 och senare)
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("------------------------------------------")

Det returnerade svaret är ett objekt som kapslar in flera iterabler, som var och en representerar resultatet av enskilda analyser.

Obs! Flera analyser är tillgängliga i API-version v3.1 och senare.

Valfri konfiguration

Valfria nyckelordsargument kan skickas in på klient- och åtgärdsnivå. Referensdokumentationen för azure-core beskriver tillgängliga konfigurationer för återförsök, loggning, transportprotokoll med mera.

Felsökning

Allmänt

Den Textanalys klienten genererar undantag som definierats i Azure Core.

Loggning

Det här biblioteket använder standardloggningsbiblioteket för loggning. Grundläggande information om HTTP-sessioner (URL:er, rubriker osv.) loggas på INFO-nivå.

Detaljerad loggning på FELSÖKNINGsnivå, inklusive begärande-/svarskroppar och oredigerade rubriker, kan aktiveras på en klient med nyckelordsargumentet 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."])

logging_enable På samma sätt kan aktivera detaljerad loggning för en enda åtgärd, även om den inte är aktiverad för klienten:

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

Nästa steg

Mer exempelkod

Dessa kodexempel visar vanliga scenarioåtgärder med Azure Textanalys-klientbiblioteket.

Autentisera klienten med en API-nyckel för Cognitive Services/Language-tjänsten eller en tokenautentiseringsuppgift från azure-identity:

Vanliga scenarier

Avancerade scenarier

Ytterligare dokumentation

Mer omfattande dokumentation om Azure Cognitive Service for Language finns i Language Service-dokumentationen om docs.microsoft.com.

Bidra

Det här projektet välkomnar bidrag och förslag. Merparten av bidragen kräver att du godkänner ett licensavtal för bidrag, där du deklarerar att du har behörighet att bevilja oss rättigheten att använda ditt bidrag, och att du dessutom uttryckligen gör så. Mer information finns i cla.microsoft.com.

När du skickar en pull-förfrågan avgör en CLA-robot automatiskt om du måste tillhandahålla ett licensavtal för bidrag med lämplig PR (t.ex. etikett eller kommentar). Följ bara robotens anvisningar. Du behöver bara göra detta en gång för alla repor som använder vårt licensavtal för bidrag.

Det här projektet använder sig av Microsofts uppförandekod för öppen källkod. Mer information finns i Vanliga frågor och svar om uppförandekod eller kontakt opencode@microsoft.com med ytterligare frågor eller kommentarer.