Azure AI Document Intelligence-clientbibliotheek voor JavaScript - versie 5.0.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:

• Indeling: extraheert tekst, tabelstructuren en selectiemarkeringen, samen met de coördinaten van het begrenzingsgebied, uit documenten.
• Document: analyseer entiteiten, sleutel-waardeparen, tabellen en selectiemarkeringen uit documenten met behulp van het algemene vooraf samengestelde documentmodel.
• Lezen: lees informatie over tekstuele elementen, zoals paginawoorden en regels, naast informatie over de teksttaal.
• Vooraf samengesteld: analyseer gegevens uit bepaalde typen algemene documenten (zoals ontvangstbewijzen, facturen, visitekaartjes of identiteitsdocumenten) met behulp van vooraf samengestelde modellen.
• Aangepast: maak 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: maak aangepaste classificaties om documenten te categoriseren in vooraf gedefinieerde klassen.

Broncode | Pakket (NPM) | API-referentiedocumentatie | Productdocumentatie | Monsters

Notitie

De Document Intelligence-service stond voorheen bekend als 'Azure Form Recognizer'. Deze services zijn 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 wordt de naam van Azure Form Recognizer gewijzigd in Azure AI Document Intelligence, dus 'Form Recognizer' en 'Document Intelligence' kunnen in sommige gevallen door elkaar worden gebruikt.

Installeer het pakket @azure/ai-form-recognizer

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

npm install @azure/ai-form-recognizer

Aan de slag

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

Momenteel ondersteunde omgevingen

• LTS-versies van Node.js
• Nieuwste versies van Safari, Chrome, Edge en Firefox.

Zie ons ondersteuningsbeleid voor meer informatie.

Vereisten

• Een Azure-abonnement
• Een Cognitive Services- of Form Recognizer-resource. Als u de resource moet maken, kunt u azure portal of Azure CLI gebruiken.

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 documentinformatieresource. Voor nu gebruikt de volgende documentatie de naam 'Form Recognizer'.

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

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 Recognizer resource 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 en <your-resource-name> door <your-resource-group-name> 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 DocumentModelAdministrationClientselecteren 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 credentialnodig. De clients kunnen een AzureKeyCredential gebruiken met een API-sleutel van uw resource of een TokenCredential die gebruikmaakt van Azure Active Directory RBAC om de client te autoriseren.

U vindt het eindpunt voor uw Form Recognizer-resource in 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 hebt, kunt u deze als volgt gebruiken:

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

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

Azure Active Directory gebruiken

Autorisatie van API-sleutels 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 hieronder weergegeven DefaultAzureCredential-provider of andere referentieproviders wilt gebruiken die bij de Azure SDK worden 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" die niet de benodigde machtigingen verlenen, volstaan alleen "Cognitive Services User" 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.

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

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

Belangrijkste concepten

DocumentAnalysisClient

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

• beginAnalyzeDocument, waarmee gegevens worden geëxtraheerd uit een invoerdocumentbestandsstroom met behulp van een aangepast of vooraf samengesteld model dat is opgegeven door de model-id. Zie de servicedocumentatie van de modellen voor informatie over de vooraf gedefinieerde modellen die worden ondersteund in alle resources en hun model-id's/uitvoer.
• beginAnalyzeDocumentFromUrl, waarmee dezelfde functie wordt uitgevoerd als beginAnalyzeDocument, maar een openbaar toegankelijke URL van een bestand wordt verzonden 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 set met trainingsgegevens. 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 set trainingsgegevens voor een gedetailleerdere uitleg over het toepassen van labels op een set met trainingsgegevens.
• beginComposeDocumentModel start een bewerking om meerdere modellen samen te stellen in één model. Bij gebruik voor aangepaste formulierherkenning voert het nieuwe samengestelde model eerst een classificatie van de invoerdocumenten uit om te bepalen welk submodel het meest geschikt is.
• beginCopyModelTo start een bewerking om een aangepast model van de ene resource naar de andere te kopiëren (of zelfs naar dezelfde resource). Hiervoor is een CopyAuthorization van de doelresource vereist, die kan worden gegenereerd met behulp van de getCopyAuthorization -methode.
• getResourceDetails haalt informatie op over de limieten van de resource, zoals het aantal aangepaste modellen en het maximum aantal modellen dat de resource kan ondersteunen.
• getDocumentModel, listDocumentModelsen deleteDocumentModel schakel het beheren van modellen in de resource in.
• getOperation en listOperations schakelt u het weergeven van de status van bewerkingen voor het maken van modellen in, zelfs de bewerkingen die actief 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.

Voorbeeldcodefragmenten die het gebruik van DocumentModelAdministrationClient illustreren om een model te bouwen, vindt u hieronder in de sectie 'Een model bouwen'.

Langlopende bewerkingen

Langlopende bewerkingen (LPO's) zijn bewerkingen die bestaan uit een initiële aanvraag die naar de service wordt verzonden om een bewerking te starten, gevolgd door polling naar een resultaat met een bepaald interval om te bepalen of de bewerking is voltooid en of deze is mislukt of geslaagd. Uiteindelijk mislukt de LRO met een fout of produceert het een resultaat.

In Azure AI Document Intelligence zijn bewerkingen waarmee modellen worden gemaakt (inclusief het kopiëren en opstellen van modellen) en de analyse-/gegevensextractiebewerkingen LPO'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 methode aan te roepen en te wachten op de pollUntilDone poller die wordt geretourneerd door de begin<operation-name> methode. In de volgende sectie vindt u voorbeeldcodefragmenten ter illustratie van langlopende bewerkingen.

Voorbeelden

De volgende sectie bevat verschillende JavaScript-codefragmenten die veelvoorkomende patronen illustreren die worden gebruikt in de Document Intelligence-clientbibliotheken.

• Een document met een model-id analyseren
• Vooraf samengestelde documentmodellen gebruiken
• De vooraf samengestelde indeling gebruiken
• Het vooraf samengestelde document gebruiken
• De vooraf samengestelde 'read' gebruiken
• Een model bouwen
• Modellen beheren

Een document met een model-id analyseren

Met de beginAnalyzeDocument methode kunnen velden en tabelgegevens uit documenten worden geëxtraheerd. Analyse kan gebruikmaken van een aangepast model, getraind met uw eigen gegevens, of een vooraf samengesteld model dat door de service wordt geleverd (zie Vooraf samengestelde modellen gebruiken hieronder). 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 meerdere zijn, zoals in een samengesteld model).

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

const fs = require("fs");

async function main() {
  const endpoint = "<cognitive services endpoint>";
  const apiKey = "<api key>";
  const modelId = "<model id>";
  const path = "<path to a document>";

  const readStream = fs.createReadStream(path);

  const client = new DocumentAnalysisClient(endpoint, new AzureKeyCredential(apiKey));
  const poller = await client.beginAnalyzeDocument(modelId, readStream, {
    onProgress: ({ status }) => {
      console.log(`status: ${status}`);
    },
  });

  // There are more fields than just these three
  const { documents, pages, tables } = await poller.pollUntilDone();

  console.log("Documents:");
  for (const document of documents || []) {
    console.log(`Type: ${document.docType}`);
    console.log("Fields:");
    for (const [name, field] of Object.entries(document.fields)) {
      console.log(
        `Field ${name} has value '${field.value}' with a confidence score of ${field.confidence}`
      );
    }
  }
  console.log("Pages:");
  for (const page of pages || []) {
    console.log(`Page number: ${page.pageNumber} (${page.width}x${page.height} ${page.unit})`);
  }

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

main().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Een document analyseren vanuit een URL

Als alternatief voor het bieden van een leesbare stroom, kan in plaats daarvan een openbaar toegankelijke URL worden opgegeven 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 gebruikmaken van op headers of certificaten gebaseerde geheimen, werken niet, 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 biedt ook ondersteuning voor het extraheren van velden uit bepaalde typen algemene documenten, zoals ontvangstbewijzen, facturen, visitekaartjes, identiteitsdocumenten en meer met behulp van vooraf gedefinieerde modellen van de Document Intelligence-service. De vooraf samengestelde modellen kunnen worden geleverd als model-id-tekenreeksen (hetzelfde als aangepaste documentmodellen, zie de sectie andere vooraf gedefinieerde 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 wordt deze geconverteerd voor het gebruik van JavaScript-naamconventies.

Voorbeeldobjecten DocumentModel voor de huidige versie van de service-API (2022-08-31) vindt u in de prebuilt map met voorbeelden. In het volgende voorbeeld gebruiken we de PrebuiltReceiptModel uit het bestand [prebuilt-receipt.ts] in die map.

Omdat het belangrijkste voordeel van analyse op basis van DocumentModelsterkere TypeScript-typebeperkingen is, wordt het volgende voorbeeld geschreven in TypeScript met behulp van de syntaxis van de ECMAScript-module:

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

U kunt ook, zoals hierboven vermeld, in plaats van het gebruik PrebuiltReceiptModelvan , wat het sterkere retourtype produceert, de model-id van de vooraf gemaakte ontvangstbevestiging ('vooraf gemaakte ontvangstbevestiging') worden gebruikt, maar de documentvelden worden niet sterk getypt in TypeScript en de veldnamen zijn over het algemeen in 'PascalCase' in plaats van 'camelCase'.

Andere vooraf gemaakte modellen

U bent niet beperkt tot ontvangstbewijzen! Er zijn een paar vooraf gebouwde modellen om uit te kiezen, met nog meer onderweg. Elk vooraf samengesteld model heeft een eigen set ondersteunde velden:

• Ontvangstbewijzen, met behulp van PrebuiltReceiptModel (zoals hierboven) of de vooraf gedefinieerde id van het ontvangstbewijsmodel "prebuilt-receipt".
• Visitekaartjes, met of de PrebuiltBusinessCardModel bijbehorende model-id "prebuilt-businessCard".
• Facturen, met of de PrebuiltInvoiceModel bijbehorende model-id "prebuilt-invoice".
• Identiteitsdocumenten (zoals rijbewijzen en paspoorten), met of de PrebuiltIdDocumentModel model-id "prebuilt-idDocument".
• W2 Belastingformulieren (Verenigde Staten), met of de PrebuiltTaxUsW2Model model-id "prebuilt-tax.us.w2".
• Zorgverzekeringskaarten (Verenigde Staten), met behulp van [PrebuiltHealthInsuranceCardUsModel][samples-prebuilt-healthinsurancecard.us] of de bijbehorende model-id "prebuilt-healthInsuranceCard.us".

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

• Het vooraf samengestelde indelingsmodel (zie De vooraf gedefinieerde indeling gebruiken hieronder), waarmee informatie wordt geëxtraheerd over basisindelingselementen (OCR), zoals pagina's en tabellen.
• Het vooraf samengestelde algemene documentmodel (zie Het vooraf gedefinieerde document gebruiken hieronder), waarmee sleutel-waardeparen (gerichte koppelingen tussen pagina-elementen, zoals gelabelde elementen) worden toegevoegd aan de informatie die door het indelingsmodel wordt geproduceerd.
• Het vooraf samengestelde model Lezen (zie Use the 'read' vooraf gedefinieerd hieronder), waarmee alleen tekstelementen, zoals paginawoorden en regels, worden geëxtraheerd, samen met informatie over de taal van het document.

Zie de documentatie van de service van de beschikbare vooraf samengestelde modellen voor informatie over de velden van al deze modellen.

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

De vooraf samengestelde indeling gebruiken

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

Omdat het belangrijkste voordeel van analyse op basis van DocumentModelsterkere TypeScript-typebeperkingen is, wordt het volgende voorbeeld geschreven in TypeScript met behulp van de syntaxis van de ECMAScript-module:

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

Het vooraf samengestelde document gebruiken

Het "prebuilt-document" model extraheert informatie over sleutel-waardeparen (gerichte koppelingen tussen pagina-elementen, zoals gelabelde velden) naast de eigenschappen die worden geproduceerd door de methode voor indelingsextractie. Dit vooraf samengestelde (algemene) documentmodel biedt vergelijkbare functionaliteit als de aangepaste modellen die zijn getraind zonder labelgegevens in eerdere iteraties van de Document Intelligence-service, maar het wordt nu geleverd als een vooraf samengesteld model dat werkt met een grote verscheidenheid aan documenten. We bieden een sterk getypt exemplaar DocumentModel met de naam PrebuiltDocumentModel dat dit model aanroept, of zoals altijd kan de model-id "prebuilt-document" rechtstreeks worden gebruikt.

Omdat het belangrijkste voordeel van analyse op basis van DocumentModelsterkere TypeScript-typebeperkingen is, wordt het volgende voorbeeld geschreven in TypeScript met behulp van de syntaxis van de ECMAScript-module:

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

De vooraf gedefinieerde 'leesbewerking' gebruiken

Het "prebuilt-read" model extraheert tekstinformatie in een document, zoals woorden en alinea's, en analyseert de taal en schrijfstijl (bijvoorbeeld handgeschreven versus typen) van die tekst. We bieden een sterk getypt exemplaar DocumentModel met de naam PrebuiltReadModel dat dit model aanroept, of zoals altijd kan de model-id "prebuilt-read" rechtstreeks worden gebruikt.

Omdat het belangrijkste voordeel van analyse op basis van DocumentModelsterkere TypeScript-typebeperkingen is, wordt het volgende voorbeeld geschreven in TypeScript met behulp van de syntaxis van de ECMAScript-module:

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

Een document classificeren

De Document Intelligence-service ondersteunt aangepaste documentclassificaties waarmee documenten kunnen worden geclassificeerd in een set vooraf gedefinieerde categorieën op basis van een set trainingsgegevens. 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 stroom met het document dat moet worden geclassificeerd, en heeft deze 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:

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

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 . Als u een model bouwt op basis van gelabelde trainingsgegevens, wordt er een nieuw model gemaakt dat wordt getraind op uw eigen documenten. Het resulterende model kan waarden herkennen uit de structuren van die documenten. De modelbouwbewerking 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 bouwen van een model 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 team van de Document Intelligence-service 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 bestaande Azure Storage-container:

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

Aangepaste classificaties worden op een vergelijkbare manier gebouwd met behulp van de beginBuildDocumentClassifier -methode in plaats beginBuildDocumentModelvan . Raadpleeg het voorbeeld van de buildclassificatie voor meer informatie over het bouwen van een aangepaste classificatie, omdat de invoertrainingsgegevens in een iets andere indeling worden gegeven. Zie de documentatie van de Document Intelligence-service voor informatie over het bouwen van een set trainingsgegevens voor een aangepaste classificatie.

Modellen beheren

DocumentModelAdministrationClient biedt ook verschillende methoden voor het openen en weergeven van modellen. In het volgende voorbeeld ziet u hoe u de modellen in een resource doorloopt (dit omvat zowel aangepaste modellen in de resource als vooraf gedefinieerde modellen die gemeenschappelijk zijn voor alle resources), een model op basis van id op te halen en een model te verwijderen.

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

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

Problemen oplossen

Zie de handleiding voor probleemoplossing voor hulp bij het oplossen van problemen.

Logboekregistratie

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

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

setLogLevel("info");

Voor meer gedetailleerde instructies over het inschakelen van logboeken kunt u de @azure-/loggerpakketdocumenten bekijken.

Volgende stappen

Bekijk de map met voorbeelden voor gedetailleerde codevoorbeelden die laten zien hoe u deze bibliotheek gebruikt, inclusief verschillende functies en methoden die niet worden weergegeven in de bovenstaande sectie 'Voorbeelden', zoals het kopiëren en opstellen van modellen, het weergeven van bewerkingen voor modelbeheer en het verwijderen van modellen.

Bijdragen

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