Questa pagina è stata tradotta dall'API Cloud Translation.

Gestione dei processori Document AI con Python

1. Panoramica

Che cos'è Document AI?

Document AI è una piattaforma che ti consente di estrarre insight dai tuoi documenti. Di base, offre un elenco sempre più vasto di processori di documenti (chiamati anche parser o splitter, a seconda della loro funzionalità).

Esistono due modi per gestire i processori Document AI:

manualmente, dalla console web;
in modo programmatico, utilizzando l'API Document AI.

Ecco uno screenshot di esempio che mostra l'elenco dei tuoi processori, sia dalla console web che dal codice Python:

In questo lab ti concentrerai sulla gestione dei processori Document AI in modo programmatico con la libreria client Python.

Informazioni visualizzate

Come configurare l'ambiente
Come recuperare i tipi di processori
Come creare processori
Come elencare i processori di progetto
Come usare i processori
Come abilitare/disabilitare i processori
Come gestire le versioni del processore
Come eliminare i processori

Che cosa ti serve

Un progetto Google Cloud
Un browser, ad esempio Chrome o Firefox
Dimestichezza nell'utilizzo di Python

Sondaggio

Come utilizzerai questo tutorial?

Solo lettura

Leggilo e completa gli esercizi

Come valuteresti la tua esperienza con Python?

Principiante

Livello intermedio

Eccellente

Come giudichi la tua esperienza con i servizi Google Cloud?

Principiante

Livello intermedio

Eccellente

2. Configurazione e requisiti

Configurazione dell'ambiente da seguire in modo autonomo

Accedi alla console Google Cloud e crea un nuovo progetto o riutilizzane uno esistente. Se non hai ancora un account Gmail o Google Workspace, devi crearne uno.

Il Nome progetto è il nome visualizzato dei partecipanti del progetto. Si tratta di una stringa di caratteri non utilizzata dalle API di Google. Puoi sempre aggiornarla.
L'ID progetto è univoco in tutti i progetti Google Cloud ed è immutabile (non può essere modificato dopo essere stato impostato). La console Cloud genera automaticamente una stringa univoca. di solito non ti importa cosa sia. Nella maggior parte dei codelab, dovrai fare riferimento al tuo ID progetto (in genere identificato come PROJECT_ID). Se l'ID generato non ti soddisfa, potresti generarne un altro casuale. In alternativa, puoi provarne una personalizzata per verificare se è disponibile. Non può essere modificato dopo questo passaggio e rimane per tutta la durata del progetto.
Per informazione, c'è un terzo valore, un numero di progetto, utilizzato da alcune API. Scopri di più su tutti e tre questi valori nella documentazione.

Successivamente, dovrai abilitare la fatturazione nella console Cloud per utilizzare risorse/API Cloud. L'esecuzione di questo codelab non ha alcun costo. Per arrestare le risorse ed evitare di incorrere in fatturazione dopo questo tutorial, puoi eliminare le risorse che hai creato o eliminare il progetto. I nuovi utenti di Google Cloud sono idonei al programma prova senza costi di 300$.

Avvia Cloud Shell

Google Cloud può essere utilizzato da remoto dal tuo laptop, ma in questo lab utilizzerai Cloud Shell, un ambiente a riga di comando in esecuzione nel cloud.

Attiva Cloud Shell

Dalla console Cloud, fai clic su Attiva Cloud Shell .

Se è la prima volta che avvii Cloud Shell, ti verrà mostrata una schermata intermedia che descrive di cosa si tratta. Se ti è stata presentata una schermata intermedia, fai clic su Continua.

Il provisioning e la connessione a Cloud Shell dovrebbero richiedere solo qualche istante.

Questa macchina virtuale viene caricata con tutti gli strumenti di sviluppo necessari. Offre una home directory permanente da 5 GB e viene eseguita in Google Cloud, migliorando notevolmente le prestazioni di rete e l'autenticazione. Gran parte, se non tutto, del lavoro in questo codelab può essere svolto con un browser.

Una volta stabilita la connessione a Cloud Shell, dovresti vedere che hai eseguito l'autenticazione e che il progetto è impostato sul tuo ID progetto.

Esegui questo comando in Cloud Shell per verificare che l'account sia autenticato:

gcloud auth list

Output comando

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

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

Esegui questo comando in Cloud Shell per confermare che il comando gcloud è a conoscenza del tuo progetto:

gcloud config list project

Output comando

[core]
project = <PROJECT_ID>

In caso contrario, puoi impostarlo con questo comando:

gcloud config set project <PROJECT_ID>

Output comando

Updated property [core/project].

3. Configurazione dell'ambiente

Prima di poter iniziare a utilizzare Document AI, esegui questo comando in Cloud Shell per abilitare l'API Document AI:

gcloud services enable documentai.googleapis.com

Il risultato dovrebbe essere simile a questo:

Operation "operations/..." finished successfully.

Ora puoi usare Document AI.

Passa alla tua home directory:

cd ~

Crea un ambiente virtuale Python per isolare le dipendenze:

virtualenv venv-docai

Attiva l'ambiente virtuale:

source venv-docai/bin/activate

Installa IPython, la libreria client di Document AI e Python-tabulate (che utilizzerai per stampare il risultato della richiesta):

pip install ipython google-cloud-documentai tabulate

Il risultato dovrebbe essere simile a questo:

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

Ora è tutto pronto per utilizzare la libreria client di Document AI.

Imposta le seguenti variabili di ambiente:

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

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

D'ora in poi, tutti i passaggi dovrebbero essere completati nella stessa sessione.

Assicurati che le variabili di ambiente siano definite correttamente:

echo $PROJECT_ID

echo $API_LOCATION

Nei passaggi successivi, utilizzerai un interprete Python interattivo chiamato IPython, che hai appena installato. Avvia una sessione eseguendo ipython in Cloud Shell:

ipython

Il risultato dovrebbe essere simile a questo:

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]:

Copia il seguente codice nella tua sessione IPython:

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

È tutto pronto per effettuare la prima richiesta e recuperare i tipi di processori.

4. Recupero dei tipi di processore in corso...

Prima di creare un processore nel passaggio successivo, recupera i tipi di processori disponibili. Puoi recuperare questo elenco con fetch_processor_types.

Aggiungi le seguenti funzioni alla sessione Python:

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))

Elenca i tipi di processori:

processor_types = fetch_processor_types()
print_processor_types(processor_types)

Il risultato dovrebbe essere simile al seguente:

+---------------------------------+-------------+----------------+------------+
| 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

Ora hai a disposizione tutte le informazioni necessarie per creare processori nel passaggio successivo.

5. Creazione dei processori

Per creare un processore, chiama create_processor con un nome visualizzato e un tipo di processore.

Aggiungi la funzione seguente:

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)

Crea i processori di test:

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")

Dovresti visualizzare quanto segue:

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

Hai creato nuovi processori.

Ora scopri come elencare i processori.

6. Elenco dei processori di progetto

list_processors restituisce l'elenco di tutti i processori appartenenti al tuo progetto.

Aggiungi le seguenti funzioni:

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)

Richiama le funzioni:

processors = list_processors()
print_processors(processors)

Dovresti visualizzare quanto segue:

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

Per recuperare un processore in base al nome visualizzato, aggiungi la seguente funzione:

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

Testa la funzione:

processor = get_processor(document_ocr_display_name, processors)

assert processor is not None
print(processor)

Il risultato dovrebbe essere simile a questo:

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

Ora sai come elencare i processori del progetto e recuperarli in base ai nomi visualizzati. Ora, scopri come utilizzare un processore.

7. Utilizzo dei processori

I documenti possono essere elaborati in due modi:

In modo sincrono: chiama process_document per analizzare un singolo documento e utilizzare direttamente i risultati.
In modo asincrono: chiama batch_process_documents per avviare un'elaborazione batch su più documenti o su documenti di grandi dimensioni.

Il documento di test ( PDF) è un questionario scansionato e completato con risposte scritte a mano. Scaricalo nella tua directory di lavoro direttamente dalla sessione IPython:

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

Controlla il contenuto della directory di lavoro:

!ls

Dovresti avere quanto segue:

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

Puoi utilizzare il metodo process_document sincrono per analizzare un file locale. Aggiungi la funzione seguente:

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

Poiché il documento è un questionario, scegli il parser del modulo. Oltre a estrarre il testo (stampato e scritto a mano), cosa che tutti i processori fanno, rileva i campi dei moduli.

Analizza il documento:

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)

Tutti i processori eseguono una prima trasmissione del documento con riconoscimento ottico dei caratteri (OCR). Rivedi il testo rilevato dalla tessera OCR:

document.text.split("\n")

Il risultato dovrebbe essere simile al seguente:

['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:',
  ...
]

Aggiungi le seguenti funzioni per stampare i campi del modulo rilevati:

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%}")

Aggiungi anche le seguenti funzioni di utilità:

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

Stampa i campi del modulo rilevati:

print_form_fields(document)

Dovresti ricevere una stampa come la seguente:

+--------------+-------------------------+------------+
|         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

Esamina i nomi e i valori dei campi rilevati ( PDF). Ecco la metà superiore del questionario:

Hai analizzato un modulo che contiene testo sia stampato che scritto a mano. Hai anche rilevato un'elevata affidabilità dei campi. Il risultato è che i pixel sono stati trasformati in dati strutturati.

8. Abilitazione e disabilitazione dei processori

Con disable_processor e enable_processor, puoi stabilire se è possibile usare un processore.

Aggiungi le seguenti funzioni:

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)

Disattiva il processore del parser di moduli e controlla lo stato dei tuoi processori:

processor = get_processor(form_parser_display_name)
assert processor is not None

disable_processor(processor)
print_processors()

Dovresti visualizzare quanto segue:

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

Riattiva il processore del parser di moduli:

enable_processor(processor)
print_processors()

Dovresti visualizzare quanto segue:

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

Ora scopri come gestire le versioni del processore.

9. Gestione delle versioni del processore

I processori possono essere disponibili in più versioni. Scopri come utilizzare i metodi list_processor_versions e set_default_processor_version.

Aggiungi le seguenti funzioni:

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)

Elenca le versioni disponibili per il processore OCR:

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

Ottieni le versioni del processore:

+--------------------------------+--------------------------+---------+
| 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

Ora aggiungi una funzione per modificare la versione predefinita del processore:

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

Passa alla versione più recente del processore:

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)

Ottieni la nuova configurazione della versione:

+--------------------------------+--------------------------+---------+
| 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

Poi c'è il metodo definitivo di gestione del processore (eliminazione).

10. Eliminazione dei processori

Infine, scopri come utilizzare il metodo delete_processor.

Aggiungi la funzione seguente:

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

Elimina i tuoi processori di test:

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()

Dovresti visualizzare quanto segue:

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

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

Hai esaminato tutti i metodi di gestione del processore. Hai quasi finito...

11. Complimenti!

Hai imparato a gestire i processori Document AI utilizzando Python.

Esegui la pulizia

Per ripulire il tuo ambiente di sviluppo, da Cloud Shell:

Se sei ancora nella sessione Python, torna alla shell: exit
Interrompi l'utilizzo dell'ambiente virtuale Python: deactivate
Elimina la cartella dell'ambiente virtuale: cd ~ ; rm -rf ./venv-docai

Per eliminare il tuo progetto Google Cloud, da Cloud Shell:

Recupera il tuo ID progetto attuale: PROJECT_ID=$(gcloud config get-value core/project)
Assicurati che questo sia il progetto che vuoi eliminare: echo $PROJECT_ID
Elimina il progetto: gcloud projects delete $PROJECT_ID

Scopri di più

Prova Document AI nel tuo browser: https://cloud.google.com/document-ai/docs/drag-and-drop
Dettagli del processore Document AI: https://cloud.google.com/document-ai/docs/processors-list
Python su Google Cloud: https://cloud.google.com/python
Librerie client di Cloud per Python: https://github.com/googleapis/google-cloud-python

Licenza

Questo lavoro è concesso in licenza ai sensi di una licenza Creative Commons Attribution 2.0 Generic.