Azure Form Recognizer-clientbibliotheek voor Python - versie 3.3.2

Azure Document Intelligence (voorheen bekend als Form Recognizer) is een cloudservice die gebruikmaakt van machine learning om tekst en gestructureerde gegevens uit uw documenten te analyseren. Het bevat de volgende hoofdfuncties:

• Indeling: inhoud en structuur (bijvoorbeeld woorden, selectiemarkeringen, tabellen) uit documenten extraheren.
• Document: analyseer sleutel-waardeparen naast de algemene indeling van documenten.
• Lezen: pagina-informatie uit documenten lezen.
• Vooraf samengesteld: algemene veldwaarden extraheren uit bepaalde documenttypen (bijvoorbeeld ontvangstbewijzen, facturen, visitekaartjes, id-documenten, Amerikaanse W-2-belastingdocumenten, onder andere) met behulp van vooraf samengestelde modellen.
• Aangepast: maak aangepaste modellen op basis van uw eigen gegevens om op maat gemaakte veldwaarden te extraheren naast de algemene indeling uit documenten.
• Classificaties: bouw aangepaste classificatiemodellen die indelings- en taalfuncties combineren om documenten die u in uw toepassing verwerkt, nauwkeurig te detecteren en te identificeren.
• Invoegtoepassingsmogelijkheden: streepjescodes/QR-codes, formules, lettertype/stijl, enzovoort extraheren of de modus hoge resolutie inschakelen voor grote documenten met optionele parameters.

Broncode | Pakket (PyPI) | Pakket (Conda) | API-referentiedocumentatie | Productdocumentatie | Monsters

Aan de slag

Vereisten

• Python 3.7 of hoger is vereist voor het gebruik van dit pakket.
• U moet een Azure-abonnement en een Cognitive Services- of Form Recognizer resource hebben om dit pakket te kunnen gebruiken.

Het pakket installeren

Installeer de Azure Form Recognizer-clientbibliotheek voor Python met pip:

pip install azure-ai-formrecognizer

Opmerking: deze versie van de clientbibliotheek is standaard de 2023-07-31 versie van de service.

In deze tabel ziet u de relatie tussen SDK-versies en ondersteunde API-versies van de service:

SDK-versie	Ondersteunde API-versie van de service
3.3.X - Meest recente GA-release	2.0, 2.1, 2022-08-31, 2023-07-31 (standaard)
3.2.X	2.0, 2.1, 2022-08-31 (standaard)
3.1.X	2.0, 2.1 (standaard)
3.0.0	2,0

Opmerking: vanaf versie 3.2.Xis er een nieuwe set clients geïntroduceerd om gebruik te maken van de nieuwste functies van de Document Intelligence-service. Raadpleeg de Migratiehandleiding voor gedetailleerde instructies over het bijwerken van toepassingscode van de clientbibliotheekversie 3.1.X of lager naar de nieuwste versie. Zie ook het Wijzigingenlogboek voor meer gedetailleerde informatie. In de onderstaande tabel wordt de relatie van elke client en de ondersteunde API-versie(s) beschreven:

API-versie	Ondersteunde clients
2023-07-31	DocumentAnalysisClient en DocumentModelAdministrationClient
2022-08-31	DocumentAnalysisClient en DocumentModelAdministrationClient
2.1	FormRecognizerClient en FormTrainingClient
2,0	FormRecognizerClient en FormTrainingClient

Een Cognitive Services- of Form Recognizer-resource maken

Document Intelligence ondersteunt toegang tot zowel meerdere services als toegang met één service. Maak een Cognitive Services-resource als u van plan bent toegang te krijgen tot meerdere cognitieve services onder één eindpunt/sleutel. Maak een Form Recognizer resource voor alleen documentinformatietoegang. Houd er rekening mee dat u een resource met één service nodig hebt als u Azure Active Directory-verificatie wilt gebruiken.

U kunt een van beide resources maken met behulp van:

• Optie 1: Azure Portal.
• Optie 2: Azure CLI.

Hieronder ziet u een voorbeeld van hoe u een Form Recognizer resource kunt maken met behulp van de CLI:

# 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

Zie hier voor meer informatie over het maken van de resource of het ophalen van de locatie- en SKU-informatie.

De client verifiëren

Als u wilt communiceren met de Document Intelligence-service, moet u een exemplaar van een client maken. Er zijn een eindpunt en referenties nodig om het clientobject te instantiëren.

Het eindpunt ophalen

U kunt het eindpunt voor uw Form Recognizer-resource vinden met behulp van Azure Portal of 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"

Een regionaal eindpunt of een aangepast subdomein kan worden gebruikt voor verificatie. Ze worden als volgt opgemaakt:

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

Een regionaal eindpunt is hetzelfde voor elke resource in een regio. Een volledige lijst met ondersteunde regionale eindpunten kunt u hier raadplegen. Houd er rekening mee dat regionale eindpunten geen ondersteuning bieden voor AAD-verificatie.

Een aangepast subdomein is daarentegen een naam die uniek is voor de Form Recognizer resource. Ze kunnen alleen worden gebruikt door resources met één service.

De API-sleutel ophalen

U vindt de API-sleutel in Azure Portal of door de volgende Azure CLI-opdracht uit te voeren:

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

De client maken met AzureKeyCredential

Als u een API-sleutel als credential parameter wilt gebruiken, geeft u de sleutel door als een tekenreeks aan een exemplaar van 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)

De client maken met een Azure Active Directory-referentie

AzureKeyCredential verificatie wordt gebruikt in de voorbeelden in deze introductiehandleiding, maar u kunt zich ook verifiëren met Azure Active Directory met behulp van de azure-identity-bibliotheek . Houd er rekening mee dat regionale eindpunten geen ondersteuning bieden voor AAD-verificatie. Maak een aangepaste subdomeinnaam voor uw resource om dit type verificatie te kunnen gebruiken.

Als u het hieronder weergegeven Type DefaultAzureCredential of andere referentietypen wilt gebruiken die worden geleverd met de Azure SDK, installeert u het azure-identity pakket:

pip install azure-identity

U moet ook een nieuwe AAD-toepassing registreren en toegang verlenen tot Document Intelligence door de "Cognitive Services User" rol toe te wijzen aan uw service-principal.

Wanneer dit is voltooid, stelt u de waarden van de client-id, tenant-id en clientgeheim van de AAD-toepassing in als omgevingsvariabelen: 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)

Belangrijkste concepten

DocumentAnalysisClient

DocumentAnalysisClient biedt bewerkingen voor het analyseren van invoerdocumenten met behulp van vooraf samengestelde en aangepaste modellen via de begin_analyze_document API's en begin_analyze_document_from_url . Gebruik de model_id parameter om het type model voor analyse te selecteren. Bekijk hier een volledige lijst met ondersteunde modellen. De DocumentAnalysisClient biedt ook bewerkingen voor het classificeren van documenten via de begin_classify_document API's en begin_classify_document_from_url . Aangepaste classificatiemodellen kunnen elke pagina in een invoerbestand classificeren om de documenten in een of meer documenten te identificeren en kunnen ook meerdere documenten of meerdere exemplaren van één document in een invoerbestand identificeren.

Hier worden voorbeeldcodefragmenten verstrekt ter illustratie met behulp van een DocumentAnalysisClient-voorbeelden. Meer informatie over het analyseren van documenten, waaronder ondersteunde functies, landinstellingen en documenttypen, vindt u in de servicedocumentatie.

DocumentModelAdministrationClient

DocumentModelAdministrationClient biedt bewerkingen voor:

• Aangepaste modellen bouwen om specifieke velden te analyseren die u opgeeft door uw aangepaste documenten te labelen. Er DocumentModelDetails wordt een geretourneerd die de documenttypen aangeeft die door het model kunnen worden geanalyseerd, evenals de geschatte betrouwbaarheid voor elk veld. Zie de servicedocumentatie voor een gedetailleerdere uitleg.
• Een samengesteld model maken op basis van een verzameling bestaande modellen.
• Modellen beheren die zijn gemaakt in uw account.
• Bewerkingen weergeven of een specifieke modelbewerking ophalen die in de afgelopen 24 uur is gemaakt.
• Het kopiëren van een aangepast model van de ene Form Recognizer-resource naar de andere.
• Bouw en beheer een aangepast classificatiemodel om de documenten die u in uw toepassing verwerkt te classificeren.

Houd er rekening mee dat modellen ook kunnen worden gebouwd met behulp van een grafische gebruikersinterface zoals Document Intelligence Studio.

Voorbeeldcodefragmenten worden hier verstrekt ter illustratie met behulp van een DocumentModelAdministrationClient-voorbeelden.

Langlopende bewerkingen

Langlopende bewerkingen zijn bewerkingen die bestaan uit een initiële aanvraag die naar de service wordt verzonden om een bewerking te starten, gevolgd door het pollen van de service met intervallen om te bepalen of de bewerking is voltooid of mislukt, en of deze is geslaagd, om het resultaat te verkrijgen.

Methoden voor het analyseren van documenten, het bouwen van modellen of het kopiëren/opstellen van modellen worden gemodelleerd als langlopende bewerkingen. De client maakt een begin_<method-name> methode beschikbaar die een LROPoller of AsyncLROPollerretourneert. Aanroepers moeten wachten tot de bewerking is voltooid door het poller-object aan te roepen result() dat is geretourneerd door de begin_<method-name> methode. Voorbeeldcodefragmenten worden gegeven ter illustratie van het gebruik van langlopende bewerkingen hieronder.

Voorbeelden

De volgende sectie bevat verschillende codefragmenten voor enkele van de meest voorkomende Document Intelligence-taken, waaronder:

• Indeling extraheren
• Het algemene documentmodel gebruiken
• Vooraf samengestelde modellen gebruiken
• Een aangepast model bouwen
• Documenten analyseren met een aangepast model
• Uw modellen beheren
• Documenten classificeren
• Mogelijkheden van invoegtoepassingen

Indeling extraheren

Extraheer tekst, selectiemarkeringen, tekststijlen en tabelstructuren, samen met de coördinaten van het begrenzingsgebied, uit documenten.

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

Het algemene documentmodel gebruiken

Analyseer sleutel-waardeparen, tabellen, stijlen en selectiemarkeringen uit documenten met behulp van het algemene documentmodel van de Document Intelligence-service. Selecteer het algemene documentmodel door door te geven aan model_id="prebuilt-document" de begin_analyze_document methode:

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

• Lees hier meer over de functies van het prebuilt-document model.

Vooraf samengestelde modellen gebruiken

Extraheer velden uit bepaalde documenttypen, zoals ontvangstbewijzen, facturen, visitekaartjes, identiteitsdocumenten en Amerikaanse W-2-belastingdocumenten met behulp van vooraf samengestelde modellen van de Document Intelligence-service.

Als u bijvoorbeeld velden van een verkoopbewijs wilt analyseren, gebruikt u het vooraf samengestelde ontvangstbewijsmodel dat wordt geleverd door door te geven model_id="prebuilt-receipt" aan de begin_analyze_document methode:

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

U bent niet beperkt tot ontvangstbewijzen! Er zijn een paar vooraf gedefinieerde modellen waaruit u kunt kiezen, die elk een eigen set ondersteunde velden hebben. Bekijk hier andere ondersteunde vooraf samengestelde modellen.

Een aangepast model bouwen

Bouw een aangepast model op basis van uw eigen documenttype. Het resulterende model kan worden gebruikt om waarden te analyseren van de typen documenten waarop het is getraind. Geef een SAS-URL van de container op voor uw Azure Storage Blob-container waar u de trainingsdocumenten opslaat.

Meer informatie over het instellen van een container en de vereiste bestandsstructuur vindt u in de servicedocumentatie.

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

Documenten analyseren met een aangepast model

Documentvelden, tabellen, selectiemarkeringen en meer analyseren. Deze modellen worden getraind met uw eigen gegevens, zodat ze zijn afgestemd op uw documenten. Voor de beste resultaten moet u alleen documenten analyseren van hetzelfde documenttype als waarmee het aangepaste model is gemaakt.

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

U kunt ook een document-URL gebruiken om documenten te analyseren met behulp van de begin_analyze_document_from_url -methode.

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

Uw modellen beheren

Beheer de aangepaste modellen die aan uw account zijn gekoppeld.

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

Mogelijkheden van invoegtoepassingen

Document Intelligence ondersteunt geavanceerdere analysemogelijkheden. Deze optionele functies kunnen worden in- en uitgeschakeld, afhankelijk van het scenario van de documentextractie.

De volgende uitbreidingsmogelijkheden zijn beschikbaar voor 2023-07-31 (GA) en latere versies:

• streepjescode/QR-code
• Formule
• lettertype/stijl
• hoge resolutie-modus
• Language

Houd er rekening mee dat voor sommige mogelijkheden van invoegtoepassingen extra kosten in rekening worden gebracht. Zie prijzen: https://azure.microsoft.com/pricing/details/ai-document-intelligence/.

Problemen oplossen

Algemeen

Form Recognizer clientbibliotheek genereert uitzonderingen die zijn gedefinieerd in Azure Core. Foutcodes en berichten die door de Document Intelligence-service worden gegenereerd, vindt u in de servicedocumentatie.

Logboekregistratie

Deze bibliotheek maakt gebruik van de standaardbibliotheek voor logboekregistratie voor logboekregistratie.

Basisinformatie over HTTP-sessies (URL's, headers, enzovoort) wordt geregistreerd op INFO niveau.

Gedetailleerde DEBUG logboekregistratie op niveau, inclusief aanvraag-/antwoordteksten en niet-bewerkte headers, kan worden ingeschakeld op de client of per bewerking met het logging_enable trefwoordargument.

Bekijk hier de volledige documentatie voor SDK-logboekregistratie met voorbeelden.

Optionele configuratie

Optionele trefwoordargumenten kunnen worden doorgegeven op het niveau van de client en per bewerking. In de naslagdocumentatie van Azure Core worden de beschikbare configuraties beschreven voor nieuwe pogingen, logboekregistratie, transportprotocollen en meer.

Volgende stappen

Meer voorbeeldcode

Zie voorbeeld-LEESMIJ voor verschillende codefragmenten die veelvoorkomende patronen illustreren die worden gebruikt in de Form Recognizer Python-API.

Aanvullende documentatie

Zie de documentinformatiedocumentatie over docs.microsoft.com voor uitgebreidere documentatie over Azure AI Document Intelligence .

Bijdragen

Wij verwelkomen bijdragen en suggesties voor dit project. Voor de meeste bijdragen moet u instemmen met een licentieovereenkomst voor bijdragers (CLA: Contributor License Agreement) waarin u verklaart dat u gerechtigd bent ons het recht te geven uw bijdrage te gebruiken, en dat u dit ook doet. Ga naar cla.microsoft.com voor meer informatie.

Wanneer u een pull-aanvraag indient, wordt met een CLA-bot automatisch bepaald of u een CLA moet verschaffen en wordt de pull-aanvraag dienovereenkomstig opgemaakt (bijvoorbeeld met een label of commentaar). Volg gewoon de instructies van de bot. U hoeft dit maar eenmaal te doen voor alle repo's waar gebruik wordt gemaakt van onze CLA.

Op dit project is de Microsoft Open Source Code of Conduct (Microsoft Open Source-gedragscode) van toepassing. Zie de Veelgestelde vragen over de gedragscode voor meer informatie of neem contact op opencode@microsoft.com met eventuele aanvullende vragen of opmerkingen.