Bibliothèque cliente Azure AI Document Intelligence pour JavaScript - version 5.1.0

Azure AI Document Intelligence est un service cloud qui utilise l’apprentissage automatique pour analyser le texte et les données structurées de vos documents. Il comprend les principales caractéristiques suivantes :

Mise en page : extrayez du texte, des structures de tableau et des marques de sélection, ainsi que les coordonnées de leur région limite, à partir de documents.
Document : analysez les entités, les paires clé-valeur, les tables et les marques de sélection des documents à l’aide du modèle de document prédéfini général.
Lire : lisez des informations sur les éléments textuels, tels que les mots et les lignes de page, en plus des informations sur la langue du texte.
Prédéfini : analysez les données de certains types de documents courants (tels que les reçus, les factures, les cartes de visite ou les documents d’identité) à l’aide de modèles prédéfinis.
Personnalisé : créez des modèles personnalisés pour extraire du texte, des valeurs de champ, des marques de sélection et des données de table à partir de documents. Les modèles personnalisés sont construits avec vos propres données, ils sont donc adaptés à vos documents.
Classificateurs - Créez des classificateurs personnalisés pour classer les documents dans des classes prédéfinies.

documentation de référence sur le code source | Package (NPM) | | Documentation produit | Exemples

Remarque

Le service Document Intelligence était auparavant connu sous le nom d'« Azure Form Recognizer ». Ces services sont identiques, et le @azure/ai-form-recognizer package pour JavaScript est le package SDK Azure pour le service Azure AI Document Intelligence. Au moment de la rédaction de cet article, le changement de nom d’Azure Form Recognizer en Azure AI Document Intelligence est en cours, de sorte que « Form Recognizer » et « Document Intelligence » peuvent être utilisés de manière interchangeable dans certains cas.

Installer le package `@azure/ai-form-recognizer`

Installez la bibliothèque cliente Azure Document Intelligence pour JavaScript avec npm:

npm install @azure/ai-form-recognizer

Mise en route

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

Environnements actuellement pris en charge

Versions LTS de Node.js
Dernières versions de Safari, Chrome, Edge et Firefox.

Pour plus d’informations, consultez notre de stratégie de support .

Conditions préalables

Un abonnement Azure
Une ressource Cognitive Services ou Form Recognizer. Si vous devez créer la ressource, vous pouvez utiliser le portail Azure ou azure CLI.

Créer une ressource Form Recognizer

Remarque : Au moment de la rédaction de cet article, le portail Azure fait toujours référence à la ressource en tant que ressource « Form Recognizer ». À l’avenir, il se peut qu’elle devienne une ressource « Document Intelligence ». Pour l’instant, la documentation suivante utilise le nom « Form Recognizer ».

Document Intelligence prend en charge l’accès multiservice et monoservice. Créez une ressource Cognitive Services si vous prévoyez d’accéder à plusieurs services cognitifs sous un seul point de terminaison/clé. Pour l’accès à Form Recognizer uniquement, créez une ressource Form Recognizer.

Vous pouvez créer la ressource à l’aide de

Option 1 :Portail Azure

Option 2 :Azure CLI.

Vous trouverez ci-dessous un exemple de création d’une ressource Form Recognizer à l’aide de l’interface de ligne de commande :

# 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

Si vous utilisez Azure CLI, remplacez <your-resource-group-name> et <your-resource-name> par vos propres noms uniques :

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

Créer et authentifier un client

Pour interagir avec le service Document Intelligence, vous devez sélectionner a DocumentAnalysisClient ou a DocumentModelAdministrationClientet créer une instance de ce type. Dans les exemples suivants, nous utiliserons DocumentAnalysisClient. Pour créer une instance cliente permettant d’accéder à l’API Document Intelligence, vous aurez besoin de la endpoint ressource Form Recognizer et d’un credential. Les clients peuvent utiliser un avec une AzureKeyCredential clé API de votre ressource ou un TokenCredential qui utilise Azure Active Directory RBAC pour autoriser le client.

Vous pouvez trouver le point de terminaison de votre ressource Form Recognizer dans le portail Azure ou à l’aide de l’extrait de code de ligne de commande Azure ci-dessous :

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

Utiliser une clé API

Utilisez le portail Azure pour accéder à votre ressource Form Recognizer et récupérer une clé d’API, ou utilisez l’extrait de code Azure CLI ci-dessous :

Remarque : Parfois, la clé API est appelée « clé d’abonnement » ou « clé API d’abonnement ».

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

Une fois que vous disposez d’une clé API et d’un point de terminaison, vous pouvez les utiliser comme suit :

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

Utiliser Azure Active Directory

L’autorisation de clé API est utilisée dans la plupart des exemples, mais vous pouvez également authentifier le client auprès d’Azure Active Directory à l’aide de la bibliothèque Azure Identity. Pour utiliser le fournisseur DefaultAzureCredential illustré ci-dessous ou d’autres fournisseurs d’informations d’identification fournis avec le SDK Azure, installez le @azure/identity package :

npm install @azure/identity

Pour vous authentifier à l’aide d’un principal de service, vous devez également inscrire une application AAD et accorder l’accès au service en attribuant le "Cognitive Services User" rôle à votre principal de service (remarque : d’autres rôles, tels que n’accorderont "Owner" pas les autorisations nécessaires, suffiront uniquement "Cognitive Services User" pour exécuter les exemples et l’exemple de code).

Définissez les valeurs de l’ID client, de l’ID de locataire et de la clé secrète client de l’application AAD en tant que variables d’environnement : 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,
);

Clouds souverains

Connectez-vous à d’autres environnements cloud Azure (tels qu’Azure Chine ou Azure Government) en spécifiant l’option lors de la audience création de votre client. Utilisez l’énumération KnownFormRecognizerAudience pour sélectionner la valeur correcte pour votre environnement.

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

Si vous ne spécifiez pas l’option audience , la valeur par défaut convient au cloud public Azure (https://cognitiveservices.azure.com).

Concepts clés

`DocumentAnalysisClient`

DocumentAnalysisClient Fournit des opérations d’analyse des documents d’entrée à l’aide de modèles personnalisés et prédéfinis. Il dispose de trois méthodes :

beginAnalyzeDocument, qui extrait des données d’un flux de fichiers de document d’entrée à l’aide d’un modèle personnalisé ou prédéfini attribué par son ID de modèle. Pour plus d’informations sur les modèles prédéfinis pris en charge dans toutes les ressources et leurs ID/sorties de modèle, consultez la documentation du service sur les modèles.
beginAnalyzeDocumentFromUrl, qui remplit la même fonction que beginAnalyzeDocument, mais soumet une URL accessible au public d’un fichier au lieu d’un flux de fichiers.

`DocumentModelAdministrationClient`

DocumentModelAdministrationClient Fournit des opérations de gestion (création, lecture, liste et suppression) de modèles dans la ressource :

beginBuildDocumentModel Démarre une opération pour créer un modèle de document à partir de votre propre ensemble de données d’entraînement. Le modèle créé peut extraire des champs selon un schéma personnalisé. Les données d’entraînement doivent se trouver dans un conteneur de stockage Azure et être organisées selon une convention particulière. Pour plus d’informations sur l’application d’étiquettes à un ensemble de données d’entraînement, consultez la documentation du service sur la création d’un ensemble de données d’entraînement .
beginComposeDocumentModel Démarre une opération pour composer plusieurs modèles en un seul modèle. Lorsqu’il est utilisé pour la reconnaissance de formulaires personnalisés, le nouveau modèle composé effectue d’abord une classification des documents d’entrée pour déterminer lequel de ses sous-modèles est le plus approprié.
beginCopyModelTo Démarre une opération de copie d’un modèle personnalisé d’une ressource à une autre (voire à la même ressource). Il nécessite un CopyAuthorization à partir de la ressource cible, qui peut être généré à l’aide de la getCopyAuthorization méthode.
getResourceDetails Récupère des informations sur les limites de la ressource, telles que le nombre de modèles personnalisés et le nombre maximal de modèles que la ressource peut prendre en charge.
getDocumentModel, listDocumentModelset deleteDocumentModel activez la gestion des modèles dans la ressource.
getOperation et listOperations permettent de visualiser l’état des opérations de création de modèle, même celles qui sont en cours ou qui ont échoué. Les opérations sont maintenues pendant 24 heures.

Veuillez noter que les modèles peuvent également être créés à l’aide de l’interface utilisateur graphique du service Document Intelligence : Document Intelligence Studio.

Des exemples d’extraits de code illustrant l’utilisation de DocumentModelAdministrationClient pour construire un modèle se trouvent ci-dessous, dans la section « Construire un modèle ».

Opérations de longue durée

Les opérations de longue durée (LRO) sont des opérations qui consistent en une demande initiale envoyée au service pour démarrer une opération, suivie d’une interrogation pour un résultat à un certain intervalle afin de déterminer si l’opération s’est terminée et si elle a échoué ou réussi. En fin de compte, le LRO échouera à cause d’une erreur ou produira un résultat.

Dans Azure AI Document Intelligence, les opérations qui créent des modèles (y compris la copie et la composition de modèles) ainsi que les opérations d’analyse/extraction de données sont des LRO. Les clients SDK fournissent des méthodes asynchrones begin<operation-name> qui renvoient Promise<PollerLike> des objets. L’objet PollerLike représente l’opération, qui s’exécute de manière asynchrone sur l’infrastructure du service, et un programme peut attendre la fin de l’opération en appelant et en attendant la pollUntilDone méthode sur l’analyseur renvoyé par la begin<operation-name> méthode. Des exemples d’extraits de code sont fournis pour illustrer l’utilisation d’opérations de longue durée dans la section suivante.

Exemples

La section suivante fournit plusieurs extraits de code JavaScript illustrant les modèles courants utilisés dans les bibliothèques clientes Document Intelligence.

Analyser un document à l’aide d’un ID de modèle
Utiliser des modèles de documents prédéfinis
Utilisez la « mise en page » prédéfinie
Utiliser le « document » prédéfini
Utilisez le prédéfini « read »
Construire un modèle
Gérer les modèles

Analyser un document à l’aide d’un ID de modèle

La beginAnalyzeDocument méthode permet d’extraire des champs et des données de table à partir de documents. L’analyse peut utiliser soit un modèle personnalisé, formé avec vos propres données, soit un modèle prédéfini fourni par le service (voir Utiliser des modèles prédéfinis ci-dessous). Un modèle personnalisé est adapté à vos propres documents, il ne doit donc être utilisé qu’avec des documents de la même structure que l’un des types de documents du modèle (il peut y en avoir plusieurs, comme dans un modèle composé).

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

Analyser un document à partir d’une URL

Au lieu de fournir un flux lisible, une URL accessible au public peut être fournie à la place à l’aide de la beginAnalyzeDocumentFromUrl méthode. « Accessible au public » signifie que les sources d’URL doivent être accessibles à partir de l’infrastructure du service (en d’autres termes, une URL intranet privée, ou des URL qui utilisent des secrets basés sur un en-tête ou un certificat, ne fonctionneront pas, car le service Document Intelligence doit être en mesure d’accéder à l’URL). Toutefois, l’URL elle-même peut encoder un code secret, tel qu’une URL d’objet blob de stockage Azure qui contient un jeton SAS dans les paramètres de requête.

Utiliser des modèles de documents prédéfinis

La beginAnalyzeDocument méthode prend également en charge l’extraction de champs à partir de certains types de documents courants tels que les reçus, les factures, les cartes de visite, les documents d’identité, etc., à l’aide de modèles prédéfinis fournis par le service Document Intelligence. Les modèles prédéfinis peuvent être fournis soit sous forme de chaînes d’ID de modèle (comme pour les modèles de documents personnalisés, voir la section Autres modèles prédéfinis ci-dessous), soit à l’aide d’un DocumentModel objet. Lorsque vous utilisez un DocumentModel, le Kit de développement logiciel (SDK) Document Intelligence pour JavaScript fournit un type TypeScript beaucoup plus fort pour les documents extraits résultants en fonction du schéma du modèle, et il sera converti pour utiliser les conventions de nommage JavaScript.

Des exemples DocumentModel d’objets pour la version actuelle de l’API de service (2022-08-31) se trouvent dans le prebuilt répertoire samples. Dans l’exemple suivant, nous allons utiliser le PrebuiltReceiptModel à partir du fichier [prebuilt-receipt.ts] dans ce répertoire.

Étant donné que le principal avantage de l’analyse basée sur les est le renforcement des DocumentModelcontraintes de type TypeScript, l’exemple suivant est écrit en TypeScript à l’aide de la syntaxe du module ECMAScript :

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

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

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

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

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

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

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

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

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

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

Alternativement, comme mentionné ci-dessus, au lieu d’utiliser PrebuiltReceiptModel, qui produit le type de retour le plus fort, l’ID de modèle de l’accusé de réception prédéfini (« prebuilt-receipt ») peut être utilisé, mais les champs du document ne seront pas fortement typés en TypeScript, et les noms de champs seront généralement en « PascalCase » au lieu de « camelCase ».

Autres modèles préconstruits

Vous n’êtes pas limité aux reçus ! Vous avez le choix entre quelques modèles préconstruits, et d’autres sont en route. Chaque modèle prédéfini possède son propre ensemble de champs pris en charge :

Reçus, à l’aide PrebuiltReceiptModel (comme ci-dessus) ou de l’ID "prebuilt-receipt"de modèle de reçu prédéfini.
Cartes de visite, à l’aide de l’identifiant PrebuiltBusinessCardModel"prebuilt-businessCard"de son modèle.
Factures, à l’aide de PrebuiltInvoiceModel ou de son ID "prebuilt-invoice"de modèle .
Documents d’identité (tels que les permis de conduire et les passeports), à l’aide de leur numéro d’identification PrebuiltIdDocumentModel"prebuilt-idDocument".
W2 Tax Forms (États-Unis), à l’aide de son numéro d’identification PrebuiltTaxUsW2Model"prebuilt-tax.us.w2"ou de son modèle.
Cartes d’assurance maladie (États-Unis), à l’aide de [PrebuiltHealthInsuranceCardUsModel][samples-prebuilt-healthinsurancecard.us] ou de son numéro de "prebuilt-healthInsuranceCard.us"modèle.

Chacun des modèles prédéfinis ci-dessus produit documents (des instances extraites du schéma de champ du modèle). Il existe également trois modèles prédéfinis qui n’ont pas de schémas de champ et ne produisent donc pas de documents. Elles sont les suivantes :

Le modèle de mise en page prédéfini (voir Utiliser la « mise en page prédéfinie » ci-dessous), qui extrait des informations sur les éléments de mise en page de base (OCR) tels que les pages et les tableaux.
Le modèle de document général prédéfini (voir Utiliser le « document » prédéfini ci-dessous), qui ajoute des paires clé-valeur (associations dirigées entre les éléments de page, tels que les éléments étiquetés) aux informations produites par le modèle de mise en page.
Le modèle Read prédéfini (voir Utiliser le prédéfini « read » ci-dessous), qui extrait uniquement les éléments textuels, tels que les mots et les lignes de page, ainsi que des informations sur la langue du document.

Pour plus d’informations sur les champs de tous ces modèles, consultez la documentation du service sur les modèles prédéfinis disponibles.

Les champs de tous les modèles prédéfinis sont également accessibles par programmation à l’aide de la getDocumentModel méthode (par leurs ID de modèle) et de l’inspection docTypes du DocumentModelAdministrationClient champ dans le résultat.

Utilisez la « mise en page » prédéfinie

Le "prebuilt-layout" modèle extrait uniquement les éléments de base du document, tels que les pages (qui se composent de mots/lignes de texte et de marques de sélection), les tableaux et les styles de texte visuels, ainsi que leurs régions et étendues englobantes dans le contenu textuel des documents d’entrée. Nous fournissons une instance fortement typée DocumentModel nommée PrebuiltLayoutModel qui appelle ce modèle ou, comme toujours, son ID "prebuilt-layout" de modèle peut être utilisé directement.

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

Utiliser le « document » prédéfini

Le "prebuilt-document" modèle extrait des informations sur les paires clé-valeur (associations dirigées entre les éléments de page, tels que les champs étiquetés) en plus des propriétés produites par la méthode d’extraction de la mise en page. Ce modèle de document prédéfini (général) offre des fonctionnalités similaires aux modèles personnalisés entraînés sans informations d’étiquette dans les itérations précédentes du service Document Intelligence, mais il est désormais fourni en tant que modèle prédéfini qui fonctionne avec une grande variété de documents. Nous fournissons une instance fortement typée DocumentModel nommée PrebuiltDocumentModel qui appelle ce modèle ou, comme toujours, son ID "prebuilt-document" de modèle peut être utilisé directement.

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

Utilisez le prédéfini « read »

Le "prebuilt-read" modèle extrait des informations textuelles dans un document, telles que des mots et des paragraphes, et analyse la langue et le style d’écriture (par exemple, écrit à la main ou typé) de ce texte. Nous fournissons une instance fortement typée DocumentModel nommée PrebuiltReadModel qui appelle ce modèle ou, comme toujours, son ID "prebuilt-read" de modèle peut être utilisé directement.

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

Classifier un document

Le service Document Intelligence prend en charge les classificateurs de documents personnalisés qui peuvent classer les documents dans un ensemble de catégories prédéfinies en fonction d’un ensemble de données d’entraînement. Les documents peuvent être classifiés à l’aide d’un classificateur personnalisé à l’aide de la beginClassifyDocument méthode .DocumentAnalysisClient Comme beginAnalyzeDocument ci-dessus, cette méthode accepte un fichier ou un flux contenant le document à classer, et elle a une beginClassifyDocumentFromUrl contrepartie qui accepte une URL accessible au public vers un document à la place.

L’exemple suivant montre comment classifier un document à l’aide d’un classificateur personnalisé :

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

Pour plus d’informations sur l’entraînement d’un classifieur personnalisé, consultez la section sur l’entraînement du classificateur à la fin de la section suivante.

Créer un modèle

Le SDK prend également en charge la création de modèles à l’aide de la DocumentModelAdministrationClient classe. La création d’un modèle à partir de données d’entraînement étiquetées crée un nouveau modèle qui est entraîné sur vos propres documents, et le modèle résultant sera capable de reconnaître des valeurs à partir des structures de ces documents. L’opération de création de modèle accepte une URL encodée en SAS vers un conteneur d’objets blob de stockage Azure qui contient les documents d’entraînement. L’infrastructure du service Document Intelligence lira les fichiers du conteneur et créera un modèle basé sur leur contenu. Pour plus d’informations sur la création et la structure d’un conteneur de données d’entraînement, consultez la documentation du service Document Intelligence pour la création d’un modèle.

Bien que nous fournissions ces méthodes pour la création de modèles programmatiques, l’équipe du service Document Intelligence a créé une application Web interactive, Document Intelligence Studio, qui permet de créer et de gérer des modèles sur le Web.

Par exemple, le programme suivant crée un modèle de document personnalisé à l’aide d’une URL encodée en SAS vers un conteneur de stockage Azure préexistant :

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

Les classificateurs personnalisés sont construits de la même manière à l’aide de la méthode plutôt que beginBuildDocumentModelde beginBuildDocumentClassifier . Pour plus d’informations sur la création d’un classifieur personnalisé, consultez l’exemple de classifieur de build , car les données d’entraînement d’entrée sont fournies dans un format légèrement différent. Pour plus d’informations sur la création d’un ensemble de données d’entraînement pour un classifieur personnalisé, consultez la documentation du service Document Intelligence.

Gérer les modèles

DocumentModelAdministrationClient Fournit également plusieurs méthodes pour accéder aux modèles et les répertorier. L’exemple suivant montre comment parcourir les modèles d’une ressource (cela inclut à la fois les modèles personnalisés dans la ressource et les modèles prédéfinis communs à toutes les ressources), obtenir un modèle par ID et supprimer un modèle.

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

Des méthodes listDocumentClassifiers similaires sont getDocumentClassifier disponibles pour répertorier et obtenir des informations sur les classifieurs personnalisés en plus de deleteDocumentClassifier la suppression des classificateurs personnalisés.

Résolution des problèmes

Pour obtenir de l’aide sur la résolution des problèmes, consultez le guide de résolution des problèmes .

Exploitation forestière

L’activation de la journalisation peut vous aider à découvrir des informations utiles sur les échecs. Pour afficher un journal des requêtes et réponses HTTP, définissez la variable AZURE_LOG_LEVELd’environnement info sur . Vous pouvez également activer la journalisation au moment de l’exécution setLogLevelen appelant @azure/logger :

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

setLogLevel("info");

Pour obtenir des instructions plus détaillées sur l’activation des journaux, vous pouvez consulter la documentation du package @azure/enregistreur d’événements.

Étapes suivantes

Jetez un coup d’œil au répertoire des exemples pour obtenir des exemples de code détaillés qui montrent comment utiliser cette bibliothèque, y compris plusieurs fonctionnalités et méthodes qui ne sont pas présentées dans la section « Exemples » ci-dessus, telles que la copie et la composition de modèles, la liste des opérations de gestion des modèles et la suppression de modèles.

Contribuer

Si vous souhaitez contribuer à cette bibliothèque, lisez le guide de contribution pour en savoir plus sur la génération et le test du code.

Rétroaction

Cette page vous a-t-elle été utile ?

Last updated on 2025-05-13