Azure Formularerkennung-Clientbibliothek für Python– Version 3.3.2

  • Artikel

Azure Document Intelligence (früher als Formularerkennung bezeichnet) ist ein Clouddienst, der maschinelles Lernen verwendet, um Text und strukturierte Daten aus Ihren Dokumenten zu analysieren. Es enthält die folgenden Standard Features:

  • Layout: Extrahieren von Inhalt und Struktur (z. B. Wörter, Auswahlmarkierungen, Tabellen) aus Dokumenten.
  • Dokument: Analysieren Sie zusätzlich zum allgemeinen Layout von Dokumenten Schlüssel-Wert-Paare.
  • Lesen: Liest Seiteninformationen aus Dokumenten.
  • Vordefiniertes Extrahieren allgemeiner Feldwerte aus ausgewählten Dokumenttypen (z. B. Quittungen, Rechnungen, Visitenkarten, ID-Dokumente, U.S. W-2-Steuerdokumente usw.) mithilfe vordefinierter Modelle.
  • Benutzerdefiniert: Erstellen Sie benutzerdefinierte Modelle aus Ihren eigenen Daten, um maßgeschneiderte Feldwerte zusätzlich zum allgemeinen Layout aus Dokumenten zu extrahieren.
  • Klassifizierer: Erstellen Sie benutzerdefinierte Klassifizierungsmodelle, die Layout- und Sprachfeatures kombinieren, um Dokumente, die Sie in Ihrer Anwendung verarbeiten, genau zu erkennen und zu identifizieren.
  • Add-On-Funktionen: Extrahieren Sie Barcodes/QR-Codes, Formeln, Schriftarten/Stil usw. oder aktivieren Sie den Modus mit hoher Auflösung für große Dokumente mit optionalen Parametern.

Quellcode | Paket (PyPI) | Paket (Conda) | API-Referenzdokumentation | Produktdokumentation | Proben

Erste Schritte

Voraussetzungen

Installieren des Pakets

Installieren Sie die Azure Formularerkennung-Clientbibliothek für Python mit pip:

pip install azure-ai-formrecognizer

Hinweis: Diese Version der Clientbibliothek verwendet standardmäßig die 2023-07-31 Version des Diensts.

Diese Tabelle gibt Aufschluss über die Beziehung zwischen SDK-Versionen und unterstützten API-Versionen des Diensts:

SDK-Version Unterstützte API-Version des Diensts
3.3.X : Neuestes GA-Release 2.0, 2.1, 31.08.2022, 31.07.2023 (Standard)
3.2.X 2.0, 2.1, 31.08.2022 (Standard)
3.1.X 2.0, 2.1 (Standard)
3.0.0 2.0

Hinweis: Ab version 3.2.Xwurde eine neue Gruppe von Clients eingeführt, um die neuesten Features des Document Intelligence-Diensts zu nutzen. Ausführliche Anweisungen zum Aktualisieren von Anwendungscode von der Clientbibliotheksversion 3.1.X oder niedriger auf die neueste Version finden Sie im Migrationshandbuch. Ausführlichere Informationen finden Sie im Changelog . In der folgenden Tabelle wird die Beziehung zwischen den einzelnen Clients und den unterstützten API-Versionen beschrieben:

API-Version Unterstützte Clients
2023-07-31 DocumentAnalysisClient und DocumentModelAdministrationClient
2022-08-31 DocumentAnalysisClient und DocumentModelAdministrationClient
2.1 FormRecognizerClient und FormTrainingClient
2.0 FormRecognizerClient und FormTrainingClient

Erstellen einer Cognitive Services- oder Formularerkennung-Ressource

Document Intelligence unterstützt sowohl den Zugriff mit mehreren Diensten als auch den Zugriff mit einem einzelnen Dienst. Erstellen Sie eine Cognitive Services-Ressource, wenn Sie planen, über einen einzelnen Endpunkt bzw. Schlüssel auf mehrere Cognitive Services-Instanzen zuzugreifen. Erstellen Sie nur für den Zugriff auf Document Intelligence eine Formularerkennung-Ressource. Beachten Sie, dass Sie eine Ressource mit einem einzelnen Dienst benötigen, wenn Sie die Azure Active Directory-Authentifizierung verwenden möchten.

Sie können eine Der folgenden Ressourcen erstellen:

Im Folgenden finden Sie ein Beispiel dafür, wie Sie eine Formularerkennung-Ressource mithilfe der CLI erstellen können:

# 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

Weitere Informationen zum Erstellen der Ressource oder zum Abrufen von Standort- und SKU-Informationen finden Sie hier.

Authentifizieren des Clients

Um mit dem Document Intelligence-Dienst zu interagieren, müssen Sie eine instance eines Clients erstellen. Ein Endpunkt und Anmeldeinformationen sind erforderlich, um das Clientobjekt zu instanziieren.

Abrufen des Endpunkts

Sie finden den Endpunkt für Ihre Formularerkennung-Ressource über das Azure-Portal oder die Azure CLI:

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

Für die Authentifizierung kann entweder ein regionaler Endpunkt oder eine benutzerdefinierte Unterdomäne verwendet werden. Sie sind wie folgt formatiert:

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

Ein regionaler Endpunkt ist für jede Ressource in einer Region identisch. Eine vollständige Liste der unterstützten regionalen Endpunkte finden Sie hier. Beachten Sie, dass regionale Endpunkte die AAD-Authentifizierung nicht unterstützen.

Eine benutzerdefinierte Unterdomäne ist dagegen ein Name, der für die Formularerkennung-Ressource eindeutig ist. Sie können nur von Ressourcen mit nur einem Dienst verwendet werden.

Abrufen des API-Schlüssels

Der API-Schlüssel finden Sie im Azure-Portal oder durch Ausführen des folgenden Azure CLI-Befehls:

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

Erstellen des Clients mit AzureKeyCredential

Um einen API-Schlüssel als credential Parameter zu verwenden, übergeben Sie den Schlüssel als Zeichenfolge an eine instance von 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)

Erstellen des Clients mit Azure Active Directory-Anmeldeinformationen

AzureKeyCredential Die Authentifizierung wird in den Beispielen in diesem Leitfaden zu den ersten Schritten verwendet, Aber Sie können sich auch mithilfe der Azure-Identity-Bibliothek bei Azure Active Directory authentifizieren. Beachten Sie, dass regionale Endpunkte die AAD-Authentifizierung nicht unterstützen. Erstellen Sie einen benutzerdefinierten Unterdomänennamen für Ihre Ressource, um diese Art der Authentifizierung zu verwenden.

Um den unten gezeigten DefaultAzureCredential-Typ oder andere Im Azure SDK bereitgestellte Anmeldeinformationstypen zu verwenden, installieren Sie das azure-identity Paket:

pip install azure-identity

Sie müssen auch eine neue AAD-Anwendung registrieren und Zugriff auf Document Intelligence gewähren, indem Sie die "Cognitive Services User" Rolle Ihrem Dienstprinzipal zuweisen.

Legen Sie nach Abschluss des Vorgangs die Werte der Client-ID, der Mandanten-ID und des geheimen Clientschlüssels der AAD-Anwendung als Umgebungsvariablen fest: 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)

Wichtige Begriffe

DocumentAnalysisClient

DocumentAnalysisClient stellt Vorgänge zum Analysieren von Eingabedokumenten mithilfe vordefinierter und benutzerdefinierter Modelle über die begin_analyze_document APIs und begin_analyze_document_from_url bereit. Verwenden Sie den model_id -Parameter, um den Typ des Modells für die Analyse auszuwählen. Eine vollständige Liste der unterstützten Modelle finden Sie hier. Bietet DocumentAnalysisClient auch Vorgänge zum Klassifizieren von Dokumenten über die begin_classify_document APIs und begin_classify_document_from_url . Benutzerdefinierte Klassifizierungsmodelle können jede Seite in einer Eingabedatei klassifizieren, um die darin enthaltenen Dokumente zu identifizieren. Sie können auch mehrere Dokumente oder mehrere Instanzen eines einzelnen Dokuments innerhalb einer Eingabedatei identifizieren.

Beispielcodeausschnitte werden bereitgestellt, um die Verwendung eines DocumentAnalysisClient-Beispiels hier zu veranschaulichen. Weitere Informationen zum Analysieren von Dokumenten, einschließlich unterstützter Features, Gebietsschemas und Dokumenttypen, finden Sie in der Dienstdokumentation.

DocumentModelAdministrationClient

DocumentModelAdministrationClient stellt Vorgänge für Folgendes bereit:

  • Erstellen benutzerdefinierter Modelle zum Analysieren bestimmter Felder, die Sie angeben, indem Sie Ihre benutzerdefinierten Dokumente bezeichnen. Es wird ein DocumentModelDetails zurückgegeben, der die Dokumenttypen angibt, die das Modell analysieren kann, sowie die geschätzte Konfidenz für jedes Feld. Eine ausführlichere Erläuterung finden Sie in der Dienstdokumentation .
  • Erstellen eines zusammengesetzten Modells aus einer Sammlung vorhandener Modelle.
  • Verwalten der in Ihrem Konto erstellten Modelle
  • Auflisten von Vorgängen oder Abrufen eines bestimmten Modellvorgangs, der innerhalb der letzten 24 Stunden erstellt wurde.
  • Kopieren eines benutzerdefinierten Modells aus einer Formularerkennungsressource in eine andere
  • Erstellen und verwalten Sie ein benutzerdefiniertes Klassifizierungsmodell, um die Dokumente zu klassifizieren, die Sie in Ihrer Anwendung verarbeiten.

Beachten Sie, dass Modelle auch mithilfe einer grafischen Benutzeroberfläche wie Document Intelligence Studio erstellt werden können.

Beispielcodeausschnitte werden bereitgestellt, um die Verwendung von DocumentModelAdministrationClient-Beispielen hier zu veranschaulichen.

Zeitintensive Vorgänge

Vorgänge mit langer Ausführungsdauer sind Vorgänge, die aus einer anfänglichen Anforderung bestehen, die an den Dienst gesendet wird, um einen Vorgang zu starten, gefolgt von der Abfrage des Diensts in Intervallen, um festzustellen, ob der Vorgang abgeschlossen oder fehlgeschlagen ist, und ob er erfolgreich war, um das Ergebnis zu erhalten.

Methoden, die Dokumente, Buildmodelle oder Kopieren/Verfassen von Modellen analysieren, werden als Vorgänge mit langer Ausführungsdauer modelliert. Der Client macht eine begin_<method-name> Methode verfügbar, die ein LROPoller oder AsyncLROPollerzurückgibt. Aufrufer sollten warten, bis der Vorgang abgeschlossen ist, indem sie für das Von der begin_<method-name> -Methode zurückgegebene Poller-Objekt aufrufenresult(). Beispielcodeausschnitte werden bereitgestellt, um die Verwendung von Vorgängen mit langer Ausführungszeit zu veranschaulichen unten.

Beispiele

Der folgende Abschnitt enthält mehrere Codeausschnitte, die einige der gängigsten Document Intelligence-Aufgaben abdecken, einschließlich:

Extrahieren des Layouts

Extrahieren Von Text, Auswahlmarkierungen, Textformatvorlagen und Tabellenstrukturen sowie deren Begrenzungsbereichkoordinaten aus Dokumenten.

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

Verwenden des allgemeinen Dokumentmodells

Analysieren Sie Schlüssel-Wert-Paare, Tabellen, Stile und Auswahlmarkierungen aus Dokumenten mithilfe des allgemeinen Dokumentmodells, das vom Document Intelligence-Dienst bereitgestellt wird. Wählen Sie das Allgemeine Dokumentmodell aus, indem Sie an die begin_analyze_document -Methode übergebenmodel_id="prebuilt-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("----------------------------------------")
  • Weitere Informationen zu den vom Modell bereitgestellten prebuilt-document Features finden Sie hier.

Verwenden vordefinierter Modelle

Extrahieren Sie Felder aus ausgewählten Dokumenttypen wie Quittungen, Rechnungen, Visitenkarten, Identitätsdokumenten und US-W-2-Steuerdokumenten mithilfe vordefinierter Modelle, die vom Document Intelligence-Dienst bereitgestellt werden.

Um beispielsweise Felder aus einem Verkaufsbeleg zu analysieren, verwenden Sie das vordefinierte Belegmodell, das durch Übergeben an model_id="prebuilt-receipt" die begin_analyze_document -Methode bereitgestellt wird:

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

Sie sind nicht auf Belege beschränkt! Es stehen einige vordefinierte Modelle zur Auswahl, von denen jedes über einen eigenen Satz unterstützter Felder verfügt. Weitere unterstützte vordefinierte Modelle finden Sie hier.

Erstellen eines benutzerdefinierten Modells

Erstellen Sie ein benutzerdefiniertes Modell für Ihren eigenen Dokumenttyp. Das resultierende Modell kann verwendet werden, um Werte aus den Dokumententypen zu analysieren, für die es trainiert wurde. Geben Sie eine CONTAINER-SAS-URL für Ihren Azure Storage-Blobcontainer an, in dem Sie die Trainingsdokumente speichern.

Weitere Informationen zum Einrichten eines Containers und zur erforderlichen Dateistruktur finden Sie in der Dienstdokumentation.

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

Analysieren von Dokumenten mit einem benutzerdefinierten Modell

Analysieren Sie Dokumentfelder, Tabellen, Auswahlmarkierungen und vieles mehr. Diese Modelle werden mit Ihren eigenen Daten trainiert, sodass sie auf Ihre Dokumente zugeschnitten sind. Um optimale Ergebnisse zu erzielen, sollten Sie nur Dokumente desselben Dokumenttyps analysieren, mit dem das benutzerdefinierte Modell erstellt wurde.

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

Alternativ kann auch eine Dokument-URL verwendet werden, um Dokumente mithilfe der begin_analyze_document_from_url -Methode zu analysieren.

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

Verwalten Ihrer Modelle

Verwalten Sie die benutzerdefinierten Modelle, die an Ihr Konto angefügt sind.

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

Add-On-Funktionen

Document Intelligence unterstützt komplexere Analysefunktionen. Diese optionalen Features können je nach Szenario der Dokumentextraktion aktiviert und deaktiviert werden.

Die folgenden Add-On-Funktionen sind für 31.07.2023 (GA) und höhere Versionen verfügbar:

Beachten Sie, dass für einige Add-On-Funktionen zusätzliche Gebühren anfallen. Weitere Informationen finden Sie unter Preise: https://azure.microsoft.com/pricing/details/ai-document-intelligence/.

Problembehandlung

Allgemein

Formularerkennung Clientbibliothek löst ausnahmen aus, die in Azure Core definiert sind. Fehlercodes und Meldungen, die vom Document Intelligence-Dienst ausgelöst werden, finden Sie in der Dienstdokumentation.

Protokollierung

Diese Bibliothek verwendet die Standardprotokollbibliothek für die Protokollierung.

Grundlegende Informationen zu HTTP-Sitzungen (URLs, Header usw.) werden auf ebener Ebene INFO protokolliert.

Die Protokollierung auf detaillierter DEBUG Ebene, einschließlich Anforderungs-/Antworttexten und nicht ausgeführten Headern, kann auf dem Client oder pro Vorgang mit dem logging_enable argument Schlüsselwort (keyword) aktiviert werden.

Die vollständige SDK-Protokollierungsdokumentation mit Beispielen finden Sie hier.

Optionale Konfiguration

Optionale Schlüsselwort (keyword) Argumente können auf Client- und Vorgangsebene übergeben werden. In der Azure Core-Referenzdokumentation werden verfügbare Konfigurationen für Wiederholungen, Protokollierung, Transportprotokolle und vieles mehr beschrieben.

Nächste Schritte

Weiterer Beispielcode

In der Readme-Beispieldatei finden Sie mehrere Codeausschnitte, die gängige Muster veranschaulichen, die in der Formularerkennung Python-API verwendet werden.

Zusätzliche Dokumentation

Eine ausführlichere Dokumentation zu Azure AI Document Intelligence finden Sie in der Document Intelligence-Dokumentation auf docs.microsoft.com.

Mitwirken

Beiträge und Vorschläge für dieses Projekt sind willkommen. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. Weitere Informationen finden Sie unter cla.microsoft.com.

Wenn Sie einen Pull Request (PR) übermitteln, überprüft ein CLA-Bot automatisch, ob Sie eine Lizenzvereinbarung bereitstellen und den PR entsprechend ergänzen müssen (z.B. mit einer Bezeichnung oder einem Kommentar). Führen Sie einfach die Anweisungen des Bots aus. Sie müssen dies nur einmal für alle Repositorys ausführen, die unsere CLA verwenden.

Für dieses Projekt gelten die Microsoft-Verhaltensregeln für Open Source (Microsoft Open Source Code of Conduct). Weitere Informationen finden Sie in den häufig gestellten Fragen zum Verhaltenskodex. Sie können sich auch an opencode@microsoft.com wenden, wenn Sie weitere Fragen oder Anmerkungen haben.