Bibliothèque de client Azure Cognitive Services Analyse de texte pour .NET - version 5.3.0

  • Article

Analyse de texte fait partie d’Azure Cognitive Service for Language, un service cloud qui fournit des fonctionnalités de traitement en langage naturel (NLP) pour la compréhension et l’analyse du texte. Cette bibliothèque cliente offre les fonctionnalités suivantes :

  • Détection de la langue
  • analyse de sentiments
  • Extraction d’expressions clés
  • La reconnaissance d’entités nommées (NER)
  • Reconnaissance d’entité d’informations d’identification personnelles (PII)
  • Liaison d’entités
  • Analyse de texte pour l’intégrité
  • Reconnaissance d’entités nommées personnalisées (NER personnalisé)
  • Classification de texte personnalisée
  • Résumé de texte extractif
  • Résumé de texte abstrait

| Code sourcePackage (NuGet) | Documentation de référence sur les | API | Documentation produitÉchantillons

Prise en main

Installer le package

Installez la bibliothèque cliente Azure Analyse de texte pour .NET avec NuGet :

dotnet add package Azure.AI.TextAnalytics

Ce tableau montre la relation entre les versions du kit de développement logiciel (SDK) et les versions d’API prises en charge du service :

Notez qu’il 5.2.0 s’agit de la première version stable de la bibliothèque cliente qui cible les API Azure Cognitive Service for Language, qui inclut les fonctionnalités existantes d’analyse de texte et de traitement en langage naturel disponibles dans la bibliothèque cliente Analyse de texte. En outre, l’API de service est passée de la sémantique au contrôle de version basé sur la date.

Version du SDK Version d’API prise en charge du service
5.3.X 3.0, 3.1, 2022-05-01, 2023-04-01 (par défaut)
5.2.X 3.0, 3.1, 2022-05-01 (par défaut)
5.1.X 3.0, 3.1 (par défaut)
5.0.X 3.0
1.0.X 3.0

Prérequis

  • Un abonnement Azure.
  • Une ressource de service Cognitive Services ou Language existante.

Créer une ressource Cognitive Services ou une ressource de service Language

Azure Cognitive Service for Language prend en charge l’accès multiservices et à service unique. Créez une ressource Cognitive Services si vous envisagez d’accéder à plusieurs services cognitifs sous un seul point de terminaison et une clé API. Pour accéder aux fonctionnalités du service Language uniquement, créez une ressource de service Language à la place.

Vous pouvez créer une ressource via le Portail Azure ou, sinon, vous pouvez suivre les étapes de ce document pour la créer à l’aide d’Azure CLI.

Authentifier le client

L’interaction avec le service à l’aide de la bibliothèque cliente commence par la création d’un instance de la classe TextAnalyticsClient. Vous aurez besoin d’un point de terminaison et d’une clé API ou TokenCredential pour instancier un objet client. Pour plus d’informations sur l’authentification auprès de Cognitive Services, consultez Authentifier les demandes auprès d’Azure Cognitive Services.

Obtenir une clé API

Vous pouvez obtenir le endpoint et API key à partir de la ressource Cognitive Services ou des informations de ressource de service de langage dans le portail Azure.

Vous pouvez également utiliser l’extrait de code Azure CLI ci-dessous pour obtenir la clé API à partir de la ressource du service Language.

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

Créer un à l’aide TextAnalyticsClient d’informations d’identification de clé API

Une fois que vous avez la valeur de la clé API, créez un AzureKeyCredential. Cela vous permettra de mettre à jour la clé API sans créer de client.

Avec la valeur du point de terminaison et d’un AzureKeyCredential, vous pouvez créer le TextAnalyticsClient :

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

Créer un TextAnalyticsClient avec des informations d’identification Azure Active Directory

L’authentification par clé API cliente est utilisée dans la plupart des exemples de ce guide de prise en main, mais vous pouvez également vous authentifier auprès d’Azure Active Directory à l’aide de la bibliothèque Azure Identity. Notez que les points de terminaison régionaux ne prennent pas en charge l’authentification AAD. Créez un sous-domaine personnalisé pour votre ressource afin d’utiliser ce type d’authentification.

Pour utiliser le fournisseur DefaultAzureCredential indiqué ci-dessous ou d’autres fournisseurs d’informations d’identification fournis avec le Kit de développement logiciel (SDK) Azure, installez le package Azure.Identity :

dotnet add package Azure.Identity

Vous devez également inscrire une nouvelle application AAD et accorder l’accès au service Language en attribuant le "Cognitive Services User" rôle à votre principal de service.

Définissez les valeurs de l’ID client, de l’ID de locataire et de la clé secrète client de l’application AAD en tant que variables d’environnement : AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET.

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

Concepts clés

TextAnalyticsClient

A TextAnalyticsClient est l’interface principale pour les développeurs qui utilisent la bibliothèque cliente Analyse de texte. Il fournit des opérations synchrones et asynchrones pour accéder à une utilisation spécifique de l’analyse de texte, comme la détection de langue ou l’extraction d’expressions clés.

Entrée

Un document est une unité d’entrée unique à analyser par les modèles prédictifs dans le service Language. Les opérations sur TextAnalyticsClient peuvent nécessiter l’analyse d’un seul document ou d’une collection de documents en tant que lot. Pour connaître les limites de longueur du document, la taille maximale des lots et l’encodage de texte pris en charge, consultez ici.

Opération sur plusieurs documents

Pour chaque opération prise en charge, TextAnalyticsClient fournit une méthode qui accepte un lot de documents sous forme de chaînes ou un lot d’objets TextDocumentInput ou .DetectLanguageInput Ces méthodes permettent aux appelants de donner à chaque document un ID unique, d’indiquer que les documents du lot sont écrits dans différentes langues ou de fournir un indicateur de pays sur la langue du document.

Note: Il est recommandé d’utiliser les méthodes de traitement par lots lorsque vous travaillez sur des environnements de production, car elles vous permettent d’envoyer une requête avec plusieurs documents. C’est plus performant que l’envoi d’une requête pour chaque document.

Valeur retournée

Les valeurs de retour, telles que AnalyzeSentimentResult, sont le résultat d’une opération de Analyse de texte, contenant une prédiction ou des prédictions relatives à un seul document. La valeur de retour d’une opération peut également inclure éventuellement des informations sur le document et la façon dont il a été traité.

Valeur de retour Collection

Une collection de valeurs de retour, telle que AnalyzeSentimentResultCollection, est une collection de résultats d’opération, où chacun correspond à l’un des documents fournis dans le lot d’entrée. Un document et son résultat auront le même index dans les collections d’entrée et de résultat. La valeur de retour contient également une HasError propriété qui permet d’identifier si une opération exécutée a réussi ou échoué pour le document donné. Il peut éventuellement inclure des informations sur le lot de documents et la façon dont il a été traité.

opérations Long-Running

Pour les documents volumineux qui prennent beaucoup de temps, ces opérations sont implémentées comme des opérations de longue durée. Les opérations de longue durée se composent d’une demande initiale envoyée au service pour démarrer une opération, suivie d’un interrogation du service à intervalles réguliers pour déterminer si l’opération s’est terminée ou échouée, et si elle a réussi, pour obtenir le résultat.

Pour les opérations de longue durée dans le Kit de développement logiciel (SDK) Azure, le client expose une Start<operation-name> méthode qui retourne un Operation<T> ou un PageableOperation<T>. Vous pouvez utiliser la méthode WaitForCompletionAsync() d’extension pour attendre que l’opération se termine et obtenir son résultat. Un exemple d’extrait de code est fourni pour illustrer l’utilisation d’opérations de longue durée ci-dessous.

Sécurité des threads

Nous garantissons que toutes les méthodes de instance client sont sécurisées pour les threads et indépendantes les unes des autres (recommandations). Cela garantit que la recommandation de réutilisation des instances clientes est toujours sécurisée, même entre les threads.

Concepts supplémentaires

Options clientes | Accès à la réponse | Gestion des défaillances | Diagnostics | Moqueur | Durée de vie du client

Exemples

La section suivante fournit plusieurs extraits de code à l’aide de ce client qui a été créé ci-dessus et décrit les fonctionnalités main présentes dans cette bibliothèque cliente. Bien que la plupart des extraits de code ci-dessous utilisent des appels de service synchrones, gardez à l’esprit que le Azure.AI.TextAnalytics package prend en charge les API synchrones et asynchrones.

Exemples de synchronisation

Exemples asynchrones

Détecter la langue

Exécutez un modèle prédictif pour déterminer la langue dans laquelle le document transmis ou le lot de documents sont écrits.

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

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

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

Pour obtenir des exemples sur l’utilisation de l’option DetectLanguageBatch recommandée en production, consultez ici.

Reportez-vous à la documentation du service pour une présentation conceptuelle de la détection de langue.

Analyser les sentiments

Exécutez un modèle prédictif pour déterminer le sentiment positif, négatif, neutre ou mixte contenu dans le document transmis ou le lot de documents.

string document =
    "I had the best day of my life. I decided to go sky-diving and it made me appreciate my whole life so"
    + "much more. I developed a deep-connection with my instructor as well, and I feel as if I've made a"
    + "life-long friend in her.";

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

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

Pour obtenir des exemples sur l’utilisation de l’option AnalyzeSentimentBatch recommandée en production, consultez ici.

Pour obtenir des informations plus précises sur les opinions relatives aux cibles d’un produit/service, également appelée Analyse des sentiments basée sur les aspects dans le traitement en langage naturel (NLP), consultez un exemple sur l’analyse des sentiments avec exploration d’opinions ici.

Reportez-vous à la documentation du service pour une discussion conceptuelle sur l’analyse des sentiments.

Extraire les phrases clés

Exécutez un modèle pour identifier une collection d’expressions significatives trouvées dans le document transmis ou le lot de documents.

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

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

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

Pour obtenir des exemples sur l’utilisation de l’option ExtractKeyPhrasesBatch recommandée en production, consultez ici.

Reportez-vous à la documentation du service pour une présentation conceptuelle de l’extraction d’expressions clés.

Reconnaître les entités nommées

Exécutez un modèle prédictif pour identifier une collection d’entités nommées dans le document transmis ou le lot de documents et catégoriser ces entités en catégories telles que personne, emplacement ou organization. Pour plus d’informations sur les catégories disponibles, consultez Analyse de texte catégories d’entités nommées.

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

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

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

Pour obtenir des exemples sur l’utilisation de l’option RecognizeEntitiesBatch recommandée en production, consultez ici.

Reportez-vous à la documentation du service pour une présentation conceptuelle de la reconnaissance d’entité nommée.

Reconnaître les entités PII

Exécutez un modèle prédictif pour identifier une collection d’entités contenant des informations d’identification personnelle trouvées dans le document transmis ou le lot de documents, et catégorisez ces entités en catégories telles que le numéro de sécurité sociale américain, le numéro de permis de conduire ou le numéro de crédit carte.

string document =
    "Parker Doe has repaid all of their loans as of 2020-04-25. Their SSN is 859-98-0987. To contact them,"
    + " use their phone number 800-102-1100. They are originally from Brazil and have document ID number"
    + " 998.214.865-68.";

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

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

Pour obtenir des exemples sur l’utilisation de l’option RecognizePiiEntitiesBatch recommandée en production, consultez ici.

Reportez-vous à la documentation du service pour connaître les types d’entités PII pris en charge.

Reconnaître les entités liées

Exécutez un modèle prédictif pour identifier une collection d’entités trouvées dans le document ou le lot de documents transmis, et incluez des informations liant les entités à leurs entrées correspondantes dans un base de connaissances bien connu.

string document =
    "Microsoft was founded by Bill Gates with some friends he met at Harvard. One of his friends, Steve"
    + " Ballmer, eventually became CEO after Bill Gates as well. Steve Ballmer eventually stepped down as"
    + " CEO of Microsoft, and was succeeded by Satya Nadella. Microsoft originally moved its headquarters"
    + " to Bellevue, Washington in Januaray 1979, but is now headquartered in Redmond.";

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

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

Pour obtenir des exemples sur l’utilisation de l’option RecognizeLinkedEntitiesBatch recommandée en production, consultez ici.

Reportez-vous à la documentation du service pour une discussion conceptuelle sur la liaison d’entités.

Détecter le langage de manière asynchrone

Exécutez un modèle prédictif pour déterminer la langue dans laquelle le document transmis ou le lot de documents sont écrits.

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

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

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

Reconnaître les entités nommées de manière asynchrone

Exécutez un modèle prédictif pour identifier une collection d’entités nommées dans le document transmis ou le lot de documents et catégoriser ces entités en catégories telles que personne, emplacement ou organization. Pour plus d’informations sur les catégories disponibles, consultez Analyse de texte catégories d’entités nommées.

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

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

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

Analyser les entités de soins de santé de manière asynchrone

L’Analyse de texte pour la santé est un service en conteneur qui extrait et étiquette les informations médicales pertinentes à partir de textes non structurés, tels que les notes du médecin, les bilans de sortie d’hospitalisation, les documents cliniques et les enregistrements d’intégrité électroniques. Pour plus d’informations, consultez Guide pratique pour utiliser Analyse de texte pour l’intégrité.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            Console.WriteLine();
        }

        Console.WriteLine();
    }
}

Exécuter plusieurs actions de manière asynchrone

Cette fonctionnalité permet d’exécuter plusieurs actions dans un ou plusieurs documents. Les actions sont les suivantes :

  • Reconnaissance des entités nommées
  • Reconnaissance des entités PII
  • Reconnaissance d’entités liées
  • Extraction d’expressions clés
  • Analyse des sentiments
  • Reconnaissance des entités de soins de santé (voir l’exemple ici)
  • Reconnaissance d’entités nommées personnalisées (voir l’exemple ici)
  • Classification d’étiquette unique personnalisée (voir l’exemple ici)
  • Classification multi-étiquettes personnalisée (voir l’exemple ici)
    string documentA =
        "We love this trail and make the trip every year. The views are breathtaking and well worth the hike!"
        + " Yesterday was foggy though, so we missed the spectacular views. We tried again today and it was"
        + " amazing. Everyone in my family liked the trail although it was too challenging for the less"
        + " athletic among us.";

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

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

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

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

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

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

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

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

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

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

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

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

Dépannage

Général

Lorsque vous interagissez avec Cognitive Services for Language à l’aide du Kit de développement logiciel (SDK) .NET Analyse de texte, les erreurs retournées par le service Language correspondent aux mêmes codes de status HTTP retournés pour les demandes d’API REST.

Par exemple, si vous envoyez un lot d’entrées de document texte contenant des ID de document en double, une 400 erreur est retournée, indiquant « Demande incorrecte ».

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

Vous remarquerez que des informations supplémentaires sont enregistrées, telles que l’ID de demande client de l’opération.

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

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

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

Configuration de la journalisation de la console

Le moyen le plus simple de voir les journaux consiste à activer la journalisation de la console. Pour créer un écouteur de journal du Kit de développement logiciel (SDK) Azure qui génère des messages dans la console, utilisez la méthode AzureEventSourceListener.CreateConsoleLogger.

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

Pour en savoir plus sur les autres mécanismes de journalisation , consultez ici.

Étapes suivantes

Des exemples montrant comment utiliser cette bibliothèque cliente sont disponibles dans ce dépôt GitHub. Des exemples sont fournis pour chaque zone fonctionnelle main, et pour chaque zone, des exemples sont fournis pour l’analyse d’un document unique et d’une collection de documents en mode synchrone et asynchrone.

Exemples avancés

Contribution

Consultez le CONTRIBUTING.md pour plus d’informations sur la création, le test et la contribution à cette bibliothèque.

Ce projet accepte les contributions et les suggestions. La plupart des contributions vous demandent d’accepter un contrat de licence de contribution (CLA) déclarant que vous avez le droit de nous accorder, et que vous nous accordez réellement, les droits d’utilisation de votre contribution. Pour plus d’informations, consultez cla.microsoft.com.

Quand vous envoyez une demande de tirage (pull request), un bot CLA détermine automatiquement si vous devez fournir un contrat CLA et agrémenter la demande de tirage de façon appropriée (par exemple, avec une étiquette ou un commentaire). Suivez simplement les instructions fournies par le bot. Vous ne devez effectuer cette opération qu’une seule fois sur tous les dépôts utilisant notre contrat CLA.

Ce projet a adopté le Code de conduite Open Source de Microsoft. Pour plus d’informations, consultez les Questions fréquentes (FAQ) sur le code de conduite ou envoyez vos questions ou vos commentaires à opencode@microsoft.com.

Impressions