Libreria client di Analisi del testo di Azure per JavaScript - versione 6.0.0-beta.1

  • Articolo

Servizio cognitivo di Azure per il linguaggio è un servizio basato sul cloud che offre un'elaborazione avanzata del linguaggio naturale su testo non elaborato e include le funzionalità principali seguenti:

Nota: Questo SDK è destinato a Servizi cognitivi di Azure per l'API del linguaggio versione 2022-04-01-preview.

  • Rilevamento lingua
  • Analisi del sentiment
  • Estrazione frasi chiave
  • Riconoscimento di entità denominate
  • Riconoscimento delle informazioni personali
  • Collegamento delle entità
  • Analisi del settore sanitario
  • Riepilogo estrativo
  • Riconoscimento di entità personalizzate
  • Classificazione personalizzata dei documenti
  • Supporto di più azioni per documento

Usare la libreria client per:

  • Rilevare il testo di input della lingua in cui è scritto.
  • Determinare cosa pensano i clienti del marchio o dell'argomento analizzando il testo non elaborato per ottenere indizi sul sentiment positivo o negativo.
  • Estrae automaticamente frasi chiave per identificare rapidamente i punti principali.
  • Identificare e classificare le entità nel testo come persone, luoghi, organizzazioni, data/ora, quantità, percentuali, valute, specifiche del settore sanitario e altro ancora.
  • Eseguire più attività precedenti contemporaneamente.

Collegamenti principali:

Introduzione

Ambienti attualmente supportati

Per altre informazioni, vedere i criteri di supporto.

Prerequisiti

Se si usa l'interfaccia della riga di comando di Azure, sostituire <your-resource-group-name> e <your-resource-name> con i propri nomi univoci:

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

Installare il pacchetto @azure/ai-text-analytics

Installare la libreria client di Analisi del testo di Azure per JavaScript con npm:

npm install @azure/ai-text-analytics

Creare e autenticare un oggetto TextAnalysisClient

Per creare un oggetto client per accedere all'API Language, è necessario disporre endpoint della risorsa Language e di un .credential Il client analisi del testo può usare le credenziali di Azure Active Directory o una credenziale della chiave API per l'autenticazione.

È possibile trovare l'endpoint per la risorsa language nel portale di Azure o usando il frammento di interfaccia della riga di comando di Azure seguente:

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

Uso di una chiave API

Usare il portale di Azure per passare alla risorsa lingua e recuperare una chiave API oppure usare il frammento di interfaccia della riga di comando di Azure seguente:

Nota: A volte la chiave API viene definita "chiave di sottoscrizione" o "chiave API di sottoscrizione".

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

Dopo aver ottenuto una chiave API e un endpoint, è possibile usare la AzureKeyCredential classe per autenticare il client come indicato di seguito:

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

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

Uso di credenziali di Azure Active Directory

L'autenticazione della chiave API client viene usata nella maggior parte degli esempi, ma è anche possibile eseguire l'autenticazione con Azure Active Directory usando la libreria di identità di Azure. Per usare il provider DefaultAzureCredential illustrato di seguito o altri provider di credenziali forniti con Azure SDK, installare il @azure/identity pacchetto:

npm install @azure/identity

Sarà anche necessario registrare una nuova applicazione AAD e concedere l'accesso a Language assegnando il "Cognitive Services User" ruolo all'entità servizio.Nota: altri ruoli, "Owner" ad esempio, non concedono le autorizzazioni necessarie, saranno sufficienti solo "Cognitive Services User" per eseguire gli esempi e il codice di esempio.

Impostare i valori dell'ID client, dell'ID tenant e del segreto client dell'applicazione AAD come variabili di ambiente: AZURE_CLIENT_ID, , AZURE_TENANT_IDAZURE_CLIENT_SECRET.

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

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

Concetti chiave

TextAnalysisClient

TextAnalysisClient è l'interfaccia principale per gli sviluppatori che usano la libreria client analisi del testo. Esplorare i metodi in questo oggetto client per comprendere le diverse funzionalità del servizio language a cui è possibile accedere.

Input

Un documento rappresenta una singola unità di input da analizzare dai modelli predittivi nel servizio di linguaggio. Le operazioni su TextAnalysisClient accettano una raccolta di input da analizzare come batch. I metodi dell'operazione hanno overload che consentono di rappresentare gli input come stringhe o come oggetti con metadati associati.

Ad esempio, ogni documento può essere passato come stringa in una matrice, ad esempio

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

oppure, se si desidera passare un documento id per elemento o languagecountryHint/, possono essere forniti come elenco di TextDocumentInput o DetectLanguageInput a seconda dell'operazione;

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

Vedere limitazioni del servizio per l'input, inclusi i limiti di lunghezza del documento, le dimensioni massime del batch e le codifiche di testo supportate.

Valore restituito

Il valore restituito corrispondente a un singolo documento è un risultato positivo o un oggetto errore. Ogni TextAnalysisClient metodo restituisce una matrice eterogenea di risultati ed errori che corrispondono agli input per indice. Un input di testo e il relativo risultato avranno lo stesso indice nelle raccolte di input e risultati.

Un risultato, ad esempio SentimentAnalysisResult, è il risultato di un'operazione language contenente una stima o stime su un singolo input di testo. Il tipo di risultato di un'operazione può anche includere facoltativamente informazioni sul documento di input e su come è stato elaborato.

L'oggetto error , TextAnalysisErrorResult, indica che il servizio ha rilevato un errore durante l'elaborazione del documento e contiene informazioni sull'errore.

Gestione degli errori del documento

Nell'insieme restituito da un'operazione, gli errori vengono distinti dalle risposte riuscite in base alla error presenza della proprietà , che contiene l'oggetto interno TextAnalysisError se si è verificato un errore. Per gli oggetti risultato riusciti, questa proprietà è sempreundefined .

Ad esempio, per filtrare tutti gli errori, è possibile usare quanto segue filter:

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

Nota: gli utenti di TypeScript possono trarre vantaggio dal controllo dei tipi migliore dei risultati e degli oggetti errore se compilerOptions.strictNullChecks è impostato su true nella tsconfig.json configurazione. Ad esempio:

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

Esempi

Analisi del sentiment

Analizzare il sentiment del testo per determinare se è positivo, negativo, neutro o misto, tra cui l'analisi del sentiment per frase e i punteggi di attendibilità.

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

Per ottenere informazioni più granulari sulle opinioni relative agli aspetti di un prodotto/servizio, noto anche come Analisi del sentiment basata su aspetti in Elaborazione del linguaggio naturale (NLP), vedere un esempio sull'analisi del sentiment con opinion mining qui.

Riconoscimento delle entità

Riconoscere e classificare le entità nel testo come persone, luoghi, organizzazioni, date/ore, quantità, valute e così via.

language è facoltativo. Se non è specificato, verrà usato il modello inglese predefinito.

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

Riconoscimento delle entità PII

Esiste un'azione separata per il riconoscimento delle informazioni personali (PII) in testo, ad esempio numeri di previdenza sociale, informazioni sul conto bancario, numeri di carta di credito e così via. L'utilizzo è molto simile al riconoscimento dell'entità standard precedente:

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

Collegamento delle entità

Un'entità "Collegata" è una entità presente in un knowledge base (ad esempio Wikipedia). L'azione EntityLinking può disambiguare le entità determinando quale voce in un knowledge base probabilmente fanno riferimento (ad esempio, in un pezzo di testo, la parola "Marte" fa riferimento al pianeta o al dio romano della guerra). Le entità collegate contengono URL associati al knowledge base che fornisce la definizione dell'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();

Estrazione frasi chiave

L'estrazione di frasi chiave identifica i punti di discussione principali in un documento. Ad esempio, dato il testo di input "Il cibo era delizioso e il personale era meraviglioso", il servizio restituisce "cibo" e "personale meraviglioso".

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

Rilevamento lingua

Determinare la lingua di un pezzo di testo.

Il countryHint parametro è facoltativo, ma può aiutare il servizio a fornire un output corretto se il paese di origine è noto. Se specificato, deve essere impostato su un codice paese ISO-3166 Alpha-2 a due lettere (ad esempio "us" per il Stati Uniti o "jp" per il Giappone) o sul valore "none". Se il parametro non viene specificato, verrà usato il modello predefinito "us" (Stati Uniti). Se non si conosce il paese di origine del documento, il parametro "none" deve essere usato e il servizio lingua applicherà un modello ottimizzato per un paese di origine sconosciuto.

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

Analisi sanitaria

L'analisi sanitaria identifica le entità sanitarie. Ad esempio, dato il testo di input "Prescritto 100mg ibuprofen, preso due volte ogni giorno", il servizio restituisce "100mg" classificato come Dosaggio, "ibuprofen" come Nome farmaco e "due volte ogni giorno" come Frequenza.

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

Riepilogo estratto

L'estrazione di riepilogo identifica le frasi che riepilogano l'articolo a cui appartengono.

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

Riconoscimento di entità personalizzato

Riconoscere e classificare le entità nel testo come entità usando modelli di rilevamento delle entità personalizzati compilati con 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();

Classificazione a etichetta singola personalizzata

Classificare i documenti usando modelli a etichetta singola personalizzati compilati con 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();

Classificazione multi-etichetta personalizzata

Classificare i documenti usando modelli multi-etichetta personalizzati compilati con 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();

Batch di azioni

Applica più azioni in ogni documento di input in una richiesta di servizio.

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

Risoluzione dei problemi

Registrazione

L'abilitazione della registrazione consente di individuare informazioni utili sugli errori. Per visualizzare un log di richieste e risposte HTTP, impostare la variabile di ambiente AZURE_LOG_LEVEL su info. In alternativa, la registrazione può essere abilitata in fase di esecuzione chiamando setLogLevel in @azure/logger:

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

setLogLevel("info");

Per istruzioni più dettagliate su come abilitare i log, è possibile esaminare la documentazione del pacchetto @azure/logger.

Passaggi successivi

Per esempi dettagliati su come usare questa libreria, vedere la directory degli esempi .

Contributo

Per contribuire a questa libreria, leggere la guida ai contributi per altre informazioni su come compilare e testare il codice.

Impression