Bu sayfa, Cloud Translation API ile çevrilmiştir.

Python ile Document AI işlemcilerini yönetme

1. Genel Bakış

Document AI nedir?

Document AI, belgelerinizden analiz elde etmenizi sağlayan bir platformdur. Temelde, gittikçe büyüyen bir belge işlemci listesi (işlevlerine bağlı olarak ayrıştırıcı veya ayırıcı olarak da adlandırılır) sunulmaktadır.

Document AI işlemcilerini yönetmenin iki yolu vardır:

manuel olarak web konsolundan;
Böylece, Project AI API'sini kullanabilirsiniz.

Hem web konsolundan hem de Python kodundaki işlemci listenizi gösteren örnek bir ekran görüntüsünü burada bulabilirsiniz:

Bu laboratuvarda, Python istemci kitaplığıyla Document AI işlemcilerini programatik olarak yönetmeye odaklanacaksınız.

Neler göreceksiniz?

Ortamınızı ayarlama
İşlemci türlerini getirme
İşleyen oluşturma
Proje işleyicilerini listeleme
İşlemcileri kullanma
İşlemcileri etkinleştirme/devre dışı bırakma
İşlemci sürümlerini yönetme
İşleyenleri silme

Gerekenler

Bir Google Cloud projesi
Chrome veya Firefox gibi bir tarayıcı
Python kullanımı hakkında bilgi

Anket

Bu eğiticiden nasıl yararlanacaksınız?

Yalnızca okuma

Okuyun ve alıştırmaları tamamlayın

Python deneyiminizi nasıl değerlendirirsiniz?

Acemi

Orta

Yeterli

Google Cloud hizmetleriyle ilgili deneyiminizi nasıl değerlendirirsiniz?

Acemi

Orta

Yeterli

2. Kurulum ve şartlar

Kendi hızınızda ortam kurulumu

Google Cloud Console'da oturum açıp yeni bir proje oluşturun veya mevcut bir projeyi yeniden kullanın. Gmail veya Google Workspace hesabınız yoksa hesap oluşturmanız gerekir.

Proje adı, bu projenin katılımcıları için görünen addır. Google API'leri tarafından kullanılmayan bir karakter dizesidir. İstediğiniz zaman güncelleyebilirsiniz.
Proje Kimliği, tüm Google Cloud projelerinde benzersizdir ve değiştirilemez (belirlendikten sonra değiştirilemez). Cloud Console, otomatik olarak benzersiz bir dize oluşturur. bunun ne olduğunu umursamıyorsunuz. Çoğu codelab'de proje kimliğinizi (genellikle PROJECT_ID olarak tanımlanır) belirtmeniz gerekir. Oluşturulan kimliği beğenmezseniz rastgele bir kimlik daha oluşturabilirsiniz. Alternatif olarak, kendi ölçümünüzü deneyip mevcut olup olmadığına bakabilirsiniz. Bu adımdan sonra değiştirilemez ve proje süresince kalır.
Bilginiz olması açısından, bazı API'lerin kullandığı üçüncü bir değer, yani Proje Numarası daha vardır. Bu değerlerin üçü hakkında daha fazla bilgiyi belgelerde bulabilirsiniz.

Sonraki adımda, Cloud kaynaklarını/API'lerini kullanmak için Cloud Console'da faturalandırmayı etkinleştirmeniz gerekir. Bu codelab'i çalıştırmanın maliyeti, yüksek değildir. Bu eğitim dışında faturalandırmanın tekrarlanmasını önlemek amacıyla kaynakları kapatmak için oluşturduğunuz kaynakları silebilir veya projeyi silebilirsiniz. Yeni Google Cloud kullanıcıları 300 ABD doları değerindeki ücretsiz denemeden yararlanabilir.

Cloud Shell'i başlatma

Google Cloud dizüstü bilgisayarınızdan uzaktan çalıştırılabilse de bu laboratuvarda, Cloud'da çalışan bir komut satırı ortamı olan Cloud Shell'i kullanacaksınız.

Cloud Shell'i etkinleştirme

Cloud Console'da, Cloud Shell'i etkinleştir simgesini tıklayın.

Cloud Shell'i ilk kez başlatıyorsanız ne olduğunu açıklayan bir ara ekran gösterilir. Ara bir ekran görüntülendiyse Devam'ı tıklayın.

Temel hazırlık ve Cloud Shell'e bağlanmak yalnızca birkaç dakika sürer.

Gereken tüm geliştirme araçları bu sanal makinede yüklüdür. 5 GB boyutunda kalıcı bir ana dizin sunar ve Google Cloud'da çalışarak ağ performansını ve kimlik doğrulamasını büyük ölçüde iyileştirir. Bu codelab'deki çalışmalarınızın tamamı olmasa bile büyük bir kısmı tarayıcıyla yapılabilir.

Cloud Shell'e bağlandıktan sonra kimliğinizin doğrulandığını ve projenin proje kimliğinize ayarlandığını göreceksiniz.

Kimlik doğrulamanızın tamamlandığını onaylamak için Cloud Shell'de aşağıdaki komutu çalıştırın:

gcloud auth list

Komut çıkışı

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

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

gcloud komutunun projenizi bildiğini onaylamak için Cloud Shell'de aşağıdaki komutu çalıştırın:

gcloud config list project

Komut çıkışı

[core]
project = <PROJECT_ID>

Doğru değilse aşağıdaki komutla ayarlayabilirsiniz:

gcloud config set project <PROJECT_ID>

Komut çıkışı

Updated property [core/project].

3. Ortam kurulumu

Document AI'yı kullanmaya başlamadan önce Document AI API'yi etkinleştirmek için Cloud Shell'de aşağıdaki komutu çalıştırın:

gcloud services enable documentai.googleapis.com

Aşağıdakine benzer bir tablo görürsünüz:

Operation "operations/..." finished successfully.

Artık Document AI'ı kullanabilirsiniz.

Ana dizininize gidin:

cd ~

Bağımlılıkları izole etmek için bir Python sanal ortamı oluşturun:

virtualenv venv-docai

Sanal ortamı etkinleştirin:

source venv-docai/bin/activate

IPython, Document AI istemci kitaplığı ve python-tabulate'i (istek sonuçlarını güzel bir şekilde yazdırmak için kullanacağınız) yükleyin:

pip install ipython google-cloud-documentai tabulate

Aşağıdakine benzer bir tablo görürsünüz:

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

Artık Document AI istemci kitaplığını kullanmaya hazırsınız.

Aşağıdaki ortam değişkenlerini ayarlayın:

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

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

Artık tüm adımlar aynı oturumda tamamlanacaktır.

Ortam değişkenlerinizin doğru bir şekilde tanımlandığından emin olun:

echo $PROJECT_ID

echo $API_LOCATION

Sonraki adımlarda, az önce yüklediğiniz IPython adlı etkileşimli bir Python çeviriciyi kullanacaksınız. Cloud Shell'de ipython çalıştırarak oturum başlatın:

ipython

Aşağıdakine benzer bir tablo görürsünüz:

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

Aşağıdaki kodu IPython oturumunuza kopyalayın:

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

İlk isteğinizi yapmaya ve işlemci türlerini getirmeye hazırsınız.

4. İşlemci türleri getiriliyor

Sonraki adımda işlemci oluşturmadan önce mevcut işlemci türlerini getirin. Bu listeyi fetch_processor_types ile alabilirsiniz.

IPython oturumunuza aşağıdaki işlevleri ekleyin:

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

İşlemci türlerini listeleyin:

processor_types = fetch_processor_types()
print_processor_types(processor_types)

Aşağıdaki gibi bir sonuç alırsınız:

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

İşlemci oluşturmak için gereken tüm bilgilere bir sonraki adımda sahip olacaksınız.

5. İşleyen oluşturma

İşleyen oluşturmak için görünen ad ve işlemci türüyle create_processor çağrısı yapın.

Aşağıdaki işlevi ekleyin:

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)

Test işlemcilerini oluşturun:

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

Aşağıdaki bilgileri almanız gerekir:

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

Yeni işlemciler oluşturdunuz.

Ardından işlemcileri nasıl listeleyeceğinizi öğrenin.

6. Proje işleyicilerini listeleme

list_processors, projenize ait tüm işleyenlerin listesini döndürür.

Aşağıdaki işlevleri ekleyin:

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)

İşlevleri çağırın:

processors = list_processors()
print_processors(processors)

Aşağıdaki bilgileri almanız gerekir:

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

Bir işlemciyi görünen adıyla almak için aşağıdaki işlevi ekleyin:

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

İşlevi test edin:

processor = get_processor(document_ocr_display_name, processors)

assert processor is not None
print(processor)

Aşağıdakine benzer bir tablo görürsünüz:

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

Artık proje işleyenlerinizi nasıl listeleyeceğinizi ve görünen adlarıyla nasıl alabileceğinizi biliyorsunuz. Daha sonra işlemcinin nasıl kullanılacağını öğrenin.

7. İşlemcileri kullanma

Dokümanlar iki şekilde işlenebilir:

Eşzamanlı: Tek bir dokümanı analiz etmek ve sonuçları doğrudan kullanmak için process_document komutunu çağırın.
Eşzamansız: Birden fazla veya büyük doküman üzerinde toplu işlem başlatmak için batch_process_documents öğesini çağırın.

Test belgeniz ( PDF), elle yazılmış cevaplarla doldurulan taranmış bir ankettir. Dosyayı, doğrudan IPython oturumunuzdan çalışma dizininize indirin:

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

Çalışma dizininizin içeriğini kontrol edin:

!ls

Aşağıdakilere sahip olmanız gerekir:

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

Yerel bir dosyayı analiz etmek için eşzamanlı process_document yöntemini kullanabilirsiniz. Aşağıdaki işlevi ekleyin:

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

Belgeniz bir anket olduğundan form ayrıştırıcıyı seçin. Bu genel işlemci, tüm işlemcilerin yaptığı metinleri (yazılmış ve el yazısı) çıkarmanın yanı sıra form alanlarını da algılar.

Dokümanı analiz edin:

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)

Tüm işleyenler dokümanda ilk olarak optik karakter tanıma (OCR) işleminden geçer. OCR kartı tarafından algılanan metni inceleyin:

document.text.split("\n")

Aşağıdaki gibi bir sonuç görmeniz gerekir:

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

Algılanan form alanlarını yazdırmak için aşağıdaki işlevleri ekleyin:

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

Şu yardımcı program işlevlerini de ekleyin:

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

Algılanan form alanlarını yazdır:

print_form_fields(document)

Aşağıdaki gibi bir çıktı alırsınız:

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

Algılanan alan adlarını ve değerleri inceleyin ( PDF). Anketin üst yarısını aşağıda görebilirsiniz:

Hem basılı hem de el yazısı metin içeren bir formu analiz ettiniz. Ayrıca, alanlarını yüksek güvenilirlikle tespit ettiniz. Sonuç olarak pikselleriniz yapılandırılmış verilere dönüştürülür.

8. İşlemcileri etkinleştirme ve devre dışı bırakma

disable_processor ve enable_processor ile bir işlemcinin kullanılıp kullanılamayacağını kontrol edebilirsiniz.

Aşağıdaki işlevleri ekleyin:

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)

Form ayrıştırıcı işlemcisini devre dışı bırakın ve işlemcilerinizin durumunu kontrol edin:

processor = get_processor(form_parser_display_name)
assert processor is not None

disable_processor(processor)
print_processors()

Aşağıdaki bilgileri almanız gerekir:

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

Form ayrıştırıcı işlemcisini yeniden etkinleştirin:

enable_processor(processor)
print_processors()

Aşağıdaki bilgileri almanız gerekir:

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

Daha sonra, işlemci sürümlerini nasıl yöneteceğinizi öğrenin.

9. İşlemci sürümlerini yönetme

İşlemcilerin çeşitli versiyonları olabilir. list_processor_versions ve set_default_processor_version yöntemlerinin nasıl kullanılacağına göz atın.

Aşağıdaki işlevleri ekleyin:

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)

OCR işlemcisinin kullanılabildiği sürümleri listeleyin:

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

İşlemci sürümleri aşağıdaki gibi olur:

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

Şimdi, varsayılan işlemci sürümünü değiştirmek için bir işlev ekleyin:

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

En son işlemci sürümüne geçin:

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)

Yeni sürüm yapılandırmasını edinirsiniz:

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

Bir sonraki adımda, en üst düzey işleyen yönetim yöntemi (silme) olacak.

10. İşleyenleri silme

Son olarak, delete_processor yönteminin nasıl kullanılacağına göz atın.

Aşağıdaki işlevi ekleyin:

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

Test işlemcilerinizi silin:

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

Aşağıdaki bilgileri almanız gerekir:

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

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

Tüm işlemci yönetimi yöntemlerini ele aldınız. Çok az kaldı...

11. Tebrikler!

Python kullanarak Document AI işlemcilerini nasıl yöneteceğinizi öğrendiniz.

Temizleme

Geliştirme ortamınızı temizlemek için Cloud Shell'den:

Hâlâ IPython oturumunuzdaysanız kabuğa geri dönün: exit
Python sanal ortamını kullanmayı bırakın: deactivate
Sanal ortam klasörünüzü silin: cd ~ ; rm -rf ./venv-docai

Google Cloud projenizi Cloud Shell'den silmek için:

Geçerli proje kimliğinizi alın: PROJECT_ID=$(gcloud config get-value core/project)
Silmek istediğiniz projenin bu proje olduğundan emin olun: echo $PROJECT_ID
Projeyi silin: gcloud projects delete $PROJECT_ID

Daha fazla bilgi

Tarayıcınızda Document AI'yı deneyin: https://cloud.google.com/document-ai/docs/drag-and-drop
Belge AI işlemcisi ayrıntıları: https://cloud.google.com/document-ai/docs/processors-list
Google Cloud'da Python: https://cloud.google.com/python
Python için Cloud İstemci Kitaplıkları: https://github.com/googleapis/google-cloud-python

Lisans

Bu çalışma, Creative Commons Attribution 2.0 Genel Amaçlı Lisans ile lisans altına alınmıştır.