Udostępnij za pośrednictwem

Biblioteka klienta usługi Azure Form Recognizer dla języka Python — wersja 3.3.2

  • Artykuł

Azure Document Intelligence (wcześniej znana jako Form Recognizer) to usługa w chmurze, która korzysta z uczenia maszynowego do analizowania tekstu i danych strukturalnych z dokumentów. Zawiera ona następujące główne funkcje:

  • Układ — wyodrębnianie zawartości i struktury (np. wyrazów, znaczników zaznaczenia, tabel) z dokumentów.
  • Dokument — analizowanie par klucz-wartość oprócz ogólnego układu z dokumentów.
  • Odczyt — odczyt informacji o stronie z dokumentów.
  • Wstępnie utworzone — wyodrębnianie wspólnych wartości pól z wybranych typów dokumentów (np. paragonów, faktur, wizytówek, dokumentów identyfikacyjnych, dokumentów podatkowych w USA W-2, między innymi) przy użyciu wstępnie utworzonych modeli.
  • Niestandardowe — twórz modele niestandardowe z własnych danych, aby wyodrębniać dostosowane wartości pól oprócz ogólnego układu z dokumentów.
  • Klasyfikatory — twórz niestandardowe modele klasyfikacji, które łączą funkcje układu i języka w celu dokładnego wykrywania i identyfikowania dokumentów przetwarzanych w aplikacji.
  • Możliwości dodatku — wyodrębnianie kodów kreskowych/kodów QR, formuł, czcionki/stylu itp. lub włączanie trybu wysokiej rozdzielczości dla dużych dokumentów z opcjonalnymi parametrami.

Kod | źródłowyPakiet (PyPI) | Pakiet (Conda) | Dokumentacja referencyjna interfejsu | APIDokumentacja | produktuPróbki

Wprowadzenie

Wymagania wstępne

Instalowanie pakietu

Zainstaluj bibliotekę klienta usługi Azure Form Recognizer dla języka Python przy użyciu narzędzia pip:

pip install azure-ai-formrecognizer

Uwaga: ta wersja biblioteki klienta jest domyślnie ustawiona na 2023-07-31 wersję usługi.

W tej tabeli przedstawiono relację między wersjami zestawu SDK i obsługiwanymi wersjami interfejsu API usługi:

Wersja zestawu SDK Obsługiwana wersja usługi interfejsu API
3.3.X — najnowsza wersja ogólnie dostępna 2.0, 2.1, 2022-08-31, 2023-07-31 (ustawienie domyślne)
3.2.X 2.0, 2.1, 2022-08-31 (ustawienie domyślne)
3.1.X 2.0, 2.1 (ustawienie domyślne)
3.0.0 2.0

Uwaga: począwszy od wersji 3.2.Xwprowadzono nowy zestaw klientów korzystających z najnowszych funkcji usługi Analizy dokumentów. Aby uzyskać szczegółowe instrukcje dotyczące aktualizowania kodu aplikacji z wersji 3.1.X biblioteki klienta lub starszej do najnowszej wersji, zobacz Przewodnik migracji. Ponadto zobacz dziennik zmian , aby uzyskać bardziej szczegółowe informacje. W poniższej tabeli opisano relację poszczególnych klientów i obsługiwanych wersji interfejsu API:

Wersja interfejsu API Obsługiwani klienci
2023-07-31 DocumentAnalysisClient i DocumentModelAdministrationClient
2022-08-31 DocumentAnalysisClient i DocumentModelAdministrationClient
2.1 FormRecognizerClient i FormTrainingClient
2.0 FormRecognizerClient i FormTrainingClient

Tworzenie zasobu usług Cognitive Services lub Form Recognizer

Analiza dokumentów obsługuje zarówno dostęp do wielu usług, jak i z jedną usługą. Utwórz zasób usług Cognitive Services, jeśli planujesz dostęp do wielu usług Cognitive Services w ramach jednego punktu końcowego/klucza. W przypadku dostępu tylko do analizy dokumentów utwórz zasób Form Recognizer. Należy pamiętać, że jeśli zamierzasz używać uwierzytelniania usługi Azure Active Directory, potrzebny będzie zasób z jedną usługą.

Możesz utworzyć dowolny zasób przy użyciu:

Poniżej przedstawiono przykład tworzenia zasobu Form Recognizer przy użyciu interfejsu wiersza polecenia:

# Create a new resource group to hold the Form Recognizer resource
# if using an existing resource group, skip this step
az group create --name <your-resource-name> --location <location>

# Create form recognizer
az cognitiveservices account create \
    --name <your-resource-name> \
    --resource-group <your-resource-group-name> \
    --kind FormRecognizer \
    --sku <sku> \
    --location <location> \
    --yes

Aby uzyskać więcej informacji na temat tworzenia zasobu lub sposobu uzyskiwania informacji o lokalizacji i jednostce SKU, zobacz tutaj.

Uwierzytelnianie klienta

Aby wchodzić w interakcje z usługą Analizy dokumentów, należy utworzyć wystąpienie klienta. Punkt końcowy i poświadczenia są niezbędne do utworzenia wystąpienia obiektu klienta.

Uzyskiwanie punktu końcowego

Punkt końcowy zasobu Form Recognizer można znaleźć przy użyciu witryny Azure Portal lub interfejsu wiersza polecenia platformy Azure:

# Get the endpoint for the Form Recognizer resource
az cognitiveservices account show --name "resource-name" --resource-group "resource-group-name" --query "properties.endpoint"

Do uwierzytelniania można użyć regionalnego punktu końcowego lub poddomeny niestandardowej. Są one sformatowane w następujący sposób:

Regional endpoint: https://<region>.api.cognitive.microsoft.com/
Custom subdomain: https://<resource-name>.cognitiveservices.azure.com/

Regionalny punkt końcowy jest taki sam dla każdego zasobu w regionie. Pełną listę obsługiwanych regionalnych punktów końcowych można znaleźć tutaj. Należy pamiętać, że regionalne punkty końcowe nie obsługują uwierzytelniania usługi AAD.

Z drugiej strony niestandardowa poddomena to nazwa unikatowa dla zasobu Form Recognizer. Mogą być używane tylko przez zasoby z jedną usługą.

Pobieranie klucza interfejsu API

Klucz interfejsu API można znaleźć w witrynie Azure Portal lub uruchamiając następujące polecenie interfejsu wiersza polecenia platformy Azure:

az cognitiveservices account keys list --name "<resource-name>" --resource-group "<resource-group-name>"

Tworzenie klienta za pomocą elementu AzureKeyCredential

Aby użyć klucza interfejsu API jako parametru credential , przekaż klucz jako ciąg do wystąpienia obiektu AzureKeyCredential.

from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer import DocumentAnalysisClient

endpoint = "https://<my-custom-subdomain>.cognitiveservices.azure.com/"
credential = AzureKeyCredential("<api_key>")
document_analysis_client = DocumentAnalysisClient(endpoint, credential)

Tworzenie klienta przy użyciu poświadczeń usługi Azure Active Directory

AzureKeyCredential uwierzytelnianie jest używane w przykładach w tym przewodniku wprowadzającym, ale można również uwierzytelniać się w usłudze Azure Active Directory przy użyciu biblioteki azure-identity . Należy pamiętać, że regionalne punkty końcowe nie obsługują uwierzytelniania usługi AAD. Utwórz niestandardową nazwę poddomeny dla zasobu, aby użyć tego typu uwierzytelniania.

Aby użyć poniższego typu DefaultAzureCredential lub innych typów poświadczeń dostarczonych z zestawem Azure SDK, zainstaluj azure-identity pakiet:

pip install azure-identity

Należy również zarejestrować nową aplikację usługi AAD i udzielić dostępu do analizy dokumentów, przypisując "Cognitive Services User" rolę do jednostki usługi.

Po zakończeniu ustaw wartości identyfikatora klienta, identyfikatora dzierżawy i klucza tajnego klienta aplikacji usługi AAD jako zmienne środowiskowe: AZURE_CLIENT_ID, AZURE_TENANT_ID. AZURE_CLIENT_SECRET

"""DefaultAzureCredential will use the values from these environment
variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET
"""
from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.identity import DefaultAzureCredential

endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
credential = DefaultAzureCredential()

document_analysis_client = DocumentAnalysisClient(endpoint, credential)

Kluczowe pojęcia

DocumentAnalysisClient

DocumentAnalysisClient Udostępnia operacje analizowania dokumentów wejściowych przy użyciu wstępnie utworzonych i niestandardowych modeli za pośrednictwem interfejsów begin_analyze_document API i begin_analyze_document_from_url . Użyj parametru , model_id aby wybrać typ modelu do analizy. Zobacz pełną listę obsługiwanych modeli tutaj. Udostępnia DocumentAnalysisClient również operacje klasyfikowania dokumentów za pośrednictwem interfejsów begin_classify_document API i begin_classify_document_from_url . Niestandardowe modele klasyfikacji mogą klasyfikować każdą stronę w pliku wejściowym, aby identyfikować dokumenty w obrębie programu , a także identyfikować wiele dokumentów lub wiele wystąpień pojedynczego dokumentu w pliku wejściowym.

Przykładowe fragmenty kodu są udostępniane w celu zilustrowania przykładów documentAnalysisClient tutaj. Więcej informacji na temat analizowania dokumentów, w tym obsługiwanych funkcji, ustawień regionalnych i typów dokumentów, można znaleźć w dokumentacji usługi.

DocumentModelAdministrationClient

DocumentModelAdministrationClient udostępnia operacje dla:

  • Tworzenie modeli niestandardowych w celu analizowania określonych pól określonych przez etykietowanie dokumentów niestandardowych. Zwracany DocumentModelDetails jest element wskazujący typy dokumentów, które model może analizować, a także szacowaną pewność dla każdego pola. Zapoznaj się z dokumentacją usługi , aby uzyskać bardziej szczegółowe wyjaśnienie.
  • Tworzenie złożonego modelu na podstawie kolekcji istniejących modeli.
  • Zarządzanie modelami utworzonymi na koncie.
  • Wyświetlanie listy operacji lub pobieranie określonej operacji modelu utworzonej w ciągu ostatnich 24 godzin.
  • Kopiowanie modelu niestandardowego z jednego zasobu Form Recognizer do innego.
  • Tworzenie niestandardowego modelu klasyfikacji i zarządzanie nim w celu klasyfikowania dokumentów przetwarzanych w aplikacji.

Należy pamiętać, że modele można również tworzyć przy użyciu graficznego interfejsu użytkownika, takiego jak Document Intelligence Studio.

Przykładowe fragmenty kodu są udostępniane w celu zilustrowania przykładów documentModelAdministrationClient tutaj.

Długotrwałe operacje

Długotrwałe operacje to operacje, które składają się z początkowego żądania wysłanego do usługi w celu uruchomienia operacji, a następnie sondowania usługi w odstępach czasu w celu ustalenia, czy operacja została ukończona, czy nie powiodła się, a jeśli zakończyła się pomyślnie, aby uzyskać wynik.

Metody analizujące dokumenty, modele kompilacji lub modele kopiowania/tworzenia są modelowane jako długotrwałe operacje. Klient uwidacznia metodę zwracającą begin_<method-name> obiekt LROPoller lub AsyncLROPoller. Obiekt wywołujący powinien czekać na ukończenie operacji przez wywołanie result() obiektu poller zwróconego begin_<method-name> z metody . Przykładowe fragmenty kodu są udostępniane w celu zilustrowania użycia długotrwałych operacji poniżej.

Przykłady

W poniższej sekcji przedstawiono kilka fragmentów kodu obejmujących niektóre z najbardziej typowych zadań analizy dokumentów, w tym:

Wyodrębnianie układu

Wyodrębnij tekst, znaczniki zaznaczenia, style tekstu i struktury tabel wraz ze współrzędnymi regionów powiązanych z dokumentami.

from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer import DocumentAnalysisClient

endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
key = os.environ["AZURE_FORM_RECOGNIZER_KEY"]

document_analysis_client = DocumentAnalysisClient(
    endpoint=endpoint, credential=AzureKeyCredential(key)
)
with open(path_to_sample_documents, "rb") as f:
    poller = document_analysis_client.begin_analyze_document(
        "prebuilt-layout", document=f
    )
result = poller.result()

for idx, style in enumerate(result.styles):
    print(
        "Document contains {} content".format(
            "handwritten" if style.is_handwritten else "no handwritten"
        )
    )

for page in result.pages:
    print("----Analyzing layout from page #{}----".format(page.page_number))
    print(
        "Page has width: {} and height: {}, measured with unit: {}".format(
            page.width, page.height, page.unit
        )
    )

    for line_idx, line in enumerate(page.lines):
        words = line.get_words()
        print(
            "...Line # {} has word count {} and text '{}' within bounding polygon '{}'".format(
                line_idx,
                len(words),
                line.content,
                line.polygon,
            )
        )

        for word in words:
            print(
                "......Word '{}' has a confidence of {}".format(
                    word.content, word.confidence
                )
            )

    for selection_mark in page.selection_marks:
        print(
            "...Selection mark is '{}' within bounding polygon '{}' and has a confidence of {}".format(
                selection_mark.state,
                selection_mark.polygon,
                selection_mark.confidence,
            )
        )

for table_idx, table in enumerate(result.tables):
    print(
        "Table # {} has {} rows and {} columns".format(
            table_idx, table.row_count, table.column_count
        )
    )
    for region in table.bounding_regions:
        print(
            "Table # {} location on page: {} is {}".format(
                table_idx,
                region.page_number,
                region.polygon,
            )
        )
    for cell in table.cells:
        print(
            "...Cell[{}][{}] has content '{}'".format(
                cell.row_index,
                cell.column_index,
                cell.content,
            )
        )
        for region in cell.bounding_regions:
            print(
                "...content on page {} is within bounding polygon '{}'".format(
                    region.page_number,
                    region.polygon,
                )
            )

print("----------------------------------------")

Korzystanie z ogólnego modelu dokumentów

Przeanalizuj pary klucz-wartość, tabele, style i znaczniki wyboru z dokumentów przy użyciu ogólnego modelu dokumentu dostarczonego przez usługę Analizy dokumentów. Wybierz ogólny model dokumentów, przekazując model_id="prebuilt-document" metodę begin_analyze_document :

from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer import DocumentAnalysisClient

endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
key = os.environ["AZURE_FORM_RECOGNIZER_KEY"]

document_analysis_client = DocumentAnalysisClient(
    endpoint=endpoint, credential=AzureKeyCredential(key)
)
with open(path_to_sample_documents, "rb") as f:
    poller = document_analysis_client.begin_analyze_document(
        "prebuilt-document", document=f
    )
result = poller.result()

for style in result.styles:
    if style.is_handwritten:
        print("Document contains handwritten content: ")
        print(",".join([result.content[span.offset:span.offset + span.length] for span in style.spans]))

print("----Key-value pairs found in document----")
for kv_pair in result.key_value_pairs:
    if kv_pair.key:
        print(
                "Key '{}' found within '{}' bounding regions".format(
                    kv_pair.key.content,
                    kv_pair.key.bounding_regions,
                )
            )
    if kv_pair.value:
        print(
                "Value '{}' found within '{}' bounding regions\n".format(
                    kv_pair.value.content,
                    kv_pair.value.bounding_regions,
                )
            )

for page in result.pages:
    print("----Analyzing document from page #{}----".format(page.page_number))
    print(
        "Page has width: {} and height: {}, measured with unit: {}".format(
            page.width, page.height, page.unit
        )
    )

    for line_idx, line in enumerate(page.lines):
        words = line.get_words()
        print(
            "...Line # {} has {} words and text '{}' within bounding polygon '{}'".format(
                line_idx,
                len(words),
                line.content,
                line.polygon,
            )
        )

        for word in words:
            print(
                "......Word '{}' has a confidence of {}".format(
                    word.content, word.confidence
                )
            )

    for selection_mark in page.selection_marks:
        print(
            "...Selection mark is '{}' within bounding polygon '{}' and has a confidence of {}".format(
                selection_mark.state,
                selection_mark.polygon,
                selection_mark.confidence,
            )
        )

for table_idx, table in enumerate(result.tables):
    print(
        "Table # {} has {} rows and {} columns".format(
            table_idx, table.row_count, table.column_count
        )
    )
    for region in table.bounding_regions:
        print(
            "Table # {} location on page: {} is {}".format(
                table_idx,
                region.page_number,
                region.polygon,
            )
        )
    for cell in table.cells:
        print(
            "...Cell[{}][{}] has content '{}'".format(
                cell.row_index,
                cell.column_index,
                cell.content,
            )
        )
        for region in cell.bounding_regions:
            print(
                "...content on page {} is within bounding polygon '{}'\n".format(
                    region.page_number,
                    region.polygon,
                )
            )
print("----------------------------------------")
  • Przeczytaj więcej o funkcjach udostępnianych prebuilt-document przez model tutaj.

Używanie wstępnie utworzonych modeli

Wyodrębnij pola z wybranych typów dokumentów, takich jak paragony, faktury, wizytówki, dokumenty tożsamości i dokumenty podatkowe W-2 USA przy użyciu wstępnie utworzonych modeli dostarczanych przez usługę Document Intelligence.

Aby na przykład analizować pola z paragonu sprzedaży, użyj wstępnie utworzonego modelu paragonu dostarczonego begin_analyze_document przez przekazanie model_id="prebuilt-receipt" do metody :

from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer import DocumentAnalysisClient

endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
key = os.environ["AZURE_FORM_RECOGNIZER_KEY"]

document_analysis_client = DocumentAnalysisClient(
    endpoint=endpoint, credential=AzureKeyCredential(key)
)
with open(path_to_sample_documents, "rb") as f:
    poller = document_analysis_client.begin_analyze_document(
        "prebuilt-receipt", document=f, locale="en-US"
    )
receipts = poller.result()

for idx, receipt in enumerate(receipts.documents):
    print(f"--------Analysis of receipt #{idx + 1}--------")
    print(f"Receipt type: {receipt.doc_type if receipt.doc_type else 'N/A'}")
    merchant_name = receipt.fields.get("MerchantName")
    if merchant_name:
        print(
            f"Merchant Name: {merchant_name.value} has confidence: "
            f"{merchant_name.confidence}"
        )
    transaction_date = receipt.fields.get("TransactionDate")
    if transaction_date:
        print(
            f"Transaction Date: {transaction_date.value} has confidence: "
            f"{transaction_date.confidence}"
        )
    if receipt.fields.get("Items"):
        print("Receipt items:")
        for idx, item in enumerate(receipt.fields.get("Items").value):
            print(f"...Item #{idx + 1}")
            item_description = item.value.get("Description")
            if item_description:
                print(
                    f"......Item Description: {item_description.value} has confidence: "
                    f"{item_description.confidence}"
                )
            item_quantity = item.value.get("Quantity")
            if item_quantity:
                print(
                    f"......Item Quantity: {item_quantity.value} has confidence: "
                    f"{item_quantity.confidence}"
                )
            item_price = item.value.get("Price")
            if item_price:
                print(
                    f"......Individual Item Price: {item_price.value} has confidence: "
                    f"{item_price.confidence}"
                )
            item_total_price = item.value.get("TotalPrice")
            if item_total_price:
                print(
                    f"......Total Item Price: {item_total_price.value} has confidence: "
                    f"{item_total_price.confidence}"
                )
    subtotal = receipt.fields.get("Subtotal")
    if subtotal:
        print(f"Subtotal: {subtotal.value} has confidence: {subtotal.confidence}")
    tax = receipt.fields.get("TotalTax")
    if tax:
        print(f"Total tax: {tax.value} has confidence: {tax.confidence}")
    tip = receipt.fields.get("Tip")
    if tip:
        print(f"Tip: {tip.value} has confidence: {tip.confidence}")
    total = receipt.fields.get("Total")
    if total:
        print(f"Total: {total.value} has confidence: {total.confidence}")
    print("--------------------------------------")

Nie masz ograniczeń do paragonów! Istnieje kilka wstępnie utworzonych modeli do wyboru, z których każdy ma własny zestaw obsługiwanych pól. Zobacz inne obsługiwane wstępnie utworzone modele tutaj.

Tworzenie modelu niestandardowego

Tworzenie modelu niestandardowego we własnym typie dokumentu. Wynikowy model może służyć do analizowania wartości z typów dokumentów, na których został wytrenowany. Podaj adres URL sygnatury dostępu współdzielonego kontenera do kontenera obiektów blob usługi Azure Storage, w którym są przechowywane dokumenty szkoleniowe.

Więcej szczegółów na temat konfigurowania kontenera i wymaganej struktury plików można znaleźć w dokumentacji usługi.

from azure.ai.formrecognizer import (
    DocumentModelAdministrationClient,
    ModelBuildMode,
)
from azure.core.credentials import AzureKeyCredential

endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
key = os.environ["AZURE_FORM_RECOGNIZER_KEY"]
container_sas_url = os.environ["CONTAINER_SAS_URL"]

document_model_admin_client = DocumentModelAdministrationClient(
    endpoint, AzureKeyCredential(key)
)
poller = document_model_admin_client.begin_build_document_model(
    ModelBuildMode.TEMPLATE,
    blob_container_url=container_sas_url,
    description="my model description",
)
model = poller.result()

print(f"Model ID: {model.model_id}")
print(f"Description: {model.description}")
print(f"Model created on: {model.created_on}")
print(f"Model expires on: {model.expires_on}")
print("Doc types the model can recognize:")
for name, doc_type in model.doc_types.items():
    print(
        f"Doc Type: '{name}' built with '{doc_type.build_mode}' mode which has the following fields:"
    )
    for field_name, field in doc_type.field_schema.items():
        print(
            f"Field: '{field_name}' has type '{field['type']}' and confidence score "
            f"{doc_type.field_confidence[field_name]}"
        )

Analizowanie dokumentów przy użyciu modelu niestandardowego

Analizuj pola dokumentów, tabele, znaczniki zaznaczenia i nie tylko. Te modele są trenowane przy użyciu własnych danych, więc są dostosowane do Twoich dokumentów. Aby uzyskać najlepsze wyniki, należy analizować tylko dokumenty tego samego typu dokumentu, z którym został utworzony model niestandardowy.

from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer import DocumentAnalysisClient

endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
key = os.environ["AZURE_FORM_RECOGNIZER_KEY"]
model_id = os.getenv("CUSTOM_BUILT_MODEL_ID", custom_model_id)

document_analysis_client = DocumentAnalysisClient(
    endpoint=endpoint, credential=AzureKeyCredential(key)
)

# Make sure your document's type is included in the list of document types the custom model can analyze
with open(path_to_sample_documents, "rb") as f:
    poller = document_analysis_client.begin_analyze_document(
        model_id=model_id, document=f
    )
result = poller.result()

for idx, document in enumerate(result.documents):
    print(f"--------Analyzing document #{idx + 1}--------")
    print(f"Document has type {document.doc_type}")
    print(f"Document has document type confidence {document.confidence}")
    print(f"Document was analyzed with model with ID {result.model_id}")
    for name, field in document.fields.items():
        field_value = field.value if field.value else field.content
        print(
            f"......found field of type '{field.value_type}' with value '{field_value}' and with confidence {field.confidence}"
        )

# iterate over tables, lines, and selection marks on each page
for page in result.pages:
    print(f"\nLines found on page {page.page_number}")
    for line in page.lines:
        print(f"...Line '{line.content}'")
    for word in page.words:
        print(f"...Word '{word.content}' has a confidence of {word.confidence}")
    if page.selection_marks:
        print(f"\nSelection marks found on page {page.page_number}")
        for selection_mark in page.selection_marks:
            print(
                f"...Selection mark is '{selection_mark.state}' and has a confidence of {selection_mark.confidence}"
            )

for i, table in enumerate(result.tables):
    print(f"\nTable {i + 1} can be found on page:")
    for region in table.bounding_regions:
        print(f"...{region.page_number}")
    for cell in table.cells:
        print(
            f"...Cell[{cell.row_index}][{cell.column_index}] has text '{cell.content}'"
        )
print("-----------------------------------")

Możesz również użyć adresu URL dokumentu do analizowania dokumentów przy użyciu begin_analyze_document_from_url metody .

document_url = "<url_of_the_document>"
poller = document_analysis_client.begin_analyze_document_from_url(model_id=model_id, document_url=document_url)
result = poller.result()

Zarządzanie modelami

Zarządzaj modelami niestandardowymi dołączonymi do konta.

from azure.ai.formrecognizer import DocumentModelAdministrationClient
from azure.core.credentials import AzureKeyCredential
from azure.core.exceptions import ResourceNotFoundError

endpoint = "https://<my-custom-subdomain>.cognitiveservices.azure.com/"
credential = AzureKeyCredential("<api_key>")

document_model_admin_client = DocumentModelAdministrationClient(endpoint, credential)

account_details = document_model_admin_client.get_resource_details()
print("Our account has {} custom models, and we can have at most {} custom models".format(
    account_details.custom_document_models.count, account_details.custom_document_models.limit
))

# Here we get a paged list of all of our models
models = document_model_admin_client.list_document_models()
print("We have models with the following ids: {}".format(
    ", ".join([m.model_id for m in models])
))

# Replace with the custom model ID from the "Build a model" sample
model_id = "<model_id from the Build a Model sample>"

custom_model = document_model_admin_client.get_document_model(model_id=model_id)
print("Model ID: {}".format(custom_model.model_id))
print("Description: {}".format(custom_model.description))
print("Model created on: {}\n".format(custom_model.created_on))

# Finally, we will delete this model by ID
document_model_admin_client.delete_document_model(model_id=custom_model.model_id)

try:
    document_model_admin_client.get_document_model(model_id=custom_model.model_id)
except ResourceNotFoundError:
    print("Successfully deleted model with id {}".format(custom_model.model_id))

Możliwości dodatków

Analiza dokumentów obsługuje bardziej zaawansowane możliwości analizy. Te opcjonalne funkcje można włączyć i wyłączyć w zależności od scenariusza wyodrębniania dokumentu.

Następujące funkcje dodatku są dostępne dla wersji 2023-07-31 (GA) i nowszych:

Pamiętaj, że niektóre funkcje dodatku będą naliczać dodatkowe opłaty. Zobacz cennik: https://azure.microsoft.com/pricing/details/ai-document-intelligence/.

Rozwiązywanie problemów

Ogólne

Form Recognizer biblioteka klienta zgłosi wyjątki zdefiniowane w usłudze Azure Core. Kody błędów i komunikaty zgłaszane przez usługę Analizy dokumentów można znaleźć w dokumentacji usługi.

Rejestrowanie

Ta biblioteka używa standardowej biblioteki rejestrowania do rejestrowania.

Podstawowe informacje o sesjach HTTP (adresach URL, nagłówkach itp.) są rejestrowane na INFO poziomie.

Szczegółowe DEBUG rejestrowanie na poziomie, w tym treści żądań/odpowiedzi i nieredagowanych nagłówków, można włączyć na kliencie lub na operację za pomocą argumentu słowa kluczowego logging_enable .

Zobacz pełną dokumentację rejestrowania zestawu SDK z przykładami tutaj.

Konfiguracja opcjonalna

Opcjonalne argumenty słów kluczowych można przekazać na poziomie klienta i na poziomie operacji. W dokumentacji referencyjnej platformy Azure opisano dostępne konfiguracje ponownych prób, rejestrowania, protokołów transportowych i nie tylko.

Następne kroki

Więcej przykładów kodu

Zobacz Przykładowy plik README, aby zapoznać się z kilkoma fragmentami kodu ilustrującymi typowe wzorce używane w interfejsie API języka Python Form Recognizer.

Dodatkowa dokumentacja

Aby uzyskać bardziej obszerną dokumentację dotyczącą analizy dokumentów sztucznej inteligencji platformy Azure, zobacz dokumentację analizy dokumentów w docs.microsoft.com.

Współtworzenie

W tym projekcie zachęcamy do współtworzenia i zgłaszania sugestii. Współtworzenie w większości przypadków wymaga zgody na umowę licencyjną dotyczącą współautorów (CLA, Contributor License Agreement), zgodnie z którą współautor ma prawo udzielić i faktycznie udziela nam praw do używania wytworzonej przez siebie zawartości. Aby uzyskać szczegółowe informacje, odwiedź stronę cla.microsoft.com.

Po przesłaniu żądania ściągnięcia robot CLA automatycznie określi, czy musisz przekazać umowę CLA, i doda odpowiednie informacje do tego żądania (na przykład etykietę czy komentarz). Po prostu postępuj zgodnie z instrukcjami robota. Wystarczy zrobić to raz dla wszystkich repozytoriów, w przypadku których jest używana nasza umowa CLA.

W tym projekcie przyjęto Kodeks postępowania oprogramowania Open Source firmy Microsoft. Aby uzyskać więcej informacji, zobacz Często zadawane pytania dotyczące kodeksu postępowania lub skontaktuj się z opencode@microsoft.com dodatkowymi pytaniami lub komentarzami.