Schnellstart: Verwenden der Textanalyse-Clientbibliothek und der REST-API

Dieser Artikel hilft Ihnen beim Einstieg in die Verwendung der Textanalyse-Clientbibliothek und der REST-API. Befolgen Sie diese Schritte, um die Codebeispiele für das Text Mining zu testen.

Wichtig

  • In dieser Schnellstartanleitung werden nur die folgenden Versionen der API behandelt: v3.1 und v3.2-preview.

Voraussetzungen

  • Azure-Abonnement – Erstellen eines kostenlosen Kontos
  • Visual Studio-IDE
  • Damit Sie den entsprechenden KI-Bedingungen zustimmen und eine Ressource erstellen können, muss Ihrem Azure-Konto die Rolle „Cognitive Services-Mitwirkender“ zugewiesen sein. Kontaktieren Sie Ihren Administrator, der Ihrem Konto diese Rolle zuweisen kann.
  • Sobald Sie über Ihr Azure-Abonnement verfügen, erstellen Sie eine Textanalyseressource im Azure-Portal, um Ihren Schlüssel und Endpunkt zu erhalten. Klicken Sie nach Abschluss der Bereitstellung auf Zu Ressource wechseln.
    • Sie benötigen den Schlüssel und den Endpunkt der von Ihnen erstellten Ressource, um Ihre Anwendung mit der Textanalyse-API zu verbinden. Der Schlüssel und der Endpunkt werden weiter unten in der Schnellstartanleitung in den Code eingefügt.
    • Sie können den kostenlosen Tarif (F0) verwenden, um den Dienst zu testen, und später für die Produktion auf einen kostenpflichtigen Tarif upgraden.
  • Sie benötigen eine Textanalyse-Ressource des Standard-Tarifs (S), um das Analyze-Feature nutzen zu können.

Einrichten

Erstellen einer neuen .NET Core-Anwendung

Erstellen Sie über die Visual Studio-IDE eine neue .NET Core-Konsolenanwendung. Dadurch wird ein Projekt vom Typ „Hallo Welt“ mit einer einzelnen C#-Quelldatei (program.cs) erstellt.

Installieren Sie die Clientbibliothek, indem Sie im Projektmappen-Explorer mit der rechten Maustaste auf die Projektmappe klicken und NuGet-Pakete verwalten auswählen. Wählen Sie im daraufhin geöffneten Paket-Manager die Option Durchsuchen aus, und suchen Sie nach Azure.AI.TextAnalytics. Stellen Sie sicher, dass Vorabversion einbeziehen aktiviert ist. Wählen Sie die Version 5.2.0-beta.1 und anschließend Installieren aus. Sie können auch die Paket-Manager-Konsole verwenden.

Features in dieser Version der Textanalyse-API:

  • Stimmungsanalyse
  • Opinion Mining
  • Spracherkennung
  • Entitätserkennung
  • Entitätsverknüpfung
  • Erkennung personenbezogener Informationen
  • Schlüsselwortextraktion
  • Asynchrone Methoden
  • Textanalyse für Gesundheit
  • Textzusammenfassung

Öffnen Sie die Datei program.cs, und fügen Sie die folgenden using-Anweisungen hinzu:

using Azure;
using System;
using System.Globalization;
using Azure.AI.TextAnalytics;

Erstellen Sie in der Program-Klasse der Anwendung Variablen für den Schlüssel und Endpunkt Ihrer Ressource.

Wichtig

Öffnen Sie das Azure-Portal. Wenn die im Abschnitt Voraussetzungen erstellte Textanalyseressource erfolgreich bereitgestellt wurde, klicken Sie unter Nächste Schritte auf die Schaltfläche Zu Ressource wechseln. Schlüssel und Endpunkt finden Sie auf der Seite mit dem Schlüssel und dem Endpunkt der Ressource unter Ressourcenverwaltung.

Denken Sie daran, den Schlüssel aus Ihrem Code zu entfernen, wenn Sie fertig sind, und ihn niemals zu veröffentlichen. In der Produktionsumgebung sollten Sie eine sichere Methode zum Speichern Ihrer Anmeldeinformationen sowie zum Zugriff darauf verwenden. Beispielsweise Azure Key Vault.

private static readonly AzureKeyCredential credentials = new AzureKeyCredential("<replace-with-your-text-analytics-key-here>");
private static readonly Uri endpoint = new Uri("<replace-with-your-text-analytics-endpoint-here>");

Ersetzen Sie die Main-Methode der Anwendung. Die hier aufgerufenen Methoden definieren Sie später.

static void Main(string[] args)
{
    var client = new TextAnalyticsClient(endpoint, credentials);
    // You will implement these methods later in the quickstart.
    SentimentAnalysisExample(client);
    SentimentAnalysisWithOpinionMiningExample(client);
    LanguageDetectionExample(client);
    EntityRecognitionExample(client);
    EntityLinkingExample(client);
    RecognizePIIExample(client);
    KeyPhraseExtractionExample(client);

    Console.Write("Press any key to exit.");
    Console.ReadKey();
}

Objektmodell

Der Textanalyse-Client ist ein Objekt vom Typ TextAnalyticsClient, das sich mit Ihrem Schlüssel bei Azure authentifiziert und Funktionen bereitstellt, um Text als einzelne Zeichenfolgen oder als Batch zu akzeptieren. Sie können Text synchron oder asynchron an die API senden. Das Antwortobjekt enthält die Analyseinformationen für die einzelnen gesendeten Dokumente.

Wenn Sie Version 3.x des Diensts verwenden, können Sie eine optionale TextAnalyticsClientOptions-Instanz nutzen, um den Client mit verschiedenen Standardeinstellungen wie Standardsprache oder Länder-/Regionshinweis zu initialisieren. Sie können für die Authentifizieren auch ein Azure Active Directory-Token verwenden.

Wenn Sie Text Analytics verwenden, dürfen die Dokumente in Ihrer Abfrage die folgenden Zeichengrenzwerte nicht überschreiten. Weitere Informationen finden Sie im Artikel zu den Datengrenzwerten.

  • Synchrone Vorgänge und Text Analytics für Integritätsvorgänge: 5.120 Zeichen pro Dokument.
  • Asynchrone Vorgänge (Analysieren): 125.000 Zeichen pro Dokument.

Authentifizieren des Clients

Stellen Sie sicher, dass mit Ihrer zuvor erstellten Main-Methode ein neues Clientobjekt mit Ihrem Endpunkt und Ihren Anmeldeinformationen erstellt wird.

var client = new TextAnalyticsClient(endpoint, credentials);

Stimmungsanalyse

Erstellen Sie eine neue Funktion namens SentimentAnalysisExample(), die den zuvor erstellten Client verwendet, und rufen Sie die zugehörige Funktion AnalyzeSentiment() auf. Das zurückgegebene Objekt vom Typ Response<DocumentSentiment> enthält die Stimmungsbezeichnung und den Stimmungswert des gesamten Eingabedokuments sowie eine Standpunktanalyse für jeden Satz (sofern erfolgreich). Im Falle eines Fehlers wird ein Fehler vom Typ RequestFailedException ausgelöst.

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

static void SentimentAnalysisExample(TextAnalyticsClient client)
{
    string inputText = "I had the best day of my life. I wish you were there with me.";
    DocumentSentiment documentSentiment = client.AnalyzeSentiment(inputText);
    Console.WriteLine($"Document sentiment: {documentSentiment.Sentiment}\n");

    foreach (var sentence in documentSentiment.Sentences)
    {
        Console.WriteLine($"\tText: \"{sentence.Text}\"");
        Console.WriteLine($"\tSentence sentiment: {sentence.Sentiment}");
        Console.WriteLine($"\tPositive score: {sentence.ConfidenceScores.Positive:0.00}");
        Console.WriteLine($"\tNegative score: {sentence.ConfidenceScores.Negative:0.00}");
        Console.WriteLine($"\tNeutral score: {sentence.ConfidenceScores.Neutral:0.00}\n");
    }
}

Output

Document sentiment: Positive

        Text: "I had the best day of my life."
        Sentence sentiment: Positive
        Positive score: 1.00
        Negative score: 0.00
        Neutral score: 0.00

        Text: "I wish you were there with me."
        Sentence sentiment: Neutral
        Positive score: 0.21
        Negative score: 0.02
        Neutral score: 0.77

Opinion Mining

Erstellen Sie eine neue Funktion namens SentimentAnalysisWithOpinionMiningExample(), die den zuvor erstellten Client verwendet, und rufen Sie die zugehörige AnalyzeSentimentBatch() Funktion mitIncludeOpinionMining der Option AnalyzeSentimentOptions bag auf. Das zurückgegebene AnalyzeSentimentResultCollection-Objekt enthält die Auflistung von AnalyzeSentimentResult, in der Response<DocumentSentiment> darstellt ist. Der Unterschied zwischen SentimentAnalysis() und SentimentAnalysisWithOpinionMiningExample() besteht darin, dass das letztere in jedem Satz SentenceOpinion enthält, was ein analysiertes Ziel und die zugehörige(n) Bewertung(en) anzeigt. Im Falle eines Fehlers wird ein Fehler vom Typ RequestFailedException ausgelöst.

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

static void SentimentAnalysisWithOpinionMiningExample(TextAnalyticsClient client)
{
    var documents = new List<string>
    {
        "The food and service were unacceptable, but the concierge were nice."
    };

    AnalyzeSentimentResultCollection reviews = client.AnalyzeSentimentBatch(documents, options: new AnalyzeSentimentOptions()
    {
        IncludeOpinionMining = true
    });

    foreach (AnalyzeSentimentResult review in reviews)
    {
        Console.WriteLine($"Document sentiment: {review.DocumentSentiment.Sentiment}\n");
        Console.WriteLine($"\tPositive score: {review.DocumentSentiment.ConfidenceScores.Positive:0.00}");
        Console.WriteLine($"\tNegative score: {review.DocumentSentiment.ConfidenceScores.Negative:0.00}");
        Console.WriteLine($"\tNeutral score: {review.DocumentSentiment.ConfidenceScores.Neutral:0.00}\n");
        foreach (SentenceSentiment sentence in review.DocumentSentiment.Sentences)
        {
            Console.WriteLine($"\tText: \"{sentence.Text}\"");
            Console.WriteLine($"\tSentence sentiment: {sentence.Sentiment}");
            Console.WriteLine($"\tSentence positive score: {sentence.ConfidenceScores.Positive:0.00}");
            Console.WriteLine($"\tSentence negative score: {sentence.ConfidenceScores.Negative:0.00}");
            Console.WriteLine($"\tSentence neutral score: {sentence.ConfidenceScores.Neutral:0.00}\n");

            foreach (SentenceOpinion sentenceOpinion in sentence.Opinions)
            {
                Console.WriteLine($"\tTarget: {sentenceOpinion.Target.Text}, Value: {sentenceOpinion.Target.Sentiment}");
                Console.WriteLine($"\tTarget positive score: {sentenceOpinion.Target.ConfidenceScores.Positive:0.00}");
                Console.WriteLine($"\tTarget negative score: {sentenceOpinion.Target.ConfidenceScores.Negative:0.00}");
                foreach (AssessmentSentiment assessment in sentenceOpinion.Assessments)
                {
                    Console.WriteLine($"\t\tRelated Assessment: {assessment.Text}, Value: {assessment.Sentiment}");
                    Console.WriteLine($"\t\tRelated Assessment positive score: {assessment.ConfidenceScores.Positive:0.00}");
                    Console.WriteLine($"\t\tRelated Assessment negative score: {assessment.ConfidenceScores.Negative:0.00}");
                }
            }
        }
        Console.WriteLine($"\n");
    }
}

Output

Document sentiment: Positive

        Positive score: 0.84
        Negative score: 0.16
        Neutral score: 0.00

        Text: "The food and service were unacceptable, but the concierge were nice."
        Sentence sentiment: Positive
        Sentence positive score: 0.84
        Sentence negative score: 0.16
        Sentence neutral score: 0.00

        Target: food, Value: Negative
        Target positive score: 0.01
        Target negative score: 0.99
                Related Assessment: unacceptable, Value: Negative
                Related Assessment positive score: 0.01
                Related Assessment negative score: 0.99
        Target: service, Value: Negative
        Target positive score: 0.01
        Target negative score: 0.99
                Related Assessment: unacceptable, Value: Negative
                Related Assessment positive score: 0.01
                Related Assessment negative score: 0.99
        Target: concierge, Value: Positive
        Target positive score: 1.00
        Target negative score: 0.00
                Related Assessment: nice, Value: Positive
                Related Assessment positive score: 1.00
                Related Assessment negative score: 0.00

Press any key to exit.

Spracherkennung

Erstellen Sie eine neue Funktion namens LanguageDetectionExample(), die den zuvor erstellten Client verwendet, und rufen Sie die zugehörige Funktion DetectLanguage() auf. Das zurückgegebene Objekt vom Typ Response<DetectedLanguage> enthält die erkannte Sprache sowie den zugehörigen Namen und ISO-6391-Code. Im Falle eines Fehlers wird ein Fehler vom Typ RequestFailedException ausgelöst.

Tipp

In einigen Fällen ist es unter Umständen schwierig, die Sprachen basierend auf den Eingaben eindeutig zu bestimmen. Mithilfe des Parameters countryHint können Sie einen zweistelligen Länder-/Regionscode angeben. Die API verwendet standardmäßig „US“ als Wert für „countryHint“. Wenn Sie dieses Verhalten entfernen möchten, können Sie diesen Parameter zurücksetzen, indem Sie seinen Wert auf eine leere Zeichenfolge (countryHint = "") festlegen. Wenn Sie einen anderen Standardwert festlegen möchten, legen Sie die Eigenschaft TextAnalyticsClientOptions.DefaultCountryHint fest, und übergeben Sie sie während der Initialisierung des Clients.

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

static void LanguageDetectionExample(TextAnalyticsClient client)
{
    DetectedLanguage detectedLanguage = client.DetectLanguage("Ce document est rédigé en Français.");
    Console.WriteLine("Language:");
    Console.WriteLine($"\t{detectedLanguage.Name},\tISO-6391: {detectedLanguage.Iso6391Name}\n");
}

Output

Language:
        French, ISO-6391: fr

Erkennung benannter Entitäten (NER)

Erstellen Sie eine neue Funktion namens EntityRecognitionExample(), die den zuvor erstellten Client verwendet, rufen Sie die zugehörige Funktion RecognizeEntities() auf, und durchlaufen Sie die Ergebnisse. Das zurückgegebene Response<CategorizedEntityCollection>-Objekt enthält die Sammlung der erkannten CategorizedEntity-Entitäten. Im Falle eines Fehlers wird ein Fehler vom Typ RequestFailedException ausgelöst.

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

static void EntityRecognitionExample(TextAnalyticsClient client)
{
    var response = client.RecognizeEntities("I had a wonderful trip to Seattle last week.");
    Console.WriteLine("Named Entities:");
    foreach (var entity in response.Value)
    {
        Console.WriteLine($"\tText: {entity.Text},\tCategory: {entity.Category},\tSub-Category: {entity.SubCategory}");
        Console.WriteLine($"\t\tScore: {entity.ConfidenceScore:F2},\tLength: {entity.Length},\tOffset: {entity.Offset}\n");
    }
}

Output

Named Entities:
        Text: trip,     Category: Event,        Sub-Category:
                Score: 0.61,    Length: 4,      Offset: 18

        Text: Seattle,  Category: Location,     Sub-Category: GPE
                Score: 0.82,    Length: 7,      Offset: 26

        Text: last week,        Category: DateTime,     Sub-Category: DateRange
                Score: 0.80,    Length: 9,      Offset: 34

Erkennung von personenbezogenen Informationen (PII)

Erstellen Sie eine neue Funktion namens RecognizePIIExample(), die den zuvor erstellten Client verwendet, rufen Sie die zugehörige Funktion RecognizePiiEntities() auf, und durchlaufen Sie die Ergebnisse. Die zurückgegebene PiiEntityCollection stellt die Liste der erkannten PII-Entitäten dar. Im Falle eines Fehlers wird ein Fehler vom Typ RequestFailedException ausgelöst.

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

static void RecognizePIIExample(TextAnalyticsClient client)
{
    string document = "A developer with SSN 859-98-0987 whose phone number is 800-102-1100 is building tools with our APIs.";

    PiiEntityCollection entities = client.RecognizePiiEntities(document).Value;

    Console.WriteLine($"Redacted Text: {entities.RedactedText}");
    if (entities.Count > 0)
    {
        Console.WriteLine($"Recognized {entities.Count} PII entit{(entities.Count > 1 ? "ies" : "y")}:");
        foreach (PiiEntity entity in entities)
        {
            Console.WriteLine($"Text: {entity.Text}, Category: {entity.Category}, SubCategory: {entity.SubCategory}, Confidence score: {entity.ConfidenceScore}");
        }
    }
    else
    {
        Console.WriteLine("No entities were found.");
    }
}

Output

Redacted Text: A developer with SSN *********** whose phone number is ************ is building tools with our APIs.
Recognized 2 PII entities:
Text: 859-98-0987, Category: U.S. Social Security Number (SSN), SubCategory: , Confidence score: 0.65
Text: 800-102-1100, Category: Phone Number, SubCategory: , Confidence score: 0.8

Entitätsverknüpfung

Erstellen Sie eine neue Funktion namens EntityLinkingExample(), die den zuvor erstellten Client verwendet, rufen Sie die zugehörige Funktion RecognizeLinkedEntities() auf, und durchlaufen Sie die Ergebnisse. Das zurückgegebene Response<LinkedEntityCollection>-Objekt enthält die Sammlung der erkannten LinkedEntity-Entitäten. Im Falle eines Fehlers wird ein Fehler vom Typ RequestFailedException ausgelöst. Da verknüpfte Entitäten eindeutig identifiziert werden, werden Vorkommen der gleichen Entität unter einem Objekt vom Typ LinkedEntity als Liste von Objekten des Typs LinkedEntityMatch gruppiert.

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

static void EntityLinkingExample(TextAnalyticsClient client)
{
    var response = client.RecognizeLinkedEntities(
        "Microsoft was founded by Bill Gates and Paul Allen on April 4, 1975, " +
        "to develop and sell BASIC interpreters for the Altair 8800. " +
        "During his career at Microsoft, Gates held the positions of chairman, " +
        "chief executive officer, president and chief software architect, " +
        "while also being the largest individual shareholder until May 2014.");
    Console.WriteLine("Linked Entities:");
    foreach (var entity in response.Value)
    {
        Console.WriteLine($"\tName: {entity.Name},\tID: {entity.DataSourceEntityId},\tURL: {entity.Url}\tData Source: {entity.DataSource}");
        Console.WriteLine("\tMatches:");
        foreach (var match in entity.Matches)
        {
            Console.WriteLine($"\t\tText: {match.Text}");
            Console.WriteLine($"\t\tScore: {match.ConfidenceScore:F2}");
            Console.WriteLine($"\t\tLength: {match.Length}");
            Console.WriteLine($"\t\tOffset: {match.Offset}\n");
        }
    }
}

Output

Linked Entities:
        Name: Microsoft,        ID: Microsoft,  URL: https://en.wikipedia.org/wiki/Microsoft    Data Source: Wikipedia
        Matches:
                Text: Microsoft
                Score: 0.55
                Length: 9
                Offset: 0

                Text: Microsoft
                Score: 0.55
                Length: 9
                Offset: 150

        Name: Bill Gates,       ID: Bill Gates, URL: https://en.wikipedia.org/wiki/Bill_Gates   Data Source: Wikipedia
        Matches:
                Text: Bill Gates
                Score: 0.63
                Length: 10
                Offset: 25

                Text: Gates
                Score: 0.63
                Length: 5
                Offset: 161

        Name: Paul Allen,       ID: Paul Allen, URL: https://en.wikipedia.org/wiki/Paul_Allen   Data Source: Wikipedia
        Matches:
                Text: Paul Allen
                Score: 0.60
                Length: 10
                Offset: 40

        Name: April 4,  ID: April 4,    URL: https://en.wikipedia.org/wiki/April_4      Data Source: Wikipedia
        Matches:
                Text: April 4
                Score: 0.32
                Length: 7
                Offset: 54

        Name: BASIC,    ID: BASIC,      URL: https://en.wikipedia.org/wiki/BASIC        Data Source: Wikipedia
        Matches:
                Text: BASIC
                Score: 0.33
                Length: 5
                Offset: 89

        Name: Altair 8800,      ID: Altair 8800,        URL: https://en.wikipedia.org/wiki/Altair_8800  Data Source: Wikipedia
        Matches:
                Text: Altair 8800
                Score: 0.88
                Length: 11
                Offset: 116

Schlüsselwortextraktion

Erstellen Sie eine neue Funktion namens KeyPhraseExtractionExample(), die den zuvor erstellten Client verwendet, und rufen Sie die zugehörige Funktion ExtractKeyPhrases() auf. Das zurückgegebene Objekt vom Typ <Response<KeyPhraseCollection> enthält die Liste erkannter Schlüsselbegriffe. Im Falle eines Fehlers wird ein Fehler vom Typ RequestFailedException ausgelöst.

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

static void KeyPhraseExtractionExample(TextAnalyticsClient client)
{
    var response = client.ExtractKeyPhrases("My cat might need to see a veterinarian.");

    // Printing key phrases
    Console.WriteLine("Key phrases:");

    foreach (string keyphrase in response.Value)
    {
        Console.WriteLine($"\t{keyphrase}");
    }
}

Output

Key phrases:
    cat
    veterinarian

Extrahieren von Integritätsentitäten

Achtung

  • Wenn Sie den Integritätsvorgang verwenden möchten, muss es sich bei Ihrer Azure-Ressource um eine Ressource im Standard-Tarif (S) handeln.

Fügen Sie Ihrer C#-Datei die folgenden Verwendungsanweisungen hinzu, sofern noch nicht geschehen:

using System.Threading.Tasks;
using System.Collections.Generic;
using System.Linq;

Sie können die Textanalyse verwenden, um eine asynchrone Anforderung zum Extrahieren von Integritätsentitäten aus dem Text durchzuführen. Nachfolgend sehen Sie ein einfaches Beispiel für diesen Vorgang. Ein komplexeres Beispiel können Sie auf GitHub finden.

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

static async Task healthExample(TextAnalyticsClient client)
{
    string document = "Prescribed 100mg ibuprofen, taken twice daily.";

    List<string> batchInput = new List<string>()
    {
        document
    };
    AnalyzeHealthcareEntitiesOperation healthOperation = await client.StartAnalyzeHealthcareEntitiesAsync(batchInput);
    await healthOperation.WaitForCompletionAsync();

    await foreach (AnalyzeHealthcareEntitiesResultCollection documentsInPage in healthOperation.Value)
    {
        Console.WriteLine($"Results of Azure Text Analytics \"Healthcare Async\" Model, version: \"{documentsInPage.ModelVersion}\"");
        Console.WriteLine("");

        foreach (AnalyzeHealthcareEntitiesResult entitiesInDoc in documentsInPage)
        {
            if (!entitiesInDoc.HasError)
            {
                foreach (var entity in entitiesInDoc.Entities)
                {
                    // view recognized healthcare 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($"  Found {entitiesInDoc.EntityRelations.Count} relations in the current document:");
                Console.WriteLine("");

                // view recognized healthcare relations
                foreach (HealthcareEntityRelation relations in entitiesInDoc.EntityRelations)
                {
                    Console.WriteLine($"    Relation: {relations.RelationType}");
                    Console.WriteLine($"    For this relation there are {relations.Roles.Count} roles");

                    // view relation roles
                    foreach (HealthcareEntityRelationRole role in relations.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("");
                }
            }
            else
            {
                Console.WriteLine("  Error!");
                Console.WriteLine($"  Document error code: {entitiesInDoc.Error.ErrorCode}.");
                Console.WriteLine($"  Message: {entitiesInDoc.Error.Message}");
            }
            Console.WriteLine("");
        }
    }
}

Nachdem Sie das Beispiel zu Ihrer Anwendung hinzugefügt haben, können Sie es mithilfe von await in der Methode main() aufrufen. Da der Analysevorgang asynchron ist, müssen Sie Ihre Main() Methode auf den Typ async Task aktualisieren.

static async Task Main(string[] args)
{
    var client = new TextAnalyticsClient(endpoint, credentials);
    await healthExample(client);
}
Results of Azure Text Analytics "Healthcare Async" Model, version: "2021-05-15"

  Entity: 100mg
  Category: Dosage
  Offset: 11
  Length: 5
  NormalizedText:
  Entity: ibuprofen
  Category: MedicationName
  Offset: 17
  Length: 9
  NormalizedText: ibuprofen
  Entity: twice daily
  Category: Frequency
  Offset: 34
  Length: 11
  NormalizedText:
  Found 2 relations in the current document:

    Relation: DosageOfMedication
    For this relation there are 2 roles
      Role Name: Dosage
      Associated Entity Text: 100mg
      Associated Entity Category: Dosage

      Role Name: Medication
      Associated Entity Text: ibuprofen
      Associated Entity Category: MedicationName


    Relation: FrequencyOfMedication
    For this relation there are 2 roles
      Role Name: Medication
      Associated Entity Text: ibuprofen
      Associated Entity Category: MedicationName

      Role Name: Frequency
      Associated Entity Text: twice daily
      Associated Entity Category: Frequency

Asynchrones Verwenden der API mit dem Analyze-Vorgang

Mithilfe des Analysevorgangs können Sie asynchrone Batchanforderungen für Folgendes ausführen: NER, Schlüsselbegriffserkennung, Stimmungsanalyse und Erkennung personenbezogener Informationen. Nachfolgend sehen Sie ein einfaches Beispiel für einen Vorgang. Ein komplexeres Beispiel können Sie auf GitHub finden.

Achtung

  • Wenn Sie den Analysevorgang verwenden möchten, muss es sich bei Ihrer Azure-Ressource um eine Ressource im Standard-Tarif (S) handeln.

Fügen Sie Ihrer C#-Datei die folgenden Verwendungsanweisungen hinzu, sofern noch nicht geschehen:

using System.Threading.Tasks;
using System.Collections.Generic;
using System.Linq;

Erstellen Sie eine neue Funktion namens AnalyzeOperationExample(), die den zuvor erstellten Client verwendet, und rufen Sie die zugehörige Funktion StartAnalyzeBatchActionsAsync() auf. Der zurückgegebene Vorgang enthält ein AnalyzeBatchActionsResult-Objekt. Da es sich um einen zeitintensiven Vorgang handelt, muss await in der operation.WaitForCompletionAsync()-Methode für den Wert aktualisiert werden. Sobald WaitForCompletionAsync() ausgeführt wurde, sollte die Sammlung in operation.Value aktualisiert sein. Im Falle eines Fehlers wird ein Fehler vom Typ RequestFailedException ausgelöst.

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

static async Task AnalyzeOperationExample(TextAnalyticsClient client)
{
    string inputText = "Microsoft was founded by Bill Gates and Paul Allen.";

    var batchDocuments = new List<string> { inputText };


    TextAnalyticsActions actions = new TextAnalyticsActions()
    {
        RecognizeEntitiesActions = new List<RecognizeEntitiesAction>() { new RecognizeEntitiesAction() },
        ExtractKeyPhrasesActions = new List<ExtractKeyPhrasesAction>() { new ExtractKeyPhrasesAction() },
        DisplayName = "Analyze Operation Quick Start Example"
    };

    AnalyzeActionsOperation operation = await client.StartAnalyzeActionsAsync(batchDocuments, actions);

    await operation.WaitForCompletionAsync();

    Console.WriteLine($"Status: {operation.Status}");
    Console.WriteLine($"Created On: {operation.CreatedOn}");
    Console.WriteLine($"Expires On: {operation.ExpiresOn}");
    Console.WriteLine($"Last modified: {operation.LastModified}");
    if (!string.IsNullOrEmpty(operation.DisplayName))
        Console.WriteLine($"Display name: {operation.DisplayName}");
    Console.WriteLine($"  Succeeded actions: {operation.ActionsSucceeded}");
    Console.WriteLine($"  Failed actions: {operation.ActionsFailed}");
    Console.WriteLine($"  In progress actions: {operation.ActionsInProgress}");

    await foreach (AnalyzeActionsResult documentsInPage in operation.Value)
    {
        RecognizeEntitiesResultCollection entitiesResult = documentsInPage.RecognizeEntitiesResults.FirstOrDefault().DocumentsResults;
        ExtractKeyPhrasesResultCollection keyPhrasesResults = documentsInPage.ExtractKeyPhrasesResults.FirstOrDefault().DocumentsResults;

        Console.WriteLine("Recognized Entities");

        foreach (RecognizeEntitiesResult result in entitiesResult)
        {
            Console.WriteLine($"  Recognized the following {result.Entities.Count} entities:");

            foreach (CategorizedEntity entity in result.Entities)
            {
                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("Key Phrases");
        
        foreach (ExtractKeyPhrasesResult documentResults in keyPhrasesResults)
        {
            Console.WriteLine($"  Recognized the following {documentResults.KeyPhrases.Count} Keyphrases:");

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

Nachdem Sie das Beispiel zu Ihrer Anwendung hinzugefügt haben, können Sie es mithilfe von await in der Methode main() aufrufen. Da der Analysevorgang asynchron ist, müssen Sie Ihre Main() Methode auf den Typ async Task aktualisieren.

static async Task Main(string[] args)
{
    var client = new TextAnalyticsClient(endpoint, credentials);
    await AnalyzeOperationExample(client);
}

Ausgabe

Status: succeeded
Created On: 3/10/2021 2:25:01 AM +00:00
Expires On: 3/11/2021 2:25:01 AM +00:00
Last modified: 3/10/2021 2:25:05 AM +00:00
Display name: Analyze Operation Quick Start Example
Total actions: 1
  Succeeded actions: 1
  Failed actions: 0
  In progress actions: 0
Recognized Entities
    Recognized the following 3 entities:
    Entity: Microsoft
    Category: Organization
    Offset: 0
    ConfidenceScore: 0.83
    SubCategory: 
    Entity: Bill Gates
    Category: Person
    Offset: 25
    ConfidenceScore: 0.85
    SubCategory: 
    Entity: Paul Allen
    Category: Person
    Offset: 40
    ConfidenceScore: 0.9
    SubCategory: 

Textzusammenfassung

Sie können die Textanalyse verwenden, um große Textblöcke zusammenzufassen.

Fügen Sie Ihrer C#-Datei die folgenden Verwendungsanweisungen hinzu, sofern noch nicht geschehen:

using System.Threading.Tasks;
using System.Collections.Generic;

Erstellen Sie eine neue Funktion mit dem Namen TextSummarizationExample(), die den Client als Argument akzeptiert. Daraus resultiert ein zeitintensiver Vorgang, aus dem Ergebnisse abgerufen werden.

static async Task TextSummarizationExample(TextAnalyticsClient client)
{
    string document = @"The extractive summarization feature in Text Analytics uses natural language processing techniques to locate key sentences in an unstructured text document. 
        These sentences collectively convey the main idea of the document. This feature is provided as an API for developers. 
        They can use it to build intelligent solutions based on the relevant information extracted to support various use cases. 
        In the public preview, extractive summarization supports several languages. It is based on pretrained multilingual transformer models, part of our quest for holistic representations. 
        It draws its strength from transfer learning across monolingual and harness the shared nature of languages to produce models of improved quality and efficiency." ;

    // Prepare analyze operation input. You can add multiple documents to this list and perform the same
    // operation to all of them.
    var batchInput = new List<string>
    {
        document
    };

    TextAnalyticsActions actions = new TextAnalyticsActions()
    {
        ExtractSummaryActions = new List<ExtractSummaryAction>() { new ExtractSummaryAction() }
    };

    // Start analysis process.
    AnalyzeActionsOperation operation = await client.StartAnalyzeActionsAsync(batchInput, actions);
    await operation.WaitForCompletionAsync();
    // View operation status.
    Console.WriteLine($"AnalyzeActions operation has completed");
    Console.WriteLine();

    Console.WriteLine($"Created On   : {operation.CreatedOn}");
    Console.WriteLine($"Expires On   : {operation.ExpiresOn}");
    Console.WriteLine($"Id           : {operation.Id}");
    Console.WriteLine($"Status       : {operation.Status}");

    Console.WriteLine();
    // View operation results.
    await foreach (AnalyzeActionsResult documentsInPage in operation.Value)
    {
        IReadOnlyCollection<ExtractSummaryActionResult> summaryResults = documentsInPage.ExtractSummaryResults;

        foreach (ExtractSummaryActionResult summaryActionResults in summaryResults)
        {
            if (summaryActionResults.HasError)
            {
                Console.WriteLine($"  Error!");
                Console.WriteLine($"  Action error code: {summaryActionResults.Error.ErrorCode}.");
                Console.WriteLine($"  Message: {summaryActionResults.Error.Message}");
                continue;
            }

            foreach (ExtractSummaryResult documentResults in summaryActionResults.DocumentsResults)
            {
                if (documentResults.HasError)
                {
                    Console.WriteLine($"  Error!");
                    Console.WriteLine($"  Document error code: {documentResults.Error.ErrorCode}.");
                    Console.WriteLine($"  Message: {documentResults.Error.Message}");
                    continue;
                }

                Console.WriteLine($"  Extracted the following {documentResults.Sentences.Count} sentence(s):");
                Console.WriteLine();

                foreach (SummarySentence sentence in documentResults.Sentences)
                {
                    Console.WriteLine($"  Sentence: {sentence.Text}");
                    Console.WriteLine();
                }
            }
        }
    }

}

Nachdem Sie das Beispiel zu Ihrer Anwendung hinzugefügt haben, können Sie es mithilfe von await in der Methode main() aufrufen. Da der Analysevorgang asynchron ist, müssen Sie Ihre Main() Methode auf den Typ async Task aktualisieren.

static async Task Main(string[] args)
{
    var client = new TextAnalyticsClient(endpoint, credentials);
    await TextSummarizationExample(client);
}

Ausgabe

AnalyzeActions operation has completed

Created On   : 8/17/2021 9:06:07 PM +00:00
Expires On   : 8/18/2021 9:06:07 PM +00:00
Id           : 70dc2e88-e930-483e-9d96-1ba5f0f27f18
Status       : succeeded

Extracted the following 3 sentence(s):

Sentence: The extractive summarization feature in Text Analytics uses natural language processing techniques to locate key sentences in an unstructured text document.
Sentence: This feature is provided as an API for developers.
Sentence: They can use it to build intelligent solutions based on the relevant information extracted to support various use cases.

Wichtig

  • Die neueste stabile Version der Textanalyse-API ist 3.1.
  • Im Code dieses Artikels werden der Einfachheit halber synchrone Methoden und ein ungeschützter Anmeldeinformationsspeicher verwendet. Für Produktionsszenarien wird aus Leistungs- und Skalierbarkeitsgründen die Verwendung der asynchronen Batchmethoden empfohlen. Informationen finden Sie in der Referenzdokumentation weiter unten.
  • Sie können auch die neueste Vorschauversion der Clientbibliothek für die extraktive Zusammenfassung verwenden. Sehen Sie sich die folgenden Beispiele auf GitHub an:

Voraussetzungen

  • Azure-Abonnement – Erstellen eines kostenlosen Kontos
  • Java Development Kit (JDK), Version 8 oder höher
  • Damit Sie den entsprechenden KI-Bedingungen zustimmen und eine Ressource erstellen können, muss Ihrem Azure-Konto die Rolle „Cognitive Services-Mitwirkender“ zugewiesen sein. Kontaktieren Sie Ihren Administrator, der Ihrem Konto diese Rolle zuweisen kann.
  • Sobald Sie über Ihr Azure-Abonnement verfügen, erstellen Sie eine Textanalyseressource im Azure-Portal, um Ihren Schlüssel und Endpunkt zu erhalten. Klicken Sie nach Abschluss der Bereitstellung auf Zu Ressource wechseln.
    • Sie benötigen den Schlüssel und den Endpunkt der von Ihnen erstellten Ressource, um Ihre Anwendung mit der Textanalyse-API zu verbinden. Der Schlüssel und der Endpunkt werden weiter unten in der Schnellstartanleitung in den Code eingefügt.
    • Sie können den kostenlosen Tarif (F0) verwenden, um den Dienst zu testen, und später für die Produktion auf einen kostenpflichtigen Tarif upgraden.
  • Sie benötigen eine Textanalyse-Ressource des Standard-Tarifs (S), um das Analyze-Feature nutzen zu können.

Einrichten

Hinzufügen der Clientbibliothek

Erstellen Sie ein Maven-Projekt in Ihrer bevorzugten IDE oder Entwicklungsumgebung. Fügen Sie anschließend der Datei pom.xml Ihres Projekts die folgende Abhängigkeit hinzu. Die Implementierungssyntax für andere Buildtools ist online verfügbar.

<dependencies>
     <dependency>
        <groupId>com.azure</groupId>
        <artifactId>azure-ai-textanalytics</artifactId>
        <version>5.2.0-beta.1</version>
    </dependency>
</dependencies>

Features in dieser Version der Textanalyse-API:

  • Stimmungsanalyse
  • Opinion Mining
  • Spracherkennung
  • Entitätserkennung
  • Entitätsverknüpfung
  • Erkennung personenbezogener Informationen
  • Schlüsselwortextraktion
  • Asynchrone Methoden
  • Textanalyse für Gesundheit
  • Textzusammenfassung

Erstellen Sie eine Java-Datei mit dem Namen TextAnalyticsSamples.java. Öffnen Sie die Datei, und fügen Sie die folgenden import-Anweisungen hinzu:

import com.azure.ai.textanalytics.TextAnalyticsAsyncClient;
import com.azure.core.credential.AzureKeyCredential;
import com.azure.ai.textanalytics.models.*;
import com.azure.ai.textanalytics.TextAnalyticsClientBuilder;
import com.azure.ai.textanalytics.TextAnalyticsClient;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

import java.util.Arrays;
import com.azure.core.util.Context;
import com.azure.core.util.polling.SyncPoller;

import com.azure.core.util.polling.LongRunningOperationStatus;
import com.azure.ai.textanalytics.util.*;
import com.azure.core.http.rest.PagedResponse;

Fügen Sie in der Java-Datei wie weiter unten gezeigt eine neue Klasse sowie den Schlüssel und den Endpunkt Ihrer Azure-Ressource hinzu.

Wichtig

Öffnen Sie das Azure-Portal. Wenn die im Abschnitt Voraussetzungen erstellte Textanalyseressource erfolgreich bereitgestellt wurde, klicken Sie unter Nächste Schritte auf die Schaltfläche Zu Ressource wechseln. Schlüssel und Endpunkt finden Sie auf der Seite mit dem Schlüssel und dem Endpunkt der Ressource unter Ressourcenverwaltung.

Denken Sie daran, den Schlüssel aus Ihrem Code zu entfernen, wenn Sie fertig sind, und ihn niemals zu veröffentlichen. In der Produktionsumgebung sollten Sie eine sichere Methode zum Speichern Ihrer Anmeldeinformationen sowie zum Zugriff darauf verwenden. Beispielsweise Azure Key Vault.

public class TextAnalyticsSamples {
    private static String KEY = "<replace-with-your-text-analytics-key-here>";
    private static String ENDPOINT = "<replace-with-your-text-analytics-endpoint-here>";
}

Fügen Sie der Klasse die folgende main-Methode hinzu. Die hier aufgerufenen Methoden definieren Sie später.

public static void main(String[] args) {
    //You will create these methods later in the quickstart.
    TextAnalyticsClient client = authenticateClient(KEY, ENDPOINT);
    sentimentAnalysisExample(client);
    sentimentAnalysisWithOpinionMiningExample(client);
    detectLanguageExample(client);
    recognizeEntitiesExample(client);
    recognizePiiEntitiesExample(client);
    recognizeLinkedEntitiesExample(client);
    extractKeyPhrasesExample(client);
    analyzeOperationExample(client);
}

Objektmodell

Der Textanalyse-Client ist ein Objekt vom Typ TextAnalyticsClient, das sich mit Ihrem Schlüssel bei Azure authentifiziert und Funktionen bereitstellt, um Text als einzelne Zeichenfolgen oder als Batch zu akzeptieren. Sie können Text synchron oder asynchron an die API senden. Das Antwortobjekt enthält die Analyseinformationen für die einzelnen gesendeten Dokumente.

Wenn Sie Text Analytics verwenden, dürfen die Dokumente in Ihrer Abfrage die folgenden Zeichengrenzwerte nicht überschreiten. Weitere Informationen finden Sie im Artikel zu den Datengrenzwerten.

  • Synchrone Vorgänge und Text Analytics für Integritätsvorgänge: 5.120 Zeichen pro Dokument.
  • Asynchrone Vorgänge (Analysieren): 125.000 Zeichen pro Dokument.

Authentifizieren des Clients

Erstellen Sie eine Methode, um das Objekt TextAnalyticsClientmit dem Schlüssel und dem Endpunkt für Ihre Textanalyseressource zu instanziieren. Dieses Beispiel ist für die Versionen 3.0 und 3.1 der API gleich.

static TextAnalyticsClient authenticateClient(String key, String endpoint) {
    return new TextAnalyticsClientBuilder()
        .credential(new AzureKeyCredential(key))
        .endpoint(endpoint)
        .buildClient();
}

Rufen Sie in der main()-Methode des Programms die Authentifizierungsmethode auf, um den Client zu instanziieren.

Stimmungsanalyse

Erstellen Sie eine neue Funktion namens sentimentAnalysisExample(), die den zuvor erstellten Client verwendet, und rufen Sie die zugehörige Funktion analyzeSentiment() auf. Das zurückgegebene Objekt AnalyzeSentimentResult enthält documentSentiment und sentenceSentiments (sofern erfolgreich). Andernfalls enthält es eine Fehlermeldung (errorMessage).

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

static void sentimentAnalysisExample(TextAnalyticsClient client)
{
    // The text that need be analyzed.
    String text = "I had the best day of my life. I wish you were there with me.";

    DocumentSentiment documentSentiment = client.analyzeSentiment(text);
    System.out.printf(
        "Recognized document sentiment: %s, positive score: %s, neutral score: %s, negative score: %s.%n",
        documentSentiment.getSentiment(),
        documentSentiment.getConfidenceScores().getPositive(),
        documentSentiment.getConfidenceScores().getNeutral(),
        documentSentiment.getConfidenceScores().getNegative());

    for (SentenceSentiment sentenceSentiment : documentSentiment.getSentences()) {
        System.out.printf(
            "Recognized sentence sentiment: %s, positive score: %s, neutral score: %s, negative score: %s.%n",
            sentenceSentiment.getSentiment(),
            sentenceSentiment.getConfidenceScores().getPositive(),
            sentenceSentiment.getConfidenceScores().getNeutral(),
            sentenceSentiment.getConfidenceScores().getNegative());
        }
    }
}

Output

Recognized document sentiment: positive, positive score: 1.0, neutral score: 0.0, negative score: 0.0.
Recognized sentence sentiment: positive, positive score: 1.0, neutral score: 0.0, negative score: 0.0.
Recognized sentence sentiment: neutral, positive score: 0.21, neutral score: 0.77, negative score: 0.02.

Opinion Mining

Zum Durchführen von Stimmungsanalyse mit Opinion Mining erstellen Sie eine neue Funktion mit dem Namen sentimentAnalysisWithOpinionMiningExample(), die den von Ihnen zuvor erstellten Client akzeptiert, und rufen seine analyzeSentiment()-Funktion mit dem Einstellungsoptionsobjekt AnalyzeSentimentOptions auf. Das zurückgegebene Objekt AnalyzeSentimentResult enthält documentSentiment und sentenceSentiments (sofern erfolgreich). Andernfalls enthält es eine Fehlermeldung (errorMessage).

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

static void sentimentAnalysisWithOpinionMiningExample(TextAnalyticsClient client)
{
    // The document that needs be analyzed.
    String document = "Bad atmosphere. Not close to plenty of restaurants, hotels, and transit! Staff are not friendly and helpful.";

    System.out.printf("Document = %s%n", document);

    AnalyzeSentimentOptions options = new AnalyzeSentimentOptions().setIncludeOpinionMining(true);
    final DocumentSentiment documentSentiment = client.analyzeSentiment(document, "en", options);
    SentimentConfidenceScores scores = documentSentiment.getConfidenceScores();
    System.out.printf(
            "Recognized document sentiment: %s, positive score: %f, neutral score: %f, negative score: %f.%n",
            documentSentiment.getSentiment(), scores.getPositive(), scores.getNeutral(), scores.getNegative());


    documentSentiment.getSentences().forEach(sentenceSentiment -> {
        SentimentConfidenceScores sentenceScores = sentenceSentiment.getConfidenceScores();
        System.out.printf("\tSentence sentiment: %s, positive score: %f, neutral score: %f, negative score: %f.%n",
                sentenceSentiment.getSentiment(), sentenceScores.getPositive(), sentenceScores.getNeutral(), sentenceScores.getNegative());
        sentenceSentiment.getOpinions().forEach(opinion -> {
            TargetSentiment targetSentiment = opinion.getTarget();
            System.out.printf("\t\tTarget sentiment: %s, target text: %s%n", targetSentiment.getSentiment(),
                    targetSentiment.getText());
            for (AssessmentSentiment assessmentSentiment : opinion.getAssessments()) {
                System.out.printf("\t\t\t'%s' assessment sentiment because of \"%s\". Is the assessment negated: %s.%n",
                        assessmentSentiment.getSentiment(), assessmentSentiment.getText(), assessmentSentiment.isNegated());
            }
        });
    });
}

Output

Document = Bad atmosphere. Not close to plenty of restaurants, hotels, and transit! Staff are not friendly and helpful.
Recognized document sentiment: negative, positive score: 0.010000, neutral score: 0.140000, negative score: 0.850000.
    Sentence sentiment: negative, positive score: 0.000000, neutral score: 0.000000, negative score: 1.000000.
        Target sentiment: negative, target text: atmosphere
            'negative' assessment sentiment because of "bad". Is the assessment negated: false.
    Sentence sentiment: negative, positive score: 0.020000, neutral score: 0.440000, negative score: 0.540000.
    Sentence sentiment: negative, positive score: 0.000000, neutral score: 0.000000, negative score: 1.000000.
        Target sentiment: negative, target text: Staff
            'negative' assessment sentiment because of "friendly". Is the assessment negated: true.
            'negative' assessment sentiment because of "helpful". Is the assessment negated: true.

Spracherkennung

Erstellen Sie eine neue Funktion namens detectLanguageExample(), die den zuvor erstellten Client verwendet, und rufen Sie die zugehörige Funktion detectLanguage() auf. Das zurückgegebene Objekt DetectLanguageResult enthält eine primäre erkannte Sprache und eine Liste mit anderen erkannten Sprachen (sofern erfolgreich). Andernfalls enthält es eine Fehlermeldung (errorMessage). Dieses Beispiel ist für die Versionen 3.0 und 3.1 der API gleich.

Tipp

In einigen Fällen ist es unter Umständen schwierig, die Sprachen basierend auf den Eingaben eindeutig zu bestimmen. Mithilfe des Parameters countryHint können Sie einen zweistelligen Ländercode angeben. Die API verwendet standardmäßig „US“ als Wert für „countryHint“. Wenn Sie dieses Verhalten entfernen möchten, können Sie diesen Parameter zurücksetzen, indem Sie seinen Wert auf eine leere Zeichenfolge (countryHint = "") festlegen. Wenn Sie einen anderen Standardwert festlegen möchten, legen Sie die Eigenschaft TextAnalyticsClientOptions.DefaultCountryHint fest, und übergeben Sie sie während der Initialisierung des Clients.

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

static void detectLanguageExample(TextAnalyticsClient client)
{
    // The text that need be analyzed.
    String text = "Ce document est rédigé en Français.";

    DetectedLanguage detectedLanguage = client.detectLanguage(text);
    System.out.printf("Detected primary language: %s, ISO 6391 name: %s, score: %.2f.%n",
        detectedLanguage.getName(),
        detectedLanguage.getIso6391Name(),
        detectedLanguage.getConfidenceScore());
}

Output

Detected primary language: French, ISO 6391 name: fr, score: 1.00.

Erkennung benannter Entitäten (NER)

Erstellen Sie eine neue Funktion namens recognizeEntitiesExample(), die den zuvor erstellten Client verwendet, und rufen Sie die zugehörige Funktion recognizeEntities() auf. Das zurückgegebene Objekt CategorizedEntityCollection enthält eine Liste mit Elementen vom Typ CategorizedEntity (sofern erfolgreich). Andernfalls enthält es eine Fehlermeldung (errorMessage).

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

static void recognizeEntitiesExample(TextAnalyticsClient client)
{
    // The text that need be analyzed.
    String text = "I had a wonderful trip to Seattle last week.";

    for (CategorizedEntity entity : client.recognizeEntities(text)) {
        System.out.printf(
            "Recognized entity: %s, entity category: %s, entity sub-category: %s, score: %s, offset: %s, length: %s.%n",
            entity.getText(),
            entity.getCategory(),
            entity.getSubcategory(),
            entity.getConfidenceScore(),
            entity.getOffset(),
            entity.getLength());
    }
}

Output

Recognized entity: trip, entity category: Event, entity sub-category: null, score: 0.61, offset: 8, length: 4.
Recognized entity: Seattle, entity category: Location, entity sub-category: GPE, score: 0.82, offset: 16, length: 7.
Recognized entity: last week, entity category: DateTime, entity sub-category: DateRange, score: 0.8, offset: 24, length: 9.

Erkennung von personenbezogenen Informationen (PII)

Erstellen Sie eine neue Funktion namens recognizePiiEntitiesExample(), die den zuvor erstellten Client verwendet, und rufen Sie die zugehörige Funktion recognizePiiEntities() auf. Das zurückgegebene Objekt PiiEntityCollection enthält eine Liste mit Elementen vom Typ PiiEntity (sofern erfolgreich). Andernfalls enthält es eine Fehlermeldung (errorMessage). Es enthält außerdem den bearbeiteten Text, der aus dem Eingabetext besteht, in dem alle identifizierbaren Entitäten durch ***** ersetzt wurden.

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

static void recognizePiiEntitiesExample(TextAnalyticsClient client)
{
    // The text that need be analyzed.
    String document = "My SSN is 859-98-0987";
    PiiEntityCollection piiEntityCollection = client.recognizePiiEntities(document);
    System.out.printf("Redacted Text: %s%n", piiEntityCollection.getRedactedText());
    piiEntityCollection.forEach(entity -> System.out.printf(
        "Recognized Personally Identifiable Information entity: %s, entity category: %s, entity subcategory: %s,"
            + " confidence score: %f.%n",
        entity.getText(), entity.getCategory(), entity.getSubcategory(), entity.getConfidenceScore()));
}

Output

Redacted Text: My SSN is ***********
Recognized Personally Identifiable Information entity: 859-98-0987, entity category: U.S. Social Security Number (SSN), entity subcategory: null, confidence score: 0.650000.

Entitätsverknüpfung

Erstellen Sie eine neue Funktion namens recognizeLinkedEntitiesExample(), die den zuvor erstellten Client verwendet, und rufen Sie die zugehörige Funktion recognizeLinkedEntities() auf. Das zurückgegebene Objekt LinkedEntityCollection enthält eine Liste mit Elementen vom Typ LinkedEntity (sofern erfolgreich). Andernfalls enthält es eine Fehlermeldung (errorMessage). Da verknüpfte Entitäten eindeutig identifiziert werden, werden Vorkommen der gleichen Entität unter einem Objekt vom Typ LinkedEntity als Liste von Objekten des Typs LinkedEntityMatch gruppiert.

static void recognizeLinkedEntitiesExample(TextAnalyticsClient client)
{
    // The text that need be analyzed.
    String text = "Microsoft was founded by Bill Gates and Paul Allen on April 4, 1975, " +
        "to develop and sell BASIC interpreters for the Altair 8800. " +
        "During his career at Microsoft, Gates held the positions of chairman, " +
        "chief executive officer, president and chief software architect, " +
        "while also being the largest individual shareholder until May 2014.";

    System.out.printf("Linked Entities:%n");
    for (LinkedEntity linkedEntity : client.recognizeLinkedEntities(text)) {
        System.out.printf("Name: %s, ID: %s, URL: %s, Data Source: %s.%n",
            linkedEntity.getName(),
            linkedEntity.getDataSourceEntityId(),
            linkedEntity.getUrl(),
            linkedEntity.getDataSource());
        System.out.printf("Matches:%n");
        for (LinkedEntityMatch linkedEntityMatch : linkedEntity.getMatches()) {
            System.out.printf("Text: %s, Score: %.2f, Offset: %s, Length: %s%n",
            linkedEntityMatch.getText(),
            linkedEntityMatch.getConfidenceScore(),
            linkedEntityMatch.getOffset(),
            linkedEntityMatch.getLength());
        }
    }
}

Output

Linked Entities:
Name: Microsoft, ID: Microsoft, URL: https://en.wikipedia.org/wiki/Microsoft, Data Source: Wikipedia.
Matches:
Text: Microsoft, Score: 0.55, Offset: 9, Length: 0
Text: Microsoft, Score: 0.55, Offset: 9, Length: 150
Name: Bill Gates, ID: Bill Gates, URL: https://en.wikipedia.org/wiki/Bill_Gates, Data Source: Wikipedia.
Matches:
Text: Bill Gates, Score: 0.63, Offset: 10, Length: 25
Text: Gates, Score: 0.63, Offset: 5, Length: 161
Name: Paul Allen, ID: Paul Allen, URL: https://en.wikipedia.org/wiki/Paul_Allen, Data Source: Wikipedia.
Matches:
Text: Paul Allen, Score: 0.60, Offset: 10, Length: 40
Name: April 4, ID: April 4, URL: https://en.wikipedia.org/wiki/April_4, Data Source: Wikipedia.
Matches:
Text: April 4, Score: 0.32, Offset: 7, Length: 54
Name: BASIC, ID: BASIC, URL: https://en.wikipedia.org/wiki/BASIC, Data Source: Wikipedia.
Matches:
Text: BASIC, Score: 0.33, Offset: 5, Length: 89
Name: Altair 8800, ID: Altair 8800, URL: https://en.wikipedia.org/wiki/Altair_8800, Data Source: Wikipedia.
Matches:
Text: Altair 8800, Score: 0.88, Offset: 11, Length: 116

Schlüsselwortextraktion

Erstellen Sie eine neue Funktion namens extractKeyPhrasesExample(), die den zuvor erstellten Client verwendet, und rufen Sie die zugehörige Funktion extractKeyPhrases() auf. Das zurückgegebene Objekt ExtractKeyPhraseResult enthält eine Liste mit Schlüsselbegriffen (sofern erfolgreich). Andernfalls enthält es eine Fehlermeldung (errorMessage). Dieses Beispiel ist für die Versionen 3.0 und 3.1 der API gleich.

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

static void extractKeyPhrasesExample(TextAnalyticsClient client)
{
    // The text that need be analyzed.
    String text = "My cat might need to see a veterinarian.";

    System.out.printf("Recognized phrases: %n");
    for (String keyPhrase : client.extractKeyPhrases(text)) {
        System.out.printf("%s%n", keyPhrase);
    }
}

Output

Recognized phrases: 
cat
veterinarian

Extrahieren von Integritätsentitäten

Achtung

  • Wenn Sie den Integritätsvorgang verwenden möchten, muss es sich bei Ihrer Azure-Ressource um eine Ressource im Standard-Tarif (S) handeln.

Sie können die Textanalyse verwenden, um eine asynchrone Anforderung zum Extrahieren von Integritätsentitäten aus dem Text durchzuführen. Nachfolgend sehen Sie ein einfaches Beispiel für diesen Vorgang. Ein komplexeres Beispiel können Sie auf GitHub finden.

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

static void healthExample(TextAnalyticsClient client){
    List<TextDocumentInput> documents = Arrays.asList(
            new TextDocumentInput("0",
                    "Prescribed 100mg ibuprofen, taken twice daily."));

    AnalyzeHealthcareEntitiesOptions options = new AnalyzeHealthcareEntitiesOptions().setIncludeStatistics(true);

    SyncPoller<AnalyzeHealthcareEntitiesOperationDetail, AnalyzeHealthcareEntitiesPagedIterable>
            syncPoller = client.beginAnalyzeHealthcareEntities(documents, options, Context.NONE);

    System.out.printf("Poller status: %s.%n", syncPoller.poll().getStatus());
    syncPoller.waitForCompletion();

    // Task operation statistics
    AnalyzeHealthcareEntitiesOperationDetail operationResult = syncPoller.poll().getValue();
    System.out.printf("Operation created time: %s, expiration time: %s.%n",
            operationResult.getCreatedAt(), operationResult.getExpiresAt());
    System.out.printf("Poller status: %s.%n", syncPoller.poll().getStatus());

    for (AnalyzeHealthcareEntitiesResultCollection resultCollection : syncPoller.getFinalResult()) {
        // Model version
        System.out.printf(
                "Results of Azure Text Analytics \"Analyze Healthcare Entities\" Model, version: %s%n",
                resultCollection.getModelVersion());

        for (AnalyzeHealthcareEntitiesResult healthcareEntitiesResult : resultCollection) {
            System.out.println("Document ID = " + healthcareEntitiesResult.getId());
            System.out.println("Document entities: ");
            // Recognized healthcare entities
            for (HealthcareEntity entity : healthcareEntitiesResult.getEntities()) {
                System.out.printf(
                        "\tText: %s, normalized name: %s, category: %s, subcategory: %s, confidence score: %f.%n",
                        entity.getText(), entity.getNormalizedText(), entity.getCategory(),
                        entity.getSubcategory(), entity.getConfidenceScore());
            }
            // Recognized healthcare entity relation groups
            for (HealthcareEntityRelation entityRelation : healthcareEntitiesResult.getEntityRelations()) {
                System.out.printf("Relation type: %s.%n", entityRelation.getRelationType());
                for (HealthcareEntityRelationRole role : entityRelation.getRoles()) {
                    HealthcareEntity entity = role.getEntity();
                    System.out.printf("\tEntity text: %s, category: %s, role: %s.%n",
                            entity.getText(), entity.getCategory(), role.getName());
                }
            }
        }
    }
}

Rufen Sie in Ihrer main()-Methode das obige Codebeispiel auf.

public static void main(String[] args) {
    TextAnalyticsClient client = authenticateClient(KEY, ENDPOINT);
    healthExample(client);
}

output

Poller status: IN_PROGRESS.
Operation created time: 2021-07-20T19:45:50Z, expiration time: 2021-07-21T19:45:50Z.
Poller status: SUCCESSFULLY_COMPLETED.
Results of Azure Text Analytics "Analyze Healthcare Entities" Model, version: 2021-05-15
Document ID = 0
Document entities: 
    Text: 100mg, normalized name: null, category: Dosage, subcategory: null, confidence score: 1.000000.
    Text: ibuprofen, normalized name: ibuprofen, category: MedicationName, subcategory: null, confidence score: 1.000000.
    Text: twice daily, normalized name: null, category: Frequency, subcategory: null, confidence score: 1.000000.
Relation type: DosageOfMedication.
    Entity text: 100mg, category: Dosage, role: Dosage.
    Entity text: ibuprofen, category: MedicationName, role: Medication.
Relation type: FrequencyOfMedication.
    Entity text: ibuprofen, category: MedicationName, role: Medication.
    Entity text: twice daily, category: Frequency, role: Frequency.

Asynchrones Verwenden der API mit dem Analyze-Vorgang

Mithilfe des Analysevorgangs können Sie asynchrone Batchanforderungen für Folgendes ausführen: NER, Schlüsselbegriffserkennung, Stimmungsanalyse und Erkennung personenbezogener Informationen. Nachfolgend sehen Sie ein einfaches Beispiel für einen Vorgang. Ein komplexeres Beispiel können Sie auf GitHub finden.

Achtung

  • Wenn Sie den Analysevorgang verwenden möchten, muss es sich bei Ihrer Azure-Ressource um eine Ressource im Standard-Tarif (S) handeln.

Erstellen Sie die neue Funktion analyzeBatchActionsExample(), die die Funktion beginAnalyzeBatchActions() aufruft. Daraus resultiert ein zeitintensiver Vorgang, aus dem Ergebnisse abgerufen werden.

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

static void analyzeActionsExample(TextAnalyticsClient client){
    List<TextDocumentInput> documents = new ArrayList<>();
    documents.add(new TextDocumentInput("0", "Microsoft was founded by Bill Gates and Paul Allen."));


    SyncPoller<AnalyzeActionsOperationDetail, AnalyzeActionsResultPagedIterable> syncPoller =
            client.beginAnalyzeActions(documents,
                    new TextAnalyticsActions().setDisplayName("Example analyze task")
                            .setRecognizeEntitiesActions(new RecognizeEntitiesAction())
                            .setExtractKeyPhrasesActions(
                                    new ExtractKeyPhrasesAction().setModelVersion("latest")),
                    new AnalyzeActionsOptions().setIncludeStatistics(false),
                    Context.NONE);

    // Task operation statistics details
    while (syncPoller.poll().getStatus() == LongRunningOperationStatus.IN_PROGRESS) {
        final AnalyzeActionsOperationDetail operationDetail = syncPoller.poll().getValue();
        System.out.printf("Action display name: %s, Successfully completed actions: %d, in-process actions: %d,"
                        + " failed actions: %d, total actions: %d%n",
                operationDetail.getDisplayName(), operationDetail.getSucceededCount(),
                operationDetail.getInProgressCount(), operationDetail.getFailedCount(),
                operationDetail.getTotalCount());
    }

    syncPoller.waitForCompletion();

    Iterable<PagedResponse<AnalyzeActionsResult>> pagedResults = syncPoller.getFinalResult().iterableByPage();
    for (PagedResponse<AnalyzeActionsResult> perPage : pagedResults) {
        System.out.printf("Response code: %d, Continuation Token: %s.%n", perPage.getStatusCode(),
                perPage.getContinuationToken());
        for (AnalyzeActionsResult actionsResult : perPage.getElements()) {
            System.out.println("Entities recognition action results:");
            for (RecognizeEntitiesActionResult actionResult : actionsResult.getRecognizeEntitiesResults()) {
                if (!actionResult.isError()) {
                    for (RecognizeEntitiesResult documentResult : actionResult.getDocumentsResults()) {
                        if (!documentResult.isError()) {
                            for (CategorizedEntity entity : documentResult.getEntities()) {
                                System.out.printf(
                                        "\tText: %s, category: %s, confidence score: %f.%n",
                                        entity.getText(), entity.getCategory(), entity.getConfidenceScore());
                            }
                        } else {
                            System.out.printf("\tCannot recognize entities. Error: %s%n",
                                    documentResult.getError().getMessage());
                        }
                    }
                } else {
                    System.out.printf("\tCannot execute Entities Recognition action. Error: %s%n",
                            actionResult.getError().getMessage());
                }
            }

            System.out.println("Key phrases extraction action results:");
            for (ExtractKeyPhrasesActionResult actionResult : actionsResult.getExtractKeyPhrasesResults()) {
                if (!actionResult.isError()) {
                    for (ExtractKeyPhraseResult documentResult : actionResult.getDocumentsResults()) {
                        if (!documentResult.isError()) {
                            System.out.println("\tExtracted phrases:");
                            for (String keyPhrases : documentResult.getKeyPhrases()) {
                                System.out.printf("\t\t%s.%n", keyPhrases);
                            }
                        } else {
                            System.out.printf("\tCannot extract key phrases. Error: %s%n",
                                    documentResult.getError().getMessage());
                        }
                    }
                } else {
                    System.out.printf("\tCannot execute Key Phrases Extraction action. Error: %s%n",
                            actionResult.getError().getMessage());
                }
            }
        }
    }
}

Nachdem Sie das Beispiel zu Ihrer Anwendung hinzugefügt haben, können Sie es in der Methode main() aufrufen.

analyzeBatchActionsExample(client);

Ausgabe

Action display name: Example analyze task, Successfully completed actions: 1, in-process actions: 1, failed actions: 0, total actions: 2
Response code: 200, Continuation Token: null.
Entities recognition action results:
    Text: Microsoft, category: Organization, confidence score: 1.000000.
    Text: Bill Gates, category: Person, confidence score: 1.000000.
    Text: Paul Allen, category: Person, confidence score: 1.000000.
Key phrases extraction action results:
    Extracted phrases:
        Bill Gates.
        Paul Allen.
        Microsoft.

Sie können den Analysevorgang auch verwenden, um NER, Schlüsselbegriffserkennung, Stimmungsanalyse und die Erkennung personenbezogener Informationen durchzuführen. Das Analyze-Beispiel finden Sie auf GitHub.

Textzusammenfassung

Sie können die Textanalyse verwenden, um große Textblöcke zusammenzufassen. Die Methode ist asynchron und gibt die obersten Sätze zurück, wenn der zeitintensive Vorgang abgeschlossen ist.

static void summarizationExample(TextAnalyticsClient client) {
    List<String> documents = new ArrayList<>();
    documents.add(
            "The extractive summarization feature in Text Analytics uses natural language processing techniques "
            + "to locate key sentences in an unstructured text document. "
            + "These sentences collectively convey the main idea of the document. This feature is provided as an API for developers. "
            + "They can use it to build intelligent solutions based on the relevant information extracted to support various use cases. "
            + "In the public preview, extractive summarization supports several languages. "
            + "It is based on pretrained multilingual transformer models, part of our quest for holistic representations. "
            + "It draws its strength from transfer learning across monolingual and harness the shared nature of languages "
            + "to produce models of improved quality and efficiency.");

    SyncPoller<AnalyzeActionsOperationDetail, AnalyzeActionsResultPagedIterable> syncPoller =
            client.beginAnalyzeActions(documents,
                    new TextAnalyticsActions().setDisplayName("{tasks_display_name}")
                            .setExtractSummaryActions(
                                    new ExtractSummaryAction()),
                    "en",
                    new AnalyzeActionsOptions());

    syncPoller.waitForCompletion();

    syncPoller.getFinalResult().forEach(actionsResult -> {
        System.out.println("Extractive Summarization action results:");
        for (ExtractSummaryActionResult actionResult : actionsResult.getExtractSummaryResults()) {
            if (!actionResult.isError()) {
                for (ExtractSummaryResult documentResult : actionResult.getDocumentsResults()) {
                    if (!documentResult.isError()) {
                        System.out.println("\tExtracted summary sentences:");
                        for (SummarySentence summarySentence : documentResult.getSentences()) {
                            System.out.printf(
                                    "\t\t Sentence text: %s, length: %d, offset: %d, rank score: %f.%n",
                                    summarySentence.getText(), summarySentence.getLength(),
                                    summarySentence.getOffset(), summarySentence.getRankScore());
                        }
                    } else {
                        System.out.printf("\tCannot extract summary sentences. Error: %s%n",
                                documentResult.getError().getMessage());
                    }
                }
            } else {
                System.out.printf("\tCannot execute Extractive Summarization action. Error: %s%n",
                        actionResult.getError().getMessage());
            }
        }
    });
}

Nachdem Sie das Beispiel zu Ihrer Anwendung hinzugefügt haben, können Sie es in der Methode main() aufrufen.

summarizationExample(client);

Wichtig

  • Die neueste stabile Version der Textanalyse-API ist 3.1.
    • Befolgen Sie nur die Anweisungen für die von Ihnen verwendete Version.
  • Im Code dieses Artikels werden der Einfachheit halber synchrone Methoden und ein ungeschützter Anmeldeinformationsspeicher verwendet. Für Produktionsszenarien wird aus Leistungs- und Skalierbarkeitsgründen die Verwendung der asynchronen Batchmethoden empfohlen. Informationen finden Sie in der Referenzdokumentation weiter unten.
  • Diese Version der Textanalyse-Clientbibliothek können Sie auch in Ihrem Browser ausführen.

Voraussetzungen

  • Azure-Abonnement – Erstellen eines kostenlosen Kontos
  • Die aktuelle Version von Node.js.
  • Damit Sie den entsprechenden KI-Bedingungen zustimmen und eine Ressource erstellen können, muss Ihrem Azure-Konto die Rolle „Cognitive Services-Mitwirkender“ zugewiesen sein. Kontaktieren Sie Ihren Administrator, der Ihrem Konto diese Rolle zuweisen kann.
  • Sobald Sie über Ihr Azure-Abonnement verfügen, erstellen Sie eine Textanalyseressource im Azure-Portal, um Ihren Schlüssel und Endpunkt zu erhalten. Klicken Sie nach Abschluss der Bereitstellung auf Zu Ressource wechseln.
    • Sie benötigen den Schlüssel und den Endpunkt der von Ihnen erstellten Ressource, um Ihre Anwendung mit der Textanalyse-API zu verbinden. Der Schlüssel und der Endpunkt werden weiter unten in der Schnellstartanleitung in den Code eingefügt.
    • Sie können den kostenlosen Tarif (F0) verwenden, um den Dienst zu testen, und später für die Produktion auf einen kostenpflichtigen Tarif upgraden.
  • Sie benötigen eine Textanalyse-Ressource des Standard-Tarifs (S), um das Analyze-Feature nutzen zu können.

Einrichten

Erstellen einer neuen Node.js-Anwendung

Erstellen Sie in einem Konsolenfenster (etwa cmd, PowerShell oder Bash) ein neues Verzeichnis für Ihre App, und rufen Sie es auf.

mkdir myapp 

cd myapp

Führen Sie den Befehl npm init aus, um eine Knotenanwendung mit der Datei package.json zu erstellen.

npm init

Installieren der Clientbibliothek

Installieren Sie das NPM-Paket @azure/ai-text-analytics:

npm install @azure/ai-text-analytics@5.2.0-beta.1

Features in dieser Version der Textanalyse-API:

  • Stimmungsanalyse
  • Opinion Mining
  • Spracherkennung
  • Entitätserkennung
  • Entitätsverknüpfung
  • Erkennung personenbezogener Informationen
  • Schlüsselwortextraktion
  • Asynchrone Methoden
  • Textanalyse für Gesundheit
  • Textzusammenfassung

Die Datei package.json Ihrer App wird mit den Abhängigkeiten aktualisiert. Erstellen Sie eine Datei namens index.js, und fügen Sie Folgendes hinzu:

"use strict";

const { TextAnalyticsClient, AzureKeyCredential } = require("@azure/ai-text-analytics");

Erstellen Sie Variablen für den Azure-Endpunkt und -Schlüssel Ihrer Ressource.

Wichtig

Öffnen Sie das Azure-Portal. Wenn die im Abschnitt Voraussetzungen erstellte Textanalyseressource erfolgreich bereitgestellt wurde, klicken Sie unter Nächste Schritte auf die Schaltfläche Zu Ressource wechseln. Schlüssel und Endpunkt finden Sie auf der Seite mit dem Schlüssel und dem Endpunkt der Ressource unter Ressourcenverwaltung.

Denken Sie daran, den Schlüssel aus Ihrem Code zu entfernen, wenn Sie fertig sind, und ihn niemals zu veröffentlichen. In der Produktionsumgebung sollten Sie eine sichere Methode zum Speichern Ihrer Anmeldeinformationen sowie zum Zugriff darauf verwenden. Beispielsweise Azure Key Vault.

const key = '<paste-your-text-analytics-key-here>';
const endpoint = '<paste-your-text-analytics-endpoint-here>';

Objektmodell

Der Textanalyseclient ist ein Objekt vom Typ TextAnalyticsClient, das sich bei Azure mit Ihrem Schlüssel authentifiziert. Der Client verfügt über verschiedene Methoden zum Analysieren von Text als einzelne Zeichenfolge oder als Batch.

Text wird als documents-Liste an die API gesendet. Hierbei handelt es sich um dictionary-Objekte, die je nach verwendeter Methode eine Kombination aus den Attributen id, text und language enthalten. Das text-Attribut speichert den zu analysierenden Text in der Ausgangssprache (language), und id kann ein beliebiger Wert sein.

Das Antwortobjekt ist eine Liste mit den Analyseinformationen für jedes Dokument.

Wenn Sie Text Analytics verwenden, dürfen die Dokumente in Ihrer Abfrage die folgenden Zeichengrenzwerte nicht überschreiten. Weitere Informationen finden Sie im Artikel zu den Datengrenzwerten.

  • Synchrone Vorgänge und Text Analytics für Integritätsvorgänge: 5.120 Zeichen pro Dokument.
  • Asynchrone Vorgänge (Analysieren): 125.000 Zeichen pro Dokument.

Authentifizieren des Clients

Erstellen Sie ein neues Objekt vom Typ TextAnalyticsClient mit Ihrem Schlüssel und Ihrem Endpunkt als Parameter.

const textAnalyticsClient = new TextAnalyticsClient(endpoint,  new AzureKeyCredential(key));

Stimmungsanalyse

Erstellen Sie ein Zeichenfolgenarray, das das zu analysierende Dokument enthält. Rufen Sie die Methode analyzeSentiment() des Clients auf, und rufen Sie das zurückgegebene Objekt SentimentBatchResult ab. Durchlaufen Sie die Liste mit den Ergebnissen, und geben Sie die ID des jeweiligen Dokuments sowie die Stimmung auf Dokumentebene zusammen mit Zuverlässigkeitsbewertungen aus. Das Ergebnis enthält die Stimmung auf Satzebene sowie Offsets, Länge und Zuverlässigkeitsbewertungen für jedes Dokument.

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

async function sentimentAnalysis(client){

    const sentimentInput = [
        "I had the best day of my life. I wish you were there with me."
    ];
    const sentimentResult = await client.analyzeSentiment(sentimentInput);

    sentimentResult.forEach(document => {
        console.log(`ID: ${document.id}`);
        console.log(`\tDocument Sentiment: ${document.sentiment}`);
        console.log(`\tDocument Scores:`);
        console.log(`\t\tPositive: ${document.confidenceScores.positive.toFixed(2)} \tNegative: ${document.confidenceScores.negative.toFixed(2)} \tNeutral: ${document.confidenceScores.neutral.toFixed(2)}`);
        console.log(`\tSentences Sentiment(${document.sentences.length}):`);
        document.sentences.forEach(sentence => {
            console.log(`\t\tSentence sentiment: ${sentence.sentiment}`)
            console.log(`\t\tSentences Scores:`);
            console.log(`\t\tPositive: ${sentence.confidenceScores.positive.toFixed(2)} \tNegative: ${sentence.confidenceScores.negative.toFixed(2)} \tNeutral: ${sentence.confidenceScores.neutral.toFixed(2)}`);
        });
    });
}
sentimentAnalysis(textAnalyticsClient)

Führen Sie in Ihrem Konsolenfenster Ihren Code mit node index.js aus.

Output

ID: 0
        Document Sentiment: positive
        Document Scores:
                Positive: 1.00  Negative: 0.00  Neutral: 0.00
        Sentences Sentiment(2):
                Sentence sentiment: positive
                Sentences Scores:
                Positive: 1.00  Negative: 0.00  Neutral: 0.00
                Sentence sentiment: neutral
                Sentences Scores:
                Positive: 0.21  Negative: 0.02  Neutral: 0.77

Opinion Mining

Zum Durchführen von Stimmungsanalyse mit Opinion Mining erstellen Sie ein Array aus Zeichenfolgen, die das zu analysierende Dokument enthalten. Rufen Sie die Methode analyzeSentiment() des Clients mit hinzugefügtem Optionsflag includeOpinionMining: true auf, und rufen Sie das zurückgegebene SentimentBatchResult-Objekt ab. Durchlaufen Sie die Liste mit den Ergebnissen, und geben Sie die ID des jeweiligen Dokuments sowie die Stimmung auf Dokumentebene zusammen mit Zuverlässigkeitsbewertungen aus. Für jedes Dokument enthält das Ergebnis nicht nur die Stimmung auf Satzebene wie oben sondern auch die Stimmung auf Ansichts- und Meinungsebene.

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

async function sentimentAnalysisWithOpinionMining(client){

  const sentimentInput = [
    {
      text: "The food and service were unacceptable, but the concierge were nice",
      id: "0",
      language: "en"
    }
  ];
  const results = await client.analyzeSentiment(sentimentInput, { includeOpinionMining: true });

  for (let i = 0; i < results.length; i++) {
    const result = results[i];
    console.log(`- Document ${result.id}`);
    if (!result.error) {
      console.log(`\tDocument text: ${sentimentInput[i].text}`);
      console.log(`\tOverall Sentiment: ${result.sentiment}`);
      console.log("\tSentiment confidence scores:", result.confidenceScores);
      console.log("\tSentences");
      for (const { sentiment, confidenceScores, opinions } of result.sentences) {
        console.log(`\t- Sentence sentiment: ${sentiment}`);
        console.log("\t  Confidence scores:", confidenceScores);
        console.log("\t  Mined opinions");
        for (const { target, assessments } of opinions) {
          console.log(`\t\t- Target text: ${target.text}`);
          console.log(`\t\t  Target sentiment: ${target.sentiment}`);
          console.log("\t\t  Target confidence scores:", target.confidenceScores);
          console.log("\t\t  Target assessments");
          for (const { text, sentiment } of assessments) {
            console.log(`\t\t\t- Text: ${text}`);
            console.log(`\t\t\t  Sentiment: ${sentiment}`);
          }
        }
      }
    } else {
      console.error(`\tError: ${result.error}`);
    }
  }
}
sentimentAnalysisWithOpinionMining(textAnalyticsClient)

Führen Sie in Ihrem Konsolenfenster Ihren Code mit node index.js aus.

Output

- Document 0
        Document text: The food and service were unacceptable, but the concierge were nice
        Overall Sentiment: positive
        Sentiment confidence scores: { positive: 0.84, neutral: 0, negative: 0.16 }
        Sentences
        - Sentence sentiment: positive
          Confidence scores: { positive: 0.84, neutral: 0, negative: 0.16 }
          Mined opinions
                - Target text: food
                  Target sentiment: negative
                  Target confidence scores: { positive: 0.01, negative: 0.99 }
                  Target assessments
                        - Text: unacceptable
                          Sentiment: negative
                - Target text: service
                  Target sentiment: negative
                  Target confidence scores: { positive: 0.01, negative: 0.99 }
                  Target assessments
                        - Text: unacceptable
                          Sentiment: negative
                - Target text: concierge
                  Target sentiment: positive
                  Target confidence scores: { positive: 1, negative: 0 }
                  Target assessments
                        - Text: nice
                          Sentiment: positive

Spracherkennung

Erstellen Sie ein Zeichenfolgenarray, das das zu analysierende Dokument enthält. Rufen Sie die Methode detectLanguage() des Clients auf, und rufen Sie das zurückgegebene Ergebnis (DetectLanguageResultCollection) ab. Durchlaufen Sie dann die Ergebnisse, und geben Sie für jedes Dokument die ID sowie die entsprechende primäre Sprache aus.

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

async function languageDetection(client) {

    const languageInputArray = [
        "Ce document est rédigé en Français."
    ];
    const languageResult = await client.detectLanguage(languageInputArray);

    languageResult.forEach(document => {
        console.log(`ID: ${document.id}`);
        console.log(`\tPrimary Language ${document.primaryLanguage.name}`)
    });
}
languageDetection(textAnalyticsClient);

Führen Sie in Ihrem Konsolenfenster Ihren Code mit node index.js aus.

Output

ID: 0
        Primary Language French

Erkennung benannter Entitäten (NER)

Erstellen Sie ein Zeichenfolgenarray, das das zu analysierende Dokument enthält. Rufen Sie die Methode recognizeEntities() des Clients auf, und rufen Sie das Objekt RecognizeEntitiesResult ab. Durchlaufen Sie die Liste mit den Ergebnissen, und geben Entitätsname, Typ, Untertyp, Offset, Länge und Bewertung aus.

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

async function entityRecognition(client){

    const entityInputs = [
        "Microsoft was founded by Bill Gates and Paul Allen on April 4, 1975, to develop and sell BASIC interpreters for the Altair 8800",
        "La sede principal de Microsoft se encuentra en la ciudad de Redmond, a 21 kilómetros de Seattle."
    ];
    const entityResults = await client.recognizeEntities(entityInputs);

    entityResults.forEach(document => {
        console.log(`Document ID: ${document.id}`);
        document.entities.forEach(entity => {
            console.log(`\tName: ${entity.text} \tCategory: ${entity.category} \tSubcategory: ${entity.subCategory ? entity.subCategory : "N/A"}`);
            console.log(`\tScore: ${entity.confidenceScore}`);
        });
    });
}
entityRecognition(textAnalyticsClient);

Führen Sie in Ihrem Konsolenfenster Ihren Code mit node index.js aus.

Output

Document ID: 0
        Name: Microsoft         Category: Organization  Subcategory: N/A
        Score: 0.29
        Name: Bill Gates        Category: Person        Subcategory: N/A
        Score: 0.78
        Name: Paul Allen        Category: Person        Subcategory: N/A
        Score: 0.82
        Name: April 4, 1975     Category: DateTime      Subcategory: Date
        Score: 0.8
        Name: 8800      Category: Quantity      Subcategory: Number
        Score: 0.8
Document ID: 1
        Name: 21        Category: Quantity      Subcategory: Number
        Score: 0.8
        Name: Seattle   Category: Location      Subcategory: GPE
        Score: 0.25

Erkennung von personenbezogenen Informationen (Personally Identifying Information, PII)

Erstellen Sie ein Zeichenfolgenarray, das das zu analysierende Dokument enthält. Rufen Sie die Methode recognizePiiEntities() des Clients auf, und rufen Sie das Objekt RecognizePIIEntitiesResult ab. Durchlaufen Sie die Liste mit den Ergebnissen, und geben Entitätsname, Typ und Bewertung aus.

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

async function piiRecognition(client) {

    const documents = [
        "The employee's phone number is (555) 555-5555."
    ];

    const results = await client.recognizePiiEntities(documents, "en");
    for (const result of results) {
        if (result.error === undefined) {
            console.log("Redacted Text: ", result.redactedText);
            console.log(" -- Recognized PII entities for input", result.id, "--");
            for (const entity of result.entities) {
                console.log(entity.text, ":", entity.category, "(Score:", entity.confidenceScore, ")");
            }
        } else {
            console.error("Encountered an error:", result.error);
        }
    }
}
piiRecognition(textAnalyticsClient)

Führen Sie in Ihrem Konsolenfenster Ihren Code mit node index.js aus.

Output

Redacted Text:  The employee's phone number is **************.
 -- Recognized PII entities for input 0 --
(555) 555-5555 : Phone Number (Score: 0.8 )

Entitätsverknüpfung

Erstellen Sie ein Zeichenfolgenarray, das das zu analysierende Dokument enthält. Rufen Sie die Methode recognizeLinkedEntities() des Clients auf, und rufen Sie das Objekt RecognizeLinkedEntitiesResult ab. Durchlaufen Sie die Liste mit den Ergebnissen, und geben Entitätsname, ID, Datenquelle, URL und Treffer aus. Jedes Objekt im Array matches enthält Offset, Länge und Bewertung für den Treffer.

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

async function linkedEntityRecognition(client){

    const linkedEntityInput = [
        "Microsoft was founded by Bill Gates and Paul Allen on April 4, 1975, to develop and sell BASIC interpreters for the Altair 8800. During his career at Microsoft, Gates held the positions of chairman, chief executive officer, president and chief software architect, while also being the largest individual shareholder until May 2014."
    ];
    const entityResults = await client.recognizeLinkedEntities(linkedEntityInput);

    entityResults.forEach(document => {
        console.log(`Document ID: ${document.id}`);
        document.entities.forEach(entity => {
            console.log(`\tName: ${entity.name} \tID: ${entity.dataSourceEntityId} \tURL: ${entity.url} \tData Source: ${entity.dataSource}`);
            console.log(`\tMatches:`)
            entity.matches.forEach(match => {
                console.log(`\t\tText: ${match.text} \tScore: ${match.confidenceScore.toFixed(2)}`);
        })
        });
    });
}
linkedEntityRecognition(textAnalyticsClient);

Führen Sie in Ihrem Konsolenfenster Ihren Code mit node index.js aus.

Output

Document ID: 0
        Name: Altair 8800       ID: Altair 8800         URL: https://en.wikipedia.org/wiki/Altair_8800  Data Source: Wikipedia
        Matches:
                Text: Altair 8800       Score: 0.88
        Name: Bill Gates        ID: Bill Gates  URL: https://en.wikipedia.org/wiki/Bill_Gates   Data Source: Wikipedia
        Matches:
                Text: Bill Gates        Score: 0.63
                Text: Gates     Score: 0.63
        Name: Paul Allen        ID: Paul Allen  URL: https://en.wikipedia.org/wiki/Paul_Allen   Data Source: Wikipedia
        Matches:
                Text: Paul Allen        Score: 0.60
        Name: Microsoft         ID: Microsoft   URL: https://en.wikipedia.org/wiki/Microsoft    Data Source: Wikipedia
        Matches:
                Text: Microsoft         Score: 0.55
                Text: Microsoft         Score: 0.55
        Name: April 4   ID: April 4     URL: https://en.wikipedia.org/wiki/April_4      Data Source: Wikipedia
        Matches:
                Text: April 4   Score: 0.32
        Name: BASIC     ID: BASIC       URL: https://en.wikipedia.org/wiki/BASIC        Data Source: Wikipedia
        Matches:
                Text: BASIC     Score: 0.33

Schlüsselwortextraktion

Erstellen Sie ein Zeichenfolgenarray, das das zu analysierende Dokument enthält. Rufen Sie die Methode extractKeyPhrases() des Clients auf, und rufen Sie das zurückgegebene Objekt ExtractKeyPhrasesResult ab. Durchlaufen Sie die Ergebnisse, und geben Sie die ID und alle erkannten Schlüsselbegriffe aus.

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

async function keyPhraseExtraction(client){

    const keyPhrasesInput = [
        "My cat might need to see a veterinarian.",
    ];
    const keyPhraseResult = await client.extractKeyPhrases(keyPhrasesInput);
    
    keyPhraseResult.forEach(document => {
        console.log(`ID: ${document.id}`);
        console.log(`\tDocument Key Phrases: ${document.keyPhrases}`);
    });
}
keyPhraseExtraction(textAnalyticsClient);

Führen Sie in Ihrem Konsolenfenster Ihren Code mit node index.js aus.

Output

ID: 0
        Document Key Phrases: cat,veterinarian

Extrahieren von Integritätsentitäten

Achtung

  • Wenn Sie den Integritätsvorgang verwenden möchten, muss es sich bei Ihrer Azure-Ressource um eine Ressource im Standard-Tarif (S) handeln.

Sie können die Textanalyse verwenden, um eine asynchrone Anforderung zum Extrahieren von Integritätsentitäten aus dem Text durchzuführen. Nachfolgend sehen Sie ein einfaches Beispiel für diesen Vorgang. Ein komplexeres Beispiel können Sie auf GitHub finden.

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

async function healthExample(client) {
    console.log("== Recognize Healthcare Entities Sample ==");

    const documents = [
        "Prescribed 100mg ibuprofen, taken twice daily."
      ];
    const poller = await client.beginAnalyzeHealthcareEntities(documents, "en", {
      includeStatistics: true
    });
  
    poller.onProgress(() => {
      console.log(
        `Last time the operation was updated was on: ${poller.getOperationState().lastModifiedOn}`
      );
    });
    console.log(
      `The analyze healthcare entities operation was created on ${
        poller.getOperationState().createdOn
      }`
    );
    console.log(
      `The analyze healthcare entities operation results will expire on ${
        poller.getOperationState().expiresOn
      }`
    );
  
    const results = await poller.pollUntilDone();
  
    for await (const result of results) {
      console.log(`- Document ${result.id}`);
      if (!result.error) {
        console.log("\tRecognized Entities:");
        for (const entity of result.entities) {
          console.log(`\t- Entity "${entity.text}" of type ${entity.category}`);
        }
        if (result.entityRelations && (result.entityRelations.length > 0)) {
          console.log(`\tRecognized relations between entities:`);
          for (const relation of result.entityRelations) {
            console.log(
              `\t\t- Relation of type ${relation.relationType} found between the following entities:`
            );
            for (const role of relation.roles) {
              console.log(`\t\t\t- "${role.entity.text}" with the role ${role.name}`);
            }
          }
        }
      } else console.error("\tError:", result.error);
    }
  }
  
  healthExample(textAnalyticsClient).catch((err) => {
    console.error("The sample encountered an error:", err);
  });

Output

- Document 0
    Recognized Entities:
    - Entity "100mg" of type Dosage
    - Entity "ibuprofen" of type MedicationName
    - Entity "twice daily" of type Frequency
    Recognized relations between entities:
        - Relation of type DosageOfMedication found between the following entities:   
                - "100mg" with the role Dosage
                - "ibuprofen" with the role Medication
        - Relation of type FrequencyOfMedication found between the following entities:
                - "ibuprofen" with the role Medication
                - "twice daily" with the role Frequency

Asynchrones Verwenden der API mit dem Analyze-Vorgang

Mithilfe des Analysevorgangs können Sie asynchrone Batchanforderungen für Folgendes ausführen: NER, Schlüsselbegriffserkennung, Stimmungsanalyse und Erkennung personenbezogener Informationen. Nachfolgend sehen Sie ein einfaches Beispiel für einen Vorgang. Erweiterte Beispiele für JavaScript und TypeScript finden Sie auf GitHub.

Achtung

  • Wenn Sie den Analysevorgang verwenden möchten, muss es sich bei Ihrer Azure-Ressource um eine Ressource im Standard-Tarif (S) handeln.

Erstellen Sie die neue Funktion analyze_example(), die die Funktion beginAnalyze() aufruft. Daraus resultiert ein zeitintensiver Vorgang, aus dem Ergebnisse abgerufen werden.

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

async function analyze_example(client) {
    const documents = [
        "Microsoft was founded by Bill Gates and Paul Allen.",
    ];

    const actions = {
        recognizeEntitiesActions: [{ modelVersion: "latest" }],
        extractKeyPhrasesActions: [{ modelVersion: "latest" }]
    };
    const poller = await client.beginAnalyzeActions(documents, actions, "en");

    console.log(
        `The analyze batch actions operation was created on ${poller.getOperationState().createdOn}`
    );
    console.log(
        `The analyze batch actions operation results will expire on ${poller.getOperationState().expiresOn
        }`
    );
    const resultPages = await poller.pollUntilDone();
    for await (const page of resultPages) {
        const entitiesAction = page.recognizeEntitiesResults[0];
        if (!entitiesAction.error) {
            for (const doc of entitiesAction.results) {
                console.log(`- Document ${doc.id}`);
                if (!doc.error) {
                    console.log("\tEntities:");
                    for (const entity of doc.entities) {
                        console.log(`\t- Entity ${entity.text} of type ${entity.category}`);
                    }
                } else {
                    console.error("\tError:", doc.error);
                }
            }
        }
        const keyPhrasesAction = page.extractKeyPhrasesResults[0];
        if (!keyPhrasesAction.error) {
            for (const doc of keyPhrasesAction.results) {
                console.log(`- Document ${doc.id}`);
                if (!doc.error) {
                    console.log("\tKey phrases:");
                    for (const phrase of doc.keyPhrases) {
                        console.log(`\t- ${phrase}`);
                    }
                } else {
                    console.error("\tError:", doc.error);
                }
            }
        }
    }
}
analyze_example(textAnalyticsClient)

Ausgabe

The analyze batch actions operation was created on Fri Jun 18 2021 12:34:52 GMT-0700 (Pacific Daylight Time)
The analyze batch actions operation results will expire on Sat Jun 19 2021 12:34:52 GMT-0700 (Pacific Daylight Time)
- Document 0
        Entities:
        - Entity Microsoft of type Organization
        - Entity Bill Gates of type Person
        - Entity Paul Allen of type Person
- Document 0
        Key phrases:
        - Bill Gates
        - Paul Allen
        - Microsoft

Sie können den Analysevorgang auch verwenden, um NER, Schlüsselbegriffserkennung, Stimmungsanalyse und die Erkennung personenbezogener Informationen durchzuführen. Die Analyze-Beispiele für JavaScript und TypeScript finden Sie auf GitHub.

Textzusammenfassung

Sie können die Textanalyse verwenden, um große Textblöcke zusammenzufassen. Die Methode ist asynchron und gibt die obersten Sätze zurück, wenn der zeitintensive Vorgang abgeschlossen ist.

async function summarization_example(client) {
    const documents = [`The extractive summarization feature in Text Analytics uses natural language processing techniques to locate key sentences in an unstructured text document. 
        These sentences collectively convey the main idea of the document. This feature is provided as an API for developers. 
        They can use it to build intelligent solutions based on the relevant information extracted to support various use cases. 
        In the public preview, extractive summarization supports several languages. It is based on pretrained multilingual transformer models, part of our quest for holistic representations. 
        It draws its strength from transfer learning across monolingual and harness the shared nature of languages to produce models of improved quality and efficiency.`];

    console.log("== Analyze Sample For Extract Summary ==");

    const actions = {
        extractSummaryActions: [{ modelVersion: "latest", orderBy: "Rank", maxSentenceCount: 5 }],
    };
    const poller = await client.beginAnalyzeActions(documents, actions, "en");

    poller.onProgress(() => {
        console.log(
            `Number of actions still in progress: ${poller.getOperationState().actionsInProgressCount}`
        );
    });

    console.log(`The analyze actions operation created on ${poller.getOperationState().createdOn}`);

    console.log(
        `The analyze actions operation results will expire on ${poller.getOperationState().expiresOn}`
    );

    const resultPages = await poller.pollUntilDone();

    for await (const page of resultPages) {
        const extractSummaryAction = page.extractSummaryResults[0];
        if (!extractSummaryAction.error) {
            for (const doc of extractSummaryAction.results) {
                console.log(`- Document ${doc.id}`);
                if (!doc.error) {
                    console.log("\tSummary:");
                    for (const sentence of doc.sentences) {
                        console.log(`\t- ${sentence.text}`);
                    }
                } else {
                    console.error("\tError:", doc.error);
                }
            }
        }
    } 
}
summarization_example(textAnalyticsClient).catch((err) => {
    console.error("The sample encountered an error:", err);
});

Führen Sie die Anwendung mit dem Befehl node für die Schnellstartdatei aus.

node index.js

Wichtig

  • In dieser Schnellstartanleitung werden nur die folgenden Versionen der API behandelt: v3.1 und v3.2-preview.

Voraussetzungen

  • Azure-Abonnement – Erstellen eines kostenlosen Kontos
  • Python 3.x
  • Damit Sie den entsprechenden KI-Bedingungen zustimmen und eine Ressource erstellen können, muss Ihrem Azure-Konto die Rolle „Cognitive Services-Mitwirkender“ zugewiesen sein. Kontaktieren Sie Ihren Administrator, der Ihrem Konto diese Rolle zuweisen kann.
  • Sobald Sie über Ihr Azure-Abonnement verfügen, erstellen Sie eine Textanalyseressource im Azure-Portal, um Ihren Schlüssel und Endpunkt zu erhalten. Klicken Sie nach Abschluss der Bereitstellung auf Zu Ressource wechseln.
    • Sie benötigen den Schlüssel und den Endpunkt der von Ihnen erstellten Ressource, um Ihre Anwendung mit der Textanalyse-API zu verbinden. Der Schlüssel und der Endpunkt werden weiter unten in der Schnellstartanleitung in den Code eingefügt.
    • Sie können den kostenlosen Tarif (F0) verwenden, um den Dienst zu testen, und später für die Produktion auf einen kostenpflichtigen Tarif upgraden.
  • Sie benötigen eine Textanalyse-Ressource des Standard-Tarifs (S), um das Analyze-Feature nutzen zu können.

Einrichten

Installieren der Clientbibliothek

Nach der Installation von Python können Sie die Clientbibliothek mit den folgenden Befehlen installieren:

pip install azure-ai-textanalytics==5.2.0b1

Features in dieser Version der Textanalyse-API:

  • Stimmungsanalyse
  • Opinion Mining
  • Spracherkennung
  • Entitätserkennung
  • Entitätsverknüpfung
  • Erkennung personenbezogener Informationen
  • Schlüsselwortextraktion
  • Asynchrone Methoden
  • Textanalyse für Gesundheit
  • Textzusammenfassung

Erstellen einer neuen Python-Anwendung

Erstellen Sie eine neue Python-Datei, und erstellen Sie Variablen für den Azure-Endpunkt und den Abonnementschlüssel Ihrer Ressource.

Wichtig

Öffnen Sie das Azure-Portal. Wenn die im Abschnitt Voraussetzungen erstellte Textanalyseressource erfolgreich bereitgestellt wurde, klicken Sie unter Nächste Schritte auf die Schaltfläche Zu Ressource wechseln. Schlüssel und Endpunkt finden Sie auf der Seite mit dem Schlüssel und dem Endpunkt der Ressource unter Ressourcenverwaltung.

Denken Sie daran, den Schlüssel aus Ihrem Code zu entfernen, wenn Sie fertig sind, und ihn niemals zu veröffentlichen. In der Produktionsumgebung sollten Sie eine sichere Methode zum Speichern Ihrer Anmeldeinformationen sowie zum Zugriff darauf verwenden. Beispielsweise Azure Key Vault.

key = "<paste-your-text-analytics-key-here>"
endpoint = "<paste-your-text-analytics-endpoint-here>"

Objektmodell

Der Textanalyseclient ist ein Objekt vom Typ TextAnalyticsClient, das sich bei Azure authentifiziert. Der Client bietet verschiedene Methoden, um Text zu analysieren.

Bei der Batchverarbeitung wird Text als Liste vom Typ documents an die API gesendet. Hierbei handelt es sich um Objekte vom Typ dictionary, die je nach verwendeter Methode eine Kombination aus den Attributen id, text und language enthalten. Das text-Attribut speichert den zu analysierenden Text in der Ausgangssprache (language), und id kann ein beliebiger Wert sein.

Das Antwortobjekt ist eine Liste mit den analysierten Informationen für jedes Dokument.

Wenn Sie Text Analytics verwenden, dürfen die Dokumente in Ihrer Abfrage die folgenden Zeichengrenzwerte nicht überschreiten. Weitere Informationen finden Sie im Artikel zu den Datengrenzwerten.

  • Synchrone Vorgänge und Text Analytics für Integritätsvorgänge: 5.120 Zeichen pro Dokument.
  • Asynchrone Vorgänge (Analysieren): 125.000 Zeichen pro Dokument.

Authentifizieren des Clients

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

Erstellen Sie eine Funktion, um das Objekt TextAnalyticsClient mit dem oben erstellten Schlüssel (key) und Endpunkt (endpoint) zu instanziieren. Erstellen Sie anschließend einen neuen Client.

from azure.ai.textanalytics import TextAnalyticsClient
from azure.core.credentials import AzureKeyCredential

def authenticate_client():
    ta_credential = AzureKeyCredential(key)
    text_analytics_client = TextAnalyticsClient(
            endpoint=endpoint, 
            credential=ta_credential)
    return text_analytics_client

client = authenticate_client()

Stimmungsanalyse

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

Erstellen Sie eine neue Funktion namens sentiment_analysis_example(), die den Client als Argument akzeptiert und anschließend die Funktion analyze_sentiment() aufruft. Das zurückgegebene Antwortobjekt enthält die Stimmungsbezeichnung und den Stimmungswert des gesamten Eingabedokuments sowie eine Standpunktanalyse für jeden Satz.

def sentiment_analysis_example(client):

    documents = ["I had the best day of my life. I wish you were there with me."]
    response = client.analyze_sentiment(documents=documents)[0]
    print("Document Sentiment: {}".format(response.sentiment))
    print("Overall scores: positive={0:.2f}; neutral={1:.2f}; negative={2:.2f} \n".format(
        response.confidence_scores.positive,
        response.confidence_scores.neutral,
        response.confidence_scores.negative,
    ))
    for idx, sentence in enumerate(response.sentences):
        print("Sentence: {}".format(sentence.text))
        print("Sentence {} sentiment: {}".format(idx+1, sentence.sentiment))
        print("Sentence score:\nPositive={0:.2f}\nNeutral={1:.2f}\nNegative={2:.2f}\n".format(
            sentence.confidence_scores.positive,
            sentence.confidence_scores.neutral,
            sentence.confidence_scores.negative,
        ))
          
sentiment_analysis_example(client)

Output

Document Sentiment: positive
Overall scores: positive=1.00; neutral=0.00; negative=0.00 

Sentence: I had the best day of my life.
Sentence 1 sentiment: positive
Sentence score:
Positive=1.00
Neutral=0.00
Negative=0.00

Sentence: I wish you were there with me.
Sentence 2 sentiment: neutral
Sentence score:
Positive=0.21
Neutral=0.77
Negative=0.02

Opinion Mining

Zum Durchführen von Stimmungsanalyse mit Opinion Mining erstellen Sie eine neue Funktion mit dem Namen sentiment_analysis_with_opinion_mining_example(), die den Client als Argument annimmt und dann die Funktion analyze_sentiment() mit dem Optionsflag show_opinion_mining=True aufruft. Das zurückgegebene Antwortobjekt enthält nicht nur die Stimmungsbezeichnung und den Stimmungswert des gesamten Eingabedokuments mit einer Stimmungsanalyse für jeden Satz, sondern außerdem die Standpunktanalyse auf Ansichts- und Meinungsebene.

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

def sentiment_analysis_with_opinion_mining_example(client):

    documents = [
        "The food and service were unacceptable, but the concierge were nice"
    ]

    result = client.analyze_sentiment(documents, show_opinion_mining=True)
    doc_result = [doc for doc in result if not doc.is_error]

    positive_reviews = [doc for doc in doc_result if doc.sentiment == "positive"]
    negative_reviews = [doc for doc in doc_result if doc.sentiment == "negative"]

    positive_mined_opinions = []
    mixed_mined_opinions = []
    negative_mined_opinions = []

    for document in doc_result:
        print("Document Sentiment: {}".format(document.sentiment))
        print("Overall scores: positive={0:.2f}; neutral={1:.2f}; negative={2:.2f} \n".format(
            document.confidence_scores.positive,
            document.confidence_scores.neutral,
            document.confidence_scores.negative,
        ))
        for sentence in document.sentences:
            print("Sentence: {}".format(sentence.text))
            print("Sentence sentiment: {}".format(sentence.sentiment))
            print("Sentence score:\nPositive={0:.2f}\nNeutral={1:.2f}\nNegative={2:.2f}\n".format(
                sentence.confidence_scores.positive,
                sentence.confidence_scores.neutral,
                sentence.confidence_scores.negative,
            ))
            for mined_opinion in sentence.mined_opinions:
                target = mined_opinion.target
                print("......'{}' target '{}'".format(target.sentiment, target.text))
                print("......Target score:\n......Positive={0:.2f}\n......Negative={1:.2f}\n".format(
                    target.confidence_scores.positive,
                    target.confidence_scores.negative,
                ))
                for assessment in mined_opinion.assessments:
                    print("......'{}' assessment '{}'".format(assessment.sentiment, assessment.text))
                    print("......Assessment score:\n......Positive={0:.2f}\n......Negative={1:.2f}\n".format(
                        assessment.confidence_scores.positive,
                        assessment.confidence_scores.negative,
                    ))
            print("\n")
        print("\n")
          
sentiment_analysis_with_opinion_mining_example(client)

Output

Document Sentiment: positive
Overall scores: positive=0.84; neutral=0.00; negative=0.16

Sentence: The food and service were unacceptable, but the concierge were nice
Sentence sentiment: positive
Sentence score:
Positive=0.84
Neutral=0.00
Negative=0.16

......'negative' target 'food'
......Target score:
......Positive=0.01
......Negative=0.99

......'negative' assessment 'unacceptable'
......Assessment score:
......Positive=0.01
......Negative=0.99

......'negative' target 'service'
......Target score:
......Positive=0.01
......Negative=0.99

......'negative' assessment 'unacceptable'
......Assessment score:
......Positive=0.01
......Negative=0.99

......'positive' target 'concierge'
......Target score:
......Positive=1.00
......Negative=0.00

......'positive' assessment 'nice'
......Assessment score:
......Positive=1.00
......Negative=0.00

Press any key to continue . . .

Spracherkennung

Erstellen Sie eine neue Funktion namens language_detection_example(), die den Client als Argument akzeptiert und anschließend die Funktion detect_language() aufruft. Das zurückgegebene Antwortobjekt enthält die erkannte Sprache in primary_language (sofern erfolgreich). Andernfalls enthält es eine Fehlermeldung (error).

Hinweis

  • Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.
  • In einigen Fällen ist es unter Umständen schwierig, die Sprachen basierend auf den Eingaben eindeutig zu bestimmen. Mithilfe des Parameters country_hint können Sie einen zweistelligen Ländercode angeben. Die API verwendet standardmäßig „US“ als Wert für „countryHint“. Wenn Sie dieses Verhalten entfernen möchten, können Sie diesen Parameter zurücksetzen, indem Sie seinen Wert auf eine leere Zeichenfolge (country_hint : "") festlegen.
def language_detection_example(client):
    try:
        documents = ["Ce document est rédigé en Français."]
        response = client.detect_language(documents = documents, country_hint = 'us')[0]
        print("Language: ", response.primary_language.name)

    except Exception as err:
        print("Encountered exception. {}".format(err))
language_detection_example(client)

Output

Language:  French

Erkennung benannter Entitäten (NER)

Erstellen Sie eine neue Funktion namens entity_recognition_example, die den Client als Argument akzeptiert und anschließend die Funktion recognize_entities() aufruft und die Ergebnisse durchläuft. Das zurückgegebene Antwortobjekt enthält die Liste erkannter Entitäten in entity (sofern erfolgreich). Andernfalls enthält es eine Fehlermeldung (error). Geben Sie für die erkannten Entitäten jeweils die Kategorie und Unterkategorie aus (sofern vorhanden).

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

def entity_recognition_example(client):

    try:
        documents = ["I had a wonderful trip to Seattle last week."]
        result = client.recognize_entities(documents = documents)[0]

        print("Named Entities:\n")
        for entity in result.entities:
            print("\tText: \t", entity.text, "\tCategory: \t", entity.category, "\tSubCategory: \t", entity.subcategory,
                    "\n\tConfidence Score: \t", round(entity.confidence_score, 2), "\tLength: \t", entity.length, "\tOffset: \t", entity.offset, "\n")

    except Exception as err:
        print("Encountered exception. {}".format(err))
entity_recognition_example(client)

Output

Named Entities:

        Text:    trip   Category:        Event  SubCategory:     None
        Confidence Score:        0.61   Length:          4      Offset:          18

        Text:    Seattle        Category:        Location       SubCategory:     GPE
        Confidence Score:        0.82   Length:          7      Offset:          26

        Text:    last week      Category:        DateTime       SubCategory:     DateRange
        Confidence Score:        0.8    Length:          9      Offset:          34

Erkennung von personenbezogenen Informationen (PII)

Erstellen Sie eine neue Funktion namens pii_recognition_example, die den Client als Argument akzeptiert und anschließend die Funktion recognize_pii_entities() aufruft und die Ergebnisse durchläuft. Das zurückgegebene Antwortobjekt enthält die Liste erkannter Entitäten in entity (sofern erfolgreich). Andernfalls enthält es eine Fehlermeldung (error). Geben Sie für die erkannten Entitäten jeweils die Kategorie und Unterkategorie aus (sofern vorhanden).

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

def pii_recognition_example(client):
    documents = [
        "The employee's SSN is 859-98-0987.",
        "The employee's phone number is 555-555-5555."
    ]
    response = client.recognize_pii_entities(documents, language="en")
    result = [doc for doc in response if not doc.is_error]
    for doc in result:
        print("Redacted Text: {}".format(doc.redacted_text))
        for entity in doc.entities:
            print("Entity: {}".format(entity.text))
            print("\tCategory: {}".format(entity.category))
            print("\tConfidence Score: {}".format(entity.confidence_score))
            print("\tOffset: {}".format(entity.offset))
            print("\tLength: {}".format(entity.length))
pii_recognition_example(client)

Output

Redacted Text: The employee's SSN is ***********.
Entity: 859-98-0987
        Category: U.S. Social Security Number (SSN)
        Confidence Score: 0.65
        Offset: 22
        Length: 11
Redacted Text: The employee's phone number is ************.
Entity: 555-555-5555
        Category: Phone Number
        Confidence Score: 0.8
        Offset: 31
        Length: 12

Entitätsverknüpfung

Erstellen Sie eine neue Funktion namens entity_linking_example(), die den Client als Argument akzeptiert und anschließend die Funktion recognize_linked_entities() aufruft und die Ergebnisse durchläuft. Das zurückgegebene Antwortobjekt enthält die Liste erkannter Entitäten in entities (sofern erfolgreich). Andernfalls enthält es eine Fehlermeldung (error). Da verknüpfte Entitäten eindeutig identifiziert werden, werden Vorkommen der gleichen Entität unter einem Objekt vom Typ entity als Liste von Objekten des Typs match gruppiert.

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

def entity_linking_example(client):

    try:
        documents = ["""Microsoft was founded by Bill Gates and Paul Allen on April 4, 1975, 
        to develop and sell BASIC interpreters for the Altair 8800. 
        During his career at Microsoft, Gates held the positions of chairman,
        chief executive officer, president and chief software architect, 
        while also being the largest individual shareholder until May 2014."""]
        result = client.recognize_linked_entities(documents = documents)[0]

        print("Linked Entities:\n")
        for entity in result.entities:
            print("\tName: ", entity.name, "\tId: ", entity.data_source_entity_id, "\tUrl: ", entity.url,
            "\n\tData Source: ", entity.data_source)
            print("\tMatches:")
            for match in entity.matches:
                print("\t\tText:", match.text)
                print("\t\tConfidence Score: {0:.2f}".format(match.confidence_score))
                print("\t\tOffset: {}".format(match.offset))
                print("\t\tLength: {}".format(match.length))
            
    except Exception as err:
        print("Encountered exception. {}".format(err))
entity_linking_example(client)

Output

Linked Entities:

        Name:  Microsoft        Id:  Microsoft  Url:  https://en.wikipedia.org/wiki/Microsoft
        Data Source:  Wikipedia
        Matches:
                Text: Microsoft
                Confidence Score: 0.55
                Offset: 0
                Length: 9
                Text: Microsoft
                Confidence Score: 0.55
                Offset: 168
                Length: 9
        Name:  Bill Gates       Id:  Bill Gates         Url:  https://en.wikipedia.org/wiki/Bill_Gates
        Data Source:  Wikipedia
        Matches:
                Text: Bill Gates
                Confidence Score: 0.63
                Offset: 25
                Length: 10
                Text: Gates
                Confidence Score: 0.63
                Offset: 179
                Length: 5
        Name:  Paul Allen       Id:  Paul Allen         Url:  https://en.wikipedia.org/wiki/Paul_Allen
        Data Source:  Wikipedia
        Matches:
                Text: Paul Allen
                Confidence Score: 0.60
                Offset: 40
                Length: 10
        Name:  April 4  Id:  April 4    Url:  https://en.wikipedia.org/wiki/April_4
        Data Source:  Wikipedia
        Matches:
                Text: April 4
                Confidence Score: 0.32
                Offset: 54
                Length: 7
        Name:  BASIC    Id:  BASIC      Url:  https://en.wikipedia.org/wiki/BASIC
        Data Source:  Wikipedia
        Matches:
                Text: BASIC
                Confidence Score: 0.33
                Offset: 98
                Length: 5
        Name:  Altair 8800      Id:  Altair 8800        Url:  https://en.wikipedia.org/wiki/Altair_8800
        Data Source:  Wikipedia
        Matches:
                Text: Altair 8800
                Confidence Score: 0.88
                Offset: 125
                Length: 11

Schlüsselwortextraktion

Erstellen Sie eine neue Funktion namens key_phrase_extraction_example(), die den Client als Argument akzeptiert und anschließend die Funktion extract_key_phrases() aufruft. Das Ergebnis enthält bei erfolgreicher Ausführung die Liste der erkannten Schlüsselbegriffe in key_phrases und andernfalls error. Geben Sie alle erkannten Schlüsselbegriffe aus.

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

def key_phrase_extraction_example(client):

    try:
        documents = ["My cat might need to see a veterinarian."]

        response = client.extract_key_phrases(documents = documents)[0]

        if not response.is_error:
            print("\tKey Phrases:")
            for phrase in response.key_phrases:
                print("\t\t", phrase)
        else:
            print(response.id, response.error)

    except Exception as err:
        print("Encountered exception. {}".format(err))
        
key_phrase_extraction_example(client)

Output

    Key Phrases:
         cat
         veterinarian

Extrahieren von Integritätsentitäten

Sie können die Textanalyse verwenden, um eine asynchrone Anforderung zum Extrahieren von Integritätsentitäten aus dem Text durchzuführen. Nachfolgend sehen Sie ein einfaches Beispiel für diesen Vorgang. Ein komplexeres Beispiel können Sie auf GitHub finden.

Achtung

  • Wenn Sie den Integritätsvorgang verwenden möchten, muss es sich bei Ihrer Azure-Ressource um eine Ressource im Standard-Tarif (S) handeln.

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

def health_example(client):
    documents = [
        """
        Patient needs to take 50 mg of ibuprofen.
        """
    ]

    poller = client.begin_analyze_healthcare_entities(documents)
    result = poller.result()

    docs = [doc for doc in result if not doc.is_error]

    for idx, doc in enumerate(docs):
        for entity in doc.entities:
            print("Entity: {}".format(entity.text))
            print("...Normalized Text: {}".format(entity.normalized_text))
            print("...Category: {}".format(entity.category))
            print("...Subcategory: {}".format(entity.subcategory))
            print("...Offset: {}".format(entity.offset))
            print("...Confidence score: {}".format(entity.confidence_score))
        for relation in doc.entity_relations:
            print("Relation of type: {} has the following roles".format(relation.relation_type))
            for role in relation.roles:
                print("...Role '{}' with entity '{}'".format(role.name, role.entity.text))
        print("------------------------------------------")
health_example(client)

Output

Entity: 50 mg
...Normalized Text: None
...Category: Dosage
...Subcategory: None
...Offset: 31
...Confidence score: 1.0
Entity: ibuprofen
...Normalized Text: ibuprofen
...Category: MedicationName
...Subcategory: None
...Offset: 40
...Confidence score: 1.0
Relation of type: DosageOfMedication has the following roles
...Role 'Dosage' with entity '50 mg'
...Role 'Medication' with entity 'ibuprofen'

Asynchrones Verwenden der API mit dem Analyze-Vorgang

Mithilfe des Analysevorgangs können Sie asynchrone Batchanforderungen für Folgendes ausführen: NER, Schlüsselbegriffserkennung, Stimmungsanalyse und Erkennung personenbezogener Informationen. Nachfolgend sehen Sie ein einfaches Beispiel für diesen Vorgang. Ein komplexeres Beispiel können Sie auf GitHub finden.

Achtung

  • Wenn Sie den Analysevorgang verwenden möchten, muss es sich bei Ihrer Azure-Ressource um eine Ressource im Standard-Tarif (S) handeln.

Hinweis

Die folgende Methode gilt für die Versionen 3.1 und 3.2-preview der API.

Erstellen Sie eine neue Funktion namens analyze_batch_example(), die den Client als Argument akzeptiert und anschließend die Funktion begin_analyze_actions() aufruft. Daraus resultiert ein zeitintensiver Vorgang, aus dem Ergebnisse abgerufen werden.

from azure.ai.textanalytics import (
    RecognizeEntitiesAction,
    ExtractKeyPhrasesAction
)

def analyze_batch_example(client):
        documents = [
            "Microsoft was founded by Bill Gates and Paul Allen."
        ]

        poller = client.begin_analyze_actions(
            documents,
            display_name="Sample Text Analysis",
            actions=[RecognizeEntitiesAction(), ExtractKeyPhrasesAction()]
        )

        result = poller.result()
        action_results = [action_result for action_result in list(result)]
        first_action_result = action_results[0][0]
        print("Results of Entities Recognition action:")

        for entity in first_action_result.entities:
            print("Entity: {}".format(entity.text))
            print("...Category: {}".format(entity.category))
            print("...Confidence Score: {}".format(entity.confidence_score))
            print("...Offset: {}".format(entity.offset))
            print("...Length: {}".format(entity.length))
        print("------------------------------------------")

        second_action_result = action_results[0][1]
        print("Results of Key Phrase Extraction action:")
        
        for key_phrase in second_action_result.key_phrases:
            print("Key Phrase: {}\n".format(key_phrase))
        print("------------------------------------------")

analyze_batch_example(client)

Ausgabe

Results of Entities Recognition action:
Entity: Microsoft
...Category: Organization
...Confidence Score: 1.0
...Offset: 0
...Length: 9
Entity: Bill Gates
...Category: Person
...Confidence Score: 1.0
...Offset: 25
...Length: 10
Entity: Paul Allen
...Category: Person
...Confidence Score: 1.0
...Offset: 40
...Length: 10
------------------------------------------
Results of Key Phrase Extraction action:
Key Phrase: Bill Gates

Key Phrase: Paul Allen

Key Phrase: Microsoft

------------------------------------------

Textzusammenfassung

Achtung

  • Wenn Sie den Vorgang für die Textzusammenfassung verwenden möchten, muss es sich bei Ihrer Azure-Ressource um eine Ressource im Standard-Tarif S handeln.

Sie können Textanalyse verwenden, um große Textblöcke zusammenzufassen. Erstellen Sie eine neue Funktion namens summarization_example(), die den Client als Argument akzeptiert und anschließend die Funktion begin_analyze_actions() aufruft. Daraus resultiert ein zeitintensiver Vorgang, aus dem Ergebnisse abgerufen werden.

def sample_extractive_summarization(client):
    from azure.core.credentials import AzureKeyCredential
    from azure.ai.textanalytics import (
        TextAnalyticsClient,
        ExtractSummaryAction
    ) 

    document = [
        "The extractive summarization feature in Text Analytics uses natural language processing techniques to locate key sentences in an unstructured text document. "
        "These sentences collectively convey the main idea of the document. This feature is provided as an API for developers. " 
        "They can use it to build intelligent solutions based on the relevant information extracted to support various use cases. "
        "In the public preview, extractive summarization supports several languages. It is based on pretrained multilingual transformer models, part of our quest for holistic representations. "
        "It draws its strength from transfer learning across monolingual and harness the shared nature of languages to produce models of improved quality and efficiency. "
    ]

    poller = client.begin_analyze_actions(
        document,
        actions=[
            ExtractSummaryAction(MaxSentenceCount=4)
        ],
    )

    document_results = poller.result()
    for result in document_results:
        extract_summary_result = result[0]  # first document, first result
        if extract_summary_result.is_error:
            print("...Is an error with code '{}' and message '{}'".format(
                extract_summary_result.code, extract_summary_result.message
            ))
        else:
            print("Summary extracted: \n{}".format(
                " ".join([sentence.text for sentence in extract_summary_result.sentences]))
            )

sample_extractive_summarization(client)

Wichtig

  • Die neueste stabile Version der Textanalyse-API ist 3.1.
    • Befolgen Sie nur die Anweisungen für die von Ihnen verwendete Version.

Voraussetzungen

  • Aktuelle Version von cURL.
  • Damit Sie den entsprechenden KI-Bedingungen zustimmen und eine Ressource erstellen können, muss Ihrem Azure-Konto die Rolle „Cognitive Services-Mitwirkender“ zugewiesen sein. Kontaktieren Sie Ihren Administrator, der Ihrem Konto diese Rolle zuweisen kann.
  • Sobald Sie über Ihr Azure-Abonnement verfügen, erstellen Sie eine Textanalyseressource im Azure-Portal, um Ihren Schlüssel und Endpunkt zu erhalten. Klicken Sie nach Abschluss der Bereitstellung auf Zu Ressource wechseln.
    • Sie benötigen den Schlüssel und den Endpunkt der von Ihnen erstellten Ressource, um Ihre Anwendung mit der Textanalyse-API zu verbinden. Der Schlüssel und der Endpunkt werden weiter unten in der Schnellstartanleitung in den Code eingefügt.
    • Sie können den kostenlosen Tarif (F0) verwenden, um den Dienst zu testen, und später für die Produktion auf einen kostenpflichtigen Tarif upgraden.

Hinweis

  • In den folgenden Bash-Beispielen wird das Zeilenfortsetzungszeichen \ verwendet. Verwenden Sie dieses Zeichen, falls in Ihrer Konsole oder Ihrem Terminal ein anderes Zeilenfortsetzungszeichen genutzt wird.
  • Sprachspezifische Beispiele finden Sie auf GitHub.
  • Navigieren Sie zum Azure-Portal, und suchen Sie den Schlüssel und den Endpunkt für die unter „Voraussetzungen“ erstellte Textanalyseressource. Sie befinden sich auf der Seite mit dem Schlüssel und Endpunkt der Ressource unter Ressourcenverwaltung. Ersetzen Sie dann die Zeichenfolgen im unten angegebenen Code durch Ihren Schlüssel und Endpunkt. Sie benötigen die folgenden Informationen, um die Textanalyse-API aufzurufen:
parameter BESCHREIBUNG
-X POST <endpoint> Gibt den Endpunkt für den Zugriff auf die API an
-H Content-Type: application/json Der Inhaltstyp zum Senden von JSON-Daten
-H "Ocp-Apim-Subscription-Key:<key> Gibt den Schlüssel für den Zugriff auf die API an
-d <documents> Die JSON-Datei, die die zu sendenden Dokumente enthält

Die folgenden cURL-Befehle werden über eine Bash-Shell ausgeführt. Fügen Sie in diese Befehle Ihren Ressourcennamen und Ressourcenschlüssel sowie Ihre JSON-Werte ein.

Stimmungsanalyse und Opinion Mining

  1. Kopieren Sie den Befehl in einen Text-Editor.
  2. Nehmen Sie die folgenden Änderungen im Befehl vor, falls dies erforderlich ist:
    1. Ersetzen Sie den Wert <your-text-analytics-key-here> durch Ihren Schlüssel.
    2. Ersetzen Sie den ersten Teil der Anforderungs-URL (<your-text-analytics-endpoint-here>) durch Ihre Endpunkt-URL.
  3. Öffnen Sie ein Eingabeaufforderungsfenster.
  4. Fügen Sie den Befehl aus dem Text-Editor in das Eingabeaufforderungsfenster ein, und führen Sie den Befehl aus.

Hinweis

Die folgenden Beispiele enthalten eine Anfrage für die Opinion Mining-Funktion der Stimmungsanalyse mit dem Parameter opinionMining=true, die granulare Informationen über Bewertungen (Adjektive) in Bezug auf Ziele (Substantive) im Text liefert.

curl -X POST https://<your-text-analytics-endpoint-here>/text/analytics/v3.2-preview.1/sentiment?opinionMining=true \
-H "Content-Type: application/json" \
-H "Ocp-Apim-Subscription-Key: <your-text-analytics-key-here>" \
-d '{ documents: [{ id: "1", text: "The customer service here is really good."}]}'

JSON-Antwort

Die JSON-Antwort ist für v3.1 und v3.2-preview.1 identisch.

{
   "documents":[
      {
         "id":"1",
         "sentiment":"positive",
         "confidenceScores":{
            "positive":1.0,
            "neutral":0.0,
            "negative":0.0
         },
         "sentences":[
            {
               "sentiment":"positive",
               "confidenceScores":{
                  "positive":1.0,
                  "neutral":0.0,
                  "negative":0.0
               },
               "offset":0,
               "length":41,
               "text":"The customer service here is really good.",
               "targets":[
                  {
                     "sentiment":"positive",
                     "confidenceScores":{
                        "positive":1.0,
                        "negative":0.0
                     },
                     "offset":4,
                     "length":16,
                     "text":"customer service",
                     "relations":[
                        {
                           "relationType":"assessment",
                           "ref":"#/documents/0/sentences/0/assessments/0"
                        }
                     ]
                  }
               ],
               "assessments":[
                  {
                     "sentiment":"positive",
                     "confidenceScores":{
                        "positive":1.0,
                        "negative":0.0
                     },
                     "offset":36,
                     "length":4,
                     "text":"good",
                     "isNegated":false
                  }
               ]
            }
         ],
         "warnings":[
            
         ]
      }
   ],
   "errors":[
      
   ],
   "modelVersion":"2020-04-01"
}

Spracherkennung

  1. Kopieren Sie den Befehl in einen Text-Editor.
  2. Nehmen Sie die folgenden Änderungen im Befehl vor, falls dies erforderlich ist:
    1. Ersetzen Sie den Wert <your-text-analytics-key-here> durch Ihren Schlüssel.
    2. Ersetzen Sie den ersten Teil der Anforderungs-URL (<your-text-analytics-endpoint-here>) durch Ihre Endpunkt-URL.
  3. Öffnen Sie ein Eingabeaufforderungsfenster.
  4. Fügen Sie den Befehl aus dem Text-Editor in das Eingabeaufforderungsfenster ein, und führen Sie den Befehl aus.
curl -X POST https://<your-text-analytics-endpoint-here>/text/analytics/v3.2-preview.1/languages/ \
-H "Content-Type: application/json" \
-H "Ocp-Apim-Subscription-Key: <your-text-analytics-key-here>" \
-d '{ documents: [{ id: "1", text: "This is a document written in English."}]}'

JSON-Antwort

Die JSON-Antwort ist für v3.1 und v3.2-preview.1 identisch.

{
   "documents":[
      {
         "id":"1",
         "detectedLanguage":{
            "name":"English",
            "iso6391Name":"en",
            "confidenceScore":1.0
         },
         "warnings":[
            
         ]
      }
   ],
   "errors":[
      
   ],
   "modelVersion":"2021-01-05"
}

Erkennung benannter Entitäten (NER)

  1. Kopieren Sie den Befehl in einen Text-Editor.
  2. Nehmen Sie die folgenden Änderungen im Befehl vor, falls dies erforderlich ist:
    1. Ersetzen Sie den Wert <your-text-analytics-key-here> durch Ihren Schlüssel.
    2. Ersetzen Sie den ersten Teil der Anforderungs-URL (<your-text-analytics-endpoint-here>) durch Ihre Endpunkt-URL.
  3. Öffnen Sie ein Eingabeaufforderungsfenster.
  4. Fügen Sie den Befehl aus dem Text-Editor in das Eingabeaufforderungsfenster ein, und führen Sie den Befehl aus.
curl -X POST https://<your-text-analytics-endpoint-here>/text/analytics/v3.2-preview.1/entities/recognition/general \
-H "Content-Type: application/json" \
-H "Ocp-Apim-Subscription-Key: <your-text-analytics-key-here>" \
-d '{ documents: [{ id: "1", language:"en", text: "I had a wonderful trip to Seattle last week."}]}'

JSON-Antwort

Die JSON-Antwort ist für v3.1 und v3.2-preview.1 identisch.

{
   "documents":[
      {
         "id":"1",
         "entities":[
            {
               "text":"Seattle",
               "category":"Location",
               "subcategory":"GPE",
               "offset":26,
               "length":7,
               "confidenceScore":0.99
            },
            {
               "text":"last week",
               "category":"DateTime",
               "subcategory":"DateRange",
               "offset":34,
               "length":9,
               "confidenceScore":0.8
            }
         ],
         "warnings":[
            
         ]
      }
   ],
   "errors":[
      
   ],
   "modelVersion":"2021-01-15"
}

Erkennung von personenbezogenen Informationen (PII)

  1. Kopieren Sie den Befehl in einen Text-Editor.
  2. Nehmen Sie die folgenden Änderungen im Befehl vor, falls dies erforderlich ist:
    1. Ersetzen Sie den Wert <your-text-analytics-key-here> durch Ihren Schlüssel.
    2. Ersetzen Sie den ersten Teil der Anforderungs-URL (<your-text-analytics-endpoint-here>) durch Ihre Endpunkt-URL.
  3. Öffnen Sie ein Eingabeaufforderungsfenster.
  4. Fügen Sie den Befehl aus dem Text-Editor in das Eingabeaufforderungsfenster ein, und führen Sie den Befehl aus.
curl -X POST https://your-text-analytics-endpoint-here>/text/analytics/v3.2-preview.1/entities/recognition/pii \
-H "Content-Type: application/json" \
-H "Ocp-Apim-Subscription-Key: <your-text-analytics-key-here>" \
-d '{ documents: [{ id: "1", language:"en", text: "Call our office at 312-555-1234, or send an email to support@contoso.com"}]}'

JSON-Antwort

Die JSON-Antwort ist für v3.1 und v3.2-preview.1 identisch.

{
   "documents":[
      {
         "redactedText":"Call our office at ************, or send an email to *******************",
         "id":"1",
         "entities":[
            {
               "text":"312-555-1234",
               "category":"PhoneNumber",
               "offset":19,
               "length":12,
               "confidenceScore":0.8
            },
            {
               "text":"support@contoso.com",
               "category":"Email",
               "offset":53,
               "length":19,
               "confidenceScore":0.8
            }
         ],
         "warnings":[
            
         ]
      }
   ],
   "errors":[
      
   ],
   "modelVersion":"2021-01-15"
}

Entitätsverknüpfung

  1. Kopieren Sie den Befehl in einen Text-Editor.
  2. Nehmen Sie die folgenden Änderungen im Befehl vor, falls dies erforderlich ist:
    1. Ersetzen Sie den Wert <your-text-analytics-key-here> durch Ihren Schlüssel.
    2. Ersetzen Sie den ersten Teil der Anforderungs-URL (<your-text-analytics-endpoint-here>) durch Ihre Endpunkt-URL.
  3. Öffnen Sie ein Eingabeaufforderungsfenster.
  4. Fügen Sie den Befehl aus dem Text-Editor in das Eingabeaufforderungsfenster ein, und führen Sie den Befehl aus.
curl -X POST https://<your-text-analytics-endpoint-here>/text/analytics/v3.2-preview.1/entities/linking \
-H "Content-Type: application/json" \
-H "Ocp-Apim-Subscription-Key: <your-text-analytics-key-here>" \
-d '{ documents: [{ id: "1", language:"en", text: "Microsoft was founded by Bill Gates and Paul Allen on April 4, 1975."}]}'

JSON-Antwort

Die JSON-Antwort ist für v3.1 und v3.2-preview.1 identisch.

{
   "documents":[
      {
         "id":"1",
         "entities":[
            {
               "bingId":"a093e9b9-90f5-a3d5-c4b8-5855e1b01f85",
               "name":"Microsoft",
               "matches":[
                  {
                     "text":"Microsoft",
                     "offset":0,
                     "length":9,
                     "confidenceScore":0.48
                  }
               ],
               "language":"en",
               "id":"Microsoft",
               "url":"https://en.wikipedia.org/wiki/Microsoft",
               "dataSource":"Wikipedia"
            },
            {
               "bingId":"0d47c987-0042-5576-15e8-97af601614fa",
               "name":"Bill Gates",
               "matches":[
                  {
                     "text":"Bill Gates",
                     "offset":25,
                     "length":10,
                     "confidenceScore":0.52
                  }
               ],
               "language":"en",
               "id":"Bill Gates",
               "url":"https://en.wikipedia.org/wiki/Bill_Gates",
               "dataSource":"Wikipedia"
            },
            {
               "bingId":"df2c4376-9923-6a54-893f-2ee5a5badbc7",
               "name":"Paul Allen",
               "matches":[
                  {
                     "text":"Paul Allen",
                     "offset":40,
                     "length":10,
                     "confidenceScore":0.54
                  }
               ],
               "language":"en",
               "id":"Paul Allen",
               "url":"https://en.wikipedia.org/wiki/Paul_Allen",
               "dataSource":"Wikipedia"
            },
            {
               "bingId":"52535f87-235e-b513-54fe-c03e4233ac6e",
               "name":"April 4",
               "matches":[
                  {
                     "text":"April 4",
                     "offset":54,
                     "length":7,
                     "confidenceScore":0.38
                  }
               ],
               "language":"en",
               "id":"April 4",
               "url":"https://en.wikipedia.org/wiki/April_4",
               "dataSource":"Wikipedia"
            }
         ],
         "warnings":[
            
         ]
      }
   ],
   "errors":[
      
   ],
   "modelVersion":"2020-02-01"
}

Schlüsselwortextraktion

  1. Kopieren Sie den Befehl in einen Text-Editor.
  2. Nehmen Sie die folgenden Änderungen im Befehl vor, falls dies erforderlich ist:
    1. Ersetzen Sie den Wert <your-text-analytics-key-here> durch Ihren Schlüssel.
    2. Ersetzen Sie den ersten Teil der Anforderungs-URL (<your-text-analytics-endpoint-here>) durch Ihre Endpunkt-URL.
  3. Öffnen Sie ein Eingabeaufforderungsfenster.
  4. Fügen Sie den Befehl aus dem Text-Editor in das Eingabeaufforderungsfenster ein, und führen Sie den Befehl aus.
curl -X POST https://<your-text-analytics-endpoint-here>/text/analytics/v3.2-preview.1/keyPhrases \
-H "Content-Type: application/json" \
-H "Ocp-Apim-Subscription-Key: <your-text-analytics-key-here>" \
-d '{ documents: [{ id: "1", language:"en", text: "I had a wonderful trip to Seattle last week."}]}'

JSON-Antwort

Die JSON-Antwort ist für v3.1 und v3.2-preview.1 identisch.

{
   "documents":[
      {
         "id":"1",
         "keyPhrases":[
            "wonderful trip",
            "Seattle"
         ],
         "warnings":[
            
         ]
      }
   ],
   "errors":[
      
   ],
   "modelVersion":"2021-06-01"
}

Textanalyse für Gesundheit

  1. Kopieren Sie den Befehl in einen Text-Editor.
  2. Nehmen Sie die folgenden Änderungen im Befehl vor, falls dies erforderlich ist:
    1. Ersetzen Sie den Wert <your-text-analytics-key-here> durch Ihren Schlüssel.
    2. Ersetzen Sie den ersten Teil der Anforderungs-URL (<your-text-analytics-endpoint-here>) durch Ihre Endpunkt-URL.
  3. Öffnen Sie ein Eingabeaufforderungsfenster.
  4. Fügen Sie den Befehl aus dem Text-Editor in das Eingabeaufforderungsfenster ein, und führen Sie den Befehl aus.
curl -i -X POST https://your-text-analytics-endpoint-here/text/analytics/v3.2-preview.1/entities/health/jobs \
-H "Content-Type: application/json" \
-H "Ocp-Apim-Subscription-Key: your-text-analytics-key-here" \
-d '{ documents: [{ id: "1", language:"en", text: "Subject was administered 100mg remdesivir intravenously over a period of 120 min"}]}'

Rufen Sie operation-location aus dem Antwortheader ab. Der Wert sieht etwa wie die folgende URL aus:

https://your-resource.cognitiveservices.azure.com/text/analytics/v3.2-preview.1/entities/health/jobs/12345678-1234-1234-1234-12345678

Verwenden Sie den folgenden cURL-Befehl, um die Ergebnisse der Anforderung abzurufen. Ersetzen Sie my-job-id durch den numerischen ID-Wert, den Sie aus dem vorherigen operation-location-Antwortheader erhalten haben:

curl -X GET  https://your-text-analytics-endpoint-here/text/analytics/v3.2-preview.1/entities/health/jobs/my-job-id \
-H "Content-Type: application/json" \
-H "Ocp-Apim-Subscription-Key: your-text-analytics-key-here"

JSON-Antwort

Die JSON-Antwort ist für v3.1 und v3.2-preview.1 identisch.

{
   "jobId":"12345678-1234-1234-1234-12345678",
   "lastUpdateDateTime":"2021-08-02T21:32:43Z",
   "createdDateTime":"2021-08-02T21:32:04Z",
   "expirationDateTime":"2021-08-03T21:32:04Z",
   "status":"succeeded",
   "errors":[
      
   ],
   "results":{
      "documents":[
         {
            "id":"1",
            "entities":[
               {
                  "offset":25,
                  "length":5,
                  "text":"100mg",
                  "category":"Dosage",
                  "confidenceScore":1.0
               },
               {
                  "offset":31,
                  "length":10,
                  "text":"remdesivir",
                  "category":"MedicationName",
                  "confidenceScore":1.0,
                  "name":"remdesivir",
                  "links":[
                     {
                        "dataSource":"UMLS",
                        "id":"C4726677"
                     },
                     {
                        "dataSource":"DRUGBANK",
                        "id":"DB14761"
                     },
                     {
                        "dataSource":"GS",
                        "id":"6192"
                     },
                     {
                        "dataSource":"MEDCIN",
                        "id":"398132"
                     },
                     {
                        "dataSource":"MMSL",
                        "id":"d09540"
                     },
                     {
                        "dataSource":"MSH",
                        "id":"C000606551"
                     },
                     {
                        "dataSource":"MTHSPL",
                        "id":"3QKI37EEHE"
                     },
                     {
                        "dataSource":"NCI",
                        "id":"C152185"
                     },
                     {
                        "dataSource":"NCI_FDA",
                        "id":"3QKI37EEHE"
                     },
                     {
                        "dataSource":"NDDF",
                        "id":"018308"
                     },
                     {
                        "dataSource":"RXNORM",
                        "id":"2284718"
                     },
                     {
                        "dataSource":"SNOMEDCT_US",
                        "id":"870592005"
                     },
                     {
                        "dataSource":"VANDF",
                        "id":"4039395"
                     }
                  ]
               },
               {
                  "offset":42,
                  "length":13,
                  "text":"intravenously",
                  "category":"MedicationRoute",
                  "confidenceScore":0.99
               },
               {
                  "offset":73,
                  "length":7,
                  "text":"120 min",
                  "category":"Time",
                  "confidenceScore":0.98
               }
            ],
            "relations":[
               {
                  "relationType":"DosageOfMedication",
                  "entities":[
                     {
                        "ref":"#/results/documents/0/entities/0",
                        "role":"Dosage"
                     },
                     {
                        "ref":"#/results/documents/0/entities/1",
                        "role":"Medication"
                     }
                  ]
               },
               {
                  "relationType":"RouteOfMedication",
                  "entities":[
                     {
                        "ref":"#/results/documents/0/entities/1",
                        "role":"Medication"
                     },
                     {
                        "ref":"#/results/documents/0/entities/2",
                        "role":"Route"
                     }
                  ]
               },
               {
                  "relationType":"TimeOfMedication",
                  "entities":[
                     {
                        "ref":"#/results/documents/0/entities/1",
                        "role":"Medication"
                     },
                     {
                        "ref":"#/results/documents/0/entities/3",
                        "role":"Time"
                     }
                  ]
               }
            ],
            "warnings":[
               
            ]
         }
      ],
      "errors":[
         
      ],
      "modelVersion":"2021-05-15"
   }
}

Textzusammenfassung

curl -i -X POST https://your-text-analytics-endpoint-here/text/analytics/v3.2-preview.1/analyze \
-H "Content-Type: application/json" \
-H "Ocp-Apim-Subscription-Key: your-text-analytics-key-here" \
-d \
' 
{
  "analysisInput": {
    "documents": [
      {
        "language": "en",
        "id": "1",
        "text": "At Microsoft, we have been on a quest to advance AI beyond existing techniques, by taking a more holistic, human-centric approach to learning and understanding. As Chief Technology Officer of Azure AI Cognitive Services, I have been working with a team of amazing scientists and engineers to turn this quest into a reality. In my role, I enjoy a unique perspective in viewing the relationship among three attributes of human cognition: monolingual text (X), audio or visual sensory signals, (Y) and multilingual (Z). At the intersection of all three, there’s magic—what we call XYZ-code as illustrated in Figure 1—a joint representation to create more powerful AI that can speak, hear, see, and understand humans better. We believe XYZ-code will enable us to fulfill our long-term vision: cross-domain transfer learning, spanning modalities and languages. The goal is to have pretrained models that can jointly learn representations to support a broad range of downstream AI tasks, much in the way humans do today. Over the past five years, we have achieved human performance on benchmarks in conversational speech recognition, machine translation, conversational question answering, machine reading comprehension, and image captioning. These five breakthroughs provided us with strong signals toward our more ambitious aspiration to produce a leap in AI capabilities, achieving multisensory and multilingual learning that is closer in line with how humans learn and understand. I believe the joint XYZ-code is a foundational component of this aspiration, if grounded with external knowledge sources in the downstream AI tasks."
      }
    ]
  },
  "tasks": {
    "extractiveSummarizationTasks": [
      {
        "parameters": {
          "model-version": "latest",
          "sentenceCount": 3,
          "sortBy": "Offset"
        }
      }
    ]
  }
}
'

Rufen Sie operation-location aus dem Antwortheader ab. Der Wert sieht etwa wie die folgende URL aus:

https://your-resource.cognitiveservices.azure.com/text/analytics/v3.2-preview.1/analyze/jobs/12345678-1234-1234-1234-12345678

Verwenden Sie den folgenden cURL-Befehl, um die Ergebnisse der Anforderung abzurufen. Ersetzen Sie my-job-id durch den numerischen ID-Wert, den Sie aus dem vorherigen operation-location-Antwortheader erhalten haben:

curl -X GET    https://your-text-analytics-endpoint-here/text/analytics/v3.2-preview.1/analyze/jobs/my-job-id \
-H "Content-Type: application/json" \
-H "Ocp-Apim-Subscription-Key: your-text-analytics-key-here"

Ausgabe

{
   "jobId":"da3a2f68-eb90-4410-b28b-76960d010ec6",
   "lastUpdateDateTime":"2021-08-24T19:15:47Z",
   "createdDateTime":"2021-08-24T19:15:28Z",
   "expirationDateTime":"2021-08-25T19:15:28Z",
   "status":"succeeded",
   "errors":[
      
   ],
   "displayName":"NA",
   "tasks":{
      "completed":1,
      "failed":0,
      "inProgress":0,
      "total":1,
      "extractiveSummarizationTasks":[
         {
            "lastUpdateDateTime":"2021-08-24T19:15:48.0011189Z",
            "taskName":"ExtractiveSummarization_latest",
            "state":"succeeded",
            "results":{
               "documents":[
                  {
                     "id":"1",
                     "sentences":[
                        {
                           "text":"At Microsoft, we have been on a quest to advance AI beyond existing techniques, by taking a more holistic, human-centric approach to learning and understanding.",
                           "rankScore":1.0,
                           "offset":0,
                           "length":160
                        },
                        {
                           "text":"In my role, I enjoy a unique perspective in viewing the relationship among three attributes of human cognition: monolingual text (X), audio or visual sensory signals, (Y) and multilingual (Z).",
                           "rankScore":0.9582327572675664,
                           "offset":324,
                           "length":192
                        },
                        {
                           "text":"At the intersection of all three, there’s magic—what we call XYZ-code as illustrated in Figure 1—a joint representation to create more powerful AI that can speak, hear, see, and understand humans better.",
                           "rankScore":0.9294747193132348,
                           "offset":517,
                           "length":203
                        }
                     ],
                     "warnings":[
                        
                     ]
                  }
               ],
               "errors":[
                  
               ],
               "modelVersion":"2021-08-01"
            }
         }
      ]
   }
}

Bereinigen von Ressourcen

Wenn Sie ein Cognitive Services-Abonnement bereinigen und entfernen möchten, können Sie die Ressource oder die Ressourcengruppe löschen. Wenn Sie die Ressourcengruppe löschen, werden auch alle anderen Ressourcen gelöscht, die ihr zugeordnet sind.

Nächste Schritte