Megosztás a következőn keresztül:

Azure Form Recognizer Python-ügyfélkódtár – 3.3.2-es verzió

  • Cikk

Az Azure Document Intelligence (korábbi nevén Form Recognizer) egy felhőalapú szolgáltatás, amely gépi tanulással elemzi a dokumentumok szövegét és strukturált adatait. A következő fő funkciókat tartalmazza:

  • Elrendezés – Tartalom és szerkezet (például szavak, kijelölési jelek, táblázatok) kinyerése a dokumentumokból.
  • Dokumentum – Kulcs-érték párok elemzése a dokumentumok általános elrendezése mellett.
  • Olvasás – Lapinformációk olvasása dokumentumokból.
  • Előre összeállított – Kinyerheti a közös mezőértékeket a kiválasztott dokumentumtípusokból (például nyugták, számlák, névjegykártyák, azonosító dokumentumok, egyesült államokbeli adódokumentumok stb.) előre összeállított modellek használatával.
  • Egyéni – Egyéni modelleket hozhat létre a saját adataiból, hogy testreszabott mezőértékeket nyerjen ki a dokumentumok általános elrendezése mellett.
  • Osztályozók – Egyéni besorolási modelleket hozhat létre, amelyek az elrendezési és nyelvi funkciókat kombinálva pontosan észlelik és azonosítják az alkalmazásban feldolgozott dokumentumokat.
  • Bővítményfunkciók – Vonalkódok/QR-kódok, képletek, betűtípus/stílus stb. kinyerése, vagy nagy felbontású mód engedélyezése nagy méretű dokumentumokhoz opcionális paraméterekkel.

Forráskód | Csomag (PyPI) | Csomag (Conda) | API-referenciadokumentáció | Termékdokumentáció | Minták

Első lépések

Előfeltételek

A csomag telepítése

Telepítse a Pythonhoz készült Azure Form Recognizer ügyfélkódtárat a pip használatával:

pip install azure-ai-formrecognizer

Megjegyzés: Az ügyfélkódtár ezen verziója alapértelmezés szerint a 2023-07-31 szolgáltatás verziójára van bekapcsolva.

Ez a táblázat a szolgáltatás SDK-verziói és támogatott API-verziói közötti kapcsolatot mutatja be:

SDK verziója A szolgáltatás támogatott API-verziója
3.3.X – A legújabb általánosan elérhető kiadás 2.0, 2.1, 2022-08-31, 2023-07-31 (alapértelmezett)
3.2.X 2.0, 2.1, 2022-08-31 (alapértelmezett)
3.1.X 2.0, 2.1 (alapértelmezett)
3.0.0 2.0

Megjegyzés: A verziótól 3.2.Xkezdve új ügyfélkészletet vezettünk be a Dokumentumintelligencia szolgáltatás legújabb funkcióinak kihasználásához. A migrálási útmutatóban részletes útmutatást talál az alkalmazáskód ügyfélkódtár-verzióról vagy a legújabb verzióra 3.1.X való frissítéséről. További információt a Változásnaplóban talál. Az alábbi táblázat az egyes ügyfelek és a támogatott API-verzió(k) kapcsolatát ismerteti:

API-verzió Támogatott kliensek
2023-07-31 DocumentAnalysisClient és DocumentModelAdministrationClient
2022-08-31 DocumentAnalysisClient és DocumentModelAdministrationClient
2.1 FormRecognizerClient és FormTrainingClient
2.0 FormRecognizerClient és FormTrainingClient

Cognitive Services- vagy Form Recognizer-erőforrás létrehozása

A Dokumentumintelligencia a többszolgáltatásos és az egyszolgáltatásos hozzáférést is támogatja. Hozzon létre egy Cognitive Services-erőforrást, ha több Cognitive Services-szolgáltatást szeretne elérni egyetlen végpont/kulcs alatt. Csak dokumentumintelligencia-hozzáféréshez hozzon létre egy Form Recognizer erőforrást. Vegye figyelembe, hogy egy egyszolgáltatásos erőforrásra lesz szüksége, ha Azure Active Directory-hitelesítést kíván használni.

Bármelyik erőforrást létrehozhatja a következő használatával:

Az alábbiakban egy példa látható arra, hogyan hozhat létre Form Recognizer erőforrást a parancssori felület használatával:

# 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

Az erőforrás létrehozásával vagy a hely és a termékváltozat lekérésével kapcsolatos további információkért lásd itt.

Az ügyfél hitelesítése

A Dokumentumintelligencia szolgáltatás használatához létre kell hoznia egy ügyfélpéldányt. Az ügyfélobjektum példányosításához végpontra és hitelesítő adatokra van szükség.

A végpont lekérése

A Form Recognizer-erőforrás végpontját az Azure Portalon vagy az Azure CLI-vel keresheti meg:

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

A hitelesítéshez használhat regionális végpontot vagy egyéni altartományt. Ezek a következőképpen vannak formázva:

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

A regionális végpontok megegyeznek a régióban lévő összes erőforrás esetében. A támogatott regionális végpontok teljes listáját itt tekintheti meg. Vegye figyelembe, hogy a regionális végpontok nem támogatják az AAD-hitelesítést.

Az egyéni altartomány viszont az Form Recognizer erőforrás egyedi neve. Csak egyszolgáltatásos erőforrások használhatják őket.

Az API-kulcs lekérése

Az API-kulcs az Azure Portalon vagy a következő Azure CLI-parancs futtatásával található meg:

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

Az ügyfél létrehozása az AzureKeyCredential használatával

Ha egy API-kulcsot szeretne paraméterként credential használni, adja át a kulcsot sztringként az AzureKeyCredential egy példányába.

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)

Az ügyfél létrehozása Azure Active Directory-hitelesítő adatokkal

AzureKeyCredential A hitelesítést az első lépések útmutatójának példáiban használjuk, de az Azure Active Directoryval is végezhet hitelesítést az azure-identity kódtár használatával. Vegye figyelembe, hogy a regionális végpontok nem támogatják az AAD-hitelesítést. Hozzon létre egy egyéni altartománynevet az erőforráshoz az ilyen típusú hitelesítés használatához.

Az alább látható DefaultAzureCredential típus vagy az Azure SDK-hoz biztosított egyéb hitelesítőadat-típusok használatához telepítse a azure-identity csomagot:

pip install azure-identity

Emellett regisztrálnia kell egy új AAD-alkalmazást, és hozzáférést kell adnia a Dokumentumintelligencia szolgáltatáshoz, ha hozzárendeli a szerepkört a "Cognitive Services User" szolgáltatásnévhez.

Ha végzett, állítsa be az AAD-alkalmazás ügyfél-azonosítójának, bérlőazonosítójának és titkos ügyfélkulcsának értékeit környezeti változóként: 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)

Fő fogalmak

DocumentAnalysisClient

DocumentAnalysisClientműveleteket biztosít a bemeneti dokumentumok elemzéséhez előre összeállított és egyéni modellek használatával a és begin_analyze_document_from_url API-k begin_analyze_document használatával. A paraméter használatával model_id válassza ki az elemzéshez használt modell típusát. A támogatott modellek teljes listáját itt tekintheti meg. A DocumentAnalysisClient emellett műveleteket is biztosít a dokumentumok és begin_classify_document_from_url API-k szerinti begin_classify_document besorolásához. Az egyéni besorolási modellek osztályozhatják a bemeneti fájl egyes lapjait a dokumentum(ok) azonosításához, és több dokumentumot vagy egyetlen dokumentum több példányát is azonosíthatják egy bemeneti fájlban.

Mintakódrészleteket ad meg, amelyek egy DocumentAnalysisClient-példa használatával szemléltetik az itt található . A dokumentumok elemzéséről, beleértve a támogatott funkciókat, a területi beállításokat és a dokumentumtípusokat, a szolgáltatás dokumentációjában talál további információt.

DocumentModelAdministrationClient

DocumentModelAdministrationClient a következő műveletekhez nyújt műveleteket:

  • Egyéni modellek létrehozása a megadott mezők elemzéséhez az egyéni dokumentumok címkézésével. A DocumentModelDetails visszaadott érték jelzi a modell által elemezhető dokumentumtípus(ok)t, valamint az egyes mezők becsült megbízhatóságát. Részletesebb magyarázatért tekintse meg a szolgáltatás dokumentációját .
  • Összeállított modell létrehozása meglévő modellek gyűjteményéből.
  • A fiókban létrehozott modellek kezelése.
  • Az elmúlt 24 órában létrehozott műveletek listázása vagy egy adott modellművelet lekérése.
  • Egyéni modell másolása Form Recognizer erőforrásból egy másikba.
  • Egyéni besorolási modellt hozhat létre és kezelhet az alkalmazásban feldolgozott dokumentumok besorolásához.

Vegye figyelembe, hogy a modellek olyan grafikus felhasználói felülettel is létrehozhatók, mint a Document Intelligence Studio.

Mintakódrészleteket biztosítunk, amelyek egy DocumentModelAdministrationClient mutatnak be itt.

Hosszú ideig futó műveletek

A hosszú ideig futó műveletek olyan műveletek, amelyek a szolgáltatásnak küldött kezdeti kérésből állnak a művelet elindításához, majd a szolgáltatás időközönkénti lekérdezése annak megállapításához, hogy a művelet befejeződött-e vagy meghiúsult-e, és ha sikerült, lekérni az eredményt.

A dokumentumok elemzési, buildelési vagy másolási/írási modelleket elemző módszerek hosszú ideig futó műveletekként vannak modellezve. Az ügyfél egy metódust begin_<method-name> tesz elérhetővé, amely egy vagy AsyncLROPoller.LROPoller A hívóknak meg kell várniuk, amíg a művelet befejeződik a metódusból begin_<method-name> visszaadott poller objektum meghívásávalresult(). Az alábbi példákat talál a hosszú ideig futó műveletek szemléltetésére.

Példák

A következő szakasz számos kódrészletet tartalmaz, amelyek a leggyakoribb dokumentumintelligencia-feladatokat tartalmazzák, többek között a következőket:

Elrendezés kibontva

Szöveg, kijelölésjelek, szövegstílusok és táblázatstruktúrák kinyerése a dokumentumokból a határolórégió koordinátáival együtt.

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

Az általános dokumentummodell használata

A dokumentumintelligencia szolgáltatás által biztosított általános dokumentummodell használatával elemezheti a kulcs-érték párokat, táblákat, stílusokat és kijelölési jeleket a dokumentumokból. Válassza ki az Általános dokumentummodellt a begin_analyze_document metódusba való model_id="prebuilt-document" továbbítással:

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("----------------------------------------")
  • A modell által prebuilt-document biztosított funkciókról itt olvashat bővebben.

Előre összeállított modellek használata

A Dokumentumintelligencia szolgáltatás előre összeállított modelljeinek használatával mezőket nyerhet ki a kiválasztott dokumentumtípusokból, például nyugtákból, számlákból, névjegykártyákból, identitásdokumentumokból és amerikai W-2 adódokumentumokból.

Ha például egy értékesítési visszaigazolás mezőit szeretné elemezni, használja az előre összeállított nyugtamodellt, amelyet a begin_analyze_document metódusba való model_id="prebuilt-receipt" továbbítással biztosít:

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

Nem csak a nyugtákra korlátozódik! Néhány előre összeállított modell közül választhat, amelyek mindegyike saját támogatott mezőkészlettel rendelkezik. További támogatott előre összeállított modelleket itt talál.

Egyéni modell létrehozása

Hozzon létre egy egyéni modellt a saját dokumentumtípusára. Az eredményként kapott modell a betanított dokumentumtípusok értékeinek elemzésére használható. Adjon meg egy tároló SAS URL-címét az Azure Storage Blob-tárolóhoz, ahol a betanítási dokumentumokat tárolja.

A tárolók és a szükséges fájlstruktúra beállításával kapcsolatos további részletek a szolgáltatás dokumentációjában találhatók.

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

Dokumentumok elemzése egyéni modellel

Dokumentummezők, táblázatok, kijelölési jelek és egyebek elemzése. Ezek a modellek saját adatokkal vannak betanva, így a dokumentumokra vannak szabva. A legjobb eredmény érdekében csak olyan dokumentumtípusú dokumentumokat kell elemeznie, amelyekkel az egyéni modell készült.

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

Másik lehetőségként a dokumentum URL-címével is elemezheti a dokumentumokat a begin_analyze_document_from_url metódus használatával.

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

A modellek kezelése

Kezelheti a fiókhoz csatolt egyéni modelleket.

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

Bővítmények képességei

A Dokumentumintelligencia kifinomultabb elemzési képességeket támogat. Ezek az opcionális funkciók a dokumentum kinyerésének forgatókönyvétől függően engedélyezhetők és letilthatók.

A 2023-07-31-es (GA) és újabb kiadásokhoz a következő bővítmények érhetők el:

Vegye figyelembe, hogy egyes bővítményfunkciók további díjakat vonnak maga után. Lásd: díjszabás: https://azure.microsoft.com/pricing/details/ai-document-intelligence/.

Hibaelhárítás

Általános kérdések

Form Recognizer ügyfélkódtár kivételeket hoz létre az Azure Core-ban. A Dokumentumintelligencia szolgáltatás által létrehozott hibakódok és üzenetek a szolgáltatás dokumentációjában találhatók.

Naplózás

Ez a kódtár a szabványos naplózási kódtárat használja a naplózáshoz.

A HTTP-munkamenetekkel (URL-címekkel, fejlécekkel stb.) kapcsolatos alapvető információk naplózása a INFO szinten történik.

A részletes DEBUG szintű naplózás, beleértve a kérés-/választörzseket és a nem végrehajtott fejléceket, engedélyezhető az ügyfélen vagy műveletenként a logging_enable kulcsszóargumentummal.

A teljes SDK-naplózási dokumentációt itt találja példákkal.

Választható konfiguráció

A választható kulcsszóargumentumok az ügyfél és a művelet szintjén is átadhatók. Az azure-core referenciadokumentáció az újrapróbálkozásokhoz, naplózáshoz, átviteli protokollokhoz és egyebekhez elérhető konfigurációkat ismerteti.

Következő lépések

További mintakód

A Form Recognizer Python API-ban használt gyakori mintákat szemléltető kódrészletekért tekintse meg a README-mintafájlt.

További dokumentáció

Az Azure AI-dokumentumintelligencia részletesebb dokumentációját a dokumentumintelligencia dokumentációjában találja docs.microsoft.com.

Közreműködés

A projektben szívesen fogadjuk a hozzájárulásokat és a javaslatokat. A legtöbb hozzájáruláshoz el kell fogadnia egy Közreműködői licencszerződést (CLA-t), amelyben kijelenti, hogy jogosult arra, hogy ránk ruházza hozzájárulása felhasználási jogát, és ezt ténylegesen meg is teszi. A részletekért látogasson el a cla.microsoft.com.

A lekéréses kérelmek elküldésekor egy CLA-robot automatikusan meghatározza, hogy kell-e biztosítania CLA-t, és megfelelően kitölti a lekéréses kérelmet (például címke, megjegyzés). Egyszerűen csak kövesse a robot által megadott utasításokat. Ezt csak egyszer kell elvégeznie az összes olyan tárházban, amely a CLA-t használja.

A projekt a Microsoft nyílt forráskódú projekteket szabályozó etikai kódexe, a Microsoft Open Source Code of Conduct hatálya alá esik. További információkért lásd a viselkedési szabályzattal kapcsolatos gyakori kérdéseket , vagy vegye fel a kapcsolatot opencode@microsoft.com az esetleges további kérdésekkel vagy megjegyzésekkel.