DocumentModelAdministrationClient class

Créer un instance DocumentModelAdministrationClient à partir d’un point de terminaison de ressource et d’une clé API statique (KeyCredential),

Exemple :

import { DocumentModelAdministrationClient, AzureKeyCredential } from "@azure/ai-form-recognizer";

const endpoint = "https://<resource name>.cognitiveservices.azure.com";
const credential = new AzureKeyCredential("<api key>");

const client = new DocumentModelAdministrationClient(endpoint, credential);

new DocumentModelAdministrationClient(endpoint: string, credential: KeyCredential, options?: DocumentModelAdministrationClientOptions)

Paramètres

Créez un instance DocumentModelAdministrationClient à partir d’un point de terminaison de ressource et d’une identité TokenCredentialAzure.

Pour plus d’informations sur l’authentification auprès d’Azure Active Directory, consultez le @azure/identity package.

Exemple :

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

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

const client = new DocumentModelAdministrationClient(endpoint, credential);

new DocumentModelAdministrationClient(endpoint: string, credential: TokenCredential, options?: DocumentModelAdministrationClientOptions)

Paramètres

Créez un classifieur de documents avec l’ID de classifieur et les types de documents donnés.

L’ID de classifieur doit être unique parmi les classifieurs au sein de la ressource.

Les types de document sont donnés sous la forme d’un objet qui mappe le nom du type de document au jeu de données d’apprentissage pour ce type de document. Deux méthodes d’entrée de données d’apprentissage sont prises en charge :

• azureBlobSource, qui forme un classifieur à l’aide des données du conteneur Stockage Blob Azure donné.
• azureBlobFileListSource, qui est similaire à azureBlobSource mais permet un contrôle plus précis sur les fichiers inclus dans le jeu de données d’apprentissage à l’aide d’une liste de fichiers au format JSONL.

Le service Form Recognizer lit le jeu de données d’entraînement à partir d’un conteneur Stockage Azure, donné en tant qu’URL vers le conteneur avec un jeton SAP qui permet au back-end de service de communiquer avec le conteneur. Au minimum, les autorisations « read » et « list » sont requises. En outre, les données du conteneur donné doivent être organisées selon une convention particulière, qui est documentée dans la documentation du service pour la création de classifieurs de documents personnalisés.

Exemple

const classifierId = "aNewClassifier";
const containerUrl1 = "<training data container SAS URL 1>";
const containerUrl2 = "<training data container SAS URL 2>";

const poller = await client.beginBuildDocumentClassifier(
  classifierId,
  {
    // The document types. Each entry in this object should map a document type name to a
    // `ClassifierDocumentTypeDetails` object
    "formX": {
      azureBlobSource: {
        containerUrl: containerUrl1,
      }
    },
    "formY": {
      azureBlobFileListSource: {
        containerUrl: containerUrl2,
        fileList: "path/to/fileList.jsonl"
      }
    },
  },
  {
    // Optionally, a text description may be attached to the classifier
    description: "This is an example classifier!"
  }
);

// Classifier building, like model creation operations, returns a poller that eventually produces a
// DocumentClassifierDetails object
const classifierDetails = await poller.pollUntilDone();

const {
  classifierId, // identical to the classifierId given when creating the classifier
  description, // identical to the description given when creating the classifier (if any)
  createdOn, // the Date (timestamp) that the classifier was created
  docTypes // information about the document types in the classifier and their details
} = classifierDetails;

function beginBuildDocumentClassifier(classifierId: string, docTypeSources: DocumentClassifierDocumentTypeSources, options?: BeginBuildDocumentClassifierOptions): Promise<DocumentClassifierPoller>

Paramètres

Retours

une opération de longue durée (pollueur) qui produira éventuellement les détails du classifieur créé ou une erreur

Créez un nouveau modèle avec un ID donné à partir d’une source de contenu de modèle.

L’ID de modèle peut se composer de n’importe quel texte, tant qu’il ne commence pas par « prédéfini - » (car ces modèles font référence aux modèles prédéfinis Form Recognizer communs à toutes les ressources) et tant qu’il n’existe pas déjà dans la ressource.

La source de contenu décrit le mécanisme que le service utilisera pour lire les données d’entraînement d’entrée. Pour plus d’informations, consultez le <xref:DocumentModelContentSource> type.

Exemple

const modelId = "aNewModel";

const poller = await client.beginBuildDocumentModel(modelId, { containerUrl: "<SAS-encoded blob container URL>" }, {
  // Optionally, a text description may be attached to the model
  description: "This is an example model!"
});

// Model building, like all other model creation operations, returns a poller that eventually produces a ModelDetails
// object
const modelDetails = await poller.pollUntilDone();

const {
  modelId, // identical to the modelId given when creating the model
  description, // identical to the description given when creating the model
  createdOn, // the Date (timestamp) that the model was created
  docTypes // information about the document types in the model and their field schemas
} = modelDetails;

function beginBuildDocumentModel(modelId: string, contentSource: DocumentModelSource, buildMode: DocumentModelBuildMode, options?: BeginBuildDocumentModelOptions): Promise<DocumentModelPoller>

Paramètres

Retours

une opération de longue durée (pollueur) qui produira éventuellement les informations du modèle créé ou une erreur

Créez un nouveau modèle avec un ID donné à partir d’un ensemble de documents d’entrée et de champs étiquetés.

L’ID de modèle peut se composer de n’importe quel texte, tant qu’il ne commence pas par « prédéfini - » (car ces modèles font référence aux modèles prédéfinis Form Recognizer communs à toutes les ressources) et tant qu’il n’existe pas déjà dans la ressource.

Le service Form Recognizer lit le jeu de données d’entraînement à partir d’un conteneur Stockage Azure, donné en tant qu’URL vers le conteneur avec un jeton SAP qui permet au back-end de service de communiquer avec le conteneur. Au minimum, les autorisations « read » et « list » sont requises. En outre, les données du conteneur donné doivent être organisées selon une convention particulière, qui est documentée dans la documentation du service pour la création de modèles personnalisés.

Exemple

const modelId = "aNewModel";
const containerUrl = "<training data container SAS URL>";

const poller = await client.beginBuildDocumentModel(modelId, containerUrl, {
  // Optionally, a text description may be attached to the model
  description: "This is an example model!"
});

// Model building, like all other model creation operations, returns a poller that eventually produces a ModelDetails
// object
const modelDetails = await poller.pollUntilDone();

const {
  modelId, // identical to the modelId given when creating the model
  description, // identical to the description given when creating the model
  createdOn, // the Date (timestamp) that the model was created
  docTypes // information about the document types in the model and their field schemas
} = modelDetails;

function beginBuildDocumentModel(modelId: string, containerUrl: string, buildMode: DocumentModelBuildMode, options?: BeginBuildDocumentModelOptions): Promise<DocumentModelPoller>

Paramètres

Retours

une opération de longue durée (pollueur) qui finira par produire les informations de modèle créées ou une erreur

Crée un modèle composé unique à partir de plusieurs sous-modèles préexistants.

Le modèle composé résultant combine les types de documents de ses modèles de composants et insère une étape de classification dans le pipeline d’extraction pour déterminer lequel de ses sous-modèles de composant est le plus approprié pour l’entrée donnée.

Exemple

const modelId = "aNewComposedModel";
const subModelIds = [
  "documentType1Model",
  "documentType2Model",
  "documentType3Model"
];

// The resulting composed model can classify and extract data from documents
// conforming to any of the above document types
const poller = await client.beginComposeDocumentModel(modelId, subModelIds, {
  description: "This is a composed model that can handle several document types."
});

// Model composition, like all other model creation operations, returns a poller that eventually produces a
// ModelDetails object
const modelDetails = await poller.pollUntilDone();

const {
  modelId, // identical to the modelId given when creating the model
  description, // identical to the description given when creating the model
  createdOn, // the Date (timestamp) that the model was created
  docTypes // information about the document types of the composed submodels
} = modelDetails;

function beginComposeDocumentModel(modelId: string, componentModelIds: Iterable<string>, options?: BeginComposeDocumentModelOptions): Promise<DocumentModelPoller>

Paramètres

Retours

une opération de longue durée (pollueur) qui finira par produire les informations de modèle créées ou une erreur

Copie un modèle avec l’ID donné dans la ressource et l’ID de modèle encodés par une autorisation de copie donnée.

Consultez CopyAuthorization et getCopyAuthorization.

Exemple

// We need a client for the source model's resource
const sourceEndpoint = "https://<source resource name>.cognitiveservices.azure.com";
const sourceCredential = new AzureKeyCredential("<source api key>");
const sourceClient = new DocumentModelAdministrationClient(sourceEndpoint, sourceCredential);

// We create the copy authorization using a client authenticated with the destination resource. Note that these two
// resources can be the same (you can copy a model to a new ID in the same resource).
const copyAuthorization = await client.getCopyAuthorization("<destination model ID>");

// Finally, use the _source_ client to copy the model and await the copy operation
const poller = await sourceClient.beginCopyModelTo("<source model ID>");

// Model copying, like all other model creation operations, returns a poller that eventually produces a ModelDetails
// object
const modelDetails = await poller.pollUntilDone();

const {
  modelId, // identical to the modelId given when creating the copy authorization
  description, // identical to the description given when creating the copy authorization
  createdOn, // the Date (timestamp) that the model was created
  docTypes // information about the document types of the model (identical to the original, source model)
} = modelDetails;

function beginCopyModelTo(sourceModelId: string, authorization: CopyAuthorization, options?: BeginCopyModelOptions): Promise<DocumentModelPoller>

Paramètres

Retours

une opération de longue durée (pollueur) qui finira par produire les informations de modèle copiées ou une erreur

Supprime un classifieur avec l’ID donné de la ressource du client, s’il existe. Cette opération NE PEUT PAS être annulée.

Exemple

await client.deleteDocumentClassifier("<classifier ID to delete>"));

function deleteDocumentClassifier(classifierId: string, options?: OperationOptions): Promise<void>

Paramètres

Retours

Supprime un modèle avec l’ID donné de la ressource du client, s’il existe. Cette opération NE PEUT PAS être annulée.

Exemple

await client.deleteDocumentModel("<model ID to delete>"));

function deleteDocumentModel(modelId: string, options?: DeleteDocumentModelOptions): Promise<void>

Paramètres

Retours

Crée une autorisation pour copier un modèle dans la ressource, utilisée avec la beginCopyModelTo méthode .

Le CopyAuthorization accorde à une autre ressource de service cognitif le droit de créer un modèle dans la ressource de ce client avec l’ID de modèle et la description facultative qui sont encodées dans l’autorisation.

Exemple

// The copyAuthorization data structure stored below grants any cognitive services resource the right to copy a
// model into the client's resource with the given destination model ID.
const copyAuthorization = await client.getCopyAuthorization("<destination model ID>");

function getCopyAuthorization(destinationModelId: string, options?: GetCopyAuthorizationOptions): Promise<CopyAuthorization>

Paramètres

Retours

une autorisation de copie qui encode le modelId donné et la description facultative

Récupère des informations sur un classifieur (DocumentClassifierDetails) par ID.

Exemple

const classifierId = "<classifier ID";

const {
  classifierId, // identical to the ID given when calling `getDocumentClassifier`
  description, // a textual description of the classifier, if provided during classifier creation
  createdOn, // the Date (timestamp) that the classifier was created
  // information about the document types in the classifier and their corresponding traning data
  docTypes
} = await client.getDocumentClassifier(classifierId);

// The `docTypes` property is a map of document type names to information about the training data
// for that document type.
for (const [docTypeName, classifierDocTypeDetails] of Object.entries(docTypes)) {
 console.log(`- '${docTypeName}': `, classifierDocTypeDetails);
}

function getDocumentClassifier(classifierId: string, options?: OperationOptions): Promise<DocumentClassifierDetails>

Paramètres

Retours

informations sur le classifieur avec l’ID donné

Récupère des informations sur un modèle (DocumentModelDetails) par ID.

Cette méthode peut récupérer des informations sur les modèles personnalisés et prédéfinis.

Changement cassant

Dans les versions précédentes de l’API REST et du Kit de développement logiciel (SDK) Form Recognizer, la getModel méthode pouvait retourner n’importe quel modèle, même un modèle qui n’a pas pu être créé en raison d’erreurs. Dans les nouvelles versions de service, getDocumentModel et listDocumentModelsne produisent que des modèles créés correctement (c’est-à-dire des modèles qui sont « prêts » à être utilisés). Les modèles ayant échoué sont désormais récupérés via les API « opérations ». Consultez getOperation et listOperations.

Exemple

// The ID of the prebuilt business card model
const modelId = "prebuilt-businessCard";

const {
  modelId, // identical to the modelId given when calling `getDocumentModel`
  description, // a textual description of the model, if provided during model creation
  createdOn, // the Date (timestamp) that the model was created
  // information about the document types in the model and their field schemas
  docTypes: {
    // the document type of the prebuilt business card model
    "prebuilt:businesscard": {
      // an optional, textual description of this document type
      description,
      // the schema of the fields in this document type, see the FieldSchema type
      fieldSchema,
      // the service's confidences in the fields (an object with field names as properties and numeric confidence
      // values)
      fieldConfidence
    }
  }
} = await client.getDocumentModel(modelId);

function getDocumentModel(modelId: string, options?: GetModelOptions): Promise<DocumentModelDetails>

Paramètres

Retours

informations sur le modèle avec l’ID donné

Récupère des informations sur une opération (OperationDetails) par son ID.

Les opérations représentent des tâches non d’analyse, telles que la création, la composition ou la copie d’un modèle.

function getOperation(operationId: string, options?: GetOperationOptions): Promise<OperationDetails>

Paramètres

Retours

informations sur l’opération avec l’ID donné

Exemple

// The ID of the operation, which should be a GUID
const operationId = "<operation GUID>";

const {
  operationId, // identical to the operationId given when calling `getOperation`
  kind, // the operation kind, one of "documentModelBuild", "documentModelCompose", or "documentModelCopyTo"
  status, // the status of the operation, one of "notStarted", "running", "failed", "succeeded", or "canceled"
  percentCompleted, // a number between 0 and 100 representing the progress of the operation
  createdOn, // a Date object that reflects the time when the operation was started
  lastUpdatedOn, // a Date object that reflects the time when the operation state was last modified
} = await client.getOperation(operationId);

Récupérez les informations de base sur la ressource de ce client.

Exemple

const {
  // Information about the custom models in the current resource
  customDocumentModelDetails: {
    // The number of custom models in the current resource
    count,
    // The maximum number of models that the current resource can support
    limit
  }
} = await client.getResourceDetails();

function getResourceDetails(options?: GetResourceDetailsOptions): Promise<ResourceDetails>

Paramètres

Retours

informations de base sur la ressource de ce client

Répertoriez les détails des classifieurs dans la ressource. Cette opération prend en charge la pagination.

Exemples

Itération asynchrone

for await (const details of client.listDocumentClassifiers()) {
  const {
    classifierId, // The classifier's unique ID
    description, // a textual description of the classifier, if provided during creation
    docTypes, // information about the document types in the classifier and their corresponding traning data
  } = details;
}

Par page

// The listDocumentClassifiers method is paged, and you can iterate by page using the `byPage` method.
const pages = client.listDocumentClassifiers().byPage();

for await (const page of pages) {
  // Each page is an array of classifiers and can be iterated synchronously
  for (const details of page) {
    const {
      classifierId, // The classifier's unique ID
      description, // a textual description of the classifier, if provided during creation
      docTypes, // information about the document types in the classifier and their corresponding traning data
    } = details;
  }
}

function listDocumentClassifiers(options?: ListModelsOptions): PagedAsyncIterableIterator<DocumentClassifierDetails, DocumentClassifierDetails[], PageSettings>

Paramètres

Retours

itérable asynchrone des détails du classifieur qui prend en charge la pagination

Répertorier les résumés des modèles dans la ressource. Des modèles personnalisés et prédéfinis seront inclus. Cette opération prend en charge la pagination.

Le résumé du modèle (DocumentModelSummary) inclut uniquement les informations de base sur le modèle, et n’inclut pas d’informations sur les types de documents dans le modèle (telles que les schémas de champ et les valeurs de confiance).

Pour accéder à toutes les informations sur le modèle, utilisez getDocumentModel.

Changement cassant

Dans les versions précédentes de l’API REST et du Kit de développement logiciel (SDK) Form Recognizer, la listModels méthode renvoyait tous les modèles, même ceux qui n’avaient pas pu être créés en raison d’erreurs. Dans les nouvelles versions de service, listDocumentModels et getDocumentModelne produisent que des modèles créés correctement (c’est-à-dire des modèles qui sont « prêts » à être utilisés). Les modèles ayant échoué sont désormais récupérés via les API « opérations ». Consultez getOperation et listOperations.

Exemples

Itération asynchrone

for await (const summary of client.listDocumentModels()) {
  const {
    modelId, // The model's unique ID
    description, // a textual description of the model, if provided during model creation
  } = summary;

  // You can get the full model info using `getDocumentModel`
  const model = await client.getDocumentModel(modelId);
}

Par page

// The listDocumentModels method is paged, and you can iterate by page using the `byPage` method.
const pages = client.listDocumentModels().byPage();

for await (const page of pages) {
  // Each page is an array of models and can be iterated synchronously
  for (const model of page) {
    const {
      modelId, // The model's unique ID
      description, // a textual description of the model, if provided during model creation
    } = summary;

    // You can get the full model info using `getDocumentModel`
    const model = await client.getDocumentModel(modelId);
  }
}

function listDocumentModels(options?: ListModelsOptions): PagedAsyncIterableIterator<DocumentModelSummary, DocumentModelSummary[], PageSettings>

Paramètres

Retours

itérable asynchrone des résumés de modèle qui prend en charge la pagination

Répertorier les opérations de création de modèle dans la ressource. Cela génère toutes les opérations, y compris les opérations qui n’ont pas réussi à créer des modèles. Cette opération prend en charge la pagination.

Exemples

Itération asynchrone

for await (const operation of client.listOperations()) {
  const {
    operationId, // the operation's GUID
    status, // the operation status, one of "notStarted", "running", "succeeded", "failed", or "canceled"
    percentCompleted // the progress of the operation, from 0 to 100
  } = operation;
}

Par page

// The listOperations method is paged, and you can iterate by page using the `byPage` method.
const pages = client.listOperations().byPage();

for await (const page of pages) {
  // Each page is an array of operation info objects and can be iterated synchronously
  for (const operation of page) {
    const {
      operationId, // the operation's GUID
      status, // the operation status, one of "notStarted", "running", "succeeded", "failed", or "canceled"
      percentCompleted // the progress of the operation, from 0 to 100
    } = operation;
  }
}

function listOperations(options?: ListOperationsOptions): PagedAsyncIterableIterator<OperationSummary, OperationSummary[], PageSettings>

Paramètres

Retours

itérable asynchrone des objets d’informations d’opération qui prend en charge la pagination