Azure AI Document Intelligence ügyfélkódtár JavaScripthez – 5.0.0-s verzió

  • Cikk

Az Azure AI Document Intelligence egy felhőalapú szolgáltatás, amely gépi tanulással elemzi a dokumentumokból származó szövegeket és strukturált adatokat. A következő fő funkciókat tartalmazza:

  • Elrendezés – Szöveg, táblázatstruktúrák és kijelölési jelek kinyerése a dokumentumokból a határolórégió koordinátáival együtt.
  • 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 – A szöveges elemekre, például az oldalszavakra és a sorokra vonatkozó információk olvasása a szöveges nyelvi információk mellett.
  • Előre összeállított – Bizonyos típusú gyakori dokumentumokból (például nyugtákból, számlákból, névjegykártyákból vagy identitásdokumentumokból) származó adatok elemzése előre összeállított modellek használatával.
  • Egyéni – Egyéni modelleket hozhat létre szöveg, mezőértékek, kijelölési jelek és táblázatadatok dokumentumokból való kinyeréséhez. Az egyéni modellek saját adatokkal készülnek, így azok a dokumentumokra vannak szabva.
  • Osztályozók – Egyéni osztályozókat hozhat létre a dokumentumok előre meghatározott osztályokba való kategorizálásához.

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

Megjegyzés

A Dokumentumintelligencia szolgáltatást korábban "Azure Form Recognizer" néven ismerték. Ezek a szolgáltatások egy és ugyanaz, a @azure/ai-form-recognizer JavaScripthez készült csomag pedig az Azure AI Document Intelligence szolgáltatás Azure SDK-csomagja. Íráskor folyamatban van az Azure Form Recognizer átnevezése az Azure AI-dokumentumintelligencia-ra, így a "Form Recognizer" és a "Dokumentumintelligencia" egyes esetekben felcserélhető.

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

Telepítse a JavaScripthez készült Azure Document Intelligence ügyfélkódtárat a következővel npm:

npm install @azure/ai-form-recognizer

Első lépések

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

Jelenleg támogatott környezetek

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

Előfeltételek

Form Recognizer-erőforrás létrehozása

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

A Dokumentumintelligencia a többszolgáltatásos és az egyszolgáltatásos hozzáférést is támogatja. Hozzon létre egy Cognitive Services-erőforrást, ha több Cognitive Services-szolgáltatást szeretne elérni egyetlen végpont/kulcs alatt. Csak Form Recognizer hozzáféréshez hozzon létre egy Form Recognizer erőforrást.

Az erőforrást a következővel hozhatja létre:

1. lehetőség:Azure Portal

2. lehetőség:Azure CLI.

Az alábbiakban egy példa látható arra, 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 <your-resource-group-name> a és <your-resource-name> nevet 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ás használatához ki kell választania egy DocumentAnalysisClient vagy egy példányt DocumentModelAdministrationClient, és létre kell hoznia egy ilyen típusú példányt. Az alábbi példákban a következőt fogjuk használni DocumentAnalysisClient: . Ahhoz, hogy létrehozhasson egy ügyfélpéldányt a Document Intelligence API eléréséhez, szüksége lesz a endpoint Form Recognizer erőforrásra és egy credential. Az ügyfelek az erőforrás API-kulcsával rendelkező vagy AzureKeyCredential az TokenCredential Azure Active Directory RBAC-t használó ügyfélalkalmazást használhatják az ügyfél engedélyezéséhez.

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

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

API-kulcs használata

Az Azure Portalon 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ői azonosítónak" vagy "előfizetési API-kulcsnak" is nevezik.

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

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

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

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

Az Azure Active Directory használata

Az API-kulcsok hitelesítése a legtöbb példában használatos, de az azure-identitástár használatával is hitelesítheti az ügyfelet az Azure Active Directoryval. 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 @azure/identity csomagot:

npm install @azure/identity

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

Állítsa be az AAD-alkalmazás ügyfél-azonosí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.

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

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

Fő fogalmak

DocumentAnalysisClient

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

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

DocumentModelAdministrationClient

DocumentModelAdministrationClient műveleteket biztosít az erőforrásban lévő modellek kezeléséhez (létrehozáshoz, olvasáshoz, listázáshoz és törléshez):

  • 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 mezőket kinyerni. A betanítási adatoknak egy Azure Storage-tárolóban kell lenniük, és egy adott konvenciónak megfelelően kell rendszerezni. A címkék betanítási adatkészletekre való alkalmazásának részletesebb magyarázatáért tekintse meg a szolgáltatás betanítási adatkészletek létrehozásával kapcsolatos dokumentációját .
  • beginComposeDocumentModel elindít egy műveletet, amely több modellt egyetlen modellbe ír ö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 almodell a legmegfelelőbb.
  • beginCopyModelTo elindít egy műveletet egy egyéni modell egyik erőforrásból egy másikba (vagy akár ugyanarra az erőforrásra) történő másolásához. Szüksége van egy CopyAuthorization célerőforrásból származóra, amely a getCopyAuthorization metódussal hozható létre.
  • getResourceDetails lekéri az erőforrás korlátaival kapcsolatos információkat, például az egyéni modellek számát és az erőforrás által támogatott modellek maximális számát.
  • getDocumentModel, listDocumentModelsés deleteDocumentModel engedélyezheti a modellek kezelését az erőforrásban.
  • getOperation és listOperations lehetővé teszi a modelllétrehozási műveletek állapotának megtekintését még a folyamatban lévő vagy sikertelen műveletek esetében is. A műveletek 24 órán át megmaradnak.

Vegye figyelembe, hogy a modellek a Document Intelligence szolgáltatás grafikus felhasználói felületével is létrehozhatók: Document Intelligence Studio.

A modell felépítését bemutató DocumentModelAdministrationClient mintakódrészletek alább, a "Modell létrehozása" példaszakaszban találhatók.

Hosszú ideig futó műveletek

A hosszú ideig futó műveletek (LPO-k) olyan műveletek, amelyek egy kezdeti kérésből állnak, amelyet a szolgáltatásnak küldött egy művelet elindítására, majd egy bizonyos időközönként lekérdezve az eredményt annak megállapítására, hogy a művelet befejeződött-e, és hogy az sikertelen volt-e vagy sikeres volt. Végső soron az LRO vagy hibával hiúsul meg, vagy eredményt ad.

Az Azure AI Document Intelligenceben a modelleket létrehozó műveletek (beleértve a modellek másolását és írását), valamint az elemzési/adatkinyerési műveletek LPO-k. Az SDK-ügyfelek aszinkron begin<operation-name> metódusokat biztosítanak, amelyek objektumokat adnak vissza Promise<PollerLike> . Az PollerLike objektum azt a műveletet jelöli, amely aszinkron módon fut a szolgáltatás infrastruktúráján, és egy program megvárhatja a művelet befejezését a metódusból begin<operation-name> visszaadott lekérdezés meghívásával és várakozásávalpollUntilDone. A kódrészleteket mintakódrészletekkel illusztráljuk, amelyek hosszú ideig futó műveletek használatát szemléltetik a következő szakaszban.

Példák

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

Dokumentum elemzése modellazonosítóval

A beginAnalyzeDocument metódus mezőket és táblaadatokat képes kinyerni a dokumentumokból. Az elemzés egyéni, saját adatokkal betanított modellt vagy a szolgáltatás által biztosított előre összeállított modellt használhat (lásd alább az Előre összeállított modellek használata című cikket). Az egyéni modell a saját dokumentumaihoz van igazítva, ezért csak a modell egyik dokumentumtípusával azonos szerkezetű dokumentumokkal szabad használni (több is lehet, például egy összeállított modellben).

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

Dokumentum elemzése URL-címből

Az olvasható streamek helyett egy nyilvánosan elérhető URL-cím is megadható a beginAnalyzeDocumentFromUrl metódussal. A "nyilvánosan hozzáférhető" azt jelenti, hogy az URL-forrásoknak elérhetőnek kell lenniük a szolgáltatás infrastruktúrájából (vagyis egy privát intranetes URL-címnek vagy fejléc- vagy tanúsítványalapú titkos kódokat használó URL-címeknek nem fognak működni, mivel a Dokumentumintelligencia szolgáltatásnak hozzá kell tudnia férni az URL-címhez). 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 gyakori dokumentumokból, például nyugtákból, számlákból, névjegykártyákból, identitásdokumentumokból és egyebekből a Dokumentumintelligencia 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 (ugyanaz, mint az egyéni dokumentummodellek – lásd alább a többi előre összeállított modell szakaszt ) vagy egy DocumentModel objektum használatával adható meg. A használatakor DocumentModela JavaScripthez készült Document Intelligence SDK sokkal erősebb TypeScript-típust biztosít az eredményként kinyert dokumentumokhoz a modell sémája alapján, és JavaScript-elnevezési konvenciók használatára lesz konvertálva.

Az aktuális szolgáltatás API-verziójához (2022-08-31) tartozó példaobjektumok DocumentModela prebuilt mintakönyvtárban találhatók. Az alábbi példában a PrebuiltReceiptModel könyvtárban lévő [prebuilt-receipt.ts] fájlból fogjuk használni.

Mivel a -based elemzés fő előnye DocumentModelaz erősebb TypeScript-típuskényszer, a következő minta TypeScriptben íródik az ECMAScript modul szintaxisával:

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

Alternatív megoldásként, ahogy fentebb említettük, az erősebb visszatérési típust eredményező használata PrebuiltReceiptModelhelyett használhatja az előre összeállított nyugta modellazonosítóját ("előre összeállított nyugta") is, de a dokumentummezők nem lesznek erősen begépelve TypeScriptben, és a mezőnevek általában a "PascalCase" karaktert használják a "camelCase" helyett.

Egyéb előre összeállított modellek

Nem csak a nyugtákra van korlátozva! Van néhány előre összeállított modell, amelyek közül választhat, és továbbiak is elérhetők. Minden előre összeállított modell saját támogatott mezőkészlettel rendelkezik:

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

A fenti előre összeállított modellek mindegyike létrehoz documents (a modell mezőséma kinyert példányai). Három előre összeállított modell is létezik, amelyek nem rendelkeznek mezősémákval, 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" előre összeállítottt ), amely információkat nyer ki az alapvető elrendezési (OCR) elemekről, például lapokról és táblázatokról.
  • Az előre összeállított Általános dokumentummodell (lásd az alábbi "dokumentum" előre összeállított dokumentumot ), amely kulcs-érték párokat (az oldalelemek közötti irányított társításokat, például címkézett elemeket) ad hozzá az elrendezési modell által létrehozott információkhoz.
  • Az előre összeállított olvasási modell (lásd alább az "olvasási" előre összeállított modellt), amely csak szöveges elemeket, például lapszavakat és sorokat, valamint a dokumentum nyelvével kapcsolatos információkat nyer ki.

Az összes ilyen modell mezőivel kapcsolatos információkért tekintse meg a szolgáltatás dokumentációját az elérhető előre összeállított modellekről.

Az összes előre összeállított modell mezői programozott módon is elérhetők az getDocumentModel eredményben szereplő mező metódusával DocumentModelAdministrationClient (a modellazonosítójuk alapján) és vizsgálatával docTypes .

Az előre összeállított "elrendezés" használata

A "prebuilt-layout" modell csak a dokumentum alapvető elemeit nyeri ki, például a lapokat (amelyek szöveges szavakból/vonalakból és kijelölési jelekből állnak), táblázatokból és vizuális szövegstílusokból, valamint határoló régiókból és a bemeneti dokumentumok szövegtartalmából. Biztosítunk egy nevű, erős típusú példányt DocumentModelPrebuiltLayoutModel , amely meghívja ezt a modellt, vagy mint mindig, a modellazonosítóját "prebuilt-layout" is használhatja közvetlenül.

Mivel a -based elemzés fő előnye DocumentModelaz erősebb TypeScript-típuskényszer, a következő minta TypeScriptben íródik az ECMAScript modul szintaxisával:

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

Az előre összeállított "dokumentum" használata

A "prebuilt-document" modell a kulcs-érték párokra (az oldalelemek közötti irányított társításokra, például a címkézett mezőkre) vonatkozó információkat nyer ki az elrendezés kinyerési módszere által előállított tulajdonságok mellett. Ez az előre összeállított (általános) dokumentummodell hasonló funkciókat biztosít a Dokumentumintelligencia szolgáltatás korábbi iterációiban címkeadatok nélkül betanított egyéni modellekhez, de most már egy olyan előre összeállított modellként érhető el, amely számos dokumentummal működik. Biztosítunk egy nevű, erős típusú példányt DocumentModelPrebuiltDocumentModel , amely meghívja ezt a modellt, vagy mint mindig, a modellazonosítóját "prebuilt-document" is használhatja közvetlenül.

Mivel a -based elemzés fő előnye DocumentModelaz erősebb TypeScript-típuskényszer, a következő minta TypeScriptben íródik az ECMAScript modul szintaxisával:

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

Az előre összeállított "olvasás" használata

A "prebuilt-read" modell szöveges információkat nyer ki egy dokumentumban, például szavakat és bekezdéseket, és elemzi a szöveg nyelvét és írási stílusát (például kézzel írt és típuskészlet). Biztosítunk egy nevű, erős típusú példányt DocumentModelPrebuiltReadModel , amely meghívja ezt a modellt, vagy mint mindig, a modellazonosítóját "prebuilt-read" is használhatja közvetlenül.

Mivel a -based elemzés fő előnye DocumentModelaz erősebb TypeScript-típuskényszer, a következő minta TypeScriptben íródik az ECMAScript modul szintaxisával:

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

Dokumentum besorolása

A Dokumentumintelligencia szolgáltatás támogatja azokat az egyéni dokumentumosztályozókat, amelyek betanítási adatkészlet alapján előre meghatározott kategóriákba sorolhatják a dokumentumokat. A dokumentumok egyéni osztályozóval osztályozhatók a beginClassifyDocument metódussal DocumentAnalysisClient. A fentiekhez hasonlóan beginAnalyzeDocument ez a metódus elfogadja a besorolni kívánt dokumentumot tartalmazó fájlt vagy streamet, és van egy beginClassifyDocumentFromUrl megfelelője, amely nyilvánosan elérhető URL-címet fogad el egy dokumentumhoz.

Az alábbi minta bemutatja, hogyan osztályozhat egy dokumentumot egyéni osztályozó használatával:

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

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 a osztály használatával is támogatja a DocumentModelAdministrationClient modellek létrehozását. A címkézett betanítási adatokból létrehozott modell egy új modellt hoz létre, amely be van tanítva a saját dokumentumain, és az eredményként kapott modell képes lesz felismerni a dokumentumok struktúrájából származó értékeket. A modellkészítési művelet a betanítási dokumentumokat tartalmazó Azure Storage Blob-tároló SAS-kódolású URL-címét fogadja el. A Dokumentumintelligencia 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 szerkezetével kapcsolatos további részletekért tekintse meg a Document Intelligence service modell készítésére vonatkozó dokumentációját.

Bár ezeket a módszereket 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 Studiót, amely lehetővé teszi modellek létrehozását és kezelését a weben.

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

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

Az egyéni osztályozók a metódus beginBuildDocumentModelhelyett hasonló módon vannak felépítvebeginBuildDocumentClassifier. 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ával kapcsolatos információkért tekintse meg a Dokumentumintelligencia szolgáltatás dokumentációját.

Modellek kezelése

DocumentModelAdministrationClient több módszert is kínál a modellek eléréséhez és listázására. Az alábbi példa bemutatja, hogyan lehet iterálni az erőforrás modelljeit (ez magában foglalja az erőforrás egyéni modelljeit és az összes erőforrásra jellemző előre összeállított modelleket is), hogyan kérhet le egy modellt azonosító alapján, és hogyan törölhet egy modellt.

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

Hasonló módszerek listDocumentClassifiers és getDocumentClassifier elérhetőek az egyéni osztályozók listázásához és lekéréséhez, valamint deleteDocumentClassifier az egyéni osztályozók törléséhez.

Hibaelhárítás

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

Naplózás

A naplózás engedélyezése hasznos információkat deríthet fel a hibákról. A HTTP-kérések és -válaszok naplójának megtekintéséhez állítsa a környezeti változót értékre AZURE_LOG_LEVELinfo. A naplózás futásidőben is engedélyezhető a következő hívásával setLogLevel@azure/logger:

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

setLogLevel("info");

A naplók engedélyezésére vonatkozó részletesebb utasításokért tekintse meg a @azure/logger csomag dokumentációját.

Következő lépések

Tekintse meg a mintakönyvtárat részletes kódmintákért, amelyek bemutatják a kódtár használatát, beleértve a fenti "Példák" szakaszban nem látható funkciókat és metódusokat, például a modellek másolását és írá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 buildeléséhez és teszteléséhez.

Megjelenések