Udostępnij za pośrednictwem

Biblioteka klienta analizy dokumentów usługi Azure AI dla języka JavaScript — wersja 5.0.0

  • Artykuł

Azure AI Document Intelligence to usługa w chmurze, która korzysta z uczenia maszynowego do analizowania tekstu i danych strukturalnych z dokumentów. Zawiera ona następujące główne funkcje:

  • Układ — wyodrębnianie tekstu, struktur tabeli i znaczników zaznaczenia wraz ze współrzędnymi regionów ograniczenia z dokumentów.
  • Dokument — analizowanie jednostek, par klucz-wartość, tabel i znaków wyboru z dokumentów przy użyciu ogólnego wstępnie utworzonego modelu dokumentu.
  • Odczyt — odczytywanie informacji o elementach tekstowych, takich jak wyrazy stron i wiersze oprócz informacji o języku tekstowym.
  • Wstępnie utworzone — analizowanie danych z niektórych typów typowych dokumentów (takich jak paragony, faktury, wizytówki lub dokumenty tożsamości) przy użyciu wstępnie utworzonych modeli.
  • Niestandardowe — twórz modele niestandardowe, aby wyodrębniać tekst, wartości pól, znaczniki wyboru i dane tabeli z dokumentów. Modele niestandardowe są tworzone przy użyciu własnych danych, dzięki czemu są dostosowane do Twoich dokumentów.
  • Klasyfikatory — twórz niestandardowe klasyfikatory, aby kategoryzować dokumenty do wstępnie zdefiniowanych klas.

Kod | źródłowyPakiet (NPM) | Dokumentacja referencyjna interfejsu | APIDokumentacja | produktuPróbki

Uwaga

Usługa analizy dokumentów była wcześniej znana jako "Azure Form Recognizer". Te usługi są takie same, a @azure/ai-form-recognizer pakiet dla języka JavaScript jest pakietem zestawu Azure SDK dla usługi Azure AI Document Intelligence Service. W momencie pisania tego artykułu zmiana nazwy usługi Azure Form Recognizer na analizę dokumentów sztucznej inteligencji platformy Azure jest w toku, więc "Form Recognizer" i "Analiza dokumentów" mogą być używane zamiennie w niektórych przypadkach.

Instalowanie pakietu @azure/ai-form-recognizer

Zainstaluj bibliotekę klienta azure Document Intelligence dla języka JavaScript za pomocą polecenia npm:

npm install @azure/ai-form-recognizer

Wprowadzenie

const { DocumentAnalysisClient } = require("@azure/ai-form-recognizer");
const { DefaultAzureCredential } = require("@azure/identity");

const fs = require("fs");

const credential = new DefaultAzureCredential();
const client = new DocumentAnalysisClient(
  "https://<resource name>.cognitiveservices.azure.com",
  credential
);

// Document Intelligence supports many different types of files.
const file = fs.createReadStream("path/to/file.jpg");
const poller = await client.beginAnalyzeDocument("<model ID>", file);

const { pages, tables, styles, keyValuePairs, entities, documents } = await poller.pollUntilDone();

Obecnie obsługiwane środowiska

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

Wymagania wstępne

Tworzenie zasobu Form Recognizer

Uwaga: w momencie pisania Azure Portal nadal odnosi się do zasobu jako zasobu "Form Recognizer". W przyszłości może to zostać zaktualizowane do zasobu "Analiza dokumentów". Na razie poniższa dokumentacja używa nazwy "Form Recognizer".

Analiza dokumentów obsługuje zarówno dostęp do wielu usług, jak i z jedną usługą. Utwórz zasób usług Cognitive Services, jeśli planujesz dostęp do wielu usług Cognitive Services w ramach jednego punktu końcowego/klucza. W przypadku dostępu tylko Form Recognizer utwórz zasób Form Recognizer.

Zasób można utworzyć przy użyciu polecenia

Opcja 1.Witryna Azure Portal

Opcja 2:interfejs wiersza polecenia platformy Azure.

Poniżej przedstawiono przykład tworzenia zasobu Form Recognizer przy użyciu interfejsu wiersza polecenia:

# Create a new resource group to hold the Form Recognizer resource -
# if using an existing resource group, skip this step
az group create --name my-resource-group --location westus2

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

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

Tworzenie i uwierzytelnianie klienta

Aby wchodzić w interakcję z usługą Analizy dokumentów, musisz wybrać typ DocumentAnalysisClient lub , DocumentModelAdministrationClienta następnie utworzyć wystąpienie tego typu. W poniższych przykładach użyjemy elementu DocumentAnalysisClient. Aby utworzyć wystąpienie klienta w celu uzyskania dostępu do interfejsu API analizy dokumentów, musisz mieć endpoint zasób Form Recognizer i element credential. Klienci mogą używać AzureKeyCredential elementu z kluczem interfejsu API zasobu lub przy TokenCredential użyciu kontroli dostępu opartej na rolach usługi Azure Active Directory w celu autoryzowania klienta.

Punkt końcowy zasobu Form Recognizer 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 Form Recognizer i pobrać klucz interfejsu API lub użyć poniższego fragmentu kodu interfejsu wiersza polecenia platformy Azure:

Uwaga: Czasami klucz interfejsu API jest określany jako "klucz subskrypcji" lub "klucz interfejsu API subskrypcji".

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

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

const { DocumentAnalysisClient, AzureKeyCredential } = require("@azure/ai-form-recognizer");

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

Korzystanie z usługi Azure Active Directory

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

npm install @azure/identity

Aby uwierzytelnić się przy użyciu jednostki usługi, należy również zarejestrować aplikację usługi AAD i udzielić dostępu do usługi, 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 klucza tajnego klienta aplikacji usługi AAD jako zmienne środowiskowe: AZURE_CLIENT_ID, , AZURE_CLIENT_SECRETAZURE_TENANT_ID.

const { DocumentAnalysisClient } = require("@azure/ai-form-recognizer");
const { DefaultAzureCredential } = require("@azure/identity");

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

Kluczowe pojęcia

DocumentAnalysisClient

DocumentAnalysisClient Udostępnia operacje analizowania dokumentów wejściowych przy użyciu niestandardowych i wstępnie utworzonych modeli. Ma trzy metody:

  • beginAnalyzeDocument, który wyodrębnia dane ze strumienia wejściowego pliku dokumentu przy użyciu niestandardowego lub wstępnie utworzonego modelu podanego przez jego identyfikator modelu. Aby uzyskać informacje o wstępnie utworzonych modelach obsługiwanych we wszystkich zasobach i ich identyfikatorach/danych wyjściowych modelu, zapoznaj się z dokumentacją usługi modeli.
  • beginAnalyzeDocumentFromUrl, który wykonuje tę samą funkcję co beginAnalyzeDocument, ale przesyła publicznie dostępny adres URL pliku zamiast strumienia plików.

DocumentModelAdministrationClient

DocumentModelAdministrationClient Udostępnia operacje zarządzania (tworzeniem, odczytywaniem, wyświetlaniem i usuwaniem) modeli w zasobie:

  • beginBuildDocumentModel Uruchamia operację tworzenia nowego modelu dokumentu na podstawie własnego zestawu danych treningowych. Utworzony model może wyodrębniać pola zgodnie ze schematem niestandardowym. Dane szkoleniowe powinny znajdować się w kontenerze usługi Azure Storage i zorganizowane zgodnie z określoną konwencją. Zapoznaj się z dokumentacją usługi dotyczącą tworzenia zestawu danych treningowych , aby uzyskać bardziej szczegółowe wyjaśnienie stosowania etykiet do zestawu danych treningowych.
  • beginComposeDocumentModel uruchamia operację redagowania wielu modeli w jeden model. W przypadku użycia do niestandardowego rozpoznawania formularzy nowy model komponowany najpierw przeprowadzi klasyfikację dokumentów wejściowych, aby określić, które z jej modeli podrzędnych jest najbardziej odpowiednie.
  • beginCopyModelTo Uruchamia operację kopiowania modelu niestandardowego z jednego zasobu do innego (a nawet do tego samego zasobu). Wymaga elementu CopyAuthorization z zasobu docelowego, który można wygenerować przy użyciu getCopyAuthorization metody .
  • getResourceDetails pobiera informacje o limitach zasobów, takich jak liczba modeli niestandardowych i maksymalna liczba modeli, które może obsłużyć zasób.
  • getDocumentModel, listDocumentModelsi deleteDocumentModel umożliwiają zarządzanie modelami w zasobie.
  • getOperation umożliwia listOperations wyświetlanie stanu operacji tworzenia modelu, nawet tych, które są w toku lub które zakończyły się niepowodzeniem. Operacje są przechowywane przez 24 godziny.

Należy pamiętać, że modele można również tworzyć przy użyciu graficznego interfejsu użytkownika usługi Document Intelligence Service: Document Intelligence Studio.

Przykładowe fragmenty kodu ilustrujące sposób tworzenia DocumentModelAdministrationClient modelu można znaleźć poniżej w sekcji przykładowej "Tworzenie modelu".

Długotrwałe operacje

Długotrwałe operacje (LROs) to operacje składające się z początkowego żądania wysłanego do usługi w celu uruchomienia operacji, a następnie sondowania wyniku w określonym interwale w celu określenia, czy operacja została ukończona, i czy zakończyła się niepowodzeniem, czy zakończyła się pomyślnie. Ostatecznie funkcja LRO zakończy się niepowodzeniem z powodu błędu lub wygeneruje wynik.

W usłudze Azure AI Document Intelligence operacje tworzenia modeli (w tym kopiowania i tworzenia modeli), a także operacje analizy/wyodrębniania danych to LROs. Klienci zestawu SDK udostępniają metody asynchroniczne begin<operation-name> , które zwracają Promise<PollerLike> obiekty. Obiekt PollerLike reprezentuje operację, która jest uruchamiana asynchronicznie w infrastrukturze usługi, a program może czekać na ukończenie operacji przez wywołanie metody i oczekiwanie pollUntilDone na metodę w poller zwróconej begin<operation-name> z metody . Przykładowe fragmenty kodu są udostępniane w celu zilustrowania użycia długotrwałych operacji w następnej sekcji.

Przykłady

Poniższa sekcja zawiera kilka fragmentów kodu JavaScript ilustrujących typowe wzorce używane w bibliotekach klienta analizy dokumentów.

Analizowanie dokumentu przy użyciu identyfikatora modelu

Metoda beginAnalyzeDocument może wyodrębniać pola i dane tabeli z dokumentów. Analiza może używać modelu niestandardowego, wytrenowanego przy użyciu własnych danych lub wstępnie utworzonego modelu dostarczonego przez usługę (zobacz Korzystanie ze wstępnie utworzonych modeli poniżej). Model niestandardowy jest dostosowany do własnych dokumentów, dlatego powinien być używany tylko z dokumentami tej samej struktury co jeden z typów dokumentów w modelu (może istnieć wiele, na przykład w modelu skomponowanym).

const { DocumentAnalysisClient, AzureKeyCredential } = require("@azure/ai-form-recognizer");

const fs = require("fs");

async function main() {
  const endpoint = "<cognitive services endpoint>";
  const apiKey = "<api key>";
  const modelId = "<model id>";
  const path = "<path to a document>";

  const readStream = fs.createReadStream(path);

  const client = new DocumentAnalysisClient(endpoint, new AzureKeyCredential(apiKey));
  const poller = await client.beginAnalyzeDocument(modelId, readStream, {
    onProgress: ({ status }) => {
      console.log(`status: ${status}`);
    },
  });

  // There are more fields than just these three
  const { documents, pages, tables } = await poller.pollUntilDone();

  console.log("Documents:");
  for (const document of documents || []) {
    console.log(`Type: ${document.docType}`);
    console.log("Fields:");
    for (const [name, field] of Object.entries(document.fields)) {
      console.log(
        `Field ${name} has value '${field.value}' with a confidence score of ${field.confidence}`
      );
    }
  }
  console.log("Pages:");
  for (const page of pages || []) {
    console.log(`Page number: ${page.pageNumber} (${page.width}x${page.height} ${page.unit})`);
  }

  console.log("Tables:");
  for (const table of tables || []) {
    console.log(`- Table (${table.columnCount}x${table.rowCount})`);
    for (const cell of table.cells) {
      console.log(`  - cell (${cell.rowIndex},${cell.columnIndex}) "${cell.content}"`);
    }
  }
}

main().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Analizowanie dokumentu z adresu URL

Zamiast tego można podać publicznie dostępny adres URL jako alternatywę dla zapewnienia czytelnego strumienia beginAnalyzeDocumentFromUrl przy użyciu metody . "Dostępny publicznie" oznacza, że źródła adresów URL muszą być dostępne z infrastruktury usługi (innymi słowy, prywatny adres URL intranetu lub adresy URL używające wpisów tajnych opartych na nagłówku lub certyfikatach, nie będą działać, ponieważ usługa analizy dokumentów musi mieć dostęp do adresu URL). Jednak sam adres URL może kodować wpis tajny, taki jak adres URL obiektu blob usługi Azure Storage, który zawiera token SAS w parametrach zapytania.

Korzystanie ze wstępnie utworzonych modeli dokumentów

Metoda beginAnalyzeDocument obsługuje również wyodrębnianie pól z niektórych typów typowych dokumentów, takich jak paragony, faktury, wizytówki, dokumenty tożsamości i inne przy użyciu wstępnie utworzonych modeli udostępnianych przez usługę Analizy dokumentów. Wstępnie utworzone modele mogą być udostępniane jako ciągi identyfikatorów modelu (takie same jak niestandardowe modele dokumentów — zobacz drugą wstępnie utworzoną sekcję DocumentModel modeli poniżej) lub używając obiektu. W przypadku korzystania z elementu DocumentModelzestaw SDK analizy dokumentów dla języka JavaScript zapewnia znacznie silniejszy typ języka TypeScript dla wynikowych wyodrębnionych dokumentów na podstawie schematu modelu i zostanie przekonwertowany na użycie konwencji nazewnictwa języka JavaScript.

Przykładowe DocumentModel obiekty dla bieżącej wersji interfejsu prebuiltAPI usługi (2022-08-31) można znaleźć w katalogu samples. W poniższym przykładzie użyjemy PrebuiltReceiptModel pliku z pliku [prebuilt-receipt.ts] w tym katalogu.

Ponieważ główną zaletą DocumentModelanalizy opartej na języku TypeScript jest silniejsze ograniczenia typu TypeScript, w języku TypeScript jest napisany następujący przykład przy użyciu składni modułu ECMAScript:

import { DocumentAnalysisClient, AzureKeyCredential } from "@azure/ai-form-recognizer";

// Copy the file from the above-linked sample directory so that it can be imported in this module
import { PrebuiltReceiptModel } from "./prebuilt/prebuilt-receipt";

import fs from "fs";

async function main() {
  const endpoint = "<cognitive services endpoint>";
  const apiKey = "<api key>";
  const path = "<path to your receipt document>"; // pdf/jpeg/png/tiff formats

  const readStream = fs.createReadStream(path);

  const client = new DocumentAnalysisClient(endpoint, new AzureKeyCredential(apiKey));

  // The PrebuiltReceiptModel `DocumentModel` instance encodes both the model ID and a stronger return type for the operation
  const poller = await client.beginAnalyzeDocument(PrebuiltReceiptModel, readStream, {
    onProgress: ({ status }) => {
      console.log(`status: ${status}`);
    },
  });

  const {
    documents: [receiptDocument],
  } = await poller.pollUntilDone();

  // The fields of the document constitute the extracted receipt data.
  const receipt = receiptDocument.fields;

  if (receipt === undefined) {
    throw new Error("Expected at least one receipt in analysis result.");
  }

  console.log(`Receipt data (${receiptDocument.docType})`);
  console.log("  Merchant Name:", receipt.merchantName?.value);

  // The items of the receipt are an example of a `DocumentArrayValue`
  if (receipt.items !== undefined) {
    console.log("Items:");
    for (const { properties: item } of receipt.items.values) {
      console.log("- Description:", item.description?.value);
      console.log("  Total Price:", item.totalPrice?.value);
    }
  }

  console.log("  Total:", receipt.total?.value);
}

main().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Alternatywnie, jak wspomniano powyżej, zamiast używać PrebuiltReceiptModelmetody , która generuje silniejszy typ zwracany, można użyć wstępnie utworzonego identyfikatora modelu paragonu ("wstępnie utworzonego paragonu"), ale pola dokumentu nie będą silnie wpisywane w języku TypeScript, a nazwy pól będą zwykle znajdować się w "PascalCase" zamiast "camelCase".

Inne wstępnie utworzone modele

Nie masz ograniczeń do paragonów! Istnieje kilka wstępnie utworzonych modeli do wyboru, z więcej na drodze. Każdy wstępnie utworzony model ma własny zestaw obsługiwanych pól:

  • Paragony, używając PrebuiltReceiptModel (jak powyżej) lub wstępnie utworzonego identyfikatora "prebuilt-receipt"modelu paragonu .
  • Wizytówki, używając PrebuiltBusinessCardModel identyfikatora modelu "prebuilt-businessCard"lub .
  • Faktury, używając PrebuiltInvoiceModel identyfikatora modelu "prebuilt-invoice"lub .
  • Dokumenty tożsamości (takie jak prawa jazdy i paszporty) przy użyciu PrebuiltIdDocumentModel lub identyfikator modelu "prebuilt-idDocument".
  • Formularze podatkowe W2 (Stany Zjednoczone) przy użyciu PrebuiltTaxUsW2Model lub identyfikator modelu "prebuilt-tax.us.w2".
  • Karty ubezpieczenia zdrowotnego (Stany Zjednoczone), używając [PrebuiltHealthInsuranceCardUsModel][samples-prebuilt-healthinsurancecard.us] lub identyfikatora "prebuilt-healthInsuranceCard.us"modelu .

Każdy z powyższych wstępnie utworzonych modeli tworzy documents (wyodrębnione wystąpienia schematu pola modelu). Istnieją również trzy wstępnie utworzone modele, które nie mają schematów pól i dlatego nie tworzą documentselementu . Są to:

  • Wstępnie utworzony model układu (zobacz Używanie wstępnie utworzonego układu poniżej), który wyodrębnia informacje o elementach podstawowego układu (OCR), takich jak strony i tabele.
  • Wstępnie utworzony ogólny model dokumentu (zobacz Używanie wstępnie utworzonego dokumentu poniżej), który dodaje pary klucz-wartość (kierowane skojarzenia między elementami strony, takimi jak elementy oznaczone) do informacji generowanych przez model układu.
  • Wstępnie utworzony model odczytu (zobacz Używanie wstępnie utworzonego "odczytu" poniżej), który wyodrębnia tylko elementy tekstowe, takie jak wyrazy i wiersze strony, wraz z informacjami o języku dokumentu.

Aby uzyskać informacje o polach wszystkich tych modeli, zobacz dokumentację usługi dostępnych wstępnie utworzonych modeli.

Pola wszystkich wstępnie utworzonych modeli mogą być również uzyskiwane programowo przy użyciu getDocumentModel metody (według ich identyfikatorów modelu) DocumentModelAdministrationClient i sprawdzania docTypes pola w wyniku.

Korzystanie ze wstępnie utworzonego układu

Model "prebuilt-layout" wyodrębnia tylko podstawowe elementy dokumentu, takie jak strony (składające się z wyrazów tekstowych/wierszy i znaków zaznaczania), tabele i style tekstu wizualnego wraz z ich regionami ograniczenia i obejmuje zawartość tekstową dokumentów wejściowych. Udostępniamy silnie typizowane DocumentModel wystąpienie o nazwie PrebuiltLayoutModel , które wywołuje ten model lub jak zawsze jego identyfikator "prebuilt-layout" modelu może być używany bezpośrednio.

Ponieważ główną zaletą DocumentModelanalizy opartej na języku TypeScript jest silniejsze ograniczenia typu TypeScript, w języku TypeScript jest napisany następujący przykład przy użyciu składni modułu ECMAScript:

import { DocumentAnalysisClient, AzureKeyCredential } from "@azure/ai-form-recognizer";

// Copy the above-linked `DocumentModel` file so that it may be imported in this module.
import { PrebuiltLayoutModel } from "./prebuilt/prebuilt-layout";

import fs from "fs";

async function main() {
  const endpoint = "<cognitive services endpoint>";
  const apiKey = "<api key>";
  const path = "<path to a document>"; // pdf/jpeg/png/tiff formats

  const readStream = fs.createReadStream(path);

  const client = new DocumentAnalysisClient(endpoint, new AzureKeyCredential(apiKey));
  const poller = await client.beginAnalyzeDocument(PrebuiltLayoutModel, readStream);
  const { pages, tables } = await poller.pollUntilDone();

  for (const page of pages || []) {
    console.log(`- Page ${page.pageNumber}: (${page.width}x${page.height} ${page.unit})`);
  }

  for (const table of tables || []) {
    console.log(`- Table (${table.columnCount}x${table.rowCount})`);
    for (const cell of table.cells) {
      console.log(`  cell [${cell.rowIndex},${cell.columnIndex}] "${cell.content}"`);
    }
  }
}

main().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Używanie wstępnie utworzonego dokumentu

Model "prebuilt-document" wyodrębnia informacje o parach klucz-wartość (kierowane skojarzenia między elementami strony, takimi jak pola oznaczone etykietami) oprócz właściwości generowanych przez metodę wyodrębniania układu. Ten wstępnie utworzony (ogólny) model dokumentu zapewnia podobne funkcje do modeli niestandardowych wytrenowanych bez informacji o etykiecie w poprzednich iteracji usługi Analizy dokumentów, ale jest teraz dostarczany jako wstępnie utworzony model, który współpracuje z wieloma różnymi dokumentami. Udostępniamy silnie typizowane DocumentModel wystąpienie o nazwie PrebuiltDocumentModel , które wywołuje ten model lub jak zawsze jego identyfikator "prebuilt-document" modelu może być używany bezpośrednio.

Ponieważ główną zaletą DocumentModelanalizy opartej na języku TypeScript jest silniejsze ograniczenia typu TypeScript, w języku TypeScript jest napisany następujący przykład przy użyciu składni modułu ECMAScript:

import { DocumentAnalysisClient, AzureKeyCredential } from "@azure/ai-form-recognizer";

// Copy the above-linked `DocumentModel` file so that it may be imported in this module.
import { PrebuiltDocumentModel } from "./prebuilt/prebuilt-document";

import fs from "fs";

async function main() {
  const endpoint = "<cognitive services endpoint>";
  const apiKey = "<api key>";
  const path = "<path to a document>"; // pdf/jpeg/png/tiff formats

  const readStream = fs.createReadStream(path);

  const client = new DocumentAnalysisClient(endpoint, new AzureKeyCredential(apiKey));
  const poller = await client.beginAnalyzeDocument(PrebuiltDocumentModel, readStream);

  // `pages`, `tables` and `styles` are also available as in the "layout" example above, but for the sake of this
  // example we won't show them here.
  const { keyValuePairs } = await poller.pollUntilDone();

  if (!keyValuePairs || keyValuePairs.length <= 0) {
    console.log("No key-value pairs were extracted from the document.");
  } else {
    console.log("Key-Value Pairs:");
    for (const { key, value, confidence } of keyValuePairs) {
      console.log("- Key  :", `"${key.content}"`);
      console.log("  Value:", `"${value?.content ?? "<undefined>"}" (${confidence})`);
    }
  }
}

main().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Używanie wstępnie utworzonego elementu "read"

"prebuilt-read" Model wyodrębnia informacje tekstowe w dokumencie, takim jak wyrazy i akapity, oraz analizuje język i styl pisania (np. odręczny a zestaw typów) tego tekstu. Udostępniamy silnie typizowane DocumentModel wystąpienie o nazwie PrebuiltReadModel , które wywołuje ten model lub jak zawsze jego identyfikator "prebuilt-read" modelu może być używany bezpośrednio.

Ponieważ główną zaletą DocumentModelanalizy opartej na języku TypeScript jest silniejsze ograniczenia typu TypeScript, w języku TypeScript jest napisany następujący przykład przy użyciu składni modułu ECMAScript:

import { DocumentAnalysisClient, AzureKeyCredential } from "@azure/ai-form-recognizer";

// Copy the above-linked `DocumentModel` file so that it may be imported in this module.
import { PrebuiltReadModel } from "./prebuilt/prebuilt-read";

// See the samples directory for a definition of this helper function.
import { getTextOfSpans } from "./utils";

import fs from "fs";

async function main() {
  const endpoint = "<cognitive services endpoint>";
  const apiKey = "<api key>";
  const path = "<path to a document>"; // pdf/jpeg/png/tiff formats

  const readStream = fs.createReadStream(path);

  const client = new DocumentAnalysisClient(endpoint, new AzureKeyCredential(apiKey));
  const poller = await client.beginAnalyzeDocument(PrebuiltReadModel, readStream);

  // The "prebuilt-read" model (`beginReadDocument` method) only extracts information about the textual content of the
  // document, such as page text elements, text styles, and information about the language of the text.
  const { content, pages, languages } = await poller.pollUntilDone();

  if (!pages || pages.length <= 0) {
    console.log("No pages were extracted from the document.");
  } else {
    console.log("Pages:");
    for (const page of pages) {
      console.log("- Page", page.pageNumber, `(unit: ${page.unit})`);
      console.log(`  ${page.width}x${page.height}, angle: ${page.angle}`);
      console.log(
        `  ${page.lines && page.lines.length} lines, ${page.words && page.words.length} words`
      );

      if (page.lines && page.lines.length > 0) {
        console.log("  Lines:");

        for (const line of page.lines) {
          console.log(`  - "${line.content}"`);
        }
      }
    }
  }

  if (!languages || languages.length <= 0) {
    console.log("No language spans were extracted from the document.");
  } else {
    console.log("Languages:");
    for (const languageEntry of languages) {
      console.log(
        `- Found language: ${languageEntry.locale} (confidence: ${languageEntry.confidence})`
      );

      for (const text of getTextOfSpans(content, languageEntry.spans)) {
        const escapedText = text.replace(/\r?\n/g, "\\n").replace(/"/g, '\\"');
        console.log(`  - "${escapedText}"`);
      }
    }
  }
}

main().catch((error) => {
  console.error("An error occurred:", error);
  process.exit(1);
});

Klasyfikowanie dokumentu

Usługa Analizy dokumentów obsługuje niestandardowe klasyfikatory dokumentów, które mogą klasyfikować dokumenty w zestawie wstępnie zdefiniowanych kategorii na podstawie zestawu danych trenowania. Dokumenty można klasyfikować za pomocą klasyfikatora niestandardowego DocumentAnalysisClientprzy użyciu beginClassifyDocument metody . Podobnie jak beginAnalyzeDocument powyżej, ta metoda akceptuje plik lub strumień zawierający dokument do sklasyfikowania i ma beginClassifyDocumentFromUrl odpowiednik, który akceptuje publicznie dostępny adres URL do dokumentu.

W poniższym przykładzie pokazano, jak sklasyfikować dokument przy użyciu klasyfikatora niestandardowego:

const { AzureKeyCredential, DocumentAnalysisClient } = require("@azure/ai-form-recognizer");

async function main() {
  const endpoint = "<endpoint>";
  const credential = new AzureKeyCredential("<api key>");

  const documentUrl =
    "https://raw.githubusercontent.com/Azure/azure-sdk-for-js/main/sdk/formrecognizer/ai-form-recognizer/assets/invoice/Invoice_1.pdf";

  const client = new DocumentAnalysisClient(endpoint, credential);

  const poller = await client.beginClassifyDocumentFromUrl("<classifier id>", documentUrl);

  const result = await poller.pollUntilDone();

  if (result.documents === undefined || result.documents.length === 0) {
    throw new Error("Failed to extract any documents.");
  }

  for (const document of result.documents) {
    console.log(
      `Extracted a document with type '${document.docType}' on page ${document.boundingRegions?.[0].pageNumber} (confidence: ${document.confidence})`
    );
  }
}

main().catch((error) => {
  console.error("An error occurred:", error);
  process.exit(1);
});

Aby uzyskać informacje na temat trenowania klasyfikatora niestandardowego, zobacz sekcję dotyczącą trenowania klasyfikatora na końcu następnej sekcji.

Tworzenie modelu

Zestaw SDK obsługuje również tworzenie modeli przy użyciu DocumentModelAdministrationClient klasy . Utworzenie modelu na podstawie danych treningowych z etykietami tworzy nowy model, który jest trenowany we własnych dokumentach, a wynikowy model będzie mógł rozpoznawać wartości ze struktur tych dokumentów. Operacja tworzenia modelu akceptuje adres URL zakodowany przy użyciu sygnatury dostępu współdzielonego do kontenera obiektów blob usługi Azure Storage, który przechowuje dokumenty szkoleniowe. Infrastruktura usługi Document Intelligence service odczytuje pliki w kontenerze i utworzy model na podstawie ich zawartości. Aby uzyskać więcej informacji na temat tworzenia i struktury kontenera danych szkoleniowych, zobacz dokumentację usługi Document Intelligence Service na potrzeby tworzenia modelu.

Mimo że udostępniamy te metody tworzenia modelu programowego, zespół usługi Analizy dokumentów utworzył interaktywną aplikację internetową , Document Intelligence Studio, która umożliwia tworzenie modeli i zarządzanie nimi w Internecie.

Na przykład następujący program tworzy niestandardowy model dokumentów przy użyciu adresu URL zakodowanego przy użyciu sygnatury dostępu współdzielonego do istniejącego kontenera usługi Azure Storage:

const {
  DocumentModelAdministrationClient,
  AzureKeyCredential,
} = require("@azure/ai-form-recognizer");

async function main() {
  const endpoint = "<cognitive services endpoint>";
  const apiKey = "<api key>";
  const containerSasUrl = "<SAS url to the blob container storing training documents>";

  const client = new DocumentModelAdministrationClient(endpoint, new AzureKeyCredential(apiKey));

  // You must provide the model ID. It can be any text that does not start with "prebuilt-".
  // For example, you could provide a randomly generated GUID using the "uuid" package.
  // The second parameter is the SAS-encoded URL to an Azure Storage container with the training documents.
  // The third parameter is the build mode: one of "template" (the only mode prior to 4.0.0-beta.3) or "neural".
  // See https://aka.ms/azsdk/formrecognizer/buildmode for more information about build modes.
  const poller = await client.beginBuildDocumentModel("<model ID>", containerSasUrl, "template", {
    // The model description is optional and can be any text.
    description: "This is my new model!",
    onProgress: ({ status }) => {
      console.log(`operation status: ${status}`);
    },
  });
  const model = await poller.pollUntilDone();

  console.log("Model ID:", model.modelId);
  console.log("Description:", model.description);
  console.log("Created:", model.createdOn);

  // A model may contain several document types, which describe the possible object structures of fields extracted using
  // this model

  console.log("Document Types:");
  for (const [docType, { description, fieldSchema: schema }] of Object.entries(
    model.docTypes ?? {}
  )) {
    console.log(`- Name: "${docType}"`);
    console.log(`  Description: "${description}"`);

    // For simplicity, this example will only show top-level field names
    console.log("  Fields:");

    for (const [fieldName, fieldSchema] of Object.entries(schema)) {
      console.log(`  - "${fieldName}" (${fieldSchema.type})`);
      console.log(`    ${fieldSchema.description ?? "<no description>"}`);
    }
  }
}

main().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Klasyfikatory niestandardowe są wbudowane w podobny sposób przy użyciu beginBuildDocumentClassifier metody zamiast beginBuildDocumentModel. Zobacz przykład klasyfikatora kompilacji , aby uzyskać więcej informacji na temat tworzenia klasyfikatora niestandardowego, ponieważ dane szkoleniowe wejściowe są dostępne w nieco innym formacie. Aby uzyskać informacje na temat tworzenia zestawu danych szkoleniowych dla klasyfikatora niestandardowego, zobacz dokumentację usługi Document Intelligence Service.

Zarządzanie modelami

DocumentModelAdministrationClient Udostępnia również kilka metod uzyskiwania dostępu do modeli i wyświetlania ich na liście. W poniższym przykładzie pokazano, jak iterować modele w zasobie (obejmuje to zarówno modele niestandardowe w zasobie, jak i wstępnie utworzone modele, które są wspólne dla wszystkich zasobów), uzyskać model według identyfikatora i usunąć model.

const {
  DocumentModelAdministrationClient,
  AzureKeyCredential,
} = require("@azure/ai-form-recognizer");

async function main() {
  const endpoint = "<cognitive services endpoint>";
  const apiKey = "<api key>";
  const client = new DocumentModelAdministrationClient(endpoint, new AzureKeyCredential(apiKey));

  // Produces an async iterable that supports paging (`PagedAsyncIterableIterator`). The `listDocumentModels` method will only
  // iterate over model summaries, which do not include detailed schema information. Schema information is only returned
  // from `getDocumentModel` as part of the full model information.
  const models = client.listDocumentModels();
  let i = 1;
  for await (const summary of models) {
    console.log(`Model ${i++}:`, summary);
  }

  // The iterable is paged, and the application can control the flow of paging if needed
  i = 1;
  for await (const page of client.listDocumentModels().byPage()) {
    for (const summary of page) {
      console.log(`Model ${i++}`, summary);
    }
  }

  // We can also get a full ModelInfo by ID. Here we only show the basic information. See the documentation and the
  // `getDocumentModel` sample program for information about the `docTypes` field, which contains the model's document type
  // schemas.
  const model = await client.getDocumentModel("<model ID>");
  console.log("ID", model.modelId);
  console.log("Created:", model.createdOn);
  console.log("Description: ", model.description ?? "<none>");

  // A model can also be deleted by its model ID. Once it is deleted, it CANNOT be recovered.
  const modelIdToDelete = "<model ID that should be deleted forever>";
  await client.deleteDocumentModel(modelIdToDelete);
}

main().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Podobne metody listDocumentClassifiers i getDocumentClassifier są dostępne do wyświetlania listy i uzyskiwania informacji o klasyfikatorach niestandardowych oprócz usuwania deleteDocumentClassifier klasyfikatorów niestandardowych.

Rozwiązywanie problemów

Aby uzyskać pomoc dotyczącą rozwiązywania problemów, zobacz przewodnik rozwiązywania problemów.

Rejestrowanie

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

const { setLogLevel } = require("@azure/logger");

setLogLevel("info");

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

Następne kroki

Zapoznaj się z katalogiem przykładów , aby uzyskać szczegółowe przykłady kodu, które pokazują, jak używać tej biblioteki, w tym kilka funkcji i metod, które nie są wyświetlane w powyższej sekcji "Przykłady", takie jak kopiowanie i tworzenie modeli, wyświetlanie listy operacji zarządzania modelami i usuwanie modeli.

Współtworzenie

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

Wrażenia