Share via


Azure Text Analysis-Clientbibliothek für JavaScript– Version 6.0.0-beta.1

Azure Cognitive Service for Language ist ein cloudbasierter Dienst, der erweiterte Verarbeitung natürlicher Sprache für Unformatierten Text bietet und die folgenden Hauptfeatures umfasst:

Hinweis: Dieses SDK zielt auf Azure Cognitive Service für Sprach-API-Version 2022-04-01-preview ab.

  • Spracherkennung
  • Standpunktanalyse
  • Schlüsselwortextraktion
  • Erkennung benannter Entitäten
  • Anerkennung personenbezogener Informationen
  • Entitätsverknüpfung
  • Analyse des Gesundheitswesens
  • Extraktive Zusammenfassung
  • Benutzerdefinierte Entitätserkennung
  • Benutzerdefinierte Dokumentklassifizierung
  • Unterstützung mehrerer Aktionen pro Dokument

Verwenden Sie die Clientbibliothek für folgende Aktionen:

  • Erkennen, in welcher Sprache eingabetext geschrieben ist.
  • Bestimmen Sie, was Kunden von Ihrer Marke oder Ihrem Thema halten, indem Sie Rohtext auf Hinweise zu einer positiven oder negativen Stimmung analysieren.
  • Extrahieren Sie automatisch Schlüsselwörter, um die wichtigsten Inhalte zu ermitteln.
  • Identifizieren und kategorisieren Sie Entitäten in Ihrem Text als Personen, Orte, Organisationen, Datum/Uhrzeit, Mengen, Prozentsätze, Währungen, Gesundheitswesen und vieles mehr.
  • Führen Sie mehrere der oben genannten Aufgaben gleichzeitig aus.

Wichtige Links:

Erste Schritte

Die derzeitig unterstützten Umgebungen

Ausführlichere Informationen finden Sie in der Supportrichtlinie.

Voraussetzungen

Wenn Sie die Azure CLI verwenden, ersetzen <your-resource-group-name> Sie und <your-resource-name> durch Ihre eigenen eindeutigen Namen:

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

Installieren Sie das Paket @azure/ai-text-analytics.

Installieren Sie die Azure Text Analysis-Clientbibliothek für JavaScript mit npm:

npm install @azure/ai-text-analytics

Erstellen und Authentifizieren eines TextAnalysisClient

Um ein Clientobjekt für den Zugriff auf die Sprach-API zu erstellen, benötigen Sie die endpoint ihrer Sprachressource und eine credential. Der Textanalyseclient kann entweder Azure Active Directory-Anmeldeinformationen oder API-Schlüsselanmeldeinformationen für die Authentifizierung verwenden.

Sie finden den Endpunkt für Ihre Sprachressource entweder im Azure-Portal oder mithilfe des folgenden Azure CLI-Ausschnitts :

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

Verwenden eines API-Schlüssels

Verwenden Sie das Azure-Portal , um zu Ihrer Sprachressource zu navigieren und einen API-Schlüssel abzurufen, oder verwenden Sie den folgenden Azure CLI-Codeausschnitt :

Hinweis: Manchmal wird der API-Schlüssel als "Abonnementschlüssel" oder "Abonnement-API-Schlüssel" bezeichnet.

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

Sobald Sie über einen API-Schlüssel und einen Endpunkt verfügen, können Sie die AzureKeyCredential -Klasse verwenden, um den Client wie folgt zu authentifizieren:

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

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

Verwenden von Azure Active Directory-Anmeldeinformationen

Die Client-API-Schlüsselauthentifizierung wird in den meisten Beispielen verwendet, Aber Sie können sich auch mithilfe der Azure Identity-Bibliothek bei Azure Active Directory authentifizieren. Um den unten gezeigten DefaultAzureCredential-Anbieter oder andere Anmeldeinformationsanbieter zu verwenden, die mit dem Azure SDK bereitgestellt werden, installieren Sie das @azure/identity Paket:

npm install @azure/identity

Sie müssen auch eine neue AAD-Anwendung registrieren und Zugriff auf Sprache gewähren, indem Sie Die "Cognitive Services User" Rolle Ihrem Dienstprinzipal zuweisen (Hinweis: Andere Rollen wie "Owner" erteilen nicht die erforderlichen Berechtigungen, reichen nur "Cognitive Services User" aus, um die Beispiele und den Beispielcode auszuführen).

Legen Sie die Werte der Client-ID, der Mandanten-ID und des geheimen Clientschlüssels der AAD-Anwendung als Umgebungsvariablen fest: 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());

Wichtige Begriffe

TextAnalysisClient

TextAnalysisClient ist die primäre Schnittstelle für Entwickler, die die Textanalyse-Clientbibliothek verwenden. Erkunden Sie die Methoden für dieses Clientobjekt, um die verschiedenen Features des Sprachdiensts zu verstehen, auf den Sie zugreifen können.

Eingabe

Ein Dokument stellt eine einzelne Eingabeeinheit dar, die von den Vorhersagemodellen im Sprachdienst analysiert werden soll. Vorgänge bei TextAnalysisClient nehmen eine Sammlung von Eingaben an, die als Batch analysiert werden sollen. Die Vorgangsmethoden verfügen über Überladungen, mit denen die Eingaben als Zeichenfolgen oder als Objekte mit angefügten Metadaten dargestellt werden können.

Beispielsweise kann jedes Dokument als Zeichenfolge in einem Array übergeben werden, z. B.

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

Oder, wenn Sie ein Dokument id pro Element oder languagecountryHint/übergeben möchten, können sie als Liste mit TextDocumentInput oder DetectLanguageInput abhängig vom Vorgang angegeben werden;

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

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

Rückgabewert

Der Rückgabewert, der einem einzelnen Dokument entspricht, ist entweder ein erfolgreiches Ergebnis oder ein Fehlerobjekt. Jede TextAnalysisClient Methode gibt ein heterogenes Array von Ergebnissen und Fehlern zurück, die den Eingaben nach Index entsprechen. Eine Texteingabe und ihr Ergebnis weisen denselben Index in den Eingabe- und Ergebnisauflistungen auf.

Ein Ergebnis, z SentimentAnalysisResult. B. , ist das Ergebnis eines Sprachvorgangs, der eine Vorhersage oder Vorhersagen zu einer einzelnen Texteingabe enthält. Der Ergebnistyp eines Vorgangs kann optional auch Informationen zum Eingabedokument und zur Verarbeitung enthalten.

Das Fehlerobjekt gibt an, TextAnalysisErrorResultdass beim Dienst bei der Verarbeitung des Dokuments ein Fehler aufgetreten ist, und enthält Informationen zum Fehler.

Dokumentfehlerbehandlung

In der Auflistung, die von einem Vorgang zurückgegeben wird, werden Fehler von erfolgreichen Antworten durch das Vorhandensein der error -Eigenschaft unterschieden, die das innere TextAnalysisError Objekt enthält, wenn ein Fehler aufgetreten ist. Bei erfolgreichen Ergebnisobjekten ist diese Eigenschaft immerundefined.

Um beispielsweise alle Fehler herauszufiltern, können Sie folgendes filterverwenden:

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

Hinweis: TypeScript-Benutzer können von einer besseren Typüberprüfung von Ergebnis- und Fehlerobjekten profitieren, wenn compilerOptions.strictNullChecks in der tsconfig.json Konfiguration auf true festgelegt ist. Beispiel:

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

Beispiele

Standpunktanalyse

Analysieren Sie die Stimmung von Text, um zu bestimmen, ob es sich um positive, negative, neutrale oder gemischte Text handelt, einschließlich stimmungsbasierter Analyse und Konfidenzbewertungen pro Satz.

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

Detailliertere Informationen zu den Meinungen im Zusammenhang mit Aspekten eines Produkts/einer Dienstleistung, die auch als aspektbasierte Stimmungsanalyse in natural Language Processing (NLP) bezeichnet wird, finden Sie hier in einem Beispiel zur Standpunktanalyse mit Opinion Mining.

Entitätserkennung

Erkennen und Kategorisieren von Entitäten im Text als Personen, Orte, Organisationen, Datum/Uhrzeiten, Mengen, Währungen usw.

Das language ist optional. Wenn es nicht angegeben ist, wird das englische Standardmodell verwendet.

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

Erkennung von PII-Entitäten

Es gibt eine separate Aktion für die Erkennung personenbezogener Informationen (PII) in Texten wie Sozialversicherungsnummern, Bankkontoinformationen, Kreditkartennummern usw. Die Verwendung ist der oben genannten Standardentitätserkennung sehr ähnlich:

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

Entitätsverknüpfung

Eine "verknüpfte" Entität ist eine Entität, die in einem Wissensdatenbank (z. B. Wikipedia) vorhanden ist. Die EntityLinking Aktion kann Entitäten mehrdeutig machen, indem sie bestimmt, auf welchen Eintrag in einer Wissensdatenbank sie sich wahrscheinlich beziehen (z. B. bezieht sich das Wort "Mars" in einem Textteil auf den Planeten oder auf den römischen Kriegsgott). Verknüpfte Entitäten enthalten zugeordnete URLs für die Wissensdatenbank, die die Definition der Entität bereitstellt.

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

Schlüsselwortextraktion

Die Schlüsselbegriffserkennung identifiziert die wichtigsten Gesprächspunkte in einem Dokument. Zum Beispiel, wenn der eingegebene Text „Das Essen war köstlich, und es gab hervorragendes Personal“ lautet, gibt der Dienst „Essen“ und „hervorragendes Personal“ zurück.

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

Spracherkennung

Bestimmen sie die Sprache eines Textteils.

Der countryHint Parameter ist optional, kann dem Dienst jedoch helfen, die richtige Ausgabe bereitzustellen, wenn das Ursprungsland bekannt ist. Wenn angegeben, sollte er auf einen iso-3166 Alpha-2-Ländercode mit zwei Buchstaben (z. B. "us" für die USA oder "jp" für Japan) oder auf den Wert "none"festgelegt werden. Wenn der Parameter nicht angegeben wird, wird das Standardmodell "us" (USA) verwendet. Wenn Sie das Ursprungsland des Dokuments nicht kennen, sollte der Parameter "none" verwendet werden, und der Sprachdienst wendet ein Modell an, das für ein unbekanntes Ursprungsland optimiert ist.

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 Gesundheitswesens

Die Analyse des Gesundheitswesens identifiziert Entitäten im Gesundheitswesen. Wenn Sie beispielsweise den Eingabetext "Verschrieben 100 mg Ibuprofen, zweimal täglich eingenommen" angegeben haben, gibt der Dienst "100 mg" als Dosierung, "Ibuprofen" als "MedicationName" und "zweimal täglich" als Frequency zurück.

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

Extrahierende Zusammenfassung

Die extrahierende Zusammenfassung identifiziert Sätze, die den Artikel zusammenfassen, zu dem sie gehören.

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

Benutzerdefinierte Entitätserkennung

Erkennen und Kategorisieren von Entitäten im Text als Entitäten mithilfe benutzerdefinierter Entitätserkennungsmodelle, die mit Azure Language Studio erstellt wurden.

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

Benutzerdefinierte Klassifizierung mit nur einer Bezeichnung

Klassifizieren Sie Dokumente mithilfe benutzerdefinierter Modelle mit nur einer Bezeichnung, die mit Azure Language Studio erstellt wurden.

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

Benutzerdefinierte Klassifizierung mit mehreren Bezeichnungen

Klassifizieren Sie Dokumente mithilfe benutzerdefinierter Modelle mit mehreren Bezeichnungen, die mit Azure Language Studio erstellt wurden.

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

Action Batching

Wendet mehrere Aktionen auf jedes Eingabedokument in einer Dienstanforderung an.

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

Problembehandlung

Protokollierung

Die Aktivierung der Protokollierung kann hilfreiche Informationen über Fehler aufdecken. Um ein Protokoll von HTTP-Anforderungen und -Antworten anzuzeigen, legen Sie die Umgebungsvariable AZURE_LOG_LEVEL auf info fest. Alternativ kann die Protokollierung zur Laufzeit aktiviert werden, indem Sie setLogLevel in @azure/logger aufrufen:

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

setLogLevel("info");

Ausführlichere Anweisungen zum Aktivieren von Protokollen finden Sie in der Paketdokumentation zu @azure/logger.

Nächste Schritte

Ausführliche Beispiele zur Verwendung dieser Bibliothek finden Sie im Beispielverzeichnis .

Mitwirken

Wenn Sie an dieser Bibliothek mitwirken möchten, lesen Sie die Anleitung für Mitwirkende, um mehr darüber zu erfahren, wie Sie den Code erstellen und testen können.

Aufrufe