1. Omówienie
Co to jest Document AI?
Document AI to platforma umożliwiająca wyodrębnianie statystyk z dokumentów. Rozszerza się lista procesorów dokumentów (w zależności od ich funkcjonalności nazywane są też parserami lub rozdzielaczami).
Procesorami Document AI możesz zarządzać na 2 sposoby:
- ręcznie w konsoli internetowej,
- w sposób zautomatyzowany za pomocą interfejsu Document AI API.
Oto przykładowy zrzut ekranu przedstawiający listę procesorów – zarówno z konsoli internetowej, jak i z kodu Pythona:
W tym module dowiesz się, jak programowo zarządzać procesorami Document AI przy użyciu biblioteki klienta w języku Python.
Co zobaczysz
- Jak skonfigurować środowisko
- Jak pobrać typy procesorów
- Jak utworzyć procesory
- Jak wyświetlić listę procesorów projektu
- Jak używać procesorów
- Jak włączyć lub wyłączyć procesory
- Jak zarządzać wersjami procesora
- Jak usunąć procesory
Czego potrzebujesz
Ankieta
Jak wykorzystasz ten samouczek?
Jak oceniasz swoje doświadczenia z językiem Python?
Jak oceniasz usługi Google Cloud?
2. Konfiguracja i wymagania
Samodzielne konfigurowanie środowiska
- Zaloguj się w konsoli Google Cloud i utwórz nowy projekt lub wykorzystaj już istniejący. Jeśli nie masz jeszcze konta Gmail ani Google Workspace, musisz je utworzyć.
- Nazwa projektu jest wyświetlaną nazwą uczestników tego projektu. To ciąg znaków, który nie jest używany przez interfejsy API Google. W każdej chwili możesz ją zaktualizować.
- Identyfikator projektu jest unikalny we wszystkich projektach Google Cloud i nie można go zmienić (po jego ustawieniu nie można go zmienić). Cloud Console automatycznie wygeneruje unikalny ciąg znaków. zwykle nieważne, co ona jest. W większości ćwiczeń w Codelabs musisz podać swój identyfikator projektu (zwykle identyfikowany jako
PROJECT_ID). Jeśli nie podoba Ci się wygenerowany identyfikator, możesz wygenerować kolejny losowy. Możesz też spróbować własnych sił i sprawdzić, czy jest dostępna. Po wykonaniu tej czynności nie można jej już zmienić. Pozostanie ona przez cały czas trwania projektu. - Jest jeszcze trzecia wartość, numer projektu, z którego korzystają niektóre interfejsy API. Więcej informacji o wszystkich 3 wartościach znajdziesz w dokumentacji.
- Następnie musisz włączyć płatności w Cloud Console, aby korzystać z zasobów Cloud/interfejsów API. Ukończenie tego ćwiczenia z programowania nic nie kosztuje. Aby wyłączyć zasoby w celu uniknięcia naliczania opłat po zakończeniu tego samouczka, możesz usunąć utworzone zasoby lub projekt. Nowi użytkownicy Google Cloud mogą skorzystać z programu bezpłatnego okresu próbnego o wartości 300 USD.
Uruchamianie Cloud Shell
Google Cloud można sterować zdalnie z laptopa, ale w tym module użyjesz Cloud Shell – środowiska wiersza poleceń działającego w Cloud.
Aktywowanie Cloud Shell
- W konsoli Cloud kliknij Aktywuj Cloud Shell
.
Jeśli uruchamiasz Cloud Shell po raz pierwszy, zobaczysz ekran pośredni z opisem tej usługi. Jeśli wyświetlił się ekran pośredni, kliknij Dalej.
Uzyskanie dostępu do Cloud Shell i połączenie się z nim powinno zająć tylko kilka chwil.
Ta maszyna wirtualna ma wszystkie potrzebne narzędzia dla programistów. Zawiera stały katalog domowy o pojemności 5 GB i działa w Google Cloud, co znacznie zwiększa wydajność sieci i uwierzytelnianie. Większość zadań w ramach tego ćwiczenia z programowania można wykonać w przeglądarce.
Po nawiązaniu połączenia z Cloud Shell powinno pojawić się potwierdzenie, że użytkownik jest uwierzytelniony, a projekt jest ustawiony na identyfikator Twojego projektu.
- Uruchom to polecenie w Cloud Shell, aby potwierdzić, że jesteś uwierzytelniony:
gcloud auth list
Dane wyjściowe polecenia
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
- Uruchom to polecenie w Cloud Shell, aby sprawdzić, czy polecenie gcloud zna Twój projekt:
gcloud config list project
Dane wyjściowe polecenia
[core] project = <PROJECT_ID>
Jeśli tak nie jest, możesz go ustawić za pomocą tego polecenia:
gcloud config set project <PROJECT_ID>
Dane wyjściowe polecenia
Updated property [core/project].
3. Konfiguracja środowiska
Zanim zaczniesz korzystać z Document AI, uruchom w Cloud Shell to polecenie, aby włączyć interfejs Document AI API:
gcloud services enable documentai.googleapis.com
Powinien pojawić się ekran podobny do tego:
Operation "operations/..." finished successfully.
Teraz możesz korzystać z Document AI.
Przejdź do katalogu głównego:
cd ~
Utwórz środowisko wirtualne Pythona, aby wyizolować zależności:
virtualenv venv-docai
Aktywuj środowisko wirtualne:
source venv-docai/bin/activate
Zainstaluj program IPython, bibliotekę klienta Document AI i narzędzie Python-tabulation (które będą używane do uatrakcyjniania wyników żądania):
pip install ipython google-cloud-documentai tabulate
Powinien pojawić się ekran podobny do tego:
... Installing collected packages: ..., tabulate, ipython, google-cloud-documentai Successfully installed ... google-cloud-documentai-2.15.0 ...
Możesz teraz korzystać z biblioteki klienta Document AI.
Ustaw te zmienne środowiskowe:
export PROJECT_ID=$(gcloud config get-value core/project)
# Choose "us" or "eu" export API_LOCATION="us"
Od teraz wszystkie czynności należy wykonać w ramach tej samej sesji.
Upewnij się, że zmienne środowiskowe są prawidłowo zdefiniowane:
echo $PROJECT_ID
echo $API_LOCATION
W następnych krokach użyjesz już zainstalowanego interaktywnego interpretera języka Python o nazwie IPython. Rozpocznij sesję od uruchomienia ipython w Cloud Shell:
ipython
Powinien pojawić się ekran podobny do tego:
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]:
Skopiuj ten kod do sesji 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
Możesz wykonać pierwsze żądanie i pobrać typy procesorów.
4. Pobieram typy procesorów
Zanim utworzysz procesor, pobierz dostępne typy procesorów. Możesz pobrać tę listę za pomocą usługi fetch_processor_types.
Dodaj do sesji IPython te funkcje:
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))
Wyświetl typy procesorów:
processor_types = fetch_processor_types()
print_processor_types(processor_types)
Powinien pojawić się następujący komunikat:
+---------------------------------+-------------+----------------+------------+ | 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
Masz teraz wszystkie informacje potrzebne do utworzenia procesorów w następnym kroku.
5. Tworzę procesory
Aby utworzyć procesor, wywołaj funkcję create_processor, podając wyświetlaną nazwę i typ procesora.
Dodaj tę funkcję:
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)
Utwórz procesory testowe:
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")
Powinien pojawić się następujący komunikat:
================================================================================ Creating document-ocr (OCR_PROCESSOR)... ================================================================================ Creating form-parser (FORM_PARSER_PROCESSOR)... ================================================================================ Done
Utworzono nowe procesory.
Następnie zobacz, jak wyświetlić listę procesorów.
6. Wyświetlanie listy procesorów projektu
list_processors zwraca listę wszystkich procesorów należących do projektu.
Dodaj te funkcje:
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)
Wywołaj funkcje:
processors = list_processors()
print_processors(processors)
Powinien pojawić się następujący komunikat:
+--------------+-----------------------+---------+ | display_name | type | state | +--------------+-----------------------+---------+ | document-ocr | OCR_PROCESSOR | ENABLED | | form-parser | FORM_PARSER_PROCESSOR | ENABLED | +--------------+-----------------------+---------+ → Processors: 2
Aby pobierać procesor według jego wyświetlanej nazwy, dodaj tę funkcję:
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
Przetestuj funkcję:
processor = get_processor(document_ocr_display_name, processors)
assert processor is not None
print(processor)
Powinien pojawić się ekran podobny do tego:
name: "projects/PROJECT_NUM/locations/LOCATION/processors/PROCESSOR_ID" type_: "OCR_PROCESSOR" display_name: "document-ocr" state: ENABLED ...
Wiesz już, jak wyświetlić procesory projektu i pobrać je według wyświetlanych nazw. Następnie, dowiedz się, jak korzystać z procesora.
7. Korzystanie z procesorów
Dokumenty można przetwarzać na 2 sposoby:
- Synchronicznie: wywołaj
process_document, aby przeanalizować pojedynczy dokument i bezpośrednio użyć wyników. - Asynchronicznie: wywołaj
batch_process_documents, aby uruchomić przetwarzanie wsadowe wielu dokumentów lub dużych dokumentów.
Dokument testowy ( PDF) to zeskanowany kwestionariusz uzupełniony odręcznymi odpowiedziami. Pobierz go do katalogu roboczego bezpośrednio z sesji IPython:
!gsutil cp gs://cloud-samples-data/documentai/form.pdf .
Sprawdź zawartość katalogu roboczego:
!ls
Najważniejsze są te elementy:
... form.pdf ... venv-docai ...
Do analizowania plików lokalnych możesz użyć synchronicznej metody process_document. Dodaj tę funkcję:
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
Ponieważ dokument jest kwestionariuszem, wybierz parser formularzy. Oprócz wyodrębniania tekstu (drukowanego i napisanego odręcznie), co robi wszystkie procesory, ten ogólny procesor wykrywa pola formularza.
Przeanalizuj 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)
Wszystkie procesory najpierw przechodzą w dokumencie za pomocą optycznego rozpoznawania znaków (OCR). Sprawdź tekst wykryty przez OCR:
document.text.split("\n")
Strona powinna wyglądać mniej więcej tak:
['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:',
...
]
Aby wydrukować wykryte pola formularza, dodaj te funkcje:
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%}")
Dodaj też te funkcje narzędziowe:
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
Wydrukuj wykryte pola formularza:
print_form_fields(document)
Powinien pojawić się następujący wydruk:
+--------------+-------------------------+------------+ | 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
Sprawdź nazwy pól i wykryte wartości ( PDF). Oto górna część kwestionariusza:
Przeanalizowałeś(-aś) formularz zawierający tekst zarówno drukowany, jak i odręczny. Udało Ci się też wykryć jego pola z wysoką pewnością. Efektem jest to, że piksele zostały przekształcone w uporządkowane dane.
8. Włączanie i wyłączanie procesorów
disable_processor i enable_processor pozwalają określić, czy procesor może być używany.
Dodaj te funkcje:
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)
Wyłącz procesor parsera formularzy i sprawdź stan procesorów:
processor = get_processor(form_parser_display_name)
assert processor is not None
disable_processor(processor)
print_processors()
Powinien pojawić się następujący komunikat:
+--------------+-----------------------+----------+ | display_name | type | state | +--------------+-----------------------+----------+ | document-ocr | OCR_PROCESSOR | ENABLED | | form-parser | FORM_PARSER_PROCESSOR | DISABLED | +--------------+-----------------------+----------+ → Processors: 2
Ponownie włącz procesor parsera formularzy:
enable_processor(processor)
print_processors()
Powinien pojawić się następujący komunikat:
+--------------+-----------------------+---------+ | display_name | type | state | +--------------+-----------------------+---------+ | document-ocr | OCR_PROCESSOR | ENABLED | | form-parser | FORM_PARSER_PROCESSOR | ENABLED | +--------------+-----------------------+---------+ → Processors: 2
W następnej kolejności zobacz, jak zarządzać wersjami procesora.
9. Zarządzanie wersjami procesora
Procesory mogą być dostępne w różnych wersjach. Dowiedz się, jak używać metod list_processor_versions i set_default_processor_version.
Dodaj te funkcje:
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)
Wyświetl listę dostępnych wersji procesora OCR:
processor = get_processor(document_ocr_display_name)
assert processor is not None
print_processor_versions(processor)
Widoczne są te wersje procesora:
+--------------------------------+--------------------------+---------+ | 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
Teraz dodaj funkcję, która zmienia domyślną wersję procesora:
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
Przejdź na najnowszą wersję procesora:
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)
Otrzymasz nową konfigurację wersji:
+--------------------------------+--------------------------+---------+ | 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
Następna jest najlepsza metoda zarządzania procesorem (usuwanie).
10. Usuwam procesory
Na koniec dowiedz się, jak używać metody delete_processor.
Dodaj tę funkcję:
def delete_processor(processor: docai.Processor):
client = get_client()
operation = client.delete_processor(name=processor.name)
operation.result() # Wait for operation to complete
Usuń procesory testowe:
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()
Powinien pojawić się następujący komunikat:
Deleting processors... Deleting form-parser... Deleting document-ocr... Done +--------------+------+-------+ | display_name | type | state | +--------------+------+-------+ | - | - | - | +--------------+------+-------+ → Processors: 0
Udało Ci się poznać wszystkie metody zarządzania procesorami. Prawie gotowe...
11. Gratulacje!
Wiesz już, jak zarządzać procesorami Document AI za pomocą Pythona.
Czyszczenie danych
Aby wyczyścić środowisko programistyczne, wykonaj te czynności w Cloud Shell:
- Jeśli nadal jesteś w sesji IPython, wróć do powłoki:
exit - Przestań używać środowiska wirtualnego Pythona:
deactivate - Usuń folder środowiska wirtualnego:
cd ~ ; rm -rf ./venv-docai
Aby usunąć projekt Google Cloud z Cloud Shell:
- Pobierz bieżący identyfikator projektu:
PROJECT_ID=$(gcloud config get-value core/project) - Sprawdź, czy to jest projekt, który chcesz usunąć:
echo $PROJECT_ID - Usuń projekt:
gcloud projects delete $PROJECT_ID
Więcej informacji
- Wypróbuj Document AI w przeglądarce: https://cloud.google.com/document-ai/docs/drag-and-drop
- Informacje o procesorze Document AI: https://cloud.google.com/document-ai/docs/processors-list
- Python w Google Cloud: https://cloud.google.com/python
- Biblioteki klienta Cloud dla Pythona: https://github.com/googleapis/google-cloud-python
Licencja
To zadanie jest licencjonowane na podstawie ogólnej licencji Creative Commons Attribution 2.0.