Prozessorversionen verwalten

Neue Versionen werden aus verschiedenen Gründen veröffentlicht, z. B. um die Genauigkeit zu verbessern, die Verfügbarkeit zu erhöhen und neue Dokumentelemente wie Auswahlmarkierungen zu unterstützen.

Da Document AI auf generativer KI basiert, werden in zukünftigen Versionen neue Foundation Models verwendet, damit Sie von Verbesserungen durch generative KI profitieren können.

Wenn wir Foundation Models verbessern, werden frühere Foundation Models eingestellt. Prozessorversionen werden sechs Monate nach der Veröffentlichung neuer Versionen eingestellt.

Ein Prozessor kann eine der folgenden Versionen haben:

• Stabile Version
• Release-Kandidat (RC)
• Angepasste Version und die zugehörige Basisversion

Auf dieser Seite wird beschrieben, wie Prozessoren versioniert sind und wie Sie eine bestimmte Version aufrufen und auswählen.

Prozessorversionen – Übersicht

Es gibt zwei Kategorien von Prozessorversionen:

• Google-Versionen sind entweder stabil (für Produktionsanwendungsfälle) oder Release-Kandidaten (experimentell mit den neuesten Funktionen).
• Nutzerversionen werden von Ihnen erstellt, um Vorhersagen für Ihre Dokumente anzupassen. Sie haben alphanumerische Versions-IDs.

Google-Versionen

Jede Google-Version wird durch eine Versions-ID identifiziert, z. B. pretrained-TYPE-vX.X-YYYY-MM-DD. Jede von Google angebotene Prozessorversion wird entweder als Google Stable oder Google Release Candidate (RC) bezeichnet.

Stabile Google-Versionen

Stabile Versionen sind produktionsreif und einsatzbereit.

• Google priorisiert die Stabilität des Prozessorverhaltens, wird aber dennoch Patches zur Behebung kritischer Fehler herausbringen.
• Frühere stabile Versionen von Google werden sechs Monate nach der Veröffentlichung der neuesten stabilen Version eingestellt, wie in der folgenden Abbildung dargestellt.

Google-Releasekandidaten (RC)

Releasekandidaten sind experimentell und werden regelmäßig mit den neuesten Funktionen aktualisiert. Dies sind keine produktionsreifen Versionen und ihre Stabilität kann variieren.

Angepasste Versionen

Benutzerdefinierte Versionen sind die Prozessorversionen, die Sie auf Grundlage Ihrer Dokumente erstellen können, um Vorhersagen anzupassen. Benutzerdefinierte Versionen haben ein Type, das den für Vorhersagen verwendeten Modelltyp angibt. Wenn Sie eine Version mit einem Foundation Model erstellen (entweder durch Erstellen einer Version oder durch Feinabstimmung), ist der Typ Generative KI. Wenn Sie eine Prozessorversion erstellen, indem Sie ein kleineres benutzerdefiniertes Modell trainieren (entweder modell- oder vorlagenbasiert), ist der Typ Benutzerdefiniert. Wenn Sie Prozessorversionen erstellen, legen Sie den Namen und die ID fest.

Basisversionen

Wenn Sie eine Prozessorversion erstellen, wird in der „Basisversion“ angegeben, welche Google-Version Ihre benutzerdefinierte Nutzerversion unterstützt. Die Basisversion bestimmt den Lebenszyklus Ihrer Nutzerversion. Sie müssen Entscheidungen darüber treffen, wie Sie den Lebenszyklus Ihrer benutzerdefinierten Nutzerversion verwalten.

Verfügbare stabile Prozessorversionen

In den folgenden Tabellen finden Sie die verfügbaren stabilen Prozessorversionen für die verschiedenen Prozessortypen.

Lebenszyklus der Prozessorversion

Sobald eine neue Google-Version verfügbar ist, sollten Sie neue Nutzerversionen erstellen und auswerten. Stellen Sie dann die neue Version bereit und heben Sie die Bereitstellung früherer Nutzerversionen auf (oder löschen Sie sie), die die vorherige stabile Version als Grundlage verwenden. Stabile Versionen werden eingestellt, sobald eine neue Version veröffentlicht wird. Google informiert Sie in diesem Fall mindestens sechs Monate im Voraus.

Was passiert, wenn eine Basisversion eingestellt wird?

Nutzerversionen, die von früheren Basisversionen abhängen, geben keine Vorhersagen mehr zurück, wenn die Basisversion eingestellt wird.

Wie werden Prozessorversionen für Ihre Anfragen ausgewählt?

Wenn Sie einen Prozessor-Endpunkt aufrufen, ohne die Prozessorversion anzugeben, wird die Standardprozessorversion verwendet. Wenn sich die Standardprozessorversion ändert, müssen Sie möglicherweise den Code aktualisieren.

Beispiel für die Einstellung einer angepassten Version

Im folgenden Szenario wird die Abfolge von Ereignissen bei der Einstellung einer benutzerdefinierten Version beschrieben:

1. Als Entwickler verwenden Sie einen benutzerdefinierten Extraktor, um Daten aus Dokumenten abzurufen. Angesichts der Komplexität und des Umfangs der von Ihnen verarbeiteten Dokumente optimieren Sie das Fundierungsmodell, um eine Version namens fine-tune-A zu erstellen. Sie legen die Version fine-tune-A als Standardversion für Ihren Prozessor fest und verwenden sie zum Verarbeiten von Dokumenten. Die Basisversion, die dem Modell fine-tune-A zugrunde liegt, ist die stabile Version pretrained-foundation-model-v1.0-2023-08-22 (v1.0).

2. Google hat eine neue stabile Version mit dem Namen pretrained-foundation-model-v1.2-2024-05-10 (v1.2) veröffentlicht und angekündigt, dass die stabile Version v1.0 am 9. April 2025 eingestellt wird.

3. Da Sie Ihre Trainings- und Testdokumente im Dataset Ihres Prozessors behalten haben, optimieren Sie eine weitere Version basierend auf der neuesten stabilen Version von Google, v1.2, und nennen sie fine-tune-B. Nachdem Sie die Leistung bewertet haben, legen Sie die Version fine-tune-B als neue Standardversion für Ihren Prozessor fest und stellen die Version fine-tune-A ein. Ihre neue Version verwendet jetzt die neueste unterstützte stabile Google-Version.

Hätten Sie die benutzerdefinierte fine-tune-B-Version nicht erstellt und ausgewertet, hätte Google die Standardversion Ihres Prozessors am 9. April 2025 auf v1.2 aktualisiert. Da Sie den Endpunkt des Prozessors aufrufen und keine Prozessorversion angeben, wird die neue v1.2-Version als neue Standardversion für die Verarbeitung Ihrer Anfragen verwendet.

Ressourcen zur Einstellung und Migration

Informationen zu eingestellten Parsern und Prozessoren finden Sie unter Document AI-Einstellung.

Weitere Informationen zu Migrationen finden Sie in den folgenden Ressourcen:

• Informationen zum Erstellen und Trainieren eines neuen Expense Parser finden Sie unter Vortrainierten Prozessor nachtrainieren.

• Informationen zum Erstellen und Optimieren eines neuen benutzerdefinierten Extraktor-Prozessors finden Sie unter Benutzerdefinierter Extraktor mit generativer KI.

Prozessorversion auswählen

Es gibt drei Möglichkeiten, anzugeben, welche Prozessorversion für die Online- und Batchverarbeitung verwendet werden soll:

• Wenn Sie keine Version angeben, wird die Standardeinstellung des Prozessors verwendet.

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

• Wenn Sie eine Version angeben, wird diese verwendet. Wenn die angegebene Version nicht vorhanden ist, schlägt die Anfrage mit einem Fehler fehl.

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

• Wenn Sie einen Channel angeben, wird die neueste Version in diesem Channel verwendet. (Optionen: stable, rc)

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

Verfügbare Version ansehen

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