Partilhar via

Biblioteca de cliente do Azure Text Analytics para JavaScript - versão 5.1.0

  • Artigo

Azure TextAnalytics é um serviço baseado na nuvem que fornece processamento avançado de linguagem natural sobre texto bruto e inclui seis funções principais:

Nota: Este SDK destina-se à API do serviço Azure Text Analytics versão 3.1.0.

  • Deteção de idioma
  • Análise de Sentimento
  • Extração de frases-chave
  • Reconhecimento de entidade nomeada
  • Reconhecimento de Informações Pessoalmente Identificáveis
  • Reconhecimento de Entidades Vinculadas
  • Análise de cuidados de saúde
  • Suporte a várias ações por documento

Use a biblioteca de cliente para:

  • Detete em que idioma o texto de entrada está escrito.
  • Determine o que os clientes pensam da sua marca ou tópico analisando o texto bruto em busca de pistas sobre sentimentos positivos ou negativos.
  • Extraia automaticamente frases-chave 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.
  • Execute várias das tarefas acima de uma só vez.

Ligações principais:

Primeiros passos

Ambientes atualmente suportados

Consulte o nosso de política de suporte para obter mais detalhes.

Pré-requisitos

  • Uma assinatura do Azure.
  • Um de Serviços Cognitivos existente ou um recurso de Análise de Texto. Se precisar criar o recurso, você pode usar o do Portal do Azure ou da 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 cliente do Azure Text Analytics para JavaScript com npm:

npm install @azure/ai-text-analytics

Criar e autenticar um TextAnalyticsClient

Para criar um objeto cliente para acessar a API de Análise de Texto, você precisará da endpoint do recurso de Análise de Texto e de um credential. O cliente de Análise de Texto pode usar credenciais do Azure Ative Directory ou uma credencial de chave de API para autenticar.

Você pode encontrar o ponto de extremidade para seu recurso de análise de texto no do Portal do Azure ou usando o trecho de da CLI do Azure abaixo:

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

Usando uma chave de API

Use o Portal do Azure para navegar até seu recurso de Análise de Texto e recuperar uma chave de API ou use o trecho de da CLI do Azure abaixo:

Nota: Às vezes, a chave da API é chamada de "chave de assinatura" ou "chave da 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ê pode usar a classe AzureKeyCredential para autenticar o cliente da seguinte maneira:

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

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

Usando uma credencial do Azure Ative Directory

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

npm install @azure/identity

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

Defina os valores do ID do cliente, ID do locatário e segredo do cliente do aplicativo AAD como variáveis de ambiente: AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET.

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

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

Conceitos-chave

TextAnalyticsClient

TextAnalyticsClient é a interface principal para desenvolvedores que usam a biblioteca de cliente do Text Analytics. Explore os métodos neste objeto de cliente para entender os diferentes recursos do serviço de Análise de Texto que você pode acessar.

Entrada

Um documento representa uma única unidade de entrada a ser analisada pelos modelos preditivos no serviço de Análise de Texto. As operações em TextAnalyticsClient levam uma coleção de insumos para serem analisados 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 desejar passar um documento por item id ou language/countryHint, eles podem ser fornecidos 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 de 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.

Valor de retorno

O valor de retorno correspondente a um único documento é um resultado bem-sucedido ou um objeto de erro. Cada método TextAnalyticsClient 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. A coleção também pode, opcionalmente, incluir informações sobre o lote de entrada e como ele foi processado no campo statistics.

Um resultado , como AnalyzeSentimentResult, é o resultado de uma operação de Análise de Texto, contendo uma previsão ou previsões sobre uma única entrada de texto. O tipo de resultado de uma operação também pode, opcionalmente, incluir informações sobre o documento de entrada e como ele foi processado.

O erro objeto, TextAnalyticsErrorResult, indica que o serviço encontrou um erro durante o processamento do documento e contém informações sobre o erro.

Tratamento de erros de documentos

Na coleção retornada por uma operação, os erros são distinguidos das respostas bem-sucedidas pela presença da propriedade error, que contém o objeto TextAnalyticsError interno 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.analyzeSentiment(documents);
const onlySuccessful = results.filter((result) => result.error === undefined);

Nota: 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 configuração tsconfig.json. Por exemplo:

const [result] = await client.analyzeSentiment(["Hello world!"]);

if (result.error !== undefined) {
  // In this if block, TypeScript will be sure that the type of `result` is
  // `TextAnalyticsError` if compilerOptions.strictNullChecks is enabled in
  // the tsconfig.json

  console.log(result.error);
}

Esse recurso foi introduzido no TypeScript 3.2, portanto, os usuários do TypeScript 3.1 devem converter valores de resultado para sua variante de sucesso correspondente da seguinte maneira:

const [result] = await client.detectLanguage(["Hello world!"]);

if (result.error === undefined) {
  const { primaryLanguage } = result as DetectLanguageSuccessResult;
}

Exemplos

Analise o 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 { TextAnalyticsClient, AzureKeyCredential } = require("@azure/ai-text-analytics");

const client = new TextAnalyticsClient("<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.analyzeSentiment(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 aspetos de um produto/serviço, também conhecido como Análise de Sentimento Baseada em Aspetos no Processamento de Linguagem Natural (NLP), consulte um exemplo sobre análise de sentimento com mineração de opinião aqui.

Reconhecer Entidades

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

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

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

const client = new TextAnalyticsClient("<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.recognizeEntities(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();

Reconhecer entidades PII

Há um ponto final e uma operação separados para reconhecer Informações de Identificação Pessoal (PII) em texto, como números de segurança 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 { TextAnalyticsClient, AzureKeyCredential } = require("@azure/ai-text-analytics");
const client = new TextAnalyticsClient("<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.recognizePiiEntities(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();

Reconhecer entidades vinculadas

Uma entidade "Vinculada" é aquela que existe em uma base de conhecimento (como a Wikipédia). A operação recognizeLinkedEntities pode desambiguar entidades, determinando a qual entrada em uma base 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 { TextAnalyticsClient, AzureKeyCredential } = require("@azure/ai-text-analytics");

const client = new TextAnalyticsClient("<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.recognizeLinkedEntities(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();

Extrair frases-chave

A extração de frases-chave identifica os principais pontos de discussão em um documento. Por exemplo, dado o texto de entrada "A comida era deliciosa e havia uma equipe maravilhosa", o serviço retorna "comida" e "equipe maravilhosa".

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

const client = new TextAnalyticsClient("<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.extractKeyPhrases(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();

Detetar idioma

Determine o idioma de um texto.

O parâmetro countryHint é opcional, mas pode ajudar o serviço a fornecer resultados corretos se o país de origem for conhecido. Se fornecido, deve ser definido como um código de país ISO-3166 Alpha-2 de duas letras (como "nós" para os Estados Unidos ou "jp" para o Japão) ou para o valor "none". Se o parâmetro não for fornecido, o modelo "us" padrão (Estados Unidos) será usado. Se você não souber o país de origem do documento, o parâmetro "none" deve ser usado, e o serviço de Análise de Texto aplicará um modelo ajustado para um país de origem desconhecido.

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

const client = new TextAnalyticsClient("<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.detectLanguage(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();

Analise Entidades de Saúde

A análise de cuidados de saúde identifica entidades de saúde. Por exemplo, dado o texto de entrada "Prescrito 100mg de ibuprofeno, tomado duas vezes ao dia", o serviço retorna "100mg" categorizado como Dosagem, "ibuprofeno" como MedicationName, e "duas vezes ao dia" como Frequência.

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

const client = new TextAnalyticsClient("<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 poller = await client.beginAnalyzeHealthcareEntities(documents);
  const results = await poller.pollUntilDone();

  for await (const result of results) {
    console.log(`- Document ${result.id}`);
    if (!result.error) {
      console.log("\tRecognized Entities:");
      for (const entity of result.entities) {
        console.log(`\t- Entity ${entity.text} of type ${entity.category}`);
      }
    } else console.error("\tError:", result.error);
  }
}

main();

Analise ações

Analisar ações permite a aplicação de várias análises (ações nomeadas) ao mesmo tempo.

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

const client = new TextAnalyticsClient("<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 = {
    recognizeEntitiesActions: [{ modelVersion: "latest" }],
    recognizePiiEntitiesActions: [{ modelVersion: "latest" }],
    extractKeyPhrasesActions: [{ modelVersion: "latest" }]
  };
  const poller = await client.beginAnalyzeActions(documents, actions);
  const resultPages = await poller.pollUntilDone();
  for await (const page of resultPages) {
    const keyPhrasesAction = page.extractKeyPhrasesResults[0];
    if (!keyPhrasesAction.error) {
      for (const doc of keyPhrasesAction.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);
        }
      }
    }

    const entitiesAction = page.recognizeEntitiesResults[0];
    if (!entitiesAction.error) {
      for (const doc of entitiesAction.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);
        }
      }
    }

    const piiEntitiesAction = page.recognizePiiEntitiesResults[0];
    if (!piiEntitiesAction.error) {
      for (const doc of piiEntitiesAction.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);
        }
      }
    }
  }
}

main();

Solução de problemas

Registo

Habilitar o registro em 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 registro em log pode ser habilitado em tempo de execução chamando setLogLevel no @azure/logger:

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

setLogLevel("info");

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

Próximos passos

Por favor, dê uma olhada no exemplos diretório para obter exemplos detalhados sobre como usar esta biblioteca.

Contribuição

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

Impressões