Azure Textanalyse-Clientbibliothek für Python– Version 5.3.0

  • Artikel

Azure Cognitive Service for Language ist ein cloudbasierter Dienst, der NLP-Features (Natural Language Processing) zum Verstehen und Analysieren von Text bereitstellt und die folgenden Standard Features umfasst:

  • Standpunktanalyse
  • Erkennung benannter Entitäten
  • Spracherkennung
  • Schlüsselwortextraktion
  • Entitätsverknüpfung
  • Mehrfachanalyse
  • Erkennung personenbezogener Informationen (PII)
  • Text Analytics for Health
  • Benutzerdefinierte Erkennung benannter Entitäten (Custom Named Entity Recognition)
  • Benutzerdefinierte Textklassifizierung
  • Extraktive Textzusammenfassung
  • Zusammenfassung von abstraktionsivem Text

Quellcode | Paket (PyPI) | Paket (Conda) | API-Referenzdokumentation | Produktdokumentation | Proben

Erste Schritte

Voraussetzungen

Erstellen einer Cognitive Services- oder Sprachdienstressource

Der Sprachdienst unterstützt sowohl den Zugriff mit mehreren diensten als auch den Zugriff mit einem einzelnen Dienst. Erstellen Sie eine Cognitive Services-Ressource, wenn Sie planen, über einen einzelnen Endpunkt bzw. Schlüssel auf mehrere Cognitive Services-Instanzen zuzugreifen. Erstellen Sie nur für den Sprachdienstzugriff eine Sprachdienstressource. Sie können die Ressource mithilfe des Azure-Portals oder der Azure CLI erstellen, indem Sie die Schritte in diesem Dokument ausführen.

Die Interaktion mit dem Dienst mithilfe der Clientbibliothek beginnt mit einem . Um ein Clientobjekt zu erstellen, benötigen Sie den Cognitive Services- oder Sprachdienst endpoint für Ihre Ressource und einen credential , der Ihnen Zugriff auf Folgendes ermöglicht:

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)

Beachten Sie, dass der Endpunkt für einige Cognitive Services-Ressourcen möglicherweise anders aussieht als der obige Codeausschnitt. Beispielsweise https://<region>.api.cognitive.microsoft.com/.

Installieren des Pakets

Installieren Sie die Azure Textanalyse-Clientbibliothek für Python mit 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))

Beachten Sie, dass 5.2.X und höher auf die Azure Cognitive Service for Language-APIs ausgerichtet sind. Diese APIs enthalten die Funktionen für die Textanalyse und die Verarbeitung natürlicher Sprache in den vorherigen Versionen der Textanalyse-Clientbibliothek. Darüber hinaus wurde die Dienst-API von der semantischen zur datumsbasierten Versionsverwaltung geändert. Diese Version der Clientbibliothek verwendet standardmäßig die neueste unterstützte API-Version, die derzeit ist 2023-04-01.

Diese Tabelle zeigt die Beziehung zwischen SDK-Versionen und unterstützten API-Versionen des Diensts.

SDK-Version Unterstützte API-Version des Diensts
5.3.X : Neueste stabile Version 3.0, 3.1, 2022-05-01, 2023-04-01 (Standard)
5.2.X 3.0, 3.1, 01.05.2022 (Standard)
5.1.0 3.0, 3.1 (Standard)
5.0.0 3.0

Die API-Version kann ausgewählt werden, indem das argument api_version Schlüsselwort (keyword) an den Client übergeben wird. Für die neuesten Sprachdienstfeatures sollten Sie die neueste Beta-API-Version auswählen. Für Produktionsszenarien wird die neueste stabile Version empfohlen. Die Einstellung auf eine ältere Version kann zu einer verringerten Featurekompatibilität führen.

Authentifizieren des Clients

Abrufen des Endpunkts

Den Endpunkt für Ihre Sprachdienstressource finden Sie über das Azure-Portal oder die 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"

Abrufen des API-Schlüssels

Sie können den API-Schlüssel aus der Cognitive Services- oder Sprachdienstressource im Azure-Portal abrufen. Alternativ können Sie den folgenden Azure CLI-Codeausschnitt verwenden, um den API-Schlüssel Ihrer Ressource abzurufen.

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

Erstellen eines TextAnalyticsClient mit api-Schlüsselanmeldeinformationen

Sobald Sie über den Wert für den API-Schlüssel verfügen, können Sie ihn als Zeichenfolge an eine instance von AzureKeyCredential übergeben. Verwenden Sie den Schlüssel als Anmeldeinformationsparameter, um den Client zu authentifizieren:

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

Erstellen eines TextAnalyticsClient mit Azure Active Directory-Anmeldeinformationen

Um Azure Active Directory-Tokenanmeldeinformationen (AAD) zu verwenden, geben Sie eine instance des gewünschten Anmeldeinformationstyps an, der aus der azure-identity-Bibliothek abgerufen wird. Beachten Sie, dass regionale Endpunkte die AAD-Authentifizierung nicht unterstützen. Erstellen Sie einen benutzerdefinierten Unterdomänennamen für Ihre Ressource, um diese Art der Authentifizierung zu verwenden.

Die Authentifizierung mit AAD erfordert eine anfängliche Einrichtung:

Nach dem Setup können Sie auswählen, welche Art von Anmeldeinformationen aus azure.identity verwendet werden soll. Beispielsweise kann DefaultAzureCredential verwendet werden, um den Client zu authentifizieren:

Legen Sie die Werte der Client-ID, mandanten-ID und des geheimen Clientschlüssels der AAD-Anwendung als Umgebungsvariablen fest: AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET

Verwenden Sie die zurückgegebenen Tokenanmeldeinformationen, um den Client zu authentifizieren:

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)

Wichtige Begriffe

TextAnalyticsClient

Die Textanalyse-Clientbibliothek stellt einen TextAnalyticsClient für die Analyse von von Dokumenten bereit. Es bietet sowohl synchrone als auch asynchrone Vorgänge für den Zugriff auf eine bestimmte Verwendung der Textanalyse, z. B. Spracherkennung oder Schlüsselbegriffserkennung.

Eingabe

Ein Dokument ist eine einzelne Einheit, die von den Vorhersagemodellen im Sprachdienst analysiert werden soll. Die Eingabe für jeden Vorgang wird als Liste von Dokumenten übergeben.

Jedes Dokument kann als Zeichenfolge in der Liste übergeben werden, z. B.

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

Oder, wenn Sie ein Elementdokument id oder languagecountry_hint/übergeben möchten, können sie als Liste von DetectLanguageInput oder TextDocumentInput oder als diktierähnliche Darstellung des Objekts übergeben werden:

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

Weitere Informationen finden Sie unter Diensteinschränkungen für die Eingabe, z. B. Grenzwerte für die Dokumentlänge, maximale Batchgröße und unterstützte Textcodierung.

Rückgabewert

Der Rückgabewert für ein einzelnes Dokument kann ein Ergebnis- oder Fehlerobjekt sein. Von jedem Vorgang wird eine heterogene Liste zurückgegeben, die eine Auflistung von Ergebnis- und Fehlerobjekten enthält. Diese Ergebnisse/Fehler werden mit der Reihenfolge der bereitgestellten Dokumente indiziert.

Ein Ergebnis, z. B . AnalyzeSentimentResult, ist das Ergebnis eines Textanalysevorgangs und enthält eine Vorhersage oder Vorhersagen zu einer Dokumenteingabe.

Das FehlerobjektDocumentError gibt an, dass der Dienst Probleme beim Verarbeiten des Dokuments hatte, und enthält den Grund, warum es nicht erfolgreich war.

Dokumentfehlerbehandlung

Sie können mit dem -Attribut nach einem Ergebnis- oder Fehlerobjekt in der is_error Liste filtern. Für ein Ergebnisobjekt ist dies immer False und für einen DocumentError ist dies True.

Um beispielsweise alle DocumentErrors herauszufiltern, können Sie das Listenverständnis verwenden:

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

Sie können das kind -Attribut auch verwenden, um zwischen Ergebnistypen zu filtern:

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 Vorgänge

Vorgänge mit langer Ausführungsdauer sind Vorgänge, die aus einer anfänglichen Anforderung bestehen, die an den Dienst gesendet wird, um einen Vorgang zu starten, gefolgt von der Abfrage des Diensts in Intervallen, um festzustellen, ob der Vorgang abgeschlossen oder fehlgeschlagen ist, und ob er erfolgreich war, um das Ergebnis zu erhalten.

Methoden, die die Analyse im Gesundheitswesen, die benutzerdefinierte Textanalyse oder mehrere Analysen unterstützen, werden als zeitintensive Vorgänge modelliert. Der Client macht eine begin_<method-name> Methode verfügbar, die ein Poller-Objekt zurückgibt. Aufrufer sollten warten, bis der Vorgang abgeschlossen ist, indem sie für das Von der begin_<method-name> -Methode zurückgegebene Poller-Objekt aufrufenresult(). Beispielcodeausschnitte werden bereitgestellt, um die Verwendung von Vorgängen mit langer Ausführungszeit zu veranschaulichen unten.

Beispiele

Der folgende Abschnitt enthält mehrere Codeausschnitte, die einige der häufigsten Sprachdienstaufgaben behandeln, einschließlich:

Analysieren der Stimmung

analyze_sentiment betrachtet den Eingabetext und bestimmt, ob die Stimmung positiv, negativ, neutral oder gemischt ist. Die Antwort umfasst stimmungsbasierte Analyse und Konfidenzbewertungen pro Satz.

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

Die zurückgegebene Antwort ist eine heterogene Liste von Ergebnis- und Fehlerobjekten: list[AnalyzeSentimentResult, DocumentError]

Eine konzeptionelle Diskussion zur Stimmungsanalyse finden Sie in der Servicedokumentation. Informationen zur detaillierteren Analyse der Meinungen zu einzelnen Aspekten (z. B. Attribute eines Produkts oder einer Dienstleistung) in einem Text finden Sie hier.

Entitäten erkennen

recognize_entities erkennt Entitäten in seinem Eingabetext als Personen, Orte, Organisationen, Datum/Uhrzeit, Mengen, Prozentsätze, Währungen und mehr.

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

Die zurückgegebene Antwort ist eine heterogene Liste von Ergebnis- und Fehlerobjekten: list[RecognizeEntitiesResult, DocumentError]

Eine konzeptionelle Diskussion zur Erkennung benannter Entitäten und unterstützten Typen finden Sie in der Dienstdokumentation.

Erkennen verknüpfter Entitäten

recognize_linked_entities erkennt und definiert die Identität jeder Entität, die in ihrem Eingabetext gefunden wird (z. B. bestimmt, ob sich ein Vorkommen des Worts Mars auf den Planeten oder auf den römischen Kriegsgott bezieht). Erkannte Entitäten sind URLs einem bekannten Wissensdatenbank wie Wikipedia zugeordnet.

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

Die zurückgegebene Antwort ist eine heterogene Liste von Ergebnis- und Fehlerobjekten: list[RecognizeLinkedEntitiesResult, DocumentError]

Eine konzeptionelle Erläuterung zu Entitätsverknüpfungs - und unterstützten Typen finden Sie in der Dienstdokumentation.

Erkennen von PII-Entitäten

recognize_pii_entities erkennt und kategorisiert Personenbezogene Informationen (PII) Entitäten in seinem Eingabetext, z. B. Sozialversicherungsnummern, Bankkontoinformationen, Kredit- Karte Nummern und mehr.

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

Die zurückgegebene Antwort ist eine heterogene Liste von Ergebnis- und Fehlerobjekten: list[RecognizePiiEntitiesResult, DocumentError]

Informationen zu unterstützten PII-Entitätstypen finden Sie in der Dienstdokumentation.

Hinweis: Der Dienst Erkennen von PII-Entitäten ist in der API-Version v3.1 und höher verfügbar.

Extrahieren von Schlüsselbegriffen

extract_key_phrases bestimmt die Standard Gesprächspunkte im Eingabetext. Beispielsweise gibt die API für den Eingabetext "Das Essen war lecker und es gab wunderbare Mitarbeiter" zurück: "Essen" und "wunderbares 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)
        ))

Die zurückgegebene Antwort ist eine heterogene Liste von Ergebnis- und Fehlerobjekten: list[ExtractKeyPhrasesResult, DocumentError]

Eine konzeptionelle Diskussion zur Schlüsselbegriffsextraktion finden Sie in der Dienstdokumentation.

Erkennen von Sprache

detect_language bestimmt die Sprache des Eingabetexts, einschließlich der Konfidenzbewertung der vorhergesagten Sprache.

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

Die zurückgegebene Antwort ist eine heterogene Liste von Ergebnis- und Fehlerobjekten: list[DetectLanguageResult, DocumentError]

Eine konzeptionelle Diskussion zur Spracherkennung sowie zur Sprach- und Regionalunterstützung finden Sie in der Servicedokumentation.

Analyse von Entitäten im Gesundheitswesen

Der lang andauernde Begin_analyze_healthcare_entities extrahiert Entitäten, die innerhalb der Gesundheitsdomäne erkannt werden, und identifiziert Beziehungen zwischen Entitäten innerhalb des Eingabedokuments und Links zu bekannten Informationsquellen in verschiedenen bekannten Datenbanken, z. B. UMLS, CHV, MSH usw.

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
]

Hinweis: Die Analyse von Entitäten im Gesundheitswesen ist nur mit der API-Version v3.1 und höher verfügbar.

Mehrfachanalyse

Der langwierige Vorgangbegin_analyze_actions mehrere Analysen für einen Satz von Dokumenten in einer einzigen Anforderung durchführt. Derzeit wird die Verwendung einer beliebigen Kombination der folgenden Sprach-APIs in einer einzelnen Anforderung unterstützt:

  • Entitätserkennung
  • Erkennung von PII-Entitäten
  • Erkennung verknüpfter Entitäten
  • Schlüsselwortextraktion
  • Standpunktanalyse
  • Benutzerdefinierte Entitätserkennung (API-Version 2022-05-01 und höher)
  • Benutzerdefinierte Single Label Classification (API-Version 2022-05-01 und höher)
  • Benutzerdefinierte Klassifizierung mit mehreren Bezeichnungen (API-Version 2022-05-01 und höher)
  • Analyse von Entitäten im Gesundheitswesen (API-Version 2022-05-01 und höher)
  • Extrahierende Zusammenfassung (API-Version 2023-04-01 und höher)
  • Abstrakte Zusammenfassung (API-Version 2023-04-01 und höher)
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("------------------------------------------")

Die zurückgegebene Antwort ist ein Objekt, das mehrere Iterables kapselt, die jeweils ergebnisse einzelner Analysen darstellen.

Hinweis: Mehrere Analysen sind in der API-Version v3.1 und höher verfügbar.

Optionale Konfiguration

Optionale Schlüsselwort (keyword) Argumente können auf Client- und Vorgangsebene übergeben werden. Die azure-core-Referenzdokumentation beschreibt verfügbare Konfigurationen für Wiederholungen, Protokollierung, Transportprotokolle und vieles mehr.

Problembehandlung

Allgemein

Der Textanalyse-Client löst die in Azure Core definierten Ausnahmen aus.

Protokollierung

Diese Bibliothek verwendet die Standardprotokollierungsbibliothek für die Protokollierung. Grundlegende Informationen zu HTTP-Sitzungen (URLs, Header usw.) werden auf INFO-Ebene protokolliert.

Eine ausführliche Protokollierung auf der Ebene DEBUG, einschließlich Anforderungs-/Antworttexten und vollständiger Header, kann auf einem Client mit dem Schlüsselwortargument logging_enable aktiviert werden:

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."])

Ebenso kann über logging_enable die ausführliche Protokollierung für einen einzelnen Vorgang aktiviert werden, auch wenn diese Funktion für den Client nicht aktiviert ist:

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

Nächste Schritte

Weiterer Beispielcode

Diese Codebeispiele zeigen häufige Szenariovorgänge mit der Azure Textanalyse-Clientbibliothek.

Authentifizieren Sie den Client mit einem Cognitive Services/Language Service-API-Schlüssel oder tokenbasierten Anmeldeinformationen aus azure-identity:

Häufige Szenarios

Erweiterte Szenarios

Zusätzliche Dokumentation

Eine ausführlichere Dokumentation zu Azure Cognitive Service for Language finden Sie in der Language Service-Dokumentation auf docs.microsoft.com.

Mitwirken

Beiträge und Vorschläge für dieses Projekt sind willkommen. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. Weitere Informationen finden Sie unter cla.microsoft.com.

Wenn Sie einen Pull Request (PR) übermitteln, überprüft ein CLA-Bot automatisch, ob Sie eine Lizenzvereinbarung bereitstellen und den PR entsprechend ergänzen müssen (z.B. mit einer Bezeichnung oder einem Kommentar). Führen Sie einfach die Anweisungen des Bots aus. Sie müssen dies nur einmal für alle Repositorys ausführen, die unsere CLA verwenden.

Für dieses Projekt gelten die Microsoft-Verhaltensregeln für Open Source (Microsoft Open Source Code of Conduct). Weitere Informationen finden Sie in den häufig gestellten Fragen zum Verhaltenskodex. Sie können sich auch an opencode@microsoft.com wenden, wenn Sie weitere Fragen oder Anmerkungen haben.