Share via

Klientská knihovna Azure AI Document Intelligence pro JavaScript – verze 5.0.0

  • Článek

Azure AI Document Intelligence je cloudová služba, která pomocí strojového učení analyzuje text a strukturovaná data z vašich dokumentů. Zahrnuje následující hlavní funkce:

  • Rozložení – extrahuje z dokumentů text, struktury tabulek a značky výběru spolu se souřadnicemi ohraničující oblasti.
  • Dokument – analýza entit, párů klíč-hodnota, tabulek a výběrových značek z dokumentů pomocí obecného předem vytvořeného modelu dokumentu.
  • Čtení – kromě informací o jazyce textu můžete číst informace o textových prvcích, jako jsou slova a řádky stránky.
  • Předem připravené – Pomocí předem připravených modelů můžete analyzovat data z určitých typů běžných dokumentů (například účtenek, faktur, vizitek nebo dokumentů identity).
  • Vlastní – vytvářejte vlastní modely pro extrakci textu, hodnot polí, výběrových značek a dat tabulky z dokumentů. Vlastní modely se vytvářejí s vlastními daty, takže jsou přizpůsobené vašim dokumentům.
  • Klasifikátory – sestavte vlastní klasifikátory pro kategorizaci dokumentů do předdefinovaných tříd.

Zdrojový kód | Balíček (NPM) | Referenční dokumentace k | rozhraní APIDokumentace k | produktuVzorky

Poznámka

Služba Document Intelligence se dříve označovala jako Azure Rozpoznávání formulářů. Tyto služby jsou stejné a @azure/ai-form-recognizer balíček pro JavaScript je balíček Sady Azure SDK pro službu Azure AI Document Intelligence. V době psaní tohoto článku probíhá přejmenování Azure Rozpoznávání formulářů na Azure AI Document Intelligence, takže Rozpoznávání formulářů a Document Intelligence se můžou v některých případech používat zaměnitelně.

Nainstalujte balíček @azure/ai-form-recognizer.

Nainstalujte klientskou knihovnu Azure Document Intelligence pro JavaScript pomocí npm:

npm install @azure/ai-form-recognizer

Začínáme

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

Aktuálně podporovaná prostředí

  • LtS verze Node.js
  • Nejnovější verze prohlížečů Safari, Chrome, Edge a Firefox.

Další podrobnosti najdete v našich zásadách podpory .

Požadavky

Vytvoření prostředku Rozpoznávání formulářů

Poznámka: V době psaní tohoto článku Azure Portal stále odkazuje na prostředek "Rozpoznávání formulářů". V budoucnu se může aktualizovat na prostředek Document Intelligence. Následující dokumentace prozatím používá název "Rozpoznávání formulářů".

Funkce Document Intelligence podporuje přístup s více službami i s jednou službou. Pokud plánujete přístup k více kognitivním službám v rámci jednoho koncového bodu nebo klíče, vytvořte prostředek Cognitive Services. Pouze pro Rozpoznávání formulářů přístup vytvořte prostředek Rozpoznávání formulářů.

Prostředek můžete vytvořit pomocí

Možnost 1:Azure Portal

Možnost 2:Azure CLI

Níže je příklad vytvoření prostředku Rozpoznávání formulářů pomocí rozhraní příkazového řádku:

# 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

Pokud používáte Azure CLI, nahraďte <your-resource-group-name> a <your-resource-name> vlastními jedinečnými názvy:

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

Vytvoření a ověření klienta

Abyste mohli pracovat se službou Document Intelligence, budete muset vybrat nebo DocumentAnalysisClientDocumentModelAdministrationClienta vytvořit instanci tohoto typu. V následujících příkladech použijeme DocumentAnalysisClient. K vytvoření instance klienta pro přístup k rozhraní API document intelligence budete potřebovat endpoint prostředek Rozpoznávání formulářů a credential. Klienti můžou použít buď AzureKeyCredential klíč rozhraní API vašeho prostředku, nebo TokenCredential objekt, který k autorizaci klienta používá Azure Active Directory RBAC.

Koncový bod pro prostředek Rozpoznávání formulářů najdete na webu Azure Portal nebo pomocí fragmentu kódu Azure CLI níže:

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

Použití klíče rozhraní API

Pomocí webu Azure Portal přejděte k prostředku Rozpoznávání formulářů a načtěte klíč rozhraní API nebo použijte fragment kódu Azure CLI níže:

Poznámka: Někdy se klíč rozhraní API označuje jako klíč předplatného nebo klíč rozhraní API předplatného.

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

Jakmile budete mít klíč rozhraní API a koncový bod, můžete ho použít následujícím způsobem:

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

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

Použití Azure Active Directory

Ve většině příkladů se používá autorizace klíče rozhraní API, ale klienta můžete také ověřit pomocí Azure Active Directory pomocí knihovny identit Azure. Pokud chcete použít zprostředkovatele DefaultAzureCredential zobrazeného níže nebo jiné poskytovatele přihlašovacích údajů poskytovaného se sadou Azure SDK, nainstalujte @azure/identity balíček:

npm install @azure/identity

Pokud chcete provést ověření pomocí instančního objektu, budete také muset zaregistrovat aplikaci AAD a udělit přístup ke službě přiřazením "Cognitive Services User" role k instančnímu objektu (poznámka: jiné role, jako "Owner" jsou, neudělují potřebná oprávnění, stačí jenom "Cognitive Services User" ke spuštění příkladů a ukázkového kódu).

Nastavte hodnoty ID klienta, ID tenanta a tajného klíče klienta aplikace AAD jako proměnné prostředí: AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET.

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

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

Klíčové koncepty

DocumentAnalysisClient

DocumentAnalysisClient poskytuje operace pro analýzu vstupních dokumentů pomocí vlastních a předem připravených modelů. Má tři metody:

  • beginAnalyzeDocument, který extrahuje data ze vstupního datového proudu souboru dokumentu pomocí vlastního nebo předem vytvořeného modelu daného id modelu. Informace o předem vytvořených modelech podporovaných ve všech prostředcích a ID a výstupech modelů najdete v dokumentaci služby k modelům.
  • beginAnalyzeDocumentFromUrl, která provádí stejnou funkci jako beginAnalyzeDocument, ale místo datového proudu souboru odesílá veřejně přístupnou adresu URL souboru.

DocumentModelAdministrationClient

DocumentModelAdministrationClient poskytuje operace pro správu (vytváření, čtení, výpis a odstraňování) modelů v prostředku:

  • beginBuildDocumentModel spustí operaci, která vytvoří nový model dokumentu z vlastní trénovací datové sady. Vytvořený model může extrahovat pole podle vlastního schématu. Očekává se, že trénovací data budou umístěná v kontejneru Azure Storage a uspořádaná podle konkrétní konvence. Podrobnější vysvětlení použití popisků u trénovací sady dat najdete v dokumentaci služby k vytvoření trénovací datové sady .
  • beginComposeDocumentModel spustí operaci, která vytvoří více modelů do jednoho modelu. Při použití pro vlastní rozpoznávání formulářů nový složený model nejprve provede klasifikaci vstupních dokumentů a určí, který z jeho dílčích modelů je nejvhodnější.
  • beginCopyModelTo spustí operaci kopírování vlastního modelu z jednoho prostředku do jiného (nebo dokonce do stejného prostředku). Vyžaduje CopyAuthorization z cílového prostředku, který se dá vygenerovat pomocí getCopyAuthorization metody .
  • getResourceDetails Načte informace o limitech prostředku, například počet vlastních modelů a maximální počet modelů, které může prostředek podporovat.
  • getDocumentModel, listDocumentModelsa deleteDocumentModel povolte správu modelů v prostředku.
  • getOperation a listOperations umožňují zobrazit stav operací vytvoření modelu, a to i těch operací, které probíhají nebo selhaly. Operace se uchovávají po dobu 24 hodin.

Upozorňujeme, že modely lze také vytvářet pomocí grafického uživatelského rozhraní služby Document Intelligence: Document Intelligence Studio.

Ukázkové fragmenty kódu, které ilustrují použití DocumentModelAdministrationClient k sestavení modelu , najdete níže v ukázkové části Sestavení modelu.

Dlouhotrvající operace

Dlouhotrvající operace (LPO) jsou operace, které se skládají z počátečního požadavku odeslaného službě na spuštění operace a následného dotazování na výsledek v určitém intervalu, aby se zjistilo, jestli se operace dokončila a jestli selhala nebo zda byla úspěšná. LRO nakonec selže s chybou nebo výsledkem.

Ve službě Azure AI Document Intelligence jsou operace, které vytvářejí modely (včetně kopírování a vytváření modelů) a také operace analýzy a extrakce dat, LTO. Klienti sady SDK poskytují asynchronní begin<operation-name> metody, které vrací Promise<PollerLike> objekty. Objekt PollerLike představuje operaci, která se spouští asynchronně na infrastruktuře služby, a program může počkat na dokončení operace voláním a čekáním pollUntilDone metody na poller vrácenou z begin<operation-name> metody. Ukázkové fragmenty kódu jsou k dispozici pro ilustraci použití dlouhotrvajících operací v další části.

Příklady

Následující část obsahuje několik fragmentů kódu JavaScriptu, které ilustrují běžné vzory používané v klientských knihovnách funkce Document Intelligence.

Analýza dokumentu s ID modelu

Metoda beginAnalyzeDocument může extrahovat pole a data tabulky z dokumentů. Analýza může používat buď vlastní model vytrénovaný pomocí vlastních dat, nebo předem vytvořený model poskytovaný službou (viz Použití předem připravených modelů níže). Vlastní model je přizpůsobený vašim dokumentům, takže by se měl používat pouze s dokumenty stejné struktury jako jeden z typů dokumentů v modelu (může jich být více, například ve složené model).

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

Analýza dokumentu z adresy URL

Jako alternativu k poskytování čitelného datového proudu můžete místo metody beginAnalyzeDocumentFromUrl zadat veřejně přístupnou adresu URL. "Veřejně přístupný" znamená, že zdroje adres URL musí být přístupné z infrastruktury služby (jinými slovy, privátní intranetová adresa URL nebo adresy URL, které používají tajné kódy založené na hlavičce nebo certifikátu, nebudou fungovat, protože služba Document Intelligence musí mít přístup k adrese URL). Samotná adresa URL ale může kódovat tajný klíč, například adresu URL objektu blob služby Azure Storage, která v parametrech dotazu obsahuje token SAS.

Použití předem připravených modelů dokumentů

Metoda beginAnalyzeDocument také podporuje extrakci polí z určitých typů běžných dokumentů, jako jsou účtenky, faktury, vizitky, dokumenty identity a další, pomocí předem připravených modelů poskytovaných službou Document Intelligence. Předem připravené modely mohou být poskytovány buď jako řetězce ID modelu (stejné jako vlastní modely dokumentů – viz další předem připravené modely níže) nebo pomocí objektu DocumentModel . Při použití DocumentModelsady SDK document intelligence pro JavaScript poskytuje pro výsledné extrahované dokumenty na základě schématu modelu mnohem silnější typ TypeScriptu a převede se na používání konvencí vytváření názvů v JavaScriptu.

Ukázkové DocumentModel objekty pro aktuální verzi rozhraní API služby (2022-08-31) najdete v adresáři prebuilt samples. V následujícím příkladu PrebuiltReceiptModel použijeme soubor ze souboru [prebuilt-receipt.ts] v tomto adresáři.

Vzhledem k tomu, že hlavní výhodou DocumentModelanalýzy je silnější omezení typu TypeScript, je následující ukázka zapsána v TypeScriptu pomocí syntaxe modulu 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);
});

Alternativně, jak je uvedeno výše, místo použití PrebuiltReceiptModel, který vytváří silnější návratový typ, lze použít ID modelu předem vytvořeného potvrzení ("prebuilt-receipt"), ale pole dokumentu nebudou silně zadávány v TypeScriptu a názvy polí budou obecně v "PascalCase" místo "camelCase".

Další předem připravené modely

Nejste omezeni na účtenky! Existuje několik předem připravených modelů, ze které si můžete vybrat, s dalšími na cestě. Každý předem vytvořený model má vlastní sadu podporovaných polí:

  • Účtenky, pomocí PrebuiltReceiptModel (jak je uvedeno výše) nebo předem vytvořeného ID "prebuilt-receipt"modelu účtenky .
  • Vizitky, pomocí PrebuiltBusinessCardModel id modelu "prebuilt-businessCard"nebo .
  • Faktury s použitím PrebuiltInvoiceModel id modelu "prebuilt-invoice"nebo .
  • Doklady identity (jako jsou řidičáky a pasy), s použitím PrebuiltIdDocumentModel id modelu "prebuilt-idDocument"nebo .
  • Daňové formuláře W2 (USA) s použitím PrebuiltTaxUsW2Model ID "prebuilt-tax.us.w2"modelu nebo .
  • Karty zdravotního pojištění (USA) s použitím [PrebuiltHealthInsuranceCardUsModel][samples-prebuilt-healthinsurancecard.us] nebo id modelu "prebuilt-healthInsuranceCard.us".

Každý z výše uvedených předem vytvořených documents modelů vytvoří (extrahované instance schématu polí modelu). Existují také tři předem vytvořené modely, které nemají schémata polí, a proto nevytvářejí documents. Jsou to tyto:

  • Předem vytvořený model rozložení (viz Použití předem připraveného rozložení níže), který extrahuje informace o elementech základního rozložení (OCR), jako jsou stránky a tabulky.
  • Předem vytvořený obecný model dokumentu (viz Použití předem vytvořeného dokumentu níže), který přidává páry klíč-hodnota (směrovaná přidružení mezi prvky stránky, jako jsou označené prvky) k informacím vytvořeným modelem rozložení.
  • Předem vytvořený model pro čtení (viz Použití předpřipočtu níže), který extrahuje pouze textové prvky, jako jsou slova a čáry stránky, spolu s informacemi o jazyce dokumentu.

Informace o polích všech těchto modelů najdete v dokumentaci služby k dostupným předem připraveným modelům.

K polím všech předem vytvořených modelů lze přistupovat také programově pomocí getDocumentModel metody (podle ID modelu) DocumentModelAdministrationClient a při docTypes kontrole pole ve výsledku.

Použití předem vytvořeného rozložení

Model "prebuilt-layout" extrahuje pouze základní prvky dokumentu, jako jsou stránky (které se skládají z textových slov nebo čar a značek výběru), tabulky a styly vizuálního textu spolu s jejich ohraničujícími oblastmi a rozsahy v textovém obsahu vstupních dokumentů. Poskytujeme instanci silného typu DocumentModel s názvem PrebuiltLayoutModel , která tento model vyvolá, nebo jako vždy může být jeho ID "prebuilt-layout" modelu použito přímo.

Vzhledem k tomu, že hlavní výhodou DocumentModelanalýzy je silnější omezení typu TypeScript, je následující ukázka zapsána v TypeScriptu pomocí syntaxe modulu 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);
});

Použití předem vytvořeného dokumentu

Model "prebuilt-document" extrahuje kromě vlastností vytvořených metodou extrakce rozložení informace o párech klíč-hodnota (směrovaná přidružení mezi prvky stránky, jako jsou označená pole). Tento předem vytvořený (obecný) model dokumentu poskytuje podobné funkce jako vlastní modely natrénované bez informací o popiscích v předchozích iteracích služby Document Intelligence, ale nyní je k dispozici jako předem připravený model, který pracuje s širokou škálou dokumentů. Poskytujeme instanci silného typu DocumentModel s názvem PrebuiltDocumentModel , která tento model vyvolá, nebo jako vždy může být jeho ID "prebuilt-document" modelu použito přímo.

Vzhledem k tomu, že hlavní výhodou DocumentModelanalýzy je silnější omezení typu TypeScript, je následující ukázka zapsána v TypeScriptu pomocí syntaxe modulu 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);
});

Použití předem připraveného nástroje pro čtení

Model "prebuilt-read" extrahuje textové informace v dokumentu, jako jsou slova a odstavce, a analyzuje jazyk a styl psaní (např. rukou psaný vs. sada typů) daného textu. Poskytujeme instanci silného typu DocumentModel s názvem PrebuiltReadModel , která tento model vyvolá, nebo jako vždy může být jeho ID "prebuilt-read" modelu použito přímo.

Vzhledem k tomu, že hlavní výhodou DocumentModelanalýzy je silnější omezení typu TypeScript, je následující ukázka zapsána v TypeScriptu pomocí syntaxe modulu 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);
});

Klasifikace dokumentu

Služba Document Intelligence podporuje vlastní klasifikátory dokumentů, které můžou klasifikovat dokumenty do sady předdefinovaných kategorií na základě trénovací sady dat. Dokumenty lze klasifikovat pomocí vlastního klasifikátoru beginClassifyDocument pomocí metody .DocumentAnalysisClient Stejně jako beginAnalyzeDocument výše tato metoda přijímá soubor nebo datový proud obsahující dokument, který má být klasifikován, a má beginClassifyDocumentFromUrl protějšek, který místo toho přijímá veřejně přístupnou adresu URL k dokumentu.

Následující ukázka ukazuje, jak klasifikovat dokument pomocí vlastního klasifikátoru:

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

Informace o trénování vlastního klasifikátoru najdete v části o trénování klasifikátoru na konci další části.

Sestavení modelu

Sada SDK také podporuje vytváření modelů pomocí DocumentModelAdministrationClient třídy . Vytvoření modelu z označených trénovacích dat vytvoří nový model, který se vytrénuje na vlastních dokumentech, a výsledný model bude schopen rozpoznat hodnoty ze struktur těchto dokumentů. Operace sestavení modelu přijímá adresu URL zakódovanou SAS do kontejneru objektů blob služby Azure Storage, který obsahuje trénovací dokumenty. Infrastruktura služby Document Intelligence přečte soubory v kontejneru a na základě jejich obsahu vytvoří model. Další podrobnosti o tom, jak vytvořit a strukturovat kontejner trénovacích dat, najdete v dokumentaci služby Document Intelligence k vytvoření modelu.

I když poskytujeme tyto metody pro programové vytváření modelů, tým služby Document Intelligence vytvořil interaktivní webovou aplikaci Document Intelligence Studio, která umožňuje vytváření a správu modelů na webu.

Následující program například vytvoří vlastní model dokumentů pomocí adresy URL zakódované sas pro již existující kontejner 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);
});

Vlastní klasifikátory jsou sestaveny podobným způsobem pomocí beginBuildDocumentClassifier metody místo beginBuildDocumentModel. Další informace o vytvoření vlastního klasifikátoru najdete v ukázce klasifikátoru sestavení , protože vstupní trénovací data jsou poskytována v mírně odlišném formátu. Informace o vytvoření trénovací sady dat pro vlastní klasifikátor najdete v dokumentaci ke službě Document Intelligence.

Správa modelů

DocumentModelAdministrationClient poskytuje také několik metod pro přístup k modelům a jejich výpis. Následující příklad ukazuje, jak iterovat modely v prostředku (to bude zahrnovat jak vlastní modely v prostředku, tak předem vytvořené modely, které jsou společné pro všechny prostředky), získat model podle ID a odstranit 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);
});

Podobné metody listDocumentClassifiers a getDocumentClassifier jsou k dispozici pro výpis a získání informací o vlastních klasifikátorech kromě deleteDocumentClassifier odstraňování vlastních klasifikátorů.

Poradce při potížích

Pomoc s řešením potíží najdete v průvodci odstraňováním potíží.

protokolování

Povolení protokolování může pomoct odhalit užitečné informace o selháních. Pokud chcete zobrazit protokol požadavků a odpovědí HTTP, nastavte proměnnou AZURE_LOG_LEVEL prostředí na info. Případně je možné protokolování povolit za běhu voláním setLogLevel v :@azure/logger

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

setLogLevel("info");

Podrobnější pokyny k povolení protokolů najdete v dokumentaci k balíčkům @azure/protokolovacího nástroje.

Další kroky

V adresáři samples najdete podrobné ukázky kódu, které ukazují, jak tuto knihovnu používat, včetně několika funkcí a metod, které nejsou uvedené v části Příklady výše, například kopírování a vytváření modelů, výpis operací správy modelů a odstraňování modelů.

Přispívání

Pokud chcete přispívat do této knihovny, přečtěte si prosím průvodce přispívání , kde se dozvíte více o tom, jak sestavit a otestovat kód.

Imprese