Diese Seite wurde von der Cloud Translation API übersetzt.

Document AI-Prozessoren mit Python verwalten

1. Übersicht

Was ist Document AI?

Document AI ist eine Plattform, mit der Sie Informationen aus Ihren Dokumenten gewinnen können. Im Kern bietet es eine wachsende Liste von Dokumentprozessoren (je nach Funktionalität auch als Parser oder Splitter bezeichnet).

Es gibt zwei Möglichkeiten, Document AI-Prozessoren zu verwalten:

manuell über die Webkonsole
mithilfe der Document AI API programmatisch erstellen und verwalten.

Hier ist ein Beispielscreenshot, in dem Ihre Prozessorliste sowohl aus der Webkonsole als auch aus Python-Code zu sehen ist:

In diesem Lab konzentrieren Sie sich auf die programmatische Verwaltung von Document AI-Prozessoren mit der Python-Clientbibliothek.

Was wird angezeigt?

Umgebung einrichten
Prozessortypen abrufen
Prozessoren erstellen
Projektauftragsverarbeiter auflisten
Prozessoren verwenden
Prozessoren aktivieren/deaktivieren
Prozessorversionen verwalten
Prozessoren löschen

Voraussetzungen

Ein Google Cloud-Projekt
Ein Browser wie Chrome oder Firefox
Vertrautheit bei der Verwendung von Python

Umfrage

Wie möchten Sie diese Anleitung nutzen?

<ph type="x-smartling-placeholder"></ph> Nur bis zum Ende lesen

Lies sie dir durch und absolviere die Übungen

Wie würden Sie Ihre Erfahrung mit Python bewerten?

<ph type="x-smartling-placeholder"></ph> Neuling

Mittel

Kompetent

Wie würden Sie Ihre Erfahrung mit Google Cloud-Diensten bewerten?

<ph type="x-smartling-placeholder"></ph> Neuling

Mittel

Kompetent

2. Einrichtung und Anforderungen

Umgebung für das selbstbestimmte Lernen einrichten

Melden Sie sich in der Google Cloud Console an und erstellen Sie ein neues Projekt oder verwenden Sie ein vorhandenes Projekt. Wenn Sie noch kein Gmail- oder Google Workspace-Konto haben, müssen Sie eines erstellen.

Der Projektname ist der Anzeigename für die Projektteilnehmer. Es handelt sich um eine Zeichenfolge, die von Google APIs nicht verwendet wird. Sie können sie jederzeit aktualisieren.
Die Projekt-ID ist für alle Google Cloud-Projekte eindeutig und unveränderlich. Sie kann nach dem Festlegen nicht mehr geändert werden. Die Cloud Console generiert automatisch einen eindeutigen String. ist Ihnen meist egal, was es ist. In den meisten Codelabs musst du auf deine Projekt-ID verweisen, die üblicherweise als PROJECT_ID bezeichnet wird. Wenn Ihnen die generierte ID nicht gefällt, können Sie eine weitere zufällige ID generieren. Alternativ können Sie einen eigenen verwenden und nachsehen, ob er verfügbar ist. Sie kann nach diesem Schritt nicht mehr geändert werden und bleibt für die Dauer des Projekts erhalten.
Zur Information gibt es noch einen dritten Wert, die Projektnummer, die von manchen APIs verwendet wird. Weitere Informationen zu allen drei Werten finden Sie in der Dokumentation.

Als Nächstes müssen Sie in der Cloud Console die Abrechnung aktivieren, um Cloud-Ressourcen/APIs verwenden zu können. Dieses Codelab ist kostengünstig. Sie können die von Ihnen erstellten Ressourcen oder das Projekt löschen, um Ressourcen herunterzufahren, um zu vermeiden, dass über diese Anleitung hinaus Kosten anfallen. Neue Google Cloud-Nutzer haben Anspruch auf das kostenlose Testprogramm mit 300$Guthaben.

Cloud Shell starten

Sie können Google Cloud zwar von Ihrem Laptop aus aus der Ferne bedienen, in diesem Lab verwenden Sie jedoch Cloud Shell, eine Befehlszeilenumgebung, die in der Cloud ausgeführt wird.

Cloud Shell aktivieren

Klicken Sie in der Cloud Console auf Cloud Shell aktivieren .

Wenn Sie Cloud Shell zum ersten Mal starten, wird ein Zwischenbildschirm mit einer Beschreibung der Funktion angezeigt. Wenn ein Zwischenbildschirm angezeigt wird, klicken Sie auf Weiter.

Die Bereitstellung und Verbindung mit Cloud Shell dauert nur einen Moment.

Diese virtuelle Maschine verfügt über alle erforderlichen Entwicklertools. Es bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und wird in Google Cloud ausgeführt. Dadurch werden die Netzwerkleistung und die Authentifizierung erheblich verbessert. Viele, wenn nicht sogar alle Arbeiten in diesem Codelab können mit einem Browser erledigt werden.

Sobald Sie mit Cloud Shell verbunden sind, sollten Sie sehen, dass Sie authentifiziert sind und das Projekt auf Ihre Projekt-ID eingestellt ist.

Führen Sie in Cloud Shell den folgenden Befehl aus, um zu prüfen, ob Sie authentifiziert sind:

gcloud auth list

Befehlsausgabe

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

Führen Sie in Cloud Shell den folgenden Befehl aus, um zu prüfen, ob der gcloud-Befehl Ihr Projekt kennt:

gcloud config list project

Befehlsausgabe

[core]
project = <PROJECT_ID>

Ist dies nicht der Fall, können Sie die Einstellung mit diesem Befehl vornehmen:

gcloud config set project <PROJECT_ID>

Befehlsausgabe

Updated property [core/project].

3. Umgebung einrichten

Bevor Sie Document AI verwenden können, führen Sie den folgenden Befehl in Cloud Shell aus, um die Document AI API zu aktivieren:

gcloud services enable documentai.googleapis.com

Auf dem Bildschirm sollte Folgendes zu sehen sein:

Operation "operations/..." finished successfully.

Jetzt können Sie Document AI verwenden!

Wechseln Sie zu Ihrem Basisverzeichnis:

cd ~

Erstellen Sie eine virtuelle Python-Umgebung, um die Abhängigkeiten zu isolieren:

virtualenv venv-docai

Aktivieren Sie die virtuelle Umgebung:

source venv-docai/bin/activate

Installieren Sie IPython, die Document AI-Clientbibliothek und python-tabulate (mit dem Sie die Ergebnisse der Anfrage richtig ausgeben werden):

pip install ipython google-cloud-documentai tabulate

Auf dem Bildschirm sollte Folgendes zu sehen sein:

...
Installing collected packages: ..., tabulate, ipython, google-cloud-documentai
Successfully installed ... google-cloud-documentai-2.15.0 ...

Jetzt können Sie die Document AI-Clientbibliothek verwenden.

Legen Sie die folgenden Umgebungsvariablen fest:

export PROJECT_ID=$(gcloud config get-value core/project)

# Choose "us" or "eu"
export API_LOCATION="us"

Ab jetzt sollten alle Schritte in derselben Sitzung abgeschlossen werden.

Achten Sie darauf, dass Ihre Umgebungsvariablen richtig definiert sind:

echo $PROJECT_ID

echo $API_LOCATION

In den nächsten Schritten verwenden Sie einen interaktiven Python-Interpreter namens IPython, den Sie gerade installiert haben. Starten Sie eine Sitzung, indem Sie ipython in Cloud Shell ausführen:

ipython

Auf dem Bildschirm sollte Folgendes zu sehen sein:

Python 3.9.2 (default, Feb 28 2021, 17:03:44)
Type 'copyright', 'credits' or 'license' for more information
IPython 8.14.0 -- An enhanced Interactive Python. Type '?' for help.

In [1]:

Kopieren Sie den folgenden Code in Ihre IPython-Sitzung:

import os
from typing import Iterator, MutableSequence, Optional, Sequence, Tuple

import google.cloud.documentai_v1 as docai
from tabulate import tabulate

PROJECT_ID = os.getenv("PROJECT_ID", "")
API_LOCATION = os.getenv("API_LOCATION", "")

assert PROJECT_ID, "PROJECT_ID is undefined"
assert API_LOCATION in ("us", "eu"), "API_LOCATION is incorrect"

# Test processors
document_ocr_display_name = "document-ocr"
form_parser_display_name = "form-parser"

test_processor_display_names_and_types = (
    (document_ocr_display_name, "OCR_PROCESSOR"),
    (form_parser_display_name, "FORM_PARSER_PROCESSOR"),
)

def get_client() -> docai.DocumentProcessorServiceClient:
    client_options = {"api_endpoint": f"{API_LOCATION}-documentai.googleapis.com"}
    return docai.DocumentProcessorServiceClient(client_options=client_options)

def get_parent(client: docai.DocumentProcessorServiceClient) -> str:
    return client.common_location_path(PROJECT_ID, API_LOCATION)

def get_client_and_parent() -> Tuple[docai.DocumentProcessorServiceClient, str]:
    client = get_client()
    parent = get_parent(client)
    return client, parent

Sie können jetzt Ihre erste Anfrage senden und die Prozessortypen abrufen.

4. Prozessortypen abrufen

Rufen Sie die verfügbaren Prozessortypen ab, bevor Sie im nächsten Schritt einen Prozessor erstellen. Sie können diese Liste mit fetch_processor_types abrufen.

Fügen Sie Ihrer IPython-Sitzung die folgenden Funktionen hinzu:

def fetch_processor_types() -> MutableSequence[docai.ProcessorType]:
    client, parent = get_client_and_parent()
    response = client.fetch_processor_types(parent=parent)

    return response.processor_types

def print_processor_types(processor_types: Sequence[docai.ProcessorType]):
    def sort_key(pt):
        return (not pt.allow_creation, pt.category, pt.type_)

    sorted_processor_types = sorted(processor_types, key=sort_key)
    data = processor_type_tabular_data(sorted_processor_types)
    headers = next(data)
    colalign = next(data)

    print(tabulate(data, headers, tablefmt="pretty", colalign=colalign))
    print(f"→ Processor types: {len(sorted_processor_types)}")

def processor_type_tabular_data(
    processor_types: Sequence[docai.ProcessorType],
) -> Iterator[Tuple[str, str, str, str]]:
    def locations(pt):
        return ", ".join(sorted(loc.location_id for loc in pt.available_locations))

    yield ("type", "category", "allow_creation", "locations")
    yield ("left", "left", "left", "left")
    if not processor_types:
        yield ("-", "-", "-", "-")
        return
    for pt in processor_types:
        yield (pt.type_, pt.category, f"{pt.allow_creation}", locations(pt))

Listen Sie die Prozessortypen auf:

processor_types = fetch_processor_types()
print_processor_types(processor_types)

Die Ausgabe sollte in etwa so aussehen:

+---------------------------------+-------------+----------------+------------+
| type                            | category    | allow_creation | locations  |
+---------------------------------+-------------+----------------+------------+
| CUSTOM_CLASSIFICATION_PROCESSOR | CUSTOM      | True           | eu, us...  |
| CUSTOM_EXTRACTION_PROCESSOR     | CUSTOM      | True           | eu, us...  |
| FORM_PARSER_PROCESSOR           | GENERAL     | True           | eu, us...  |
| OCR_PROCESSOR                   | GENERAL     | True           | eu, us...  |
| EXPENSE_PROCESSOR               | SPECIALIZED | True           | eu, us...  |
...
+---------------------------------+-------------+----------------+------------+
→ Processor types: 40

Jetzt haben Sie alle Informationen, die zum Erstellen von Prozessoren im nächsten Schritt erforderlich sind.

5. Prozessoren erstellen

Rufen Sie zum Erstellen eines Prozessors create_processor mit einem Anzeigenamen und einem Prozessortyp auf.

Fügen Sie die folgende Funktion hinzu:

def create_processor(display_name: str, type: str) -> docai.Processor:
    client, parent = get_client_and_parent()
    processor = docai.Processor(display_name=display_name, type_=type)

    return client.create_processor(parent=parent, processor=processor)

Erstellen Sie die Testprozessoren:

separator = "=" * 80
for display_name, type in test_processor_display_names_and_types:
    print(separator)
    print(f"Creating {display_name} ({type})...")
    try:
        create_processor(display_name, type)
    except Exception as err:
        print(err)
print(separator)
print("Done")

Sie sollten Folgendes sehen:

================================================================================
Creating document-ocr (OCR_PROCESSOR)...
================================================================================
Creating form-parser (FORM_PARSER_PROCESSOR)...
================================================================================
Done

Sie haben neue Prozessoren erstellt.

Als Nächstes erfahren Sie, wie Sie die Prozessoren auflisten.

6. Projektprozessoren auflisten

list_processors gibt die Liste aller Prozessoren zurück, die zu Ihrem Projekt gehören.

Fügen Sie die folgenden Funktionen hinzu:

def list_processors() -> MutableSequence[docai.Processor]:
    client, parent = get_client_and_parent()
    response = client.list_processors(parent=parent)

    return list(response.processors)

def print_processors(processors: Optional[Sequence[docai.Processor]] = None):
    def sort_key(processor):
        return processor.display_name

    if processors is None:
        processors = list_processors()
    sorted_processors = sorted(processors, key=sort_key)
    data = processor_tabular_data(sorted_processors)
    headers = next(data)
    colalign = next(data)

    print(tabulate(data, headers, tablefmt="pretty", colalign=colalign))
    print(f"→ Processors: {len(sorted_processors)}")

def processor_tabular_data(
    processors: Sequence[docai.Processor],
) -> Iterator[Tuple[str, str, str]]:
    yield ("display_name", "type", "state")
    yield ("left", "left", "left")
    if not processors:
        yield ("-", "-", "-")
        return
    for processor in processors:
        yield (processor.display_name, processor.type_, processor.state.name)

Rufen Sie die Funktionen auf:

processors = list_processors()
print_processors(processors)

Sie sollten Folgendes sehen:

+--------------+-----------------------+---------+
| display_name | type                  | state   |
+--------------+-----------------------+---------+
| document-ocr | OCR_PROCESSOR         | ENABLED |
| form-parser  | FORM_PARSER_PROCESSOR | ENABLED |
+--------------+-----------------------+---------+
→ Processors: 2

Fügen Sie die folgende Funktion hinzu, um einen Prozessor anhand seines Anzeigenamens abzurufen:

def get_processor(
    display_name: str,
    processors: Optional[Sequence[docai.Processor]] = None,
) -> Optional[docai.Processor]:
    if processors is None:
        processors = list_processors()
    for processor in processors:
        if processor.display_name == display_name:
            return processor
    return None

Die Funktion testen:

processor = get_processor(document_ocr_display_name, processors)

assert processor is not None
print(processor)

Auf dem Bildschirm sollte Folgendes zu sehen sein:

name: "projects/PROJECT_NUM/locations/LOCATION/processors/PROCESSOR_ID"
type_: "OCR_PROCESSOR"
display_name: "document-ocr"
state: ENABLED
...

Jetzt wissen Sie, wie Sie Ihre Projektprozessoren auflisten und nach Anzeigenamen abrufen. Als Nächstes sehen wir uns an, wie ein Prozessor verwendet wird.

7. Prozessoren verwenden

Dokumente können auf zwei Arten verarbeitet werden:

Synchron: Rufen Sie process_document auf, um ein einzelnes Dokument zu analysieren und die Ergebnisse direkt zu verwenden.
Asynchron: Rufen Sie batch_process_documents auf, um eine Batchverarbeitung für mehrere oder große Dokumente zu starten.

Ihr Testdokument ( PDF) ist ein eingescannter Fragebogen mit handschriftlichen Antworten. Laden Sie es direkt aus Ihrer IPython-Sitzung in Ihr Arbeitsverzeichnis herunter:

!gsutil cp gs://cloud-samples-data/documentai/form.pdf .

Prüfen Sie den Inhalt Ihres Arbeitsverzeichnisses:

!ls

Sie sollten Folgendes haben:

...  form.pdf  ...  venv-docai  ...

Sie können die synchrone Methode process_document verwenden, um eine lokale Datei zu analysieren. Fügen Sie die folgende Funktion hinzu:

def process_file(
    processor: docai.Processor,
    file_path: str,
    mime_type: str,
) -> docai.Document:
    client = get_client()
    with open(file_path, "rb") as document_file:
        document_content = document_file.read()
    document = docai.RawDocument(content=document_content, mime_type=mime_type)
    request = docai.ProcessRequest(raw_document=document, name=processor.name)

    response = client.process_document(request)

    return response.document

Da es sich bei Ihrem Dokument um einen Fragebogen handelt, wählen Sie den Formularparser aus. Dieser allgemeine Prozessor extrahiert nicht nur den (gedruckten und handgeschriebenen) Text, der von allen Prozessoren stammt, sondern auch Formularfelder.

Analysieren Sie das Dokument:

processor = get_processor(form_parser_display_name)
assert processor is not None

file_path = "./form.pdf"
mime_type = "application/pdf"

document = process_file(processor, file_path, mime_type)

Alle Prozessoren führen zuerst eine optische Zeichenerkennung (Optical Character Recognition, OCR) für das Dokument aus. Prüfen Sie den von der OCR-Karte erkannten Text:

document.text.split("\n")

Die Ausgabe sollte etwa so aussehen:

['FakeDoc M.D.',
 'HEALTH INTAKE FORM',
 'Please fill out the questionnaire carefully. The information you provide will be used to complete',
 'your health profile and will be kept confidential.',
 'Date:',
 'Sally',
 'Walker',
 'Name:',
 '9/14/19',
 'DOB: 09/04/1986',
 'Address: 24 Barney Lane City: Towaco State: NJ Zip: 07082',
 'Email: Sally, waller@cmail.com Phone #: (906) 917-3486',
 'Gender: F',
 'Single Occupation: Software Engineer',
 'Referred By: None',
 'Emergency Contact: Eva Walker Emergency Contact Phone: (906) 334-8976',
 'Marital Status:',
  ...
]

Fügen Sie die folgenden Funktionen hinzu, um die erkannten Formularfelder auszugeben:

def print_form_fields(document: docai.Document):
    sorted_form_fields = form_fields_sorted_by_ocr_order(document)
    data = form_field_tabular_data(sorted_form_fields, document)
    headers = next(data)
    colalign = next(data)

    print(tabulate(data, headers, tablefmt="pretty", colalign=colalign))
    print(f"→ Form fields: {len(sorted_form_fields)}")

def form_field_tabular_data(
    form_fields: Sequence[docai.Document.Page.FormField],
    document: docai.Document,
) -> Iterator[Tuple[str, str, str]]:
    yield ("name", "value", "confidence")
    yield ("right", "left", "right")
    if not form_fields:
        yield ("-", "-", "-")
        return
    for form_field in form_fields:
        name_layout = form_field.field_name
        value_layout = form_field.field_value
        name = text_from_layout(name_layout, document)
        value = text_from_layout(value_layout, document)
        confidence = value_layout.confidence
        yield (name, value, f"{confidence:.1%}")

Fügen Sie außerdem diese Dienstprogrammfunktionen hinzu:

def form_fields_sorted_by_ocr_order(
    document: docai.Document,
) -> MutableSequence[docai.Document.Page.FormField]:
    def sort_key(form_field):
        # Sort according to the field name detected position
        text_anchor = form_field.field_name.text_anchor
        return text_anchor.text_segments[0].start_index if text_anchor else 0

    fields = (field for page in document.pages for field in page.form_fields)

    return sorted(fields, key=sort_key)


def text_from_layout(
    layout: docai.Document.Page.Layout,
    document: docai.Document,
) -> str:
    full_text = document.text
    segs = layout.text_anchor.text_segments
    text = "".join(full_text[seg.start_index : seg.end_index] for seg in segs)
    if text.endswith("\n"):
        text = text[:-1]

    return text

Geben Sie die erkannten Formularfelder aus:

print_form_fields(document)

Sie sollten einen Ausdruck wie den folgenden erhalten:

+--------------+-------------------------+------------+
|         name | value                   | confidence |
+--------------+-------------------------+------------+
|        Date: | 9/14/19                 |     100.0% |
|        Name: | Sally                   |      99.7% |
|              | Walker                  |            |
|         DOB: | 09/04/1986              |     100.0% |
|     Address: | 24 Barney Lane          |      99.9% |
|        City: | Towaco                  |      99.8% |
|       State: | NJ                      |      99.7% |
|         Zip: | 07082                   |      99.5% |
|       Email: | Sally, waller@cmail.com |      99.6% |
|     Phone #: | (906) 917-3486          |     100.0% |
|      Gender: | F                       |     100.0% |
|  Occupation: | Software Engineer       |     100.0% |
| Referred By: | None                    |     100.0% |
...
+--------------+-------------------------+------------+
→ Form fields: 17

Prüfen Sie die erkannten Feldnamen und -werte ( PDF). Hier ist die obere Hälfte des Fragebogens:

Sie haben ein Formular analysiert, das sowohl gedruckten als auch handschriftlichen Text enthält. Sie haben auch die zugehörigen Felder mit hoher Zuverlässigkeit erkannt. Als Ergebnis wurden Ihre Pixel in strukturierte Daten umgewandelt.

8. Prozessoren aktivieren und deaktivieren

Mit disable_processor und enable_processor können Sie steuern, ob ein Prozessor verwendet werden kann.

Fügen Sie die folgenden Funktionen hinzu:

def update_processor_state(processor: docai.Processor, enable_processor: bool):
    client = get_client()
    if enable_processor:
        request = docai.EnableProcessorRequest(name=processor.name)
        operation = client.enable_processor(request)
    else:
        request = docai.DisableProcessorRequest(name=processor.name)
        operation = client.disable_processor(request)
    operation.result()  # Wait for operation to complete

def enable_processor(processor: docai.Processor):
    update_processor_state(processor, True)

def disable_processor(processor: docai.Processor):
    update_processor_state(processor, False)

Deaktivieren Sie den Formularparser-Prozessor und prüfen Sie den Status Ihrer Prozessoren:

processor = get_processor(form_parser_display_name)
assert processor is not None

disable_processor(processor)
print_processors()

Sie sollten Folgendes sehen:

+--------------+-----------------------+----------+
| display_name | type                  | state    |
+--------------+-----------------------+----------+
| document-ocr | OCR_PROCESSOR         | ENABLED  |
| form-parser  | FORM_PARSER_PROCESSOR | DISABLED |
+--------------+-----------------------+----------+
→ Processors: 2

Aktivieren Sie den Formularparser-Prozessor wieder:

enable_processor(processor)
print_processors()

Sie sollten Folgendes sehen:

+--------------+-----------------------+---------+
| display_name | type                  | state   |
+--------------+-----------------------+---------+
| document-ocr | OCR_PROCESSOR         | ENABLED |
| form-parser  | FORM_PARSER_PROCESSOR | ENABLED |
+--------------+-----------------------+---------+
→ Processors: 2

Als Nächstes erfahren Sie, wie Sie Prozessorversionen verwalten.

9. Prozessorversionen verwalten

Prozessoren können in mehreren Versionen verfügbar sein. Methoden list_processor_versions und set_default_processor_version verwenden

Fügen Sie die folgenden Funktionen hinzu:

def list_processor_versions(
    processor: docai.Processor,
) -> MutableSequence[docai.ProcessorVersion]:
    client = get_client()
    response = client.list_processor_versions(parent=processor.name)

    return list(response)


def get_sorted_processor_versions(
    processor: docai.Processor,
) -> MutableSequence[docai.ProcessorVersion]:
    def sort_key(processor_version: docai.ProcessorVersion):
        return processor_version.name

    versions = list_processor_versions(processor)

    return sorted(versions, key=sort_key)


def print_processor_versions(processor: docai.Processor):
    versions = get_sorted_processor_versions(processor)
    default_version_name = processor.default_processor_version
    data = processor_versions_tabular_data(versions, default_version_name)
    headers = next(data)
    colalign = next(data)

    print(tabulate(data, headers, tablefmt="pretty", colalign=colalign))
    print(f"→ Processor versions: {len(versions)}")


def processor_versions_tabular_data(
    versions: Sequence[docai.ProcessorVersion],
    default_version_name: str,
) -> Iterator[Tuple[str, str, str]]:
    yield ("version", "display name", "default")
    yield ("left", "left", "left")
    if not versions:
        yield ("-", "-", "-")
        return
    for version in versions:
        mapping = docai.DocumentProcessorServiceClient.parse_processor_version_path(
            version.name
        )
        processor_version = mapping["processor_version"]
        is_default = "Y" if version.name == default_version_name else ""
        yield (processor_version, version.display_name, is_default)

Listen Sie die verfügbaren Versionen für den OCR-Prozessor auf:

processor = get_processor(document_ocr_display_name)
assert processor is not None
print_processor_versions(processor)

Sie erhalten die Prozessorversionen:

+--------------------------------+--------------------------+---------+
| version                        | display name             | default |
+--------------------------------+--------------------------+---------+
| pretrained-ocr-v1.0-2020-09-23 | Google Stable            | Y       |
| pretrained-ocr-v1.1-2022-09-12 | Google Release Candidate |         |
| pretrained-ocr-v1.2-2022-11-10 | Google Release Candidate |         |
+--------------------------------+--------------------------+---------+
→ Processor versions: 3

Fügen Sie jetzt eine Funktion hinzu, um die Standard-Prozessorversion zu ändern:

def set_default_processor_version(processor: docai.Processor, version_name: str):
    client = get_client()
    request = docai.SetDefaultProcessorVersionRequest(
        processor=processor.name,
        default_processor_version=version_name,
    )

    operation = client.set_default_processor_version(request)
    operation.result()  # Wait for operation to complete

Zur neuesten Prozessorversion wechseln:

processor = get_processor(document_ocr_display_name)
assert processor is not None
versions = get_sorted_processor_versions(processor)

new_version = versions[-1]  # Latest version
set_default_processor_version(processor, new_version.name)

# Update the processor info
processor = get_processor(document_ocr_display_name)
assert processor is not None
print_processor_versions(processor)

Sie erhalten die neue Versionskonfiguration:

+--------------------------------+--------------------------+---------+
| version                        | display name             | default |
+--------------------------------+--------------------------+---------+
| pretrained-ocr-v1.0-2020-09-23 | Google Stable            |         |
| pretrained-ocr-v1.1-2022-09-12 | Google Release Candidate |         |
| pretrained-ocr-v1.2-2022-11-10 | Google Release Candidate | Y       |
+--------------------------------+--------------------------+---------+
→ Processor versions: 3

Und als Nächstes die ultimative Methode zur Verwaltung des Prozessors (Löschen).

10. Prozessoren löschen

Abschließend erfahren Sie, wie Sie die Methode delete_processor verwenden.

Fügen Sie die folgende Funktion hinzu:

def delete_processor(processor: docai.Processor):
    client = get_client()
    operation = client.delete_processor(name=processor.name)
    operation.result()  # Wait for operation to complete

Löschen Sie Ihre Testprozessoren:

processors_to_delete = [dn for dn, _ in test_processor_display_names_and_types]
print("Deleting processors...")

for processor in list_processors():
    if processor.display_name not in processors_to_delete:
        continue
    print(f"  Deleting {processor.display_name}...")
    delete_processor(processor)

print("Done\n")
print_processors()

Sie sollten Folgendes sehen:

Deleting processors...
  Deleting form-parser...
  Deleting document-ocr...
Done

+--------------+------+-------+
| display_name | type | state |
+--------------+------+-------+
| -            | -    | -     |
+--------------+------+-------+
→ Processors: 0

Sie haben alle Methoden der Prozessorverwaltung behandelt! Fast fertig...

11. Glückwunsch!

Sie haben gelernt, wie Document AI-Prozessoren mit Python verwaltet werden.

Bereinigen

So bereinigen Sie die Entwicklungsumgebung in Cloud Shell:

Wenn Sie sich noch in Ihrer IPython-Sitzung befinden, gehen Sie zurück zur Shell: exit
Verwendung der virtuellen Python-Umgebung beenden: deactivate
Löschen Sie den Ordner der virtuellen Umgebung: cd ~ ; rm -rf ./venv-docai

So löschen Sie Ihr Google Cloud-Projekt in Cloud Shell:

Rufen Sie Ihre aktuelle Projekt-ID ab: PROJECT_ID=$(gcloud config get-value core/project)
Achten Sie darauf, dass dies das Projekt ist, das Sie löschen möchten: echo $PROJECT_ID
Projekt löschen: gcloud projects delete $PROJECT_ID

Weitere Informationen

Testen Sie Document AI in Ihrem Browser: https://cloud.google.com/document-ai/docs/drag-and-drop
Details zum Document AI-Prozessor: https://cloud.google.com/document-ai/docs/processors-list
Python in Google Cloud: https://cloud.google.com/python
Cloud-Clientbibliotheken für Python: https://github.com/googleapis/google-cloud-python

Lizenz

Dieser Text ist mit einer Creative Commons Attribution 2.0 Generic License lizenziert.