Biblioteka klienta usługi Azure AI Document Intelligence dla języka JavaScript — wersja 5.1.0

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

• Układ — wyodrębnianie tekstu, struktur tabel i znaczników zaznaczenia wraz z ich współrzędnymi regionu ograniczającego z dokumentów.
• Dokument — analizowanie jednostek, par klucz-wartość, tabel i znaczników wyboru z dokumentów przy użyciu ogólnego wstępnie utworzonego modelu dokumentów.
• Odczyt — odczyt informacji o elementach tekstowych, takich jak słowa i wiersze strony, a także informacji o języku tekstu.
• 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 — tworzenie modeli niestandardowych w celu wyodrębniania tekstu, wartości pól, znaczników wyboru i danych tabeli z dokumentów. Modele niestandardowe są tworzone na podstawie własnych danych, dzięki czemu są dostosowane do dokumentów.
• Klasyfikatory — tworzenie klasyfikatorów niestandardowych w celu kategoryzowania dokumentów w wstępnie zdefiniowane klasy.

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

Uwaga / Notatka

Usługa analizy dokumentów była wcześniej znana jako "Azure Form Recognizer". Te usługi są jednym i tym samym, a @azure/ai-form-recognizer pakiet języka JavaScript to pakiet zestawu Azure SDK dla usługi Azure AI Document Intelligence. W chwili pisania tego tekstu trwa zmiana nazwy usługi Azure Form Recognizer na usługę Azure AI Document Intelligence, więc w niektórych przypadkach terminy "Form Recognizer" i "Document Intelligence" mogą być używane zamiennie.

Instalowanie pakietu @azure/ai-form-recognizer

Zainstaluj bibliotekę klienta usługi Azure Document Intelligence dla języka JavaScript za pomocą npmpolecenia :

npm install @azure/ai-form-recognizer

Wprowadzenie

import { DefaultAzureCredential } from "@azure/identity";
import { DocumentAnalysisClient } from "@azure/ai-form-recognizer";
import { createReadStream } from "node: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 = createReadStream("path/to/file.jpg");
const poller = await client.beginAnalyzeDocument("<model ID>", file);

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

Obecnie obsługiwane środowiska

• Wersje LTS systemu Node.js
• Najnowsze wersje przeglądarek Safari, Chrome, Edge i Firefox.

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

Wymagania wstępne

• Subskrypcja platformy Azure
• Zasób usług Cognitive Services lub Form Recognizer. Jeśli musisz utworzyć zasób, możesz użyć witryny Azure Portal lub interfejsu wiersza polecenia platformy Azure.

Tworzenie zasobu rozpoznawania formularzy

Uwaga: W chwili pisania tego tekstu Azure Portal nadal odwołuje się do zasobu jako zasobu "Form Recognizer". W przyszłości może to zostać zaktualizowane do zasobu "Analiza dokumentów". Na razie w poniższej dokumentacji użyto nazwy "Form Recognizer".

Document Intelligence obsługuje zarówno dostęp z wieloma usługami, jak i z jedną usługą. Utwórz zasób usług Cognitive Services, jeśli planujesz uzyskać dostęp do wielu usług Cognitive Services w ramach jednego punktu końcowego/klucza. W przypadku dostępu tylko do rozpoznawania formularzy utwórz zasób rozpoznawania formularzy.

Zasób można utworzyć za pomocą

Opcja 1:Azure Portal

Opcja 2:interfejs wiersza polecenia platformy Azure.

Poniżej znajduje się przykład sposobu 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> 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 interakcje z usługą analizy dokumentów, należy wybrać opcję a DocumentAnalysisClient lub a DocumentModelAdministrationClienti utworzyć wystąpienie tego typu. W poniższych przykładach użyjemy DocumentAnalysisClient. Aby utworzyć wystąpienie klienta w celu uzyskania dostępu do interfejsu API analizy dokumentów, potrzebny endpoint jest zasób Form Recognizer i .credential Klienci mogą używać AzureKeyCredential klucza interfejsu API zasobu lub klucza TokenCredential RBAC usługi Azure Active Directory w celu autoryzowania klienta.

Punkt końcowy zasobu Form Recognizer można znaleźć w Azure Portal lub przy użyciu poniższego fragmentu kodu interfejsu 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 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>

Gdy masz już klucz interfejsu API i punkt końcowy, możesz go użyć w następujący sposób:

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

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

Korzystanie z usługi Azure Active Directory

Autoryzacja klucza interfejsu API jest używana w większości przykładów, ale można również uwierzytelnić klienta za pomocą usługi 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 pakiet:@azure/identity

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 udzielą niezbędnych uprawnień, wystarczą tylko "Cognitive Services User" do uruchomienia przykładów i przykładowego kodu).

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

import { DefaultAzureCredential } from "@azure/identity";
import { DocumentAnalysisClient } from "@azure/ai-form-recognizer";

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

Suwerenne chmury

Połącz się z alternatywnymi środowiskami chmury platformy Azure (takimi jak Azure China lub Azure Government), określając opcję audience podczas tworzenia klienta. Użyj wyliczenia, KnownFormRecognizerAudience aby wybrać poprawną wartość dla danego środowiska.

import { DefaultAzureCredential } from "@azure/identity";
import { DocumentAnalysisClient, KnownFormRecognizerAudience } from "@azure/ai-form-recognizer";

const credential = new DefaultAzureCredential();
const client = new DocumentAnalysisClient(
  "https://<resource name>.cognitiveservices.azure.com", // endpoint
  credential,
  {
    audience: KnownFormRecognizerAudience.AzureGovernment,
  }
);

Jeśli opcja audience nie zostanie określona, wartość domyślna jest odpowiednia dla chmury publicznej platformy Azure (https://cognitiveservices.azure.com).

Najważniejsze 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 pliku dokumentu wejściowego 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 modeli/danych wyjściowych, zapoznaj się z dokumentacją usługi dotyczącą modeli.
• beginAnalyzeDocumentFromUrl, który pełni 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 modelami (tworzenie, odczytywanie, wyświetlanie listy i usuwanie) w zasobie:

• beginBuildDocumentModel Uruchamia operację w celu utworzenia nowego modelu dokumentu na podstawie własnego zestawu danych treningowych. Utworzony model może wyodrębniać pola zgodnie z niestandardowym schematem. Oczekuje się, że dane treningowe będą znajdować się w kontenerze usługi Azure Storage i być 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ę łączenia wielu modeli w jeden model. W przypadku użycia do rozpoznawania formularzy niestandardowych nowy model złożony najpierw przeprowadzi klasyfikację dokumentów wejściowych, aby określić, który z jego podmodeli jest najbardziej odpowiedni.
• beginCopyModelTo Uruchamia operację kopiowania modelu niestandardowego z jednego zasobu do innego (lub nawet do tego samego zasobu). Wymaga zasobu CopyAuthorization docelowego, który można wygenerować przy użyciu getCopyAuthorization metody.
• getResourceDetails Pobiera informacje o limitach zasobu, takich jak liczba modeli niestandardowych i maksymalna liczba modeli, które zasób może obsługiwać.
• getDocumentModel, listDocumentModelsi deleteDocumentModel umożliwia zarządzanie modelami w zasobie.
• getOperation i listOperations umożliwiają wyświetlanie stanu operacji tworzenia modelu, nawet tych operacji, które są w toku lub zakończyły się niepowodzeniem. Operacje są przechowywane przez 24 godziny.

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

Przykładowe fragmenty kodu, które ilustrują użycie DocumentModelAdministrationClient do zbudowania modelu, można znaleźć poniżej, w przykładowej sekcji "Tworzenie modelu".

Długotrwałe operacje

Operacje długotrwałe (LRO) to operacje, które składają się z początkowego żądania wysłanego do usługi w celu rozpoczęcia operacji, po którym następuje sondowanie wyniku w określonym interwale w celu określenia, czy operacja została ukończona i czy zakończyła się niepowodzeniem, czy powodzeniem. Ostatecznie LRO albo zakończy się niepowodzeniem z powodu błędu, albo da wynik.

W usłudze Azure AI Document Intelligence operacje, które tworzą modele (w tym kopiowanie i tworzenie modeli), a także operacje analizy/wyodrębniania danych są LRO. 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 zakończenie operacji, wywołując i oczekując pollUntilDone na metodę w przeszukiwaniu zwróconym begin<operation-name> z metody. Przykładowe fragmenty kodu są dostępne w celu zilustrowania 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 klienckich analizy dokumentów.

• Analizowanie dokumentu z identyfikatorem modelu
• Korzystanie ze wstępnie utworzonych modeli dokumentów
• Użyj wstępnie utworzonego "układu"
• Użyj wstępnie utworzonego "dokumentu"
• Użyj wstępnie utworzonego elementu "odczyt"
• Tworzenie modelu
• Zarządzanie modelami

Analizowanie dokumentu z identyfikatorem modelu

Metoda beginAnalyzeDocument może wyodrębniać pola i dane tabel 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 o tej samej strukturze, co jeden z typów dokumentów w modelu (może być ich wiele, na przykład w modelu złożonym).

import { DefaultAzureCredential } from "@azure/identity";
import { DocumentAnalysisClient } from "@azure/ai-form-recognizer";
import { createReadStream } from "node:fs";

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

const modelId = "<model id>";
const path = "<path to a document>";
const readStream = createReadStream(path);

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 content '${field.content}' 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}"`);
  }
}

Analizowanie dokumentu na podstawie adresu URL

Alternatywą dla dostarczania czytelnego strumienia jest podanie publicznie dostępnego adresu URL przy użyciu tej beginAnalyzeDocumentFromUrl metody. "Publicznie dostępne" oznacza, że źródła adresów URL muszą być dostępne z poziomu infrastruktury usługi (innymi słowy, prywatny adres URL intranetu lub adresy URL, które używają wpisów tajnych opartych na nagłówku lub certyfikacie, nie będą działać, ponieważ usługa Document Intelligence 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ć dostarczane jako ciągi identyfikatora modelu (tak samo jak w przypadku niestandardowych modeli dokumentów — zobacz sekcję inne wstępnie utworzone modele poniżej) lub przy użyciu obiektu DocumentModel . W przypadku korzystania z DocumentModelzestawu SDK analizy dokumentów dla języka JavaScript zapewnia znacznie silniejszy typ TypeScript dla wynikowych wyodrębnionych dokumentów na podstawie schematu modelu i zostanie przekonwertowany na konwencje nazewnictwa JavaScript.

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

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

import { DefaultAzureCredential } from "@azure/identity";
import { DocumentAnalysisClient } from "@azure/ai-form-recognizer";
import { createReadStream } from "node:fs";
import { PrebuiltReceiptModel } from "../samples-dev/prebuilt/prebuilt-receipt.js";

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

const path = "<path to a document>";
const readStream = createReadStream(path);

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

Alternatywnie, jak wspomniano powyżej, zamiast używać PrebuiltReceiptModel, co daje silniejszy typ zwracany, można użyć identyfikatora modelu wstępnie utworzonego paragonu ("prebuilt-receipt"), ale pola dokumentu nie będą silnie wpisane w TypeScript, a nazwy pól będą zazwyczaj w "PascalCase" zamiast "camelCase".

Inne wstępnie utworzone modele

Nie jesteś ograniczony do paragonów! Do wyboru jest kilka gotowych modeli, a kolejne są w drodze. Każdy wstępnie utworzony model ma własny zestaw obsługiwanych pól:

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

Każdy z powyższych wstępnie utworzonych modeli generuje 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 generują documents. Są to:

• Wstępnie utworzony model układu (zobacz Używanie wstępnie utworzonego "układu" poniżej), który wyodrębnia informacje o podstawowych elementach układu (OCR), takich jak strony i tabele.
• Wstępnie utworzony model dokumentu ogólnego (zobacz Korzystanie z wstępnie utworzonego "dokumentu" poniżej), który dodaje pary klucz-wartość (skierowane skojarzenia między elementami strony, takimi jak elementy oznaczone etykietami) do informacji generowanych przez model układu.
• Wstępnie utworzony model odczytu (zobacz Używanie wstępnie utworzonego elementu "odczyt " 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, zapoznaj się z dokumentacją usługi dotyczącą dostępnych wstępnie utworzonych modeli.

Dostęp do pól wszystkich wstępnie utworzonych modeli można również uzyskać programowo przy użyciu getDocumentModel metody (za pomocą identyfikatorów modelu) pola i DocumentModelAdministrationClient sprawdzania docTypes go w wyniku.

Użyj wstępnie utworzonego "układu"

Model "prebuilt-layout" wyodrębnia tylko podstawowe elementy dokumentu, takie jak strony (które składają się ze słów/wierszy tekstu i znaczników wyboru), tabele i wizualne style tekstu wraz z ich regionami ograniczającymi i zakresami w zawartości tekstowej dokumentów wejściowych. Udostępniamy instancję o nazwie PrebuiltLayoutModel o jednoznacznie określonym typieDocumentModel, która 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 są silniejsze ograniczenia typu TypeScript, poniższy przykład jest napisany w języku TypeScript przy użyciu składni modułu ECMAScript:

import { DefaultAzureCredential } from "@azure/identity";
import { DocumentAnalysisClient } from "@azure/ai-form-recognizer";
import { createReadStream } from "node:fs";
import { PrebuiltLayoutModel } from "../samples-dev/prebuilt/prebuilt-layout.js";

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

const path = "<path to a document>";
const readStream = createReadStream(path);

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

Użyj wstępnie utworzonego "dokumentu"

Model "prebuilt-document" wyodrębnia informacje o parach klucz-wartość (skierowane 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 etykietach w poprzednich iteracjach usługi analizy dokumentów, ale teraz jest dostarczany jako wstępnie utworzony model, który współpracuje z szeroką gamą dokumentów. Udostępniamy instancję o nazwie PrebuiltDocumentModel o jednoznacznie określonym typieDocumentModel, która 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 są silniejsze ograniczenia typu TypeScript, poniższy przykład jest napisany w języku TypeScript przy użyciu składni modułu ECMAScript:

import { DefaultAzureCredential } from "@azure/identity";
import { DocumentAnalysisClient } from "@azure/ai-form-recognizer";
import { createReadStream } from "node:fs";
import { PrebuiltDocumentModel } from "../samples-dev/prebuilt/prebuilt-document.js";

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

const path = "<path to a document>";
const readStream = createReadStream(path);

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

Użyj wstępnie utworzonego elementu "odczyt"

"prebuilt-read" Model wyodrębnia informacje tekstowe w dokumencie, takie jak słowa i akapity, a następnie analizuje język i styl pisania (np. pismo odręczne lub skład) tego tekstu. Udostępniamy instancję o nazwie PrebuiltReadModel o jednoznacznie określonym typieDocumentModel, która 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 są silniejsze ograniczenia typu TypeScript, poniższy przykład jest napisany w języku TypeScript przy użyciu składni modułu ECMAScript:

import { DefaultAzureCredential } from "@azure/identity";
import { DocumentAnalysisClient } from "@azure/ai-form-recognizer";
import { createReadStream } from "node:fs";
import { PrebuiltReadModel } from "../samples-dev/prebuilt/prebuilt-read.js";

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

const path = "<path to a document>";
const readStream = createReadStream(path);

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

function* getTextOfSpans(content, spans) {
  for (const span of spans) {
    yield content.slice(span.offset, span.offset + span.length);
  }
}

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 treningowych. Dokumenty można klasyfikować za pomocą klasyfikatora niestandardowego przy użyciu beginClassifyDocument metody DocumentAnalysisClient. Podobnie jak beginAnalyzeDocument powyżej, ta metoda akceptuje plik lub strumień zawierający dokument, który ma zostać sklasyfikowany, i ma beginClassifyDocumentFromUrl odpowiednik, który zamiast tego akceptuje publicznie dostępny adres URL dokumentu.

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

import { DefaultAzureCredential } from "@azure/identity";
import { DocumentAnalysisClient } from "@azure/ai-form-recognizer";

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

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

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

const result = await poller.pollUntilDone();

if (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})`,
  );
}

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. Tworzenie modelu na podstawie oznaczonych danych treningowych powoduje utworzenie nowego modelu, który jest trenowany na własnych dokumentach, a wynikowy model będzie w stanie rozpoznać wartości ze struktur tych dokumentów. Operacja tworzenia modelu akceptuje adres URL zakodowany w sygnaturze dostępu współdzielonego do kontenera obiektów blob usługi Azure Storage, który zawiera dokumenty szkoleniowe. Infrastruktura usługi Document Intelligence odczyta pliki w kontenerze i utworzy model na podstawie ich zawartości. Aby uzyskać więcej informacji na temat tworzenia i strukturyzowania kontenera danych treningowych, zapoznaj się z dokumentacją usługi Document Intelligence dotyczącą tworzenia modelu.

Chociaż udostępniamy te metody tworzenia modeli programowych, zespół usługi analizy dokumentów utworzył interaktywną aplikację internetową Document Intelligence Studio, która umożliwia tworzenie modeli i zarządzanie nimi w sieci Web.

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

import { DefaultAzureCredential } from "@azure/identity";
import { DocumentModelAdministrationClient } from "@azure/ai-form-recognizer";

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

const containerSasUrl = "<SAS url to the blob container storing training documents>";

// 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>"}`);
  }
}

Klasyfikatory niestandardowe są budowane w podobny sposób przy użyciu metody, a beginBuildDocumentClassifier nie beginBuildDocumentModel. Aby uzyskać więcej informacji na temat tworzenia klasyfikatora niestandardowego, zobacz przykład klasyfikatora kompilacji , ponieważ wejściowe dane treningowe są udostępniane w nieco innym formacie. Aby uzyskać informacje na temat tworzenia zestawu danych treningowych dla klasyfikatora niestandardowego, zobacz dokumentację usługi analizy dokumentów.

Zarządzaj modelami

DocumentModelAdministrationClient udostępnia również kilka metod uzyskiwania dostępu do modeli i wyświetlania ich list. W poniższym przykładzie pokazano, jak iterować po modelach 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), pobierać model według identyfikatora i usuwać model.

import { DefaultAzureCredential } from "@azure/identity";
import { DocumentModelAdministrationClient } from "@azure/ai-form-recognizer";

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

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

Podobne metody listDocumentClassifiers są getDocumentClassifier dostępne do wyświetlania listy i uzyskiwania informacji o klasyfikatorach niestandardowych, a deleteDocumentClassifier także do usuwania klasyfikatorów niestandardowych.

Rozwiązywanie problemów

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

Przemysł drzewny

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. Alternatywnie rejestrowanie można włączyć w czasie wykonywania, wywołując polecenie setLogLevel 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.

Dalsze kroki

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

Wkład

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