Azure AI Document Intelligence-Clientbibliothek für Python– Version 1.0.0b1

  • Artikel

Azure AI 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.

Erste Schritte

Installieren des Pakets

python -m pip install azure-ai-documentintelligence

Voraussetzungen

  • Für die Verwendung dieses Pakets ist Python 3.7 oder höher erforderlich.
  • Sie benötigen ein Azure-Abonnement , um dieses Paket verwenden zu können.
  • Eine vorhandene Azure AI Document Intelligence-instance.

Erstellen einer Cognitive Services- oder Document Intelligence-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 Dokument Intelligenz eine Dokument Intelligenz-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 Document Intelligence-Ressource mithilfe der CLI erstellen können:

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

# Create the Document Intelligence resource
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 Document Intelligence-Ressource über das Azure-Portal oder die Azure CLI:

# Get the endpoint for the Document Intelligence 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 Document Intelligence-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.documentintelligence import DocumentIntelligenceClient

endpoint = "https://<my-custom-subdomain>.cognitiveservices.azure.com/"
credential = AzureKeyCredential("<api_key>")
document_analysis_client = DocumentIntelligenceClient(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.documentintelligence import DocumentIntelligenceClient
from azure.identity import DefaultAzureCredential

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

document_analysis_client = DocumentIntelligenceClient(endpoint, credential)

Wichtige Begriffe

DocumentIntelligenceClient

DocumentIntelligenceClient stellt Vorgänge zum Analysieren von Eingabedokumenten mithilfe vordefinierter und benutzerdefinierter Modelle über die begin_analyze_document API 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 DocumentIntelligenceClient auch Vorgänge zum Klassifizieren von Dokumenten über die begin_classify_document API. 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 hier bereitgestellt, um die Verwendung eines DocumentIntelligenceClient-Beispiels zu veranschaulichen. Weitere Informationen zum Analysieren von Dokumenten, einschließlich unterstützter Features, Gebietsschemas und Dokumenttypen, finden Sie in der Dienstdokumentation.

DocumentIntelligenceAdministrationClient

DocumentIntelligenceAdministrationClient 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 Dokument Intelligenz-Ressource 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 eines DocumentIntelligenceAdministrationClient-Beispiels 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.documentintelligence import DocumentIntelligenceClient

endpoint = os.environ["DOCUMENTINTELLIGENCE_ENDPOINT"]
key = os.environ["DOCUMENTINTELLIGENCE_API_KEY"]

document_intelligence_client = DocumentIntelligenceClient(
    endpoint=endpoint, credential=AzureKeyCredential(key)
)
with open(path_to_sample_documents, "rb") as f:
    poller = document_intelligence_client.begin_analyze_document(
        "prebuilt-layout", analyze_request=f, content_type="application/octet-stream"
    )
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 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.documentintelligence import DocumentIntelligenceClient

endpoint = os.environ["DOCUMENTINTELLIGENCE_ENDPOINT"]
key = os.environ["DOCUMENTINTELLIGENCE_API_KEY"]

document_analysis_client = DocumentIntelligenceClient(endpoint=endpoint, credential=AzureKeyCredential(key))
with open(path_to_sample_documents, "rb") as f:
    poller = document_analysis_client.begin_analyze_document(
        "prebuilt-receipt", analyze_request=f, locale="en-US", content_type="application/octet-stream"
    )
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.get('valueString')} has confidence: " f"{merchant_name.confidence}")
    transaction_date = receipt.fields.get("TransactionDate")
    if transaction_date:
        print(
            f"Transaction Date: {transaction_date.get('valueDate')} has confidence: "
            f"{transaction_date.confidence}"
        )
    if receipt.fields.get("Items"):
        print("Receipt items:")
        for idx, item in enumerate(receipt.fields.get("Items").get("valueArray")):
            print(f"...Item #{idx + 1}")
            item_description = item.get("valueObject").get("Description")
            if item_description:
                print(
                    f"......Item Description: {item_description.get('valueString')} has confidence: "
                    f"{item_description.confidence}"
                )
            item_quantity = item.get("valueObject").get("Quantity")
            if item_quantity:
                print(
                    f"......Item Quantity: {item_quantity.get('valueString')} has confidence: "
                    f"{item_quantity.confidence}"
                )
            item_total_price = item.get("valueObject").get("TotalPrice")
            if item_total_price:
                print(
                    f"......Total Item Price: {format_price(item_total_price.get('valueCurrency'))} has confidence: "
                    f"{item_total_price.confidence}"
                )
    subtotal = receipt.fields.get("Subtotal")
    if subtotal:
        print(f"Subtotal: {format_price(subtotal.get('valueCurrency'))} has confidence: {subtotal.confidence}")
    tax = receipt.fields.get("TotalTax")
    if tax:
        print(f"Total tax: {format_price(tax.get('valueCurrency'))} has confidence: {tax.confidence}")
    tip = receipt.fields.get("Tip")
    if tip:
        print(f"Tip: {format_price(tip.get('valueCurrency'))} has confidence: {tip.confidence}")
    total = receipt.fields.get("Total")
    if total:
        print(f"Total: {format_price(total.get('valueCurrency'))} 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 (
    DocumentIntelligenceAdministrationClient,
    ModelBuildMode,
)
from azure.core.credentials import AzureKeyCredential

endpoint = os.environ["DOCUMENTINTELLIGENCE_ENDPOINT"]
key = os.environ["DOCUMENTINTELLIGENCE_API_KEY"]
container_sas_url = os.environ["CONTAINER_SAS_URL"]

document_model_admin_client = DocumentIntelligenceAdministrationClient(
    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.documentintelligence import DocumentIntelligenceClient

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

document_analysis_client = DocumentIntelligenceClient(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, analyze_request=f, content_type="application/octet-stream"
    )
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.get("valueString") if field.get("valueString") else field.content
        print(
            f"......found field of type '{field.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("-----------------------------------")

Darüber hinaus kann eine Dokument-URL auch verwendet werden, um Dokumente mit der begin_analyze_document -Methode zu analysieren.

from azure.core.credentials import AzureKeyCredential
from azure.ai.documentintelligence import DocumentIntelligenceClient
from azure.ai.documentintelligence.models import AnalyzeDocumentRequest

endpoint = os.environ["DOCUMENTINTELLIGENCE_ENDPOINT"]
key = os.environ["DOCUMENTINTELLIGENCE_API_KEY"]

document_analysis_client = DocumentIntelligenceClient(endpoint=endpoint, credential=AzureKeyCredential(key))
url = "https://raw.githubusercontent.com/Azure/azure-sdk-for-python/main/sdk/documentintelligence/azure-ai-documentintelligence/tests/sample_forms/receipt/contoso-receipt.png"
poller = document_analysis_client.begin_analyze_document("prebuilt-receipt", AnalyzeDocumentRequest(url_source=url))
receipts = poller.result()

Verwalten Ihrer Modelle

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

from azure.ai.documentintelligence import DocumentIntelligenceAdministrationClient
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 = DocumentIntelligenceAdministrationClient(endpoint, credential)

account_details = document_model_admin_client.get_resource_info()
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_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_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_model(model_id=custom_model.model_id)

try:
    document_model_admin_client.get_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

Die Document Intelligence-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 Document Intelligence-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. Ausführliche Informationen finden Sie unter https://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 FAQ zum Verhaltenskodex, oder wenden Sie sich mit weiteren Fragen oder Kommentaren an opencode@microsoft.com.