Dela via

Azure AI Document Intelligence-klientbibliotek för JavaScript – version 5.0.0

  • Artikel

Azure AI Document Intelligence är en molntjänst som använder maskininlärning för att analysera text och strukturerade data från dina dokument. Den innehåller följande huvudfunktioner:

  • Layout – Extrahera text, tabellstrukturer och urvalsmarkeringar, tillsammans med deras koordinater för avgränsningsregion, från dokument.
  • Dokument – Analysera entiteter, nyckel/värde-par, tabeller och urvalsmarkeringar från dokument med hjälp av den allmänna fördefinierade dokumentmodellen.
  • Läs – Läs information om textelement, till exempel sidord och rader utöver information om textspråk.
  • Fördefinierad – Analysera data från vissa typer av vanliga dokument (till exempel kvitton, fakturor, visitkort eller identitetsdokument) med hjälp av fördefinierade modeller.
  • Anpassad – Skapa anpassade modeller för att extrahera text, fältvärden, urvalsmarkeringar och tabelldata från dokument. Anpassade modeller skapas med dina egna data, så de är skräddarsydda för dina dokument.
  • Klassificerare – Skapa anpassade klassificerare för att kategorisera dokument i fördefinierade klasser.

| KällkodPaket (NPM) | API-referensdokumentation | Produktdokumentation | Prover

Anteckning

Dokumentintelligenstjänsten kallades tidigare "Azure Formigenkänning". Dessa tjänster är en och samma, och @azure/ai-form-recognizer paketet för JavaScript är Azure SDK-paketet för Azure AI Document Intelligence-tjänsten. I skrivande stund pågår namnbytet av Azure Formigenkänning till Azure AI Document Intelligence, så "Formigenkänning" och "Dokumentinformation" kan användas synonymt i vissa fall.

Installera @azure/ai-form-recognizer-paketet

Installera Azure Document Intelligence-klientbiblioteket för JavaScript med npm:

npm install @azure/ai-form-recognizer

Komma igång

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

Miljöer som stöds för närvarande

Mer information finns i vår supportpolicy .

Förutsättningar

Skapa en Formigenkänning resurs

Obs! I skrivande stund refererar Azure Portal fortfarande till resursen som en "Formigenkänning"-resurs. I framtiden kan detta uppdateras till en "Dokumentinformation"-resurs. För tillfället använder följande dokumentation namnet "Formigenkänning".

Dokumentinformation stöder både åtkomst med flera tjänster och en enda tjänst. Skapa en Cognitive Services-resurs om du planerar att komma åt flera kognitiva tjänster under en enda slutpunkt/nyckel. För endast Formigenkänning åtkomst skapar du en Formigenkänning resurs.

Du kan skapa resursen med hjälp av

Alternativ 1:Azure-portalen

Alternativ 2:Azure CLI.

Nedan visas ett exempel på hur du kan skapa en Formigenkänning resurs med hjälp av 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

Om du använder Azure CLI ersätter <your-resource-group-name> du och <your-resource-name> med dina egna unika namn:

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

Skapa och autentisera en klient

För att kunna interagera med dokumentinformationstjänsten måste du välja antingen en DocumentAnalysisClient eller en DocumentModelAdministrationClientoch skapa en instans av den här typen. I följande exempel använder DocumentAnalysisClientvi . Om du vill skapa en klientinstans för att få åtkomst till API:et endpoint för dokumentinformation behöver du för din Formigenkänning resurs och en credential. Klienterna kan använda antingen en AzureKeyCredential med en API-nyckel för din resurs eller en TokenCredential som använder Azure Active Directory RBAC för att auktorisera klienten.

Du hittar slutpunkten för din Formigenkänning resurs antingen i Azure-portalen eller med hjälp av Azure CLI-kodfragmentet nedan:

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

Använda en API-nyckel

Använd Azure-portalen för att bläddra till din Formigenkänning resurs och hämta en API-nyckel, eller använd Azure CLI-kodfragmentet nedan:

Observera: Ibland kallas API-nyckeln för en "prenumerationsnyckel" eller "prenumerations-API-nyckel".

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

När du har en API-nyckel och en slutpunkt kan du använda den på följande sätt:

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

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

Använda Azure Active Directory

API-nyckelauktorisering används i de flesta exempel, men du kan även autentisera klienten med Azure Active Directory med hjälp av Azure Identity-biblioteket. Om du vill använda DefaultAzureCredential-providern som visas nedan eller andra leverantörer av autentiseringsuppgifter som medföljer Azure SDK installerar @azure/identity du paketet:

npm install @azure/identity

Om du vill autentisera "Cognitive Services User" med tjänstens huvudnamn måste du också registrera ett AAD-program och bevilja åtkomst till tjänsten genom att tilldela rollen till tjänstens huvudnamn (obs! Andra roller som "Owner" inte beviljar nödvändiga behörigheter räcker bara "Cognitive Services User" för att köra exemplen och exempelkoden).

Ange värdena för klient-ID, klient-ID och klienthemlighet för AAD-programmet som miljövariabler: 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());

Viktiga begrepp

DocumentAnalysisClient

DocumentAnalysisClient tillhandahåller åtgärder för att analysera indatadokument med hjälp av anpassade och fördefinierade modeller. Den har tre metoder:

  • beginAnalyzeDocument, som extraherar data från en indatadokumentfilström med hjälp av en anpassad eller fördefinierad modell som anges av dess modell-ID. Information om de fördefinierade modeller som stöds i alla resurser och deras modell-ID/utdata finns i tjänstens dokumentation om modellerna.
  • beginAnalyzeDocumentFromUrl, som utför samma funktion som beginAnalyzeDocument, men skickar en offentligt tillgänglig URL för en fil i stället för en filström.

DocumentModelAdministrationClient

DocumentModelAdministrationClient innehåller åtgärder för att hantera (skapa, läsa, lista och ta bort) modeller i resursen:

  • beginBuildDocumentModel startar en åtgärd för att skapa en ny dokumentmodell från din egen träningsdatauppsättning. Den skapade modellen kan extrahera fält enligt ett anpassat schema. Träningsdata förväntas finnas i en Azure Storage-container och organiseras enligt en viss konvention. Se tjänstens dokumentation om hur du skapar en träningsdatauppsättning för en mer detaljerad förklaring av hur du tillämpar etiketter på en träningsdatauppsättning.
  • beginComposeDocumentModel startar en åtgärd för att skapa flera modeller i en enda modell. När den nya sammansatta modellen används för anpassad formulärigenkänning utför den först en klassificering av indatadokumenten för att avgöra vilken av dess undermodeller som är lämpligast.
  • beginCopyModelTo startar en åtgärd för att kopiera en anpassad modell från en resurs till en annan (eller till och med till samma resurs). Det kräver en CopyAuthorization från målresursen som kan genereras med hjälp av getCopyAuthorization metoden .
  • getResourceDetails hämtar information om resursens gränser, till exempel antalet anpassade modeller och det maximala antalet modeller som resursen kan stödja.
  • getDocumentModel, listDocumentModelsoch deleteDocumentModel aktivera hantering av modeller i resursen.
  • getOperation och listOperations aktivera visning av status för åtgärder för att skapa modeller, även de åtgärder som pågår eller som har misslyckats. Åtgärder behålls i 24 timmar.

Observera att modeller också kan skapas med hjälp av document intelligence-tjänstens grafiska användargränssnitt: Document Intelligence Studio.

Exempelkodfragment som illustrerar användningen av DocumentModelAdministrationClient för att skapa en modell finns nedan i exempelavsnittet "Skapa en modell".

Tidskrävande åtgärder

Långvariga åtgärder (LRI) är åtgärder som består av en första begäran som skickas till tjänsten för att starta en åtgärd, följt av avsökning för ett resultat med ett visst intervall för att avgöra om åtgärden har slutförts och om den misslyckades eller lyckades. I slutändan misslyckas LRO antingen med ett fel eller ger ett resultat.

I Azure AI Document Intelligence är åtgärder som skapar modeller (inklusive kopiering och sammansättning av modeller) samt analys-/dataextraheringsåtgärder LRE. SDK-klienterna tillhandahåller asynkrona begin<operation-name> metoder som returnerar Promise<PollerLike> objekt. Objektet PollerLike representerar åtgärden, som körs asynkront på tjänstens infrastruktur, och ett program kan vänta tills åtgärden har slutförts genom att anropa och vänta på pollUntilDone metoden på den poller som returneras från begin<operation-name> metoden. Exempelkodfragment tillhandahålls för att illustrera användningen av långvariga åtgärder i nästa avsnitt.

Exempel

Följande avsnitt innehåller flera JavaScript-kodfragment som illustrerar vanliga mönster som används i dokumentinformationsklientbiblioteken.

Analysera ett dokument med ett modell-ID

Metoden beginAnalyzeDocument kan extrahera fält och tabelldata från dokument. Analysen kan använda antingen en anpassad modell, tränad med dina egna data eller en fördefinierad modell som tillhandahålls av tjänsten (se Använd fördefinierade modeller nedan). En anpassad modell är skräddarsydd för dina egna dokument, så den bör endast användas med dokument med samma struktur som en av dokumenttyperna i modellen (det kan finnas flera, till exempel i en sammansatt modell).

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

Analysera ett dokument från en URL

Som ett alternativ till att tillhandahålla en läsbar ström kan en offentligt tillgänglig URL tillhandahållas i stället med hjälp av beginAnalyzeDocumentFromUrl metoden . "Offentligt tillgänglig" innebär att URL-källor måste vara tillgängliga från tjänstens infrastruktur (med andra ord kommer en privat intranät-URL eller URL:er som använder huvud- eller certifikatbaserade hemligheter inte att fungera, eftersom dokumentinformationstjänsten måste kunna komma åt URL:en). Själva URL:en kan dock koda en hemlighet, till exempel en Azure Storage-blob-URL som innehåller en SAS-token i frågeparametrarna.

Använda fördefinierade dokumentmodeller

Metoden beginAnalyzeDocument stöder också extrahering av fält från vissa typer av vanliga dokument, till exempel kvitton, fakturor, visitkort, identitetsdokument och mer med hjälp av fördefinierade modeller som tillhandahålls av document intelligence-tjänsten. De fördefinierade modellerna kan tillhandahållas antingen som modell-ID-strängar (samma som anpassade dokumentmodeller – se det andra fördefinierade avsnittet modeller nedan) eller med hjälp av ett DocumentModel objekt. När du använder en DocumentModelger Document Intelligence SDK för JavaScript en mycket starkare TypeScript-typ för de resulterande extraherade dokumenten baserat på modellens schema, och det konverteras till att använda JavaScript-namngivningskonventioner.

Exempelobjekt DocumentModel för den aktuella tjänstens API-version (2022-08-31) finns i exempelkatalogenprebuilt. I följande exempel använder PrebuiltReceiptModel vi från filen [prebuilt-receipt.ts] i den katalogen.

Eftersom den huvudsakliga fördelen med -baserad analys är starkare TypeScript-typbegränsningar, skrivs följande exempel i TypeScript med hjälp av DocumentModelECMAScript-modulsyntax:

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

Alternativt, som nämnts ovan, i stället för att använda PrebuiltReceiptModel, som ger den starkare returtypen, kan det fördefinierade kvittots modell-ID ("prebuilt-receipt") användas, men dokumentfälten skrivs inte starkt i TypeScript, och fältnamnen kommer vanligtvis att vara i "PascalCase" i stället för "camelCase".

Andra fördefinierade modeller

Du är inte begränsad till kvitton! Det finns några fördefinierade modeller att välja mellan, med fler på väg. Varje fördefinierad modell har en egen uppsättning fält som stöds:

  • Kvitton, med ( PrebuiltReceiptModel som ovan) eller det fördefinierade kvittomodell-ID:t "prebuilt-receipt".
  • Visitkort, med eller PrebuiltBusinessCardModel dess modell-ID "prebuilt-businessCard".
  • Fakturor, med eller PrebuiltInvoiceModel dess modell-ID "prebuilt-invoice".
  • Identitetsdokument (till exempel körkort och pass), med hjälp av PrebuiltIdDocumentModel eller dess modell-ID "prebuilt-idDocument".
  • W2 Skatteformulär (USA), med hjälp av PrebuiltTaxUsW2Model eller dess modell-ID "prebuilt-tax.us.w2".
  • Sjukförsäkringskort (USA), med [PrebuiltHealthInsuranceCardUsModel][samples-prebuilt-healthinsurancecard.us] eller dess modell-ID "prebuilt-healthInsuranceCard.us".

Var och en av ovanstående fördefinierade modeller producerar documents (extraherade instanser av modellens fältschema). Det finns också tre fördefinierade modeller som inte har fältscheman och därför inte producerar documents. De är:

  • Den fördefinierade layoutmodellen (se Använd den fördefinierade layouten nedan), som extraherar information om OCR-element (Basic Layout), till exempel sidor och tabeller.
  • Den fördefinierade allmänna dokumentmodellen (se Använd det "dokument" som är fördefinierat nedan), som lägger till nyckel/värde-par (riktade associationer mellan sidelement, till exempel märkta element) till informationen som skapas av layoutmodellen.
  • Den fördefinierade läsmodellen (se Använd den "lästa" som är fördefinierad nedan), som endast extraherar textelement, till exempel sidord och linjer, tillsammans med information om dokumentets språk.

Information om fälten för alla dessa modeller finns i tjänstens dokumentation om de tillgängliga fördefinierade modellerna.

Fälten för alla fördefinierade modeller kan också nås programmatiskt med hjälp getDocumentModel av metoden (med deras modell-ID: n) DocumentModelAdministrationClient för och inspektera docTypes fältet i resultatet.

Använd den fördefinierade layouten

Modellen "prebuilt-layout" extraherar endast de grundläggande elementen i dokumentet, till exempel sidor (som består av textord/rader och markeringsmarkeringar), tabeller och visuella textformat tillsammans med deras avgränsningsregioner och sträcker sig inom textinnehållet i indatadokumenten. Vi tillhandahåller en starkt typad DocumentModel instans med namnet PrebuiltLayoutModel som anropar den här modellen, eller som alltid kan dess modell-ID "prebuilt-layout" användas direkt.

Eftersom den huvudsakliga fördelen med -baserad analys är starkare TypeScript-typbegränsningar, skrivs följande exempel i TypeScript med hjälp av DocumentModelECMAScript-modulsyntax:

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

Använd det fördefinierade dokumentet

Modellen "prebuilt-document" extraherar information om nyckel/värde-par (riktade associationer mellan sidelement, till exempel märkta fält) utöver de egenskaper som skapas av layoutextraheringsmetoden. Den här fördefinierade (allmänna) dokumentmodellen ger liknande funktioner som de anpassade modeller som tränats utan etikettinformation i tidigare iterationer av dokumentunderrättelsetjänsten, men den tillhandahålls nu som en fördefinierad modell som fungerar med en mängd olika dokument. Vi tillhandahåller en starkt typad DocumentModel instans med namnet PrebuiltDocumentModel som anropar den här modellen, eller som alltid kan dess modell-ID "prebuilt-document" användas direkt.

Eftersom den huvudsakliga fördelen med -baserad analys är starkare TypeScript-typbegränsningar, skrivs följande exempel i TypeScript med hjälp av DocumentModelECMAScript-modulsyntax:

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

Använd den fördefinierade "read"

Modellen "prebuilt-read" extraherar textinformation i ett dokument, till exempel ord och stycken, och analyserar språket och skrivstilen (t.ex. handskriven eller typuppsättning) för texten. Vi tillhandahåller en starkt typad DocumentModel instans med namnet PrebuiltReadModel som anropar den här modellen, eller som alltid kan dess modell-ID "prebuilt-read" användas direkt.

Eftersom den huvudsakliga fördelen med -baserad analys är starkare TypeScript-typbegränsningar, skrivs följande exempel i TypeScript med hjälp av DocumentModelECMAScript-modulsyntax:

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

Klassificera ett dokument

Dokumentinformationstjänsten stöder anpassade dokumentklassificerare som kan klassificera dokument i en uppsättning fördefinierade kategorier baserat på en träningsdatauppsättning. Dokument kan klassificeras med en anpassad klassificerare med hjälp beginClassifyDocument av DocumentAnalysisClientmetoden . Precis som beginAnalyzeDocument ovan accepterar den här metoden en fil eller dataström som innehåller dokumentet som ska klassificeras, och den har en beginClassifyDocumentFromUrl motsvarighet som accepterar en offentligt tillgänglig URL till ett dokument i stället.

Följande exempel visar hur du klassificerar ett dokument med hjälp av en anpassad klassificerare:

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

Information om hur du tränar en anpassad klassificerare finns i avsnittet om klassificerarutbildning i slutet av nästa avsnitt.

Skapa en modell

SDK har också stöd för att skapa modeller med hjälp av DocumentModelAdministrationClient klassen. När du skapar en modell från märkta träningsdata skapas en ny modell som tränas på dina egna dokument, och den resulterande modellen kan identifiera värden från strukturerna i dessa dokument. Modellskapandeåtgärden accepterar en SAS-kodad URL till en Azure Storage Blob-container som innehåller träningsdokumenten. Dokumentinformationstjänstens infrastruktur läser filerna i containern och skapar en modell baserat på deras innehåll. Mer information om hur du skapar och strukturerar en träningsdatacontainer finns i dokumentationen för document intelligence-tjänsten för att skapa en modell.

Vi tillhandahåller dessa metoder för att skapa programmatiska modeller, men dokumentunderrättelsetjänsten har skapat ett interaktivt webbprogram, Document Intelligence Studio, som gör det möjligt att skapa och hantera modeller på webben.

Följande program skapar till exempel en anpassad dokumentmodell med hjälp av en SAS-kodad URL till en befintlig 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);
});

Anpassade klassificerare är inbyggda på ett liknande sätt med hjälp av beginBuildDocumentClassifier metoden i stället beginBuildDocumentModelför . Mer information om hur du skapar en anpassad klassificerare finns i exemplet på byggklassificerare eftersom träningsdata för indata tillhandahålls i ett något annorlunda format. Information om hur du skapar en träningsdatauppsättning för en anpassad klassificerare finns i dokumentationen till Document Intelligence Service.

Hantera modeller

DocumentModelAdministrationClient innehåller också flera metoder för att komma åt och visa modeller. I följande exempel visas hur du itererar genom modellerna i en resurs (detta inkluderar både anpassade modeller i resursen och fördefinierade modeller som är gemensamma för alla resurser), hämtar en modell efter ID och tar bort en modell.

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

Liknande metoder listDocumentClassifiers och getDocumentClassifier är tillgängliga för att visa och hämta information om anpassade klassificerare utöver för att deleteDocumentClassifier ta bort anpassade klassificerare.

Felsökning

Mer information om felsökning finns i felsökningsguiden.

Loggning

Aktivering av loggning kan hjälpa dig att hitta användbar information om fel. Om du vill se en logg över HTTP-begäranden och svar anger du AZURE_LOG_LEVEL miljövariabeln till info. Du kan också aktivera loggning vid körning genom att anropa setLogLevel i @azure/logger:

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

setLogLevel("info");

Mer detaljerade anvisningar om hur du aktiverar loggar finns i @azure-/loggningspaketdokumenten.

Nästa steg

Ta en titt på exempelkatalogen för detaljerade kodexempel som visar hur du använder det här biblioteket, inklusive flera funktioner och metoder som inte visas i avsnittet "Exempel" ovan, till exempel kopiering och sammansättning av modeller, listning av modellhanteringsåtgärder och borttagning av modeller.

Bidra

Om du vill bidra till det här biblioteket kan du läsa bidragsguiden för att lära dig mer om hur du skapar och testar koden.

Visningar