Delen via

Azure AI Document Intelligence-clientbibliotheek voor JavaScript - versie 5.1.0

Azure AI Document Intelligence is een cloudservice die gebruikmaakt van machine learning om tekst en gestructureerde gegevens uit uw documenten te analyseren. Het bevat de volgende hoofdfuncties:

  • Lay-out: extraheer tekst, tabelstructuren en selectiemarkeringen, samen met de coördinaten van het begrenzende gebied, uit documenten.
  • Document - Analyseer entiteiten, sleutel-waardeparen, tabellen en selectiemarkeringen uit documenten met behulp van het algemene vooraf gebouwde documentmodel.
  • Lezen - Lees informatie over tekstuele elementen, zoals paginawoorden en regels, naast teksttaalinformatie.
  • Vooraf gemaakt: analyseer gegevens uit bepaalde typen veelgebruikte documenten (zoals ontvangstbewijzen, facturen, visitekaartjes of identiteitsdocumenten) met behulp van vooraf gemaakte modellen.
  • Aangepast: bouw aangepaste modellen om tekst, veldwaarden, selectiemarkeringen en tabelgegevens uit documenten te extraheren. Aangepaste modellen worden gebouwd met uw eigen gegevens, zodat ze zijn afgestemd op uw documenten.
  • Classificaties - Bouw aangepaste classificaties om documenten te categoriseren in vooraf gedefinieerde klassen.

Broncode | Pakket (NPM) | Documentatie voor | API-referentieProduct documentatie | Monsters

Opmerking

De Document Intelligence-service stond voorheen bekend als 'Azure Form Recognizer'. Deze services zijn één en hetzelfde en het @azure/ai-form-recognizer pakket voor JavaScript is het Azure SDK-pakket voor de Azure AI Document Intelligence-service. Op het moment van schrijven is de hernoeming van Azure Form Recognizer naar Azure AI Document Intelligence aan de gang, dus "Form Recognizer" en "Document Intelligence" kunnen in sommige gevallen door elkaar worden gebruikt.

Het @azure/ai-form-recognizer-pakket installeren

Installeer de Azure Document Intelligence-clientbibliotheek voor JavaScript met npm:

npm install @azure/ai-form-recognizer

Aan de slag

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

Momenteel ondersteunde omgevingen

Zie ons ondersteuningsbeleid voor meer informatie.

Vereiste voorwaarden

Een Form Recognizer-resource maken

Opmerking: Op het moment van schrijven verwijst de Azure Portal nog steeds naar de resource als een 'Form Recognizer'-resource. In de toekomst kan dit worden bijgewerkt naar een "Document Intelligence"-bron. Voorlopig wordt in de volgende documentatie de naam 'Form Recognizer' gebruikt.

Document Intelligence ondersteunt toegang tot zowel meerdere services als één service. Maak een Cognitive Services-resource als u van plan bent toegang te krijgen tot meerdere cognitieve services onder één eindpunt/sleutel. Maak voor alleen Form Recognizer-toegang een Form Recognizer-resource.

U kunt de resource maken met behulp van

Optie 1:Azure Portal

Optie 2:Azure CLI.

Hieronder ziet u een voorbeeld van hoe u een Form Herkenningsresource kunt maken met behulp van de CLI:

# 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

Als u de Azure CLI gebruikt, vervangt u <your-resource-group-name> en <your-resource-name> door uw eigen unieke namen:

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

Een client maken en verifiëren

Als u wilt communiceren met de Document Intelligence-service, moet u een DocumentAnalysisClient of een DocumentModelAdministrationClientexemplaar selecteren en een exemplaar van dit type maken. In de volgende voorbeelden gebruiken DocumentAnalysisClientwe . Als u een clientexemplaar wilt maken voor toegang tot de Document Intelligence-API, hebt u de endpoint van uw Form Recognizer-resource en een credential. De clients kunnen een met een API-sleutel van uw resource gebruiken of een AzureKeyCredentialTokenCredential die gebruikmaakt van Azure Active Directory RBAC om de client te autoriseren.

U kunt het eindpunt voor uw Form Recognizer-resource vinden in de Azure Portal of met behulp van het onderstaande Azure CLI-fragment :

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

Een API-sleutel gebruiken

Gebruik de Azure Portal om naar uw Form Recognizer-resource te bladeren en een API-sleutel op te halen, of gebruik het onderstaande Azure CLI-fragment :

Opmerking: Soms wordt de API-sleutel een 'abonnementssleutel' of 'abonnements-API-sleutel' genoemd.

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

Zodra u een API-sleutel en eindpunt heeft, kunt u deze als volgt gebruiken:

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

Azure Active Directory gebruiken

API-sleutelautorisatie wordt in de meeste voorbeelden gebruikt, maar u kunt de client ook verifiëren met Azure Active Directory met behulp van de Azure Identity-bibliotheek. Als u de DefaultAzureCredential-provider wilt gebruiken die hieronder wordt weergegeven of andere referentieproviders die bij de Azure SDK zijn geleverd, installeert u het @azure/identity pakket:

npm install @azure/identity

Als u zich wilt verifiëren met behulp van een service-principal, moet u ook een AAD-toepassing registreren en toegang verlenen tot de service door de "Cognitive Services User" rol toe te wijzen aan uw service-principal (opmerking: andere rollen, zoals "Owner" het niet verlenen van de benodigde machtigingen, zijn alleen "Cognitive Services User" voldoende om de voorbeelden en de voorbeeldcode uit te voeren).

Stel de waarden van de client-id, tenant-id en clientgeheim van de AAD-toepassing in als omgevingsvariabelen: 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,
);

Onafhankelijke clouds

Maak verbinding met alternatieve Azure-cloudomgevingen (zoals Azure China of Azure Government) door de optie op te geven bij het audience maken van uw client. Gebruik de KnownFormRecognizerAudience enum om de juiste waarde voor uw omgeving te selecteren.

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

Als u de audience optie niet opgeeft, is de standaardinstelling geschikt voor de Azure Public Cloud (https://cognitiveservices.azure.com).

Belangrijke concepten

DocumentAnalysisClient

DocumentAnalysisClient Biedt bewerkingen voor het analyseren van invoerdocumenten met behulp van aangepaste en vooraf gebouwde modellen. Het heeft drie methoden:

  • beginAnalyzeDocument, waarmee gegevens worden geëxtraheerd uit een bestandsstroom van een invoerdocument met behulp van een aangepast of vooraf samengesteld model dat wordt gegeven door de model-id. Voor informatie over de vooraf gebouwde modellen die in alle resources worden ondersteund en hun model-ID's/uitvoers, raadpleegt u de documentatie van de modellen van de service.
  • beginAnalyzeDocumentFromUrl, die dezelfde functie vervult als beginAnalyzeDocument, maar een openbaar toegankelijke URL van een bestand verzendt in plaats van een bestandsstroom.

DocumentModelAdministrationClient

DocumentModelAdministrationClient Biedt bewerkingen voor het beheren (maken, lezen, weergeven en verwijderen) van modellen in de resource:

  • beginBuildDocumentModel Start een bewerking om een nieuw documentmodel te maken op basis van uw eigen trainingsgegevensset. Het gemaakte model kan velden extraheren volgens een aangepast schema. De trainingsgegevens bevinden zich naar verwachting in een Azure Storage-container en zijn georganiseerd volgens een bepaalde conventie. Zie de documentatie van de service over het maken van een trainingsgegevensset voor een gedetailleerdere uitleg over het toepassen van labels op een trainingsgegevensset.
  • beginComposeDocumentModel Start een bewerking om meerdere modellen samen te stellen tot één model. Wanneer het wordt gebruikt voor aangepaste formulierherkenning, zal het nieuwe samengestelde model eerst een classificatie van de invoerdocumenten uitvoeren om te bepalen welke van de submodellen het meest geschikt is.
  • beginCopyModelTo Hiermee start u een bewerking om een aangepast model van de ene resource naar de andere (of zelfs naar dezelfde resource) te kopiëren. Het vereist een CopyAuthorization van de doelresource, die kan worden gegenereerd met behulp van de getCopyAuthorization methode.
  • getResourceDetails Hiermee wordt informatie opgehaald over de limieten van de resource, zoals het aantal aangepaste modellen en het maximale aantal modellen dat de resource kan ondersteunen.
  • getDocumentModel, listDocumentModelsen deleteDocumentModel schakel het beheren van modellen in de resource in.
  • getOperation en het mogelijk maken om de status van bewerkingen voor het maken van modellen weer te geven, zelfs de bewerkingen listOperations die aan de gang zijn of die zijn mislukt. Bewerkingen worden 24 uur bewaard.

Houd er rekening mee dat modellen ook kunnen worden gemaakt met behulp van de grafische gebruikersinterface van de Document Intelligence-service: Document Intelligence Studio.

Voorbeelden van codefragmenten die het gebruik van DocumentModelAdministrationClient illustreren om een model te bouwen, vindt u hieronder, in de voorbeeldsectie "Een model bouwen".

Langlopende bewerkingen

Langlopende bewerkingen (LRO's) zijn bewerkingen die bestaan uit een eerste verzoek dat naar de service wordt verzonden om een bewerking te starten, gevolgd door een peiling naar een resultaat met een bepaald interval om te bepalen of de bewerking is voltooid en of deze is mislukt of geslaagd. Uiteindelijk zal de LRO ofwel mislukken met een fout of een resultaat opleveren.

In Azure AI Document Intelligence zijn bewerkingen voor het maken van modellen (inclusief het kopiëren en samenstellen van modellen) en de bewerkingen voor analyse/gegevensextractie LRO's. De SDK-clients bieden asynchrone begin<operation-name> methoden die objecten retourneren Promise<PollerLike> . Het PollerLike object vertegenwoordigt de bewerking, die asynchroon wordt uitgevoerd op de infrastructuur van de service, en een programma kan wachten tot de bewerking is voltooid door de pollUntilDone methode aan te roepen en te wachten op de poller die door de begin<operation-name> methode wordt geretourneerd. In de volgende sectie worden voorbeeldcodefragmenten verstrekt om het gebruik van langlopende bewerkingen te illustreren.

Voorbeelden

In de volgende sectie vindt u verschillende JavaScript-codefragmenten die veelvoorkomende patronen illustreren die worden gebruikt in de Document Intelligence-clientbibliotheken.

Een document analyseren met een model-ID

De beginAnalyzeDocument methode kan velden en tabelgegevens uit documenten extraheren. Analyse kan gebruik maken van een aangepast model, getraind met uw eigen gegevens, of een vooraf samengesteld model dat door de service wordt geleverd (zie Vooraf gebouwde modellen hieronder gebruiken ). Een aangepast model is afgestemd op uw eigen documenten, dus het mag alleen worden gebruikt met documenten met dezelfde structuur als een van de documenttypen in het model (er kunnen er meerdere zijn, zoals in een samengesteld model).

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

Een document analyseren vanaf een URL

Als alternatief voor het aanbieden van een leesbare stream kan in plaats daarvan een openbaar toegankelijke URL worden verstrekt met behulp van de beginAnalyzeDocumentFromUrl methode. "Openbaar toegankelijk" betekent dat URL-bronnen toegankelijk moeten zijn vanuit de infrastructuur van de service (met andere woorden, een privé-intranet-URL, of URL's die header- of certificaatgebaseerde geheimen gebruiken, zullen niet werken, omdat de Document Intelligence-service toegang moet hebben tot de URL). De URL zelf kan echter een geheim coderen, zoals een Azure Storage-blob-URL die een SAS-token bevat in de queryparameters.

Vooraf samengestelde documentmodellen gebruiken

De beginAnalyzeDocument methode ondersteunt ook het extraheren van velden uit bepaalde typen veelgebruikte documenten, zoals ontvangstbewijzen, facturen, visitekaartjes, identiteitsdocumenten en meer, met behulp van vooraf gebouwde modellen die worden geleverd door de Document Intelligence-service. De vooraf gebouwde modellen kunnen worden geleverd als model-ID-tekenreeksen (hetzelfde als aangepaste documentmodellen, zie de sectie andere vooraf gebouwde modellen hieronder) of met behulp van een DocumentModel object. Wanneer u een DocumentModelgebruikt, biedt de Document Intelligence SDK voor JavaScript een veel sterker TypeScript-type voor de resulterende geëxtraheerde documenten op basis van het schema van het model, en het wordt geconverteerd om JavaScript-naamgevingsconventies te gebruiken.

Voorbeeldobjecten DocumentModel voor de huidige service-API-versie (2022-08-31) zijn te vinden in de prebuilt map Voorbeelden. In het volgende voorbeeld gebruiken we het PrebuiltReceiptModel bestand uit het [prebuilt-receipt.ts] bestand in die map.

Aangezien het belangrijkste voordeel van analyse op basis van -based sterkere TypeScript-typebeperkingen is, wordt het volgende voorbeeld in TypeScript geschreven met behulp van DocumentModelde ECMAScript-modulesyntaxis:

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

Zoals hierboven vermeld, kan ook in plaats van het gebruik van PrebuiltReceiptModel, dat het sterkere retourtype oplevert, de model-ID van de vooraf gebouwde ontvangst ("prebuilt-receipt") worden gebruikt, maar de documentvelden worden niet sterk getypt in TypeScript en de veldnamen worden over het algemeen in "PascalCase" weergegeven in plaats van "camelCase".

Andere kant-en-klare modellen

Je bent niet beperkt tot bonnetjes! Er zijn een paar kant-en-klare modellen om uit te kiezen, en er komen er nog meer aan. Elk vooraf samengesteld model heeft zijn eigen set ondersteunde velden:

  • Ontvangstbewijzen, met behulp van PrebuiltReceiptModel (zoals hierboven) of de vooraf samengestelde model-ID "prebuilt-receipt"van de ontvangstbon.
  • Visitekaartjes, met behulp van PrebuiltBusinessCardModel of de model-ID "prebuilt-businessCard".
  • Facturen, met behulp van PrebuiltInvoiceModel of de model-ID "prebuilt-invoice".
  • Identiteitsdocumenten (zoals rijbewijzen en paspoorten), met behulp van PrebuiltIdDocumentModel of de model-ID "prebuilt-idDocument".
  • W2-belastingformulieren (Verenigde Staten), met behulp van PrebuiltTaxUsW2Model of de model-ID "prebuilt-tax.us.w2".
  • Ziekteverzekeringskaarten (Verenigde Staten), met behulp van [PrebuiltHealthInsuranceCardUsModel][samples-prebuilt-healthinsurancecard.us] of de model-ID "prebuilt-healthInsuranceCard.us".

Elk van de bovenstaande vooraf gebouwde modellen produceert documents (geëxtraheerde exemplaren van het veldschema van het model). Er zijn ook drie vooraf gebouwde modellen die geen veldschema's hebben en daarom geen documents. Dit zijn:

Voor informatie over de velden van al deze modellen raadpleegt u de documentatie van de service van de beschikbare vooraf gebouwde modellen.

De velden van alle vooraf gebouwde modellen kunnen ook programmatisch worden geopend met behulp van de getDocumentModel methode (door hun model-ID's) van en het inspecteren van DocumentModelAdministrationClient het docTypes veld in het resultaat.

Gebruik de "lay-out" vooraf gebouwd

Het "prebuilt-layout" model extraheert alleen de basiselementen van het document, zoals pagina's (die bestaan uit tekstwoorden/-regels en selectietekens), tabellen en visuele tekststijlen, samen met hun begrenzingsgebieden en -reeksen binnen de tekstinhoud van de invoerdocumenten. We bieden een sterk getypeerde DocumentModel instantie met de naam PrebuiltLayoutModel die dit model aanroept, of, zoals altijd, kan de model-ID "prebuilt-layout" rechtstreeks worden gebruikt.

Aangezien het belangrijkste voordeel van analyse op basis van -based sterkere TypeScript-typebeperkingen is, wordt het volgende voorbeeld in TypeScript geschreven met behulp van DocumentModelde ECMAScript-modulesyntaxis:

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

Gebruik het "document" vooraf gemaakt

Het "prebuilt-document" model extraheert informatie over sleutel-waardeparen (gerichte associaties tussen pagina-elementen, zoals gelabelde velden) naast de eigenschappen die worden geproduceerd door de lay-outextractiemethode. Dit vooraf gebouwde (algemene) documentmodel biedt vergelijkbare functionaliteit als de aangepaste modellen die zonder labelinformatie zijn getraind in eerdere iteraties van de Document Intelligence-service, maar het wordt nu geleverd als een vooraf samengesteld model dat werkt met een breed scala aan documenten. We bieden een sterk getypeerde DocumentModel instantie met de naam PrebuiltDocumentModel die dit model aanroept, of, zoals altijd, kan de model-ID "prebuilt-document" rechtstreeks worden gebruikt.

Aangezien het belangrijkste voordeel van analyse op basis van -based sterkere TypeScript-typebeperkingen is, wordt het volgende voorbeeld in TypeScript geschreven met behulp van DocumentModelde ECMAScript-modulesyntaxis:

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

Gebruik de "gelezen" vooraf gebouwde

Het "prebuilt-read" model extraheert tekstuele informatie in een document, zoals woorden en alinea's, en analyseert de taal en schrijfstijl (bijv. handgeschreven versus zet) van die tekst. We bieden een sterk getypeerde DocumentModel instantie met de naam PrebuiltReadModel die dit model aanroept, of, zoals altijd, kan de model-ID "prebuilt-read" rechtstreeks worden gebruikt.

Aangezien het belangrijkste voordeel van analyse op basis van -based sterkere TypeScript-typebeperkingen is, wordt het volgende voorbeeld in TypeScript geschreven met behulp van DocumentModelde ECMAScript-modulesyntaxis:

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

Een document classificeren

De Document Intelligence-service ondersteunt aangepaste documentclassificaties die documenten kunnen classificeren in een set vooraf gedefinieerde categorieën op basis van een trainingsgegevensset. Documenten kunnen worden geclassificeerd met een aangepaste classificatie met behulp van de beginClassifyDocument methode van DocumentAnalysisClient. Net als beginAnalyzeDocument hierboven accepteert deze methode een bestand of stream die het te classificeren document bevat, en heeft het een beginClassifyDocumentFromUrl tegenhanger die in plaats daarvan een openbaar toegankelijke URL naar een document accepteert.

In het volgende voorbeeld ziet u hoe u een document classificeert met behulp van een aangepaste classificatie:

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

Zie de sectie over classificatietraining aan het einde van de volgende sectie voor informatie over het trainen van een aangepaste classificatie.

Een model bouwen

De SDK biedt ook ondersteuning voor het maken van modellen met behulp van de DocumentModelAdministrationClient klasse. Door een model te bouwen op basis van gelabelde trainingsgegevens, wordt een nieuw model gemaakt dat wordt getraind op uw eigen documenten, en het resulterende model kan waarden herkennen uit de structuren van die documenten. De bewerking voor het bouwen van het model accepteert een SAS-gecodeerde URL naar een Azure Storage Blob-container die de trainingsdocumenten bevat. De infrastructuur van de Document Intelligence-service leest de bestanden in de container en maakt een model op basis van de inhoud ervan. Zie de documentatie van de Document Intelligence-service voor het maken en structureren van een container voor trainingsgegevens voor meer informatie over het maken en structureren van een container voor trainingsgegevens.

Hoewel we deze methoden bieden voor het maken van programmatische modellen, heeft het Document Intelligence-serviceteam een interactieve webtoepassing gemaakt, Document Intelligence Studio, waarmee u modellen op internet kunt maken en beheren.

Het volgende programma bouwt bijvoorbeeld een aangepast documentmodel met behulp van een SAS-gecodeerde URL naar een reeds bestaande Azure Storage-container:

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

Aangepaste classificaties worden op een vergelijkbare manier gebouwd met behulp van de beginBuildDocumentClassifier methode in plaats van beginBuildDocumentModel. Zie het voorbeeld van de build-classificatie voor meer informatie over het bouwen van een aangepaste classificatie, aangezien de ingevoerde trainingsgegevens in een iets andere indeling worden verstrekt. Zie de documentatie van de Document Intelligence-service voor informatie over het maken van een trainingsgegevensset voor een aangepaste classificatie.

Modellen beheren

DocumentModelAdministrationClient Biedt ook verschillende methoden voor toegang tot en vermelding van modellen. In het volgende voorbeeld ziet u hoe u de modellen in een resource kunt doorlopen (dit omvat zowel aangepaste modellen in de resource als vooraf gemaakte modellen die gemeenschappelijk zijn voor alle resources), een model op id kunt ophalen en een model kunt verwijderen.

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

Vergelijkbare methoden listDocumentClassifiers en getDocumentClassifier zijn beschikbaar voor het weergeven en verkrijgen van informatie over aangepaste classificaties, naast deleteDocumentClassifier voor het verwijderen van aangepaste classificaties.

Probleemoplossingsproces

Zie de gids voor probleemoplossingvoor hulp bij het oplossen van problemen.

Loggen

Het inschakelen van logboekregistratie kan helpen nuttige informatie over fouten te ontdekken. Als u een logboek met HTTP-aanvragen en -antwoorden wilt zien, stelt u de AZURE_LOG_LEVEL omgevingsvariabele in op info. U kunt logboekregistratie ook tijdens runtime inschakelen door het setLogLevelvolgende aan te roepen@azure/logger:

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

setLogLevel("info");

Voor gedetailleerdere instructies over het inschakelen van logboeken, kunt u de documentatie over het @azure/logger-pakket bekijken.

Volgende stappen

Neem een kijkje in de map met voorbeelden voor gedetailleerde codevoorbeelden die laten zien hoe u deze bibliotheek kunt gebruiken, inclusief verschillende functies en methoden die niet worden weergegeven in de sectie 'Voorbeelden' hierboven, zoals het kopiëren en samenstellen van modellen, het weergeven van modelbeheerbewerkingen en het verwijderen van modellen.

Bijdragen

Als u een bijdrage wilt leveren aan deze bibliotheek, leest u de gids voor bijdragen voor meer informatie over het bouwen en testen van de code.