Dela via

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

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 markeringsmarkeringar, tillsammans med deras koordinater för avgränsningsområdet, 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ördefinierade – Analysera data från vissa typer av vanliga dokument (till exempel kvitton, fakturor, visitkort eller identitetshandlingar) med hjälp av fördefinierade modeller.
  • Anpassad – Skapa anpassade modeller för att extrahera text, fältvärden, markeringsmarkeringar och tabelldata från dokument. Anpassade modeller skapas med dina egna data, så de skräddarsys efter dina dokument.
  • Klassificerare – Skapa anpassade klassificerare för att kategorisera dokument i fördefinierade klasser.

| Package (NPM) | API-referensdokumentation | Produktdokumentation | Exempel

Anmärkning

Tjänsten Document Intelligence 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 Распознаватель приложенатель приложений till Azure AI Document Intelligence, så "Распознаватель приложений

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

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

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

Mer information finns i vår supportprincip.

Förutsättningar

Skapa en formigenkänningsresurs

I skrivande stund refererar Azure Portal fortfarande till resursen som en "Formigenkänning" resurs. I framtiden kan detta komma att uppdateras till en "Document Intelligence"-resurs. För tillfället används namnet "Распознаватель приложени

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

Du kan skapa resursen med hjälp av

alternativ 1:Azure Portal

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 du <your-resource-group-name> 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 Document Intelligence-tjänsten måste du välja antingen a DocumentAnalysisClient eller a DocumentModelAdministrationClientoch skapa en instans av den här typen. I följande exempel kommer vi att använda DocumentAnalysisClient. Om du vill skapa en klientinstans för att få åtkomst till API:et för dokumentintelligens behöver endpoint 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 som använder Azure Active Directory RBAC för att auktorisera klienten TokenCredential .

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änd 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:

Obs! 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 slutpunkt kan du använda den på följande sätt:

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

Använda Azure Active Directory

Auktorisering av API-nyckel används i de flesta exemplen, men du kan också autentisera klienten med Azure Active Directory med hjälp av Azure Identity-biblioteket. Om du vill använda providern DefaultAzureCredential 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 med hjälp av ett huvudnamn för tjänsten måste du också registrera ett AAD-program och bevilja åtkomst till tjänsten genom att tilldela "Cognitive Services User" rollen till tjänstens huvudnamn (observera att andra roller, till exempel "Owner" inte beviljar de nödvändiga behörigheterna, utan bara "Cognitive Services User" räcker 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.

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

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

Suveräna moln

Anslut till alternativa Azure-molnmiljöer (till exempel Azure China eller Azure Government) genom att ange alternativet när du skapar klienten audience . Använd uppräkningen KnownFormRecognizerAudience för att välja rätt värde för din miljö.

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

Om du inte anger något audience alternativ är standardvärdet lämpligt för det offentliga Azure-molnet (https://cognitiveservices.azure.com).

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 filström för indatadokument med hjälp av en anpassad eller fördefinierad modell som ges av dess modell-ID. Information om de fördefinierade modeller som stöds i alla resurser och deras modell-ID:n/utdata finns i tjänstens dokumentation om modellerna.
  • beginAnalyzeDocumentFromUrl, som har samma funktion som beginAnalyzeDocument, men skickar en offentligt tillgänglig URL till en fil i stället för en filström.

DocumentModelAdministrationClient

DocumentModelAdministrationClient Tillhandahå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 använder etiketter på en träningsdatauppsättning.
  • beginComposeDocumentModel Startar en åtgärd för att skapa flera modeller till en enda modell. När den används för anpassad formulärigenkänning utför den nya sammansatta modellen först en klassificering av indatadokumenten för att avgöra vilken av dess delmodeller som är mest lämplig.
  • 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 från målresursen CopyAuthorization , 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.
  • getDocumentModeloch listDocumentModelsdeleteDocumentModel gör det möjligt att hantera modeller i resursen.
  • getOperation och listOperations gör det möjligt att visa 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 även kan skapas med hjälp av Document Intelligence-tjänstens grafiska användargränssnitt: Document Intelligence Studio.

Exempel på kodavsnitt som illustrerar användningen av DocumentModelAdministrationClient för att bygga en modell finns nedan, i exempelavsnittet "Bygg en modell".

Tidskrävande åtgärder

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

I Azure AI Document Intelligence är åtgärder som skapar modeller (inklusive kopiering och komponering av modeller) samt analys-/dataextraheringsåtgärder LRO:er. 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 på att åtgärden ska slutföras genom att anropa och vänta pollUntilDone på metoden på avsökaren som returneras från begin<operation-name> metoden. Exempelkodfragment tillhandahålls för att illustrera hur du använder 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 klientbiblioteken för dokumentintelligens.

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 som tränats med dina egna data eller en fördefinierad modell som tillhandahålls av tjänsten (se Använda 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).

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

Analysera ett dokument från en URL

Som ett alternativ till att tillhandahålla en läsbar dataström kan en offentligt tillgänglig URL anges 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 fungerar inte en privat intranät-URL eller URL:er som använder rubrik- eller certifikatbaserade hemligheter, eftersom Document Intelligence-tjä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 som kvitton, fakturor, visitkort, identitetshandlingar med mera med hjälp av fördefinierade modeller som tillhandahålls av Document Intelligence-tjänsten. De fördefinierade modellerna kan anges antingen som modell-ID-strängar (samma som anpassade dokumentmodeller – se avsnittet om andra fördefinierade 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 den konverteras för att använda JavaScript-namnkonventioner.

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

Eftersom den största fördelen med DocumentModel-baserad analys är starkare begränsningar av TypeScript-typ skrivs följande exempel i TypeScript med hjälp av ECMAScript-modulsyntax:

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

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 ("fördefinierat kvitto") användas, men dokumentfälten kommer inte att skrivas 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örbyggda modeller att välja mellan, och fler är på väg. Varje fördefinierad modell har en egen uppsättning fält som stöds:

  • Kvitton, med hjälp av PrebuiltReceiptModel (som ovan) eller det fördefinierade kvittomodell-ID:t "prebuilt-receipt".
  • Visitkort, med hjälp av PrebuiltBusinessCardModel eller dess modell-ID "prebuilt-businessCard".
  • Fakturor, med hjälp av PrebuiltInvoiceModel eller dess modell-ID "prebuilt-invoice".
  • Identitetshandlingar (t.ex. körkort och pass), med hjälp av PrebuiltIdDocumentModel eller dess modell-ID "prebuilt-idDocument".
  • W2 Tax Forms (USA), med hjälp av PrebuiltTaxUsW2Model eller dess modell-ID "prebuilt-tax.us.w2".
  • Sjukförsäkringskort (USA) med hjälp av [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 grundläggande layoutelement (OCR) som sidor och tabeller.
  • Den fördefinierade allmänna dokumentmodellen (se Använd det fördefinierade dokumentet nedan), som lägger till nyckel/värde-par (riktade associationer mellan sidelement, t.ex. märkta element) till den information som skapas av layoutmodellen.
  • Den fördefinierade läsmodellen (se Använd den fördefinierade "läsa" nedan), som endast extraherar textelement, till exempel sidord och rader, tillsammans med information om dokumentets språk.

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

Fälten i alla fördefinierade modeller kan också nås programmatiskt med hjälp getDocumentModel av metoden (av deras modell-ID:n) för DocumentModelAdministrationClient 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/linjer och markeringstecken), tabeller och visuella textformat tillsammans med deras avgränsningsområden och sträcker sig inom textinnehållet i indatadokumenten. Vi tillhandahåller en starkt typifierad 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 största fördelen med DocumentModel-baserad analys är starkare begränsningar av TypeScript-typ skrivs följande exempel i TypeScript med hjälp av ECMAScript-modulsyntax:

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

Använda det fördefinierade dokumentet "dokument"

Modellen "prebuilt-document" extraherar information om nyckel/värde-par (riktade associationer mellan sidelement, t.ex. 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 Document Intelligence-tjänsten, men den tillhandahålls nu som en fördefinierad modell som fungerar med en mängd olika dokument. Vi tillhandahåller en starkt typifierad 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 största fördelen med DocumentModel-baserad analys är starkare begränsningar av TypeScript-typ skrivs följande exempel i TypeScript med hjälp av ECMAScript-modulsyntax:

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

Använda den fördefinierade "läs"

Modellen "prebuilt-read" extraherar textinformation i ett dokument, t.ex. ord och stycken, och analyserar språket och skrivstilen (t.ex. handskriven kontra typuppsättning) för den texten. Vi tillhandahåller en starkt typifierad 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 största fördelen med DocumentModel-baserad analys är starkare begränsningar av TypeScript-typ skrivs följande exempel i TypeScript med hjälp av ECMAScript-modulsyntax:

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

Klassificera ett dokument

Document Intelligence-tjä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:

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

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

Skapa en modell

SDK:n har också stöd för att skapa modeller med hjälp av DocumentModelAdministrationClient klassen. Genom att skapa en modell från märkta träningsdata skapas en ny modell som tränas på dina egna dokument, och den resulterande modellen kommer att kunna identifiera värden från dokumentens strukturer. Modellbyggnadsåtgärden accepterar en SAS-kodad URL till en Azure Storage Blob-container som innehåller träningsdokumenten. Dokumentintelligenstjänstens infrastruktur läser filerna i behållaren och skapar en modell baserat på deras innehåll. Mer information om hur du skapar och strukturerar en behållare för träningsdata finns i Document Intelligence-tjänstens dokumentation för att skapa en modell.

Även om vi tillhandahåller dessa metoder för att skapa programmatiska modeller har Document Intelligence-tjänstteamet 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:

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

Anpassade klassificerare skapas på ett liknande sätt med hjälp av beginBuildDocumentClassifier metoden i stället för beginBuildDocumentModel. Mer information om hur du skapar en anpassad klassificerare finns i exemplet på byggklassificerare , eftersom indataträningsdata 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 för Document Intelligence-tjänsten.

Hantera modeller

DocumentModelAdministrationClient Innehåller också flera metoder för att komma åt och lista 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.

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

Liknande metoder listDocumentClassifiers och getDocumentClassifier är tillgängliga för att lista och få information om anpassade klassificerare samt deleteDocumentClassifier för att ta bort anpassade klassificerare.

Felsökning

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

Loggning / Skogsavverkning

Aktivering av loggning kan hjälpa dig att hitta användbar information om fel. Om du vill se en logg med 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:

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

setLogLevel("info");

Mer detaljerade anvisningar om hur du aktiverar loggar finns i dokument för @azure/logger-paket.

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 att kopiera och komponera modeller, lista modellhanteringsoperationer och ta bort modeller.

Bidrag

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