Bibliothèque cliente Analyse de texte Azure pour JavaScript - version 6.0.0-beta.1

Article
04/05/2023

Azure Cognitive Service for Language est un service cloud qui fournit un traitement avancé en langage naturel sur du texte brut et inclut les principales fonctionnalités suivantes :

Note: Ce SDK cible l’API Azure Cognitive Service for Language version 2022-04-01-preview.

Détection de la langue
Analyse des sentiments
Extraction d’expressions clés
Reconnaissance d’entité nommée
Reconnaissance des informations d’identification personnelle
Liaison d’entités
Analyse des soins de santé
Résumé extractif
Reconnaissance d’entité personnalisée
Classification de documents personnalisée
Prise en charge de plusieurs actions par document

Utilisez la bibliothèque cliente pour :

Détecter le texte d’entrée de langue dans lequel il est écrit.
Déterminez ce que les clients pensent de votre marque ou de votre sujet en analysant le texte brut à la recherche d’indices sur les sentiments positifs ou négatifs.
Extrayez automatiquement des phrases clés pour identifier rapidement les points principaux.
Identifiez et classez les entités dans votre texte en tant que personnes, lieux, organisations, date/heure, quantités, pourcentages, devises, spécifiques aux soins de santé, etc.
Effectuez plusieurs des tâches ci-dessus à la fois.

Liens clés :

Prise en main

Environnements actuellement pris en charge

Versions LTS de Node.js
Dernières versions de Safari, Chrome, Edge et Firefox.

Pour plus d’informations, consultez notre politique de support .

Prérequis

Un abonnement Azure.
Une ressource Cognitive Services ou Language existante. Si vous devez créer la ressource, vous pouvez utiliser le portail Azure ou Azure CLI.

Si vous utilisez Azure CLI, remplacez <your-resource-group-name> et <your-resource-name> par vos propres noms uniques :

az cognitiveservices account create --kind TextAnalytics --resource-group <your-resource-group-name> --name <your-resource-name> --sku <your-sku-name> --location <your-location>

Installez le package `@azure/ai-text-analytics`

Installez la bibliothèque cliente Analyse de texte Azure pour JavaScript avec npm:

npm install @azure/ai-text-analytics

Créez et authentifiez un`TextAnalysisClient`

Pour créer un objet client afin d’accéder à l’API language, vous aurez besoin du endpoint de votre ressource Language et d’un credential. Le client Analyse de texte peut utiliser les informations d’identification Azure Active Directory ou une clé API pour s’authentifier.

Vous pouvez trouver le point de terminaison de votre ressource Language dans le portail Azure ou à l’aide de l’extrait de code Azure CLI ci-dessous :

az cognitiveservices account show --name <your-resource-name> --resource-group <your-resource-group-name> --query "properties.endpoint"

Utilisation d’une clé API

Utilisez le portail Azure pour accéder à votre ressource Language et récupérer une clé API, ou utilisez l’extrait de code Azure CLI ci-dessous :

Note: Parfois, la clé API est appelée « clé d’abonnement » ou « clé API d’abonnement ».

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

Une fois que vous disposez d’une clé API et d’un point de terminaison, vous pouvez utiliser la AzureKeyCredential classe pour authentifier le client comme suit :

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

const client = new TextAnalysisClient("<endpoint>", new AzureKeyCredential("<API key>"));

Utilisation d’informations d’identification Azure Active Directory

L’authentification par clé API cliente est utilisée dans la plupart des exemples, mais vous pouvez également vous authentifier auprès d’Azure Active Directory à l’aide de la bibliothèque Azure Identity. 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 @azure/identity package :

npm install @azure/identity

Vous devez également inscrire une nouvelle application AAD et accorder l’accès à Language en attribuant le "Cognitive Services User" rôle à votre principal de service (remarque : d’autres rôles tels que "Owner" n’accordent pas les autorisations nécessaires, seuls "Cognitive Services User" suffisent pour exécuter les exemples et l’exemple de code).

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.

const { TextAnalysisClient } = require("@azure/ai-text-analytics");
const { DefaultAzureCredential } = require("@azure/identity");

const client = new TextAnalysisClient("<endpoint>", new DefaultAzureCredential());

Concepts clés

TextAnalysisClient

TextAnalysisClient est l’interface principale pour les développeurs qui utilisent la bibliothèque cliente Analyse de texte. Explorez les méthodes de cet objet client pour comprendre les différentes fonctionnalités du service Language auquel vous pouvez accéder.

Entrée

Un document représente une seule unité d’entrée à analyser par les modèles prédictifs dans le service Language. Les opérations sur TextAnalysisClient prennent une collection d’entrées à analyser en tant que lot. Les méthodes d’opération ont des surcharges qui permettent aux entrées d’être représentées sous forme de chaînes ou d’objets avec des métadonnées attachées.

Par exemple, chaque document peut être passé sous forme de chaîne dans un tableau, par exemple.

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

ou, si vous souhaitez passer un document id par élément ou languagecountryHint/, ils peuvent être donnés sous forme de liste de ou DetectLanguageInput en fonction de TextDocumentInput l’opération ;

const textDocumentInputs = [
  { id: "1", language: "en", text: "I hated the movie. It was so slow!" },
  { id: "2", language: "en", text: "The movie made it into my top ten favorites." },
  { id: "3", language: "en", text: "What a great movie!" },
];

Consultez les limitations du service pour l’entrée, notamment les limites de longueur du document, la taille maximale du lot et les encodages de texte pris en charge.

Valeur renvoyée

La valeur de retour correspondant à un seul document est un résultat réussi ou un objet d’erreur. Chaque TextAnalysisClient méthode retourne un tableau hétérogène de résultats et d’erreurs qui correspondent aux entrées par index. Une entrée de texte et son résultat auront le même index dans les collections d’entrée et de résultats.

Un résultat, tel que SentimentAnalysisResult, est le résultat d’une opération Language, qui contient une prédiction ou des prédictions sur une entrée de texte unique. Le type de résultat d’une opération peut également inclure des informations sur le document d’entrée et la façon dont il a été traité.

L’objet error, , TextAnalysisErrorResultindique que le service a rencontré une erreur lors du traitement du document et contient des informations sur l’erreur.

Gestion des erreurs de document

Dans la collection retournée par une opération, les erreurs sont distinguées des réponses réussies par la présence de la error propriété, qui contient l’objet interne TextAnalysisError si une erreur a été rencontrée. Pour les objets de résultat réussis, cette propriété est toujoursundefined .

Par exemple, pour filtrer toutes les erreurs, vous pouvez utiliser les éléments suivants filter:

const results = await client.analyze("SentimentAnalysis", documents);
const onlySuccessful = results.filter((result) => result.error === undefined);

Remarque : les utilisateurs TypeScript peuvent bénéficier d’une meilleure vérification de type des objets de résultat et d’erreur si compilerOptions.strictNullChecks est défini sur true dans la tsconfig.json configuration. Par exemple :

const [result] = await client.analyze("SentimentAnalysis", ["Hello world!"]);

if (result.error !== undefined) {
  // In this if block, TypeScript will be sure that the type of `result` is
  // `TextAnalysisError` if compilerOptions.strictNullChecks is enabled in
  // the tsconfig.json

  console.log(result.error);
}

Exemples

Analyse des sentiments

Analysez le sentiment de texte pour déterminer s’il est positif, négatif, neutre ou mixte, y compris l’analyse des sentiments par phrase et les scores de confiance.

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

const client = new TextAnalysisClient("<endpoint>", new AzureKeyCredential("<API key>"));

const documents = [
  "I did not like the restaurant. The food was too spicy.",
  "The restaurant was decorated beautifully. The atmosphere was unlike any other restaurant I've been to.",
  "The food was yummy. :)",
];

async function main() {
  const results = await client.analyze("SentimentAnalysis", documents);

  for (const result of results) {
    if (result.error === undefined) {
      console.log("Overall sentiment:", result.sentiment);
      console.log("Scores:", result.confidenceScores);
    } else {
      console.error("Encountered an error:", result.error);
    }
  }
}

main();

Pour obtenir des informations plus précises sur les opinions relatives aux aspects 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.

Reconnaissance d’entité

Reconnaître et classer les entités dans le texte en tant que personnes, lieux, organisations, dates/heures, quantités, devises, etc.

Le paramètre language est facultatif. S’il n’est pas spécifié, le modèle anglais par défaut est utilisé.

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

const client = new TextAnalysisClient("<endpoint>", new AzureKeyCredential("<API key>"));

const documents = [
  "Microsoft was founded by Bill Gates and Paul Allen.",
  "Redmond is a city in King County, Washington, United States, located 15 miles east of Seattle.",
  "Jeff bought three dozen eggs because there was a 50% discount.",
];

async function main() {
  const results = await client.analyze("EntityRecognition", documents, "en");

  for (const result of results) {
    if (result.error === undefined) {
      console.log(" -- Recognized 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);
    }
  }
}

main();

Reconnaissance d’entité PII

Il existe une action distincte pour reconnaître les informations d’identification personnelle (PII) dans du texte, comme les numéros de sécurité sociale, les informations de compte bancaire, les numéros de carte de crédit, etc. Son utilisation est très similaire à la reconnaissance d’entité standard ci-dessus :

const { TextAnalysisClient, AzureKeyCredential } = require("@azure/ai-text-analytics");
const client = new TextAnalysisClient("<endpoint>", new AzureKeyCredential("<API key>"));
const documents = [
  "The employee's SSN is 555-55-5555.",
  "The employee's phone number is (555) 555-5555.",
];
async function main() {
  const results = await client.analyze("PiiEntityRecognition", documents, "en");
  for (const result of results) {
    if (result.error === undefined) {
      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);
    }
  }
}
main();

Liaison d’entités

Une entité « Liée » est une entité qui existe dans un base de connaissances (par exemple, Wikipédia). L’action EntityLinking peut lever l’ambiguïté des entités en déterminant quelle entrée dans un base de connaissances elles sont susceptibles de faire référence (par exemple, dans un morceau de texte, le mot « Mars » fait-il référence à la planète, ou au dieu romain de la guerre). Les entités liées contiennent des URL associées à l’base de connaissances qui fournit la définition de l’entité.

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

const client = new TextAnalysisClient("<endpoint>", new AzureKeyCredential("<API key>"));

const documents = [
  "Microsoft was founded by Bill Gates and Paul Allen.",
  "Easter Island, a Chilean territory, is a remote volcanic island in Polynesia.",
  "I use Azure Functions to develop my product.",
];

async function main() {
  const results = await client.analyze("EntityLinking", documents, "en");

  for (const result of results) {
    if (result.error === undefined) {
      console.log(" -- Recognized linked entities for input", result.id, "--");
      for (const entity of result.entities) {
        console.log(entity.name, "(URL:", entity.url, ", Source:", entity.dataSource, ")");
        for (const match of entity.matches) {
          console.log(
            "  Occurrence:",
            '"' + match.text + '"',
            "(Score:",
            match.confidenceScore,
            ")"
          );
        }
      }
    } else {
      console.error("Encountered an error:", result.error);
    }
  }
}

main();

Extraction d’expressions clés

L’extraction d’expressions clés identifie les principaux points de discussion d’un document. Par exemple, si nous considérons le texte d’entrée « la nourriture était délicieuse et le personnel était merveilleux », le service retourne « nourriture » et « personnel merveilleux ».

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

const client = new TextAnalysisClient("<endpoint>", new AzureKeyCredential("<API key>"));

const documents = [
  "Redmond is a city in King County, Washington, United States, located 15 miles east of Seattle.",
  "I need to take my cat to the veterinarian.",
  "I will travel to South America in the summer.",
];

async function main() {
  const results = await client.analyze("KeyPhraseExtraction", documents, "en");

  for (const result of results) {
    if (result.error === undefined) {
      console.log(" -- Extracted key phrases for input", result.id, "--");
      console.log(result.keyPhrases);
    } else {
      console.error("Encountered an error:", result.error);
    }
  }
}

main();

Détection de la langue

Déterminer la langue d’un morceau de texte.

Le countryHint paramètre est facultatif, mais peut aider le service à fournir une sortie correcte si le pays d’origine est connu. S’il est fourni, il doit être défini sur un code de pays à deux lettres Iso-3166 Alpha-2 (tel que « nous » pour le États-Unis ou « jp » pour le Japon) ou sur la valeur "none". Si le paramètre n’est pas fourni, le modèle par défaut "us" (États-Unis) est utilisé. Si vous ne connaissez pas le pays d’origine du document, le paramètre "none" doit être utilisé et le service Language applique un modèle qui est paramétré pour un pays d’origine inconnu.

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

const client = new TextAnalysisClient("<endpoint>", new AzureKeyCredential("<API key>"));

const documents = [
  "This is written in English.",
  "Il documento scritto in italiano.",
  "Dies ist in deutscher Sprache verfasst.",
];

async function main() {
  const results = await client.analyze("LanguageDetection", documents, "none");

  for (const result of results) {
    if (result.error === undefined) {
      const { primaryLanguage } = result;
      console.log(
        "Input #",
        result.id,
        "identified as",
        primaryLanguage.name,
        "( ISO6391:",
        primaryLanguage.iso6391Name,
        ", Score:",
        primaryLanguage.confidenceScore,
        ")"
      );
    } else {
      console.error("Encountered an error:", result.error);
    }
  }
}

main();

Analyse des soins de santé

L’analyse des soins de santé identifie les entités de soins de santé. Par exemple, en fonction du texte d’entrée « Ibuprofène prescrit de 100 mg, pris deux fois par jour », le service retourne « 100 mg » classé comme Dosage, « ibuprofène » comme MedicationName et « deux fois par jour » comme Fréquence.

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

const client = new TextAnalysisClient("<endpoint>", new AzureKeyCredential("<API key>"));

const documents = [
  "Prescribed 100mg ibuprofen, taken twice daily.",
  "Patient does not suffer from high blood pressure.",
];

async function main() {
  const actions: AnalyzeBatchAction[] = [
    {
      kind: "Healthcare",
    },
  ];
  const poller = await client.beginAnalyzeBatch(actions, documents, "en");
  const results = await poller.pollUntilDone();
  for await (const actionResult of results) {
    if (actionResult.kind !== "Healthcare") {
      throw new Error(`Expected a healthcare results but got: ${actionResult.kind}`);
    }
    if (actionResult.error) {
      const { code, message } = actionResult.error;
      throw new Error(`Unexpected error (${code}): ${message}`);
    }
    for (const result of actionResult.results) {
      console.log(`- Document ${result.id}`);
      if (result.error) {
        const { code, message } = result.error;
        throw new Error(`Unexpected error (${code}): ${message}`);
      }
      console.log("\tRecognized Entities:");
      for (const entity of result.entities) {
        console.log(`\t- Entity "${entity.text}" of type ${entity.category}`);
        if (entity.dataSources.length > 0) {
          console.log("\t and it can be referenced in the following data sources:");
          for (const ds of entity.dataSources) {
            console.log(`\t\t- ${ds.name} with Entity ID: ${ds.entityId}`);
          }
        }
      }
    }
  }
}

main();

Résumé extractif

Le résumé extractif identifie les phrases qui résument l’article auquel elles appartiennent.

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

const client = new TextAnalysisClient("<endpoint>", new AzureKeyCredential("<API key>"));

const documents = [
  "Prescribed 100mg ibuprofen, taken twice daily.",
  "Patient does not suffer from high blood pressure.",
];

async function main() {
  const actions: AnalyzeBatchAction[] = [
    {
      kind: "ExtractiveSummarization",
      maxSentenceCount: 2,
    },
  ];
  const poller = await client.beginAnalyzeBatch(actions, documents, "en");
  const results = await poller.pollUntilDone();

  for await (const actionResult of results) {
    if (actionResult.kind !== "ExtractiveSummarization") {
      throw new Error(`Expected extractive summarization results but got: ${actionResult.kind}`);
    }
    if (actionResult.error) {
      const { code, message } = actionResult.error;
      throw new Error(`Unexpected error (${code}): ${message}`);
    }
    for (const result of actionResult.results) {
      console.log(`- Document ${result.id}`);
      if (result.error) {
        const { code, message } = result.error;
        throw new Error(`Unexpected error (${code}): ${message}`);
      }
      console.log("Summary:");
      console.log(result.sentences.map((sentence) => sentence.text).join("\n"));
    }
  }
}

main();

Reconnaissance d’entité personnalisée

Reconnaître et classer les entités dans le texte en tant qu’entités à l’aide de modèles de détection d’entités personnalisés créés à l’aide d’Azure Language Studio.

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

const client = new TextAnalysisClient("<endpoint>", new AzureKeyCredential("<API key>"));

const documents = [
  "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.",
  "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!",
];

async function main() {
  const actions: AnalyzeBatchAction[] = [
    {
      kind: "CustomEntityRecognition",
      deploymentName,
      projectName,
    },
  ];
  const poller = await client.beginAnalyzeBatch(actions, documents, "en");
  for await (const actionResult of results) {
    if (actionResult.kind !== "CustomEntityRecognition") {
      throw new Error(`Expected a CustomEntityRecognition results but got: ${actionResult.kind}`);
    }
    if (actionResult.error) {
      const { code, message } = actionResult.error;
      throw new Error(`Unexpected error (${code}): ${message}`);
    }
    for (const result of actionResult.results) {
      console.log(`- Document ${result.id}`);
      if (result.error) {
        const { code, message } = result.error;
        throw new Error(`Unexpected error (${code}): ${message}`);
      }
      console.log("\tRecognized Entities:");
      for (const entity of result.entities) {
        console.log(`\t- Entity "${entity.text}" of type ${entity.category}`);
      }
    }
  }
}

main();

Classification à étiquette unique personnalisée

Classifiez des documents à l’aide de modèles personnalisés en étiquette unique créés à l’aide d’Azure Language Studio.

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

const client = new TextAnalysisClient("<endpoint>", new AzureKeyCredential("<API key>"));

const documents = [
  "The plot begins with a large group of characters where everyone thinks that the two main ones should be together but foolish things keep them apart. Misunderstandings, miscommunication, and confusion cause a series of humorous situations.",
];

async function main() {
  const actions: AnalyzeBatchAction[] = [
    {
      kind: "CustomSingleLabelClassification",
      deploymentName,
      projectName,
    },
  ];
  const poller = await client.beginAnalyzeBatch(actions, documents, "en");
  const results = await poller.pollUntilDone();

  for await (const actionResult of results) {
    if (actionResult.kind !== "CustomSingleLabelClassification") {
      throw new Error(
        `Expected a CustomSingleLabelClassification results but got: ${actionResult.kind}`
      );
    }
    if (actionResult.error) {
      const { code, message } = actionResult.error;
      throw new Error(`Unexpected error (${code}): ${message}`);
    }
    for (const result of actionResult.results) {
      console.log(`- Document ${result.id}`);
      if (result.error) {
        const { code, message } = result.error;
        throw new Error(`Unexpected error (${code}): ${message}`);
      }
      console.log(`\tClassification: ${result.classification.category}`);
    }
  }
}

main();

Classification multi-étiquettes personnalisée

Classifiez les documents à l’aide de modèles multi-étiquettes personnalisés créés à l’aide d’Azure Language Studio.

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

const client = new TextAnalysisClient("<endpoint>", new AzureKeyCredential("<API key>"));

const documents = [
  "The plot begins with a large group of characters where everyone thinks that the two main ones should be together but foolish things keep them apart. Misunderstandings, miscommunication, and confusion cause a series of humorous situations.",
];

async function main() {
  const actions: AnalyzeBatchAction[] = [
    {
      kind: "CustomMultiLabelClassification",
      deploymentName,
      projectName,
    },
  ];
  const poller = await client.beginAnalyzeBatch(actions, documents, "en");
  const results = await poller.pollUntilDone();

  for await (const actionResult of results) {
    if (actionResult.kind !== "CustomMultiLabelClassification") {
      throw new Error(
        `Expected a CustomMultiLabelClassification results but got: ${actionResult.kind}`
      );
    }
    if (actionResult.error) {
      const { code, message } = actionResult.error;
      throw new Error(`Unexpected error (${code}): ${message}`);
    }
    for (const result of actionResult.results) {
      console.log(`- Document ${result.id}`);
      if (result.error) {
        const { code, message } = result.error;
        throw new Error(`Unexpected error (${code}): ${message}`);
      }
      console.log(`\tClassification:`);
      for (const classification of result.classifications) {
        console.log(`\t\t-category: ${classification.category}`);
      }
    }
  }
}

main();

Traitement par lots d’actions

Applique plusieurs actions sur chaque document d’entrée dans une demande de service.

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

const client = new TextAnalysisClient("<endpoint>", new AzureKeyCredential("<API key>"));

const documents = [
  "Microsoft was founded by Bill Gates and Paul Allen.",
  "The employee's SSN is 555-55-5555.",
  "Easter Island, a Chilean territory, is a remote volcanic island in Polynesia.",
  "I use Azure Functions to develop my product.",
];

async function main() {
  const actions: AnalyzeBatchAction[] = [
    {
      kind: "EntityRecognition",
      modelVersion: "latest",
    },
    {
      kind: "PiiEntityRecognition",
      modelVersion: "latest",
    },
    {
      kind: "KeyPhraseExtraction",
      modelVersion: "latest",
    },
  ];
  const poller = await client.beginAnalyzeBatch(actions, documents, "en");
  const actionResults = await poller.pollUntilDone();
  for await (const actionResult of actionResults) {
    if (actionResult.error) {
      const { code, message } = actionResult.error;
      throw new Error(`Unexpected error (${code}): ${message}`);
    }
    switch (actionResult.kind) {
      case "KeyPhraseExtraction": {
        for (const doc of actionResult.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);
          }
        }
        break;
      }
      case "EntityRecognition": {
        for (const doc of actionResult.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);
          }
        }
        break;
      }
      case "PiiEntityRecognition": {
        for (const doc of actionResult.results) {
          console.log(`- Document ${doc.id}`);
          if (!doc.error) {
            console.log("\tPii Entities:");
            for (const entity of doc.entities) {
              console.log(`\t- Entity ${entity.text} of type ${entity.category}`);
            }
          } else {
            console.error("\tError:", doc.error);
          }
        }
        break;
      }
      default: {
        throw new Error(`Unexpected action results: ${actionResult.kind}`);
      }
    }
  }
}

main();

Résolution des problèmes

Journalisation

L’activation de la journalisation peut vous aider à mieux comprendre les échecs. Pour avoir un journal des requêtes et réponses HTTP, définissez la variable d’environnement AZURE_LOG_LEVEL sur info. Vous pouvez également activer la journalisation au moment de l’exécution en appelant setLogLevel dans @azure/logger :

import { setLogLevel } from "@azure/logger";

setLogLevel("info");

Pour obtenir des instructions plus détaillées sur l’activation des journaux, consultez les documents relatifs au package @azure/logger.

Étapes suivantes

Consultez le répertoire d’exemples pour obtenir des exemples détaillés sur l’utilisation de cette bibliothèque.

Contribution

Si vous souhaitez contribuer à cette bibliothèque, lisez le guide de contribution pour en savoir plus sur la génération et le test du code.

Kit de développement logiciel (SDK) Microsoft Azure pour JavaScript

Impressions

Partager via

Bibliothèque cliente Analyse de texte Azure pour JavaScript - version 6.0.0-beta.1

Prise en main

Environnements actuellement pris en charge

Prérequis

Installez le package `@azure/ai-text-analytics`

Créez et authentifiez un`TextAnalysisClient`

Utilisation d’une clé API

Utilisation d’informations d’identification Azure Active Directory

Concepts clés

TextAnalysisClient

Entrée

Valeur renvoyée

Gestion des erreurs de document

Exemples

Analyse des sentiments

Reconnaissance d’entité

Reconnaissance d’entité PII

Liaison d’entités

Extraction d’expressions clés

Détection de la langue

Analyse des soins de santé

Résumé extractif

Reconnaissance d’entité personnalisée

Classification à étiquette unique personnalisée

Classification multi-étiquettes personnalisée

Traitement par lots d’actions

Résolution des problèmes

Journalisation

Étapes suivantes

Contribution

Ressources supplémentaires

Partager via

Bibliothèque cliente Analyse de texte Azure pour JavaScript - version 6.0.0-beta.1

Prise en main

Environnements actuellement pris en charge

Prérequis

Installez le package @azure/ai-text-analytics

Créez et authentifiez unTextAnalysisClient

Utilisation d’une clé API

Utilisation d’informations d’identification Azure Active Directory

Concepts clés

TextAnalysisClient

Entrée

Valeur renvoyée

Gestion des erreurs de document

Exemples

Analyse des sentiments

Reconnaissance d’entité

Reconnaissance d’entité PII

Liaison d’entités

Extraction d’expressions clés

Détection de la langue

Analyse des soins de santé

Résumé extractif

Reconnaissance d’entité personnalisée

Classification à étiquette unique personnalisée

Classification multi-étiquettes personnalisée

Traitement par lots d’actions

Résolution des problèmes

Journalisation

Étapes suivantes

Contribution

Projets associés

Ressources supplémentaires

Installez le package `@azure/ai-text-analytics`

Créez et authentifiez un`TextAnalysisClient`