Freigeben über

Azure Document Intelligence-Clientbibliothek für Java – Version 4.1.2

  • Artikel

Azure Document Intelligence (früher bekannt als Formularerkennung) 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 Sie Text, Tabellenstrukturen und Auswahlmarkierungen zusammen mit ihren Begrenzungsbereichskoordinaten aus Dokumenten.
  • Dokument: Analysieren von Entitäten, Schlüssel-Wert-Paaren, Tabellen und Auswahlzeichen aus Dokumenten mithilfe des allgemeinen vordefinierten Dokumentmodells.
  • Vordefiniertes Analysieren von Daten aus bestimmten Arten gängiger Dokumente (z. B. Belege, Rechnungen, Visitenkarten, Identitätsdokumente oder US W2-Steuerformulare) mithilfe vordefinierter Modelle.
  • Benutzerdefiniert: Erstellen Sie benutzerdefinierte Modelle, um Text, Feldwerte, Auswahlmarkierungen und Tabellendaten aus Dokumenten zu extrahieren. Benutzerdefinierte Modelle werden mit Ihren eigenen Daten erstellt, sodass sie auf Ihre Dokumente zugeschnitten sind.
  • Lesen: Lesen Sie zusätzlich zu Textsprachinformationen Informationen zu Textelementen, z. B. Seitenwörter und Zeilen.
  • Klassifizierer: Erstellen Sie benutzerdefinierte Klassifizierer, um Dokumente in vordefinierte Klassen zu kategorisieren.

Quellcode | Paket (Maven) | API-Referenzdokumentation | Produktdokumentation | Proben

Erste Schritte

Voraussetzungen

Schließen Sie das Paket ein

BOM-Datei einfügen

Fügen Sie das azure-sdk-bom in Ihr Projekt ein, um die Abhängigkeit von der GA-Version der Bibliothek zu übernehmen. Ersetzen Sie im folgenden Codeausschnitt den Platzhalter {bom_version_to_target} durch die Versionsnummer. Weitere Informationen zur Stückliste finden Sie in der AZURE SDK-BOM-INFODATEI.

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>com.azure</groupId>
            <artifactId>azure-sdk-bom</artifactId>
            <version>{bom_version_to_target}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

Fügen Sie dann die direkte Abhängigkeit ohne versionstag in den Abschnitt abhängigkeiten ein.

<dependencies>
  <dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-ai-formrecognizer</artifactId>
  </dependency>
</dependencies>

Direkte Abhängigkeiten einfügen

Wenn Sie abhängigkeiten von einer bestimmten Version der Bibliothek übernehmen möchten, die in der Stückliste nicht vorhanden ist, fügen Sie die direkte Abhängigkeit wie folgt zu Ihrem Projekt hinzu.

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-ai-formrecognizer</artifactId>
    <version>4.1.2</version>
</dependency>

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.0.x 2.0
3.1.X – 3.1.12 2.0, 2.1 (Standard)
4.0.0 2.0, 2.1, 31.08.2022 (Standard)
4.1.0 2.0, 2.1, 2022-08-31, 2023-07-31 (Standard)

Hinweis: Ab Version 4.0.X wurden neue Clients eingeführt, um die neuesten Features des Formularerkennung-Diensts zu nutzen. Im Migrationshandbuch finden Sie ausführliche Anweisungen zum Aktualisieren von Anwendungscode von Clientbibliotheksversion 3.1.X oder niedriger auf die neueste Version. Weitere Informationen finden Sie unter 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 Formularerkennungsressource

Formularerkennung unterstützt sowohl den Zugriff mit mehreren diensten als auch den Einzeldienst. Erstellen Sie eine Cognitive Service-Ressource, wenn Sie planen, auf mehrere Cognitive Services unter einem einzelnen Endpunkt/Schlüssel zuzugreifen. Erstellen Sie eine Formularerkennungsressource, falls nur auf die Formularerkennung zugegriffen werden soll.

Sie können eine Der folgenden Ressourcen erstellen:

Option 1:Azure-Portal

Option 2:Azure CLI

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-group> --location <location>

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

Authentifizieren des Clients

Um mit dem Formularerkennung-Dienst zu interagieren, müssen Sie eine instance des Dokumentanalyseclients erstellen. Sowohl die asynchronen als auch die synchronen Clients können mithilfe DocumentAnalysisClientBuildervon erstellt werden. Beim Aufrufen buildClient() wird der synchrone Client erstellt, während beim Aufrufen buildAsyncClient dessen asynchrones Pendant erstellt wird.

Sie benötigen einen Endpunkt und einen Schlüssel , um ein Clientobjekt zu instanziieren.

Nachschlagen des Endpunkts

Sie finden den Endpunkt für Ihre Formularerkennung-Ressource im Azure-Portal oder in der Azure CLI.

# Get the endpoint for the resource
az cognitiveservices account show --name "resource-name" --resource-group "resource-group-name" --query "endpoint"

Erstellen eines Dokumentanalyseclients mit AzureKeyCredential

Um die Authentifizierung zu verwenden AzureKeyCredential , geben Sie den Schlüssel als Zeichenfolge für AzureKeyCredential an. Diesen Schlüssel finden Sie in der Azure-Portal in Ihrer erstellten Formularerkennung-Ressource oder indem Sie den folgenden Azure CLI-Befehl ausführen, um den Schlüssel aus der Formularerkennung-Ressource abzurufen:

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

Verwenden Sie den API-Schlüssel als Anmeldeinformationsparameter, um den Client zu authentifizieren:

DocumentAnalysisClient documentAnalysisClient = new DocumentAnalysisClientBuilder()
    .credential(new AzureKeyCredential("{key}"))
    .endpoint("{endpoint}")
    .buildClient();

DocumentModelAdministrationClient client =
    new DocumentModelAdministrationClientBuilder()
        .credential(new AzureKeyCredential("{key}"))
        .endpoint("{endpoint}")
        .buildClient();

Erstellen eines Dokumentanalyseclients mit Azure Active Directory-Anmeldeinformationen

Das Azure SDK für Java unterstützt ein Azure Identity-Paket, das das Abrufen von Anmeldeinformationen von Microsoft Identity Platform vereinfacht.

Die Authentifizierung mit AAD erfordert eine anfängliche Einrichtung:

  • Hinzufügen des Azure Identity-Pakets
<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity</artifactId>
    <version>1.10.0</version>
</dependency>

Nach dem Setup können Sie auswählen, welche Art von Anmeldeinformationen aus azure-identity verwendet werden sollen. Als Beispiel kann DefaultAzureCredential verwendet werden, um den Client zu authentifizieren: Legen Sie 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.

Die Autorisierung ist am einfachsten mit DefaultAzureCredential. Es findet die besten Anmeldeinformationen, die in seiner ausgeführten Umgebung verwendet werden können. Weitere Informationen zur Verwendung der Azure Active Directory-Autorisierung mit Formularerkennung finden Sie in der zugehörigen Dokumentation.

DocumentAnalysisClient documentAnalysisClient = new DocumentAnalysisClientBuilder()
    .endpoint("{endpoint}")
    .credential(new DefaultAzureCredentialBuilder().build())
    .buildClient();

Wichtige Begriffe

DocumentAnalysisClient

DocumentAnalysisClient und DocumentAnalysisAsyncClient bieten synchrone und asynchrone Vorgänge zum Analysieren von Eingabedokumenten mithilfe benutzerdefinierter und vordefinierter Modelle über die beginAnalyzeDocument Methoden undbeginAnalyzeDocumentFromUrl. Eine vollständige Liste der unterstützten Modelle finden Sie hier.

Beispielcodeausschnitte, um die Verwendung eines DocumentAnalysisClients zu veranschaulichen. Weitere Informationen zur Analyse von Dokumenten, einschließlich unterstützter Features, Gebietsschemas und Dokumenttypen, finden Sie hier.

DocumentModelAdministrationClient

DocumentModelAdministrationClient und DocumentModelAdministrationAsyncClient bieten sowohl synchrone als auch asynchrone Vorgänge.

  • Erstellen Sie benutzerdefinierte Dokumentanalysemodelle, um Textinhalte, Felder und Werte in Ihren benutzerdefinierten Dokumenten zu analysieren. Siehe Beispiel Erstellen eines Dokumentmodells. Ein DocumentModelDetails wird zurückgegeben, der die Dokumenttypen angibt, die das Modell analysieren kann, zusammen mit den Feldern und Schemas, die es extrahieren wird.
  • Verwalten von Modellen, die in Ihrem Konto erstellt wurden, indem Sie ihr Konto erstellen, auflisten, löschen und die Grenzwerte für benutzerdefinierte Modelle Ihres Kontos anzeigen. Weitere Informationen finden Sie unter Beispiel verwalten von Modellen.
  • Kopieren eines benutzerdefinierten Modells aus einer Formularerkennungsressource in eine andere
  • Erstellen eines zusammengesetzten Modells aus einer Sammlung vorhandener erstellter Modelle.
  • Auflisten von Dokumentmodellvorgängen, die der Formularerkennung Ressource zugeordnet sind.

Beispielcodeausschnitte werden bereitgestellt, um die Verwendung eines DocumentModelAdministrationClient-Beispiels 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 Modelle erstellen, Werte aus Dokumenten analysieren oder Modelle kopieren und verfassen, werden als Vorgänge mit langer Ausführungsdauer modelliert. Der Client macht eine begin<MethodName> Methode verfügbar, die eine oder PollerFlux instance SyncPoller zurückgibt. Aufrufer sollten warten, bis der Vorgang abgeschlossen ist, indem sie für den zurückgegebenen Vorgang von der begin<MethodName> -Methode aufrufengetFinalResult(). Beispielcodeausschnitte werden bereitgestellt, um die Verwendung von Vorgängen mit langer Ausführungszeit unten zu veranschaulichen.

Beispiele

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

Extrahieren des Layouts

Extrahieren Sie Text, Tabellenstrukturen und Auswahlzeichen wie Optionsfelder und Kontrollkästchen sowie deren Begrenzungsrahmenkoordinaten aus Dokumenten, ohne dass ein Modell erstellt werden muss.

// analyze document layout using file input stream
File layoutDocument = new File("local/file_path/filename.png");
Path filePath = layoutDocument.toPath();
BinaryData layoutDocumentData = BinaryData.fromFile(filePath, (int) layoutDocument.length());

SyncPoller<OperationResult, AnalyzeResult> analyzeLayoutResultPoller =
    documentAnalysisClient.beginAnalyzeDocument("prebuilt-layout", layoutDocumentData);

AnalyzeResult analyzeLayoutResult = analyzeLayoutResultPoller.getFinalResult();

// pages
analyzeLayoutResult.getPages().forEach(documentPage -> {
    System.out.printf("Page has width: %.2f and height: %.2f, measured with unit: %s%n",
        documentPage.getWidth(),
        documentPage.getHeight(),
        documentPage.getUnit());

    // lines
    documentPage.getLines().forEach(documentLine ->
        System.out.printf("Line '%s' is within a bounding box %s.%n",
            documentLine.getContent(),
            documentLine.getBoundingPolygon().toString()));

    // selection marks
    documentPage.getSelectionMarks().forEach(documentSelectionMark ->
        System.out.printf("Selection mark is '%s' and is within a bounding box %s with confidence %.2f.%n",
            documentSelectionMark.getSelectionMarkState().toString(),
            documentSelectionMark.getBoundingPolygon().toString(),
            documentSelectionMark.getConfidence()));
});

// tables
List<DocumentTable> tables = analyzeLayoutResult.getTables();
for (int i = 0; i < tables.size(); i++) {
    DocumentTable documentTable = tables.get(i);
    System.out.printf("Table %d has %d rows and %d columns.%n", i, documentTable.getRowCount(),
        documentTable.getColumnCount());
    documentTable.getCells().forEach(documentTableCell -> {
        System.out.printf("Cell '%s', has row index %d and column index %d.%n", documentTableCell.getContent(),
            documentTableCell.getRowIndex(), documentTableCell.getColumnIndex());
    });
    System.out.println();
}

Verwenden eines allgemeinen Dokumentmodells

Analysieren Sie Schlüssel-Wert-Paare, Tabellen, Stile und Auswahlmarkierungen aus Dokumenten mithilfe des allgemeinen Dokumentmodells, das vom Formularerkennung-Dienst bereitgestellt wird. Wählen Sie das Allgemeine Dokumentmodell aus, indem Sie modelId="prebuilt-document" wie folgt an die beginAnalyzeDocumentFromUrl-Methode übergeben:

String documentUrl = "{document-url}";
String modelId = "prebuilt-document";
SyncPoller<OperationResult, AnalyzeResult> analyzeDocumentPoller =
    documentAnalysisClient.beginAnalyzeDocumentFromUrl(modelId, documentUrl);

AnalyzeResult analyzeResult = analyzeDocumentPoller.getFinalResult();

for (int i = 0; i < analyzeResult.getDocuments().size(); i++) {
    final AnalyzedDocument analyzedDocument = analyzeResult.getDocuments().get(i);
    System.out.printf("----------- Analyzing document %d -----------%n", i);
    System.out.printf("Analyzed document has doc type %s with confidence : %.2f%n",
        analyzedDocument.getDocType(), analyzedDocument.getConfidence());
}

analyzeResult.getPages().forEach(documentPage -> {
    System.out.printf("Page has width: %.2f and height: %.2f, measured with unit: %s%n",
        documentPage.getWidth(),
        documentPage.getHeight(),
        documentPage.getUnit());

    // lines
    documentPage.getLines().forEach(documentLine ->
        System.out.printf("Line '%s' is within a bounding box %s.%n",
            documentLine.getContent(),
            documentLine.getBoundingPolygon().toString()));

    // words
    documentPage.getWords().forEach(documentWord ->
        System.out.printf("Word '%s' has a confidence score of %.2f.%n",
            documentWord.getContent(),
            documentWord.getConfidence()));
});

// tables
List<DocumentTable> tables = analyzeResult.getTables();
for (int i = 0; i < tables.size(); i++) {
    DocumentTable documentTable = tables.get(i);
    System.out.printf("Table %d has %d rows and %d columns.%n", i, documentTable.getRowCount(),
        documentTable.getColumnCount());
    documentTable.getCells().forEach(documentTableCell -> {
        System.out.printf("Cell '%s', has row index %d and column index %d.%n",
            documentTableCell.getContent(),
            documentTableCell.getRowIndex(), documentTableCell.getColumnIndex());
    });
    System.out.println();
}

// Key-value
analyzeResult.getKeyValuePairs().forEach(documentKeyValuePair -> {
    System.out.printf("Key content: %s%n", documentKeyValuePair.getKey().getContent());
    System.out.printf("Key content bounding region: %s%n",
        documentKeyValuePair.getKey().getBoundingRegions().toString());

    System.out.printf("Value content: %s%n", documentKeyValuePair.getValue().getContent());
    System.out.printf("Value content bounding region: %s%n", documentKeyValuePair.getValue().getBoundingRegions().toString());
});

Verwenden vordefinierter Modelle

Extrahieren Sie Felder aus ausgewählten Dokumenttypen wie Quittungen, Rechnungen, Visitenkarten und Identitätsdokumenten mithilfe vordefinierter Modelle, die vom Formularerkennung-Dienst bereitgestellt werden. Unterstützte vordefinierte Modelle sind:

  • Analysieren von Belegen mithilfe des prebuilt-receipt Modells (vom Dienst erkannte Felder finden Sie hier).
  • Analysieren Von Visitenkarten mit dem prebuilt-businessCard Modell (vom Dienst erkannte Felder finden Sie hier).
  • Analysieren Sie Rechnungen mit dem prebuilt-invoice Modell (die vom Dienst erkannten Felder finden Sie hier).
  • Analysieren Sie Identitätsdokumente mithilfe des prebuilt-idDocuments Modells (vom Dienst erkannte Felder finden Sie hier).
  • Analysieren Sie US W2-Steuerformulare mithilfe des prebuilt-tax.us.w2 Modells. Unterstützte Felder.

So analysieren Sie beispielsweise Felder aus einem Verkaufsbeleg in die beginAnalyzeDocumentFromUrl -Methode:

String receiptUrl = "https://raw.githubusercontent.com/Azure/azure-sdk-for-java/main/sdk/formrecognizer"
    + "/azure-ai-formrecognizer/src/samples/resources/sample-documents/receipts/contoso-allinone.jpg";

SyncPoller<OperationResult, AnalyzeResult> analyzeReceiptPoller =
    documentAnalysisClient.beginAnalyzeDocumentFromUrl("prebuilt-receipt", receiptUrl);

AnalyzeResult receiptResults = analyzeReceiptPoller.getFinalResult();

for (int i = 0; i < receiptResults.getDocuments().size(); i++) {
    AnalyzedDocument analyzedReceipt = receiptResults.getDocuments().get(i);
    Map<String, DocumentField> receiptFields = analyzedReceipt.getFields();
    System.out.printf("----------- Analyzing receipt info %d -----------%n", i);
    DocumentField merchantNameField = receiptFields.get("MerchantName");
    if (merchantNameField != null) {
        if (DocumentFieldType.STRING == merchantNameField.getType()) {
            String merchantName = merchantNameField.getValueAsString();
            System.out.printf("Merchant Name: %s, confidence: %.2f%n",
                merchantName, merchantNameField.getConfidence());
        }
    }

    DocumentField merchantPhoneNumberField = receiptFields.get("MerchantPhoneNumber");
    if (merchantPhoneNumberField != null) {
        if (DocumentFieldType.PHONE_NUMBER == merchantPhoneNumberField.getType()) {
            String merchantAddress = merchantPhoneNumberField.getValueAsPhoneNumber();
            System.out.printf("Merchant Phone number: %s, confidence: %.2f%n",
                merchantAddress, merchantPhoneNumberField.getConfidence());
        }
    }

    DocumentField transactionDateField = receiptFields.get("TransactionDate");
    if (transactionDateField != null) {
        if (DocumentFieldType.DATE == transactionDateField.getType()) {
            LocalDate transactionDate = transactionDateField.getValueAsDate();
            System.out.printf("Transaction Date: %s, confidence: %.2f%n",
                transactionDate, transactionDateField.getConfidence());
        }
    }

    DocumentField receiptItemsField = receiptFields.get("Items");
    if (receiptItemsField != null) {
        System.out.printf("Receipt Items: %n");
        if (DocumentFieldType.LIST == receiptItemsField.getType()) {
            List<DocumentField> receiptItems = receiptItemsField.getValueAsList();
            receiptItems.stream()
                .filter(receiptItem -> DocumentFieldType.MAP == receiptItem.getType())
                .map(documentField -> documentField.getValueAsMap())
                .forEach(documentFieldMap -> documentFieldMap.forEach((key, documentField) -> {
                    if ("Name".equals(key)) {
                        if (DocumentFieldType.STRING == documentField.getType()) {
                            String name = documentField.getValueAsString();
                            System.out.printf("Name: %s, confidence: %.2fs%n",
                                name, documentField.getConfidence());
                        }
                    }
                    if ("Quantity".equals(key)) {
                        if (DocumentFieldType.DOUBLE == documentField.getType()) {
                            Double quantity = documentField.getValueAsDouble();
                            System.out.printf("Quantity: %f, confidence: %.2f%n",
                                quantity, documentField.getConfidence());
                        }
                    }
                }));
        }
    }
}

Weitere Informationen und Beispiele für die Verwendung vordefinierter Modelle finden Sie unter:

Erstellen eines Dokumentmodells

Erstellen Sie ein durch maschinelles Lernen erlerntes Modell für Ihren eigenen Dokumenttyp. Das resultierende Modell kann Werte aus den Dokumenttypen analysieren, auf der es erstellt wurde. Geben Sie eine CONTAINER-SAS-URL für Ihren Azure Storage-Blobcontainer an, in dem Sie die Trainingsdokumente speichern. Ausführliche Informationen zum Einrichten finden Sie in der Schnellstartdokumentation des Diensts.

Hinweis

Sie können die Formularerkennung Studio-Vorschau verwenden, um eine beschriftete Datei für Ihre Trainingsformulare zu erstellen. Weitere Informationen zum Einrichten eines Containers und zur erforderlichen Dateistruktur finden Sie hier.

// Build custom document analysis model
String blobContainerUrl = "{SAS_URL_of_your_container_in_blob_storage}";
// The shared access signature (SAS) Url of your Azure Blob Storage container with your forms.
String prefix = "{blob_name_prefix}}";
SyncPoller<OperationResult, DocumentModelDetails> buildOperationPoller =
    documentModelAdminClient.beginBuildDocumentModel(blobContainerUrl,
        DocumentModelBuildMode.TEMPLATE,
        prefix,
        new BuildDocumentModelOptions().setModelId("my-build-model").setDescription("model desc"),
        Context.NONE);

DocumentModelDetails documentModelDetails = buildOperationPoller.getFinalResult();

// Model Info
System.out.printf("Model ID: %s%n", documentModelDetails.getModelId());
System.out.printf("Model Description: %s%n", documentModelDetails.getDescription());
System.out.printf("Model created on: %s%n%n", documentModelDetails.getCreatedOn());
documentModelDetails.getDocumentTypes().forEach((key, documentTypeDetails) -> {
    System.out.printf("Document type: %s%n", key);
    documentTypeDetails.getFieldSchema().forEach((name, documentFieldSchema) -> {
        System.out.printf("Document field: %s%n", name);
        System.out.printf("Document field type: %s%n", documentFieldSchema.getType().toString());
        System.out.printf("Document field confidence: %.2f%n", documentTypeDetails.getFieldConfidence().get(name));
    });
});

Analysieren von Dokumenten mithilfe eines benutzerdefinierten Modells

Analysieren Sie die Schlüssel-Wert-Paare und Tabellendaten aus Dokumenten. Diese Modelle werden mit Ihren eigenen Daten erstellt, sodass sie auf Ihre Dokumente zugeschnitten sind. Sie sollten nur Dokumente mit demselben Dokumenttyp analysieren, auf dem das benutzerdefinierte Modell erstellt wurde.

String documentUrl = "{document-url}";
String modelId = "{custom-built-model-ID}";
SyncPoller<OperationResult, AnalyzeResult> analyzeDocumentPoller =
    documentAnalysisClient.beginAnalyzeDocumentFromUrl(modelId, documentUrl);

AnalyzeResult analyzeResult = analyzeDocumentPoller.getFinalResult();

for (int i = 0; i < analyzeResult.getDocuments().size(); i++) {
    final AnalyzedDocument analyzedDocument = analyzeResult.getDocuments().get(i);
    System.out.printf("----------- Analyzing custom document %d -----------%n", i);
    System.out.printf("Analyzed document has doc type %s with confidence : %.2f%n",
        analyzedDocument.getDocType(), analyzedDocument.getConfidence());
    analyzedDocument.getFields().forEach((key, documentField) -> {
        System.out.printf("Document Field content: %s%n", documentField.getContent());
        System.out.printf("Document Field confidence: %.2f%n", documentField.getConfidence());
        System.out.printf("Document Field Type: %s%n", documentField.getType());
        System.out.printf("Document Field found within bounding region: %s%n",
            documentField.getBoundingRegions().toString());
    });
}

analyzeResult.getPages().forEach(documentPage -> {
    System.out.printf("Page has width: %.2f and height: %.2f, measured with unit: %s%n",
        documentPage.getWidth(),
        documentPage.getHeight(),
        documentPage.getUnit());

    // lines
    documentPage.getLines().forEach(documentLine ->
        System.out.printf("Line '%s' is within a bounding box %s.%n",
            documentLine.getContent(),
            documentLine.getBoundingPolygon().toString()));

    // words
    documentPage.getWords().forEach(documentWord ->
        System.out.printf("Word '%s' has a confidence score of %.2f.%n",
            documentWord.getContent(),
            documentWord.getConfidence()));
});

// tables
List<DocumentTable> tables = analyzeResult.getTables();
for (int i = 0; i < tables.size(); i++) {
    DocumentTable documentTable = tables.get(i);
    System.out.printf("Table %d has %d rows and %d columns.%n", i, documentTable.getRowCount(),
        documentTable.getColumnCount());
    documentTable.getCells().forEach(documentTableCell -> {
        System.out.printf("Cell '%s', has row index %d and column index %d.%n",
            documentTableCell.getContent(),
            documentTableCell.getRowIndex(), documentTableCell.getColumnIndex());
    });
    System.out.println();
}

Verwalten Ihrer Modelle

Verwalten Sie die Modelle in Ihrem Formularerkennung-Konto.

AtomicReference<String> modelId = new AtomicReference<>();

// First, we see how many models we have, and what our limit is
ResourceDetails resourceDetails = documentModelAdminClient.getResourceDetails();
System.out.printf("The resource has %s models, and we can have at most %s models",
    resourceDetails.getCustomDocumentModelCount(), resourceDetails.getCustomDocumentModelLimit());

// Next, we get a paged list of all of our models
PagedIterable<DocumentModelSummary> customDocumentModels = documentModelAdminClient.listDocumentModels();
System.out.println("We have following models in the account:");
customDocumentModels.forEach(documentModelSummary -> {
    System.out.printf("Model ID: %s%n", documentModelSummary.getModelId());
    modelId.set(documentModelSummary.getModelId());

    // get custom document analysis model info
    DocumentModelDetails documentModel = documentModelAdminClient.getDocumentModel(documentModelSummary.getModelId());
    System.out.printf("Model ID: %s%n", documentModel.getModelId());
    System.out.printf("Model Description: %s%n", documentModel.getDescription());
    System.out.printf("Model created on: %s%n", documentModel.getCreatedOn());
    documentModel.getDocumentTypes().forEach((key, documentTypeDetails) -> {
        documentTypeDetails.getFieldSchema().forEach((field, documentFieldSchema) -> {
            System.out.printf("Field: %s", field);
            System.out.printf("Field type: %s", documentFieldSchema.getType());
            System.out.printf("Field confidence: %.2f", documentTypeDetails.getFieldConfidence().get(field));
        });
    });
});

// Delete Model
documentModelAdminClient.deleteDocumentModel(modelId.get());

Klassifizieren eines Dokuments

Der Formularerkennung-Dienst unterstützt benutzerdefinierte Dokumentklassifizierer, die Dokumente basierend auf einem Trainingsdataset in einen Satz vordefinierter Kategorien klassifizieren können. Dokumente können mit einem benutzerdefinierten Klassifizierer mithilfe der beginClassifyDocument - oder beginClassifyDocumentFromUrl -Methode von DocumentAnalysisClientklassifiziert werden. Im folgenden Beispiel wird gezeigt, wie Sie ein Dokument mithilfe eines benutzerdefinierten Klassifizierers klassifizieren:

String documentUrl = "{file_source_url}";
String classifierId = "{custom_trained_classifier_id}";

documentAnalysisClient.beginClassifyDocumentFromUrl(classifierId, documentUrl, Context.NONE)
    .getFinalResult()
    .getDocuments()
    .forEach(analyzedDocument -> System.out.printf("Doc Type: %s%n", analyzedDocument.getDocType()));

Ausführlichere Beispiele finden Sie in den Beispielen.

Problembehandlung

Allgemein

Formularerkennung Clients lösen Ausnahmen ausHttpResponseException. Wenn Sie z. B. versuchen, eine ungültige Dateiquellen-URL anzugeben, wird eine HttpResponseException mit einem Hinweis auf die Fehlerursache ausgelöst. Im folgenden Codeausschnitt wird der Fehler ordnungsgemäß behandelt, indem die Ausnahme abgefangen wird und zusätzliche Fehlerinformationen angezeigt werden.

try {
    documentAnalysisClient.beginAnalyzeDocumentFromUrl("prebuilt-receipt", "invalidSourceUrl");
} catch (HttpResponseException e) {
    System.out.println(e.getMessage());
    // Do something with the exception
}

Aktivieren der Clientprotokollierung

Azure SDKs für Java bieten einen konsistenten Protokollierungsverlauf, um die Problembehandlung von Anwendungsfehlern zu unterstützen und deren Lösung zu beschleunigen. Die erstellten Protokolle erfassen den Flow einer Anwendung, bevor sie den Endzustand erreichen. Dies trägt zur Ermittlung der Grundursache bei. Informationen zum Aktivieren der Protokollierung finden Sie im Protokollierungswiki.

HTTP-Standardclient

Alle Clientbibliotheken verwenden standardmäßig den Netty-HTTP-Client. Fügen Sie die oben genannte Abhängigkeit hinzu, um die Clientbibliothek automatisch für die Verwendung des Netty-HTTP-Clients zu konfigurieren. Das Konfigurieren oder Ändern des HTTP-Clients wird detailliert im Wiki zu HTTP-Clients beschrieben.

Nächste Schritte

Der folgende Abschnitt enthält mehrere Codeausschnitte, die gängige Muster veranschaulichen, die in der Formularerkennung-API verwendet werden. Diese Codebeispiele zeigen allgemeine Szenariovorgänge mit der Azure Formularerkennung-Clientbibliothek.

Asynchrone APIs

Alle bisher gezeigten Beispiele haben synchrone APIs verwendet, aber wir bieten auch vollständige Unterstützung für asynchrone APIs. Sie müssen DocumentAnalysisAsyncClient

DocumentAnalysisAsyncClient documentAnalysisAsyncClient = new DocumentAnalysisClientBuilder()
    .credential(new AzureKeyCredential("{key}"))
    .endpoint("{endpoint}")
    .buildAsyncClient();

Zusätzliche Dokumentation

In der Beispiellesedatei finden Sie mehrere Codeausschnitte, die gängige Muster veranschaulichen, die im Formularerkennung Java SDK verwendet werden. Eine ausführlichere Dokumentation zu Azure Cognitive Services-Formularerkennung finden Sie in der Formularerkennung-Dokumentation.

Mitwirken

Beiträge und Vorschläge für dieses Projekt sind willkommen. Für die meisten Beiträge ist die Zustimmung zu einer Lizenzvereinbarung für Mitwirkende (Contributor License Agreement, CLA) erforderlich, in der Sie erklären, dass Sie dazu berechtigt sind, uns die Rechte für die Nutzung Ihres Beitrags zu erteilen, und dies auch tun.

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 Kommentare haben.

Aufrufe