Azure AI Document Intelligence JavaScripthez készült ügyféloldali kódtár – 5.1.0-s verzió

Az Azure AI Document Intelligence egy felhőszolgáltatás, amely gépi tanulással elemzi a dokumentumok szövegét és strukturált adatait. A következő fő funkciókat tartalmazza:

Elrendezés – Szöveg, táblázatszerkezetek és kijelölési jelek, valamint határolóterület-koordinátáik kinyerése a dokumentumokból.
Dokumentum – Entitások, kulcs-érték párok, táblák és kijelölési jelek elemzése a dokumentumokból az általános előre összeállított dokumentummodell használatával.
Olvasás – Szöveges elemek, például oldalszavak és sorok olvasása a szövegnyelvi információk mellett.
Előre összeállított – Bizonyos típusú gyakori dokumentumok (például nyugták, számlák, névjegykártyák vagy identitásdokumentumok) adatainak elemzése előre összeállított modellek használatával.
Egyéni – Egyéni modellek létrehozása szöveg, mezőértékek, kijelölési jelek és táblázatadatok dokumentumokból való kinyeréséhez. Az egyéni modellek a saját adataidból készülnek, így a dokumentumokhoz igazodnak.
Osztályozók – Egyéni osztályozók létrehozása a dokumentumok előre definiált osztályokba sorolásához.

Forráskód | Csomag (NPM) | API-referenciadokumentáció | Termékdokumentáció | Minták

Megjegyzés:

A Document Intelligence szolgáltatás korábban "Azure Form Recognizer" néven volt ismert. Ezek a szolgáltatások egy és ugyanazok, és a @azure/ai-form-recognizer JavaScript csomagja az Azure AI Document Intelligence szolgáltatás Azure SDK-csomagja. A cikk írásakor folyamatban van az Azure Form Recognizer átnevezése Azure AI Document Intelligence-re, így a "Form Recognizer" és a "Document Intelligence" bizonyos esetekben felcserélhető.

Telepítse a(z) `@azure/ai-form-recognizer` csomagot

Telepítse az Azure Document Intelligence JavaScript-ügyféloldali kódtárát a következővel npm:

npm install @azure/ai-form-recognizer

Kezdő lépések

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

Jelenleg támogatott környezetek

A Node.jsLTS-változatai
A Safari, a Chrome, az Edge és a Firefox legújabb verziói.

További részletekért tekintse meg támogatási szabályzatunkat.

Előfeltételek

Azure-előfizetés
Egy Cognitive Services vagy Form Recognizer erőforrás. Ha létre kell hoznia az erőforrást, használhatja az Azure Portal vagy az Azure CLI .

Űrlap-felismerő erőforrás létrehozása

Megjegyzés: A cikk írásakor a Azure Portal továbbra is "Form Recognizer" erőforrásként hivatkozik az erőforrásra. A jövőben ez egy "Document Intelligence" erőforrásra frissülhet. Az alábbi dokumentáció egyelőre a "Form Recognizer" nevet használja.

A Document Intelligence támogatja a többszolgáltatásos és az egyszolgáltatásos hozzáférést is. Hozzon létre egy Cognitive Services-erőforrást, ha több Cognitive Services egyetlen végponttal/kulccsal szeretne hozzáférni. Csak űrlap-felismerői hozzáférés esetén hozzon létre egy Űrlap-felismerő erőforrást.

Az erőforrást a következő használatával hozhatja létre:

1. lehetőség:Azure Portal

2. lehetőség:Azure CLI.

Az alábbi példa bemutatja, hogyan hozhat létre Form Recognizer erőforrást a parancssori felület használatával:

# 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

Ha az Azure CLI-t használja, cserélje le a <your-resource-group-name> és <your-resource-name> a saját egyedi nevére:

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

Ügyfél létrehozása és hitelesítése

A Dokumentumintelligencia szolgáltatással való interakcióhoz ki kell választania az a DocumentAnalysisClient vagy a DocumentModelAdministrationClient, és létre kell hoznia egy ilyen típusú példányt. A következő példákban a következőt fogjuk használni DocumentAnalysisClient. Ha ügyfélpéldányt szeretne létrehozni a Document Intelligence API eléréséhez, szüksége lesz a endpoint Form Recognizer erőforrásra és egy credential. Az ügyfelek használhatják AzureKeyCredential az erőforrás API-kulcsát, vagy az Azure Active Directory RBAC-t használó eszközt TokenCredential az ügyfél engedélyezéséhez.

A Form Recognizer erőforrás végpontját a Azure Portal vagy az alábbi Azure CLI-kódrészlet használatával találja:

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

API-kulcs használata

A Azure Portal keresse meg a Form Recognizer erőforrást, és kérjen le egy API-kulcsot, vagy használja az alábbi Azure CLI-kódrészletet :

Megjegyzés: Néha az API-kulcsot "előfizetési kulcsnak" vagy "előfizetési API-kulcsnak" is nevezik.

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

Ha rendelkezik API-kulccsal és végponttal, az alábbiak szerint használhatja:

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

Az Azure Active Directory használata

A legtöbb példában API-kulcs-hitelesítést használunk, de az ügyfelet a Azure Active Directory is hitelesítheti az Azure Identity kódtár használatával. Az alább látható DefaultAzureCredential szolgáltató vagy az Azure SDK-hoz biztosított egyéb hitelesítőadat-szolgáltatók használatához telepítse a csomagot @azure/identity :

npm install @azure/identity

A szolgáltatásnévvel való hitelesítéshez regisztrálnia kell egy AAD-alkalmazást , és hozzáférést kell adnia a szolgáltatáshoz úgy, hogy hozzárendeli a szerepkört "Cognitive Services User" a szolgáltatásnévhez (megjegyzés: más szerepkörök, például "Owner" nem adják meg a szükséges engedélyeket, csak "Cognitive Services User" a példák és a mintakód futtatásához elegendőek).

Állítsa be az AAD-alkalmazás ügyfélazonosítójának, bérlőazonosítójának és titkos ügyfélkulcsának értékeit környezeti változóként: 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,
);

Független felhők

Csatlakozzon alternatív Azure-felhőkörnyezetekhez (például Azure China vagy Azure Government) az ügyfél létrehozásakor megadott beállítás megadásával audience . A felsorolás használatával KnownFormRecognizerAudience válassza ki a környezetének megfelelő értéket.

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

Ha nem adja meg a beállítást audience , az alapértelmezett érték az Azure nyilvános felhőhöz (https://cognitiveservices.azure.com).

Főbb fogalmak

`DocumentAnalysisClient`

DocumentAnalysisClient Műveleteket biztosít a bemeneti dokumentumok elemzéséhez egyéni és előre összeállított modellek használatával. Három módszere van:

beginAnalyzeDocument, amely adatokat nyer ki egy bemeneti dokumentumfájl-streamből a modellazonosítója által megadott egyéni vagy előre összeállított modell használatával. Az összes erőforrás által támogatott előre összeállított modellekkel és azok modellazonosítóival/kimeneteivel kapcsolatos információkért tekintse meg a szolgáltatás modelljeinek dokumentációját.
beginAnalyzeDocumentFromUrl, amely ugyanazt a funkciót látja el, mint beginAnalyzeDocument, de fájlfolyam helyett egy fájl nyilvánosan elérhető URL-címét küldi el.

`DocumentModelAdministrationClient`

DocumentModelAdministrationClient Műveleteket biztosít az erőforrás modelljeinek kezeléséhez (létrehozásához, olvasásához, listázásához és törléséhez):

beginBuildDocumentModel Elindít egy műveletet, amely új dokumentummodellt hoz létre a saját betanítási adatkészletéből. A létrehozott modell egyéni séma szerint képes kinyerni a mezőket. A betanítási adatok várhatóan egy Azure Storage-tárolóban találhatók, és egy adott konvenció szerint vannak rendezve. A betanítási adatkészlet címkék betanítási adatkészletre való alkalmazásának részletesebb magyarázatát a szolgáltatás betanítási adatkészlet létrehozásával kapcsolatos dokumentációjában találja.
beginComposeDocumentModel Elindít egy műveletet, amely több modellt egyetlen modellbe állít össze. Egyéni űrlapfelismeréshez használva az új összeállított modell először elvégzi a bemeneti dokumentumok besorolását annak meghatározásához, hogy melyik almodellje a legmegfelelőbb.
beginCopyModelTo Elindít egy műveletet, amely egy egyéni modellt másol egyik erőforrásból a másikba (vagy akár ugyanabba az erőforrásba). Ehhez a célerőforrásból kell a-t CopyAuthorization készíteni, amely a getCopyAuthorization metódus segítségével generálható.
getResourceDetails Információkat kér le az erőforrás korlátairól, például az egyéni modellek számáról és az erőforrás által támogatott modellek maximális számáról.
getDocumentModel, listDocumentModelsés deleteDocumentModel engedélyezze a modellek kezelését az erőforrásban.
getOperation és listOperations lehetővé teszi a modell-létrehozási műveletek állapotának megtekintését, még a folyamatban lévő vagy sikertelen műveleteket is. A műveletek 24 órán át megmaradnak.

Felhívjuk figyelmét, hogy a modellek a Document Intelligence szolgáltatás grafikus felhasználói felületén, a Document Intelligence Studio-n keresztül is létrehozhatók.

A modell felépítését szemléltető DocumentModelAdministrationClient mintakódrészletek alább, a "Modell létrehozása" példa szakaszban találhatók.

Hosszú ideig futó műveletek

A hosszú ideig futó műveletek olyan műveletek, amelyek a szolgáltatásnak küldött kezdeti kérésből állnak egy művelet elindításához, majd egy adott időközönként az eredmény lekérdezéséből állnak, amely megállapítja, hogy a művelet befejeződött-e, és hogy sikertelen vagy sikeres volt-e. Végső soron az LRO vagy hibával meghibásodik, vagy eredményt produkál.

Az Azure AI Document Intelligence-ben a modelleket létrehozó műveletek (beleértve a modellek másolását és összeállítását), valamint az elemzési/adatkinyerési műveletek LRO-k. Az SDK-ügyfelek aszinkron begin<operation-name> metódusokat biztosítanak, amelyek objektumokat adnak vissza Promise<PollerLike> . Az PollerLike objektum a szolgáltatás infrastruktúráján aszinkron módon futó műveletet jelöli, és a program megvárhatja a művelet befejezését a metódusból visszaadott begin<operation-name> lekérdezés metódusának hívásával és megvárásávalpollUntilDone. A következő szakaszban mintakódrészletek láthatók a hosszú ideig futó műveletek használatának szemléltetésére.

Példák

A következő szakasz számos JavaScript-kódrészletet tartalmaz, amelyek a Document Intelligence ügyfélkódtárakban használt gyakori mintákat szemléltetik.

Dokumentum elemzése modellazonosítóval
Előre összeállított dokumentummodellek használata
Használja az előre összeállított "elrendezést"
Használja az előre összeállított "dokumentumot"
Használja az "olvasás" előre összeállított
Modell összeállítása
Modellek kezelése

Dokumentum elemzése modellazonosítóval

A beginAnalyzeDocument metódus mezőket és táblázatadatokat nyerhet ki a dokumentumokból. Az elemzés használhat saját adatokkal betanított egyéni modellt, vagy a szolgáltatás által biztosított előre összeállított modellt (lásd alább az Előre összeállított modellek használatát ). Az egyéni modell a saját dokumentumaihoz van szabva, ezért csak a modell egyik dokumentumtípusával azonos szerkezetű dokumentumokkal használható (több is lehet, például egy összeállított modellben).

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

Dokumentum elemzése URL-címről

Az olvasható adatfolyam biztosítása helyett egy nyilvánosan elérhető URL-cím is megadható a beginAnalyzeDocumentFromUrl módszer használatával. A "nyilvánosan elérhető" azt jelenti, hogy az URL-forrásoknak elérhetőnek kell lenniük a szolgáltatás infrastruktúrájából (más szóval a privát intranetes URL-cím, vagy a fejléc- vagy tanúsítványalapú titkos kulcsokat használó URL-címek nem működnek, mivel a Dokumentumintelligencia szolgáltatásnak hozzá kell férnie az URL-hez). Maga az URL-cím azonban kódolhat egy titkos kódot, például egy Azure Storage-blob URL-címét, amely SAS-jogkivonatot tartalmaz a lekérdezési paraméterekben.

Előre összeállított dokumentummodellek használata

A beginAnalyzeDocument metódus támogatja a mezők kinyerését bizonyos típusú gyakori dokumentumokból, például nyugtákból, számlákból, névjegykártyákból, személyazonosító dokumentumokból és egyebekből a Document Intelligence szolgáltatás által biztosított előre összeállított modellek használatával. Az előre összeállított modellek modellazonosító sztringekként (ugyanazok, mint az egyéni dokumentummodellek – lásd alább a többi előre összeállított modell szakaszt) vagy objektum DocumentModel használatával. Ha a DocumentModelJavaScripthez készült Document Intelligence SDK sokkal erősebb TypeScript-típust biztosít az eredményül kapott kinyert dokumentumokhoz a modell sémája alapján, és a rendszer JavaScript-elnevezési konvenciók használatára konvertálja.

Az aktuális szolgáltatás API-verziójának (2022-08-31) példaobjektumai DocumentModela prebuilt samples könyvtárban találhatók. A következő példában a PrebuiltReceiptModel könyvtárban található fájltprebuilt-receipt.ts fogjuk használni.

Mivel a -alapú elemzés fő előnye DocumentModelaz erősebb TypeScript-típusmegkötések, a következő minta TypeScriptben íródott az ECMAScript modul szintaxisával:

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

Alternatív megoldásként, ahogy fentebb említettük, az PrebuiltReceiptModelerősebb visszárutípust előállító , helyett az előre összeállított nyugta modellazonosítója ("prebuilt-receipt") használható, de a dokumentummezők nem lesznek erősen beírva a TypeScriptben, és a mezőnevek általában "PascalCase" betűvel lesznek ellátva a "camelCase" helyett.

Egyéb előre elkészített modellek

Nem korlátozódik a nyugtákra! Néhány előre elkészített modell közül választhat, és továbbiak is úton vannak. Minden előre összeállított modell saját támogatott mezőkészlettel rendelkezik:

Nyugták, a (fentiek szerint) vagy az előre összeállított nyugtamodell-azonosító "prebuilt-receipt"használatával PrebuiltReceiptModel .
Névjegykártyák, vagy PrebuiltBusinessCardModel annak modellazonosítója "prebuilt-businessCard".
Számlák, vagy PrebuiltInvoiceModel annak modellazonosítója "prebuilt-invoice".
Személyazonosító okmányok (például jogosítványok és útlevelek), vagy PrebuiltIdDocumentModel annak modellazonosítója "prebuilt-idDocument".
W2 adózási űrlapok (Egyesült Államok), vagy annak modellazonosítóját PrebuiltTaxUsW2Model"prebuilt-tax.us.w2"használva.
Egészségbiztosítási kártyák (Egyesült Államok), a [PrebuiltHealthInsuranceCardUsModel][samples-prebuilt-healthinsurancecard.us] vagy annak modellazonosítója "prebuilt-healthInsuranceCard.us"használatával.

A fenti előre összeállított modellek mindegyike létrehozza documents (a modell mezősémájának kinyert példányait). Három előre elkészített modell is létezik, amelyek nem rendelkeznek terepi sémákkal, ezért nem hoznak létre documents. Ezek a következők:

Az előre összeállított elrendezési modell (lásd alább az "elrendezés" használata) című részt), amely információkat nyer ki az alapvető elrendezési (OCR) elemekről, például az oldalakról és a táblázatokról.
Az előre összeállított általános dokumentummodell (lásd alább az előre összeállított "dokumentum" használata ), amely kulcs-érték párokat (irányított társításokat az oldalelemek között, például címkézett elemeket) ad hozzá az elrendezési modell által előállított információkhoz.
Az előre összeállított olvasási modell (lásd alább az "olvasás" előre összeállított használata ) amely csak szöveges elemeket, például oldalszavakat és sorokat nyer ki, valamint a dokumentum nyelvére vonatkozó információkat.

Az összes modell mezőivel kapcsolatos információkért tekintse meg a szolgáltatás rendelkezésre álló előre összeállított modellek dokumentációját.

Az összes előre elkészített modell mezői programozottan is elérhetők az getDocumentModel eredményben szereplő mező metódusával (modellazonosítójuk alapján) DocumentModelAdministrationClientdocTypes és megvizsgálva.

Használja az előre összeállított "elrendezést"

A "prebuilt-layout" modell csak a dokumentum alapvető elemeit nyeri ki, például az oldalakat (amelyek szöveges szavakból/sorokból és kijelölési jelekből állnak), a táblázatokat és a vizuális szövegstílusokat, valamint azok határoló területeit és tartományait a bemeneti dokumentumok szöveges tartalmán belül. Biztosítunk egy erősen PrebuiltLayoutModel típusos példánytDocumentModel, amely meghívja ezt a modellt, vagy mint mindig, a modellazonosítója "prebuilt-layout" közvetlenül is használható.

Mivel a -alapú elemzés fő előnye DocumentModelaz erősebb TypeScript-típusmegkötések, a következő minta TypeScriptben íródott az ECMAScript modul szintaxisával:

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

Használja az előre összeállított "dokumentumot"

A "prebuilt-document" modell az elrendezés-kinyerési módszer által előállított tulajdonságok mellett kinyeri a kulcs-érték párokról (az oldalelemek közötti irányított társításokról, például a címkézett mezőkről) szóló információkat. Ez az előre összeállított (általános) dokumentummodell hasonló funkciókat biztosít, mint a Document Intelligence szolgáltatás korábbi iterációiban címkeinformációk nélkül betanított egyéni modellek, de mostantól előre összeállított modellként is elérhető, amely számos dokumentummal működik. Biztosítunk egy erősen PrebuiltDocumentModel típusos példánytDocumentModel, amely meghívja ezt a modellt, vagy mint mindig, a modellazonosítója "prebuilt-document" közvetlenül is használható.

Mivel a -alapú elemzés fő előnye DocumentModelaz erősebb TypeScript-típusmegkötések, a következő minta TypeScriptben íródott az ECMAScript modul szintaxisával:

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

Használja az "olvasás" előre összeállított

A "prebuilt-read" modell kinyeri a dokumentum szöveges információit, például szavakat és bekezdéseket, és elemzi a szöveg nyelvét és írásmódját (pl. kézzel írt vs. betűkészlet). Biztosítunk egy erősen PrebuiltReadModel típusos példánytDocumentModel, amely meghívja ezt a modellt, vagy mint mindig, a modellazonosítója "prebuilt-read" közvetlenül is használható.

Mivel a -alapú elemzés fő előnye DocumentModelaz erősebb TypeScript-típusmegkötések, a következő minta TypeScriptben íródott az ECMAScript modul szintaxisával:

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

Dokumentum besorolása

A Document Intelligence szolgáltatás támogatja az egyéni dokumentumosztályozókat, amelyek a dokumentumokat előre definiált kategóriákba sorolhatják egy betanítási adatkészlet alapján. A dokumentumok egyéni osztályozóval beginClassifyDocumentDocumentAnalysisClientosztályozhatók a . A fentiekhez hasonlóan beginAnalyzeDocument ez a metódus is elfogadja a besorolandó dokumentumot tartalmazó fájlt vagy adatfolyamot, és van egy beginClassifyDocumentFromUrl megfelelője, amely elfogadja a dokumentum nyilvánosan elérhető URL-címét.

Az alábbi példa bemutatja, hogyan osztályozhat egy dokumentumot egyéni osztályozóval:

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

Az egyéni osztályozók betanításával kapcsolatos információkért tekintse meg az osztályozó betanításáról szóló szakaszt a következő szakasz végén.

Modell létrehozása

Az SDK támogatja a modellek létrehozását az DocumentModelAdministrationClient osztály használatával is. A modell címkézett betanítási adatokból való létrehozása létrehoz egy új modellt, amely a saját dokumentumaira van betanítva, és az eredményül kapott modell képes lesz felismerni az értékeket a dokumentumok struktúráiból. A modellépítési művelet elfogadja az SAS-kódolású URL-címet egy Azure Storage Blob-tárolóhoz, amely a betanítási dokumentumokat tartalmazza. A Document Intelligence szolgáltatás infrastruktúrája beolvassa a tárolóban lévő fájlokat, és létrehoz egy modellt a tartalmuk alapján. A betanítási adattárolók létrehozásával és strukturálásával kapcsolatos további részletekért tekintse meg a Document Intelligence szolgáltatás modellépítési dokumentációját.

Bár ezeket a módszereket a programozott modellek létrehozásához biztosítjuk, a Document Intelligence szolgáltatás csapata létrehozott egy interaktív webalkalmazást, a Document Intelligence Studio-t, amely lehetővé teszi modellek létrehozását és kezelését az interneten.

A következő program például egy SAS-kódolású URL-címmel hoz létre egy egyéni dokumentummodellt egy már meglévő Azure Storage-tárolóhoz:

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

Az egyéni osztályozók hasonló módon épülnek fel a metódus használatával, nem pedig beginBuildDocumentModel.beginBuildDocumentClassifier Az egyéni osztályozók létrehozásával kapcsolatos további információkért tekintse meg a buildosztályozó mintáját , mivel a bemeneti betanítási adatok kissé eltérő formátumban vannak megadva. Az egyéni osztályozók betanítási adatkészletének létrehozásáról a Document Intelligence szolgáltatás dokumentációjában talál további információt.

Modellek kezelése

DocumentModelAdministrationClient Számos módszert is biztosít a modellek eléréséhez és listázásához. Az alábbi példa bemutatja, hogyan iterálhatja az erőforrás modelljeit (ez magában foglalja az erőforrás egyéni modelljeit, valamint az összes erőforrásra jellemző előre összeállított modelleket), hogyan lehet lekérni egy modellt azonosító alapján, és törölni egy modellt.

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

Hasonló módszerek listDocumentClassifiers és az getDocumentClassifier egyéni osztályozók törlése mellett deleteDocumentClassifier az egyéni osztályozók listázásához és az azokkal kapcsolatos információk lekéréséhez is elérhetők.

Hibaelhárítás

A hibaelhárítással kapcsolatos segítségért tekintse meg a hibaelhárítási útmutatót.

Fakitermelés

A naplózás engedélyezése segíthet a hibákról szóló hasznos információk feltárásában. A HTTP-kérések és válaszok naplójának megtekintéséhez állítsa a környezeti változót a AZURE_LOG_LEVEL következőre info: . Alternatívaként a naplózás futásidőben is engedélyezhető a setLogLevel hívásával a @azure/logger.

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

setLogLevel("info");

A naplók engedélyezésére vonatkozó részletesebb útmutatásért tekintse meg a @azure/logger csomag dokumentációit.

Következő lépések

Tekintse meg a mintakönyvtárat a kódtár használatát bemutató részletes kódmintákért, beleértve a fenti "Példák" szakaszban nem látható számos funkciót és metódust, például a modellek másolását és összeállítását, a modellkezelési műveletek listázását és a modellek törlését.

Közreműködés

Ha hozzá szeretne járulni ehhez a kódtárhoz, olvassa el a közreműködői útmutatót , amelyből többet is megtudhat a kód összeállításáról és teszteléséről.

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-05-13

Megosztás a következőn keresztül:

Azure AI Document Intelligence JavaScripthez készült ügyféloldali kódtár – 5.1.0-s verzió

Megjegyzés:

Telepítse a(z) @azure/ai-form-recognizer csomagot

Kezdő lépések

Jelenleg támogatott környezetek

Előfeltételek

Űrlap-felismerő erőforrás létrehozása

Ügyfél létrehozása és hitelesítése

API-kulcs használata

Az Azure Active Directory használata

Független felhők

Főbb fogalmak

DocumentAnalysisClient

DocumentModelAdministrationClient

Hosszú ideig futó műveletek

Példák

Dokumentum elemzése modellazonosítóval

Dokumentum elemzése URL-címről

Előre összeállított dokumentummodellek használata

Egyéb előre elkészített modellek

Használja az előre összeállított "elrendezést"

Használja az előre összeállított "dokumentumot"

Használja az "olvasás" előre összeállított

Dokumentum besorolása

Modell létrehozása

Modellek kezelése

Hibaelhárítás

Fakitermelés

Következő lépések

Közreműködés

Visszajelzés

További források

Telepítse a(z) `@azure/ai-form-recognizer` csomagot

`DocumentAnalysisClient`

`DocumentModelAdministrationClient`