Biblioteca de cliente da Análise de Texto do Azure para JavaScript – versão 6.0.0-beta.1

Artigo
04/05/2023

O Serviço Cognitivo do Azure para Linguagem é um serviço baseado na cloud que fornece processamento avançado de linguagem natural em texto não processado e inclui as seguintes funcionalidades principais:

Nota: Este SDK destina-se ao Serviço Cognitivo do Azure para a versão da API de Idioma 2022-04-01-preview.

Deteção de Idioma
Análise de Sentimentos
Extração de Expressões-Chave
Reconhecimento de Entidades Nomeadas
Reconhecimento de Informações Pessoais
Ligar à Entidade
Análise de Cuidados de Saúde
Resumo Extrativo
Reconhecimento de Entidades Personalizadas
Classificação personalizada de documentos
Suportar Múltiplas Ações Por Documento

Utilize a biblioteca de cliente para:

Detetar em que texto de entrada de idioma está escrito.
Determine o que os clientes pensam da sua marca ou tópico ao analisar texto não processado para obter pistas sobre sentimentos positivos ou negativos.
Extraia expressões-chave automaticamente para identificar rapidamente os pontos principais.
Identifique e categorize entidades no seu texto como pessoas, locais, organizações, data/hora, quantidades, percentagens, moedas, cuidados de saúde específicos e muito mais.
Efetue várias das tarefas acima ao mesmo tempo.

Ligações principais:

Introdução

Ambientes atualmente suportados

Versões LTS do Node.js
Versões mais recentes do Safari, Chrome, Edge e Firefox.

Veja a nossa política de suporte para obter mais detalhes.

Pré-requisitos

Uma subscrição do Azure.
Um recurso de Serviços Cognitivos ou Idioma existente. Se precisar de criar o recurso, pode utilizar o Portal do Azure ou a CLI do Azure.

Se utilizar a CLI do Azure, substitua <your-resource-group-name> e <your-resource-name> pelos seus próprios nomes exclusivos:

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

Instalar o pacote `@azure/ai-text-analytics`

Instale a biblioteca de cliente da Análise de Texto do Azure para JavaScript com npm:

npm install @azure/ai-text-analytics

Criar e autenticar um `TextAnalysisClient`

Para criar um objeto de cliente para aceder à API de Idioma, precisará do endpoint recurso Idioma e de um credential. O cliente de Análise de Texto pode utilizar credenciais do Azure Active Directory ou uma credencial de chave de API para autenticar.

Pode encontrar o ponto final do recurso de Idioma no Portal do Azure ou com o fragmento da CLI do Azure abaixo:

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

Utilizar uma Chave de API

Utilize o Portal do Azure para navegar para o recurso de Idioma e obter uma chave de API ou utilize o fragmento da CLI do Azure abaixo:

Nota: Por vezes, a chave de API é referida como uma "chave de subscrição" ou "chave de API de subscrição".

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

Assim que tiver uma chave de API e um ponto final, pode utilizar a AzureKeyCredential classe para autenticar o cliente da seguinte forma:

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

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

Utilizar uma Credencial do Azure Active Directory

A autenticação da chave de API de cliente é utilizada na maioria dos exemplos, mas também pode autenticar com o Azure Active Directory com a biblioteca de Identidade do Azure. Para utilizar o fornecedor DefaultAzureCredential mostrado abaixo ou outros fornecedores de credenciais fornecidos com o SDK do Azure, instale o @azure/identity pacote:

npm install @azure/identity

Também terá de registar uma nova aplicação do AAD e conceder acesso ao Idioma ao atribuir a "Cognitive Services User" função ao principal de serviço (nota: outras funções, como "Owner" não concederão as permissões necessárias, só "Cognitive Services User" serão suficientes para executar os exemplos e o código de exemplo).

Defina os valores do ID de cliente, do ID do inquilino e do segredo do cliente da aplicação do AAD como variáveis de 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());

Conceitos-chave

TextAnalysisClient

TextAnalysisClient é a interface principal para programadores que utilizam a biblioteca de cliente análise de texto. Explore os métodos neste objeto de cliente para compreender as diferentes funcionalidades do serviço Idioma a que pode aceder.

Entrada

Um documento representa uma única unidade de entrada a ser analisada pelos modelos preditivos no serviço Idioma. As operações no TextAnalysisClient assumem uma coleção de entradas a serem analisadas como um lote. Os métodos de operação têm sobrecargas que permitem que as entradas sejam representadas como cadeias ou como objetos com metadados anexados.

Por exemplo, cada documento pode ser transmitido como uma cadeia numa matriz, por exemplo,

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

ou, se quiser transmitir um documento id por item ou languagecountryHint/, estes podem ser fornecidos como uma lista ou TextDocumentInputDetectLanguageInput dependendo da operação;

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

Veja limitações de serviço para a entrada, incluindo limites de comprimento do documento, tamanho máximo do lote e codificações de texto suportadas.

Devolver Valor

O valor devolvido correspondente a um único documento é um resultado bem-sucedido ou um objeto de erro. Cada TextAnalysisClient método devolve uma matriz heterogénea de resultados e erros que correspondem às entradas por índice. Uma entrada de texto e o respetivo resultado terão o mesmo índice nas coleções de entrada e de resultados.

Um resultado, como SentimentAnalysisResult, é o resultado de uma operação de Idioma, que contém uma predição ou predições sobre uma única entrada de texto. O tipo de resultado de uma operação também pode incluir, opcionalmente, informações sobre o documento de entrada e como foi processado.

O objeto de erro , TextAnalysisErrorResult, indica que o serviço encontrou um erro ao processar o documento e contém informações sobre o erro.

Processamento de Erros do Documento

Na coleção devolvida por uma operação, os erros distinguem-se das respostas com êxito pela presença da error propriedade, que contém o objeto interno TextAnalysisError se for encontrado um erro. Para objetos de resultado bem-sucedidos, esta propriedade é sempreundefined.

Por exemplo, para filtrar todos os erros, pode utilizar o seguinte filter:

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

Nota: os utilizadores do TypeScript podem beneficiar de uma melhor verificação de tipos de objetos de resultado e erro se compilerOptions.strictNullChecks estiverem definidos como true na tsconfig.json configuração. Por exemplo:

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

Exemplos

Análise de Sentimentos

Analise o sentimento do texto para determinar se é positivo, negativo, neutro ou misto, incluindo análise de sentimentos por frase e classificações de confiança.

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

Para obter informações mais granulares sobre as opiniões relacionadas com aspetos de um produto/serviço, também conhecido como Análise de Sentimentos Baseada em Aspeto no Processamento de Linguagem Natural (NLP), veja aqui uma amostra da análise de sentimentos com extração de opiniões.

Reconhecimento de entidade

Reconhecer e categorizar entidades em texto como pessoas, locais, organizações, datas/horas, quantidades, moedas, etc.

O language parâmetro é opcional. Se não for especificado, será utilizado o modelo inglês predefinido.

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

Reconhecimento de Entidades PII

Existe uma ação separada para reconhecer Informações Pessoais (PII) em texto, como Números de Segurança Social, informações da conta bancária, números de cartão de crédito, etc. A sua utilização é muito semelhante ao reconhecimento de entidade padrão acima:

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

Ligar à Entidade

Uma entidade "Ligada" é uma entidade que existe num base de dados de conhecimento (como a Wikipédia). A EntityLinking ação pode desambiguar entidades determinando a entrada num base de dados de conhecimento a que provavelmente se referem (por exemplo, num pedaço de texto, a palavra "Marte" refere-se ao planeta, ou ao deus romano da guerra). As entidades ligadas contêm URLs associados ao base de dados de conhecimento que fornece a definição da entidade.

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

Extração de Expressões-Chave

A extração de Expressões-Chave identifica os principais pontos de discussão num documento. Por exemplo, com o texto de entrada "A comida estava deliciosa e havia pessoal maravilhoso", o serviço devolve "comida" e "pessoal maravilhoso".

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

Deteção de Idioma

Determinar o idioma de uma parte do texto.

O countryHint parâmetro é opcional, mas pode ajudar o serviço a fornecer um resultado correto se o país de origem for conhecido. Se for fornecido, deve ser definido como um código de país de duas letras ISO-3166 Alpha-2 (como "nós" para o Estados Unidos ou "jp" para o Japão) ou para o valor "none". Se o parâmetro não for fornecido, será utilizado o modelo predefinido "us" (Estados Unidos). Se não souber o país de origem do documento, o parâmetro "none" deve ser utilizado e o serviço Idioma aplicará um modelo otimizado para um país de origem desconhecido.

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

Análise de Cuidados de Saúde

A análise de cuidados de saúde identifica as entidades de cuidados de saúde. Por exemplo, com o texto de entrada "Prescrito 100mg ibuprofeno, tomado duas vezes por dia", o serviço devolve "100mg" categorizado como Dosage, "ibuprofeno" como MedicationName e "duas vezes por dia" como Frequência.

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

Resumo Extrativo

O resumo extrativo identifica frases que resumem o artigo a que pertencem.

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

Reconhecimento de Entidades Personalizadas

Reconhecer e categorizar entidades no texto como entidades com modelos de deteção de entidades personalizados criados com o 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();

Classificação personalizada de etiqueta única

Classificar documentos com modelos de etiqueta única personalizados criados com o 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();

Classificação personalizada de várias etiquetas

Classificar documentos com modelos de várias etiquetas personalizados criados com o 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();

Criação de Batches de Ação

Aplica várias ações em cada documento de entrada num pedido de serviço.

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

Resolução de problemas

Registo

Ativar o registo pode ajudar a descobrir informações úteis sobre falhas. Para ver um registo de pedidos e respostas HTTP, defina a variável de AZURE_LOG_LEVEL ambiente como info. Em alternativa, o registo pode ser ativado no runtime ao chamar setLogLevel no @azure/logger:

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

setLogLevel("info");

Para obter instruções mais detalhadas sobre como ativar os registos, pode ver os documentos do pacote @azure/logger.

Passos seguintes

Veja o diretório de exemplos para obter exemplos detalhados sobre como utilizar esta biblioteca.

Contribuir

Se quiser contribuir para esta biblioteca, leia o guia de contribuição para saber mais sobre como criar e testar o código.

SDK do Microsoft Azure para JavaScript

Impressões

Biblioteca de cliente da Análise de Texto do Azure para JavaScript – versão 6.0.0-beta.1

Introdução

Ambientes atualmente suportados

Pré-requisitos

Instalar o pacote `@azure/ai-text-analytics`

Criar e autenticar um `TextAnalysisClient`

Utilizar uma Chave de API

Utilizar uma Credencial do Azure Active Directory

Conceitos-chave

TextAnalysisClient

Entrada

Devolver Valor

Processamento de Erros do Documento

Exemplos

Análise de Sentimentos

Reconhecimento de entidade

Reconhecimento de Entidades PII

Ligar à Entidade

Extração de Expressões-Chave

Deteção de Idioma

Análise de Cuidados de Saúde

Resumo Extrativo

Reconhecimento de Entidades Personalizadas

Classificação personalizada de etiqueta única

Classificação personalizada de várias etiquetas

Criação de Batches de Ação

Resolução de problemas

Registo

Passos seguintes

Contribuir

Comentários

Recursos adicionais

Biblioteca de cliente da Análise de Texto do Azure para JavaScript – versão 6.0.0-beta.1

Introdução

Ambientes atualmente suportados

Pré-requisitos

Instalar o pacote @azure/ai-text-analytics

Criar e autenticar um TextAnalysisClient

Utilizar uma Chave de API

Utilizar uma Credencial do Azure Active Directory

Conceitos-chave

TextAnalysisClient

Entrada

Devolver Valor

Processamento de Erros do Documento

Exemplos

Análise de Sentimentos

Reconhecimento de entidade

Reconhecimento de Entidades PII

Ligar à Entidade

Extração de Expressões-Chave

Deteção de Idioma

Análise de Cuidados de Saúde

Resumo Extrativo

Reconhecimento de Entidades Personalizadas

Classificação personalizada de etiqueta única

Classificação personalizada de várias etiquetas

Criação de Batches de Ação

Resolução de problemas

Registo

Passos seguintes

Contribuir

Projetos relacionados

Comentários

Recursos adicionais

Instalar o pacote `@azure/ai-text-analytics`

Criar e autenticar um `TextAnalysisClient`