Azure Text Analysis-clientbibliotheek voor JavaScript - versie 6.0.0-beta.1

  • Artikel

Azure Cognitive Service for Language is een cloudservice die geavanceerde verwerking van natuurlijke taal via onbewerkte tekst biedt en de volgende hoofdfuncties bevat:

Opmerking: Deze SDK is gericht op Azure Cognitive Service voor Language API versie 2022-04-01-preview.

  • Taaldetectie
  • Sentimentanalyse
  • Sleuteltermextractie
  • Herkenning van benoemde entiteiten
  • Herkenning van persoonsgegevens
  • Entiteiten koppelen
  • Gezondheidszorganalyse
  • Extractieve samenvatting
  • Aangepaste entiteitsherkenning
  • Aangepaste documentclassificatie
  • Ondersteuning voor meerdere acties per document

Gebruik de clientbibliotheek voor het volgende:

  • Detecteren in welke taalinvoertekst is geschreven.
  • Bepaal wat klanten van uw merk of onderwerp vinden door onbewerkte tekst te analyseren op aanwijzingen over positief of negatief gevoel.
  • Extraheer automatisch sleuteltermen om snel de hoofdpunten te identificeren.
  • Identificeer en categoriseer entiteiten in uw tekst als personen, plaatsen, organisaties, datum/tijd, hoeveelheden, percentages, valuta's, specifieke gezondheidszorg en meer.
  • Voer meerdere van de bovenstaande taken tegelijk uit.

Belangrijke koppelingen:

Aan de slag

Momenteel ondersteunde omgevingen

Zie ons ondersteuningsbeleid voor meer informatie.

Vereisten

Als u de Azure CLI gebruikt, vervangt u en <your-resource-name> door <your-resource-group-name> uw eigen unieke namen:

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

Installeer het pakket @azure/ai-text-analytics

Installeer de Azure Text Analysis-clientbibliotheek voor JavaScript met npm:

npm install @azure/ai-text-analytics

Een maken en verifiëren TextAnalysisClient

Als u een clientobject wilt maken voor toegang tot de Taal-API, hebt u de endpoint van uw taalresource en een credentialnodig. De Text Analysis-client kan azure Active Directory-referenties of een API-sleutelreferentie gebruiken om te verifiëren.

U vindt het eindpunt voor uw taalresource in Azure Portal of met behulp van het onderstaande Azure CLI-fragment :

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

Een API-sleutel gebruiken

Gebruik de Azure-portal om naar uw taalresource te bladeren en een API-sleutel op te halen, of gebruik het onderstaande Azure CLI-fragment :

Opmerking: Soms wordt de API-sleutel een 'abonnementssleutel' of 'abonnements-API-sleutel' genoemd.

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

Zodra u een API-sleutel en eindpunt hebt, kunt u de AzureKeyCredential klasse als volgt gebruiken om de client te verifiëren:

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

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

Een Azure Active Directory-referentie gebruiken

Verificatie van client-API-sleutels wordt in de meeste voorbeelden gebruikt, maar u kunt zich ook verifiëren met Azure Active Directory met behulp van de Azure Identity-bibliotheek. Als u de hieronder weergegeven DefaultAzureCredential-provider of andere referentieproviders wilt gebruiken die bij de Azure SDK worden geleverd, installeert u het @azure/identity pakket:

npm install @azure/identity

U moet ook een nieuwe AAD-toepassing registreren en toegang verlenen tot Language door de "Cognitive Services User" rol toe te wijzen aan uw service-principal (opmerking: andere rollen, zoals "Owner" die niet de benodigde machtigingen verlenen, zijn alleen "Cognitive Services User" voldoende om de voorbeelden en de voorbeeldcode uit te voeren).

Stel de waarden van de client-id, tenant-id en clientgeheim van de AAD-toepassing in als omgevingsvariabelen: 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());

Belangrijkste concepten

TextAnalysisClient

TextAnalysisClient is de primaire interface voor ontwikkelaars die gebruikmaken van de Text Analysis-clientbibliotheek. Verken de methoden op dit clientobject om inzicht te krijgen in de verschillende functies van de taalservice waartoe u toegang hebt.

Invoer

Een document vertegenwoordigt één invoereenheid die moet worden geanalyseerd door de voorspellende modellen in de Taalservice. Bewerkingen op TextAnalysisClient nemen een verzameling invoer die als een batch moet worden geanalyseerd. De bewerkingsmethoden hebben overbelastingen waardoor de invoer kan worden weergegeven als tekenreeksen of als objecten met gekoppelde metagegevens.

Elk document kan bijvoorbeeld worden doorgegeven als een tekenreeks in een matrix, bijvoorbeeld

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

of, als u een document id per item of languagecountryHint/wilt doorgeven, kunnen deze worden opgegeven als een lijst van of DetectLanguageInput afhankelijk van TextDocumentInput de bewerking;

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

Zie servicebeperkingen voor de invoer, waaronder limieten voor documentlengte, maximale batchgrootte en ondersteunde tekstcoderingen.

Retourwaarde

De geretourneerde waarde die overeenkomt met één document is een geslaagd resultaat of een foutobject. Elke TextAnalysisClient methode retourneert een heterogene matrix van resultaten en fouten die overeenkomen met de invoer per index. Een tekstinvoer en het resultaat hebben dezelfde index in de invoer- en resultaatverzamelingen.

Een resultaat, zoals SentimentAnalysisResult, is het resultaat van een taalbewerking die een voorspelling of voorspellingen over één tekstinvoer bevat. Het resultaattype van een bewerking kan desgewenst ook informatie bevatten over het invoerdocument en hoe het is verwerkt.

Het foutobject , TextAnalysisErrorResult, geeft aan dat de service een fout heeft opgetreden tijdens het verwerken van het document en bevat informatie over de fout.

Afhandeling van documentfouten

In de verzameling die door een bewerking wordt geretourneerd, worden fouten onderscheiden van geslaagde antwoorden door de aanwezigheid van de error eigenschap, die het binnenste TextAnalysisError object bevat als er een fout is opgetreden. Voor geslaagde resultaatobjecten is deze eigenschap altijdundefined.

Als u bijvoorbeeld alle fouten wilt filteren, kunt u het volgende filtergebruiken:

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

Opmerking: TypeScript-gebruikers kunnen profiteren van een betere typecontrole van resultaat- en foutobjecten als compilerOptions.strictNullChecks is ingesteld op true in de tsconfig.json configuratie. Bijvoorbeeld:

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

Voorbeelden

Sentimentanalyse

Het gevoel van tekst analyseren om te bepalen of deze positief, negatief, neutraal of gemengd is, inclusief sentimentanalyse per zin en betrouwbaarheidsscores.

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

Voor gedetailleerdere informatie over de meningen met betrekking tot aspecten van een product/service, ook wel bekend als Aspect-based Sentiment Analysis in Natural Language Processing (NLP), bekijkt u hier een voorbeeld van sentimentanalyse met meninganalyse.

Herkenning van entiteiten

Entiteiten in tekst herkennen en categoriseren als personen, plaatsen, organisaties, datums/tijden, hoeveelheden, valuta's, enzovoort.

De language parameter is optioneel. Als dit niet is opgegeven, wordt het standaard Engelse model gebruikt.

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

PII-entiteitsherkenning

Er is een afzonderlijke actie voor het herkennen van persoonsgegevens (PII) in tekst, zoals burgerservicenummers, bankrekeninggegevens, creditcardnummers, enzovoort. Het gebruik ervan is vergelijkbaar met de bovenstaande standaardentiteitsherkenning:

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

Entiteiten koppelen

Een 'gekoppelde' entiteit is een entiteit die bestaat in een Knowledge Base (zoals Wikipedia). De EntityLinking actie kan entiteiten ondubbelzinnig maken door te bepalen naar welke vermelding in een Knowledge Base ze waarschijnlijk verwijzen (in een stuk tekst verwijst het woord 'Mars' bijvoorbeeld naar de planeet of naar de Romeinse oorlogsgod). Gekoppelde entiteiten bevatten gekoppelde URL's naar de Knowledge Base die de definitie van de entiteit biedt.

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

Sleuteltermextractie

Sleuteltermextractie identificeert de belangrijkste gesprekspunten in een document. Als u bijvoorbeeld invoertekst 'Het eten was heerlijk en er was geweldig personeel', retourneert de service 'eten' en 'geweldig personeel'.

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

Taaldetectie

Bepaal de taal van een stuk tekst.

De countryHint parameter is optioneel, maar kan de service helpen bij het leveren van de juiste uitvoer als het land van oorsprong bekend is. Indien opgegeven, moet deze worden ingesteld op een ISO-3166 Alpha-2-landcode van twee letters (zoals 'us' voor de Verenigde Staten of 'jp' voor Japan) of op de waarde "none". Als de parameter niet is opgegeven, wordt het standaardmodel "us" (Verenigde Staten) gebruikt. Als u het land van oorsprong van het document niet weet, moet de parameter "none" worden gebruikt en past de Taalservice een model toe dat is afgestemd op een onbekend land van oorsprong.

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

Gezondheidszorganalyse

Gezondheidszorganalyse identificeert gezondheidszorgentiteiten. Bijvoorbeeld, opgegeven invoertekst 'Voorgeschreven 100mg ibuprofen, tweemaal daags' retourneert de service '100mg' gecategoriseerd als dosering, 'ibuprofen' als MedicationName en 'tweemaal daags' als Frequentie.

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

Extractieve samenvatting

Extractieve samenvatting identificeert zinnen die het artikel samenvatten waartoe ze behoren.

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

Aangepaste entiteitsherkenning

Entiteiten in tekst herkennen en categoriseren als entiteiten met behulp van aangepaste entiteitsdetectiemodellen die zijn gebouwd met Behulp van 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();

Aangepaste classificatie met één label

Documenten classificeren met behulp van aangepaste modellen met één label die zijn gebouwd met Behulp van 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();

Aangepaste classificatie met meerdere labels

Documenten classificeren met behulp van aangepaste modellen met meerdere labels die zijn gebouwd met Behulp van 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();

Batchverwerking van acties

Hiermee worden meerdere acties toegepast op elk invoerdocument in één serviceaanvraag.

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

Problemen oplossen

Logboekregistratie

Het inschakelen van logboekregistratie kan helpen bij het ontdekken van nuttige informatie over fouten. Als u een logboek met HTTP-aanvragen en -antwoorden wilt zien, stelt u de AZURE_LOG_LEVEL omgevingsvariabele in op info. U kunt logboekregistratie ook tijdens runtime inschakelen door aan te roepen setLogLevel in de @azure/logger:

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

setLogLevel("info");

Voor meer gedetailleerde instructies over het inschakelen van logboeken kunt u de @azure-/loggerpakketdocumenten bekijken.

Volgende stappen

Bekijk de map met voorbeelden voor gedetailleerde voorbeelden van het gebruik van deze bibliotheek.

Bijdragen

Als u een bijdrage wilt leveren aan deze bibliotheek, leest u de handleiding voor bijdragen voor meer informatie over het bouwen en testen van de code.

Weergaven