Informationen zu diesem Codelab
1. Übersicht
Was ist Document AI?
Document AI ist eine Plattform, mit der Sie Erkenntnisse aus Ihren Dokumenten gewinnen können. Im Kern bietet es eine wachsende Liste von Dokumentenprozessoren (je nach Funktion auch als Parser oder Splitter bezeichnet).
Es gibt zwei Möglichkeiten, Document AI-Prozessoren zu verwalten:
- manuell über die Webkonsole
- programmgesteuert mit der Document AI API.
Hier ist ein Beispiel für einen Screenshot, der die Prozessorliste sowohl aus der Webkonsole als auch aus Python-Code zeigt:
In diesem Lab geht es darum, Document AI-Prozessoren programmatisch mit der Python-Clientbibliothek zu verwalten.
Was wird angezeigt?
- Umgebung einrichten
- Prozessortypen abrufen
- Prozessoren erstellen
- Projektprozessoren auflisten
- Verwendung von Prozessoren
- Prozessoren aktivieren/deaktivieren
- Prozessorversionen verwalten
- Prozessoren löschen
Voraussetzungen
Umfrage
Wie möchten Sie diese Anleitung verwenden?
Wie würden Sie Ihre Erfahrung mit Python bewerten?
Wie würden Sie Ihre Erfahrung mit den Google Cloud-Diensten bewerten?
2. Einrichtung und Anforderungen
Einrichtung der Umgebung im eigenen Tempo
- Melden Sie sich in der Google Cloud Console an und erstellen Sie ein neues Projekt oder verwenden Sie ein vorhandenes. Wenn Sie noch kein Gmail- oder Google Workspace-Konto haben, müssen Sie ein Konto erstellen.
- Der Projektname ist der Anzeigename für die Teilnehmer dieses Projekts. Es ist ein Zeichenstring, der von Google APIs nicht verwendet wird. Sie können sie jederzeit aktualisieren.
- Die Projekt-ID ist für alle Google Cloud-Projekte eindeutig und kann nach der Festlegung nicht mehr geändert werden. In der Cloud Console wird automatisch ein eindeutiger String generiert. In der Regel spielt es keine Rolle, wie er lautet. In den meisten Codelabs müssen Sie auf Ihre Projekt-ID verweisen (normalerweise als
PROJECT_IDgekennzeichnet). Wenn Ihnen die generierte ID nicht gefällt, können Sie eine andere zufällige generieren. Alternativ können Sie Ihr eigenes Konto ausprobieren und prüfen, ob es verfügbar ist. Sie kann nach diesem Schritt nicht mehr geändert werden und bleibt für die Dauer des Projekts bestehen. - Zur Information: Es gibt einen dritten Wert, die Projektnummer, die von einigen APIs verwendet wird. Weitere Informationen zu diesen drei Werten finden Sie in der Dokumentation.
- Als Nächstes müssen Sie die Abrechnung in der Cloud Console aktivieren, um Cloud-Ressourcen/-APIs verwenden zu können. Die Durchführung dieses Codelabs ist kostenlos oder kostet nur sehr wenig. Wenn Sie die Ressourcen deaktivieren möchten, um weitere Kosten nach Abschluss dieser Anleitung zu vermeiden, können Sie die von Ihnen erstellten Ressourcen oder das Projekt löschen. Neuen Google Cloud-Nutzern steht das kostenlose Testprogramm mit einem Guthaben von 300$ zur Verfügung.
Cloud Shell starten
Sie können Google Cloud zwar per Fernzugriff von Ihrem Laptop aus nutzen, 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 angezeigt. Klicken Sie in diesem Fall auf Weiter.
Die Bereitstellung und Verbindung mit Cloud Shell sollte nur wenige Minuten dauern.
Auf dieser virtuellen Maschine sind alle erforderlichen Entwicklungstools installiert. Sie bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und läuft in Google Cloud, was die Netzwerkleistung und Authentifizierung erheblich verbessert. Die meisten, wenn nicht alle Aufgaben 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 festgelegt 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 mit Document AI arbeiten können, müssen Sie die Document AI API aktivieren. Führen Sie dazu den folgenden Befehl in Cloud Shell aus:
gcloud services enable documentai.googleapis.com
Auf dem Bildschirm sollte Folgendes zu sehen sein:
Operation "operations/..." finished successfully.
Sie können Document AI jetzt verwenden.
Rufen Sie Ihr Basisverzeichnis auf:
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 der Sie die Anfrageergebnisse in einer ansprechenden Formatierung ausgeben können:
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 ausgeführt werden.
Prüfen Sie, ob Ihre Umgebungsvariablen richtig definiert sind:
echo $PROJECT_ID
echo $API_LOCATION
In den nächsten Schritten verwenden Sie den interaktiven Python-Interpreter IPython, den Sie gerade installiert haben. Starten Sie eine Sitzung, indem Sie in Cloud Shell ipython ausführen:
ipython
Auf dem Bildschirm sollte Folgendes zu sehen sein:
Python 3.12.3 (main, Feb 4 2025, 14:48:35) [GCC 13.3.0] Type 'copyright', 'credits' or 'license' for more information IPython 9.1.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
Bevor Sie im nächsten Schritt einen Prozessor erstellen, rufen Sie die verfügbaren Prozessortypen ab. 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 | ... | FORM_PARSER_PROCESSOR | GENERAL | True | eu, us | | LAYOUT_PARSER_PROCESSOR | GENERAL | True | eu, us | | OCR_PROCESSOR | GENERAL | True | eu, us | | BANK_STATEMENT_PROCESSOR | SPECIALIZED | True | eu, us | | EXPENSE_PROCESSOR | SPECIALIZED | True | eu, us | ... +--------------------------------------+-------------+----------------+-----------+ → Processor types: 19
Sie haben jetzt alle Informationen, die Sie für den nächsten Schritt zum Erstellen von Prozessoren benötigen.
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
Wenn Sie einen Zahlungsabwickler anhand seines Anzeigenamens abrufen möchten, fügen Sie die folgende Funktion hinzu:
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 anhand ihrer Anzeigenamen abrufen. Als Nächstes erfahren Sie, wie Sie einen Prozessor verwenden.
7. Prozessoren verwenden
Dokumente können auf zwei Arten verarbeitet werden:
- Synchron: Rufen Sie
process_documentauf, um ein einzelnes Dokument zu analysieren und die Ergebnisse direkt zu verwenden. - Asynchron: Rufen Sie
batch_process_documentsauf, um eine Batchverarbeitung für mehrere oder große Dokumente zu starten.
Ihr Testdokument ( PDF) ist ein gescannter Fragebogen mit handschriftlichen Antworten. Laden Sie sie 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 process_document-Methode 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 Formular-Parser aus. Neben dem Extrahieren von Text (gedruckt und handgeschrieben), was alle Prozessoren tun, erkennt dieser allgemeine Prozessor auch Formularfelder.
Dokument analysieren:
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 eine erste optische Zeichenerkennung (OCR) auf dem Dokument aus. Überprüfen Sie den durch die OCR-Karte/-Ticket 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:', '9/14/19', 'Name:', 'Sally Walker', 'DOB: 09/04/1986', 'Address: 24 Barney Lane', 'City: Towaco', 'State: NJ Zip: 07082', 'Email: Sally, walker@cmail.com', '_Phone #: (906) 917-3486', 'Gender: F', '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 auch diese Dienstfunktionen 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
Drucken Sie die erkannten Formularfelder:
print_form_fields(document)
Sie sollten einen Ausdruck erhalten, der in etwa so aussieht:
+-----------------+-------------------------+------------+ | name | value | confidence | +-----------------+-------------------------+------------+ | Date: | 9/14/19 | 83.0% | | Name: | Sally Walker | 87.3% | | DOB: | 09/04/1986 | 88.5% | | Address: | 24 Barney Lane | 82.4% | | City: | Towaco | 90.0% | | State: | NJ | 89.4% | | Zip: | 07082 | 91.4% | | Email: | Sally, walker@cmail.com | 79.7% | | _Phone #: | walker@cmail.com | 93.2% | | | (906 | | | Gender: | F | 88.2% | | Marital Status: | Single | 85.2% | | Occupation: | Software Engineer | 81.5% | | Referred By: | None | 76.9% | ... +-----------------+-------------------------+------------+ → 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 handgeschriebenen Text enthält. Außerdem haben Sie die Felder mit hoher Wahrscheinlichkeit erkannt. Ihre Pixel wurden in strukturierte Daten umgewandelt.
8. Prozessoren aktivieren und deaktivieren
Mit disable_processor und enable_processor können Sie festlegen, 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. Weitere Informationen zur Verwendung der Methoden list_processor_versions und set_default_processor_version
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 folgenden Prozessorversionen:
+--------------------------------+--------------------------+---------+ | 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 | | | pretrained-ocr-v2.0-2023-06-02 | Google Stable | Y | | pretrained-ocr-v2.1-2024-08-07 | Google Release Candidate | | +--------------------------------+--------------------------+---------+ → Processor versions: 5
Fügen Sie nun eine Funktion hinzu, um die Standardversion des Prozessors 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
Wechseln Sie zur neuesten Prozessorversion:
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 Konfiguration der neuen Version:
+--------------------------------+--------------------------+---------+ | 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 | | | pretrained-ocr-v2.0-2023-06-02 | Google Stable | | | pretrained-ocr-v2.1-2024-08-07 | Google Release Candidate | Y | +--------------------------------+--------------------------+---------+ → Processor versions: 5
Als Nächstes folgt die ultimative Methode zur Prozessorverwaltung: das Löschen.
10. Prozessoren löschen
Sehen Sie sich abschließend an, 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
So löschen Sie 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 zur Prozessorverwaltung kennengelernt. Sie sind fast fertig…
11. Glückwunsch!
Sie haben gelernt, wie Sie Document AI-Prozessoren mit Python verwalten.
Bereinigen
So bereinigen Sie Ihre Entwicklungsumgebung in Cloud Shell:
- Wenn Sie sich noch in der IPython-Sitzung befinden, kehren Sie zur Shell zurück:
exit - Beenden Sie die Verwendung der virtuellen Python-Umgebung:
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) - Prüfen Sie, ob es sich dabei um das Projekt handelt, das Sie löschen möchten:
echo $PROJECT_ID - Projekt löschen:
gcloud projects delete $PROJECT_ID
Weitere Informationen
- Document AI in Ihrem Browser ausprobieren: 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.