Udostępnij za pośrednictwem

Biblioteka klienta analizy tekstu platformy Azure dla języka JavaScript — wersja 6.0.0-beta.1

  • Artykuł

Azure Cognitive Service for Language to usługa oparta na chmurze, która zapewnia zaawansowane przetwarzanie języka naturalnego w nieprzetworzonym tekście i obejmuje następujące główne funkcje:

Uwaga: Ten zestaw SDK jest przeznaczony dla usługi Azure Cognitive Service dla interfejsu API języka w wersji 2022-04-01-preview.

  • Wykrywanie języka
  • Analiza tonacji
  • Wyodrębnianie kluczowych fraz
  • Rozpoznawanie jednostek nazwanych
  • Rozpoznawanie danych osobowych
  • Łączenie jednostek
  • Analiza opieki zdrowotnej
  • Podsumowanie wyodrębniające
  • Niestandardowe rozpoznawanie jednostek
  • Niestandardowa klasyfikacja dokumentów
  • Obsługa wielu akcji na dokument

Użyj biblioteki klienta, aby:

  • Wykryj, w jakim języku jest zapisywany tekst wejściowy.
  • Określ, co klienci myślą o twojej marce lub temacie, analizując nieprzetworzone tekst pod kątem wskazówek dotyczących pozytywnych lub negatywnych tonacji.
  • Automatycznie wyodrębniaj kluczowe frazy, aby szybko identyfikować główne punkty.
  • Identyfikowanie i kategoryzowanie jednostek w tekście jako osób, miejsc, organizacji, daty/godziny, ilości, wartości procentowych, walut, specyficznych dla opieki zdrowotnej i nie tylko.
  • Wykonaj wiele powyższych zadań jednocześnie.

Kluczowe linki:

Wprowadzenie

Obecnie obsługiwane środowiska

Aby uzyskać więcej informacji, zobacz nasze zasady pomocy technicznej .

Wymagania wstępne

Jeśli używasz interfejsu wiersza polecenia platformy Azure, zastąp <your-resource-group-name> ciąg i <your-resource-name> własnymi unikatowymi nazwami:

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

Instalowanie pakietu @azure/ai-text-analytics

Zainstaluj bibliotekę klienta analizy tekstu platformy Azure dla języka JavaScript przy użyciu polecenia npm:

npm install @azure/ai-text-analytics

Tworzenie i uwierzytelnianie TextAnalysisClient

Aby utworzyć obiekt klienta w celu uzyskania dostępu do interfejsu API języka, potrzebny endpoint będzie zasób Language i .credential Klient analizy tekstu może używać poświadczeń usługi Azure Active Directory lub poświadczeń klucza interfejsu API do uwierzytelniania.

Punkt końcowy zasobu Language można znaleźć w witrynie Azure Portal lub przy użyciu poniższego fragmentu wiersza polecenia platformy Azure :

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

Używanie klucza interfejsu API

Użyj witryny Azure Portal , aby przejść do zasobu Language i pobrać klucz interfejsu API lub użyć poniższego fragmentu kodu interfejsu wiersza polecenia platformy Azure :

Uwaga: Czasami klucz interfejsu API jest nazywany "kluczem subskrypcji" lub "kluczem interfejsu API subskrypcji".

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

Po utworzeniu klucza interfejsu AzureKeyCredential API i punktu końcowego możesz użyć klasy do uwierzytelnienia klienta w następujący sposób:

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

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

Używanie poświadczeń usługi Azure Active Directory

Uwierzytelnianie klucza interfejsu API klienta jest używane w większości przykładów, ale można również uwierzytelnić się w usłudze Azure Active Directory przy użyciu biblioteki tożsamości platformy Azure. Aby użyć poniższego dostawcy DefaultAzureCredential lub innych dostawców poświadczeń dostarczonych z zestawem Azure SDK, zainstaluj @azure/identity pakiet:

npm install @azure/identity

Należy również zarejestrować nową aplikację usługi AAD i udzielić dostępu do języka, przypisując "Cognitive Services User" rolę do jednostki usługi (uwaga: inne role, takie jak "Owner" nie będą udzielać niezbędnych uprawnień, wystarczy "Cognitive Services User" uruchomić przykłady i przykładowy kod).

Ustaw wartości identyfikatora klienta, identyfikatora dzierżawy i wpisu tajnego klienta aplikacji usługi AAD jako zmienne środowiskowe: AZURE_CLIENT_ID, , AZURE_CLIENT_SECRETAZURE_TENANT_ID.

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

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

Kluczowe pojęcia

TextAnalysisClient

TextAnalysisClient jest podstawowym interfejsem dla deweloperów korzystających z biblioteki klienta analizy tekstu. Zapoznaj się z metodami w tym obiekcie klienta, aby zrozumieć różne funkcje usługi językowej, do których możesz uzyskać dostęp.

Dane wejściowe

Dokument reprezentuje jedną jednostkę danych wejściowych do analizy przez modele predykcyjne w usłudze językowej. Operacje dotyczące TextAnalysisClient pobierania kolekcji danych wejściowych, które mają być analizowane jako partia. Metody operacji mają przeciążenia, które umożliwiają reprezentację danych wejściowych jako ciągi lub obiekty z dołączonymi metadanymi.

Na przykład każdy dokument można przekazać jako ciąg w tablicy, np.

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

lub, jeśli chcesz przekazać dokument id na element lub languagecountryHint/, mogą one być podane jako lista TextDocumentInput lub DetectLanguageInput w zależności od operacji;

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

Zobacz ograniczenia usługi dotyczące danych wejściowych , w tym limity długości dokumentu, maksymalny rozmiar partii i obsługiwane kodowanie tekstu.

Wartość zwracana

Zwracana wartość odpowiadająca pojedynczemu dokumentowi jest wynikiem pomyślnym lub obiektem błędu. Każda TextAnalysisClient metoda zwraca heterogeniczną tablicę wyników i błędów odpowiadających danych wejściowych według indeksu. Dane wejściowe tekstu i jego wynik będą miały ten sam indeks w kolekcjach danych wejściowych i wynikowych.

Wynik, taki jak SentimentAnalysisResult, jest wynikiem operacji języka zawierającej przewidywanie lub przewidywania dotyczące pojedynczego tekstu wejściowego. Typ wyniku operacji może również opcjonalnie zawierać informacje o dokumencie wejściowym i sposobie jego przetwarzania.

Obiekt błędu , wskazuje, TextAnalysisErrorResultże usługa napotkała błąd podczas przetwarzania dokumentu i zawiera informacje o błędzie.

Obsługa błędów dokumentu

W kolekcji zwróconej przez operację błędy są rozróżniane od pomyślnych odpowiedzi przez obecność error właściwości, która zawiera obiekt wewnętrzny TextAnalysisError , jeśli wystąpił błąd. W przypadku obiektów wyników zakończonych powodzeniem ta właściwość jest zawszeundefined.

Aby na przykład odfiltrować wszystkie błędy, można użyć następującego filterpolecenia:

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

Uwaga: użytkownicy języka TypeScript mogą korzystać z lepszego sprawdzania typów obiektów wyników i błędów, jeśli compilerOptions.strictNullChecks jest ustawiona na true w tsconfig.json konfiguracji. Przykład:

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

Przykłady

Analiza tonacji

Przeanalizuj tonację tekstu, aby określić, czy jest dodatnia, negatywna, neutralna lub mieszana, w tym analiza tonacji na zdanie i wyniki ufności.

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

Aby uzyskać bardziej szczegółowe informacje o opiniach związanych z aspektami produktu/usługi, znany również jako Analiza tonacji opartej na aspektach w przetwarzaniu języka naturalnego (NLP), zobacz przykład analizy tonacji z wyszukiwaniem opinii tutaj.

Rozpoznawanie jednostek

Rozpoznawanie i kategoryzowanie jednostek w tekście jako osób, miejsc, organizacji, dat/godzin, ilości, walut itp.

Parametr language jest opcjonalny. Jeśli nie zostanie określony, zostanie użyty domyślny model angielski.

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

Rozpoznawanie jednostek PII

Istnieje osobna akcja rozpoznawania danych osobowych (PII) w tekście, takim jak numery ubezpieczenia społecznego, informacje o koncie bankowym, numery kart kredytowych itp. Jego użycie jest bardzo podobne do powyższego rozpoznawania jednostek standardowych:

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

Łączenie jednostek

Jednostka "Połączona" to jednostka, która istnieje w baza wiedzy (na przykład Wikipedia). Akcja EntityLinking może uściślać jednostki, określając, który wpis w baza wiedzy prawdopodobnie się odwołuje (na przykład w kawałku tekstu, czy słowo "Mars" odnosi się do planety lub do rzymskiego boga wojny). Połączone jednostki zawierają skojarzone adresy URL do baza wiedzy, które udostępniają definicję jednostki.

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

Wyodrębnianie kluczowych fraz

Wyodrębnianie kluczowych fraz identyfikuje główne punkty rozmów w dokumencie. Na przykład podany tekst wejściowy "Jedzenie było pyszne i były wspaniałe personel", usługa zwraca "jedzenie" i "wspaniały personel".

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

Wykrywanie języka

Określanie języka fragmentu tekstu.

Parametr countryHint jest opcjonalny, ale może pomóc usłudze w dostarczaniu poprawnych danych wyjściowych, jeśli kraj pochodzenia jest znany. W przypadku podania należy ustawić dwuliterowy kod kraju ISO-3166 Alpha-2 (taki jak "us" dla Stany Zjednoczone lub "jp" dla Japonii) lub wartość "none". Jeśli parametr nie zostanie podany, zostanie użyty domyślny "us" model (Stany Zjednoczone). Jeśli nie znasz kraju pochodzenia dokumentu, należy użyć parametru "none" , a usługa językowa zastosuje model dostosowany do nieznanego kraju pochodzenia.

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

Analiza opieki zdrowotnej

Analiza opieki zdrowotnej identyfikuje jednostki opieki zdrowotnej. Na przykład, biorąc pod uwagę tekst wejściowy "Przepisane 100mg ibuprofen, podjęte dwa razy dziennie", usługa zwraca "100mg" kategoryzowane jako Dawkowanie, "ibuprofen" jako LekiName i "dwa razy dziennie" jako Częstotliwość.

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

Podsumowanie wyodrębniania

Podsumowanie wyodrębniane identyfikuje zdania podsumowujące artykuł, do którego należą.

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

Niestandardowe rozpoznawanie jednostek

Rozpoznawanie i kategoryzowanie jednostek w tekście jako jednostek przy użyciu niestandardowych modeli wykrywania jednostek utworzonych przy użyciu programu 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();

Niestandardowa klasyfikacja z pojedynczą etykietą

Klasyfikowanie dokumentów przy użyciu niestandardowych modeli z pojedynczą etykietą utworzonych przy użyciu usługi 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();

Niestandardowa klasyfikacja wielu etykiet

Klasyfikowanie dokumentów przy użyciu niestandardowych modeli z wieloma etykietami utworzonych przy użyciu usługi 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();

Przetwarzanie wsadowe akcji

Stosuje wiele akcji dla każdego dokumentu wejściowego w jednym żądaniu obsługi.

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

Rozwiązywanie problemów

Rejestrowanie

Włączenie rejestrowania może pomóc odkryć przydatne informacje o błędach. Aby wyświetlić dziennik żądań i odpowiedzi HTTP, ustaw zmienną AZURE_LOG_LEVEL środowiskową na info. Alternatywnie rejestrowanie można włączyć w czasie wykonywania, wywołując setLogLevel polecenie w pliku @azure/logger:

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

setLogLevel("info");

Aby uzyskać bardziej szczegółowe instrukcje dotyczące włączania dzienników, zapoznaj się z dokumentami dotyczącymi pakietów @azure/rejestratora.

Następne kroki

Zapoznaj się z katalogiem samples , aby zapoznać się ze szczegółowymi przykładami dotyczącymi korzystania z tej biblioteki.

Współtworzenie

Jeśli chcesz współtworzyć tę bibliotekę, przeczytaj przewodnik współtworzenia , aby dowiedzieć się więcej na temat tworzenia i testowania kodu.

Wrażenia