Biblioteca de clientes de 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 em nuvem que fornece processamento avançado de linguagem natural em texto bruto e inclui os seguintes recursos principais:

Nota: Esse SDK tem como destino o Serviço Cognitivo do Azure para API de Linguagem versão 2022-04-01-preview.

Detecção de Idioma
Análise de Sentimento
Extração de Frases-Chave
Reconhecimento de Entidade Nomeada
Reconhecimento de informações de identificação pessoal
Vinculação de Identidade
Análise de serviços de saúde
Resumo extrativo
Reconhecimento de Entidade Personalizada
Classificação personalizada de documentos
Suporte a várias ações por documento

Use a biblioteca de clientes para:

Detecte em qual texto de entrada de idioma está escrito.
Determine o que os clientes pensam de sua marca ou tópico analisando texto bruto para obter pistas sobre sentimento positivo ou negativo.
Extrai automaticamente frases-chave para identificar rapidamente os principais pontos.
Identifique e categorize entidades em seu texto como pessoas, locais, organizações, data/hora, quantidades, percentuais, moedas, específicos à saúde e muito mais.
Execute várias das tarefas acima ao mesmo tempo.

Links principais:

Introdução

Ambientes com suporte no momento

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

Confira nossa política de suporte para mais detalhes.

Pré-requisitos

Uma assinatura do Azure.
Um recurso de Linguagem ou Serviços Cognitivos existente. Se você precisar criar o recurso, poderá usar o Portal do Azure ou a CLI do Azure.

Se você usar a CLI do Azure, substitua <your-resource-group-name> e <your-resource-name> por 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 clientes 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 cliente para acessar a API de Linguagem, você precisará do endpoint recurso de Linguagem e de um credential. O cliente de Análise de Texto pode usar credenciais do Azure Active Directory ou uma credencial de chave de API para autenticar.

Você pode encontrar o ponto de extremidade para o recurso idioma no Portal do Azure ou usando o snippet da CLI do Azure abaixo:

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

Usando uma chave de API

Use o Portal do Azure para navegar até o recurso Idioma e recuperar uma chave de API ou usar o snippet da CLI do Azure abaixo:

Nota: Às vezes, a chave de API é chamada de "chave de assinatura" ou "chave de API de assinatura".

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

Depois de ter uma chave de API e um ponto de extremidade, você poderá usar a AzureKeyCredential classe para autenticar o cliente da seguinte maneira:

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

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

Usando uma credencial do Azure Active Directory

A autenticação de chave de API do cliente é usada na maioria dos exemplos, mas você também pode autenticar com o Azure Active Directory usando a biblioteca de Identidade do Azure. Para usar o provedor DefaultAzureCredential mostrado abaixo ou outros provedores de credenciais fornecidos com o SDK do Azure, instale o @azure/identity pacote:

npm install @azure/identity

Você também precisará registrar um novo aplicativo do AAD e conceder acesso ao Language atribuindo a "Cognitive Services User" função à entidade de serviço (observação: outras funções como "Owner" não concederão as permissões necessárias, bastará apenas "Cognitive Services User" executar os exemplos e o código de exemplo).

Defina os valores da ID do cliente, da ID do locatário e do segredo do cliente do aplicativo AAD como variáveis de ambiente: 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());

Principais conceitos

TextAnalysisClient

TextAnalysisClient é a interface primária para desenvolvedores que usam a biblioteca de clientes de Análise de Texto. Explore os métodos neste objeto cliente para entender os diferentes recursos do serviço de Linguagem que você pode acessar.

Entrada

Um documento representa uma única unidade de entrada a ser analisada pelos modelos preditivos no serviço de linguagem. As operações em TextAnalysisClient levam 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 de caracteres ou como objetos com metadados anexados.

Por exemplo, cada documento pode ser passado como uma cadeia de caracteres em uma 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 você quiser passar um documento id por item ou languagecountryHint/, ele poderá ser dado como uma lista de TextDocumentInput ou DetectLanguageInput 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!" },
];

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

Valor Retornado

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

Um resultado, como SentimentAnalysisResult, é o resultado de uma operação language, contendo uma previsão ou previsõ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 ele 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.

Tratamento de erros de documento

Na coleção retornada por uma operação, os erros são diferenciados das respostas bem-sucedidas pela presença da error propriedade , que contém o objeto interno TextAnalysisError se um erro foi encontrado. Para objetos de resultado bem-sucedidos, essa propriedade é sempreundefined.

Por exemplo, para filtrar todos os erros, você pode usar o seguinte filter:

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

Observação: os usuários do TypeScript podem se beneficiar de uma melhor verificação de tipo de objetos de resultado e erro se compilerOptions.strictNullChecks estiver definido 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 Sentimento

Analise o sentimento do texto para determinar se ele é positivo, negativo, neutro ou misto, incluindo análise de sentimento por frase e pontuaçõ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 a aspectos de um produto/serviço, também conhecido como NlP (Análise de Sentimento Baseado em Aspectos no Processamento de Linguagem Natural), consulte um exemplo de análise de sentimento com mineração de opiniões aqui.

Reconhecimento de Entidade

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

O language é opcional. Se não for especificado, o modelo padrão em inglês será usado.

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 Entidade pii

Há uma ação separada para reconhecer informações de identificação pessoal (PII) no texto, como Números da Previdência Social, informações de conta bancária, números de cartão de crédito etc. Seu uso é 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();

Vinculação de Identidade

Uma entidade "Vinculada" é aquela que existe em um base de dados de conhecimento (como a Wikipédia). A EntityLinking ação pode desambiguar entidades determinando a qual entrada em um base de dados de conhecimento elas provavelmente se referem (por exemplo, em um pedaço de texto, a palavra "Marte" se refere ao planeta ou ao deus romano da guerra). As entidades vinculadas contêm URLs associadas à 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 Frases-Chave

A extração de frases-chave identifica os principais pontos de discussão em um documento. Por exemplo, texto de entrada especificado “A comida estava deliciosa e a equipe foi maravilhosa”, o serviço retorna “comida” e “equipe maravilhosa”.

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

Detecção de Idioma

Determine o idioma de um texto.

O countryHint parâmetro é opcional, mas pode ajudar o serviço a fornecer a saída correta se o país de origem for conhecido. Se fornecido, ele deverá 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, o modelo padrão "us" (Estados Unidos) será usado. Se você não souber o país de origem do documento, o parâmetro "none" deverá ser usado e o serviço de Linguagem aplicará um modelo ajustado 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 serviços de saúde

A análise de serviços de saúde identifica entidades de saúde. Por exemplo, dado o texto de entrada "Prescrito 100mg ibuprofeno, tomado duas vezes por dia", o serviço retorna "100mg" categorizado como Dosagem, "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 ao qual 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 Entidade Personalizada

Reconhecer e categorizar entidades em texto como entidades usando modelos de detecção de entidade personalizados criados usando 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 de rótulo único personalizado

Classifique documentos usando modelos personalizados de rótulo único criados usando 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 de vários rótulos personalizada

Classifique documentos usando modelos personalizados de vários rótulos criados usando 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();

Envio em lote de ação

Aplica várias ações em cada documento de entrada em uma solicitação 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();

Solução de problemas

Log

A habilitação do log pode ajudar a descobrir informações úteis sobre falhas. Para ver um log de solicitações e respostas HTTP, defina a variável de ambiente AZURE_LOG_LEVEL como info. Como alternativa, o log pode ser habilitado no runtime chamando setLogLevel em @azure/logger:

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

setLogLevel("info");

Para obter instruções mais detalhadas sobre como habilitar logs, veja os documentos do pacote @azure/logger.

Próximas etapas

Dê uma olhada no diretório de exemplos para obter exemplos detalhados sobre como usar essa biblioteca.

Contribuição

Se você quiser contribuir com essa biblioteca, leia o guia de contribuição para saber como criar e testar o código.

SDK do Microsoft Azure para JavaScript

Impressões

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

Introdução

Ambientes com suporte no momento

Pré-requisitos

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

Criar e autenticar um `TextAnalysisClient`

Usando uma chave de API

Usando uma credencial do Azure Active Directory

Principais conceitos

TextAnalysisClient

Entrada

Valor Retornado

Tratamento de erros de documento

Exemplos

Análise de Sentimento

Reconhecimento de Entidade

Reconhecimento de Entidade pii

Vinculação de Identidade

Extração de Frases-Chave

Detecção de Idioma

Análise de serviços de saúde

Resumo extrativo

Reconhecimento de Entidade Personalizada

Classificação de rótulo único personalizado

Classificação de vários rótulos personalizada

Envio em lote de ação

Solução de problemas

Log

Próximas etapas

Contribuição

Comentários

Recursos adicionais

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

Introdução

Ambientes com suporte no momento

Pré-requisitos

Instalar o pacote @azure/ai-text-analytics

Criar e autenticar um TextAnalysisClient

Usando uma chave de API

Usando uma credencial do Azure Active Directory

Principais conceitos

TextAnalysisClient

Entrada

Valor Retornado

Tratamento de erros de documento

Exemplos

Análise de Sentimento

Reconhecimento de Entidade

Reconhecimento de Entidade pii

Vinculação de Identidade

Extração de Frases-Chave

Detecção de Idioma

Análise de serviços de saúde

Resumo extrativo

Reconhecimento de Entidade Personalizada

Classificação de rótulo único personalizado

Classificação de vários rótulos personalizada

Envio em lote de ação

Solução de problemas

Log

Próximas etapas

Contribuição

Projetos relacionados

Comentários

Recursos adicionais

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

Criar e autenticar um `TextAnalysisClient`