Gérer les versions du processeur

De nouvelles versions sont publiées pour diverses raisons, par exemple pour améliorer la précision, augmenter la disponibilité et prendre en charge de nouveaux éléments de document, tels que les marques de sélection.

Étant donné que Document AI est optimisé par l'IA générative, les futures versions utiliseront de nouveaux modèles de fondation pour vous permettre de bénéficier des améliorations de l'IA générative.

À mesure que nous améliorons les modèles de fondation, les modèles de fondation précédents sont abandonnés. De même, les versions de processeur sont obsolètes six mois après la sortie de nouvelles versions.

Un processeur peut avoir l'une des versions suivantes :

• Version stable
• Version candidate
• Version personnalisée et sa version de base associée

Cette page explique comment les versions des processeurs sont gérées, et comment afficher et sélectionner une version spécifique.

Présentation des versions du processeur

Il existe deux catégories de versions de processeur :

• Les versions Google sont soit stables (pour les cas d'utilisation en production), soit des versions candidates (expérimentales avec les dernières fonctionnalités).
• Les versions utilisateur sont créées par vous pour personnaliser les prédictions pour vos documents. Elles comportent des ID de version alphanumériques.

Versions Google

Chaque version Google est identifiée par un ID de version, par exemple pretrained-TYPE-vX.X-YYYY-MM-DD. Chaque version de processeur proposée par Google est nommée Google Stable ou Google Release Candidate (RC).

Versions stables de Google

Les versions stables sont de qualité production et prêtes à être utilisées.

• Google donne la priorité à la stabilité du comportement du processeur, mais inclut toujours les correctifs essentiels.
• Les versions stables antérieures de Google sont obsolètes six mois après la sortie de la version stable la plus récente, comme illustré dans la figure suivante.

Versions candidates de Google

Les versions candidates sont expérimentales et sont mises à niveau régulièrement pour intégrer les dernières fonctionnalités. Il ne s'agit pas de versions de qualité production, et leur stabilité peut varier.

Versions personnalisées

Les versions personnalisées sont les versions de processeur que vous pouvez créer à partir de vos documents pour personnaliser les prédictions. Les versions personnalisées comportent un Type qui indique le type de modèle utilisé pour les prédictions. Si vous créez une version à l'aide d'un modèle de fondation (en créant une version ou en l'affinant), le type est IA générative. Si vous créez une version de processeur en entraînant un modèle personnalisé plus petit (basé sur un modèle ou un modèle), le type est Personnalisé. Si vous créez des versions de processeur, vous choisissez le nom et l'ID.

Versions de base

Si vous créez une version de processeur, la "version de base" indique la version Google qui alimente votre version utilisateur personnalisée. La version de base détermine le cycle de vie de votre version utilisateur. Vous devez décider comment gérer le cycle de vie de votre version utilisateur personnalisée.

Versions de processeur stables disponibles

Vous pouvez consulter les versions de processeur stable disponibles pour les différents types de processeurs dans les tableaux suivants.

Cycle de vie des versions du processeur

Dès qu'une nouvelle version de Google est disponible, vous devez créer et évaluer de nouvelles versions utilisateur avec la nouvelle version de base. Déployez ensuite votre nouvelle version et annulez le déploiement (ou supprimez) les versions utilisateur antérieures qui utilisent la version stable précédente comme base. Les versions stables sont abandonnées après la sortie d'une nouvelle version. Google vous en avertit au moins six mois à l'avance.

Que se passe-t-il lorsqu'une version de base est obsolète ?

Les versions utilisateur qui dépendent de versions de base antérieures cessent de renvoyer des prédictions lorsque la version de base est obsolète.

Comment les versions de l'outil de traitement sont-elles sélectionnées pour vos demandes ?

Lorsque vous appelez un point de terminaison de processeur sans spécifier la version du processeur, la version par défaut du processeur est utilisée. Lorsque la version du processeur par défaut change, vous devrez peut-être mettre à jour le code.

Exemple d'abandon d'une version personnalisée

Prenons l'exemple suivant, qui décrit la séquence d'événements lors de l'abandon d'une version personnalisée :

1. En tant que développeur, vous utilisez un extracteur personnalisé pour obtenir des données à partir de documents. Compte tenu de la complexité et du volume de documents que vous traitez, vous affinez le modèle de fondation pour créer une version nommée fine-tune-A. Vous définissez la version fine-tune-A comme version par défaut de votre processeur et l'utilisez pour traiter les documents. La version de base qui alimente le modèle fine-tune-A est la version stable pretrained-foundation-model-v1.0-2023-08-22 (v1.0).

2. Google a publié une nouvelle version stable nommée pretrained-foundation-model-v1.2-2024-05-10 (v1.2) et a annoncé que la version stable v1.0 sera obsolète le 9 avril 2025.

3. Comme vous avez conservé vos documents d'entraînement et de test dans l'ensemble de données de votre processeur, vous affinez une autre version basée sur la dernière version stable de Google, v1.2, et vous la nommez fine-tune-B. Après avoir évalué ses performances, vous définissez la version fine-tune-B comme nouvelle version par défaut de votre processeur et mettez hors service la version fine-tune-A. Votre nouvelle version utilise désormais la dernière version stable de Google compatible.

En revanche, si vous n'aviez pas créé ni évalué la version personnalisée de fine-tune-B, Google aurait mis à jour la version par défaut de votre processeur vers v1.2 le 9 avril 2025. Étant donné que vous appelez le point de terminaison du processeur et que vous ne spécifiez pas de version de processeur, la nouvelle version v1.2 est utilisée comme nouvelle version par défaut pour traiter vos requêtes.

Ressources d'abandon et de migration

Pour les analyseurs et processeurs obsolètes, vous pouvez consulter la page Obsolescences de Document AI.

Consultez les ressources suivantes sur les migrations :

• Pour créer et entraîner un analyseur de notes de frais, vous pouvez vous reporter au processeur préentraîné uptrain.

• Pour créer et ajuster un processeur d'extraction personnalisé, consultez Extracteur personnalisé avec l'IA générative.

Sélectionner une version de processeur

Il existe trois façons de spécifier la version du processeur à utiliser pour le traitement en ligne et par lot :

• Si vous ne spécifiez pas de version, celle par défaut du processeur est utilisée.

  • Exemple : projects/my-proj/locations/us/processors/my-processor:process

• Si vous spécifiez une version, c'est cette version qui est utilisée. Si la version spécifique n'existe pas, la requête échoue et une erreur est générée.

  • Exemple : projects/my-proj/locations/us/processors/my-processor/processorVersions/pretrained-invoice-v1.2-2022-02-18:process

• Si vous spécifiez un canal, la dernière version de ce canal est utilisée. (Options : stable, rc)

  • Exemple : projects/my-proj/locations/us/processors/my-processor/processorVersions/stable:process

Afficher la version disponible

GET https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions

curl -X GET \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     "https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions"

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method GET `
    -Headers $headers `
    -Uri "https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions" | Select-Object -Expand Content

{
  "processorVersions": [
    {
      "name": "projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/pretrained-ocr-v1.1-2022-09-12",
      "displayName": "Google Release Candidate",
      "state": "DEPLOYED",
      "createTime": "2022-09-13T23:39:12.156648Z",
      "googleManaged": true
    },
    {
      "name": "projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/pretrained-ocr-v1.0-2020-09-23",
      "displayName": "Google Stable",
      "state": "DEPLOYED",
      "createTime": "2022-09-12T23:35:09.829557Z",
      "googleManaged": true,
      "deprecationInfo": {
        "deprecationTime": "1970-01-01T00:00:00Z"
      }
    }
  ]
}

using Google.Api.Gax;
using Google.Cloud.DocumentAI.V1;
using System;

public sealed partial class GeneratedDocumentProcessorServiceClientSnippets
{
    /// <summary>Snippet for ListProcessorVersions</summary>
    /// <remarks>
    /// This snippet has been automatically generated and should be regarded as a code template only.
    /// It will require modifications to work:
    /// - It may require correct/in-range values for request initialization.
    /// - It may require specifying regional endpoints when creating the service client as shown in
    ///   https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint.
    /// </remarks>
    public void ListProcessorVersionsRequestObject()
    {
        // Create client
        DocumentProcessorServiceClient documentProcessorServiceClient = DocumentProcessorServiceClient.Create();
        // Initialize request argument(s)
        ListProcessorVersionsRequest request = new ListProcessorVersionsRequest
        {
            ParentAsProcessorName = ProcessorName.FromProjectLocationProcessor("[PROJECT]", "[LOCATION]", "[PROCESSOR]"),
        };
        // Make the request
        PagedEnumerable<ListProcessorVersionsResponse, ProcessorVersion> response = documentProcessorServiceClient.ListProcessorVersions(request);

        // Iterate over all response items, lazily performing RPCs as required
        foreach (ProcessorVersion item in response)
        {
            // Do something with each item
            Console.WriteLine(item);
        }

        // Or iterate over pages (of server-defined size), performing one RPC per page
        foreach (ListProcessorVersionsResponse page in response.AsRawResponses())
        {
            // Do something with each page of items
            Console.WriteLine("A page of results:");
            foreach (ProcessorVersion item in page)
            {
                // Do something with each item
                Console.WriteLine(item);
            }
        }

        // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
        int pageSize = 10;
        Page<ProcessorVersion> singlePage = response.ReadPage(pageSize);
        // Do something with the page of items
        Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
        foreach (ProcessorVersion item in singlePage)
        {
            // Do something with each item
            Console.WriteLine(item);
        }
        // Store the pageToken, for when the next page is required.
        string nextPageToken = singlePage.NextPageToken;
    }
}

//go:build examples

package main

import (
	"context"

	documentai "cloud.google.com/go/documentai/apiv1"
	documentaipb "cloud.google.com/go/documentai/apiv1/documentaipb"
	"google.golang.org/api/iterator"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := documentai.NewDocumentProcessorClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &documentaipb.ListProcessorVersionsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/documentai/apiv1/documentaipb#ListProcessorVersionsRequest.
	}
	it := c.ListProcessorVersions(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(