Sdílet prostřednictvím

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

Azure AI Document Intelligence je cloudová služba, která využívá strojové učení k analýze textu a strukturovaných dat z vašich dokumentů. Zahrnuje následující hlavní funkce:

  • Rozvržení – Extrahuje z dokumentů text, struktury tabulek a značky výběru spolu s jejich souřadnicemi ohraničujících oblastí.
  • Dokument – Analyzujte entity, páry klíč-hodnota, tabulky a značky výběru z dokumentů pomocí obecného předem vytvořeného modelu dokumentu.
  • Číst – kromě informací o jazyce textu si můžete přečíst informace o textových prvcích, jako jsou slova a řádky stránky.
  • Předem připravené – Analyzujte data z určitých typů běžných dokumentů (jako jsou účtenky, faktury, vizitky nebo doklady totožnosti) pomocí předem připravených modelů.
  • Vlastní – Vytvářejte vlastní modely pro extrakci textu, hodnot polí, značek výběru a dat tabulek z dokumentů. Vlastní modely jsou vytvářeny na základě vašich vlastních dat, takže jsou přizpůsobeny vašim dokumentům.
  • Klasifikátory - Vytvářejte 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 výrobkuVzorky

Poznámka:

Služba Document Intelligence byla dříve známá jako "Rozpoznávání formulářů Azure". Tyto služby jsou jedna a tatáž a balíček @azure/ai-form-recognizer pro JavaScript je balíček Azure SDK pro službu Azure AI Document Intelligence. V době psaní tohoto článku probíhá přejmenování služby Azure Rozpoznávání formulářů na Azure AI Document Intelligence, takže výrazy "Rozpoznávání formulářů" a "Document Intelligence" mohou být v některých případech používány 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

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

Aktuálně podporovaná prostředí

Další podrobnosti najdete v 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 označuje prostředek jako prostředek "Rozpoznávání formulářů". V budoucnu může být tato funkce aktualizována na zdroj "Document Intelligence". Prozatím následující dokumentace používá název "Rozpoznávání formulářů".

Document Intelligence podporuje přístup k více službám i k jedné službě. Prostředek služeb Cognitive Services vytvořte, pokud plánujete přístup k více službám Cognitive Services v rámci jednoho koncového bodu nebo klíče. Pro přístup k Form Recognizeru vytvořte prostředek Form Recognizer.

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

Možnost 1:Portál Azure

Možnost 2:Azure CLI.

Níže je uveden příklad, jak můžete vytvořit prostředek 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 buď a DocumentAnalysisClient nebo DocumentModelAdministrationClienta a vytvořit instanci tohoto typu. V následujících příkladech použijeme DocumentAnalysisClient. Chcete-li vytvořit instanci klienta pro přístup k rozhraní API Document Intelligence, budete potřebovat endpoint svůj prostředek Rozpoznávání formulářů a soubor credential. Klienti mohou k autorizaci klienta použít buď an AzureKeyCredential s klíčem rozhraní API vašeho prostředku, nebo a TokenCredential , který k autorizaci klienta používá Azure Active Directory RBAC.

Koncový bod pro váš prostředek Rozpoznávání formulářů najdete buď na webu Azure Portal , nebo pomocí níže uvedeného fragmentu Azure CLI :

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 ke svému prostředku Rozpoznávání formulářů a načtěte klíč rozhraní API, nebo použijte následující fragment kódu Azure CLI :

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íč API a koncový bod, můžete je použít následovně:

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

Použití Azure Active Directory

Autorizace klíče rozhraní API se používá ve většině příkladů, ale můžete také ověřit klienta pomocí Azure Active Directory pomocí knihovny Azure Identity. Pokud chcete použít níže uvedeného poskytovatele DefaultAzureCredential nebo jiné poskytovatele přihlašovacích údajů, kteří jsou součástí sady Azure SDK, nainstalujte @azure/identity balíček:

npm install @azure/identity

Chcete-li 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 vašemu instančnímu objektu (poznámka: jiné role, například "Owner" neudělí potřebná oprávnění, budou stačit pouze "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.

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

Suverénní cloudy

Připojte se k alternativním cloudovým prostředím Azure (například Azure China nebo Azure Government) zadáním této audience možnosti při vytváření klienta. Pomocí výčtu KnownFormRecognizerAudience vyberte správnou hodnotu pro vaše prostředí.

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

Pokud tuto audience možnost nezadáte, je výchozí nastavení vhodné pro veřejný cloud Azure (https://cognitiveservices.azure.com).

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 streamu vstupního souboru dokumentu pomocí vlastního nebo předem připraveného modelu daného jeho ID modelu. Informace o předem připravených modelech podporovaných ve všech zdrojích a jejich ID a výstupech modelů najdete v dokumentaci k modelům služby.
  • beginAnalyzeDocumentFromUrl, který plní 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 vytvoření nového modelu dokumentu z vlastní sady trénovacích dat. Vytvořený model může extrahovat pole podle vlastního schématu. Očekává se, že trénovací data budou umístěna v kontejneru Azure Storage a uspořádána podle konkrétní konvence. Podrobnější vysvětlení použití štítků na sadu trénovacích dat naleznete v dokumentaci ke službě týkající se vytváření sady trénovacích dat .
  • beginComposeDocumentModel Spustí operaci pro vytvoření více modelů do jednoho modelu. Při použití pro rozpoznávání vlastních formulářů nový složený model nejprve provede klasifikaci vstupních dokumentů, aby určil, který z jeho dílčích modelů je nejvhodnější.
  • beginCopyModelTo Spustí operaci kopírování vlastního modelu z jednoho prostředku do druhého (nebo dokonce do stejného prostředku). Vyžaduje a CopyAuthorization z cílového zdroje, který lze pomocí metody vygenerovat getCopyAuthorization .
  • getResourceDetails Načte informace o omezeních zdroje, jako je počet vlastních modelů a maximální počet modelů, které může zdroj podporovat.
  • getDocumentModela listDocumentModelsdeleteDocumentModel povolte správu modelů v prostředku.
  • getOperation a listOperations umožňují zobrazení stavu operací vytváření modelu, a to i těch operací, které probíhají nebo které se nezdařily. Operace jsou uchovávány po dobu 24 hodin.

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

Ukázkové fragmenty kódu, které ilustrují použití k DocumentModelAdministrationClient sestavení modelu, naleznete níže, v části příkladu "Sestavení modelu".

Dlouhotrvající operace

Dlouhotrvající operace (LRO) jsou operace, které se skládají z počátečního požadavku odeslaného službě na zahájení operace, po kterém následuje dotazování na výsledek v určitém intervalu, aby se zjistilo, zda byla operace dokončena a zda selhala nebo byla úspěšná. V konečném důsledku LRO buď selže s chybou, nebo vytvoří výsledek.

V Azure AI Document Intelligence jsou operace, které vytvářejí modely (včetně kopírování a skládání modelů) a také operace analýzy a extrakce dat, LRO. Klienti sady SDK poskytují asynchronní begin<operation-name> metody, které vracejí Promise<PollerLike> objekty. Objekt PollerLike představuje operaci, která běží asynchronně na infrastruktuře služby, a program může čekat na dokončení operace voláním a čekáním na pollUntilDone metodu na dotazovači vráceném begin<operation-name> z 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 jazyka JavaScript, které znázorňují běžné vzory používané v klientských knihovnách Document Intelligence.

Analýza dokumentu s ID modelu

Metoda beginAnalyzeDocument dokáže extrahovat data polí a tabulek z dokumentů. Analýza může používat buď vlastní model natrénovaný na vlastních datech, nebo předem připravený model poskytovaný službou (viz Použití předem připravených modelů níže). Vlastní model je přizpůsoben vašim vlastním 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ém modelu).

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

Analýza dokumentu z adresy URL

Jako alternativu k poskytování čitelného datového proudu lze místo beginAnalyzeDocumentFromUrl této metody poskytnout veřejně přístupnou adresu URL. "Veřejně přístupné" znamená, že zdroje URL musí být přístupné z infrastruktury služby (jinými slovy, soukromá intranetová adresa URL nebo adresy URL, které používají tajné klíče založené na záhlaví 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ý kód, 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 extrahování polí z určitých typů běžných dokumentů, jako jsou účtenky, faktury, vizitky, doklady totožnosti a další, pomocí předem připravených modelů poskytovaných službou Document Intelligence. Předpřipravené modely mohou být poskytnuty buď jako řetězce ID modelu (stejně jako vlastní modely dokumentů – viz část Další předem připravené modely níže), nebo pomocí DocumentModel objektu. Při použití DocumentModelrozhraní API poskytuje sada Document Intelligence SDK pro JavaScript mnohem silnější typ TypeScript pro výsledné extrahované dokumenty na základě schématu modelu a bude převedena tak, aby používala konvence pojmenování jazyka JavaScript.

Příklady DocumentModel objektů pro aktuální verzi rozhraní API služby (2022-08-31) naleznete v adresáři prebuilt samples. V následujícím příkladu použijeme soubor PrebuiltReceiptModel z [prebuilt-receipt.ts] v tomto adresáři.

Vzhledem k tomu, že hlavní výhodou analýzy založené na DocumentModelmetodách jsou silnější omezení typu TypeScript, je následující ukázka napsána v TypeScriptu pomocí syntaxe modulu ECMAScript:

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

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

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

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

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

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

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

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

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

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

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

Další předem připravené modely

Nejste omezeni pouze na účtenky! Na výběr je několik předem připravených modelů a další jsou na cestě. Každý předem připravený model má svou vlastní sadu podporovaných polí:

  • Účtenky, pomocí PrebuiltReceiptModel (jak je uvedeno výše) nebo předem sestaveného ID "prebuilt-receipt"modelu účtenky.
  • Vizitky, pomocí PrebuiltBusinessCardModel nebo ID modelu "prebuilt-businessCard".
  • Faktury, pomocí PrebuiltInvoiceModel nebo jejich ID "prebuilt-invoice"modelu.
  • Doklady totožnosti (například řidičské průkazy a cestovní pasy), pomocí PrebuiltIdDocumentModel ID "prebuilt-idDocument"modelu.
  • W2 Tax Forms (Spojené státy) pomocí PrebuiltTaxUsW2Model ID "prebuilt-tax.us.w2"modelu .
  • Průkazy zdravotního pojištění (Spojené státy) pomocí [PrebuiltHealthInsuranceCardUsModel][samples-prebuilt-healthinsurancecard.us] nebo ID "prebuilt-healthInsuranceCard.us"modelu.

Každý z výše uvedených předem připravených modelů vytváří documents (extrahované instance schématu polí modelu). Existují také tři předem připravené modely, které nemají schémata polí, a proto nevytvářejí documentsrozhraní . Mezi ně patří:

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

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

Použijte předem připravené rozvržení

Model "prebuilt-layout" extrahuje pouze základní prvky dokumentu, jako jsou stránky (které se skládají z textových slov/řádků a značek výběru), tabulky a vizuální styly 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á vyvolá tento model, nebo jako vždy může být přímo použito její ID "prebuilt-layout" modelu.

Vzhledem k tomu, že hlavní výhodou analýzy založené na DocumentModelmetodách jsou silnější omezení typu TypeScript, je následující ukázka napsána v TypeScriptu pomocí syntaxe modulu ECMAScript:

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

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

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

const poller = await client.beginAnalyzeDocument(PrebuiltLayoutModel, readStream);
const { pages, tables } = await poller.pollUntilDone();

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

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

Použijte předem vytvořený "dokument"

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

Vzhledem k tomu, že hlavní výhodou analýzy založené na DocumentModelmetodách jsou silnější omezení typu TypeScript, je následující ukázka napsána v TypeScriptu pomocí syntaxe modulu ECMAScript:

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

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

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

const poller = await client.beginAnalyzeDocument(PrebuiltDocumentModel, readStream);

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

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

Použijte předem sestavený nástroj "read"

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

Vzhledem k tomu, že hlavní výhodou analýzy založené na DocumentModelmetodách jsou silnější omezení typu TypeScript, je následující ukázka napsána v TypeScriptu pomocí syntaxe modulu ECMAScript:

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

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

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

const poller = await client.beginAnalyzeDocument(PrebuiltReadModel, readStream);

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

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

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

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

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

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

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

Klasifikace dokumentu

Služba Document Intelligence podporuje vlastní klasifikátory dokumentů, které mohou klasifikovat dokumenty do sady předdefinovaných kategorií na základě sady trénovacích dat. Dokumenty lze klasifikovat pomocí vlastního klasifikátoru pomocí beginClassifyDocument 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 dokumentu.

Následující příklad ukazuje, jak klasifikovat dokument pomocí vlastního klasifikátoru:

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

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

Vytvoření modelu

Sada SDK také podporuje vytváření modelů pomocí DocumentModelAdministrationClient této třídy. Vytvořením modelu z označených trénovacích dat se vytvoří nový model, který se naučí na vašich vlastních dokumentech, a výsledný model bude schopen rozpoznat hodnoty ze struktur těchto dokumentů. Operace sestavení modelu přijímá adresu URL s kódováním SAS pro kontejner objektů blob služby Azure Storage, který obsahuje školicí dokumenty. Infrastruktura služby Document Intelligence nač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 ke službě Document Intelligence pro vytvoření modelu.

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

Například následující program vytvoří vlastní model dokumentu pomocí adresy URL zakódované SAS do již existujícího kontejneru Azure Storage:

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

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

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

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

console.log(`Model ID: ${model.modelId}`);
console.log(`Description: ${model.description}`);
console.log(`Created: ${model.createdOn}`);

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

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

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

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

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

Správa modelů

DocumentModelAdministrationClient Poskytuje také několik metod pro přístup k modelům a jejich vypsání. Následující příklad ukazuje, jak iterovat modely v prostředku (to bude zahrnovat jak vlastní modely v prostředku, tak předem připravené modely, které jsou společné pro všechny prostředky), získat model podle ID a odstranit model.

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

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

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

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

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

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

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

Řešení problémů

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

Logování

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

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

setLogLevel("info");

Podrobnější pokyny k povolení protokolů najdete v dokumentaci k @azure/protokolovacímu balíčku.

Další kroky

Podívejte se prosím do adresáře samples , kde najdete podrobné ukázky kódu, které ukazují, jak používat tuto knihovnu, včetně několika funkcí a metod, které nejsou uvedeny v části "Příklady" výše, jako je kopírování a vytváření modelů, výpis operací správy modelů a odstraňování modelů.

Přispění

Pokud chcete přispívat do této knihovny, přečtěte si průvodce přispívání a přečtěte si další informace o vytváření a testování kódu.

  • Last updated on