Freigeben über

Azure Cognitive Services Textanalyse Clientbibliothek für .NET – Version 5.3.0

  • Artikel

Textanalyse ist Teil von Azure Cognitive Service for Language, einem cloudbasierten Dienst, der NLP-Features (Natural Language Processing) zum Verstehen und Analysieren von Text bereitstellt. Diese Clientbibliothek bietet die folgenden Features:

  • Spracherkennung
  • Stimmungsanalyse
  • Schlüsselwortextraktion
  • Erkennung benannter Entitäten (NER)
  • Erkennung von Personenidentifizierbaren Informationen (PII)
  • Entitätsverknüpfung
  • Textanalyse für Gesundheit
  • Erkennung benutzerdefinierter benannter Entitäten (Custom NER)
  • Benutzerdefinierte Textklassifizierung
  • Extrahierende Textzusammenfassung
  • Zusammenfassung abstrakter Texte

Quellcode | Paket (NuGet) | API-Referenzdokumentation | Produktdokumentation | Proben

Erste Schritte

Installieren des Pakets

Installieren Sie die Azure Textanalyse-Clientbibliothek für .NET mit NuGet:

dotnet add package Azure.AI.TextAnalytics

Diese Tabelle gibt Aufschluss über die Beziehung zwischen SDK-Versionen und unterstützten API-Versionen des Diensts:

Beachten Sie, dass es sich 5.2.0 um die erste stabile Version der Clientbibliothek handelt, die auf die Azure Cognitive Service for Language-APIs abzielt, die die vorhandenen Funktionen für die Textanalyse und die Verarbeitung natürlicher Sprache in der Textanalyse-Clientbibliothek enthält. Darüber hinaus wurde die Dienst-API von der semantischen zur datumsbasierten Versionsverwaltung geändert.

SDK-Version Unterstützte API-Version des Diensts
5.3.X 3.0, 3.1, 2022-05-01, 2023-04-01 (Standard)
5.2.X 3.0, 3.1, 01.05.2022 (Standard)
5.1.X 3.0, 3.1 (Standard)
5.0.X 3.0
1.0.X 3.0

Voraussetzungen

  • Ein Azure-Abonnement.
  • Eine vorhandene Cognitive Services- oder Sprachdienstressource.

Erstellen einer Cognitive Services-Ressource oder einer Sprachdienstressource

Azure Cognitive Service for Language unterstützt sowohl den Zugriff mit mehreren Diensten als auch den Einzeldienst. Erstellen Sie eine Cognitive Services-Ressource, wenn Sie planen, auf mehrere Cognitive Services unter einem einzelnen Endpunkt und api-Schlüssel zuzugreifen. Um nur auf die Features des Sprachdiensts zuzugreifen, erstellen Sie stattdessen eine Sprachdienstressource.

Sie können entweder eine Ressource über die Azure-Portal erstellen oder alternativ die Schritte in diesem Dokument ausführen, um sie mithilfe der Azure CLI zu erstellen.

Authentifizieren des Clients

Die Interaktion mit dem Dienst mithilfe der Clientbibliothek beginnt mit dem Erstellen einer instance der TextAnalyticsClient-Klasse. Sie benötigen einen Endpunkt und entweder einen API-Schlüssel oder TokenCredential zum Instanziieren eines Clientobjekts. Weitere Informationen zur Authentifizierung mit Cognitive Services finden Sie unter Authentifizieren von Anforderungen an Azure Cognitive Services.

Abrufen eines API-Schlüssels

Sie können die Informationen API key und endpoint aus der Cognitive Services-Ressource oder der Sprachdienstressourcen im Azure-Portal abrufen.

Alternativ können Sie den folgenden Azure CLI-Codeausschnitt verwenden, um den API-Schlüssel aus der Sprachdienstressource abzurufen.

az cognitiveservices account keys list --resource-group <your-resource-group-name> --name <your-resource-name>

Erstellen von TextAnalyticsClient Anmeldeinformationen für einen API-Schlüssel

Wenn Sie über den Wert für den API-Schlüssel verfügen, erstellen Sie einen AzureKeyCredential. Dadurch können Sie den API-Schlüssel aktualisieren, ohne einen neuen Client zu erstellen.

Mit dem Wert des Endpunkts und eines AzureKeyCredentialkönnen Sie textAnalyticsClient erstellen:

Uri endpoint = new("<endpoint>");
AzureKeyCredential credential = new("<apiKey>");
TextAnalyticsClient client = new(endpoint, credential);

Erstellen eines TextAnalyticsClient mit Azure Active Directory-Anmeldeinformationen

Die Client-API-Schlüsselauthentifizierung wird in den meisten Beispielen in diesem Leitfaden für die ersten Schritte verwendet. Sie können sich jedoch auch mithilfe der Azure Identity-Bibliothek bei Azure Active Directory authentifizieren. Beachten Sie, dass regionale Endpunkte die AAD-Authentifizierung nicht unterstützen. Erstellen Sie eine benutzerdefinierte Unterdomäne für Ihre Ressource, um diesen Authentifizierungstyp zu verwenden.

Um den unten gezeigten Anbieter DefaultAzureCredential oder andere Anbieter von Anmeldeinformationen zu verwenden, die mit dem Azure SDK bereitgestellt werden, installieren Sie das Azure.Identity-Paket:

dotnet add package Azure.Identity

Sie müssen auch eine neue AAD-Anwendung registrieren und zugriff auf den Sprachdienst gewähren, indem Sie die "Cognitive Services User" Rolle Ihrem Dienstprinzipal zuweisen.

Legen Sie die Werte der Client-ID, Mandanten-ID und geheimen Clientschlüssel der AAD-Anwendung als Umgebungsvariablen fest: AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET.

Uri endpoint = new("<endpoint>");
TextAnalyticsClient client = new(endpoint, new DefaultAzureCredential());

Wichtige Begriffe

TextAnalyticsClient

A TextAnalyticsClient ist die primäre Schnittstelle für Entwickler, die die Textanalyse Clientbibliothek verwenden. Es bietet sowohl synchrone als auch asynchrone Vorgänge für den Zugriff auf eine bestimmte Verwendung der Textanalyse, z. B. Spracherkennung oder Schlüsselbegriffsextraktion.

Eingabe

Ein Dokument ist eine einzelne Eingabeeinheit, die von den Vorhersagemodellen im Sprachdienst analysiert werden soll. Vorgänge an TextAnalyticsClient können ein einzelnes Dokument oder eine Sammlung von Dokumenten als Batch analysieren. Dokumentlängenlimits, maximale Batchgröße und unterstützte Textcodierung finden Sie hier.

Vorgang für mehrere Dokumente

Stellt für jeden unterstützten Vorgang eine Methode bereit, TextAnalyticsClient die einen Batch von Dokumenten als Zeichenfolgen akzeptiert, oder einen Batch mit entweder TextDocumentInput - oder DetectLanguageInput -Objekten. Mit diesen Methoden können Aufrufer jedem Dokument eine eindeutige ID zukommen lassen, angeben, dass die Dokumente im Batch in verschiedenen Sprachen geschrieben sind, oder einen Länderhinweis zur Sprache des Dokuments bereitstellen.

Hinweis: Es wird empfohlen, die Batchmethoden zu verwenden, wenn Sie in Produktionsumgebungen arbeiten, da sie es Ihnen ermöglichen, eine Anforderung mit mehreren Dokumenten zu senden. Dies ist effizienter als das Senden einer Anforderung pro Dokument.

Rückgabewert

Rückgabewerte, zAnalyzeSentimentResult. B. , sind das Ergebnis eines Textanalyse Vorgangs, der eine Vorhersage oder Vorhersagen zu einem einzelnen Dokument enthält. Der Rückgabewert eines Vorgangs kann optional auch Informationen zum Dokument und seiner Verarbeitung enthalten.

Rückgabewertauflistung

Eine Rückgabewertauflistung, z AnalyzeSentimentResultCollection. B. , ist eine Sammlung von Vorgangsergebnissen, bei denen jedes einem der im Eingabebatch bereitgestellten Dokumente entspricht. Ein Dokument und sein Ergebnis weisen denselben Index in den Eingabe- und Ergebnisauflistungen auf. Der Rückgabewert enthält auch eine HasError Eigenschaft, mit der ermittelt werden kann, ob ein ausgeführter Vorgang für das angegebene Dokument erfolgreich war oder nicht erfolgreich war. Es kann optional Informationen zum Dokumentbatch und zur Verarbeitung enthalten.

Long-Running Vorgänge

Bei großen Dokumenten, deren Ausführung sehr lange dauert, werden diese Vorgänge als langwierige Vorgänge implementiert. Vorgänge mit langer Ausführungsdauer bestehen aus einer anfänglichen Anforderung, 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 wenn er erfolgreich war, um das Ergebnis zu erhalten.

Bei Vorgängen mit langer Ausführungsdauer im Azure SDK macht der Client eine Start<operation-name> Methode verfügbar, die ein Operation<T> oder zurückgibt PageableOperation<T>. Sie können die Erweiterungsmethode WaitForCompletionAsync() verwenden, um auf den Abschluss des Vorgangs zu warten und das Ergebnis abzurufen. Ein Beispielcodeausschnitt wird bereitgestellt, um die Verwendung von Vorgängen mit langer Ausführungsdauer unten zu veranschaulichen.

Threadsicherheit

Wir garantieren, dass alle Client-instance Methoden threadsicher und unabhängig voneinander sind (Richtlinie). Dadurch wird sichergestellt, dass die Empfehlung, Clientinstanzen wiederzuverwenden, immer sicher ist, auch über Threads hinweg.

Zusätzliche Konzepte

Clientoptionen | Zugreifen auf die Antwort | Behandeln von Fehlern | Diagnose | Spott | Clientlebensdauer

Beispiele

Der folgende Abschnitt enthält mehrere Codeausschnitte, die das clientoben erstellte verwenden, und behandelt die Standard Features in dieser Clientbibliothek. Obwohl die meisten der folgenden Codeausschnitte synchrone Dienstaufrufe verwenden, beachten Sie, dass das Azure.AI.TextAnalytics Paket sowohl synchrone als auch asynchrone APIs unterstützt.

Synchronisierungsbeispiele

Asynchrone Beispiele

Erkennen von Sprache

Führen Sie ein Vorhersagemodell aus, um die Sprache zu bestimmen, in der das übergebene Dokument oder der Batch von Dokumenten geschrieben ist.

string document =
    "Este documento está escrito en un lenguaje diferente al inglés. Su objectivo es demostrar cómo"
    + " invocar el método de Detección de Lenguaje del servicio de Text Analytics en Microsoft Azure."
    + " También muestra cómo acceder a la información retornada por el servicio. Esta funcionalidad es"
    + " útil para los sistemas de contenido que recopilan texto arbitrario, donde el lenguaje no se conoce"
    + " de antemano. Puede usarse para detectar una amplia gama de lenguajes, variantes, dialectos y"
    + " algunos idiomas regionales o culturales.";

try
{
    Response<DetectedLanguage> response = client.DetectLanguage(document);
    DetectedLanguage language = response.Value;

    Console.WriteLine($"Detected language is {language.Name} with a confidence score of {language.ConfidenceScore}.");
}
catch (RequestFailedException exception)
{
    Console.WriteLine($"Error Code: {exception.ErrorCode}");
    Console.WriteLine($"Message: {exception.Message}");
}

Beispiele zur Verwendung der empfohlenen Produktionsoption DetectLanguageBatch finden Sie hier.

Eine konzeptionelle Erläuterung zur Spracherkennung finden Sie in der Servicedokumentation.

Analysieren der Stimmung

Führen Sie ein Vorhersagemodell aus, um die positive, negative, neutrale oder gemischte Stimmung zu bestimmen, die im übergebenen Dokument oder Batch von Dokumenten enthalten ist.

string document =
    "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.";

try
{
    Response<DocumentSentiment> response = client.AnalyzeSentiment(document);
    DocumentSentiment docSentiment = response.Value;

    Console.WriteLine($"Document sentiment is {docSentiment.Sentiment} with: ");
    Console.WriteLine($"  Positive confidence score: {docSentiment.ConfidenceScores.Positive}");
    Console.WriteLine($"  Neutral confidence score: {docSentiment.ConfidenceScores.Neutral}");
    Console.WriteLine($"  Negative confidence score: {docSentiment.ConfidenceScores.Negative}");
}
catch (RequestFailedException exception)
{
    Console.WriteLine($"Error Code: {exception.ErrorCode}");
    Console.WriteLine($"Message: {exception.Message}");
}

Beispiele zur Verwendung der empfohlenen Produktionsoption AnalyzeSentimentBatch finden Sie hier.

Um präzisere Informationen zu den Meinungen im Zusammenhang mit Zielen eines Produkts/einer Dienstleistung zu erhalten, die auch als aspektbasierte Stimmungsanalyse in natural Language Processing (NLP) bezeichnet wird, finden Sie hier ein Beispiel zur Standpunktanalyse mit Opinion Mining.

Eine konzeptionelle Erläuterung zur Stimmungsanalyse finden Sie in der Servicedokumentation.

Extrahieren von Schlüsselbegriffen

Führen Sie ein Modell aus, um eine Sammlung wichtiger Ausdrücke zu identifizieren, die im übergebenen Dokument oder Im Batch von Dokumenten gefunden wurden.

string document =
    "My cat might need to see a veterinarian. It has been sneezing more than normal, and although my"
    + " little sister thinks it is funny, I am worried it has the cold that I got last week. We are going"
    + " to call tomorrow and try to schedule an appointment for this week. Hopefully it will be covered by"
    + " the cat's insurance. It might be good to not let it sleep in my room for a while.";

try
{
    Response<KeyPhraseCollection> response = client.ExtractKeyPhrases(document);
    KeyPhraseCollection keyPhrases = response.Value;

    Console.WriteLine($"Extracted {keyPhrases.Count} key phrases:");
    foreach (string keyPhrase in keyPhrases)
    {
        Console.WriteLine($"  {keyPhrase}");
    }
}
catch (RequestFailedException exception)
{
    Console.WriteLine($"Error Code: {exception.ErrorCode}");
    Console.WriteLine($"Message: {exception.Message}");
}

Beispiele zur Verwendung der empfohlenen Produktionsoption ExtractKeyPhrasesBatch finden Sie hier.

Eine konzeptionelle Erläuterung der Schlüsselbegriffserkennung finden Sie in der Dienstdokumentation.

Erkennen benannter Entitäten

Führen Sie ein Vorhersagemodell aus, um eine Sammlung benannter Entitäten im übergebenen Dokument oder Batch von Dokumenten zu identifizieren und diese Entitäten in Kategorien wie Person, Standort oder organization zu kategorisieren. Weitere Informationen zu verfügbaren Kategorien finden Sie unter Textanalyse Benannte Entitätskategorien.

string document =
    "We love this trail and make the trip every year. The views are breathtaking and well worth the hike!"
    + " Yesterday was foggy though, so we missed the spectacular views. We tried again today and it was"
    + " amazing. Everyone in my family liked the trail although it was too challenging for the less"
    + " athletic among us. Not necessarily recommended for small children. A hotel close to the trail"
    + " offers services for childcare in case you want that.";

try
{
    Response<CategorizedEntityCollection> response = client.RecognizeEntities(document);
    CategorizedEntityCollection entitiesInDocument = response.Value;

    Console.WriteLine($"Recognized {entitiesInDocument.Count} entities:");
    foreach (CategorizedEntity entity in entitiesInDocument)
    {
        Console.WriteLine($"  Text: {entity.Text}");
        Console.WriteLine($"  Offset: {entity.Offset}");
        Console.WriteLine($"  Length: {entity.Length}");
        Console.WriteLine($"  Category: {entity.Category}");
        if (!string.IsNullOrEmpty(entity.SubCategory))
            Console.WriteLine($"  SubCategory: {entity.SubCategory}");
        Console.WriteLine($"  Confidence score: {entity.ConfidenceScore}");
        Console.WriteLine();
    }
}
catch (RequestFailedException exception)
{
    Console.WriteLine($"Error Code: {exception.ErrorCode}");
    Console.WriteLine($"Message: {exception.Message}");
}

Beispiele zur Verwendung der empfohlenen Produktionsoption RecognizeEntitiesBatch finden Sie hier.

Eine konzeptionelle Erläuterung zur Erkennung benannter Entitäten finden Sie in der Dienstdokumentation.

Erkennen von PII-Entitäten

Führen Sie ein Vorhersagemodell aus, um eine Sammlung von Entitäten zu identifizieren, die personenbezogene Informationen enthalten, die im übergebenen Dokument oder im Batch von Dokumenten gefunden wurden, und kategorisieren Sie diese Entitäten in Kategorien wie US-Sozialversicherungsnummer, Führerscheinnummer oder Gutschrift Karte Nummer.

string document =
    "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 800-102-1100. They are originally from Brazil and have document ID number"
    + " 998.214.865-68.";

try
{
    Response<PiiEntityCollection> response = client.RecognizePiiEntities(document);
    PiiEntityCollection entities = response.Value;

    Console.WriteLine($"Redacted Text: {entities.RedactedText}");
    Console.WriteLine();
    Console.WriteLine($"Recognized {entities.Count} PII entities:");
    foreach (PiiEntity entity in entities)
    {
        Console.WriteLine($"  Text: {entity.Text}");
        Console.WriteLine($"  Category: {entity.Category}");
        if (!string.IsNullOrEmpty(entity.SubCategory))
            Console.WriteLine($"  SubCategory: {entity.SubCategory}");
        Console.WriteLine($"  Confidence score: {entity.ConfidenceScore}");
        Console.WriteLine();
    }
}
catch (RequestFailedException exception)
{
    Console.WriteLine($"Error Code: {exception.ErrorCode}");
    Console.WriteLine($"Message: {exception.Message}");
}

Beispiele zur Verwendung der empfohlenen Produktionsoption RecognizePiiEntitiesBatch finden Sie hier.

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

Erkennen verknüpfter Entitäten

Führen Sie ein Vorhersagemodell aus, um eine Sammlung von Entitäten zu identifizieren, die im übergebenen Dokument oder Batch von Dokumenten gefunden wurden, und fügen Sie Informationen ein, die die Entitäten mit ihren entsprechenden Einträgen in einem bekannten Wissensdatenbank verknüpfen.

string document =
    "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 Januaray 1979, but is now headquartered in Redmond.";

try
{
    Response<LinkedEntityCollection> response = client.RecognizeLinkedEntities(document);
    LinkedEntityCollection linkedEntities = response.Value;

    Console.WriteLine($"Recognized {linkedEntities.Count} entities:");
    foreach (LinkedEntity linkedEntity in linkedEntities)
    {
        Console.WriteLine($"  Name: {linkedEntity.Name}");
        Console.WriteLine($"  Language: {linkedEntity.Language}");
        Console.WriteLine($"  Data Source: {linkedEntity.DataSource}");
        Console.WriteLine($"  URL: {linkedEntity.Url}");
        Console.WriteLine($"  Entity Id in Data Source: {linkedEntity.DataSourceEntityId}");
        foreach (LinkedEntityMatch match in linkedEntity.Matches)
        {
            Console.WriteLine($"    Match Text: {match.Text}");
            Console.WriteLine($"    Offset: {match.Offset}");
            Console.WriteLine($"    Length: {match.Length}");
            Console.WriteLine($"    Confidence score: {match.ConfidenceScore}");
        }
        Console.WriteLine();
    }
}
catch (RequestFailedException exception)
{
    Console.WriteLine($"Error Code: {exception.ErrorCode}");
    Console.WriteLine($"Message: {exception.Message}");
}

Beispiele zur Verwendung der empfohlenen Produktionsoption RecognizeLinkedEntitiesBatch finden Sie hier.

Eine konzeptionelle Erläuterung der Entitätsverknüpfung finden Sie in der Dienstdokumentation.

Asynchrones Erkennen von Sprache

Führen Sie ein Vorhersagemodell aus, um die Sprache zu bestimmen, in der das übergebene Dokument oder der Batch von Dokumenten geschrieben ist.

string document =
    "Este documento está escrito en un lenguaje diferente al inglés. Su objectivo es demostrar cómo"
    + " invocar el método de Detección de Lenguaje del servicio de Text Analytics en Microsoft Azure."
    + " También muestra cómo acceder a la información retornada por el servicio. Esta funcionalidad es"
    + " útil para los sistemas de contenido que recopilan texto arbitrario, donde el lenguaje no se conoce"
    + " de antemano. Puede usarse para detectar una amplia gama de lenguajes, variantes, dialectos y"
    + " algunos idiomas regionales o culturales.";

try
{
    Response<DetectedLanguage> response = await client.DetectLanguageAsync(document);
    DetectedLanguage language = response.Value;

    Console.WriteLine($"Detected language is {language.Name} with a confidence score of {language.ConfidenceScore}.");
}
catch (RequestFailedException exception)
{
    Console.WriteLine($"Error Code: {exception.ErrorCode}");
    Console.WriteLine($"Message: {exception.Message}");
}

Asynchrones Erkennen benannter Entitäten

Führen Sie ein Vorhersagemodell aus, um eine Sammlung benannter Entitäten im übergebenen Dokument oder Batch von Dokumenten zu identifizieren und diese Entitäten in Kategorien wie Person, Standort oder organization zu kategorisieren. Weitere Informationen zu verfügbaren Kategorien finden Sie unter Textanalyse Benannte Entitätskategorien.

string document =
    "We love this trail and make the trip every year. The views are breathtaking and well worth the hike!"
    + " Yesterday was foggy though, so we missed the spectacular views. We tried again today and it was"
    + " amazing. Everyone in my family liked the trail although it was too challenging for the less"
    + " athletic among us. Not necessarily recommended for small children. A hotel close to the trail"
    + " offers services for childcare in case you want that.";

try
{
    Response<CategorizedEntityCollection> response = await client.RecognizeEntitiesAsync(document);
    CategorizedEntityCollection entitiesInDocument = response.Value;

    Console.WriteLine($"Recognized {entitiesInDocument.Count} entities:");
    foreach (CategorizedEntity entity in entitiesInDocument)
    {
        Console.WriteLine($"  Text: {entity.Text}");
        Console.WriteLine($"  Offset: {entity.Offset}");
        Console.WriteLine($"  Length: {entity.Length}");
        Console.WriteLine($"  Category: {entity.Category}");
        if (!string.IsNullOrEmpty(entity.SubCategory))
            Console.WriteLine($"  SubCategory: {entity.SubCategory}");
        Console.WriteLine($"  Confidence score: {entity.ConfidenceScore}");
        Console.WriteLine();
    }
}
catch (RequestFailedException exception)
{
    Console.WriteLine($"Error Code: {exception.ErrorCode}");
    Console.WriteLine($"Message: {exception.Message}");
}

Asynchrones Analysieren von Entitäten im Gesundheitswesen

Text Analytics for Health ist ein Containerdienst, der relevante medizinische Informationen aus unstrukturierten Texten wie Arztbriefen, Entlassungsberichten, klinischen Dokumenten und elektronischen Gesundheitsakten extrahiert und bezeichnet. Weitere Informationen finden Sie unter Vorgehensweise: Verwenden von Textanalyse für die Integrität.

string documentA =
    "RECORD #333582770390100 | MH | 85986313 | | 054351 | 2/14/2001 12:00:00 AM |"
    + " CORONARY ARTERY DISEASE | Signed | DIS |"
    + Environment.NewLine
    + " Admission Date: 5/22/2001 Report Status: Signed Discharge Date: 4/24/2001"
    + " ADMISSION DIAGNOSIS: CORONARY ARTERY DISEASE."
    + Environment.NewLine
    + " HISTORY OF PRESENT ILLNESS: The patient is a 54-year-old gentleman with a history of progressive"
    + " angina over the past several months. The patient had a cardiac catheterization in July of this"
    + " year revealing total occlusion of the RCA and 50% left main disease, with a strong family history"
    + " of coronary artery disease with a brother dying at the age of 52 from a myocardial infarction and"
    + " another brother who is status post coronary artery bypass grafting. The patient had a stress"
    + " echocardiogram done on July, 2001, which showed no wall motion abnormalities, but this was a"
    + " difficult study due to body habitus. The patient went for six minutes with minimal ST depressions"
    + " in the anterior lateral leads, thought due to fatigue and wrist pain, his anginal equivalent. Due"
    + " to the patient'sincreased symptoms and family history and history left main disease with total"
    + " occasional of his RCA was referred for revascularization with open heart surgery.";

string documentB = "Prescribed 100mg ibuprofen, taken twice daily.";

// Prepare the input of the text analysis operation. You can add multiple documents to this list and
// perform the same operation on all of them simultaneously.
List<string> batchedDocuments = new()
{
    documentA,
    documentB
};

// Perform the text analysis operation.
AnalyzeHealthcareEntitiesOperation operation = await client.AnalyzeHealthcareEntitiesAsync(WaitUntil.Completed, batchedDocuments);

Console.WriteLine($"The operation has completed.");
Console.WriteLine();

// View the operation status.
Console.WriteLine($"Created On   : {operation.CreatedOn}");
Console.WriteLine($"Expires On   : {operation.ExpiresOn}");
Console.WriteLine($"Id           : {operation.Id}");
Console.WriteLine($"Status       : {operation.Status}");
Console.WriteLine($"Last Modified: {operation.LastModified}");
Console.WriteLine();

// View the operation results.
await foreach (AnalyzeHealthcareEntitiesResultCollection documentsInPage in operation.Value)
{
    Console.WriteLine($"Analyze Healthcare Entities, model version: \"{documentsInPage.ModelVersion}\"");
    Console.WriteLine();

    foreach (AnalyzeHealthcareEntitiesResult documentResult in documentsInPage)
    {
        if (documentResult.HasError)
        {
            Console.WriteLine($"  Error!");
            Console.WriteLine($"  Document error code: {documentResult.Error.ErrorCode}");
            Console.WriteLine($"  Message: {documentResult.Error.Message}");
            continue;
        }

        Console.WriteLine($"  Recognized the following {documentResult.Entities.Count} healthcare entities:");
        Console.WriteLine();

        // View the healthcare entities that were recognized.
        foreach (HealthcareEntity entity in documentResult.Entities)
        {
            Console.WriteLine($"  Entity: {entity.Text}");
            Console.WriteLine($"  Category: {entity.Category}");
            Console.WriteLine($"  Offset: {entity.Offset}");
            Console.WriteLine($"  Length: {entity.Length}");
            Console.WriteLine($"  NormalizedText: {entity.NormalizedText}");
            Console.WriteLine($"  Links:");

            // View the entity data sources.
            foreach (EntityDataSource entityDataSource in entity.DataSources)
            {
                Console.WriteLine($"    Entity ID in Data Source: {entityDataSource.EntityId}");
                Console.WriteLine($"    DataSource: {entityDataSource.Name}");
            }

            // View the entity assertions.
            if (entity.Assertion is not null)
            {
                Console.WriteLine($"  Assertions:");

                if (entity.Assertion?.Association is not null)
                {
                    Console.WriteLine($"    Association: {entity.Assertion?.Association}");
                }

                if (entity.Assertion?.Certainty is not null)
                {
                    Console.WriteLine($"    Certainty: {entity.Assertion?.Certainty}");
                }

                if (entity.Assertion?.Conditionality is not null)
                {
                    Console.WriteLine($"    Conditionality: {entity.Assertion?.Conditionality}");
                }
            }
        }

        Console.WriteLine($"  We found {documentResult.EntityRelations.Count} relations in the current document:");
        Console.WriteLine();

        // View the healthcare entity relations that were recognized.
        foreach (HealthcareEntityRelation relation in documentResult.EntityRelations)
        {
            Console.WriteLine($"    Relation: {relation.RelationType}");
            if (relation.ConfidenceScore is not null)
            {
                Console.WriteLine($"    ConfidenceScore: {relation.ConfidenceScore}");
            }
            Console.WriteLine($"    For this relation there are {relation.Roles.Count} roles");

            // View the relation roles.
            foreach (HealthcareEntityRelationRole role in relation.Roles)
            {
                Console.WriteLine($"      Role Name: {role.Name}");

                Console.WriteLine($"      Associated Entity Text: {role.Entity.Text}");
                Console.WriteLine($"      Associated Entity Category: {role.Entity.Category}");
                Console.WriteLine();
            }

            Console.WriteLine();
        }

        Console.WriteLine();
    }
}

Ausführen mehrerer Aktionen asynchron

Diese Funktionalität ermöglicht das Ausführen mehrerer Aktionen in einem oder mehreren Dokumenten. Dazu gehören die folgenden Aktionen:

  • Erkennung benannter Entitäten
  • Erkennung von PII-Entitäten
  • Erkennung verknüpfter Entitäten
  • Schlüsselwortextraktion
  • Standpunktanalyse
  • Erkennung von Entitäten im Gesundheitswesen (siehe Beispiel hier)
  • Benutzerdefinierte Erkennung benannter Entitäten (siehe Beispiel hier)
  • Benutzerdefinierte Klassifizierung für einzelne Bezeichnungen (siehe Beispiel hier)
  • Benutzerdefinierte Klassifizierung mit mehreren Bezeichnungen (siehe Beispiel hier)
    string documentA =
        "We love this trail and make the trip every year. The views are breathtaking and well worth the hike!"
        + " Yesterday was foggy though, so we missed the spectacular views. We tried again today and it was"
        + " amazing. Everyone in my family liked the trail although it was too challenging for the less"
        + " athletic among us.";

    string documentB =
        "Last week we stayed at Hotel Foo to celebrate our anniversary. The staff knew about our anniversary"
        + " so they helped me organize a little surprise for my partner. The room was clean and with the"
        + " decoration I requested. It was perfect!";

    // Prepare the input of the text analysis operation. You can add multiple documents to this list and
    // perform the same operation on all of them simultaneously.
    List<string> batchedDocuments = new()
    {
        documentA,
        documentB
    };

    TextAnalyticsActions actions = new()
    {
        ExtractKeyPhrasesActions = new List<ExtractKeyPhrasesAction>() { new ExtractKeyPhrasesAction() { ActionName = "ExtractKeyPhrasesSample" } },
        RecognizeEntitiesActions = new List<RecognizeEntitiesAction>() { new RecognizeEntitiesAction() { ActionName = "RecognizeEntitiesSample" } },
        DisplayName = "AnalyzeOperationSample"
    };

    // Perform the text analysis operation.
    AnalyzeActionsOperation operation = await client.AnalyzeActionsAsync(WaitUntil.Completed, batchedDocuments, actions);

    // View the operation status.
    Console.WriteLine($"Created On   : {operation.CreatedOn}");
    Console.WriteLine($"Expires On   : {operation.ExpiresOn}");
    Console.WriteLine($"Id           : {operation.Id}");
    Console.WriteLine($"Status       : {operation.Status}");
    Console.WriteLine($"Last Modified: {operation.LastModified}");
    Console.WriteLine();

    if (!string.IsNullOrEmpty(operation.DisplayName))
    {
        Console.WriteLine($"Display name: {operation.DisplayName}");
        Console.WriteLine();
    }

    Console.WriteLine($"Total actions: {operation.ActionsTotal}");
    Console.WriteLine($"  Succeeded actions: {operation.ActionsSucceeded}");
    Console.WriteLine($"  Failed actions: {operation.ActionsFailed}");
    Console.WriteLine($"  In progress actions: {operation.ActionsInProgress}");
    Console.WriteLine();

    await foreach (AnalyzeActionsResult documentsInPage in operation.Value)
    {
        IReadOnlyCollection<ExtractKeyPhrasesActionResult> keyPhrasesResults = documentsInPage.ExtractKeyPhrasesResults;
        IReadOnlyCollection<RecognizeEntitiesActionResult> entitiesResults = documentsInPage.RecognizeEntitiesResults;

        Console.WriteLine("Recognized Entities");
        int docNumber = 1;
        foreach (RecognizeEntitiesActionResult entitiesActionResults in entitiesResults)
        {
            Console.WriteLine($" Action name: {entitiesActionResults.ActionName}");
            Console.WriteLine();
            foreach (RecognizeEntitiesResult documentResult in entitiesActionResults.DocumentsResults)
            {
                Console.WriteLine($" Document #{docNumber++}");
                Console.WriteLine($"  Recognized {documentResult.Entities.Count} entities:");

                foreach (CategorizedEntity entity in documentResult.Entities)
                {
                    Console.WriteLine();
                    Console.WriteLine($"    Entity: {entity.Text}");
                    Console.WriteLine($"    Category: {entity.Category}");
                    Console.WriteLine($"    Offset: {entity.Offset}");
                    Console.WriteLine($"    Length: {entity.Length}");
                    Console.WriteLine($"    ConfidenceScore: {entity.ConfidenceScore}");
                    Console.WriteLine($"    SubCategory: {entity.SubCategory}");
                }
                Console.WriteLine();
            }
        }

        Console.WriteLine("Extracted Key Phrases");
        docNumber = 1;
        foreach (ExtractKeyPhrasesActionResult keyPhrasesActionResult in keyPhrasesResults)
        {
            Console.WriteLine($" Action name: {keyPhrasesActionResult.ActionName}");
            Console.WriteLine();
            foreach (ExtractKeyPhrasesResult documentResults in keyPhrasesActionResult.DocumentsResults)
            {
                Console.WriteLine($" Document #{docNumber++}");
                Console.WriteLine($"  Recognized the following {documentResults.KeyPhrases.Count} Keyphrases:");

                foreach (string keyphrase in documentResults.KeyPhrases)
                {
                    Console.WriteLine($"    {keyphrase}");
                }
                Console.WriteLine();
            }
        }
    }
}

Problembehandlung

Allgemein

Wenn Sie mit Cognitive Services für Sprache mithilfe des .NET Textanalyse SDK interagieren, entsprechen vom Sprachdienst zurückgegebene Fehler denselben HTTP-status Codes, die für REST-API-Anforderungen zurückgegeben werden.

Wenn Sie beispielsweise einen Batch von Textdokumenteingaben mit doppelten Dokument-IDs übermitteln, wird ein 400 Fehler zurückgegeben, der auf "Ungültige Anforderung" hinweist.

try
{
    DetectedLanguage result = client.DetectLanguage(document);
}
catch (RequestFailedException e)
{
    Console.WriteLine(e.ToString());
}

Sie werden feststellen, dass zusätzliche Informationen protokolliert werden, z. B. die Clientanforderungs-ID des Vorgangs.

Message:
    Azure.RequestFailedException:
    Status: 400 (Bad Request)

Content:
    {"error":{"code":"InvalidRequest","innerError":{"code":"InvalidDocument","message":"Request contains duplicated Ids. Make sure each document has a unique Id."},"message":"Invalid document in request."}}

Headers:
    Transfer-Encoding: chunked
    x-aml-ta-request-id: 146ca04a-af54-43d4-9872-01a004bee5f8
    X-Content-Type-Options: nosniff
    x-envoy-upstream-service-time: 6
    apim-request-id: c650acda-2b59-4ff7-b96a-e316442ea01b
    Strict-Transport-Security: max-age=31536000; includeSubDomains; preload
    Date: Wed, 18 Dec 2019 16:24:52 GMT
    Content-Type: application/json; charset=utf-8

Einrichten der Konsolenprotokollierung

Die einfachste Möglichkeit, die Protokolle anzuzeigen, besteht darin, die Konsolenprotokollierung zu aktivieren. Verwenden Sie die AzureEventSourceListener.CreateConsoleLogger-Methode, um einen Azure SDK-Protokolllistener zu erstellen, der Nachrichten an die Konsole ausgibt.

// Setup a listener to monitor logged events.
using AzureEventSourceListener listener = AzureEventSourceListener.CreateConsoleLogger();

Weitere Informationen zu anderen Protokollierungsmechanismen finden Sie hier.

Nächste Schritte

Beispiele zur Verwendung dieser Clientbibliothek sind in diesem GitHub-Repository verfügbar. Für jeden Standard Funktionsbereich werden Beispiele bereitgestellt, und für jeden Bereich werden Beispiele für die Analyse eines einzelnen Dokuments und eine Sammlung von Dokumenten im synchronen und asynchronen Modus bereitgestellt.

Erweiterte Beispiele

Mitwirken

Ausführliche Informationen zum Erstellen, Testen und Mitwirken zu dieser Bibliothek finden Sie im CONTRIBUTING.md .

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.

Aufrufe